@auto-engineer/server-generator-apollo-emmett 1.110.0 → 1.110.2

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.110.0",
-    "@auto-engineer/message-bus": "1.110.0"
+    "@auto-engineer/narrative": "1.110.2",
+    "@auto-engineer/message-bus": "1.110.2"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.110.0"
+    "@auto-engineer/cli": "1.110.2"
   },
-  "version": "1.110.0",
+  "version": "1.110.2",
   "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

@@ -374,6 +374,102 @@ describe('extractMessagesFromSpecs (command slice)', () => {
   });
 });
 
+describe('extractMessagesFromSpecs (query slice)', () => {
+  it('should not include non-event When steps in the events list', () => {
+    const slice: Slice = {
+      type: 'query',
+      name: 'views workout details',
+      server: {
+        description: 'Shows workout details',
+        data: {
+          items: [
+            {
+              origin: {
+                type: 'projection',
+                idField: 'workoutId',
+                name: 'WorkoutDetailsProjection',
+              },
+              target: {
+                type: 'State',
+                name: 'WorkoutDetails',
+              },
+            },
+          ],
+        },
+        specs: [
+          {
+            type: 'gherkin',
+            feature: 'Workout details query',
+            rules: [
+              {
+                name: 'Should show workout details',
+                examples: [
+                  {
+                    name: 'Workout details shown',
+                    steps: [
+                      {
+                        keyword: 'Given',
+                        text: 'WorkoutLogged',
+                        docString: { workoutId: 'wkt_001', exercise: 'squat' },
+                      },
+                      {
+                        keyword: 'When',
+                        text: 'GetWorkoutDetails',
+                        docString: {},
+                      },
+                      {
+                        keyword: 'Then',
+                        text: 'WorkoutDetails',
+                        docString: { workoutId: 'wkt_001', exercise: 'squat' },
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const allMessages: MessageDefinition[] = [
+      {
+        type: 'event',
+        name: 'WorkoutLogged',
+        fields: [
+          { name: 'workoutId', type: 'string', required: true },
+          { name: 'exercise', type: 'string', required: true },
+        ],
+      },
+      {
+        type: 'state',
+        name: 'WorkoutDetails',
+        fields: [
+          { name: 'workoutId', type: 'string', required: true },
+          { name: 'exercise', type: 'string', required: true },
+        ],
+      },
+    ];
+
+    const result = extractMessagesFromSpecs(slice, allMessages);
+
+    expect(result.events).toEqual([
+      {
+        type: 'WorkoutLogged',
+        fields: [
+          { name: 'workoutId', tsType: 'string', required: true },
+          { name: 'exercise', tsType: 'string', required: true },
+        ],
+        source: 'given',
+        sourceFlowName: undefined,
+        sourceSliceName: undefined,
+      },
+    ]);
+
+    expect(result.events.some((e) => e.type === 'GetWorkoutDetails')).toBe(false);
+  });
+});
+
 describe('extractMessagesFromSpecs (react slice with data target events)', () => {
   it('should extract data target events with source then', () => {
     const slice: Slice = {

package/src/codegen/extract/messages.ts

@@ -132,19 +132,21 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
   const events: Message[] = gwtSpecs.flatMap((gwt) => {
     const eventsFromWhen: EventRef[] = Array.isArray(gwt.when) ? gwt.when : [];
     const givenEvents = extractEventsFromGiven(gwt.given, allMessages);
-    const whenEvents: Message[] = eventsFromWhen.map((eventExample) => {
-      const fields = extractFieldsFromMessage(eventExample.eventRef, 'event', allMessages);
-      const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventExample.eventRef);
-      const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
-
-      return {
-        type: eventExample.eventRef,
-        fields,
-        source: 'when',
-        sourceFlowName: metadata?.sourceFlowName,
-        sourceSliceName: metadata?.sourceSliceName,
-      };
-    });
+    const whenEvents: Message[] = eventsFromWhen
+      .filter((eventExample) => allMessages.some((m) => m.type === 'event' && m.name === eventExample.eventRef))
+      .map((eventExample) => {
+        const fields = extractFieldsFromMessage(eventExample.eventRef, 'event', allMessages);
+        const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventExample.eventRef);
+        const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
+
+        return {
+          type: eventExample.eventRef,
+          fields,
+          source: 'when',
+          sourceFlowName: metadata?.sourceFlowName,
+          sourceSliceName: metadata?.sourceSliceName,
+        };
+      });
 
     return [...givenEvents, ...whenEvents];
   });

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

@@ -477,4 +477,106 @@ describe('generateScaffoldFilePlans', () => {
       "
     `);
   });
+  it('should generate randomUUID for stream vars not in any command', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Fitness tracker',
+          slices: [
+            {
+              type: 'command',
+              name: 'Log workout',
+              stream: 'workouts-${workoutId}',
+              client: { specs: [] },
+              server: {
+                description: 'test',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Workout logged',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { exercise: 'squat', reps: 10 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: { exercise: 'squat', reps: 10 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'WorkoutLogged' },
+                      destination: { type: 'stream', pattern: 'workouts-${workoutId}' },
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogWorkout',
+          fields: [
+            { name: 'exercise', type: 'string', required: true },
+            { name: 'reps', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'WorkoutLogged',
+          source: 'internal',
+          fields: [
+            { name: 'exercise', type: 'string', required: true },
+            { name: 'reps', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const handleFile = plans.find((p) => p.outputPath.endsWith('handle.ts'));
+
+    expect(handleFile?.contents).toMatchInlineSnapshot(`
+      "import { randomUUID } from 'crypto';
+
+      import { CommandHandler, type EventStore, type MessageHandlerResult } from '@event-driven-io/emmett';
+      import { evolve } from './evolve';
+      import { initialState } from './state';
+      import { decide } from './decide';
+      import type { LogWorkout } from './commands';
+
+      const handler = CommandHandler({
+        evolve,
+        initialState,
+      });
+
+      export const handle = async (eventStore: EventStore, command: LogWorkout): Promise<MessageHandlerResult> => {
+        const streamId = \`workouts-\${randomUUID()}\`;
+
+        await handler(eventStore, streamId, (state) => decide(command, state));
+        return undefined;
+      };
+      "
+    `);
+  });
 });

package/src/codegen/templates/command/handle.ts.ejs

@@ -63,8 +63,14 @@ while ((svMatch = svRegex.exec(streamPatternStr)) !== null) {
 }
 const allCmdFieldSets = commands.map(c => new Set((c.fields ?? []).map(f => f.name)));
 const needsStreamGuard = streamVars.length > 0 && !allCmdFieldSets.every(fs => streamVars.every(v => fs.has(v)));
+const varInAnyCommand = (v) => allCmdFieldSets.some(fs => fs.has(v));
+const guardVars = needsStreamGuard ? streamVars.filter(v => varInAnyCommand(v)) : [];
+const uuidVars = needsStreamGuard ? streamVars.filter(v => !varInAnyCommand(v)) : [];
 %>
 
+<% if (uuidVars.length > 0) { -%>
+import { randomUUID } from 'crypto';
+<% } -%>
 <% integrationSideEffectImports.forEach((importSource) => { %>
     import '<%= importSource %>';
 <% }); %>
@@ -96,16 +102,21 @@ eventStore: EventStore,
 command: <%= commands.map(c => pascalCase(c.type)).join(' | ') %>
 ): Promise<MessageHandlerResult> => {
     <% if (stream?.pattern?.includes('${')) { -%>
-        <% if (needsStreamGuard) { -%>
-            const commandData = command.data;
-            <% for (const v of streamVars) { -%>
-                if (!('<%= v %>' in commandData)) {
-                    throw new Error('Cannot determine stream: "<%= v %>" not in command data');
-                }
-            <% } -%>
-            const streamId = `<%= stream.pattern.replace(/\$\{([^}]+)\}/g, (_, key) => `\${commandData.${key}}`) %>`;
-        <% } else { -%>
+        <% if (!needsStreamGuard) { -%>
             const streamId = `<%= stream.pattern.replace(/\$\{([^}]+)\}/g, (_, key) => `\${command.data.${key}}`) %>`;
+        <% } else { -%>
+            <% if (guardVars.length > 0) { -%>
+                const commandData = command.data;
+                <% for (const v of guardVars) { -%>
+                    if (!('<%= v %>' in commandData)) {
+                        throw new Error('Cannot determine stream: "<%= v %>" not in command data');
+                    }
+                <% } -%>
+            <% } -%>
+            const streamId = `<%= stream.pattern.replace(/\$\{([^}]+)\}/g, (_, key) => {
+                if (varInAnyCommand(key)) return '${commandData.' + key + '}';
+                return '${randomUUID()}';
+            }) %>`;
         <% } -%>
     <% } else { -%>
         const streamId = '<%= stream?.pattern ?? 'unknown-stream' %>';

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

@@ -114,9 +114,9 @@ describe('query.resolver.ts.ejs', () => {
           return model.find((item) => {
             if (location !== undefined && item.location !== location) return false;
 
-            if (maxPrice !== undefined && item.maxPrice !== maxPrice) return false;
+            // TODO: 'maxPrice' has no matching field on the state type — implement custom filter logic.
 
-            if (minGuests !== undefined && item.minGuests !== minGuests) return false;
+            // TODO: 'minGuests' has no matching field on the state type — implement custom filter logic.
 
             return true;
           });
@@ -935,7 +935,7 @@ describe('query.resolver.ts.ejs', () => {
           // If this query should return a single item, switch to findOne().
 
           return model.find((item) => {
-            if (pantryId !== undefined && item.pantryId !== pantryId) return false;
+            // TODO: 'pantryId' has no matching field on the state type — implement custom filter logic.
 
             return true;
           });
@@ -1177,7 +1177,7 @@ describe('query.resolver.ts.ejs', () => {
           // If this query should return a single item, switch to findOne().
 
           return model.find((item) => {
-            if (pantryId !== undefined && item.pantryId !== pantryId) return false;
+            // TODO: 'pantryId' has no matching field on the state type — implement custom filter logic.
 
             return true;
           });

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

@@ -165,9 +165,15 @@ const model = new ReadModel<<%= viewType %>>(ctx.database, '<%= collectionName %
 
 return model.find((<%= hasArgs ? 'item' : '_item' %>) => {
 <% if (parsedRequest?.args?.length) {
-        for (const arg of parsedRequest.args) { %>
+        const stateFieldNames = new Set(messageFields.map(f => f.name));
+        for (const arg of parsedRequest.args) {
+            if (stateFieldNames.has(arg.name)) { %>
     if (<%= arg.name %> !== undefined && item.<%= arg.name %> !== <%= arg.name %>) return false;
-<% } } %>
+<%          } else { %>
+    // TODO: '<%= arg.name %>' has no matching field on the state type — implement custom filter logic.
+<%          }
+        }
+} %>
 return true;
 });
 }

package/src/codegen/templates/react/react.specs.ts.ejs

@@ -132,11 +132,32 @@ describe('<%= ruleDescription %>', () => {
     }]);
 <%    }
     }
+-%>
+<%
+    const eventSchema = events.find(e => e.type === exampleEvent.eventRef);
+    const mergedEventData = { ...(exampleEvent.exampleData || {}) };
+    const eventFieldNames = new Set((eventSchema?.fields || []).map(f => f.name));
+    for (const cmd of thenCommands) {
+        for (const [key, value] of Object.entries(cmd.exampleData || {})) {
+            if (!(key in mergedEventData) && eventFieldNames.has(key)) {
+                mergedEventData[key] = value;
+            }
+        }
+    }
+    for (const field of (eventSchema?.fields || [])) {
+        if (!(field.name in mergedEventData)) {
+            const tsType = field.tsType || field.type || 'string';
+            if (tsType === 'number') mergedEventData[field.name] = 0;
+            else if (tsType === 'boolean') mergedEventData[field.name] = false;
+            else if (!tsType.includes('{') && !tsType.includes('[]') && !tsType.includes('Array'))
+                mergedEventData[field.name] = `test-${field.name}`;
+        }
+    }
 -%>
     await given([])
       .when({
         type: '<%= exampleEvent.eventRef %>',
-        data: <%- formatDataObject(exampleEvent.exampleData, events.find(e => e.type === exampleEvent.eventRef)) %>
+        data: <%- formatDataObject(mergedEventData, eventSchema) %>
       })
 <% if (thenCommands.length === 1) {
     const commandSchema = thenCommands[0];