@auto-engineer/server-generator-apollo-emmett 1.70.0 → 1.71.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @auto-engineer/server-generator-apollo-emmett@1.70.0 build /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
+> @auto-engineer/server-generator-apollo-emmett@1.71.0 build /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
 > 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
 
 Fixed ESM imports in dist/

package/.turbo/turbo-test.log

@@ -1,14 +1,14 @@
 
-> @auto-engineer/server-generator-apollo-emmett@1.69.0 test /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
+> @auto-engineer/server-generator-apollo-emmett@1.70.0 test /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
 > vitest run --reporter=dot
 
 
  RUN  v3.2.4 /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
 
-·························································································································································-·················
+···························································································································································-·················
 
  Test Files  30 passed | 1 skipped (31)
-      Tests  170 passed | 1 skipped (171)
-   Start at  06:29:43
-   Duration  37.68s (transform 6.24s, setup 0ms, collect 76.15s, tests 19.55s, environment 13ms, prepare 6.57s)
+      Tests  172 passed | 1 skipped (173)
+   Start at  12:06:20
+   Duration  22.20s (transform 3.79s, setup 0ms, collect 45.99s, tests 8.68s, environment 6ms, prepare 4.29s)
 

package/.turbo/turbo-type-check.log

@@ -1,4 +1,4 @@
 
-> @auto-engineer/server-generator-apollo-emmett@1.69.0 type-check /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
+> @auto-engineer/server-generator-apollo-emmett@1.70.0 type-check /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
 > tsc --noEmit --project tsconfig.json
 

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @auto-engineer/server-generator-apollo-emmett
 
