@auto-engineer/server-generator-apollo-emmett 1.131.0 → 1.134.0

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.131.0",
-    "@auto-engineer/narrative": "1.131.0"
+    "@auto-engineer/narrative": "1.134.0",
+    "@auto-engineer/message-bus": "1.134.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.131.0"
+    "@auto-engineer/cli": "1.134.0"
   },
-  "version": "1.131.0",
+  "version": "1.134.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/data-sink.specs.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { extractStreamIdFields } from './data-sink';
+
+describe('extractStreamIdFields', () => {
+  it('extracts a single template variable from a stream pattern', () => {
+    expect(extractStreamIdFields('workouts-${id}')).toEqual(['id']);
+  });
+
+  it('extracts a different single template variable', () => {
+    expect(extractStreamIdFields('workouts-${workoutId}')).toEqual(['workoutId']);
+  });
+
+  it('extracts multiple template variables', () => {
+    expect(extractStreamIdFields('user-project-${userId}-${projectId}')).toEqual(['userId', 'projectId']);
+  });
+
+  it('returns empty array for pattern with no variables', () => {
+    expect(extractStreamIdFields('static-stream')).toEqual([]);
+  });
+
+  it('returns empty array for empty string', () => {
+    expect(extractStreamIdFields('')).toEqual([]);
+  });
+});

package/src/codegen/extract/data-sink.ts

@@ -62,6 +62,16 @@ function processStreamSink(item: unknown, exampleData: Record<string, unknown>)
   return { streamPattern, streamId };
 }
 
