@auto-engineer/server-generator-apollo-emmett 1.45.1 → 1.45.2

package/ketchup-plan.md

@@ -1,17 +1,7 @@
-# Ketchup Plan: Separate InitializeServer from GenerateServer
+# Ketchup Plan: Fix `@Field(() => JSON)` uses JS built-in instead of GraphQL scalar
 
 ## TODO
 
 ## DONE
 
-- [x] Burst 1: Export 4 config-writing functions from generate-server.ts (03543045)
-- [x] Burst 2: InitializeServer creates all files in empty dir + emits ServerInitialized (cc8fe3c0)
-- [x] Burst 3: InitializeServer is idempotent (doesn't overwrite existing files) (e8137a58)
-- [x] Burst 4: InitializeServer emits ServerInitializationFailed on error (2f320556)
-- [x] Burst 5: Update index.ts exports + auto.config.ts pipeline wiring (849fa106)
-- [x] Burst 6: GenerateServer preserves health resolver after clean (8d37de62)
-- [x] Burst 1: Command slices — Given-step state refs get local event type definitions (261a0d41)
-- [x] Burst 2: findEventSource — check react data target events (9ac929f9)
-- [x] Burst 3: extractMessagesForReact — extract data target events with source 'then' (f7aee89b)
-- [x] Burst 4: Add events.ts.ejs template for react slices + defaultFilesByType entry (d2e5e5b8)
-- [x] Burst 5: formatSpecValue — handle stringified JSON arrays (6cb406c3)
+- [x] Burst 1: Fix graphqlType() to return 'GraphQLJSON' for object/inline-object types and update snapshots (c810efdd)

package/package.json

@@ -32,8 +32,8 @@
     "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
     "zod": "^3.22.4",
-    "@auto-engineer/narrative": "1.45.1",
-    "@auto-engineer/message-bus": "1.45.1"
+    "@auto-engineer/narrative": "1.45.2",
+    "@auto-engineer/message-bus": "1.45.2"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.45.1"
+    "@auto-engineer/cli": "1.45.2"
   },
-  "version": "1.45.1",
+  "version": "1.45.2",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src",

package/src/codegen/scaffoldFromSchema.ts

