@typespec/mutator-framework 0.12.0

package/src/mutation/mutation-engine.test.ts

@@ -0,0 +1,202 @@
+import type { Model } from "@typespec/compiler";
+import { t } from "@typespec/compiler/testing";
+import { $, type Typekit } from "@typespec/compiler/typekit";
+import { expect, it } from "vitest";
+import { Tester } from "../../test/test-host.js";
+import type { MutationSubgraph } from "../mutation-node/mutation-subgraph.js";
+import { ModelPropertyMutation } from "./model-property.js";
+import { ModelMutation } from "./model.js";
+import { MutationEngine, MutationOptions } from "./mutation-engine.js";
+import { SimpleMutationEngine } from "./simple-mutation-engine.js";
+
+class RenameMutationOptions extends MutationOptions {
+  prefix: string;
+  suffix: string;
+
+  constructor(prefix: string, suffix: string) {
+    super();
+    this.prefix = prefix;
+    this.suffix = suffix;
+  }
+
+  cacheKey() {
+    return `${this.prefix}-${this.suffix}`;
+  }
+}
+
+class RenameMutationEngine extends MutationEngine<RenameMutationClasses> {
+  constructor($: Typekit) {
+    super($, {
+      Model: RenameModelMutation,
+    });
+    this.registerSubgraph("prefix");
+    this.registerSubgraph("suffix");
+  }
+
+  getPrefixSubgraph(options: RenameMutationOptions): MutationSubgraph {
+    return this.getMutationSubgraph(options, "prefix");
+  }
+
+  getSuffixSubgraph(options: RenameMutationOptions): MutationSubgraph {
+    return this.getMutationSubgraph(options, "suffix");
+  }
+}
+
+interface RenameMutationClasses {
+  Model: RenameModelMutation;
+}
+
+class RenameModelMutation extends ModelMutation<
+  RenameMutationOptions,
+  RenameMutationClasses,
+  RenameMutationEngine
+> {
+  get #prefixSubgraph() {
+    return this.engine.getPrefixSubgraph(this.options);
+  }
+
+  get #suffixSubgraph() {
+    return this.engine.getSuffixSubgraph(this.options);
+  }
+
+  get withPrefix() {
+    return this.getMutatedType(this.#prefixSubgraph);
+  }
+
+  get withSuffix() {
+    return this.getMutatedType(this.#suffixSubgraph);
+  }
+
+  mutate() {
+    if ("name" in this.sourceType && typeof this.sourceType.name === "string") {
+      this.mutateType(
+        this.#prefixSubgraph,
+        (m) => (m.name = `${this.options.prefix}${this.sourceType.name}`),
+      );
+      this.mutateType(
+        this.#suffixSubgraph,
+        (m) => (m.name = `${this.sourceType.name}${this.options.suffix}`),
+      );
+    }
+
+    // mutate all connected types passing on the same options
+    super.mutate();
+  }
+}
+it("creates mutations", async () => {
+  const runner = await Tester.createInstance();
+  const { Foo, Bar, prop, program } = await runner.compile(t.code`
+    model ${t.model("Foo")} {
+      ${t.modelProperty("prop")}: Bar;
+    }
+
+    model ${t.model("Bar")} {
+      prop: string;
+    }
+  `);
+
+  const tk = $(program);
+  const engine = new RenameMutationEngine(tk);
+  const options = new RenameMutationOptions("Pre", "Suf");
+  const fooMutation = engine.mutate(Foo, options);
+
+  // can navigate the mutation result to get prefix and suffix names side-by-side
+  expect(fooMutation.properties.size).toBe(1);
+
+  const barMutation = fooMutation.properties.get("prop")!.type as RenameModelMutation;
+  expect(barMutation.withPrefix.name).toBe("PreBar");
+
+  // Or you could get barMutation like:
+  const barMutation2 = engine.mutate(Bar, options);
+
+  // but these are not the same mutation node because the mutation accessed via
+  // the property is a distinct from the one accessed from the scalar.
+  expect(barMutation === barMutation2).toBe(false);
+  expect(barMutation.referenceTypes.length).toEqual(1);
+  expect(barMutation.referenceTypes[0] === prop).toBe(true);
+  expect(barMutation2.referenceTypes.length).toEqual(0);
+
+  // The graph is mutated
+  const prefixModel = fooMutation.withPrefix;
+  const suffixModel = fooMutation.withSuffix;
+
+  expect(prefixModel.name).toBe("PreFoo");
+  expect((prefixModel.properties.get("prop")!.type as Model).name).toBe("PreBar");
+  expect(suffixModel.name).toBe("FooSuf");
+  expect((suffixModel.properties.get("prop")!.type as Model).name).toBe("BarSuf");
+});
+
+interface UnionifyMutations {
+  Model: UnionifyModel;
+  ModelProperty: UnionifyProperty;
+}
+
+class UnionifyModel extends ModelMutation<
+  MutationOptions,
+  UnionifyMutations,
+  SimpleMutationEngine<UnionifyMutations>
+> {
+  get unionified() {
+    return this.getMutatedType();
+  }
+}
+
+class UnionifyProperty extends ModelPropertyMutation<
+  MutationOptions,
+  UnionifyMutations,
+  SimpleMutationEngine<UnionifyMutations>
+> {
+  get unionified() {
+    return this.getMutatedType();
+  }
+
+  mutate() {
+    if (!this.engine.$.union.is(this.sourceType.type)) {
+      // turn it into this union:
+      const newUnionType = this.engine.$.union.create({
+        variants: [
+          this.engine.$.unionVariant.create({ type: this.sourceType.type }),
+          this.engine.$.unionVariant.create({
+            type: this.engine.$.builtin.string,
+          }),
+        ],
+      });
+
+      this.type = this.replaceReferencedType(
+        this.engine.getDefaultMutationSubgraph(this.options),
+        newUnionType,
+      );
+    } else {
+      super.mutate();
+    }
+  }
+}
+
+it("mutates model properties into unions", async () => {
+  const runner = await Tester.createInstance();
+  const { Foo, program } = await runner.compile(t.code`
+    model ${t.model("Foo")} {
+      ${t.modelProperty("prop")}: Bar;
+    }
+
+    model ${t.model("Bar")} {
+      barProp: string;
+    }
+  `);
+
+  const tk = $(program);
+  const engine = new SimpleMutationEngine(tk, {
+    ModelProperty: UnionifyProperty,
+    Model: UnionifyModel,
+  });
+
+  const fooMutation = engine.mutate(Foo);
+  const propMutation = fooMutation.properties.get("prop")!;
+  const typeMutation = propMutation.type as UnionifyModel;
+  expect(typeMutation.kind).toBe("Union");
+  const propType = propMutation.unionified;
+  expect(tk.union.is(propType.type)).toBe(true);
+
+  const mutatedFoo = fooMutation.unionified;
+  expect(tk.union.is(mutatedFoo.properties.get("prop")!.type)).toBe(true);
+});

package/src/mutation/mutation-engine.ts

@@ -0,0 +1,288 @@
+import type { MemberType, Type } from "@typespec/compiler";
+import type { Typekit } from "@typespec/compiler/typekit";
+import type { MutationNodeForType } from "../mutation-node/factory.js";
+import { MutationSubgraph } from "../mutation-node/mutation-subgraph.js";
+import { InterfaceMutation } from "./interface.js";
+import { IntrinsicMutation } from "./intrinsic.js";
+import { LiteralMutation } from "./literal.js";
+import { ModelPropertyMutation } from "./model-property.js";
+import { ModelMutation } from "./model.js";
+import { Mutation } from "./mutation.js";
+import { OperationMutation } from "./operation.js";
+import { ScalarMutation } from "./scalar.js";
+import { UnionVariantMutation } from "./union-variant.js";
+import { UnionMutation } from "./union.js";
+
+export type MutationRegistry = Record<Type["kind"], Mutation<Type, any, any>>;
+
+export interface DefaultMutationClasses<TCustomMutations extends CustomMutationClasses>
+  extends MutationRegistry {
+  Operation: OperationMutation<MutationOptions, TCustomMutations>;
+  Interface: InterfaceMutation<MutationOptions, TCustomMutations>;
+  Model: ModelMutation<MutationOptions, TCustomMutations>;
+  Scalar: ScalarMutation<MutationOptions, TCustomMutations>;
+  ModelProperty: ModelPropertyMutation<MutationOptions, TCustomMutations>;
+  Union: UnionMutation<MutationOptions, TCustomMutations>;
+  UnionVariant: UnionVariantMutation<MutationOptions, TCustomMutations>;
+  String: LiteralMutation<MutationOptions, TCustomMutations>;
+  Number: LiteralMutation<MutationOptions, TCustomMutations>;
+  Boolean: LiteralMutation<MutationOptions, TCustomMutations>;
+  Intrinsic: IntrinsicMutation<MutationOptions, TCustomMutations>;
+}
+
+export type CustomMutationClasses = Partial<MutationRegistry>;
+
+export type WithDefaultMutations<TCustomMutationClasses extends CustomMutationClasses> =
+  TCustomMutationClasses & DefaultMutationClasses<TCustomMutationClasses>;
+
+export type MutationFor<
+  TCustomMutations extends CustomMutationClasses,
+  TKind extends Type["kind"] = Type["kind"],
+> = WithDefaultMutations<TCustomMutations>[TKind];
+
+export type Constructor<T = object> = new (...args: any[]) => T;
+export type ConstructorsFor<T> = { [K in keyof T]: Constructor<T[K]> };
+export type InstancesFor<T extends Record<string, new (...args: any[]) => any>> = {
+  [K in keyof T]: InstanceType<T[K]>;
+};
+
+export class MutationEngine<TCustomMutations extends CustomMutationClasses> {
+  $: Typekit;
+
+  // Map of Type -> (Map of options.cacheKey() -> Mutation)
+  #mutationCache = new Map<Type, Map<string, MutationFor<TCustomMutations>>>();
+
+  // Map of MemberType -> (Map of options.cacheKey() -> Mutation)
+  #referenceMutationCache = new Map<MemberType, Map<string, MutationFor<TCustomMutations>>>();
+
+  #subgraphNames = new Set<string>();
+
+  // Map of subgraph names -> (Map of options.cacheKey() -> MutationSubgraph)
+  #subgraphs = new Map<string, Map<string, MutationSubgraph>>();
+
+  #mutatorClasses: MutationRegistry;
+
+  constructor($: Typekit, mutatorClasses: ConstructorsFor<TCustomMutations>) {
+    this.$ = $;
+    this.#mutatorClasses = {
+      Operation: mutatorClasses.Operation ?? OperationMutation,
+      Interface: mutatorClasses.Interface ?? InterfaceMutation,
+      Model: mutatorClasses.Model ?? ModelMutation,
+      Scalar: mutatorClasses.Scalar ?? ScalarMutation,
+      ModelProperty: mutatorClasses.ModelProperty ?? ModelPropertyMutation,
+      Union: mutatorClasses.Union ?? UnionMutation,
+      UnionVariant: mutatorClasses.UnionVariant ?? UnionVariantMutation,
+      String: mutatorClasses.String ?? LiteralMutation,
+      Number: mutatorClasses.Number ?? LiteralMutation,
+      Boolean: mutatorClasses.Boolean ?? LiteralMutation,
+      Intrinsic: mutatorClasses.Intrinsic ?? IntrinsicMutation,
+    } as any;
+  }
+
+  protected registerSubgraph(name: string) {
+    this.#subgraphNames.add(name);
+  }
+
+  protected getMutationSubgraph(options: MutationOptions, name?: string) {
+    const optionsKey = options?.cacheKey() ?? "default";
+    if (!this.#subgraphs.has(optionsKey)) {
+      this.#subgraphs.set(optionsKey, new Map());
+    }
+    const subgraphsForOptions = this.#subgraphs.get(optionsKey)!;
+
+    name = name ?? "default";
+    if (!subgraphsForOptions.has(name)) {
+      subgraphsForOptions.set(name, new MutationSubgraph(this));
+    }
+
+    return subgraphsForOptions.get(name)!;
+  }
+
+  getDefaultMutationSubgraph(options?: MutationOptions): MutationSubgraph {
+    throw new Error("This mutation engine does not provide a default mutation subgraph.");
+  }
+
+  /**
+   * Retrieve the mutated type from the default mutation subgraph for the given options.
+   */
+  getMutatedType<T extends Type>(options: MutationOptions, sourceType: T): T;
+  /**
+   * Retrieve the mutated type from a specific mutation subgraph.
+   */
+  getMutatedType<T extends Type>(subgraph: MutationSubgraph, sourceType: T): T;
+  /**
+   * Retrieve the mutated type from either the default subgraph with the given
+   * options or a specific subgraph.
+   */
+  getMutatedType<T extends Type>(
+    subgraphOrOptions: MutationOptions | MutationSubgraph,
+    sourceType: T,
+  ): T;
+  getMutatedType<T extends Type>(
+    subgraphOrOptions: MutationOptions | MutationSubgraph,
+    sourceType: T,
+  ) {
+    if (subgraphOrOptions instanceof MutationOptions) {
+      return this.getMutationNode(subgraphOrOptions, sourceType).mutatedType;
+    }
+    return this.getMutationNode(subgraphOrOptions, sourceType).mutatedType;
+  }
+
+  /**
+   * Get (and potentially create) the mutation node for the provided type in the default subgraph.
+   */
+  getMutationNode<T extends Type>(options: MutationOptions, type: T): MutationNodeForType<T>;
+  /**
+   * Get (and potentially create) the mutation node for the provided type in a specific subgraph.
+   */
+  getMutationNode<T extends Type>(subgraph: MutationSubgraph, type: T): MutationNodeForType<T>;
+
+  /**
+   * Get (and potentially create) the mutation node for the provided type in
+   * either the default subgraph with the given options or a specific subgraph.
+   */
+  getMutationNode<T extends Type>(
+    subgraphOrOptions: MutationOptions | MutationSubgraph,
+    type: T,
+  ): MutationNodeForType<T>;
+  getMutationNode<T extends Type>(subgraphOrOptions: MutationOptions | MutationSubgraph, type: T) {
+    let subgraph: MutationSubgraph;
+    if (subgraphOrOptions instanceof MutationOptions) {
+      subgraph = this.getDefaultMutationSubgraph(subgraphOrOptions);
+    } else {
+      subgraph = subgraphOrOptions;
+    }
+    return subgraph.getNode(type);
+  }
+
+  mutateType<T extends Type>(
+    subgraphOrOptions: MutationOptions | MutationSubgraph,
+    type: T,
+    initializeMutation: (type: T) => void,
+  ) {
+    const subgraph = this.#getSubgraphFromOptions(subgraphOrOptions);
+    this.getMutationNode(subgraph, type).mutate(initializeMutation as (type: Type) => void);
+  }
+
+  #getSubgraphFromOptions(subgraphOrOptions: MutationOptions | MutationSubgraph) {
+    if (subgraphOrOptions instanceof MutationOptions) {
+      return this.getDefaultMutationSubgraph(subgraphOrOptions);
+    } else {
+      return subgraphOrOptions;
+    }
+  }
+
+  mutate<TType extends Type>(
+    type: TType,
+    options: MutationOptions = new MutationOptions(),
+  ): MutationFor<TCustomMutations, TType["kind"]> {
+    if (!this.#mutationCache.has(type)) {
+      this.#mutationCache.set(type, new Map<string, MutationFor<TCustomMutations, Type["kind"]>>());
+    }
+
+    const byType = this.#mutationCache.get(type)!;
+    const key = options.cacheKey();
+    if (byType.has(key)) {
+      const existing = byType.get(key)! as any;
+      if (!existing.isMutated) {
+        existing.isMutated = true;
+        existing.mutate();
+      }
+      return existing;
+    }
+
+    this.#initializeSubgraphs(type, options);
+
+    const mutatorClass = this.#mutatorClasses[type.kind];
+    if (!mutatorClass) {
+      throw new Error("No mutator registered for type kind: " + type.kind);
+    }
+
+    // TS doesn't like this abstract class here, but it will be a derivative
+    // class in practice.
+    const mutation = new (mutatorClass as any)(this, type, [], options);
+
+    byType.set(key, mutation);
+    mutation.isMutated = true;
+    mutation.mutate();
+    return mutation;
+  }
+
+  mutateReference<TType extends MemberType>(
+    memberType: TType,
+    referencedMutationNode: Type,
+    options: MutationOptions,
+  ): MutationFor<TCustomMutations>;
+  mutateReference<TType extends MemberType>(
+    memberType: TType,
+    options: MutationOptions,
+  ): MutationFor<TCustomMutations>;
+  mutateReference<TType extends MemberType>(
+    memberType: TType,
+    referencedMutationNodeOrOptions: Type | MutationOptions,
+    options?: MutationOptions,
+  ): MutationFor<TCustomMutations> {
+    let referencedMutationNode: Type | undefined;
+    let finalOptions: MutationOptions;
+    if (referencedMutationNodeOrOptions instanceof MutationOptions) {
+      finalOptions = referencedMutationNodeOrOptions;
+      referencedMutationNode = undefined;
+    } else {
+      referencedMutationNode = referencedMutationNodeOrOptions as Type;
+      finalOptions = options!;
+    }
+
+    if (!this.#referenceMutationCache.has(memberType)) {
+      this.#referenceMutationCache.set(
+        memberType,
+        new Map<string, MutationFor<TCustomMutations>>(),
+      );
+    }
+
+    const byType = this.#referenceMutationCache.get(memberType)!;
+    const key = finalOptions.cacheKey();
+    if (byType.has(key)) {
+      const existing = byType.get(key)! as any;
+      if (!existing.isMutated) {
+        existing.isMutated = true;
+        existing.mutate();
+      }
+      return existing;
+    }
+
+    this.#initializeSubgraphs(memberType, finalOptions);
+    const sources: MemberType[] = [];
+
+    let referencedType: Type = memberType;
+    while (referencedType.kind === "ModelProperty" || referencedType.kind === "UnionVariant") {
+      sources.push(referencedType);
+      referencedType = referencedType.type;
+    }
+
+    const typeToMutate = referencedMutationNode ?? referencedType;
+    const mutatorClass = this.#mutatorClasses[typeToMutate.kind];
+    if (!mutatorClass) {
+      throw new Error("No mutator registered for type kind: " + typeToMutate.kind);
+    }
+
+    const mutation = new (mutatorClass as any)(this, typeToMutate, sources, finalOptions);
+
+    byType.set(key, mutation);
+    mutation.isMutated = true;
+    mutation.mutate();
+    return mutation;
+  }
+
+  #initializeSubgraphs(root: Type, options: MutationOptions) {
+    for (const name of this.#subgraphNames) {
+      const subgraph = this.getMutationSubgraph(options, name);
+      subgraph.getNode(root);
+    }
+  }
+}
+
+export class MutationOptions {
+  cacheKey(): string {
+    return "";
+  }
+}

