@auto-engineer/server-generator-apollo-emmett 1.110.7 → 1.111.0

package/ketchup-plan.md

@@ -6,6 +6,11 @@
 
 ## DONE (Round 3)
 
+- [x] Burst 30: Fix 12 — Exclude custom GraphQL input types from enum imports in query.resolver.ts.ejs
+- [x] Burst 29: Fix 11 — SKIPPED: requires modifying standalone types.ts (blocked by type-organization rule); output is identical so no behavioral impact
+- [x] Burst 28: Fix 10 — Remove "valid" qualifier from decide.specs.ts.ejs test descriptions
+- [x] Burst 27: Fix 9 — Map custom GraphQL input type args to GraphQLJSON in query.resolver.ts.ejs
+
 - [x] Burst 26: Add fart-model test for query-arg-differs-from-projection case
 - [x] Burst 25: Exclude query arg fields from projection spec expected state (6da49a58)
 

package/package.json

@@ -32,8 +32,8 @@
     "uuid": "^13.0.0",
     "web-streams-polyfill": "^4.1.0",
     "zod": "^3.22.4",
-    "@auto-engineer/message-bus": "1.110.7",
-    "@auto-engineer/narrative": "1.110.7"
+    "@auto-engineer/narrative": "1.111.0",
+    "@auto-engineer/message-bus": "1.111.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.110.7"
+    "@auto-engineer/cli": "1.111.0"
   },
-  "version": "1.110.7",
+  "version": "1.111.0",
   "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/extract/messages.specs.ts

@@ -557,3 +557,175 @@ describe('extractMessagesFromSpecs (react slice with data target events)', () =>
     );
   });
 });
