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

Author: FionaBronwen

packages/graphql/src/registry.ts

@@ -1,99 +1,84 @@
 import { UsageFlags, type Enum, type Model } from "@typespec/compiler";
-import {
-  GraphQLBoolean,
-  GraphQLEnumType,
-  GraphQLObjectType,
-  type GraphQLNamedType,
-  type GraphQLSchemaConfig,
-} from "graphql";
+import { GraphQLBoolean, GraphQLObjectType, type GraphQLSchemaConfig } from "graphql";
+import { EnumTypeMap, ModelTypeMap, type TypeKey } from "./type-maps/index.js";
 
-// The TSPTypeContext interface represents the intermediate TSP type information before materialization.
-// It stores the raw TSP type and any extracted metadata relevant for GraphQL generation.
-interface TSPTypeContext {
-  tspType: Enum | Model; // Extend with other TSP types like Operation, Interface, TSP Union, etc.
-  name: string;
-  usageFlags?: Set<UsageFlags>;
-  // TODO: Add any other TSP-specific metadata here.
-}
 /**
  * GraphQLTypeRegistry manages the registration and materialization of TypeSpec (TSP)
  * types into their corresponding GraphQL type definitions.
  *
  * The registry operates in a two-stage process:
  * 1. Registration: TSP types (like Enums, Models, etc.) are first registered
  *    along with relevant metadata (e.g., name, usage flags). This stores an
- *    intermediate representation (`TSPTypeContext`) without immediately creating
- *    GraphQL types. This stage is typically performed while traversing the TSP AST.
- *    Register type by calling the appropriate method (e.g., `addEnum`).
+ *    intermediate representation without immediately creating GraphQL types.
  *
  * 2. Materialization: When a GraphQL type is needed (e.g., to build the final
- *    schema or resolve a field type), the registry can materialize the TSP type
+ *    schema or resolve a field type), the registry materializes the TSP type
  *    into its GraphQL counterpart (e.g., `GraphQLEnumType`, `GraphQLObjectType`).
- *    Materialize types by calling the appropriate method (e.g., `materializeEnum`).
  *
  * This approach helps in:
  *  - Decoupling TSP AST traversal from GraphQL object instantiation.
  *  - Caching materialized GraphQL types to avoid redundant work and ensure object identity.
  *  - Handling forward references and circular dependencies, as types can be
- *    registered first and materialized later when all dependencies are known or
- *    by using thunks for fields/arguments.
+ *    registered first and materialized later when all dependencies are known.
  */
 export class GraphQLTypeRegistry {
-  // Stores intermediate TSP type information, keyed by TSP type name.
-  // TODO: make this more of a seen set
-  private TSPTypeContextRegistry: Map<string, TSPTypeContext> = new Map();
-
-  // Stores materialized GraphQL types, keyed by their GraphQL name.
-  private materializedGraphQLTypes: Map<string, GraphQLNamedType> = new Map();
+  // TypeMaps for each GraphQL type kind
+  private enumMap = new EnumTypeMap();
+  private modelMap = new ModelTypeMap();
 
+  /**
+   * Register a TypeSpec Enum for later materialization.
+   */
   addEnum(tspEnum: Enum): void {
-    const enumName = tspEnum.name;
-    if (this.TSPTypeContextRegistry.has(enumName)) {
-      // Optionally, log a warning or update if new information is more complete.
-      return;
+    if (!this.enumMap.isRegistered(tspEnum.name)) {
+      this.enumMap.register({
+        type: tspEnum,
+        usageFlag: UsageFlags.None,
+        metadata: {},
+      });
     }
-
-    this.TSPTypeContextRegistry.set(enumName, {
-      tspType: tspEnum,
-      name: enumName,
-      // TODO: Populate usageFlags based on TSP context and other decorator context.
-    });
   }
 
-  // Materializes a TSP Enum into a GraphQLEnumType.
-  materializeEnum(enumName: string): GraphQLEnumType | undefined {
-    // Check if the GraphQL type is already materialized.
-    if (this.materializedGraphQLTypes.has(enumName)) {
-      return this.materializedGraphQLTypes.get(enumName) as GraphQLEnumType;
-    }
-
-    const context = this.TSPTypeContextRegistry.get(enumName);
-    if (!context || context.tspType.kind !== "Enum") {
-      // TODO: Handle error or warning for missing context.
-      return undefined;
+  /**
+   * Register a TypeSpec Model for later materialization.
+   */
+  addModel(tspModel: Model): void {
+    if (!this.modelMap.isRegistered(tspModel.name)) {
+      this.modelMap.register({
+        type: tspModel,
+        usageFlag: UsageFlags.None,
+        metadata: {},
+      });
     }
+  }
 
-    const tspEnum = context.tspType as Enum;
-
-    const gqlEnum = new GraphQLEnumType({
-      name: context.name,
-      values: Object.fromEntries(
-        Array.from(tspEnum.members.values()).map((member) => [
-          member.name,
-          {
-            value: member.value ?? member.name,
-          },
-        ]),
-      ),
-    });
+  /**
+   * Materialize a registered enum into a GraphQLEnumType.
+   */
+  materializeEnum(enumName: string): void {
+    this.enumMap.get(enumName as TypeKey);
+  }
 
-    this.materializedGraphQLTypes.set(enumName, gqlEnum);
-    return gqlEnum;
+  /**
+   * Materialize a registered model into a GraphQLObjectType.
+   */
+  materializeModel(modelName: string): void {
+    this.modelMap.get(modelName as TypeKey);
   }
 
+  /**
+   * Build the final GraphQL schema configuration.
+   */
   materializeSchemaConfig(): GraphQLSchemaConfig {
-    const allMaterializedGqlTypes = Array.from(this.materializedGraphQLTypes.values());
-    let queryType = this.materializedGraphQLTypes.get("Query") as GraphQLObjectType | undefined;
+    // Collect all materialized types from all type maps
+    const allMaterializedGqlTypes = [
+      ...this.enumMap.getAllMaterialized(),
+      ...this.modelMap.getAllMaterialized(),
+    ];
+
+    let queryType = undefined as GraphQLObjectType | undefined;
+    // TODO: Get query type from operations when implemented
+
     if (!queryType) {
       queryType = new GraphQLObjectType({
         name: "Query",

packages/graphql/src/schema-emitter.ts

@@ -10,6 +10,7 @@ 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 {
@@ -18,12 +19,13 @@ class GraphQLSchemaEmitter {
   private options: GraphQLEmitterOptions;
   private diagnostics: DiagnosticCollector;
   private registry: GraphQLTypeRegistry;
+  private engine: GraphQLMutationEngine | null = null;
+
   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;
@@ -32,12 +34,16 @@ class GraphQLSchemaEmitter {
   }
 
   async emitSchema(): Promise<[GraphQLSchema, Readonly<Diagnostic[]>] | undefined> {
-    const schemaNamespace = this.tspSchema.type;
-    // Logic to emit the GraphQL schema
-    navigateTypesInNamespace(schemaNamespace, this.semanticNodeListener());
+    // Create mutation engine with the schema namespace
+    this.engine = createGraphQLMutationEngine(this.context.program, this.tspSchema.type);
+
+    // 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({
@@ -51,19 +57,26 @@ class GraphQLSchemaEmitter {
   }
 
   semanticNodeListener() {
-    // TODO: Add GraphQL types to registry as the TSP nodes are visited
     return {
       enum: (node: Enum) => {
-        this.registry.addEnum(node);
+        // Mutate the enum (applies name sanitization)
+        const mutation = this.engine!.mutateEnum(node);
+        this.registry.addEnum(mutation.mutatedType);
       },
       model: (node: Model) => {
-        // Add logic to handle the model node
+        // Mutate the model (applies name sanitization)
+        const mutation = this.engine!.mutateModel(node);
+        this.registry.addModel(mutation.mutatedType);
       },
       exitEnum: (node: Enum) => {
-        this.registry.materializeEnum(node.name);
+        // Use mutated name for materialization
+        const mutation = this.engine!.mutateEnum(node);
+        this.registry.materializeEnum(mutation.mutatedType.name);
       },
       exitModel: (node: Model) => {
-        // Add logic to handle the exit of the model node
+        // Use mutated name for materialization
+        const mutation = this.engine!.mutateModel(node);
+        this.registry.materializeModel(mutation.mutatedType.name);
       },
     };
   }
@@ -74,7 +87,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,9 +2,21 @@ import { strictEqual } from "node:assert";
 import { describe, it } from "vitest";
 import { emitSingleSchema } from "./test-host.js";
 
-// For now, the expected output is a placeholder string.
-// In the future, this should be replaced with the actual GraphQL schema output.
-const expectedGraphQLSchema = `type Query {
+// Expected output with models. Note: field types are placeholders (String) until
+// type resolution is fully implemented.
+const expectedGraphQLSchema = `type Book {
+  name: String
+  page_count: String
+  published: String
+  price: String
+}
+
+type Author {
+  name: String
+  books: String
+}
+
+type Query {
   """
   A placeholder field. If you are seeing this, it means no operations were defined that could be emitted.
   """