+export function extractStreamIdFields(pattern: string): string[] {
+  const fields: string[] = [];
+  const regex = /\$\{([^}]+)\}/g;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(pattern)) !== null) {
+    fields.push(match[1]);
+  }
+  return fields;
+}
+
 export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
   if (!('server' in slice)) return {};
   if (slice.server?.data?.items == null || !Array.isArray(slice.server.data.items)) {

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

@@ -0,0 +1,212 @@
+import type { Narrative } from '@auto-engineer/narrative';
+import { describe, expect, it } from 'vitest';
+import type { Message } from '../types';
+import { buildEventIdFieldMap } from './projection';
+
+describe('buildEventIdFieldMap', () => {
+  it('maps events to their producing slice stream id fields', () => {
+    const events: Message[] = [
+      { type: 'WorkoutCreated', fields: [] },
+      { type: 'ExerciseLogged', fields: [] },
+    ];
+
+    const flows: Narrative[] = [
+      {
+        name: 'workout-flow',
+        slices: [
+          {
+            type: 'command',
+            name: 'create-workout',
+            stream: 'workouts-${id}',
+            client: { specs: [] },
+            server: {
+              description: '',
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Create workout',
+                  rules: [
+                    {
+                      name: 'rule',
+                      examples: [
+                        {
+                          name: 'ex',
+                          steps: [
+                            { keyword: 'When', text: 'CreateWorkout', docString: { id: 'w1' } },
+                            { keyword: 'Then', text: 'WorkoutCreated', docString: { id: 'w1' } },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+          {
+            type: 'command',
+            name: 'log-exercises',
+            stream: 'workouts-${workoutId}',
+            client: { specs: [] },
+            server: {
+              description: '',
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Log exercises',
+                  rules: [
+                    {
+                      name: 'rule',
+                      examples: [
+                        {
+                          name: 'ex',
+                          steps: [
+                            { keyword: 'When', text: 'LogExercises', docString: { workoutId: 'w1' } },
+                            { keyword: 'Then', text: 'ExerciseLogged', docString: { workoutId: 'w1' } },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ];
+
+    const findEventSourceFn = (_fls: Narrative[], eventType: string) => {
+      if (eventType === 'WorkoutCreated') return { flowName: 'workout-flow', sliceName: 'create-workout' };
+      if (eventType === 'ExerciseLogged') return { flowName: 'workout-flow', sliceName: 'log-exercises' };
+      return null;
+    };
+
+    const result = buildEventIdFieldMap(events, flows, findEventSourceFn);
+    expect(result).toEqual(
+      new Map([
+        ['WorkoutCreated', 'id'],
+        ['ExerciseLogged', 'workoutId'],
+      ]),
+    );
+  });
+
+  it('returns undefined when all events share the same id field', () => {
+    const events: Message[] = [
+      { type: 'WorkoutCreated', fields: [] },
+      { type: 'WorkoutUpdated', fields: [] },
+    ];
+
+    const flows: Narrative[] = [
+      {
+        name: 'workout-flow',
+        slices: [
+          {
+            type: 'command',
+            name: 'manage-workout',
+            stream: 'workouts-${id}',
+            client: { specs: [] },
+            server: {
+              description: '',
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Manage workout',
+                  rules: [
+                    {
+                      name: 'rule',
+                      examples: [
+                        {
+                          name: 'ex1',
+                          steps: [
+                            { keyword: 'When', text: 'CreateWorkout', docString: { id: 'w1' } },
+                            { keyword: 'Then', text: 'WorkoutCreated', docString: { id: 'w1' } },
+                          ],
+                        },
+                        {
+                          name: 'ex2',
+                          steps: [
+                            { keyword: 'When', text: 'UpdateWorkout', docString: { id: 'w1' } },
+                            { keyword: 'Then', text: 'WorkoutUpdated', docString: { id: 'w1' } },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ];
+
+    const findEventSourceFn = (_fls: Narrative[], _eventType: string) => ({
+      flowName: 'workout-flow',
+      sliceName: 'manage-workout',
+    });
+
+    const result = buildEventIdFieldMap(events, flows, findEventSourceFn);
+    expect(result).toEqual(
+      new Map([
+        ['WorkoutCreated', 'id'],
+        ['WorkoutUpdated', 'id'],
+      ]),
+    );
+  });
+
+  it('returns undefined when no producing slice is found', () => {
+    const events: Message[] = [{ type: 'UnknownEvent', fields: [] }];
+    const flows: Narrative[] = [];
+    const findEventSourceFn = () => null;
+
+    const result = buildEventIdFieldMap(events, flows, findEventSourceFn);
+    expect(result).toEqual(undefined);
+  });
+
+  it('skips events from slices with composite keys', () => {
+    const events: Message[] = [{ type: 'UserJoined', fields: [] }];
+
+    const flows: Narrative[] = [
+      {
+        name: 'flow',
+        slices: [
+          {
+            type: 'command',
+            name: 'join',
+            stream: 'membership-${userId}-${projectId}',
+            client: { specs: [] },
+            server: {
+              description: '',
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Join',
+                  rules: [
+                    {
+                      name: 'rule',
+                      examples: [
+                        {
+                          name: 'ex',
+                          steps: [
+                            { keyword: 'When', text: 'Join', docString: { userId: 'u1', projectId: 'p1' } },
+                            { keyword: 'Then', text: 'UserJoined', docString: { userId: 'u1', projectId: 'p1' } },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ];
+
+    const findEventSourceFn = () => ({ flowName: 'flow', sliceName: 'join' });
+
+    const result = buildEventIdFieldMap(events, flows, findEventSourceFn);
+    expect(result).toEqual(undefined);
+  });
+});

package/src/codegen/extract/projection.ts

@@ -1,4 +1,6 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Narrative, Slice } from '@auto-engineer/narrative';
+import type { Message } from '../types';
+import { extractStreamIdFields } from './data-sink';
 
 interface ProjectionOrigin {
   type: 'projection';
@@ -58,6 +60,25 @@ export function extractProjectionName(slice: Slice): string | undefined {
   return extractProjectionField(slice, 'name');
 }
 
+export function buildEventIdFieldMap(
+  events: Message[],
+  flows: Narrative[],
+  findEventSourceFn: (flows: Narrative[], eventType: string) => { flowName: string; sliceName: string } | null,
+): Map<string, string> | undefined {
+  const map = new Map<string, string>();
+  for (const event of events) {
+    const source = findEventSourceFn(flows, event.type);
+    if (!source) continue;
+    const slice = flows.find((f) => f.name === source.flowName)?.slices.find((s) => s.name === source.sliceName);
+    if (!slice || typeof slice.stream !== 'string') continue;
+    const fields = extractStreamIdFields(slice.stream);
+    if (fields.length === 1) {
+      map.set(event.type, fields[0]);
+    }
+  }
+  return map.size > 0 ? map : undefined;
+}
+
 export function extractProjectionSingleton(slice: Slice): boolean {
   if (!('server' in slice)) return false;
   const dataSource = slice.server?.data?.items?.[0];

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

@@ -0,0 +1,137 @@
+import type { MappingEntry } from '@auto-engineer/narrative';
+import { describe, expect, it } from 'vitest';
+import { buildArgToStateFieldMap, type QueryGwtCondition } from './query';
+
+describe('buildArgToStateFieldMap', () => {
+  it('maps arg to state field via matching example data values', () => {
+    const queryGwtMapping: QueryGwtCondition[] = [
+      {
+        description: 'fetch workout by workoutId',
+        when: {
+          queryAction: 'GetWorkout',
+          args: { workoutId: 'w1' },
+        },
+        then: [{ stateRef: 'WorkoutView', exampleData: { id: 'w1', name: 'Leg Day' } }],
+      },
+    ];
+    const stateFieldNames = new Set(['id', 'name']);
+
+    const result = buildArgToStateFieldMap(queryGwtMapping, stateFieldNames);
+    expect(result).toEqual({ workoutId: { field: 'id', operator: 'eq' } });
+  });
+
+  it('skips args that already match state field names', () => {
+    const queryGwtMapping: QueryGwtCondition[] = [
+      {
+        description: 'fetch by id',
+        when: {
+          queryAction: 'GetItem',
+          args: { id: 'item1' },
+        },
+        then: [{ stateRef: 'ItemView', exampleData: { id: 'item1', title: 'Test' } }],
+      },
+    ];
+    const stateFieldNames = new Set(['id', 'title']);
+
+    const result = buildArgToStateFieldMap(queryGwtMapping, stateFieldNames);
+    expect(result).toEqual({});
+  });
+
+  it('returns empty map when no GWT data has query actions', () => {
+    const queryGwtMapping: QueryGwtCondition[] = [
+      {
+        description: 'event-driven query',
+        when: [{ eventRef: 'SomeEvent', exampleData: { id: '1' } }],
+        then: [{ stateRef: 'SomeState', exampleData: { id: '1' } }],
+      },
+    ];
+    const stateFieldNames = new Set(['id']);
+
+    const result = buildArgToStateFieldMap(queryGwtMapping, stateFieldNames);
+    expect(result).toEqual({});
+  });
+
+  it('returns empty map when GWT mapping is empty', () => {
+    const result = buildArgToStateFieldMap([], new Set(['id']));
+    expect(result).toEqual({});
+  });
+
+  it('uses explicit mapping with operator', () => {
+    const mappings: MappingEntry[] = [
+      {
+        source: { type: 'Query', name: 'SearchListings', field: 'minBedrooms' },
+        target: { type: 'State', name: 'SearchResult', field: 'numBedrooms' },
+        operator: 'gte',
+      },
+    ];
+    const stateFieldNames = new Set(['numBedrooms', 'price']);
+
+    const result = buildArgToStateFieldMap([], stateFieldNames, mappings);
+    expect(result).toEqual({ minBedrooms: { field: 'numBedrooms', operator: 'gte' } });
+  });
+
+  it('defaults to eq when explicit mapping has no operator', () => {
+    const mappings: MappingEntry[] = [
+      {
+        source: { type: 'Query', name: 'GetWorkout', field: 'workoutId' },
+        target: { type: 'State', name: 'WorkoutView', field: 'id' },
+      },
+    ];
+    const stateFieldNames = new Set(['id', 'name']);
+
+    const result = buildArgToStateFieldMap([], stateFieldNames, mappings);
+    expect(result).toEqual({ workoutId: { field: 'id', operator: 'eq' } });
+  });
+
+  it('explicit mapping takes priority over GWT value match', () => {
+    const mappings: MappingEntry[] = [
+      {
+        source: { type: 'Query', name: 'SearchListings', field: 'minPrice' },
+        target: { type: 'State', name: 'Listing', field: 'pricePerNight' },
+        operator: 'gte',
+      },
+    ];
+    const queryGwtMapping: QueryGwtCondition[] = [
+      {
+        description: 'search by price',
+        when: {
+          queryAction: 'SearchListings',
+          args: { minPrice: 100 },
+        },
+        then: [{ stateRef: 'Listing', exampleData: { pricePerNight: 100, title: 'Beach House' } }],
+      },
+    ];
+    const stateFieldNames = new Set(['pricePerNight', 'title']);
+
+    const result = buildArgToStateFieldMap(queryGwtMapping, stateFieldNames, mappings);
+    expect(result).toEqual({ minPrice: { field: 'pricePerNight', operator: 'gte' } });
+  });
+
+  it('skips explicit mappings where target field is not in state', () => {
+    const mappings: MappingEntry[] = [
+      {
+        source: { type: 'Query', name: 'Search', field: 'minPrice' },
+        target: { type: 'State', name: 'Result', field: 'nonExistentField' },
+        operator: 'gte',
+      },
+    ];
+    const stateFieldNames = new Set(['price', 'title']);
+
+    const result = buildArgToStateFieldMap([], stateFieldNames, mappings);
+    expect(result).toEqual({});
+  });
+
+  it('skips explicit mappings where source type is not Query', () => {
+    const mappings: MappingEntry[] = [
+      {
+        source: { type: 'Command', name: 'CreateItem', field: 'id' },
+        target: { type: 'State', name: 'Item', field: 'id' },
+        operator: 'eq',
+      },
+    ];
+    const stateFieldNames = new Set(['id']);
+
+    const result = buildArgToStateFieldMap([], stateFieldNames, mappings);
+    expect(result).toEqual({});
+  });
+});

package/src/codegen/extract/query.ts

@@ -1,8 +1,15 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { MappingEntry, Slice } from '@auto-engineer/narrative';
 import type { EventRef, StateRef } from '../types';
 import { extractGwtFromSpecs, isQueryAction, type QueryActionRef } from './step-converter';
 
-interface QueryGwtCondition {
+type FilterOperator = NonNullable<MappingEntry['operator']>;
+
+export interface ArgMapping {
+  field: string;
+  operator: FilterOperator;
+}
+
+export interface QueryGwtCondition {
   description: string;
   given?: EventRef[];
   when: EventRef[] | QueryActionRef;
@@ -34,3 +41,40 @@ export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
     };
   });
 }
+
+export function buildArgToStateFieldMap(
+  queryGwtMapping: QueryGwtCondition[],
+  stateFieldNames: Set<string>,
+  mappings?: MappingEntry[],
+): Record<string, ArgMapping> {
+  const map: Record<string, ArgMapping> = {};
+
+  if (mappings) {
+    for (const mapping of mappings) {
+      if (mapping.source.type !== 'Query') continue;
+      if (!stateFieldNames.has(mapping.target.field)) continue;
+      map[mapping.source.field] = {
+        field: mapping.target.field,
+        operator: mapping.operator ?? 'eq',
+      };
+    }
+  }
+
+  for (const gwt of queryGwtMapping) {
+    if (!isQueryAction(gwt.when)) continue;
+    const args = gwt.when.args;
+    const stateExample = gwt.then[0]?.exampleData;
+    if (!args || !stateExample) continue;
+    for (const [argName, argValue] of Object.entries(args)) {
+      if (stateFieldNames.has(argName)) continue;
+      if (map[argName]) continue;
+      for (const [fieldName, fieldValue] of Object.entries(stateExample)) {
+        if (stateFieldNames.has(fieldName) && argValue === fieldValue) {
+          map[argName] = { field: fieldName, operator: 'eq' };
+          break;
+        }
+      }
+    }
+  }
+  return map;
+}

package/src/codegen/scaffoldFromSchema.ts

@@ -43,6 +43,8 @@ import {
   sanitizeFieldType,
 } from './extract';
 import { getStreamFromSink } from './extract/data-sink';
+import { buildEventIdFieldMap } from './extract/projection';
+import { buildArgToStateFieldMap } from './extract/query';
 import { normalizeSliceForTemplate } from './extract/slice-normalizer';
 import { extractGwtSpecsFromSlice, type GwtResult } from './extract/step-converter';
 import type { GwtCondition, Message, MessageDefinition } from './types';
@@ -635,6 +637,7 @@ async function prepareTemplateData(
   projectionSingleton: boolean | undefined,
   allMessages?: MessageDefinition[],
   integrations?: Model['integrations'],
+  flows?: Narrative[],
 ): Promise<Record<string, unknown>> {
   debug('Preparing template data for slice: %s (flow: %s)', slice.name, flow.name);
   debug('  Commands: %d', commands.length);
@@ -699,6 +702,13 @@ async function prepareTemplateData(
     }
   }
 
+  const eventIdFieldMap =
+    slice.type === 'query' && flows ? buildEventIdFieldMap(events, flows, findEventSource) : undefined;
+
+  const stateFieldNames = new Set((queryMessage?.fields ?? []).map((f) => f.name));
+  const argToStateFieldMap =
+    slice.type === 'query' ? buildArgToStateFieldMap(queryGwtMapping, stateFieldNames, slice.mappings) : undefined;
+
   return {
     flowName: flow.name,
     sliceName: slice.name,
@@ -727,6 +737,8 @@ async function prepareTemplateData(
     localEvents,
     referencedTypes,
     eventCommandPairs,
+    eventIdFieldMap,
+    argToStateFieldMap,
   };
 }
 
@@ -903,6 +915,7 @@ async function generateFilesForSlice(
     extracted.projectionSingleton,
     messages,
     integrations,
+    flows,
   );
 
   debugSlice('  Generating %d files from templates', filteredTemplates.length);