@@ -311,8 +311,8 @@ async function renderTemplate(
     if (arr2 !== null) return `[${graphqlType(arr2[1].trim())}]`;
 
     if (base === 'unknown' || base === 'any') return 'GraphQLJSON';
-    if (base === 'object') return 'JSON';
-    if (isInlineObject(base)) return 'JSON';
+    if (base === 'object') return 'GraphQLJSON';
+    if (isInlineObject(base)) return 'GraphQLJSON';
     if (isStringLiteralUnion(base)) return resolveEnumOrString(base);
 
     return convertPrimitiveType(base);

package/src/codegen/templates/command/mutation.resolver.specs.ts

@@ -111,7 +111,7 @@ describe('mutation.resolver.ts.ejs', () => {
         @Field(() => Float)
         rating!: number;
 
-        @Field(() => JSON)
+        @Field(() => GraphQLJSON)
         metadata!: object;
 
         @Field(() => GraphQLISODateTime)

package/src/codegen/templates/query/projection.specs.ts

@@ -831,4 +831,136 @@ describe('projection.ts.ejs', () => {
       "
     `);
   });
+
+  it('should not treat mixed union type with quotes as enum import', async () => {
+    const flows: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'order-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'place-order',
+              stream: 'order-${orderId}',
+              client: { specs: [] },
+              server: {
+                description: 'handles order placement',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Place order',
+                    rules: [
+                      {
+                        name: 'Should handle order placement',
+                        examples: [
+                          {
+                            name: 'User places order',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'PlaceOrder',
+                                docString: { orderId: 'order_1', total: 100 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'OrderPlaced',
+                                docString: { orderId: 'order_1', total: 100 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'query',
+              name: 'view-order-status',
+              stream: 'orders',
+              client: { specs: [] },
+              server: {
+                description: 'projection for order status',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'State', name: 'OrderStatus' },
+                      origin: {
+                        type: 'projection',
+                        name: 'OrderStatusProjection',
+                        idField: 'orderId',
+                      },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'View order status',
+                    rules: [
+                      {
+                        name: 'Should project order status',
+                        examples: [
+                          {
+                            name: 'Order placed shows in status',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'OrderPlaced',
+                                docString: { orderId: 'order_1', total: 100 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'OrderStatus',
+                                docString: { orderId: 'order_1', mixedStatus: 0 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'PlaceOrder',
+          fields: [
+            { name: 'orderId', type: 'string', required: true },
+            { name: 'total', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'OrderPlaced',
+          source: 'internal',
+          fields: [
+            { name: 'orderId', type: 'string', required: true },
+            { name: 'total', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'OrderStatus',
+          fields: [
+            { name: 'orderId', type: 'string', required: true },
+            { name: 'mixedStatus', type: 'number | "pending"', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(flows.narratives, flows.messages, undefined, 'src/domain/flows');
+    const projectionFile = plans.find((p) => p.outputPath.endsWith('view-order-status/projection.ts'));
+
+    expect(projectionFile?.contents).not.toContain('number | "pending"');
+    expect(projectionFile?.contents).toContain('mixedStatus: /* TODO: map from event.data */ undefined as any');
+  });
 });

package/src/codegen/templates/query/projection.ts.ejs

@@ -26,7 +26,7 @@ if (targetName && messages) {
     if (targetDef?.fields) {
         for (const field of targetDef.fields) {
             const fieldType = (field.type || '').replace(/\s*\|\s*null/g, '').trim();
-            if (fieldType.includes('|') && (fieldType.includes('"') || fieldType.includes("'"))) {
+            if (isEnumType(fieldType)) {
                 const enumName = toTsFieldType(field.type);
                 if (enumName && enumName !== 'String' && !stateEnums.includes(enumName)) {
                     stateEnums.push(enumName);
@@ -223,7 +223,7 @@ case '<%= event.type %>': {
             placeholder = isNullable ? '/* TODO: map from event.data */ null' : '/* TODO: map from event.data */ new Date()';
         } else if (baseType.startsWith('Array<')) {
             placeholder = isNullable ? '/* TODO: map from event.data */ null' : '/* TODO: map from event.data */ []';
-        } else if (baseType.includes('|') && (baseType.includes('"') || baseType.includes("'"))) {
+        } else if (isEnumType(baseType)) {
             const enumName = toTsFieldType(type);
             const firstValue = baseType.match(/['"]([^'"]+)['"]/)?.[1] ?? '';
             const enumConstant = firstValue ? firstValue.toUpperCase().replace(/[^A-Z0-9]/g, '_') : '';

package/src/codegen/templates/query/query.resolver.specs.ts

@@ -703,6 +703,67 @@ describe('query.resolver.ts.ejs', () => {
     expect(resolverFile?.contents).not.toContain(', ReadModel');
   });
 
+  it('should not treat mixed union type with quotes as enum in singleton default values', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'order-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'views-order-summary',
+              request: `
+                query GetOrderSummary {
+                  orderSummary {
+                    totalOrders
+                    mixedStatus
+                  }
+                }
+              `,
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      origin: {
+                        type: 'projection',
+                        name: 'OrderSummaryProjection',
+                        singleton: true,
+                      },
+                      target: {
+                        type: 'State',
+                        name: 'OrderSummary',
+                      },
+                    },
+                  ],
+                },
+                specs: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'OrderSummary',
+          fields: [
+            { name: 'totalOrders', type: 'number', required: true },
+            { name: 'mixedStatus', type: 'number | "pending"', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).not.toContain("mixedStatus: 'pending'");
+    expect(resolverFile?.contents).toContain('mixedStatus: 0');
+  });
+
   it('should handle nested Array<{...}> in embedded ObjectType without breaking', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
@@ -770,5 +831,6 @@ describe('query.resolver.ts.ejs', () => {
     expect(resolverFile?.contents).toContain('export class WorkoutSessionPerformance');
     expect(resolverFile?.contents).toContain('exerciseId!: string;');
     expect(resolverFile?.contents).toContain('sets!: { reps: number; weight: number }[];');
+    expect(resolverFile?.contents).toContain('@Field(() => [GraphQLJSON])');
   });
 });

package/src/codegen/templates/query/query.resolver.ts.ejs

@@ -112,7 +112,7 @@ async <%= queryName %>(
       defaultValue = 'new Date()';
     } else if (baseType.startsWith('Array<')) {
       defaultValue = '[]';
-    } else if (baseType.includes('|') && (baseType.includes('"') || baseType.includes("'"))) {
+    } else if (isEnumType(baseType)) {
       const firstValue = baseType.match(/['"]([^'"]+)['"]/)?.[1] ?? '';
       defaultValue = `'${firstValue}'`;
     }