@typespec/mutator-framework 0.12.0

package/src/mutation/union-variant.ts

@@ -0,0 +1,30 @@
+import type { MemberType, Type, UnionVariant } from "@typespec/compiler";
+import type {
+  CustomMutationClasses,
+  MutationEngine,
+  MutationFor,
+  MutationOptions,
+} from "./mutation-engine.js";
+import { Mutation } from "./mutation.js";
+
+export class UnionVariantMutation<
+  TOptions extends MutationOptions,
+  TCustomMutations extends CustomMutationClasses,
+  TEngine extends MutationEngine<TCustomMutations> = MutationEngine<TCustomMutations>,
+> extends Mutation<UnionVariant, TCustomMutations, TOptions, TEngine> {
+  readonly kind = "UnionVariant";
+  type!: MutationFor<TCustomMutations, Type["kind"]>;
+
+  constructor(
+    engine: TEngine,
+    sourceType: UnionVariant,
+    referenceTypes: MemberType[] = [],
+    options: TOptions,
+  ) {
+    super(engine, sourceType, referenceTypes, options);
+  }
+
+  mutate(): void {
+    this.type = this.engine.mutate(this.sourceType.type, this.options);
+  }
+}

package/src/mutation/union.ts

@@ -0,0 +1,39 @@
+import type { MemberType, Union } from "@typespec/compiler";
+import type {
+  CustomMutationClasses,
+  MutationEngine,
+  MutationFor,
+  MutationOptions,
+} from "./mutation-engine.js";
+import { Mutation } from "./mutation.js";
+
+export class UnionMutation<
+  TOptions extends MutationOptions,
+  TCustomMutations extends CustomMutationClasses,
+  TEngine extends MutationEngine<TCustomMutations> = MutationEngine<TCustomMutations>,
+> extends Mutation<Union, TCustomMutations, TOptions, TEngine> {
+  readonly kind = "Union";
+  variants: Map<string | symbol, MutationFor<TCustomMutations, "UnionVariant">> = new Map();
+
+  constructor(
+    engine: TEngine,
+    sourceType: Union,
+    referenceTypes: MemberType[] = [],
+    options: TOptions,
+  ) {
+    super(engine, sourceType, referenceTypes, options);
+  }
+
+  protected mutateVariants() {
+    this.variants = new Map(
+      [...this.sourceType.variants].map(([name, variant]) => [
+        name,
+        this.engine.mutate(variant, this.options),
+      ]),
+    );
+  }
+
+  mutate() {
+    this.mutateVariants();
+  }
+}

package/src/mutation-node/enum-member.test.ts

@@ -0,0 +1,26 @@
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, expect, it } from "vitest";
+import { Tester } from "../../test/test-host.js";
+import { getSubgraph } from "../../test/utils.js";
+let runner: TesterInstance;
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+
+it("handles mutation of member values", async () => {
+  const { program, Foo, a } = await runner.compile(t.code`
+      enum ${t.enum("Foo")} {
+        ${t.enumMember("a")}: "valueA";
+        b: "valueB";
+      }
+    `);
+
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const aNode = subgraph.getNode(a);
+  aNode.mutate((clone) => (clone.value = "valueARenamed"));
+  expect(aNode.isMutated).toBe(true);
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.members.get("a") === aNode.mutatedType).toBe(true);
+  expect(aNode.mutatedType.value).toBe("valueARenamed");
+});

package/src/mutation-node/enum-member.ts

@@ -0,0 +1,8 @@
+import type { EnumMember } from "@typespec/compiler";
+import { MutationNode } from "./mutation-node.js";
+
+export class EnumMemberMutationNode extends MutationNode<EnumMember> {
+  readonly kind = "EnumMember";
+
+  traverse() {}
+}

package/src/mutation-node/enum.test.ts

@@ -0,0 +1,26 @@
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, expect, it } from "vitest";
+import { Tester } from "../../test/test-host.js";
+import { getSubgraph } from "../../test/utils.js";
+let runner: TesterInstance;
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+
+it("handles mutation of members", async () => {
+  const { program, Foo, a } = await runner.compile(t.code`
+      enum ${t.enum("Foo")} {
+        ${t.enumMember("a")};
+        b;
+      }
+    `);
+
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const aNode = subgraph.getNode(a);
+  aNode.mutate((clone) => (clone.name = "aRenamed"));
+  expect(aNode.isMutated).toBe(true);
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.members.get("a") === undefined).toBeTruthy();
+  expect(fooNode.mutatedType.members.get("aRenamed") === aNode.mutatedType).toBeTruthy();
+});

