@auto-engineer/server-generator-apollo-emmett 1.155.0 → 1.156.0

package/dist/src/codegen/templates/command/decide.specs.specs.ts

@@ -2793,4 +2793,129 @@ describe('spec.ts.ejs', () => {
       "
     `);
   });
+
+  it('should use preceding sibling events for state-ref Given on shared stream', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Gym session',
+          moments: [
+            {
+              type: 'command',
+              name: 'Start session',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'SessionStarted' },
+                      destination: { type: 'stream', pattern: 'sessions-${id}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Start session',
+                    rules: [
+                      {
+                        name: 'Start session',
+                        examples: [
+                          {
+                            name: 'Start session example',
+                            steps: [
+                              { keyword: 'When', text: 'StartSession', docString: { userId: 'u1' } },
+                              { keyword: 'Then', text: 'SessionStarted', docString: { id: 's1', userId: 'u1' } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'command',
+              name: 'Complete session',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'SessionCompleted' },
+                      destination: { type: 'stream', pattern: 'sessions-${sessionId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Complete session',
+                    rules: [
+                      {
+                        name: 'Complete session',
+                        examples: [
+                          {
+                            name: 'Complete session example',
+                            steps: [
+                              { keyword: 'Given', text: 'ActiveSession', docString: { status: 'active' } },
+                              { keyword: 'When', text: 'CompleteSession', docString: { sessionId: 's1' } },
+                              {
+                                keyword: 'Then',
+                                text: 'SessionCompleted',
+                                docString: { sessionId: 's1', completedAt: '2024-01-15' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        { type: 'command', name: 'StartSession', fields: [{ name: 'userId', type: 'string', required: true }] },
+        { type: 'command', name: 'CompleteSession', fields: [{ name: 'sessionId', type: 'string', required: true }] },
+        {
+          type: 'event',
+          name: 'SessionStarted',
+          source: 'internal',
+          fields: [
+            { name: 'id', type: 'string', required: true },
+            { name: 'userId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'SessionCompleted',
+          source: 'internal',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'completedAt', type: 'string', required: true },
+          ],
+        },
+        { type: 'state', name: 'ActiveSession', fields: [{ name: 'status', type: 'string', required: true }] },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+
+    const completeSpecs = plans.find(
+      (p) => p.outputPath.includes('complete-session') && p.outputPath.endsWith('decide.specs.ts'),
+    );
+    const contents = completeSpecs?.contents ?? '';
+
+    expect(contents).toContain("import type { SessionStarted } from '../start-session/events';");
+    expect(contents).toContain("type: 'SessionStarted'");
+    expect(contents).toContain("id: 's1'");
+    expect(contents).toContain("userId: 'u1'");
+  });
 });

package/dist/src/codegen/templates/command/decide.specs.ts

@@ -593,7 +593,7 @@ describe('decide.ts.ejs', () => {
       import type { ItemsSuggested } from './events';
       import type { Products } from '@auto-engineer/product-catalogue-integration';
 
-      export const decide = (command: SuggestItems, _state: State, products?: Products): ItemsSuggested => {
+      export const decide = (command: SuggestItems, _state: State, context?: { products?: Products }): ItemsSuggested => {
         switch (command.type) {
           case 'SuggestItems': {
             /**
@@ -604,7 +604,7 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
-          * - Use \`products\` (integration result) to enrich or filter the output
+          * - Use \`context?.products\` (integration result) to enrich or filter the output
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
@@ -613,7 +613,7 @@ describe('decide.ts.ejs', () => {
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
           *
           * Integration result shape (Products):
-          * products?.data = {
+          * context?.products?.data = {
           *   products: Array<{
       *     id: string;
       *     name: string;
@@ -648,4 +648,259 @@ describe('decide.ts.ejs', () => {
       "
     `);
   });
