feat(graphql): integrate mutation engine and TypeMaps into emitter

Author: FionaBronwen

packages/graphql/src/schema-emitter.ts

@@ -11,6 +11,10 @@ import {
 import { GraphQLSchema, validateSchema } from "graphql";
 import { type GraphQLEmitterOptions } from "./lib.js";
 import type { Schema } from "./lib/schema.js";
+import {
+  createGraphQLMutationEngine,
+  type GraphQLMutationEngine,
+} from "./mutation-engine/index.js";
 import { GraphQLTypeRegistry } from "./registry.js";
 
 class GraphQLSchemaEmitter {
@@ -19,26 +23,29 @@ class GraphQLSchemaEmitter {
   private options: GraphQLEmitterOptions;
   private diagnostics: DiagnosticCollector;
   private registry: GraphQLTypeRegistry;
+  private engine: GraphQLMutationEngine;
+
   constructor(
     tspSchema: Schema,
     context: EmitContext<GraphQLEmitterOptions>,
     options: GraphQLEmitterOptions,
   ) {
-    // Initialize any properties if needed, including the registry
     this.tspSchema = tspSchema;
     this.context = context;
     this.options = options;
     this.diagnostics = createDiagnosticCollector();
     this.registry = new GraphQLTypeRegistry();
+    this.engine = createGraphQLMutationEngine(context.program, tspSchema.type);
   }
 
   async emitSchema(): Promise<[GraphQLSchema, Readonly<Diagnostic[]>] | undefined> {
-    const schemaNamespace = this.tspSchema.type;
-    // Logic to emit the GraphQL schema
-    navigateTypesInNamespace(schemaNamespace, this.semanticNodeListener());
+    // Navigate the original namespace, mutate on-demand via engine
+    navigateTypesInNamespace(this.tspSchema.type, this.semanticNodeListener());
+
     const schemaConfig = this.registry.materializeSchemaConfig();
     const schema = new GraphQLSchema(schemaConfig);
-    // validate the schema
+
+    // Validate the schema
     const validationErrors = validateSchema(schema);
     validationErrors.forEach((error) => {
       this.diagnostics.add({
@@ -52,20 +59,23 @@ class GraphQLSchemaEmitter {
   }
 
   semanticNodeListener() {
-    // TODO: Add GraphQL types to registry as the TSP nodes are visited
     return {
       enum: (node: Enum) => {
-        this.registry.addEnum(node);
+        const mutation = this.engine.mutateEnum(node);
+        this.registry.addEnum(mutation.mutatedType);
       },
       model: (node: Model) => {
-        // TODO: Determine usageFlag from mutation engine or usage tracking
-        this.registry.addModel(node, UsageFlags.Output);
+        const mutation = this.engine.mutateModel(node);
+        // TODO: Handle input/output variants
+        this.registry.addModel(mutation.mutatedType, UsageFlags.Output);
       },
       exitEnum: (node: Enum) => {
-        this.registry.materializeEnum(node.name);
+        const mutation = this.engine.mutateEnum(node);
+        this.registry.materializeEnum(mutation.mutatedType.name);
       },
       exitModel: (node: Model) => {
-        this.registry.materializeModel(node.name);
+        const mutation = this.engine.mutateModel(node);
+        this.registry.materializeModel(mutation.mutatedType.name);
       },
     };
   }
@@ -76,7 +86,6 @@ export function createSchemaEmitter(
   context: EmitContext<GraphQLEmitterOptions>,
   options: GraphQLEmitterOptions,
 ): GraphQLSchemaEmitter {
-  // Placeholder for creating a GraphQL schema emitter
   return new GraphQLSchemaEmitter(schema, context, options);
 }
 

packages/graphql/test/emitter.test.ts

@@ -2,7 +2,16 @@ import { strictEqual } from "node:assert";
 import { describe, it } from "vitest";
 import { emitSingleSchema } from "./test-host.js";
 
-const expectedGraphQLSchema = `type Book {
+// Expected output with models and enums. Note: field types are placeholders (String) until
+// type resolution is fully implemented.
+const expectedGraphQLSchema = `enum Genre {
+  _Fiction_
+  NonFiction
+  Mystery
+  Fantasy
+}
+
+type Book {
   name: String
   page_count: String
   published: String
@@ -21,8 +30,8 @@ type Query {
   _: Boolean
 }`;
 
-describe("name", () => {
-  it("Emits a schema.graphql file with placeholder text", async () => {
+describe("emitter", () => {
+  it("emits models and enums with mutations applied", async () => {
     const code = `
       @schema
       namespace TestNamespace {
@@ -36,6 +45,12 @@ describe("name", () => {
           name: string;
           books: Book[];
         }
+        enum Genre {
+          $Fiction$,
+          NonFiction,
+          Mystery,
+          Fantasy,
+        }
         op getBooks(): Book[];
         op getAuthors(): Author[];
       }

packages/graphql/test/main.tsp

@@ -19,7 +19,7 @@ namespace MyLibrary {
   }
 
   enum Genre {
-    Fiction,
+    $Fiction$,
     NonFiction,
     Mystery,
     Fantasy,