package/src/mutation/mutation.ts

@@ -0,0 +1,90 @@
+import type { MemberType, Type } from "@typespec/compiler";
+import type { MutationNodeForType } from "../mutation-node/factory.js";
+import type { MutationSubgraph } from "../mutation-node/mutation-subgraph.js";
+import type { CustomMutationClasses, MutationEngine, MutationOptions } from "./mutation-engine.js";
+
+export abstract class Mutation<
+  TSourceType extends Type,
+  TCustomMutations extends CustomMutationClasses,
+  TOptions extends MutationOptions = MutationOptions,
+  TEngine extends MutationEngine<TCustomMutations> = MutationEngine<TCustomMutations>,
+> {
+  abstract readonly kind: string;
+
+  static readonly subgraphNames: string[] = [];
+
+  engine: TEngine;
+  sourceType: TSourceType;
+  options: TOptions;
+  isMutated: boolean = false;
+  referenceTypes: MemberType[];
+
+  constructor(
+    engine: TEngine,
+    sourceType: TSourceType,
+    referenceTypes: MemberType[],
+    options: TOptions,
+  ) {
+    this.engine = engine;
+    this.sourceType = sourceType;
+    this.options = options;
+    this.referenceTypes = referenceTypes;
+  }
+
+  abstract mutate(): void;
+
+  /**
+   * Retrieve the mutated type for this mutation's default subgraph.
+   */
+  protected getMutatedType(): TSourceType;
+  /**
+   * Retrieve the mutated type for the provided subgraph.
+   */
+  protected getMutatedType(subgraph: MutationSubgraph): TSourceType;
+  protected getMutatedType(subgraphOrOptions?: MutationSubgraph | MutationOptions) {
+    return this.engine.getMutatedType(subgraphOrOptions ?? this.options, this.sourceType);
+  }
+
+  /**
+   * Retrieve the mutation node for this mutation's default subgraph.
+   */
+  protected getMutationNode(): MutationNodeForType<TSourceType>;
+  /**
+   * Retrieve the mutation node for the provided subgraph.
+   */
+  protected getMutationNode(subgraph: MutationSubgraph): MutationNodeForType<TSourceType>;
+  /**
+   * Retrieve the mutation node for either the default subgraph with the given
+   * options or a specific subgraph.
+   */
+  protected getMutationNode(
+    subgraphOrOptions: MutationSubgraph | MutationOptions,
+  ): MutationNodeForType<TSourceType>;
+  protected getMutationNode(subgraphOrOptions?: MutationSubgraph | MutationOptions) {
+    return this.engine.getMutationNode(subgraphOrOptions ?? this.options, this.sourceType);
+  }
+
+  /**
+   * Mutate this type in the default subgraph.
+   */
+  protected mutateType(initializeMutation?: (type: TSourceType) => void): void;
+  /**
+   * Mutate this type in the given subgraph
+   */
+  protected mutateType(
+    subgraph: MutationSubgraph,
+    initializeMutation?: (type: TSourceType) => void,
+  ): void;
+
+  protected mutateType(
+    subgraphOrInit?: MutationSubgraph | ((type: TSourceType) => void),
+    initializeMutation?: (type: TSourceType) => void,
+  ) {
+    if (typeof subgraphOrInit === "function") {
+      initializeMutation = subgraphOrInit;
+      subgraphOrInit = undefined;
+    }
+    const node = this.getMutationNode(subgraphOrInit ?? this.options);
+    node.mutate(initializeMutation as (type: Type) => void);
+  }
+}

