@auto-engineer/server-generator-apollo-emmett 1.124.0 → 1.125.1

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

@@ -217,7 +217,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
               },
             })
 
-            .then({
+            .thenSends({
               type: 'NotifyHost',
               kind: 'Command',
               data: {
@@ -457,7 +457,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
     expect(specFile?.contents).toContain('type ReactorCommand = SendNotification;');
     expect(specFile?.contents).not.toContain('MilestoneNotified');
     expect(specFile?.contents).toContain("type: 'SendNotification'");
-    expect(specFile?.contents).toContain('.then({');
+    expect(specFile?.contents).toContain('.thenSends({');
   });
 
   it('should seed event store with Given state data via appendToStream', async () => {
@@ -637,7 +637,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
               },
             })
 
-            .then({
+            .thenSends({
               type: 'NotifyBarber',
               kind: 'Command',
               data: {

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

@@ -233,7 +233,7 @@ describe('handle.ts.ejs (react slice)', () => {
     const handleFile = plans.find((p) => p.outputPath.endsWith('react.ts'));
 
     expect(handleFile?.contents).toMatchInlineSnapshot(`
-      "import { inMemoryReactor, type MessageHandlerResult, IllegalStateError } from '@event-driven-io/emmett';
+      "import { inMemoryReactor, type MessageHandlerResult } from '@event-driven-io/emmett';
       import type { BookingRequested } from '../guest-submits-booking-request/events';
       import type { ReactorContext } from '../../../shared';
 
@@ -244,7 +244,7 @@ describe('handle.ts.ejs (react slice)', () => {
           connectionOptions: {
             database,
           },
-          eachMessage: async (event, context): Promise<MessageHandlerResult> => {
+          eachMessage: async (event): Promise<MessageHandlerResult> => {
             /**
              * ## IMPLEMENTATION INSTRUCTIONS ##
              *

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

@@ -162,13 +162,13 @@ describe('<%= ruleDescription %>', () => {
 <% if (thenCommands.length === 1) {
     const commandSchema = thenCommands[0];
 %>
-      .then({
+      .thenSends({
         type: '<%= commandSchema.commandRef %>',
         kind: 'Command',
         data: <%- formatDataObject(commandSchema.exampleData, commands.find(c => c.type === commandSchema.commandRef)) %>
       });
 <% } else { %>
-      .then([
+      .thenSends([
 <% for (const cmd of thenCommands) { %>
         {
           type: '<%= cmd.commandRef %>',

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

@@ -1,51 +1,50 @@
 <%
-const specs = slice.server?.specs;
-const firstExample = specs?.rules?.flatMap(rule => rule.examples)[0] ?? null;
-const gwt = firstExample ? {
-  given: firstExample.given,
-  when: firstExample.when,
-  then: firstExample.then
-} : null;
-const when = Array.isArray(gwt?.when) ? gwt.when[0] : gwt?.when;
-const then = Array.isArray(gwt?.then) ? gwt.then[0] : gwt?.then;
+if (!eventCommandPairs || eventCommandPairs.length === 0) {
+  throw new Error(`react.ts.ejs: slice "${slice.name}" has no event→command pairs — check specs`);
+}
 
-const eventType = when?.eventRef;
-const commandType = then?.commandRef;
-if (!eventType) throw new Error(
-  `react.ts.ejs: slice "${slice.name}" has no event in .when() — check specs`
-);
-if (!commandType) throw new Error(
-  `react.ts.ejs: slice "${slice.name}" has no command in .then() — check specs`
-);
-const event = events.find(e => e.type === eventType);
-const isCrossFlow = event?.sourceFlowName && event.sourceFlowName !== flowName;
-const eventImportBase = isCrossFlow
-  ? `../../${toKebabCase(event.sourceFlowName)}/${toKebabCase(event.sourceSliceName)}`
-  : event?.sourceSliceName ? `../${toKebabCase(event.sourceSliceName)}` : '.';
+const importGroups = new Map();
+for (const pair of eventCommandPairs) {
+  const event = events.find(e => e.type === pair.eventType);
+  const isCrossFlow = event?.sourceFlowName && event.sourceFlowName !== flowName;
+  const importBase = isCrossFlow
+    ? `../../${toKebabCase(event.sourceFlowName)}/${toKebabCase(event.sourceSliceName)}`
+    : event?.sourceSliceName ? `../${toKebabCase(event.sourceSliceName)}` : '.';
+  if (!importGroups.has(importBase)) importGroups.set(importBase, []);
+  const typeName = pascalCase(pair.eventType);
+  if (!importGroups.get(importBase).includes(typeName)) {
+    importGroups.get(importBase).push(typeName);
+  }
+}
+
+const allEventTypeNames = eventCommandPairs.map(p => pascalCase(p.eventType));
+const uniqueEventTypeNames = [...new Set(allEventTypeNames)];
+const eventUnion = uniqueEventTypeNames.join(' | ');
+
+const willHaveAnyAggregateStream = eventCommandPairs.some(pair => {
+  const eventDef = messages.find(m => m.name === pair.eventType);
+  return states.some(state =>
+    findPrimitiveLinkingField(state.fields, eventDef?.fields || []) !== undefined
+  );
+});
 -%>
 import {
 inMemoryReactor,
 type MessageHandlerResult,
-IllegalStateError,
 } from '@event-driven-io/emmett';
-import type { <%= pascalCase(eventType) %> } from '<%= eventImportBase %>/events';
+<% for (const [importBase, types] of importGroups) { -%>
+import type { <%= types.join(', ') %> } from '<%= importBase %>/events';
+<% } -%>
 import type { ReactorContext } from '../../../shared';
 
 export const react = ({ eventStore, commandSender, database }: ReactorContext) =>
-inMemoryReactor<<%= pascalCase(eventType) %>>({
+inMemoryReactor<<%= eventUnion %>>({
 processorId: '<%= toKebabCase(flowName) %>-<%= toKebabCase(slice.name) %>',
-canHandle: ['<%= eventType %>'],
+canHandle: [<%= eventCommandPairs.map(p => `'${p.eventType}'`).join(', ') %>],
 connectionOptions: {
 database,
 },
-eachMessage: async (event, context): Promise<MessageHandlerResult> => {
-<%
-const eventDef = messages.find(m => m.name === eventType);
-const commandDef = messages.find(m => m.name === commandType && m.type === 'command');
-const willHaveAggregateStream = states.some(state =>
-  findPrimitiveLinkingField(state.fields, eventDef?.fields || []) !== undefined
-);
--%>
+eachMessage: async (event): Promise<MessageHandlerResult> => {
     /**
     * ## IMPLEMENTATION INSTRUCTIONS ##
     *
@@ -57,7 +56,7 @@ const willHaveAggregateStream = states.some(state =>
     *   NEVER hardcode values copied from test assertions.
     *
     * Preserve all import paths above — they are generated from the model.
-<% if (willHaveAggregateStream) { -%>
+<% if (willHaveAnyAggregateStream) { -%>
     * Do NOT modify or remove aggregateStream calls — they load required state.
 <% } -%>
     *
@@ -69,31 +68,38 @@ const willHaveAggregateStream = states.some(state =>
     *
     * Add business logic (validation, conditional sends) as needed.
     */
-<%
-const commandFields = (commandDef?.fields || []);
-const eventFieldSet = new Set((eventDef?.fields || []).map(f => f.name));
-const stateFieldSources = {};
+<% if (eventCommandPairs.length === 1) {
+  const pair = eventCommandPairs[0];
+  const eventDef = messages.find(m => m.name === pair.eventType);
+  const commandDef = messages.find(m => m.name === pair.commandType && m.type === 'command');
+  const commandFields = (commandDef?.fields || []);
+  const eventFieldSet = new Set((eventDef?.fields || []).map(f => f.name));
+  const stateFieldSources = {};
 -%>
 <% if (eventDef?.fields?.length) { %>
-    // Event (<%= eventType %>) fields: <%= eventDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
+    // Event (<%= pair.eventType %>) fields: <%= eventDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
 <% } -%>
 <% if (commandDef?.fields?.length) { %>
-    // Command (<%= commandType %>) fields: <%= commandDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
+    // Command (<%= pair.commandType %>) fields: <%= commandDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
 <% } -%>
 <% if (states.length > 0) {
-  let hasAggregateStream = false;
-  for (const state of states) {
-    const linkingField = findPrimitiveLinkingField(state.fields, eventDef?.fields || []);
-    if (linkingField) {
-      hasAggregateStream = true;
-      const varName = camelCase(state.type);
-      for (const f of state.fields) {
-        if (!stateFieldSources[f.name]) stateFieldSources[f.name] = varName;
-      }
+    let hasAggregateStream = false;
+    for (const state of states) {
+      const linkingField = findPrimitiveLinkingField(state.fields, eventDef?.fields || []);
+      if (linkingField) {
+        hasAggregateStream = true;
+        const varName = camelCase(state.type);
+        for (const f of state.fields) {
+          if (!stateFieldSources[f.name]) stateFieldSources[f.name] = varName;
+        }
+        const stateUsedByCommand = commandFields.some(f =>
+          !eventFieldSet.has(f.name) && state.fields.some(sf => sf.name === f.name)
+        );
+        const varPrefix = stateUsedByCommand ? '' : '_';
 -%>
 
-    const { state: <%= varName %> } = await eventStore.aggregateStream(
-      '<%= state.type %>-' + event.data.<%= linkingField %>,
+    const { state: <%= varPrefix %><%= varName %> } = await eventStore.aggregateStream(
+      `<%= state.type %>-${event.data.<%= linkingField %>}`,
       {
         evolve: (currentState: Record<string, unknown>, evt: { type: string; data: Record<string, unknown> }) => ({ ...currentState, ...evt.data }),
         initialState: (): Record<string, unknown> => ({}),
@@ -101,35 +107,103 @@ const stateFieldSources = {};
     );
     // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
 
-<%    }
-  }
-  if (!hasAggregateStream) {
+<%      }
+    }
+    if (!hasAggregateStream) {
 -%>
 
-<%  }
-} else {
+<%    }
+  } else {
 -%>
 
 <% } -%>
     await commandSender.send({
-      type: '<%= commandType %>',
+      type: '<%= pair.commandType %>',
       kind: 'Command',
       data: {
 <% for (const field of commandFields) {
-    const fieldName = field.name;
-    if (eventFieldSet.has(fieldName)) {
+      const fieldName = field.name;
+      if (eventFieldSet.has(fieldName)) {
 -%>
         <%= fieldName %>: event.data.<%= fieldName %>,
-<%  } else if (stateFieldSources[fieldName]) { -%>
+<%    } else if (stateFieldSources[fieldName]) { -%>
         <%= fieldName %>: <%= stateFieldSources[fieldName] %>.<%= fieldName %>,
-<%  } else { -%>
+<%    } else { -%>
         <%= fieldName %>: undefined, // TODO: source unknown
-<%  }
-  }
+<%    }
+    }
 -%>
       },
     });
 
     return;
+<% } else {
+  for (let pairIdx = 0; pairIdx < eventCommandPairs.length; pairIdx++) {
+    const pair = eventCommandPairs[pairIdx];
+    const eventDef = messages.find(m => m.name === pair.eventType);
+    const commandDef = messages.find(m => m.name === pair.commandType && m.type === 'command');
+    const commandFields = (commandDef?.fields || []);
+    const eventFieldSet = new Set((eventDef?.fields || []).map(f => f.name));
+    const stateFieldSources = {};
+    const condition = pairIdx === 0 ? 'if' : '} else if';
+-%>
+    <%= condition %> (event.type === '<%= pair.eventType %>') {
+<% if (eventDef?.fields?.length) { %>
+      // Event (<%= pair.eventType %>) fields: <%= eventDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
+<% } -%>
+<% if (commandDef?.fields?.length) { %>
+      // Command (<%= pair.commandType %>) fields: <%= commandDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
+<% } -%>
+<% if (states.length > 0) {
+      for (const state of states) {
+        const linkingField = findPrimitiveLinkingField(state.fields, eventDef?.fields || []);
+        if (linkingField) {
+          const varName = camelCase(state.type);
+          for (const f of state.fields) {
+            if (!stateFieldSources[f.name]) stateFieldSources[f.name] = varName;
+          }
+          const stateUsedByCommand = commandFields.some(f =>
+            !eventFieldSet.has(f.name) && state.fields.some(sf => sf.name === f.name)
+          );
+          const varPrefix = stateUsedByCommand ? '' : '_';
+-%>
+
+      const { state: <%= varPrefix %><%= varName %> } = await eventStore.aggregateStream(
+        `<%= state.type %>-${event.data.<%= linkingField %>}`,
+        {
+          evolve: (currentState: Record<string, unknown>, evt: { type: string; data: Record<string, unknown> }) => ({ ...currentState, ...evt.data }),
+          initialState: (): Record<string, unknown> => ({}),
+        },
+      );
+      // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
+
+<%        }
+      }
+    }
+-%>
+      await commandSender.send({
+        type: '<%= pair.commandType %>',
+        kind: 'Command',
+        data: {
+<% for (const field of commandFields) {
+        const fieldName = field.name;
+        if (eventFieldSet.has(fieldName)) {
+-%>
+          <%= fieldName %>: event.data.<%= fieldName %>,
+<%      } else if (stateFieldSources[fieldName]) { -%>
+          <%= fieldName %>: <%= stateFieldSources[fieldName] %>.<%= fieldName %>,
+<%      } else { -%>
+          <%= fieldName %>: undefined, // TODO: source unknown
+<%      }
+      }
+-%>
+        },
+      });
+<%  }
+-%>
+    }
+
+    return;
+<% } -%>
     },
     });

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

@@ -762,8 +762,250 @@ export type BarberNotified = Event<
     const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const reactFile = plans.find((p) => p.outputPath.endsWith('check-record-updates/react.ts'));
 
-    expect(reactFile?.contents).toContain("'WorkoutSummary-' + event.data.memberId");
+    expect(reactFile?.contents).toContain('`WorkoutSummary-${event.data.memberId}`');
     expect(reactFile?.contents).toContain('aggregateStream');
     expect(reactFile?.contents).not.toContain('event.data.exercises');
   });
+
+  it('should scaffold handlers for multiple event→command pairs', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'fitness flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'earn points',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Earn points',
+                    rules: [
+                      {
+                        name: 'Should earn',
+                        examples: [
+                          {
+                            name: 'Points earned',
+                            steps: [
+                              { keyword: 'When', text: 'EarnPoints', docString: { memberId: 'm1', amount: 10 } },
+                              { keyword: 'Then', text: 'PointsEarned', docString: { memberId: 'm1', amount: 10 } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'command',
+              name: 'update record',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Update record',
+                    rules: [
+                      {
+                        name: 'Should update',
+                        examples: [
+                          {
+                            name: 'Record updated',
+                            steps: [
+                              { keyword: 'When', text: 'UpdateRecord', docString: { memberId: 'm1' } },
+                              {
+                                keyword: 'Then',
+                                text: 'PersonalRecordUpdated',
+                                docString: { memberId: 'm1', record: 'bench' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'award badges',
+              server: {
+                description: 'Awards badges based on points and records',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Award badges',
+                    rules: [
+                      {
+                        name: 'Should award on points',
+                        examples: [
+                          {
+                            name: 'Badge for points',
+                            steps: [
+                              { keyword: 'When', text: 'PointsEarned', docString: { memberId: 'm1', amount: 100 } },
+                              {
+                                keyword: 'Then',
+                                text: 'AwardBadge',
+                                docString: { memberId: 'm1', badge: 'centurion' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                      {
+                        name: 'Should notify on record',
+                        examples: [
+                          {
+                            name: 'Notification for record',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'PersonalRecordUpdated',
+                                docString: { memberId: 'm1', record: 'bench' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'SendRecordNotification',
+                                docString: { memberId: 'm1', message: 'New record!' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'EarnPoints',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'amount', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'PointsEarned',
+          source: 'internal',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'amount', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'UpdateRecord',
+          fields: [{ name: 'memberId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'PersonalRecordUpdated',
+          source: 'internal',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'record', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'AwardBadge',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'badge', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'SendRecordNotification',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'message', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const reactFile = plans.find((p) => p.outputPath.endsWith('award-badges/react.ts'));
+
+    expect(reactFile?.contents).toMatchInlineSnapshot(`
+      "import { inMemoryReactor, type MessageHandlerResult } from '@event-driven-io/emmett';
+      import type { PointsEarned } from '../earn-points/events';
+      import type { PersonalRecordUpdated } from '../update-record/events';
+      import type { ReactorContext } from '../../../shared';
+
+      export const react = ({ eventStore, commandSender, database }: ReactorContext) =>
+        inMemoryReactor<PointsEarned | PersonalRecordUpdated>({
+          processorId: 'fitness-flow-award-badges',
+          canHandle: ['PointsEarned', 'PersonalRecordUpdated'],
+          connectionOptions: {
+            database,
+          },
+          eachMessage: async (event): Promise<MessageHandlerResult> => {
+            /**
+             * ## IMPLEMENTATION INSTRUCTIONS ##
+             *
+             * Complete the command send below. Field sources are pre-classified:
+             * - \`event.data.<field>\` → already wired from the triggering event.
+             * - \`<stateVar>.<field>\` → already wired from loaded aggregate state.
+             * - \`undefined, // TODO: source unknown\` → MUST be dynamically derived:
+             *   compute from event.data, loaded state, or runtime logic.
+             *   NEVER hardcode values copied from test assertions.
+             *
+             * Preserve all import paths above — they are generated from the model.
+             *
+             * CONSTRAINTS:
+             * - NEVER use \`as SomeType\` type assertions. Use typed variable declarations.
+             * - Only reference event.data fields listed in the "Event fields:" comment below. Check the type before accessing any field.
+             * - Do NOT modify the inMemoryReactor configuration, connectionOptions, import statements, or commandSender.send() call structure. Only fill in data fields marked TODO.
+             * - When event.data contains nested arrays/objects (e.g., exercises[].sets[]), iterate them to compute values. Do NOT cast arrays/objects to primitive types.
+             *
+             * Add business logic (validation, conditional sends) as needed.
+             */
+            if (event.type === 'PointsEarned') {
+              // Event (PointsEarned) fields: memberId: string, amount: number
+
+              // Command (AwardBadge) fields: memberId: string, badge: string
+              await commandSender.send({
+                type: 'AwardBadge',
+                kind: 'Command',
+                data: {
+                  memberId: event.data.memberId,
+                  badge: undefined, // TODO: source unknown
+                },
+              });
+            } else if (event.type === 'PersonalRecordUpdated') {
+              // Event (PersonalRecordUpdated) fields: memberId: string, record: string
+
+              // Command (SendRecordNotification) fields: memberId: string, message: string
+              await commandSender.send({
+                type: 'SendRecordNotification',
+                kind: 'Command',
+                data: {
+                  memberId: event.data.memberId,
+                  message: undefined, // TODO: source unknown
+                },
+              });
+            }
+
+            return;
+          },
+        });
+      "
+    `);
+  });
 });