package/src/mutation-node/enum.ts

@@ -0,0 +1,33 @@
+import type { Enum, EnumMember } from "@typespec/compiler";
+import { MutationEdge } from "./mutation-edge.js";
+import { MutationNode } from "./mutation-node.js";
+
+export class EnumMutationNode extends MutationNode<Enum> {
+  readonly kind = "Enum";
+
+  traverse() {
+    for (const member of this.sourceType.members.values()) {
+      const memberNode = this.subgraph.getNode(member);
+      this.connectMember(memberNode, member.name);
+    }
+  }
+
+  connectMember(memberNode: MutationNode<EnumMember>, sourcePropName: string) {
+    MutationEdge.create(this, memberNode, {
+      onTailMutation: () => {
+        this.mutatedType.members.delete(sourcePropName);
+        this.mutatedType.members.set(memberNode.mutatedType.name, memberNode.mutatedType);
+      },
+      onTailDeletion: () => {
+        this.mutatedType.members.delete(sourcePropName);
+      },
+      onTailReplaced: (newTail) => {
+        if (newTail.mutatedType.kind !== "EnumMember") {
+          throw new Error("Cannot replace enum member with non-enum member type");
+        }
+        this.mutatedType.members.delete(sourcePropName);
+        this.mutatedType.members.set(newTail.mutatedType.name, newTail.mutatedType);
+      },
+    });
+  }
+}

package/src/mutation-node/factory.ts

@@ -0,0 +1,95 @@
+import type {
+  BooleanLiteral,
+  Enum,
+  EnumMember,
+  Interface,
+  IntrinsicType,
+  Model,
+  ModelProperty,
+  NumericLiteral,
+  Operation,
+  Scalar,
+  StringLiteral,
+  Tuple,
+  Type,
+  Union,
+  UnionVariant,
+} from "@typespec/compiler";
+import { EnumMemberMutationNode } from "./enum-member.js";
+import { EnumMutationNode } from "./enum.js";
+import { InterfaceMutationNode } from "./interface.js";
+import { IntrinsicMutationNode } from "./intrinsic.js";
+import { LiteralMutationNode } from "./literal.js";
+import { ModelPropertyMutationNode } from "./model-property.js";
+import { ModelMutationNode } from "./model.js";
+import type { MutationSubgraph } from "./mutation-subgraph.js";
+import { OperationMutationNode } from "./operation.js";
+import { ScalarMutationNode } from "./scalar.js";
+import { TupleMutationNode } from "./tuple.js";
+import { UnionVariantMutationNode } from "./union-variant.js";
+import { UnionMutationNode } from "./union.js";
+
+export function mutationNodeFor<T extends Type>(
+  subgraph: MutationSubgraph,
+  sourceType: T,
+): MutationNodeForType<T> {
+  switch (sourceType.kind) {
+    case "Operation":
+      return new OperationMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "Interface":
+      return new InterfaceMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "Model":
+      return new ModelMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "ModelProperty":
+      return new ModelPropertyMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "Scalar":
+      return new ScalarMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "Tuple":
+      return new TupleMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "Union":
+      return new UnionMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "UnionVariant":
+      return new UnionVariantMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "Enum":
+      return new EnumMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "EnumMember":
+      return new EnumMemberMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    case "String":
+    case "Number":
+    case "Boolean":
+      return new LiteralMutationNode(
+        subgraph,
+        sourceType as StringLiteral | NumericLiteral | BooleanLiteral,
+      ) as MutationNodeForType<T>;
+    case "Intrinsic":
+      return new IntrinsicMutationNode(subgraph, sourceType) as MutationNodeForType<T>;
+    default:
+      throw new Error("Unsupported type kind: " + sourceType.kind);
+  }
+}
+
+export type MutationNodeForType<T extends Type> = T extends Model
+  ? ModelMutationNode
+  : T extends Interface
+    ? InterfaceMutationNode
+    : T extends Operation
+      ? OperationMutationNode
+      : T extends ModelProperty
+        ? ModelPropertyMutationNode
+        : T extends Scalar
+          ? ScalarMutationNode
+          : T extends Tuple
+            ? TupleMutationNode
+            : T extends Union
+              ? UnionMutationNode
+              : T extends UnionVariant
+                ? UnionVariantMutationNode
+                : T extends Enum
+                  ? EnumMutationNode
+                  : T extends EnumMember
+                    ? EnumMemberMutationNode
+                    : T extends StringLiteral | NumericLiteral | BooleanLiteral
+                      ? LiteralMutationNode
+                      : T extends IntrinsicType
+                        ? IntrinsicMutationNode
+                        : never;

