Changes to mutation node and canonicalization implementations.

Author: bterlson

.vscode/settings.json

@@ -56,6 +56,6 @@
   },
   "typescript.tsdk": "./node_modules/typescript/lib",
   "git.ignoreLimitWarning": true,
-  "vitest.workspaceConfig": "./vitest.config.ts",
-  "typespec.tsp-server.path": "${workspaceFolder}/packages/compiler"
+  "typespec.tsp-server.path": "${workspaceFolder}/packages/compiler",
+  "vitest.rootConfig": "vitest.config.js"
 }

packages/http-canonicalization/src/codecs.ts

@@ -1,7 +1,6 @@
 import { getEncode, type MemberType, type Program, type Type } from "@typespec/compiler";
 import type { Typekit } from "@typespec/compiler/typekit";
 import { isHeader } from "@typespec/http";
-import type { HttpCanonicalization } from "./http-canonicalization-classes.js";
 
 export interface CodecEncodeResult {
   codec: Codec;
@@ -19,9 +18,9 @@ export class CodecRegistry {
     this.#codecs.push(codec);
   }
 
-  detect(type: HttpCanonicalization): Codec {
+  detect(sourceType: Type, referenceTypes: MemberType[]): Codec {
     for (const codec of this.#codecs) {
-      const codecInstance = codec.detect(this.$, type);
+      const codecInstance = codec.detect(this.$, sourceType, referenceTypes);
       if (codecInstance) {
         return codecInstance;
       }
@@ -33,15 +32,17 @@ export class CodecRegistry {
 
 export abstract class Codec {
   abstract id: string;
-  canonicalization: HttpCanonicalization;
   $: Typekit;
+  sourceType: Type;
+  referenceTypes: MemberType[];
 
-  constructor($: Typekit, canonicalization: HttpCanonicalization) {
-    this.canonicalization = canonicalization;
+  constructor($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
     this.$ = $;
+    this.sourceType = sourceType;
+    this.referenceTypes = referenceTypes;
   }
 
-  static detect($: Typekit, canonicalization: HttpCanonicalization): Codec | undefined {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]): Codec | undefined {
     return undefined;
   }
 
@@ -84,31 +85,29 @@ export abstract class Codec {
 
 export class IdentityCodec extends Codec {
   readonly id = "identity";
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    return new IdentityCodec($, canonicalization);
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    return new IdentityCodec($, sourceType, referenceTypes);
   }
 
   encode() {
     return {
-      wireType: this.canonicalization.sourceType,
-      languageType: this.canonicalization.sourceType,
+      wireType: this.sourceType,
+      languageType: this.sourceType,
     };
   }
 }
 
 export class UnixTimestamp64Codec extends Codec {
   readonly id = "unix-timestamp-64";
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    const type = canonicalization.sourceType;
-
-    if (!$.scalar.is(type) || !$.type.isAssignableTo(type, $.builtin.utcDateTime)) {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    if (!$.scalar.is(sourceType) || !$.type.isAssignableTo(sourceType, $.builtin.utcDateTime)) {
       return;
     }
 
     const encodingInfo = this.getMetadata(
       $,
-      type,
-      canonicalization.referenceTypes,
+      sourceType,
+      referenceTypes,
       $.modelProperty.is,
       getEncode,
     );
@@ -118,7 +117,7 @@ export class UnixTimestamp64Codec extends Codec {
     }
 
     if (encodingInfo.encoding === "unix-timestamp" && encodingInfo.type === $.builtin.int64) {
-      return new UnixTimestamp64Codec($, canonicalization);
+      return new UnixTimestamp64Codec($, sourceType, referenceTypes);
     }
   }
 
@@ -132,17 +131,15 @@ export class UnixTimestamp64Codec extends Codec {
 
 export class UnixTimestamp32Codec extends Codec {
   readonly id = "unix-timestamp-32";
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    const type = canonicalization.sourceType;
-
-    if (!$.scalar.is(type) || !$.type.isAssignableTo(type, $.builtin.utcDateTime)) {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    if (!$.scalar.is(sourceType) || !$.type.isAssignableTo(sourceType, $.builtin.utcDateTime)) {
       return;
     }
 
     const encodingInfo = this.getMetadata(
       $,
-      type,
-      canonicalization.referenceTypes,
+      sourceType,
+      referenceTypes,
       $.modelProperty.is,
       getEncode,
     );
@@ -152,7 +149,7 @@ export class UnixTimestamp32Codec extends Codec {
     }
 
     if (encodingInfo.encoding === "unix-timestamp" && encodingInfo.type === $.builtin.int32) {
-      return new UnixTimestamp32Codec($, canonicalization);
+      return new UnixTimestamp32Codec($, sourceType, referenceTypes);
     }
   }
 
@@ -167,19 +164,17 @@ export class UnixTimestamp32Codec extends Codec {
 export class Rfc3339Codec extends Codec {
   readonly id = "rfc3339";
 
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    const type = canonicalization.sourceType;
-
-    if (!$.scalar.is(type) || !$.type.isAssignableTo(type, $.builtin.utcDateTime)) {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    if (!$.scalar.is(sourceType) || !$.type.isAssignableTo(sourceType, $.builtin.utcDateTime)) {
       return;
     }
 
-    return new Rfc3339Codec($, canonicalization);
+    return new Rfc3339Codec($, sourceType, referenceTypes);
   }
 
   encode() {
     return {
-      languageType: this.canonicalization.sourceType,
+      languageType: this.sourceType,
       wireType: this.$.builtin.string,
     };
   }
@@ -188,44 +183,34 @@ export class Rfc3339Codec extends Codec {
 export class Rfc7231Codec extends Codec {
   readonly id = "rfc7231";
 
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    const type = canonicalization.sourceType;
-
-    if (!$.scalar.is(type) || !$.type.isAssignableTo(type, $.builtin.utcDateTime)) {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    if (!$.scalar.is(sourceType) || !$.type.isAssignableTo(sourceType, $.builtin.utcDateTime)) {
       return;
     }
 
     const encodingInfo = this.getMetadata(
       $,
-      type,
-      canonicalization.referenceTypes,
+      sourceType,
+      referenceTypes,
       $.modelProperty.is,
       getEncode,
     );
 
     if (!encodingInfo) {
-      if (
-        this.getMetadata(
-          $,
-          undefined,
-          canonicalization.referenceTypes,
-          $.modelProperty.is,
-          isHeader,
-        )
-      ) {
-        return new Rfc7231Codec($, canonicalization);
+      if (this.getMetadata($, undefined, referenceTypes, $.modelProperty.is, isHeader)) {
+        return new Rfc7231Codec($, sourceType, referenceTypes);
       }
       return;
     }
 
     if (encodingInfo.encoding === "rfc7231") {
-      return new Rfc7231Codec($, canonicalization);
+      return new Rfc7231Codec($, sourceType, referenceTypes);
     }
   }
 
   encode() {
     return {
-      languageType: this.canonicalization.sourceType,
+      languageType: this.sourceType,
       wireType: this.$.builtin.string,
     };
   }
@@ -234,19 +219,17 @@ export class Rfc7231Codec extends Codec {
 export class Base64Codec extends Codec {
   readonly id = "base64";
 
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    const type = canonicalization.sourceType;
-
-    if (!$.type.isAssignableTo(type, $.builtin.bytes)) {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    if (!$.type.isAssignableTo(sourceType, $.builtin.bytes)) {
       return;
     }
 
-    return new Base64Codec($, canonicalization);
+    return new Base64Codec($, sourceType, referenceTypes);
   }
 
   encode() {
     return {
-      languageType: this.canonicalization.sourceType,
+      languageType: this.sourceType,
       wireType: this.$.builtin.string,
     };
   }
@@ -255,19 +238,17 @@ export class Base64Codec extends Codec {
 export class CoerceToFloat64Codec extends Codec {
   readonly id = "coerce-to-float64";
 
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    const type = canonicalization.sourceType;
-
-    if (!$.type.isAssignableTo(type, $.builtin.numeric)) {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    if (!$.type.isAssignableTo(sourceType, $.builtin.numeric)) {
       return;
     }
 
-    return new CoerceToFloat64Codec($, canonicalization);
+    return new CoerceToFloat64Codec($, sourceType, referenceTypes);
   }
 
   encode() {
     return {
-      languageType: this.canonicalization.sourceType,
+      languageType: this.sourceType,
       wireType: this.$.builtin.float64,
     };
   }
@@ -276,45 +257,37 @@ export class CoerceToFloat64Codec extends Codec {
 export class NumericToStringCodec extends Codec {
   readonly id = "numeric-to-string";
 
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    const type = canonicalization.sourceType;
-
-    if (!$.type.isAssignableTo(type, $.builtin.numeric)) {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    if (!$.type.isAssignableTo(sourceType, $.builtin.numeric)) {
       return;
     }
 
-    return new NumericToStringCodec($, canonicalization);
+    return new NumericToStringCodec($, sourceType, referenceTypes);
   }
 
   encode() {
     return {
-      languageType: this.canonicalization.sourceType,
+      languageType: this.sourceType,
       wireType: this.$.builtin.string,
     };
   }
 }
 
 export class ArrayJoinCodec extends Codec {
   readonly id = "array-join";
-  static detect($: Typekit, canonicalization: HttpCanonicalization) {
-    const type = canonicalization.sourceType;
-
-    if (!$.array.is(type)) {
+  static detect($: Typekit, sourceType: Type, referenceTypes: MemberType[]) {
+    if (!$.array.is(sourceType)) {
       return;
     }
 
-    if (
-      canonicalization.options.location === "query" ||
-      canonicalization.options.location === "header" ||
-      canonicalization.options.location === "path"
-    ) {
-      return new ArrayJoinCodec($, canonicalization);
-    }
+    // Note: This codec previously checked canonicalization.options.location
+    // This logic may need to be refactored to pass location info differently
+    return new ArrayJoinCodec($, sourceType, referenceTypes);
   }
 
   encode() {
     return {
-      languageType: this.canonicalization.sourceType,
+      languageType: this.sourceType,
       wireType: this.$.builtin.string,
     };
   }

packages/http-canonicalization/src/http-canonicalization.test.ts

@@ -34,7 +34,7 @@ it("canonicalizes models for read visibility", async () => {
   // validate mutation node
   expect(read.properties.size).toBe(2);
   const deletedProperty = read.properties.get("name")! as ModelPropertyHttpCanonicalization;
-  expect(deletedProperty.languageType).toBe(tk.intrinsic.never);
+  expect((deletedProperty.languageType as any) === tk.intrinsic.never).toBe(true);
 
   // validate language type
   expect(read.languageType.name).toBe("Foo");
@@ -97,3 +97,42 @@ it("returns the same canonicalization for the same type", async () => {
 
   expect(read1 === read2).toBe(true);
 });
+
+it("handles referring to the same canonicalization", async () => {
+  const runner = await Tester.createInstance();
+  const { Foo, Bar, Baz, program } = await runner.compile(t.code`
+    model ${t.model("Foo")} {
+      @visibility(Lifecycle.Read) createdAt: utcDateTime;
+      name: string;
+    }  
+
+    model ${t.model("Bar")} {
+      foo: Foo;
+    }
+
+    model ${t.model("Baz")} {
+      foo: Foo;
+    }
+  `);
+
+  const tk = $(program);
+
+  const canonicalizer = new HttpCanonicalizer(tk);
+
+  const createFoo = canonicalizer.canonicalize(Foo, {
+    visibility: Visibility.Create,
+  }) as ModelHttpCanonicalization;
+
+  const createBar = canonicalizer.canonicalize(Bar, {
+    visibility: Visibility.Create,
+  }) as ModelHttpCanonicalization;
+
+  expect(createBar.properties.get("foo")!.type === createFoo).toBe(true);
+  expect(createBar.properties.get("foo")!.languageType.type === createFoo.languageType).toBe(true);
+
+  const createBaz = canonicalizer.canonicalize(Baz, {
+    visibility: Visibility.Create,
+  }) as ModelHttpCanonicalization;
+
+  expect(createBaz.properties.get("foo")!.type === createFoo).toBe(true);
+});