@auto-engineer/server-generator-apollo-emmett 1.146.0 → 1.148.0

package/ketchup-plan.md

@@ -1,9 +1,10 @@
-# Ketchup Plan: Cross-Scene Given Events in handle.ts
+# Ketchup Plan: G4 — Fix remaining decide.ts implementer failures
 
 ## TODO
 
 ## DONE
 
-- [x] Burst 1: Compute `crossSceneGivens` in template data (d5786a13)
-- [x] Burst 2: Generate cross-scene handler in handle.ts.ejs (f919ab8b)
-- [x] Burst 3: End-to-end verification — all 299 tests pass, existing snapshots unchanged
+- [x] B1: Extract shared template helpers and wire into template data [depends: none] (78f159a4)
+- [x] B3: Add hasGivenStates + state context instruction to decide.ts.ejs [depends: B1] (42f66c71)
+- [x] B4: Add context-aware nonCommandField classification to decide.ts.ejs [depends: B3] (65212e33)
+- [x] B5: Add Given state ref hints to state.ts.ejs [depends: none]

package/package.json

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

@@ -190,7 +190,7 @@ describe('extractMessagesFromSpecs (react slice)', () => {
 });
 
 describe('extractMessagesFromSpecs (command slice)', () => {
-  it('should create state-as-event with source then for Given-step state refs', () => {
+  it('should extract Given-step state refs into states array, not events', () => {
     const slice: Moment = {
       type: 'command',
       name: 'book barber appointment',
@@ -263,23 +263,24 @@ describe('extractMessagesFromSpecs (command slice)', () => {
 
     expect(result.events).toEqual([
       {
-        type: 'CustomerAppointments',
+        type: 'BarberAppointmentBooked',
         fields: [
           { name: 'customerId', tsType: 'string', required: true },
-          { name: 'appointments', tsType: 'object[]', required: true },
+          { name: 'barberId', tsType: 'string', required: true },
         ],
         source: 'then',
+        sourceSceneName: undefined,
         sourceMomentName: 'book barber appointment',
       },
+    ]);
+
+    expect(result.states).toEqual([
       {
-        type: 'BarberAppointmentBooked',
+        type: 'CustomerAppointments',
         fields: [
           { name: 'customerId', tsType: 'string', required: true },
-          { name: 'barberId', tsType: 'string', required: true },
+          { name: 'appointments', tsType: 'object[]', required: true },
         ],
-        source: 'then',
-        sourceSceneName: undefined,
-        sourceMomentName: 'book barber appointment',
       },
     ]);
   });

package/src/codegen/extract/messages.ts

@@ -91,16 +91,8 @@ function extractMessagesForCommand(slice: Moment, allMessages: MessageDefinition
   debugCommand('  Command schemas: %o', Object.keys(commandSchemasByName));
 
   const allGivenRefs = gwtSpecs.flatMap((gwt) => gwt.given);
-  const stateAsEvents: Message[] = allGivenRefs
-    .filter((ref) => !allMessages.some((m) => m.type === 'event' && m.name === ref.eventRef))
-    .filter((ref) => allMessages.some((m) => m.type === 'state' && m.name === ref.eventRef))
-    .map((ref) => ({
-      type: ref.eventRef,
-      fields: extractFieldsFromMessage(ref.eventRef, 'state', allMessages),
-      source: 'then' as const,
-      sourceMomentName: slice.name,
-    }));
-  debugCommand('  State-as-events from Given: %d', stateAsEvents.length);
+  const givenStates = extractStatesFromGiven(allGivenRefs, allMessages);
+  debugCommand('  Given states: %d', givenStates.length);
 
   const events: Message[] = gwtSpecs.flatMap((gwt): Message[] => {
     const eventOnlyGiven = gwt.given.filter((ref) =>
@@ -120,8 +112,8 @@ function extractMessagesForCommand(slice: Moment, allMessages: MessageDefinition
 
   const result = {
     commands,
-    events: deduplicateMessages([...stateAsEvents, ...events, ...dataTargetEvents]),
-    states: [],
+    events: deduplicateMessages([...events, ...dataTargetEvents]),
+    states: givenStates,
     commandSchemasByName,
   };
 

package/src/codegen/extract/states.specs.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import type { EventRef, MessageDefinition } from '../types';
+import { extractStatesFromGiven } from './states';
+
+describe('extractStatesFromGiven', () => {
+  it('should extract state refs from given and return state messages', () => {
+    const givenRefs: EventRef[] = [{ eventRef: 'CustomerAppointments' }, { eventRef: 'OrderPlaced' }];
+
+    const allMessages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'CustomerAppointments',
+        fields: [
+          { name: 'customerId', type: 'string', required: true },
+          { name: 'appointments', type: 'object[]', required: true },
+        ],
+      },
+      {
+        type: 'event',
+        name: 'OrderPlaced',
+        fields: [{ name: 'orderId', type: 'string', required: true }],
+      },
+    ];
+
+    const result = extractStatesFromGiven(givenRefs, allMessages);
+
+    expect(result).toEqual([
+      {
+        type: 'CustomerAppointments',
+        fields: [
+          { name: 'customerId', tsType: 'string', required: true },
+          { name: 'appointments', tsType: 'object[]', required: true },
+        ],
+      },
+    ]);
+  });
+
+  it('should return empty array when no given refs match state messages', () => {
+    const givenRefs: EventRef[] = [{ eventRef: 'OrderPlaced' }];
+
+    const allMessages: MessageDefinition[] = [
+      {
+        type: 'event',
+        name: 'OrderPlaced',
+        fields: [{ name: 'orderId', type: 'string', required: true }],
+      },
+    ];
+
+    const result = extractStatesFromGiven(givenRefs, allMessages);
+
+    expect(result).toEqual([]);
+  });
+});

package/src/codegen/scaffoldFromSchema.ts

@@ -42,11 +42,12 @@ import {
   isValidTsIdentifier,
   sanitizeFieldType,
 } from './extract';
-import { extractStreamIdFields, getStreamFromSink } from './extract/data-sink';
+import { getStreamFromSink } from './extract/data-sink';
 import { buildEventIdFieldMap } from './extract/projection';
 import { buildArgToStateFieldMap } from './extract/query';
 import { normalizeMomentForTemplate } from './extract/slice-normalizer';
 import { extractGwtSpecsFromMoment, type GwtResult } from './extract/step-converter';
+import { buildKeepFieldNames, findDerivedDateInfo, isKeyTraceable } from './templateHelpers';
 import type { GwtCondition, Message, MessageDefinition } from './types';
 
 export class TemplateRenderError extends Error {
@@ -431,6 +432,9 @@ async function renderTemplate(
     isReferencedMessageTypeArray,
     extractReferencedTypeName,
     referencedTypes: data.referencedTypes,
+    findDerivedDateInfo,
+    isKeyTraceable,
+    buildKeepFieldNames,
   });
 
   debugTemplate('Template rendered, output size: %d bytes', result.length);
@@ -709,8 +713,6 @@ async function prepareTemplateData(
   const argToStateFieldMap =
     slice.type === 'query' ? buildArgToStateFieldMap(queryGwtMapping, stateFieldNames, slice.mappings) : undefined;
 
-  const crossSceneGivens = buildCrossSceneGivens(gwtMapping, events, scene, scenes ?? [], filteredCommands);
-
   return {
     sceneName: scene.name,
     momentName: slice.name,
@@ -741,63 +743,9 @@ async function prepareTemplateData(
     eventCommandPairs,
     eventIdFieldMap,
     argToStateFieldMap,
-    crossSceneGivens,
   };
 }
 
-interface CrossSceneGiven {
-  sourceStreamPattern: string;
-  linkingFields: Array<{
-    streamVar: string;
-    commandField: string;
-  }>;
-  allVarsResolved: boolean;
-}
-
-export function buildCrossSceneGivens(
-  gwtMapping: Record<string, GwtCondition[]>,
-  events: Message[],
-  currentScene: Scene,
-  scenes: Scene[],
-  filteredCommands: Message[],
-): CrossSceneGiven[] {
-  const commandFieldNames = new Set(filteredCommands.flatMap((c) => c.fields.map((f) => f.name)));
-  const seenPatterns = new Set<string>();
-  const result: CrossSceneGiven[] = [];
-
-  for (const conditions of Object.values(gwtMapping)) {
-    for (const gwt of conditions) {
-      for (const givenRef of gwt.given ?? []) {
-        if (!('eventRef' in givenRef)) continue;
-
-        const event = events.find((e) => e.type === givenRef.eventRef);
-        if (!event || event.sourceSceneName === currentScene.name) continue;
-
-        const sourceScene = scenes.find((s) => s.name === event.sourceSceneName);
-        const sourceMoment = sourceScene?.moments.find((m) => m.name === event.sourceMomentName);
-        if (!sourceMoment) continue;
-
-        const { streamPattern } = getStreamFromSink(sourceMoment);
-        if (!streamPattern || seenPatterns.has(streamPattern)) continue;
-        seenPatterns.add(streamPattern);
-
-        const streamVars = extractStreamIdFields(streamPattern);
-        const linkingFields = streamVars
-          .filter((v) => commandFieldNames.has(v))
-          .map((v) => ({ streamVar: v, commandField: v }));
-
-        result.push({
-          sourceStreamPattern: streamPattern,
-          linkingFields,
-          allVarsResolved: linkingFields.length === streamVars.length,
-        });
-      }
-    }
-  }
-
-  return result;
-}
-
 function annotateEventSources(
   events: Message[],
   scenes: Scene[],
@@ -980,11 +928,12 @@ async function generateFilesForMoment(
   );
 
   debugMoment('  Generating %d files from templates', filteredTemplates.length);
-  const plans = await Promise.all(
+  const allPlans = await Promise.all(
     filteredTemplates.map((template) =>
       generateFileForTemplate(template, slice, momentDir, templateData, unionToEnumName),
     ),
   );
+  const plans = allPlans.filter((p) => p.contents.trim().length > 0);
   debugMoment('  Generated %d file plans for moment: %s', plans.length, slice.name);
   return { plans, duplicateCommands };
 }

package/src/codegen/templateHelpers.specs.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest';
+import { buildKeepFieldNames, findDerivedDateInfo, isKeyTraceable } from './templateHelpers';
+
+describe('findDerivedDateInfo', () => {
+  it('should detect a date field not in command fields and not in given events', () => {
+    const eventResults = [{ exampleData: { workoutId: 'w1', date: '2024-01-01', duration: 30 } }];
+    const commandFieldNames = new Set(['workoutId', 'duration']);
+
+    const result = findDerivedDateInfo(eventResults, commandFieldNames, undefined);
+
+    expect(result).toEqual({ date: '2024-01-01', fields: ['date'] });
+  });
+
+  it('should return null date when no date-like fields exist', () => {
+    const eventResults = [{ exampleData: { workoutId: 'w1', duration: 30 } }];
+    const commandFieldNames = new Set(['workoutId', 'duration']);
+
+    const result = findDerivedDateInfo(eventResults, commandFieldNames, undefined);
+
+    expect(result).toEqual({ date: null, fields: [] });
+  });
+
+  it('should exclude date values that appear in given events', () => {
+    const eventResults = [{ exampleData: { id: 'x', startDate: '2024-01-01' } }];
+    const commandFieldNames = new Set(['id']);
+    const givenEvents = [{ exampleData: { startDate: '2024-01-01' } }];
+
+    const result = findDerivedDateInfo(eventResults, commandFieldNames, givenEvents);
+
+    expect(result).toEqual({ date: null, fields: [] });
+  });
+
+  it('should return null when multiple distinct dates exist', () => {
+    const eventResults = [{ exampleData: { startDate: '2024-01-01', endDate: '2024-02-01' } }];
+    const commandFieldNames = new Set<string>();
+
+    const result = findDerivedDateInfo(eventResults, commandFieldNames, undefined);
+
+    expect(result).toEqual({ date: null, fields: [] });
+  });
+
+  it('should group multiple fields sharing the same date', () => {
+    const eventResults = [{ exampleData: { createdAt: '2024-01-01', updatedAt: '2024-01-01' } }];
+    const commandFieldNames = new Set<string>();
+
+    const result = findDerivedDateInfo(eventResults, commandFieldNames, undefined);
+
+    expect(result).toEqual({ date: '2024-01-01', fields: ['createdAt', 'updatedAt'] });
+  });
+});
+
+describe('isKeyTraceable', () => {
+  it('should return true when key+value match a given event', () => {
+    const givenEvents = [{ exampleData: { userId: 'u1' } }];
+
+    expect(isKeyTraceable('userId', 'u1', givenEvents)).toBe(true);
+  });
+
+  it('should return false when value does not match', () => {
+    const givenEvents = [{ exampleData: { userId: 'u1' } }];
+
+    expect(isKeyTraceable('userId', 'u2', givenEvents)).toBe(false);
+  });
+
+  it('should return false for null/undefined/object values', () => {
+    expect(isKeyTraceable('x', null, [{ exampleData: { x: null } }])).toBe(false);
+    expect(isKeyTraceable('x', undefined, [{ exampleData: { x: undefined } }])).toBe(false);
+    expect(isKeyTraceable('x', { a: 1 }, [{ exampleData: { x: { a: 1 } } }])).toBe(false);
+  });
+
+  it('should return false when no given events', () => {
+    expect(isKeyTraceable('x', 'v', undefined)).toBe(false);
+  });
+});
+
+describe('buildKeepFieldNames', () => {
+  it('should include command fields, derived date fields, and traceable fields', () => {
+    const eventResults = [{ exampleData: { workoutId: 'w1', userId: 'u1', date: '2024-01-01', duration: 30 } }];
+    const commandFieldNames = new Set(['workoutId', 'duration']);
+    const derivedDateFieldNames = ['date'];
+    const givenEvents = [{ exampleData: { userId: 'u1' } }];
+
+    const result = buildKeepFieldNames(eventResults, commandFieldNames, derivedDateFieldNames, givenEvents);
+
+    expect(result).toEqual(new Set(['workoutId', 'duration', 'date', 'userId']));
+  });
+
+  it('should not include untraceable fields', () => {
+    const eventResults = [{ exampleData: { id: 'x', mystery: 'abc' } }];
+    const commandFieldNames = new Set(['id']);
+    const derivedDateFieldNames: string[] = [];
+    const givenEvents: Array<{ exampleData?: Record<string, unknown> }> = [];
+
+    const result = buildKeepFieldNames(eventResults, commandFieldNames, derivedDateFieldNames, givenEvents);
+
+    expect(result).toEqual(new Set(['id']));
+  });
+});

package/src/codegen/templateHelpers.ts

@@ -0,0 +1,58 @@
+interface EventData {
+  exampleData?: Record<string, unknown>;
+}
+
+export function findDerivedDateInfo(
+  eventResults: EventData[],
+  commandFieldNames: Set<string>,
+  givenEvents: EventData[] | undefined,
+): { date: string | null; fields: string[] } {
+  const givenValues = new Set<string>();
+  for (const g of givenEvents ?? []) {
+    for (const val of Object.values(g.exampleData ?? {})) {
+      if (typeof val === 'string') givenValues.add(val);
+    }
+  }
+  const fieldsByDate = new Map<string, string[]>();
+  for (const e of eventResults) {
+    for (const [key, val] of Object.entries(e.exampleData ?? {})) {
+      if (
+        !commandFieldNames.has(key) &&
+        typeof val === 'string' &&
+        /^\d{4}-\d{2}-\d{2}$/.test(val) &&
+        !givenValues.has(val)
+      ) {
+        if (!fieldsByDate.has(val)) fieldsByDate.set(val, []);
+        fieldsByDate.get(val)!.push(key);
+      }
+    }
+  }
+  if (fieldsByDate.size !== 1) return { date: null, fields: [] };
+  const [date, fields] = [...fieldsByDate.entries()][0];
+  return { date, fields };
+}
+
+export function isKeyTraceable(key: string, value: unknown, givenEvents: EventData[] | undefined): boolean {
+  if (value === null || value === undefined || typeof value === 'object') return false;
+  for (const g of givenEvents ?? []) {
+    if ((g.exampleData ?? {})[key] === value) return true;
+  }
+  return false;
+}
+
+export function buildKeepFieldNames(
+  eventResults: EventData[],
+  commandFieldNames: Set<string>,
+  derivedDateFieldNames: string[],
+  givenEvents: EventData[] | undefined,
+): Set<string> {
+  const keep = new Set([...commandFieldNames, ...derivedDateFieldNames]);
+  for (const e of eventResults) {
+    for (const [key, value] of Object.entries(e.exampleData ?? {})) {
+      if (!keep.has(key) && isKeyTraceable(key, value, givenEvents)) {
+        keep.add(key);
+      }
+    }
+  }
+  return keep;
+}