@auto-engineer/server-generator-apollo-emmett 1.88.0 → 1.89.0

package/ketchup-plan.md

@@ -2,10 +2,19 @@
 
 ## TODO
 
-- [x] Burst 8: Return array `idField` natively from extraction (d4633c71)
-- [x] Burst 9: Fix `findOne` fallback with safe value resolution (8d3ee9cd)
-- [x] Burst 10: Derive stable `metadata.now` with narrow trigger
+(none)
 
 ## DONE
 
+- [x] Burst 18: Filter events from react Then assertions (cb94eb5d)
 - [x] Burst 1: Slim ReadModel to find + findOne, update EJS template API docs, update all inline snapshots
+- [x] Burst 8: Return array `idField` natively from extraction (d4633c71)
+- [x] Burst 9: Fix `findOne` fallback with safe value resolution (8d3ee9cd)
+- [x] Burst 10: Derive stable `metadata.now` with narrow trigger (b7bfd7bf)
+- [x] Burst 11: Omit non-command fields from Then assertions + scaffold annotations (c6953364)
+- [x] Burst 12: Implementer system prompt — anti-hardcoding rules for decide functions
+- [x] Burst 13: Fix formatSpecValue and formatTsValueSimple value-type guards (2412e231)
+- [x] Burst 14: Embed implementation instructions in scaffold templates (f211bd90)
+- [x] Burst 15: Add expectEvents typing shim to decide.specs.ts.ejs (681db5a5)
+- [x] Burst 16: Type-annotate aggregateStream callbacks + dynamic error listing + strengthen instructions (8693a4b3)
+- [x] Burst 17: Filter linking field to primitive types only — skip array/object fields in react template linking (d48982d5)

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.88.0",
-    "@auto-engineer/message-bus": "1.88.0"
+    "@auto-engineer/narrative": "1.89.0",
+    "@auto-engineer/message-bus": "1.89.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.88.0"
+    "@auto-engineer/cli": "1.89.0"
   },
-  "version": "1.88.0",
+  "version": "1.89.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/slice-normalizer.specs.ts

@@ -90,4 +90,87 @@ describe('slice-normalizer', () => {
       ]);
     });
   });