package/src/mutation-node/index.ts

@@ -0,0 +1,16 @@
+export * from "./mutation-node.js";
+
+export * from "./enum.js";
+export * from "./interface.js";
+export * from "./intrinsic.js";
+export * from "./literal.js";
+export * from "./model-property.js";
+export * from "./model.js";
+export * from "./mutation-edge.js";
+export * from "./mutation-subgraph.js";
+export * from "./operation.js";
+export * from "./scalar.js";
+export * from "./tuple.js";
+export * from "./union-variant.js";
+export * from "./union.js";
+//export * from "./enum-member.js";

package/src/mutation-node/interface.ts

@@ -0,0 +1,33 @@
+import type { Interface, Operation } from "@typespec/compiler";
+import { MutationEdge } from "./mutation-edge.js";
+import { MutationNode } from "./mutation-node.js";
+
+export class InterfaceMutationNode extends MutationNode<Interface> {
+  readonly kind = "Interface";
+
+  traverse() {
+    for (const [opName, op] of this.sourceType.operations) {
+      const opNode = this.subgraph.getNode(op);
+      this.connectOperation(opNode, opName);
+    }
+  }
+
+  connectOperation(opNode: MutationNode<Operation>, opName: string) {
+    MutationEdge.create(this, opNode, {
+      onTailMutation: () => {
+        this.mutatedType.operations.delete(opName);
+        this.mutatedType.operations.set(opNode.mutatedType.name, opNode.mutatedType);
+      },
+      onTailDeletion: () => {
+        this.mutatedType.operations.delete(opName);
+      },
+      onTailReplaced: (newTail) => {
+        if (newTail.mutatedType.kind !== "Operation") {
+          throw new Error("Cannot replace operation with non-operation type");
+        }
+        this.mutatedType.operations.delete(opName);
+        this.mutatedType.operations.set(newTail.mutatedType.name, newTail.mutatedType);
+      },
+    });
+  }
+}

package/src/mutation-node/intrinsic.ts

@@ -0,0 +1,8 @@
+import type { IntrinsicType } from "@typespec/compiler";
+import { MutationNode } from "./mutation-node.js";
+
+export class IntrinsicMutationNode extends MutationNode<IntrinsicType> {
+  readonly kind = "Intrinsic";
+
+  traverse() {}
+}

package/src/mutation-node/literal.ts

@@ -0,0 +1,10 @@
+import type { BooleanLiteral, NumericLiteral, StringLiteral } from "@typespec/compiler";
+import { MutationNode } from "./mutation-node.js";
+
+export class LiteralMutationNode extends MutationNode<
+  StringLiteral | NumericLiteral | BooleanLiteral
+> {
+  readonly kind = "Literal";
+
+  traverse() {}
+}

package/src/mutation-node/model-property.test.ts