+
+  it('should generate context parameter and uuid assignment for stream uuid vars that are event fields', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Fitness tracker',
+          moments: [
+            {
+              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: { workoutId: 'wk-1', 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: 'workoutId', type: 'string', required: true },
+            { name: 'exercise', type: 'string', required: true },
+            { name: 'reps', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find((p) => p.outputPath.endsWith('decide.ts'));
+
+    expect(decideFile?.contents).toMatchInlineSnapshot(`
+      "import { randomUUID } from 'node:crypto';
+      import { IllegalStateError } from '@event-driven-io/emmett';
+      import type { State } from './state';
+      import type { LogWorkout } from './commands';
+      import type { WorkoutLogged } from './events';
+
+      export const decide = (
+        command: LogWorkout,
+        _state: State,
+        context?: { generated?: { workoutId: string } },
+      ): WorkoutLogged => {
+        switch (command.type) {
+          case 'LogWorkout': {
+            /**
+      * ## IMPLEMENTATION INSTRUCTIONS ##
+      *
+      * This command can directly emit one or more events based on the input.
+      *
+      * You should:
+      * - Validate the command input fields
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
+      *   ⚠️ Error constructors: IllegalStateError takes a string message
+      * - If valid, return one or more events with the correct structure
+      *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
+      * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
+
+      * Business rules:
+      *   - Should log workout
+      */
+
+            const workoutId = context?.generated?.workoutId ?? randomUUID();
+
+            // IMPLEMENT: Use a typed variable to prevent type widening:
+            // const result: WorkoutLogged = {
+            //   type: 'WorkoutLogged',
+            //   data: { ...command.data, workoutId },
+            // };
+            // return result;
+
+            throw new IllegalStateError('Not yet implemented: ' + command.type);
+          }
+          default:
+            throw new IllegalStateError('Unexpected command type');
+        }
+      };
+      "
+    `);
+  });
+
+  it('should say Inspect _state for state-ref Given with preceding siblings', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Gym session',
+          moments: [
+            {
+              type: 'command',
+              name: 'Start session',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'SessionStarted' },
+                      destination: { type: 'stream', pattern: 'sessions-${id}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Start',
+                    rules: [
+                      {
+                        name: 'Start',
+                        examples: [
+                          {
+                            name: 'Start',
+                            steps: [
+                              { keyword: 'When', text: 'StartSession', docString: { userId: 'u1' } },
+                              { keyword: 'Then', text: 'SessionStarted', docString: { id: 's1', userId: 'u1' } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'command',
+              name: 'Complete session',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'SessionCompleted' },
+                      destination: { type: 'stream', pattern: 'sessions-${sessionId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Complete',
+                    rules: [
+                      {
+                        name: 'Complete',
+                        examples: [
+                          {
+                            name: 'Complete',
+                            steps: [
+                              { keyword: 'Given', text: 'ActiveSession', docString: { status: 'active' } },
+                              { keyword: 'When', text: 'CompleteSession', docString: { sessionId: 's1' } },
+                              {
+                                keyword: 'Then',
+                                text: 'SessionCompleted',
+                                docString: { sessionId: 's1', completedAt: '2024-01-15' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        { type: 'command', name: 'StartSession', fields: [{ name: 'userId', type: 'string', required: true }] },
+        { type: 'command', name: 'CompleteSession', fields: [{ name: 'sessionId', type: 'string', required: true }] },
+        {
+          type: 'event',
+          name: 'SessionStarted',
+          source: 'internal',
+          fields: [
+            { name: 'id', type: 'string', required: true },
+            { name: 'userId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'SessionCompleted',
+          source: 'internal',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'completedAt', type: 'string', required: true },
+          ],
+        },
+        { type: 'state', name: 'ActiveSession', fields: [{ name: 'status', type: 'string', required: true }] },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find(
+      (p) => p.outputPath.includes('complete-session') && p.outputPath.endsWith('decide.ts'),
+    );
+    const contents = decideFile?.contents ?? '';
+
+    expect(contents).toContain('requires evaluating prior state');
+    expect(contents).toContain('Inspect the current domain');
+    expect(contents).not.toContain('succeed from initial state');
+  });
 });

package/dist/src/codegen/templates/command/decide.specs.ts.ejs

@@ -1,6 +1,7 @@
 <%
 const allEvents = [];
 const ruleGroups = new Map();
+const _stateRefGivenSeen = new Set();
 for (const commandName in gwtMapping) {
     const cases = gwtMapping[commandName];
     for (const gwt of cases) {
@@ -12,8 +13,17 @@ for (const commandName in gwtMapping) {
         if (gwt.given && gwt.given.length) {
             for (const g of gwt.given) {
                 if (g.eventRef) {
-                    const event = events.find(e => e.type === g.eventRef);
-                    if (event) allEvents.push(event);
+                    const event = allStreamEvents.find(e => e.type === g.eventRef);
+                    if (event) {
+                        allEvents.push(event);
+                    } else if (precedingSiblingEvents.length > 0 && !_stateRefGivenSeen.has(g.eventRef)) {
+                        _stateRefGivenSeen.add(g.eventRef);
+                        for (const se of precedingSiblingEvents) {
+                            if (!allEvents.some(e => e.type === se.type)) {
+                                allEvents.push(se);
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -33,7 +43,7 @@ const testEventsByPath = new Map();
 
 for (const event of allEvents) {
     if (!event.type) continue;
-    const importGroup = eventImportGroups.find(group =>
+    const importGroup = allStreamEventImportGroups.find(group =>
         group.eventTypes.includes(event.type)
     );
 
@@ -64,7 +74,7 @@ for (const commandName in gwtMapping) {
         const eventResults = gwt.then.filter(t => 'eventRef' in t);
         const errorResult = gwt.then.find(t => 'errorType' in t);
         if (errorResult) continue;
-        const givenEventRefs = (gwt.given || []).filter(g => events.some(ev => ev.type === g.eventRef));
+        const givenEventRefs = (gwt.given || []).filter(g => allStreamEvents.some(ev => ev.type === g.eventRef));
         for (const e of eventResults) {
             const dedupeKey = `${commandName}::${e.eventRef}`;
             if (seenCommandEvents.has(dedupeKey)) continue;
@@ -116,12 +126,22 @@ describe('<%= escapeJsString(ruleDescription) %>', () => {
 %>
   it('<%= escapeJsString(testDescription) %>', () => {
     given([
-<%_ const givenEvents = (gwt.given || []).filter(g => events.some(e => e.type === g.eventRef)); _%>
+<%_
+    let givenEvents = (gwt.given || []).filter(g => allStreamEvents.some(e => e.type === g.eventRef));
+    const hasStateRefGiven = (gwt.given || []).some(g => !allStreamEvents.some(e => e.type === g.eventRef));
+    if (givenEvents.length === 0 && hasStateRefGiven && precedingSiblingEvents.length > 0) {
+        givenEvents = precedingSiblingEvents;
+    }
+_%>
 <%_ if (givenEvents.length) { _%>
-      <%- givenEvents.map(g => `{
-        type: '${g.eventRef}',
-        data: ${formatDataObject(g.exampleData, events.find(e => e.type === g.eventRef))}
-      }`).join(',\n      ') %>
+      <%- givenEvents.map(g => {
+          const schema = allStreamEvents.find(e => e.type === (g.eventRef || g.type));
+          const data = g.exampleData || siblingExampleData[g.type] || {};
+          return `{
+        type: '${g.eventRef || g.type}',
+        data: ${formatDataObject(data, schema)}
+      }`;
+      }).join(',\n      ') %>
 <%_ } _%>
     ])
       .when({
@@ -171,7 +191,11 @@ describe('field completeness', () => {
     const firstScenario = scenarios[0];
     const gwt = firstScenario.gwt;
     const schema = commandSchemasByName[cmdName];
-    const givenEvents = (gwt.given || []).filter(g => events.some(e => e.type === g.eventRef));
+    let givenEvents = (gwt.given || []).filter(g => allStreamEvents.some(e => e.type === g.eventRef));
+    const hasStateRefGiven = (gwt.given || []).some(g => !allStreamEvents.some(e => e.type === g.eventRef));
+    if (givenEvents.length === 0 && hasStateRefGiven && precedingSiblingEvents.length > 0) {
+        givenEvents = precedingSiblingEvents;
+    }
     const example = gwt.when;
     const cmdFieldNames = firstScenario.cmdFieldNames;
     const filteredCmdData = Object.fromEntries(
@@ -181,10 +205,14 @@ describe('field completeness', () => {
   it('should include all required fields in <%= scenarios.map(s => s.eventRef).join(', ') %>', () => {
 <%_ if (givenEvents.length) { _%>
     const state = [
-      <%- givenEvents.map(g => `{
-        type: '${g.eventRef}' as const,
-        data: ${formatDataObject(g.exampleData, events.find(e => e.type === g.eventRef))}
-      }`).join(',\n      ') %>
+      <%- givenEvents.map(g => {
+          const schema = allStreamEvents.find(e => e.type === (g.eventRef || g.type));
+          const data = g.exampleData || siblingExampleData[g.type] || {};
+          return `{
+        type: '${g.eventRef || g.type}' as const,
+        data: ${formatDataObject(data, schema)}
+      }`;
+      }).join(',\n      ') %>
     ].reduce((s, e) => evolve(s, e), initialState());
 <%_ } else { _%>
     const state = initialState();