+
+  describe('filterReactThenToCommands — removes mislabeled events from Then', () => {
+    const allMessages: MessageDefinition[] = [
+      {
+        type: 'event',
+        name: 'PointsEarned',
+        fields: [
+          { name: 'memberId', type: 'string', required: true },
+          { name: 'points', type: 'number', required: true },
+        ],
+      },
+      {
+        type: 'command',
+        name: 'NotifyAchievementOpportunity',
+        fields: [{ name: 'memberId', type: 'string', required: true }],
+      },
+      {
+        type: 'event',
+        name: 'AchievementOpportunityNotified',
+        fields: [{ name: 'memberId', type: 'string', required: true }],
+      },
+    ];
+
+    it('should remove event And-step after command Then-step', () => {
+      const specs: Spec[] = [
+        {
+          type: 'gherkin',
+          feature: 'React to points milestone',
+          rules: [
+            {
+              name: 'When points are earned, notify achievement',
+              examples: [
+                {
+                  name: 'command first, event second',
+                  steps: [
+                    { keyword: 'When', text: 'PointsEarned', docString: { memberId: 'm1', points: 100 } },
+                    { keyword: 'Then', text: 'NotifyAchievementOpportunity', docString: { memberId: 'm1' } },
+                    { keyword: 'And', text: 'AchievementOpportunityNotified', docString: { memberId: 'm1' } },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const slice = createReactSlice(specs);
+      const result = normalizeSliceForTemplate(slice, allMessages);
+      const example = result.server?.specs?.rules[0].examples[0];
+
+      expect(example?.then).toEqual([{ commandRef: 'NotifyAchievementOpportunity', exampleData: { memberId: 'm1' } }]);
+    });
+
+    it('should remove event even when it appears before the command in Then', () => {
+      const specs: Spec[] = [
+        {
+          type: 'gherkin',
+          feature: 'React to points milestone',
+          rules: [
+            {
+              name: 'When points are earned, notify achievement',
+              examples: [
+                {
+                  name: 'event first, command second',
+                  steps: [
+                    { keyword: 'When', text: 'PointsEarned', docString: { memberId: 'm1', points: 100 } },
+                    { keyword: 'Then', text: 'AchievementOpportunityNotified', docString: { memberId: 'm1' } },
+                    { keyword: 'And', text: 'NotifyAchievementOpportunity', docString: { memberId: 'm1' } },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const slice = createReactSlice(specs);
+      const result = normalizeSliceForTemplate(slice, allMessages);
+      const example = result.server?.specs?.rules[0].examples[0];
+
+      expect(example?.then).toEqual([{ commandRef: 'NotifyAchievementOpportunity', exampleData: { memberId: 'm1' } }]);
+    });
+  });
 });

package/src/codegen/extract/slice-normalizer.ts

@@ -80,6 +80,20 @@ function normalizeReactPatternB(rules: NormalizedRule[], allMessages: MessageDef
   }
 }
 
+function filterReactThenToCommands(rules: NormalizedRule[], allMessages: MessageDefinition[]): void {
+  const commandNames = new Set(allMessages.filter((m) => m.type === 'command').map((m) => m.name));
+  for (const rule of rules) {
+    for (const example of rule.examples) {
+      example.then = example.then.filter((item) => {
+        if ('commandRef' in item) {
+          return commandNames.has(item.commandRef);
+        }
+        return true;
+      });
+    }
+  }
+}
+
 function normalizeSpecsForTemplate(
   specs: Spec[],
   sliceType: SliceType,
@@ -99,6 +113,7 @@ function normalizeSpecsForTemplate(
 
   if (sliceType === 'react' && allMessages) {
     normalizeReactPatternB(rules, allMessages);
+    filterReactThenToCommands(rules, allMessages);
   }
 
   return {

package/src/codegen/extract/type-helpers.specs.ts

@@ -1,5 +1,11 @@
 import { describe, expect, it } from 'vitest';
-import { isValidTsIdentifier, parseInlineObjectFields, sanitizeFieldType } from './type-helpers';
+import {
+  findPrimitiveLinkingField,
+  isPrimitiveTsType,
+  isValidTsIdentifier,
+  parseInlineObjectFields,
+  sanitizeFieldType,
+} from './type-helpers';
 
 describe('parseInlineObjectFields', () => {
   it('should parse simple inline object fields', () => {
@@ -94,3 +100,73 @@ describe('sanitizeFieldType', () => {
     expect(sanitizeFieldType('string')).toBe('string');
   });
 });
+
+describe('isPrimitiveTsType', () => {
+  it('accepts primitive types', () => {
+    expect(isPrimitiveTsType('string')).toBe(true);
+    expect(isPrimitiveTsType('number')).toBe(true);
+    expect(isPrimitiveTsType('boolean')).toBe(true);
+    expect(isPrimitiveTsType('Date')).toBe(true);
+    expect(isPrimitiveTsType('ID')).toBe(true);
+  });
+
+  it('accepts nullable primitives', () => {
+    expect(isPrimitiveTsType('string | null')).toBe(true);
+    expect(isPrimitiveTsType('Date | null')).toBe(true);
+  });
+
+  it('rejects complex types', () => {
+    expect(isPrimitiveTsType('{exercise:string}[]')).toBe(false);
+    expect(isPrimitiveTsType('{exercise:string,sets:number}[]')).toBe(false);
+    expect(isPrimitiveTsType('unknown')).toBe(false);
+    expect(isPrimitiveTsType('Array<string>')).toBe(false);
+  });
+});
+
+describe('findPrimitiveLinkingField', () => {
+  it('matches primitive fields by name', () => {
+    expect(
+      findPrimitiveLinkingField([{ name: 'memberId', tsType: 'string' }], [{ name: 'memberId', type: 'string' }]),
+    ).toBe('memberId');
+  });
+
+  it('skips array/object fields even when names match', () => {
+    expect(
+      findPrimitiveLinkingField(
+        [
+          { name: 'exercises', tsType: '{exercise:string}[]' },
+          { name: 'memberId', tsType: 'string' },
+        ],
+        [
+          { name: 'exercises', type: '{exercise:string}[]' },
+          { name: 'memberId', type: 'string' },
+        ],
+      ),
+    ).toBe('memberId');
+  });
+
+  it('returns undefined when only non-primitive fields match', () => {
+    expect(
+      findPrimitiveLinkingField(
+        [{ name: 'exercises', tsType: '{exercise:string}[]' }],
+        [{ name: 'exercises', type: '{exercise:string}[]' }],
+      ),
+    ).toBeUndefined();
+  });
+
+  it('returns undefined when no field names match', () => {
+    expect(
+      findPrimitiveLinkingField([{ name: 'barberId', tsType: 'string' }], [{ name: 'appointmentId', type: 'string' }]),
+    ).toBeUndefined();
+  });
+
+  it('handles fields with tsType property (extracted state fields)', () => {
+    expect(findPrimitiveLinkingField([{ name: 'id', tsType: 'string' }], [{ name: 'id', tsType: 'string' }])).toBe(
+      'id',
+    );
+  });
+
+  it('handles fields with type property (raw message fields)', () => {
+    expect(findPrimitiveLinkingField([{ name: 'id', type: 'string' }], [{ name: 'id', type: 'string' }])).toBe('id');
+  });
+});

package/src/codegen/extract/type-helpers.ts

@@ -155,3 +155,26 @@ export function createCollectEnumNames(isEnumType: (tsType: string) => boolean,
     return Array.from(enumNames).sort();
   };
 }
+
+export function isPrimitiveTsType(tsType: string): boolean {
+  return ['string', 'number', 'boolean', 'Date', 'ID'].includes(baseTs(tsType));
+}
+
+export function findPrimitiveLinkingField(
+  stateFields: Array<{ name: string; type?: string; tsType?: string }>,
+  eventFields: Array<{ name: string; type?: string; tsType?: string }>,
+): string | undefined {
+  for (const sf of stateFields) {
+    const sfType = sf.type ?? sf.tsType ?? '';
+    if (!isPrimitiveTsType(sfType)) continue;
+    if (
+      eventFields.some((ef) => {
+        const efType = ef.type ?? ef.tsType ?? '';
+        return ef.name === sf.name && isPrimitiveTsType(efType);
+      })
+    ) {
+      return sf.name;
+    }
+  }
+  return undefined;
+}

package/src/codegen/formatTsValueSimple.specs.ts

@@ -45,4 +45,12 @@ describe('formatTsValueSimple', () => {
   it('should return new Date(...) for Date tsType', () => {
     expect(formatTsValueSimple('2025-01-01', 'Date')).toBe('new Date("2025-01-01")');
   });
+
+  it('should fall through to JSON.stringify for array value when tsType is string', () => {
+    expect(formatTsValueSimple([{ memberId: 'm1', points: 100 }], 'string')).toBe('[{"memberId":"m1","points":100}]');
+  });
+
+  it('should fall through to JSON.stringify for object value when tsType is string', () => {
+    expect(formatTsValueSimple({ memberId: 'm1' }, 'string')).toBe('{"memberId":"m1"}');
+  });
 });

package/src/codegen/scaffoldFromSchema.ts

@@ -16,6 +16,7 @@ const debugSlice = createDebug('auto:server-generator-apollo-emmett:scaffold:sli
 const debugPlan = createDebug('auto:server-generator-apollo-emmett:scaffold:plan');
 const debugFormat = createDebug('auto:server-generator-apollo-emmett:scaffold:format');
 
+import { parseSliceRequest } from '@auto-engineer/narrative';
 import {
   baseTs,
   buildCommandGwtMapping,
@@ -28,17 +29,18 @@ import {
   createIsEnumType,
   extractMessagesFromSpecs,
   extractProjectionName,
+  findPrimitiveLinkingField,
   getAllEventTypes,
   getLocalEvents,
   groupEventImports,
   isInlineObjectArray as isInlineObjectArrayHelper,
   isInlineObject as isInlineObjectHelper,
+  isPrimitiveTsType,
   isValidTsIdentifier,
   parseInlineObjectFields,
   sanitizeFieldType,
 } from './extract';
 import { getStreamFromSink } from './extract/data-sink';
-import { parseGraphQlRequest } from './extract/graphql';
 import { normalizeSliceForTemplate } from './extract/slice-normalizer';
 import { extractGwtSpecsFromSlice, type GwtResult } from './extract/step-converter';
 import type { GwtCondition, Message, MessageDefinition } from './types';
@@ -392,6 +394,8 @@ async function renderTemplate(
     parseInlineObjectFields,
     baseTs,
     isEnumType,
+    isPrimitiveTsType,
+    findPrimitiveLinkingField,
     fieldUsesDate,
     fieldUsesJSON,
     fieldUsesFloat,
@@ -412,7 +416,7 @@ export function formatTsValueSimple(value: unknown, tsType: string): string {
   if (tsType === 'Date') {
     return `new Date(${JSON.stringify(value)})`;
   }
-  if (tsType === 'string') {
+  if (tsType === 'string' && typeof value !== 'object') {
     return JSON.stringify(typeof value === 'string' ? value : String(value));
   }
   if (tsType === 'number') {
@@ -608,7 +612,7 @@ async function prepareTemplateData(
     projectionIdField,
     projectionSingleton,
     projectionName,
-    parsedRequest: slice.type === 'query' && slice.request != null ? parseGraphQlRequest(slice.request) : undefined,
+    parsedRequest: parseSliceRequest(slice),
     messages: allMessages,
     message:
       slice.type === 'query' && allMessages