@@ -0,0 +1,136 @@
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { $ } from "@typespec/compiler/typekit";
+import { beforeEach, expect, it } from "vitest";
+import { Tester } from "../../test/test-host.js";
+import { getSubgraph } from "../../test/utils.js";
+
+let runner: TesterInstance;
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+
+it("handles mutation of property types", async () => {
+  const { prop, program } = await runner.compile(t.code`
+      model Foo {
+        ${t.modelProperty("prop")}: string;
+      }
+    `);
+  const subgraph = getSubgraph(program);
+  const propNode = subgraph.getNode(prop);
+  const stringNode = subgraph.getNode($(program).builtin.string);
+  stringNode.mutate();
+  expect(propNode.isMutated).toBe(true);
+  expect(propNode.mutatedType.type === stringNode.mutatedType).toBe(true);
+});
+
+it("handles mutating a reference", async () => {
+  const { Foo, Bar, prop, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} {
+        ${t.modelProperty("prop")}: Bar;
+      };
+      model ${t.model("Bar")} {}
+    `);
+
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const propNode = subgraph.getNode(prop);
+  const barPrime = subgraph.getReferenceNode(prop);
+
+  // initially the source type is just Bar.
+  expect(barPrime.sourceType === Bar).toBe(true);
+
+  barPrime.mutate();
+  expect(fooNode.isMutated).toBe(true);
+  expect(propNode.isMutated).toBe(true);
+  expect(barPrime.isMutated).toBe(true);
+  expect(fooNode.mutatedType.properties.get("prop")!.type === barPrime.mutatedType).toBeTruthy();
+
+  const barNode = subgraph.getNode(Bar);
+  barNode.mutate();
+  expect(barNode.isMutated).toBe(true);
+  expect(barPrime.isMutated).toBe(true);
+  // the mutated type doesn't change here.
+  expect(fooNode.mutatedType.properties.get("prop")!.type === barPrime.mutatedType).toBeTruthy();
+});
+
+it("handles replacing the model reference", async () => {
+  const { Foo, Bar, prop, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} {
+        ${t.modelProperty("prop")}: Bar;
+      };
+      model ${t.model("Bar")} {}
+    `);
+  const tk = $(program);
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const propNode = subgraph.getNode(prop);
+  const barPrime = subgraph.getReferenceNode(prop);
+  const unionType = tk.union.create({
+    variants: [
+      tk.unionVariant.create({ type: tk.builtin.string }),
+      tk.unionVariant.create({ type: Bar }),
+    ],
+  });
+
+  const replacedBarPrime = barPrime.replace(unionType);
+
+  // the subgraph now returns the new reference node
+  expect(subgraph.getReferenceNode(prop) === replacedBarPrime).toBe(true);
+
+  // foo and prop are marked mutated, barPrime is replaced
+  expect(fooNode.isMutated).toBe(true);
+  expect(propNode.isMutated).toBe(true);
+  expect(barPrime.isReplaced).toBe(true);
+
+  // prop's type is the replaced type
+  expect(tk.union.is(propNode.mutatedType.type)).toBe(true);
+  expect(
+    fooNode.mutatedType!.properties.get("prop")!.type === replacedBarPrime.mutatedType,
+  ).toBeTruthy();
+});
+
+it("handles mutating a reference to a reference", async () => {
+  const { myString, Foo, fprop, Bar, program } = await runner.compile(t.code`
+      scalar ${t.scalar("myString")} extends string;
+      model ${t.model("Foo")} {
+        ${t.modelProperty("fprop")}: myString;
+      };
+      model ${t.model("Bar")} {
+        bprop: Foo.fprop;
+      }
+    `);
+
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const barNode = subgraph.getNode(Bar);
+  const myStringNode = subgraph.getNode(myString);
+
+  myStringNode.mutate();
+  expect(myStringNode.isMutated).toBe(true);
+  expect(fooNode.isMutated).toBe(true);
+  expect(barNode.isMutated).toBe(true);
+
+  // Foo.prop's type is the mutated myString
+  expect(
+    fooNode.mutatedType.properties.get("fprop")!.type === myStringNode.mutatedType,
+  ).toBeTruthy();
+
+  // Bar.prop's type is the mutated Foo.prop
+  expect(
+    barNode.mutatedType.properties.get("bprop")!.type ===
+      fooNode.mutatedType.properties.get("fprop")!,
+  ).toBeTruthy();
+
+  const fpropRefNode = subgraph.getReferenceNode(fprop);
+  fpropRefNode.mutate();
+  expect(fpropRefNode.isMutated).toBe(true);
+  expect(
+    fooNode.mutatedType.properties.get("fprop")!.type === fpropRefNode.mutatedType,
+  ).toBeTruthy();
+
+  // Bar.bprop references the mutated type (though is the same reference since fprop was already mutated)
+  expect(
+    barNode.mutatedType.properties.get("bprop")!.type ===
+      fooNode.mutatedType.properties.get("fprop")!,
+  ).toBeTruthy();
+});

package/src/mutation-node/model-property.ts

@@ -0,0 +1,53 @@
+import type { ModelProperty, Type } from "@typespec/compiler";
+import { MutationEdge } from "./mutation-edge.js";
+import { MutationNode } from "./mutation-node.js";
+
+export class ModelPropertyMutationNode extends MutationNode<ModelProperty> {
+  readonly kind = "ModelProperty";
+  #referenceMutated = false;
+
+  traverse() {
+    const typeNode = this.subgraph.getNode(this.sourceType.type);
+    const referenceNode = this.subgraph.getReferenceNode(this.sourceType);
+
+    this.connectType(typeNode);
+    this.connectReference(referenceNode);
+  }
+
+  connectReference(referenceNode: MutationNode<Type>) {
+    MutationEdge.create(this, referenceNode, {
+      onTailMutation: () => {
+        this.#referenceMutated = true;
+        this.mutatedType.type = referenceNode.mutatedType;
+      },
+      onTailDeletion: () => {
+        this.#referenceMutated = true;
+        this.mutatedType.type = this.$.intrinsic.any;
+      },
+      onTailReplaced: (newTail) => {
+        this.#referenceMutated = true;
+        this.mutatedType.type = newTail.mutatedType;
+      },
+    });
+  }
+
+  connectType(typeNode: MutationNode<Type>) {
+    MutationEdge.create(this, typeNode, {
+      onTailMutation: () => {
+        if (this.#referenceMutated) {
+          return;
+        }
+        this.mutatedType.type = typeNode.mutatedType;
+      },
+      onTailDeletion: () => {
+        if (this.#referenceMutated) {
+          return;
+        }
+        this.mutatedType.type = this.$.intrinsic.any;
+      },
+      onTailReplaced: (newTail) => {
+        this.mutatedType.type = newTail.mutatedType;
+      },
+    });
+  }
+}

