@auto-engineer/server-generator-apollo-emmett 1.147.0 → 1.149.0

package/ketchup-plan.md

@@ -1,8 +1,10 @@
-# Ketchup Plan: Fix G1 + G2 Generator Bugs
+# Ketchup Plan: G4 — Fix remaining decide.ts implementer failures
 
 ## TODO
 
 ## DONE
 
-- [x] Burst 1+2: G1 — filter state refs from given() in decide.specs.ts.ejs + tests (fc8b7961)
-- [x] Burst 3+4: G2 — skip empty file plans in scaffoldFromSchema.ts + test (bf8c92ac)
+- [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/message-bus": "1.147.0",
-    "@auto-engineer/narrative": "1.147.0"
+    "@auto-engineer/narrative": "1.149.0",
+    "@auto-engineer/message-bus": "1.149.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.147.0"
+    "@auto-engineer/cli": "1.149.0"
   },
-  "version": "1.147.0",
+  "version": "1.149.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/scaffoldFromSchema.ts

@@ -47,6 +47,7 @@ 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);

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;
+}