package/src/mutation/operation.ts

@@ -0,0 +1,40 @@
+import type { MemberType, Operation, Type } from "@typespec/compiler";
+import type {
+  CustomMutationClasses,
+  MutationEngine,
+  MutationFor,
+  MutationOptions,
+} from "./mutation-engine.js";
+import { Mutation } from "./mutation.js";
+
+export class OperationMutation<
+  TOptions extends MutationOptions,
+  TCustomMutations extends CustomMutationClasses,
+  TEngine extends MutationEngine<TCustomMutations> = MutationEngine<TCustomMutations>,
+> extends Mutation<Operation, TCustomMutations, TOptions, TEngine> {
+  readonly kind = "Operation";
+  parameters!: MutationFor<TCustomMutations, "Model">;
+  returnType!: MutationFor<TCustomMutations, Type["kind"]>;
+
+  constructor(
+    engine: TEngine,
+    sourceType: Operation,
+    referenceTypes: MemberType[] = [],
+    options: TOptions,
+  ) {
+    super(engine, sourceType, referenceTypes, options);
+  }
+
+  protected mutateParameters() {
+    this.parameters = this.engine.mutate(this.sourceType.parameters, this.options);
+  }
+
+  protected mutateReturnType() {
+    this.returnType = this.engine.mutate(this.sourceType.returnType, this.options);
+  }
+
+  mutate() {
+    this.mutateParameters();
+    this.mutateReturnType();
+  }
+}