+## 1.71.0
+
+### Minor Changes
+
+- [`82543ae`](https://github.com/BeOnAuto/auto-engineer/commit/82543aec90a4398696e148f9ea26e5f4df51eb91) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: seed event store with Given state data in react specs template
+
+- [`6a7a3f2`](https://github.com/BeOnAuto/auto-engineer/commit/6a7a3f237c1267e1835168afaccf21e482e48278) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: generate aggregateStream for Given states
+  - **server-generator-apollo-emmett**: add Burst 3 to ketchup plan for commandSender.send generation
+  - **server-generator-apollo-emmett**: mark all react Given states bursts done
+
+- [`560d192`](https://github.com/BeOnAuto/auto-engineer/commit/560d19212be145f358ab2176c2424f6a8849070f) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: generate real commandSender.send() in react scaffold
+
+- [`b5f823a`](https://github.com/BeOnAuto/auto-engineer/commit/b5f823a8b6e08c05518220aedad5b686e8bf37ac) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: generate aggregateStream for Given states
+
+### Patch Changes
+
+- [`dde21b9`](https://github.com/BeOnAuto/auto-engineer/commit/dde21b9f06c8aaba5d18cfa4f1a68eed3bf4c190) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: mark all react Given states bursts done
+
+- [`28efa44`](https://github.com/BeOnAuto/auto-engineer/commit/28efa44f51373af11febb3fff00d85d1b3350784) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: mark Burst 3 done in ketchup plan
+
+- [`8b1238a`](https://github.com/BeOnAuto/auto-engineer/commit/8b1238ab2c98ad7bf396987edabf642b43b730bd) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: add ketchup plan for react slice Given states fix
+
+- [`e7a4ddf`](https://github.com/BeOnAuto/auto-engineer/commit/e7a4ddff607260651ecbf504a881a21db4657f19) Thanks [@github-actions[bot]](https://github.com/github-actions%5Bbot%5D)! - - **job-graph-processor**: increase time tolerance for parallel job dispatch test
+  - **root**: update @event-driven-io/emmett and @event-driven-io/emmett-sqlite versions to 0.42.0
+  - **ci**: remove --reporter=append to show pnpm install errors
+  - **generate-react-client**: update landing page header text
+  - **pipeline**: emit to event store before SSE broadcast in broadcastPipelineRunStarted
+- Updated dependencies [[`82543ae`](https://github.com/BeOnAuto/auto-engineer/commit/82543aec90a4398696e148f9ea26e5f4df51eb91), [`dde21b9`](https://github.com/BeOnAuto/auto-engineer/commit/dde21b9f06c8aaba5d18cfa4f1a68eed3bf4c190), [`28efa44`](https://github.com/BeOnAuto/auto-engineer/commit/28efa44f51373af11febb3fff00d85d1b3350784), [`6a7a3f2`](https://github.com/BeOnAuto/auto-engineer/commit/6a7a3f237c1267e1835168afaccf21e482e48278), [`560d192`](https://github.com/BeOnAuto/auto-engineer/commit/560d19212be145f358ab2176c2424f6a8849070f), [`8b1238a`](https://github.com/BeOnAuto/auto-engineer/commit/8b1238ab2c98ad7bf396987edabf642b43b730bd), [`e7a4ddf`](https://github.com/BeOnAuto/auto-engineer/commit/e7a4ddff607260651ecbf504a881a21db4657f19), [`b5f823a`](https://github.com/BeOnAuto/auto-engineer/commit/b5f823a8b6e08c05518220aedad5b686e8bf37ac)]:
+  - @auto-engineer/message-bus@1.71.0
+  - @auto-engineer/narrative@1.71.0
+
 ## 1.70.0
 
 ### Minor Changes

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

@@ -368,4 +368,203 @@ describe('react.specs.ts.ejs (react slice)', () => {
     expect(specFile?.contents).not.toContain("tipAmount: '5.00'");
     expect(specFile?.contents).not.toContain('tipAmount: "5.00"');
   });
+
+  it('should seed event store with Given state data via appendToStream', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'barbershop flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'cancel appointment',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Cancel appointment command',
+                    rules: [
+                      {
+                        name: 'Should cancel appointment',
+                        examples: [
+                          {
+                            name: 'Appointment cancelled',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'CancelAppointment',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'AppointmentCancelled',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'notify barber of cancellation',
+              server: {
+                description: 'Notifies barber when appointment is cancelled',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'NotifyBarber' },
+                      destination: { type: 'stream', pattern: 'barber-${barberId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Notify barber of cancellation reaction',
+                    rules: [
+                      {
+                        name: 'Should notify barber on cancellation',
+                        examples: [
+                          {
+                            name: 'Barber notified after cancellation',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'Appointment',
+                                docString: { barberId: 'barber_001', clientName: 'John' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'AppointmentCancelled',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'NotifyBarber',
+                                docString: { barberId: 'barber_001', message: 'Appointment cancelled' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'CancelAppointment',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'AppointmentCancelled',
+          source: 'internal',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'NotifyBarber',
+          fields: [
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'message', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'Appointment',
+          fields: [
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'clientName', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+
+    const specFile = plans.find((p) => p.outputPath.endsWith('notify-barber-of-cancellation/react.specs.ts'));
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, it, beforeEach } from 'vitest';
+      import 'reflect-metadata';
+      import { getInMemoryEventStore, type InMemoryEventStore, type CommandSender } from '@event-driven-io/emmett';
+      import { type ReactorContext, ReactorSpecification } from '../../../shared';
+      import { react } from './react';
+      import type { AppointmentCancelled } from '../cancel-appointment/events';
+      import type { NotifyBarber } from './commands';
+
+      type ReactorEvent = AppointmentCancelled;
+      type ReactorCommand = NotifyBarber;
+
+      describe('Should notify barber on cancellation', () => {
+        let eventStore: InMemoryEventStore;
+        let given: ReactorSpecification<ReactorEvent, ReactorCommand, ReactorContext>;
+        let messageBus: CommandSender;
+
+        beforeEach(() => {
+          eventStore = getInMemoryEventStore({});
+          given = ReactorSpecification.for<ReactorEvent, ReactorCommand, ReactorContext>(
+            () => react({ eventStore, commandSender: messageBus, database: eventStore.database }),
+            (commandSender) => {
+              messageBus = commandSender;
+              return {
+                eventStore,
+                commandSender,
+                database: eventStore.database,
+              };
+            },
+          );
+        });
+
+        it('Barber notified after cancellation', async () => {
+          await eventStore.appendToStream('Appointment-barber_001', [
+            {
+              type: 'AppointmentInitialized',
+              data: {
+                barberId: 'barber_001',
+                clientName: 'John',
+              },
+            },
+          ]);
+          await given([])
+            .when({
+              type: 'AppointmentCancelled',
+              data: {
+                appointmentId: 'apt_001',
+                barberId: 'barber_001',
+              },
+            })
+
+            .then({
+              type: 'NotifyBarber',
+              kind: 'Command',
+              data: {
+                barberId: 'barber_001',
+                message: 'Appointment cancelled',
+              },
+            });
+        });
+      });
+      "
+    `);
+  });
 });

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

@@ -248,36 +248,28 @@ describe('handle.ts.ejs (react slice)', () => {
             /**
              * ## IMPLEMENTATION INSTRUCTIONS ##
              *
-             * - Inspect event data to determine if the command should be sent.
-             * - Replace the placeholder logic and \\\`throw\\\` below with real implementation.
-             * - Send one or more commands via: commandSender.send({...})
-             * - Optionally return a MessageHandlerResult for SKIP or error cases.
+             * - Review the generated send call below and adjust if needed.
+             * - Add business logic (validation, conditional sends) as required.
              */
 
             // Event (BookingRequested) fields: bookingId: string, hostId: string, message: string
 
             // Command (NotifyHost) fields: hostId: string, notificationType: string, priority: string, channels: string[], message: string, actionRequired: boolean
 
-            throw new IllegalStateError('Not yet implemented: react in response to BookingRequested');
-
-            // Example:
-            // if (event.data.status !== 'expected') {
-            //   return {
-            //     type: 'SKIP',
-            //     reason: 'Condition not met',
-            //   };
-            // }
-
-            // await commandSender.send({
-            //   type: 'NotifyHost',
-            //   kind: 'Command',
-            //   data: {
-            //     // Map event fields to command fields here
-            //     // e.g., userId: event.data.userId,
-            //   },
-            // });
+            await commandSender.send({
+              type: 'NotifyHost',
+              kind: 'Command',
+              data: {
+                hostId: event.data.hostId,
+                notificationType: undefined, // TODO: source unknown
+                priority: undefined, // TODO: source unknown
+                channels: undefined, // TODO: source unknown
+                message: event.data.message,
+                actionRequired: undefined, // TODO: source unknown
+              },
+            });
 
-            // return;
+            return;
           },
         });
       "
@@ -560,6 +552,7 @@ describe('handle.ts.ejs (react slice)', () => {
     expect(reactFile?.contents).toContain("canHandle: ['PaymentProcessed']");
     expect(reactFile?.contents).toContain("from '../../order-management/process-payment/events'");
     expect(reactFile?.contents).not.toContain('ReactToPaymentProcessed');
-    expect(reactFile?.contents).toContain('Context state available: InventoryReservation (readable from database)');
+    expect(reactFile?.contents).not.toContain('readable from database');
+    expect(reactFile?.contents).not.toContain('aggregateStream');
   });
 });

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

@@ -115,6 +115,26 @@ describe('<%= ruleDescription %>', () => {
             `should send ${thenCommands.map(c => c.commandRef).join(', ')} when ${exampleEvent.eventRef} is received`;
 %>
   it('<%= description %>', async () => {
+<%
+    const givenStates = testCase.given.filter(g =>
+      messages.some(m => m.type === 'state' && m.name === g.eventRef)
+    );
+    for (const gs of givenStates) {
+      const stateSchema = states.find(s => s.type === gs.eventRef);
+      const eventDef = messages.find(m => m.name === exampleEvent.eventRef);
+      const stateFieldNames = (stateSchema?.fields || []).map(f => f.name);
+      const eventFieldNames = (eventDef?.fields || []).map(f => f.name);
+      const linkingField = stateFieldNames.find(f => eventFieldNames.includes(f));
+      if (linkingField) {
+        const linkingValue = gs.exampleData[linkingField];
+-%>
+    await eventStore.appendToStream('<%= gs.eventRef %>-<%= linkingValue %>', [{
+      type: '<%= gs.eventRef %>Initialized',
+      data: <%- formatDataObject(gs.exampleData, stateSchema) %>
+    }]);
+<%    }
+    }
+-%>
     await given([])
       .when({
         type: '<%= exampleEvent.eventRef %>',

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

@@ -42,17 +42,15 @@ eachMessage: async (event, context): Promise<MessageHandlerResult> => {
     /**
     * ## IMPLEMENTATION INSTRUCTIONS ##
     *
-    * - Inspect event data to determine if the command should be sent.
-    * - Replace the placeholder logic and \`throw\` below with real implementation.
-    * - Send one or more commands via: commandSender.send({...})
-    * - Optionally return a MessageHandlerResult for SKIP or error cases.
-<% if (states.length > 0) { -%>
-    * - Context state available: <%= states.map(s => pascalCase(s.type)).join(', ') %> (readable from database)
-<% } -%>
+    * - Review the generated send call below and adjust if needed.
+    * - Add business logic (validation, conditional sends) as required.
     */
 <%
 const eventDef = messages.find(m => m.name === eventType);
 const commandDef = messages.find(m => m.name === 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(', ') %>
@@ -60,26 +58,58 @@ const commandDef = messages.find(m => m.name === commandType && m.type === 'comm
 <% if (commandDef?.fields?.length) { %>
     // Command (<%= 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 stateFieldNames = state.fields.map(f => f.name);
+    const eventFieldNames = (eventDef?.fields || []).map(f => f.name);
+    const linkingField = stateFieldNames.find(f => eventFieldNames.includes(f));
+    if (linkingField) {
+      hasAggregateStream = true;
+      const varName = camelCase(state.type);
+      for (const f of state.fields) {
+        if (!stateFieldSources[f.name]) stateFieldSources[f.name] = varName;
+      }
+-%>
 
-    throw new IllegalStateError('Not yet implemented: react in response to <%= eventType %>');
+    const { state: <%= varName %> } = await eventStore.aggregateStream(
+      '<%= state.type %>-' + event.data.<%= linkingField %>,
+      {
+        evolve: (currentState, evt) => ({ ...currentState, ...evt.data }),
+        initialState: () => ({}),
+      },
+    );
+    // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
+
+<%    }
+  }
+  if (!hasAggregateStream) {
+-%>
 
-    // Example:
-    // if (event.data.status !== 'expected') {
-    //   return {
-    //     type: 'SKIP',
-    //     reason: 'Condition not met',
-    //   };
-    // }
+<%  }
+} else {
+-%>
 
-    // await commandSender.send({
-    //   type: '<%= commandType %>',
-    //   kind: 'Command',
-    //   data: {
-    //     // Map event fields to command fields here
-    //     // e.g., userId: event.data.userId,
-    //   },
-    // });
+<% } -%>
+    await commandSender.send({
+      type: '<%= 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;
+    return;
     },
     });

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

@@ -190,6 +190,11 @@ describe('react.ts.ejs', () => {
     // Should contain field-type hints for event and command
     expect(reactFile?.contents).toContain('// Event (OrderPlaced) fields:');
     expect(reactFile?.contents).toContain('// Command (SendConfirmation) fields:');
+
+    expect(reactFile?.contents).toContain('commandSender.send({');
+    expect(reactFile?.contents).toContain('event.data.orderId');
+    expect(reactFile?.contents).toContain('undefined, // TODO: source unknown');
+    expect(reactFile?.contents).not.toContain('throw new IllegalStateError');
   });
 
   it('should skip react slice with empty examples without throwing', async () => {
@@ -410,4 +415,151 @@ export type BarberNotified = Event<
 "
     `);
   });
+
+  it('should generate aggregateStream when Given states exist', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'barbershop flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'cancel appointment',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Cancel appointment command',
+                    rules: [
+                      {
+                        name: 'Should cancel appointment',
+                        examples: [
+                          {
+                            name: 'Appointment cancelled',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'CancelAppointment',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'AppointmentCancelled',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'notify barber of cancellation',
+              server: {
+                description: 'Notifies barber when appointment is cancelled',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'NotifyBarber' },
+                      destination: { type: 'stream', pattern: 'barber-${barberId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Notify barber of cancellation reaction',
+                    rules: [
+                      {
+                        name: 'Should notify barber on cancellation',
+                        examples: [
+                          {
+                            name: 'Barber notified after cancellation',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'Appointment',
+                                docString: { barberId: 'barber_001', clientName: 'John' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'AppointmentCancelled',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'NotifyBarber',
+                                docString: { barberId: 'barber_001', message: 'Appointment cancelled' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'CancelAppointment',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'AppointmentCancelled',
+          source: 'internal',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'NotifyBarber',
+          fields: [
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'message', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'Appointment',
+          fields: [
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'clientName', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const reactFile = plans.find((p) => p.outputPath.endsWith('notify-barber-of-cancellation/react.ts'));
+
+    expect(reactFile?.contents).toContain('aggregateStream');
+    expect(reactFile?.contents).toContain('event.data.barberId');
+    expect(reactFile?.contents).toContain('appointment');
+    expect(reactFile?.contents).not.toContain('readable from database');
+
+    expect(reactFile?.contents).toContain('commandSender.send({');
+    expect(reactFile?.contents).toContain("type: 'NotifyBarber'");
+    expect(reactFile?.contents).toContain('event.data.barberId');
+    expect(reactFile?.contents).toContain('undefined, // TODO: source unknown');
+    expect(reactFile?.contents).not.toContain('throw new IllegalStateError');
+    expect(reactFile?.contents).not.toContain('// Example:');
+  });
 });

package/ketchup-plan.md

@@ -1,7 +1,10 @@
-# Ketchup Plan: Fix stale enums in shared/types.ts
+# Ketchup Plan: Fix react slice scaffold ignoring Given states
 
 ## TODO
 
 ## DONE
 
-- [x] Burst 1: Replace appendEnumsToSharedTypes with from-scratch buildSharedTypesContent + writeSharedTypes + tests [depends: none] (4bc755b4)
+- [x] Burst 3: Generate real commandSender.send() in react.ts.ejs with field-source mapping (89610315)
+
+- [x] Burst 1: Fix react.specs.ts.ejs — seed event store with Given state data via appendToStream (0afa65ca)
+- [x] Burst 2: Fix react.ts.ejs — generate aggregateStream pattern when Given states exist (8380e5a2)

package/package.json

@@ -32,8 +32,8 @@
     "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
     "zod": "^3.22.4",
-    "@auto-engineer/narrative": "1.70.0",
-    "@auto-engineer/message-bus": "1.70.0"
+    "@auto-engineer/message-bus": "1.71.0",
+    "@auto-engineer/narrative": "1.71.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.70.0"
+    "@auto-engineer/cli": "1.71.0"
   },
-  "version": "1.70.0",
+  "version": "1.71.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/templates/react/react.specs.specs.ts

@@ -368,4 +368,203 @@ describe('react.specs.ts.ejs (react slice)', () => {
     expect(specFile?.contents).not.toContain("tipAmount: '5.00'");
     expect(specFile?.contents).not.toContain('tipAmount: "5.00"');
   });
+
+  it('should seed event store with Given state data via appendToStream', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'barbershop flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'cancel appointment',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Cancel appointment command',
+                    rules: [
+                      {
+                        name: 'Should cancel appointment',
+                        examples: [
+                          {
+                            name: 'Appointment cancelled',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'CancelAppointment',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'AppointmentCancelled',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'notify barber of cancellation',
+              server: {
+                description: 'Notifies barber when appointment is cancelled',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'NotifyBarber' },
+                      destination: { type: 'stream', pattern: 'barber-${barberId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Notify barber of cancellation reaction',
+                    rules: [
+                      {
+                        name: 'Should notify barber on cancellation',
+                        examples: [
+                          {
+                            name: 'Barber notified after cancellation',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'Appointment',
+                                docString: { barberId: 'barber_001', clientName: 'John' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'AppointmentCancelled',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'NotifyBarber',
+                                docString: { barberId: 'barber_001', message: 'Appointment cancelled' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'CancelAppointment',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'AppointmentCancelled',
+          source: 'internal',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'NotifyBarber',
+          fields: [
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'message', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'Appointment',
+          fields: [
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'clientName', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+
+    const specFile = plans.find((p) => p.outputPath.endsWith('notify-barber-of-cancellation/react.specs.ts'));
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, it, beforeEach } from 'vitest';
+      import 'reflect-metadata';
+      import { getInMemoryEventStore, type InMemoryEventStore, type CommandSender } from '@event-driven-io/emmett';
+      import { type ReactorContext, ReactorSpecification } from '../../../shared';
+      import { react } from './react';
+      import type { AppointmentCancelled } from '../cancel-appointment/events';
+      import type { NotifyBarber } from './commands';
+
+      type ReactorEvent = AppointmentCancelled;
+      type ReactorCommand = NotifyBarber;
+
+      describe('Should notify barber on cancellation', () => {
+        let eventStore: InMemoryEventStore;
+        let given: ReactorSpecification<ReactorEvent, ReactorCommand, ReactorContext>;
+        let messageBus: CommandSender;
+
+        beforeEach(() => {
+          eventStore = getInMemoryEventStore({});
+          given = ReactorSpecification.for<ReactorEvent, ReactorCommand, ReactorContext>(
+            () => react({ eventStore, commandSender: messageBus, database: eventStore.database }),
+            (commandSender) => {
+              messageBus = commandSender;
+              return {
+                eventStore,
+                commandSender,
+                database: eventStore.database,
+              };
+            },
+          );
+        });
+
+        it('Barber notified after cancellation', async () => {
+          await eventStore.appendToStream('Appointment-barber_001', [
+            {
+              type: 'AppointmentInitialized',
+              data: {
+                barberId: 'barber_001',
+                clientName: 'John',
+              },
+            },
+          ]);
+          await given([])
+            .when({
+              type: 'AppointmentCancelled',
+              data: {
+                appointmentId: 'apt_001',
+                barberId: 'barber_001',
+              },
+            })
+
+            .then({
+              type: 'NotifyBarber',
+              kind: 'Command',
+              data: {
+                barberId: 'barber_001',
+                message: 'Appointment cancelled',
+              },
+            });
+        });
+      });
+      "
+    `);
+  });
 });

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

@@ -248,36 +248,28 @@ describe('handle.ts.ejs (react slice)', () => {
             /**
              * ## IMPLEMENTATION INSTRUCTIONS ##
              *
-             * - Inspect event data to determine if the command should be sent.
-             * - Replace the placeholder logic and \\\`throw\\\` below with real implementation.
-             * - Send one or more commands via: commandSender.send({...})
-             * - Optionally return a MessageHandlerResult for SKIP or error cases.
+             * - Review the generated send call below and adjust if needed.
+             * - Add business logic (validation, conditional sends) as required.
              */
 
             // Event (BookingRequested) fields: bookingId: string, hostId: string, message: string
 
             // Command (NotifyHost) fields: hostId: string, notificationType: string, priority: string, channels: string[], message: string, actionRequired: boolean
 
-            throw new IllegalStateError('Not yet implemented: react in response to BookingRequested');
-
-            // Example:
-            // if (event.data.status !== 'expected') {
-            //   return {
-            //     type: 'SKIP',
-            //     reason: 'Condition not met',
-            //   };
-            // }
-
-            // await commandSender.send({
-            //   type: 'NotifyHost',
-            //   kind: 'Command',
-            //   data: {
-            //     // Map event fields to command fields here
-            //     // e.g., userId: event.data.userId,
-            //   },
-            // });
+            await commandSender.send({
+              type: 'NotifyHost',
+              kind: 'Command',
+              data: {
+                hostId: event.data.hostId,
+                notificationType: undefined, // TODO: source unknown
+                priority: undefined, // TODO: source unknown
+                channels: undefined, // TODO: source unknown
+                message: event.data.message,
+                actionRequired: undefined, // TODO: source unknown
+              },
+            });
 
-            // return;
+            return;
           },
         });
       "
@@ -560,6 +552,7 @@ describe('handle.ts.ejs (react slice)', () => {
     expect(reactFile?.contents).toContain("canHandle: ['PaymentProcessed']");
     expect(reactFile?.contents).toContain("from '../../order-management/process-payment/events'");
     expect(reactFile?.contents).not.toContain('ReactToPaymentProcessed');
-    expect(reactFile?.contents).toContain('Context state available: InventoryReservation (readable from database)');
+    expect(reactFile?.contents).not.toContain('readable from database');
+    expect(reactFile?.contents).not.toContain('aggregateStream');
   });
 });

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

@@ -115,6 +115,26 @@ describe('<%= ruleDescription %>', () => {
             `should send ${thenCommands.map(c => c.commandRef).join(', ')} when ${exampleEvent.eventRef} is received`;
 %>
   it('<%= description %>', async () => {
+<%
+    const givenStates = testCase.given.filter(g =>
+      messages.some(m => m.type === 'state' && m.name === g.eventRef)
+    );
+    for (const gs of givenStates) {
+      const stateSchema = states.find(s => s.type === gs.eventRef);
+      const eventDef = messages.find(m => m.name === exampleEvent.eventRef);
+      const stateFieldNames = (stateSchema?.fields || []).map(f => f.name);
+      const eventFieldNames = (eventDef?.fields || []).map(f => f.name);
+      const linkingField = stateFieldNames.find(f => eventFieldNames.includes(f));
+      if (linkingField) {
+        const linkingValue = gs.exampleData[linkingField];
+-%>
+    await eventStore.appendToStream('<%= gs.eventRef %>-<%= linkingValue %>', [{
+      type: '<%= gs.eventRef %>Initialized',
+      data: <%- formatDataObject(gs.exampleData, stateSchema) %>
+    }]);
+<%    }
+    }
+-%>
     await given([])
       .when({
         type: '<%= exampleEvent.eventRef %>',

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

@@ -42,17 +42,15 @@ eachMessage: async (event, context): Promise<MessageHandlerResult> => {
     /**
     * ## IMPLEMENTATION INSTRUCTIONS ##
     *
-    * - Inspect event data to determine if the command should be sent.
-    * - Replace the placeholder logic and \`throw\` below with real implementation.
-    * - Send one or more commands via: commandSender.send({...})
-    * - Optionally return a MessageHandlerResult for SKIP or error cases.
-<% if (states.length > 0) { -%>
-    * - Context state available: <%= states.map(s => pascalCase(s.type)).join(', ') %> (readable from database)
-<% } -%>
+    * - Review the generated send call below and adjust if needed.
+    * - Add business logic (validation, conditional sends) as required.
     */
 <%
 const eventDef = messages.find(m => m.name === eventType);
 const commandDef = messages.find(m => m.name === 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(', ') %>
@@ -60,26 +58,58 @@ const commandDef = messages.find(m => m.name === commandType && m.type === 'comm
 <% if (commandDef?.fields?.length) { %>
     // Command (<%= 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 stateFieldNames = state.fields.map(f => f.name);
+    const eventFieldNames = (eventDef?.fields || []).map(f => f.name);
+    const linkingField = stateFieldNames.find(f => eventFieldNames.includes(f));
+    if (linkingField) {
+      hasAggregateStream = true;
+      const varName = camelCase(state.type);
+      for (const f of state.fields) {
+        if (!stateFieldSources[f.name]) stateFieldSources[f.name] = varName;
+      }
+-%>
 
-    throw new IllegalStateError('Not yet implemented: react in response to <%= eventType %>');
+    const { state: <%= varName %> } = await eventStore.aggregateStream(
+      '<%= state.type %>-' + event.data.<%= linkingField %>,
+      {
+        evolve: (currentState, evt) => ({ ...currentState, ...evt.data }),
+        initialState: () => ({}),
+      },
+    );
+    // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
+
+<%    }
+  }
+  if (!hasAggregateStream) {
+-%>
 
-    // Example:
-    // if (event.data.status !== 'expected') {
-    //   return {
-    //     type: 'SKIP',
-    //     reason: 'Condition not met',
-    //   };
-    // }
+<%  }
+} else {
+-%>
 
-    // await commandSender.send({
-    //   type: '<%= commandType %>',
-    //   kind: 'Command',
-    //   data: {
-    //     // Map event fields to command fields here
-    //     // e.g., userId: event.data.userId,
-    //   },
-    // });
+<% } -%>
+    await commandSender.send({
+      type: '<%= 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;
+    return;
     },
     });

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

@@ -190,6 +190,11 @@ describe('react.ts.ejs', () => {
     // Should contain field-type hints for event and command
     expect(reactFile?.contents).toContain('// Event (OrderPlaced) fields:');
     expect(reactFile?.contents).toContain('// Command (SendConfirmation) fields:');
+
+    expect(reactFile?.contents).toContain('commandSender.send({');
+    expect(reactFile?.contents).toContain('event.data.orderId');
+    expect(reactFile?.contents).toContain('undefined, // TODO: source unknown');
+    expect(reactFile?.contents).not.toContain('throw new IllegalStateError');
   });
 
   it('should skip react slice with empty examples without throwing', async () => {
@@ -410,4 +415,151 @@ export type BarberNotified = Event<
 "
     `);
   });
+
+  it('should generate aggregateStream when Given states exist', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'barbershop flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'cancel appointment',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Cancel appointment command',
+                    rules: [
+                      {
+                        name: 'Should cancel appointment',
+                        examples: [
+                          {
+                            name: 'Appointment cancelled',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'CancelAppointment',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'AppointmentCancelled',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'notify barber of cancellation',
+              server: {
+                description: 'Notifies barber when appointment is cancelled',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'NotifyBarber' },
+                      destination: { type: 'stream', pattern: 'barber-${barberId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Notify barber of cancellation reaction',
+                    rules: [
+                      {
+                        name: 'Should notify barber on cancellation',
+                        examples: [
+                          {
+                            name: 'Barber notified after cancellation',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'Appointment',
+                                docString: { barberId: 'barber_001', clientName: 'John' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'AppointmentCancelled',
+                                docString: { appointmentId: 'apt_001', barberId: 'barber_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'NotifyBarber',
+                                docString: { barberId: 'barber_001', message: 'Appointment cancelled' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'CancelAppointment',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'AppointmentCancelled',
+          source: 'internal',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'NotifyBarber',
+          fields: [
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'message', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'Appointment',
+          fields: [
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'clientName', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const reactFile = plans.find((p) => p.outputPath.endsWith('notify-barber-of-cancellation/react.ts'));
+
+    expect(reactFile?.contents).toContain('aggregateStream');
+    expect(reactFile?.contents).toContain('event.data.barberId');
+    expect(reactFile?.contents).toContain('appointment');
+    expect(reactFile?.contents).not.toContain('readable from database');
+
+    expect(reactFile?.contents).toContain('commandSender.send({');
+    expect(reactFile?.contents).toContain("type: 'NotifyBarber'");
+    expect(reactFile?.contents).toContain('event.data.barberId');
+    expect(reactFile?.contents).toContain('undefined, // TODO: source unknown');
+    expect(reactFile?.contents).not.toContain('throw new IllegalStateError');
+    expect(reactFile?.contents).not.toContain('// Example:');
+  });
 });