package/src/mutation-node/model.test.ts

@@ -0,0 +1,151 @@
+import type { Model, Type } from "@typespec/compiler";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, expect, it } from "vitest";
+import { Tester } from "../../test/test-host.js";
+import { getSubgraph } from "../../test/utils.js";
+
+let runner: TesterInstance;
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+
+it("handles mutation of properties", async () => {
+  const { Foo, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} {
+        prop: string;
+      }
+    `);
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const propNode = subgraph.getNode(Foo.properties.get("prop")!);
+  propNode.mutate();
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.properties.get("prop") === propNode.mutatedType).toBe(true);
+});
+
+it("handles deletion of properties", async () => {
+  const { Foo, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} {
+        prop: string;
+      }
+    `);
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const propNode = subgraph.getNode(Foo.properties.get("prop")!);
+  propNode.delete();
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.properties.get("prop")).toBeUndefined();
+});
+
+it("handles mutation of properties with name change", async () => {
+  const { Foo, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} {
+        prop: string;
+      }
+    `);
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const propNode = subgraph.getNode(Foo.properties.get("prop")!);
+  propNode.mutate((clone) => (clone.name = "propRenamed"));
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.properties.get("prop") === undefined).toBe(true);
+  expect(fooNode.mutatedType.properties.get("propRenamed") === propNode.mutatedType).toBe(true);
+});
+
+it("handles mutation of base models", async () => {
+  const { Foo, Bar, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} extends Bar {
+        barProp: string;
+      }
+
+      model ${t.model("Bar")} {
+        bazProp: string;
+      }
+    `);
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const barNode = subgraph.getNode(Bar);
+
+  barNode.mutate();
+  expect(barNode.isMutated).toBe(true);
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.baseModel === barNode.mutatedType).toBeTruthy();
+});
+
+it("handles deletion of base models", async () => {
+  const { Foo, Bar, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} extends Bar {
+        barProp: string;
+      }
+
+      model ${t.model("Bar")} {
+        bazProp: string;
+      }
+    `);
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const barNode = subgraph.getNode(Bar);
+
+  barNode.delete();
+  expect(barNode.isDeleted).toBe(true);
+  expect(fooNode.isMutated).toBe(true);
+  expect(fooNode.mutatedType.baseModel).toBeUndefined();
+});
+
+it("handles mutation of indexers", async () => {
+  const { Foo, Bar, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} is Record<Bar> {};
+      model ${t.model("Bar")} {
+        bazProp: string;
+      }
+    `);
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const barNode = subgraph.getNode(Bar);
+
+  barNode.mutate();
+  expect(barNode.isMutated).toBe(true);
+  expect(fooNode.isMutated).toBe(true);
+  expect((fooNode.mutatedType.indexer?.value as Type) === barNode.mutatedType).toBeTruthy();
+});
+
+it("handles mutation of arrays", async () => {
+  const { Foo, Bar, bazProp, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} {};
+      model ${t.model("Bar")} {
+        ${t.modelProperty("bazProp")}: Foo[];
+      }
+    `);
+
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const barNode = subgraph.getNode(Bar);
+  const bazPropNode = subgraph.getNode(bazProp);
+
+  fooNode.mutate();
+  expect(fooNode.isMutated).toBe(true);
+  expect(barNode.isMutated).toBe(true);
+  expect(bazPropNode.isMutated).toBe(true);
+  expect(
+    (bazPropNode.mutatedType.type as Model).indexer!.value === fooNode.mutatedType,
+  ).toBeTruthy();
+});
+
+it("handles circular models", async () => {
+  const { Foo, Bar, program } = await runner.compile(t.code`
+      model ${t.model("Foo")} {
+        bar: Bar;
+      };
+      model ${t.model("Bar")} {
+        foo: Foo;
+      }
+    `);
+
+  const subgraph = getSubgraph(program);
+  const fooNode = subgraph.getNode(Foo);
+  const barNode = subgraph.getNode(Bar);
+
+  fooNode.mutate();
+  expect(fooNode.isMutated).toBe(true);
+  expect(barNode.isMutated).toBe(true);
+});