package/src/mutation/scalar.ts

@@ -0,0 +1,36 @@
+import type { MemberType, Scalar } from "@typespec/compiler";
+import type {
+  CustomMutationClasses,
+  MutationEngine,
+  MutationFor,
+  MutationOptions,
+} from "./mutation-engine.js";
+import { Mutation } from "./mutation.js";
+
+export class ScalarMutation<
+  TOptions extends MutationOptions,
+  TCustomMutations extends CustomMutationClasses,
+  TEngine extends MutationEngine<TCustomMutations> = MutationEngine<TCustomMutations>,
+> extends Mutation<Scalar, TCustomMutations, TOptions, TEngine> {
+  readonly kind = "Scalar";
+  baseScalar?: MutationFor<TCustomMutations, "Scalar">;
+
+  constructor(
+    engine: TEngine,
+    sourceType: Scalar,
+    referenceTypes: MemberType[] = [],
+    options: TOptions,
+  ) {
+    super(engine, sourceType, referenceTypes, options);
+  }
+
+  protected mutateBaseScalar() {
+    if (this.sourceType.baseScalar) {
+      this.baseScalar = this.engine.mutate(this.sourceType.baseScalar, this.options);
+    }
+  }
+
+  mutate() {
+    this.mutateBaseScalar();
+  }
+}

package/src/mutation/simple-mutation-engine.ts

@@ -0,0 +1,21 @@
+import type { Typekit } from "@typespec/compiler/typekit";
+import type { MutationSubgraph } from "../mutation-node/mutation-subgraph.js";
+import {
+  type ConstructorsFor,
+  type CustomMutationClasses,
+  MutationEngine,
+  MutationOptions,
+} from "./mutation-engine.js";
+
+export class SimpleMutationEngine<
+  TCustomMutations extends CustomMutationClasses,
+> extends MutationEngine<TCustomMutations> {
+  constructor($: Typekit, mutatorClasses: ConstructorsFor<TCustomMutations>) {
+    super($, mutatorClasses);
+    this.registerSubgraph("subgraph");
+  }
+
+  getDefaultMutationSubgraph(options: MutationOptions): MutationSubgraph {
+    return super.getMutationSubgraph(options, "subgraph");
+  }
+}