+
+describe('extractMessagesFromSpecs (command slice with data target events)', () => {
+  it('should extract data.items Event not in GWT Then', () => {
+    const slice: Slice = {
+      type: 'command',
+      name: 'submit workout log',
+      server: {
+        description: 'Submits a workout log',
+        data: {
+          items: [
+            {
+              target: { type: 'Event', name: 'WorkoutLogged' },
+              destination: { type: 'stream', pattern: 'workout-${workoutId}' },
+            },
+            {
+              target: { type: 'Event', name: 'PointsEarned' },
+              destination: { type: 'stream', pattern: 'points-${userId}' },
+            },
+            {
+              target: { type: 'Event', name: 'WorkoutLogRejected' },
+              destination: { type: 'stream', pattern: 'workout-${workoutId}' },
+            },
+          ],
+        },
+        specs: [
+          {
+            type: 'gherkin',
+            feature: 'Submit workout log',
+            rules: [
+              {
+                name: 'Should submit workout',
+                examples: [
+                  {
+                    name: 'Workout logged',
+                    steps: [
+                      { keyword: 'When', text: 'SubmitWorkoutLog', docString: { workoutId: 'w1' } },
+                      { keyword: 'Then', text: 'WorkoutLogged', docString: { workoutId: 'w1' } },
+                    ],
+                  },
+                  {
+                    name: 'Workout rejected',
+                    steps: [
+                      { keyword: 'When', text: 'SubmitWorkoutLog', docString: { workoutId: 'w2' } },
+                      { keyword: 'Then', text: 'WorkoutLogRejected', docString: { workoutId: 'w2' } },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const allMessages: MessageDefinition[] = [
+      {
+        type: 'command',
+        name: 'SubmitWorkoutLog',
+        fields: [{ name: 'workoutId', type: 'string', required: true }],
+      },
+      {
+        type: 'event',
+        name: 'WorkoutLogged',
+        fields: [{ name: 'workoutId', type: 'string', required: true }],
+      },
+      {
+        type: 'event',
+        name: 'PointsEarned',
+        fields: [
+          { name: 'userId', type: 'string', required: true },
+          { name: 'points', type: 'number', required: true },
+        ],
+      },
+      {
+        type: 'event',
+        name: 'WorkoutLogRejected',
+        fields: [{ name: 'workoutId', type: 'string', required: true }],
+      },
+    ];
+
+    const result = extractMessagesFromSpecs(slice, allMessages);
+
+    expect(result.events).toEqual([
+      {
+        type: 'WorkoutLogged',
+        fields: [{ name: 'workoutId', tsType: 'string', required: true }],
+        source: 'then',
+        sourceFlowName: undefined,
+        sourceSliceName: 'submit workout log',
+      },
+      {
+        type: 'WorkoutLogRejected',
+        fields: [{ name: 'workoutId', tsType: 'string', required: true }],
+        source: 'then',
+        sourceFlowName: undefined,
+        sourceSliceName: 'submit workout log',
+      },
+      {
+        type: 'PointsEarned',
+        fields: [
+          { name: 'userId', tsType: 'string', required: true },
+          { name: 'points', tsType: 'number', required: true },
+        ],
+        source: 'then',
+        sourceSliceName: 'submit workout log',
+      },
+    ]);
+  });
+
+  it('should deduplicate events present in both GWT Then and data.items', () => {
+    const slice: Slice = {
+      type: 'command',
+      name: 'place order',
+      server: {
+        description: 'Places an order',
+        data: {
+          items: [
+            {
+              target: { type: 'Event', name: 'OrderPlaced' },
+              destination: { type: 'stream', pattern: 'order-${orderId}' },
+            },
+          ],
+        },
+        specs: [
+          {
+            type: 'gherkin',
+            feature: 'Place order',
+            rules: [
+              {
+                name: 'Should place',
+                examples: [
+                  {
+                    name: 'Order placed',
+                    steps: [
+                      { keyword: 'When', text: 'PlaceOrder', docString: { orderId: 'o1' } },
+                      { keyword: 'Then', text: 'OrderPlaced', docString: { orderId: 'o1' } },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const allMessages: MessageDefinition[] = [
+      {
+        type: 'command',
+        name: 'PlaceOrder',
+        fields: [{ name: 'orderId', type: 'string', required: true }],
+      },
+      {
+        type: 'event',
+        name: 'OrderPlaced',
+        fields: [{ name: 'orderId', type: 'string', required: true }],
+      },
+    ];
+
+    const result = extractMessagesFromSpecs(slice, allMessages);
+
+    expect(result.events).toEqual([
+      {
+        type: 'OrderPlaced',
+        fields: [{ name: 'orderId', tsType: 'string', required: true }],
+        source: 'then',
+        sourceFlowName: undefined,
+        sourceSliceName: 'place order',
+      },
+    ]);
+  });
+});

package/src/codegen/extract/messages.ts

@@ -52,6 +52,23 @@ function deduplicateMessages<T extends Message>(messages: T[]): T[] {
   return result;
 }
 
+function extractDataTargetEvents(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+  const events: Message[] = [];
+  if ('server' in slice && slice.server?.data?.items) {
+    for (const item of slice.server.data.items) {
+      if (item.target.type === 'Event') {
+        events.push({
+          type: item.target.name,
+          fields: extractFieldsFromMessage(item.target.name, 'event', allMessages),
+          source: 'then' as const,
+          sourceSliceName: slice.name,
+        });
+      }
+    }
+  }
+  return events;
+}
+
 function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
   debugCommand('Extracting messages for command slice: %s', slice.name);
 
@@ -98,9 +115,12 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
   });
   debugCommand('  Total events extracted: %d', events.length);
 
+  const dataTargetEvents = extractDataTargetEvents(slice, allMessages);
+  debugCommand('  Extracted %d data target events', dataTargetEvents.length);
+
   const result = {
     commands,
-    events: deduplicateMessages([...stateAsEvents, ...events]),
+    events: deduplicateMessages([...stateAsEvents, ...events, ...dataTargetEvents]),
     states: [],
     commandSchemasByName,
   };
@@ -215,19 +235,7 @@ function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[])
   const dataStates = extractStatesFromData(slice, allMessages);
   debugReact('  Extracted %d states from data', dataStates.length);
 
-  const dataTargetEvents: Message[] = [];
-  if (slice.server?.data?.items) {
-    for (const item of slice.server.data.items) {
-      if (item.target.type === 'Event') {
-        dataTargetEvents.push({
-          type: item.target.name,
-          fields: extractFieldsFromMessage(item.target.name, 'event', allMessages),
-          source: 'then' as const,
-          sourceSliceName: slice.name,
-        });
-      }
-    }
-  }
+  const dataTargetEvents = extractDataTargetEvents(slice, allMessages);
   debugReact('  Extracted %d data target events', dataTargetEvents.length);
 
   const result = {

package/src/codegen/findEventSource.specs.ts

@@ -95,6 +95,60 @@ describe('findEventSource', () => {
     });
   });
 
+  it('should find event in command slice data.items when not in GWT specs', () => {
+    const flows: Narrative[] = [
+      {
+        name: 'workout flow',
+        slices: [
+          {
+            type: 'command',
+            name: 'submit workout log',
+            server: {
+              description: 'Submits a workout log',
+              data: {
+                items: [
+                  {
+                    target: { type: 'Event', name: 'WorkoutLogged' },
+                    destination: { type: 'stream', pattern: 'workout-${workoutId}' },
+                  },
+                  {
+                    target: { type: 'Event', name: 'PointsEarned' },
+                    destination: { type: 'stream', pattern: 'points-${userId}' },
+                  },
+                ],
+              },
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Submit workout',
+                  rules: [
+                    {
+                      name: 'Should submit',
+                      examples: [
+                        {
+                          name: 'Workout logged',
+                          steps: [
+                            { keyword: 'When', text: 'SubmitWorkoutLog', docString: {} },
+                            { keyword: 'Then', text: 'WorkoutLogged', docString: {} },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ];
+
+    expect(findEventSource(flows, 'PointsEarned')).toEqual({
+      flowName: 'workout flow',
+      sliceName: 'submit workout log',
+    });
+  });
+
   it('should return null when event is not found anywhere', () => {
     const flows: Narrative[] = [
       {

package/src/codegen/scaffoldFromSchema.ts

@@ -742,10 +742,10 @@ export function findEventSource(flows: Narrative[], eventType: string): { flowNa
           return { flowName: flow.name, sliceName: slice.name };
         }
       }
-      if (slice.type === 'react' && slice.server?.data?.items) {
+      if ('server' in slice && slice.server?.data?.items) {
         for (const item of slice.server.data.items) {
           if (item.target.type === 'Event' && item.target.name === eventType) {
-            debugSlice('  Found event source in react data target: flow=%s, slice=%s', flow.name, slice.name);
+            debugSlice('  Found event source in data target: flow=%s, slice=%s', flow.name, slice.name);
             return { flowName: flow.name, sliceName: slice.name };
           }
         }

package/src/codegen/templates/command/decide.specs.specs.ts

@@ -1387,4 +1387,71 @@ describe('spec.ts.ejs', () => {
     expect(decideFile?.contents).toContain('...command.data');
     expect(decideFile?.contents).not.toContain('`NotFoundError`');
   });
+
+  it('should not include "valid" qualifier in fallback test description', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'order-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'place order',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Place order',
+                    rules: [
+                      {
+                        name: 'Order placement',
+                        examples: [
+                          {
+                            name: '',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'PlaceOrder',
+                                docString: { orderId: 'o1' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'OrderPlaced',
+                                docString: { orderId: 'o1' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'PlaceOrder',
+          fields: [{ name: 'orderId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'OrderPlaced',
+          fields: [{ name: 'orderId', type: 'string', required: true }],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
+
+    expect(specFile?.contents).toContain('should emit OrderPlaced for PlaceOrder');
+    expect(specFile?.contents).not.toContain('for valid');
+  });
 });

package/src/codegen/templates/command/decide.specs.ts.ejs

@@ -132,7 +132,7 @@ describe('<%= ruleDescription %>', () => {
     const testDescription = gwt.description ||
         (errorResult
             ? `should throw ${errorResult.errorType} when ${gwt.failingFields?.join(', ') || 'invalid input'}`
-            : `should emit ${eventResults.map(e => e.eventRef).join(', ')} for valid ${commandName}`);
+            : `should emit ${eventResults.map(e => e.eventRef).join(', ')} for ${commandName}`);
 %>
   it('<%= testDescription %>', () => {
     given([

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

@@ -1186,4 +1186,69 @@ describe('query.resolver.ts.ejs', () => {
       "
     `);
   });
+
+  it('should map custom input type args to GraphQLJSON and Record<string, unknown>', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'workout-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'list-workouts',
+              request: `
+                query ListWorkouts($filter: ListWorkoutsFilterInput, $limit: Int) {
+                  listWorkouts(filter: $filter, limit: $limit) {
+                    workoutId
+                    exercise
+                  }
+                }
+              `,
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      origin: {
+                        type: 'projection',
+                        idField: 'workoutId',
+                        name: 'WorkoutsProjection',
+                      },
+                      target: {
+                        type: 'State',
+                        name: 'WorkoutSummary',
+                      },
+                    },
+                  ],
+                },
+                specs: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'WorkoutSummary',
+          fields: [
+            { name: 'workoutId', type: 'string', required: true },
+            { name: 'exercise', type: 'string', 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).toContain("import { GraphQLJSON } from 'graphql-type-json';");
+    expect(resolverFile?.contents).toContain(
+      "@Arg('filter', () => GraphQLJSON, { nullable: true }) filter?: Record<string, unknown>",
+    );
+    expect(resolverFile?.contents).toContain("@Arg('limit', () => Float, { nullable: true }) limit?: number");
+    expect(resolverFile?.contents).not.toContain('ListWorkoutsFilterInput');
+  });
 });

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

@@ -11,14 +11,17 @@ const usesID = parsedRequest?.args?.some(arg => graphqlType(arg.tsType) === 'ID'
 
 const messageFields = message?.fields ?? [];
 const refFields = (referencedTypes ?? []).flatMap(rt => rt.fields ?? []);
+const KNOWN_GQL_SCALARS = new Set(['String', 'Int', 'Float', 'Number', 'Boolean', 'Date', 'ID']);
 const usesDate = [...messageFields, ...refFields].some(f => fieldUsesDate(f.type)) ||
         (parsedRequest?.args ?? []).some(a => fieldUsesDate(a.tsType));
+const hasCustomTypeArgs = (parsedRequest?.args ?? []).some(a => !KNOWN_GQL_SCALARS.has(a.graphqlType));
 const usesJSON = [...messageFields, ...refFields].some(f => fieldUsesJSON(f.type)) ||
-        (parsedRequest?.args ?? []).some(a => fieldUsesJSON(a.tsType));
+        (parsedRequest?.args ?? []).some(a => fieldUsesJSON(a.tsType)) ||
+        hasCustomTypeArgs;
 const usesFloat = [...messageFields, ...refFields].some(f => fieldUsesFloat(f.type)) ||
         (parsedRequest?.args ?? []).some(a => fieldUsesFloat(a.tsType));
 
-const enumList = collectEnumNames([...messageFields, ...(parsedRequest?.args ?? []), ...refFields]);
+const enumList = collectEnumNames([...messageFields, ...refFields]);
 const filteredReferencedTypes = (referencedTypes ?? []).filter(rt => rt.name !== viewType);
 
 const embeddedTypes = [];
@@ -32,6 +35,14 @@ for (const field of messageFields) {
     }
 }
 const hasArgs = parsedRequest?.args?.length > 0;
+
+const resolveArgTypes = (arg) => {
+    const isCustom = !KNOWN_GQL_SCALARS.has(arg.graphqlType);
+    return {
+        gqlType: isCustom ? 'GraphQLJSON' : graphqlType(arg.tsType),
+        tsType: arg.tsType === 'ID' ? 'string' : (isCustom ? 'Record<string, unknown>' : arg.tsType),
+    };
+};
 %>
 import { Query, Resolver<% if (hasArgs) { %>, Arg<% } %>, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesFloat) { %>, Float<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
 <% if (usesJSON) { %>import { GraphQLJSON } from 'graphql-type-json';
@@ -106,8 +117,7 @@ async <%= queryName %>(
 @Ctx() ctx: GraphQLContext<% if (parsedRequest?.args?.length) { %>,
 <%   for (let i = 0; i < parsedRequest.args.length; i++) {
     const arg = parsedRequest.args[i];
-    const gqlType = graphqlType(arg.tsType);
-    const tsType = arg.tsType === 'ID' ? 'string' : arg.tsType;
+    const { gqlType, tsType } = resolveArgTypes(arg);
 %>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
 <%   } } %>
 ): Promise<<%= viewType %>> {
@@ -149,8 +159,7 @@ async <%= queryName %>(
 @Ctx() ctx: GraphQLContext<% if (parsedRequest?.args?.length) { %>,
 <%   for (let i = 0; i < parsedRequest.args.length; i++) {
     const arg = parsedRequest.args[i];
-    const gqlType = graphqlType(arg.tsType);
-    const tsType = arg.tsType === 'ID' ? 'string' : arg.tsType;
+    const { gqlType, tsType } = resolveArgTypes(arg);
 %>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
 <%   } } %>
 ): Promise<<%= viewType %>[]> {

package/src/commands/generate-server.specs.ts

@@ -89,15 +89,12 @@ describe('cleanServerDir', () => {
     expect(await fs.pathExists(join(dir, 'src'))).toBe(false);
   });
 
-  it('removes scripts/ and dist/ directories when present', async () => {
-    await fs.ensureDir(join(dir, 'scripts'));
-    await fs.writeFile(join(dir, 'scripts', 'generate-schema.ts'), 'export {}');
+  it('removes dist/ directory when present', async () => {
     await fs.ensureDir(join(dir, 'dist'));
     await fs.writeFile(join(dir, 'dist', 'server.js'), 'export {}');
 
     await cleanServerDir(dir);
 
-    expect(await fs.pathExists(join(dir, 'scripts'))).toBe(false);
     expect(await fs.pathExists(join(dir, 'dist'))).toBe(false);
   });
 });