@auto-engineer/server-generator-apollo-emmett 1.88.0 → 1.90.0

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

@@ -194,6 +194,8 @@ describe('react.ts.ejs', () => {
     expect(reactFile?.contents).toContain('commandSender.send({');
     expect(reactFile?.contents).toContain('event.data.orderId');
     expect(reactFile?.contents).toContain('undefined, // TODO: source unknown');
+    expect(reactFile?.contents).toContain('NEVER hardcode values copied from test assertions');
+    expect(reactFile?.contents).toContain('Preserve all import paths');
     expect(reactFile?.contents).not.toContain('throw new IllegalStateError');
   });
 
@@ -551,6 +553,8 @@ export type BarberNotified = Event<
     const reactFile = plans.find((p) => p.outputPath.endsWith('notify-barber-of-cancellation/react.ts'));
 
     expect(reactFile?.contents).toContain('aggregateStream');
+    expect(reactFile?.contents).toContain('Record<string, unknown>');
+    expect(reactFile?.contents).toContain('Do NOT modify or remove aggregateStream');
     expect(reactFile?.contents).toContain('event.data.barberId');
     expect(reactFile?.contents).toContain('appointment');
     expect(reactFile?.contents).not.toContain('readable from database');
@@ -562,4 +566,253 @@ export type BarberNotified = Event<
     expect(reactFile?.contents).not.toContain('throw new IllegalStateError');
     expect(reactFile?.contents).not.toContain('// Example:');
   });
+
+  it('should ignore event And-steps in react Then, using only commands', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'notification 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: 'react',
+              name: 'notify milestone',
+              server: {
+                description: 'Notifies on milestone',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'SendNotification' },
+                      destination: { type: 'stream', pattern: 'notif-${memberId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Milestone notification',
+                    rules: [
+                      {
+                        name: 'Should notify',
+                        examples: [
+                          {
+                            name: 'Milestone reached',
+                            steps: [
+                              { keyword: 'When', text: 'PointsEarned', docString: { memberId: 'm1', amount: 10 } },
+                              { keyword: 'Then', text: 'MilestoneNotified', docString: { memberId: 'm1' } },
+                              { keyword: 'And', text: 'SendNotification', docString: { memberId: 'm1' } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      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: 'SendNotification',
+          fields: [{ name: 'memberId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'MilestoneNotified',
+          source: 'internal',
+          fields: [{ name: 'memberId', 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-milestone/react.ts'));
+
+    expect(reactFile?.contents).toContain("type: 'SendNotification'");
+    expect(reactFile?.contents).not.toContain('MilestoneNotified');
+  });
+
+  it('should use primitive linking field, skipping array/object fields', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'fitness flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'log workout',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Workout logged',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { memberId: 'm1', exercises: [{ exercise: 'squat', sets: 3 }] },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: { memberId: 'm1', exercises: [{ exercise: 'squat', sets: 3 }] },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'check record updates',
+              server: {
+                description: 'Updates records after workout',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'UpdateRecord' },
+                      destination: { type: 'stream', pattern: 'records-${memberId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Check record updates',
+                    rules: [
+                      {
+                        name: 'Should update records',
+                        examples: [
+                          {
+                            name: 'Record updated',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'WorkoutSummary',
+                                docString: { memberId: 'm1', exercises: [{ exercise: 'squat', sets: 3 }] },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'WorkoutLogged',
+                                docString: { memberId: 'm1', exercises: [{ exercise: 'squat', sets: 3 }] },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'UpdateRecord',
+                                docString: { memberId: 'm1' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogWorkout',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'exercises', type: '{exercise:string,sets:number}[]', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'WorkoutLogged',
+          source: 'internal',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'exercises', type: '{exercise:string,sets:number}[]', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'UpdateRecord',
+          fields: [{ name: 'memberId', type: 'string', required: true }],
+        },
+        {
+          type: 'state',
+          name: 'WorkoutSummary',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'exercises', type: '{exercise:string,sets:number}[]', required: true },
+          ],
+        },
+      ],
+    };
+
+    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('aggregateStream');
+    expect(reactFile?.contents).not.toContain('event.data.exercises');
+  });
 });

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

@@ -232,31 +232,35 @@ describe('register.ts.ejs (react slice)', () => {
     const registerFile = plans.find((p) => p.outputPath.endsWith('send-notification-to-host/register.ts'));
 
     expect(registerFile?.contents).toMatchInlineSnapshot(`
-          "import { type CommandSender, type EventSubscription, type EventStore } from '@event-driven-io/emmett';
-          import type { BookingRequested } from '../guest-submits-booking-request/events';
+      "import { type CommandSender, type EventSubscription, type EventStore } from '@event-driven-io/emmett';
+      import type { BookingRequested } from '../guest-submits-booking-request/events';
 
-          export async function register(messageBus: CommandSender & EventSubscription, eventStore: EventStore) {
-            messageBus.subscribe(async (event: BookingRequested) => {
-              /**
-               * ## IMPLEMENTATION INSTRUCTIONS ##
-               *
-               * - Replace the placeholder logic with the  real implementation.
-               * - Send one or more commands via: messageBus.send({...})
-               */
+      export async function register(messageBus: CommandSender & EventSubscription, eventStore: EventStore) {
+        messageBus.subscribe(async (event: BookingRequested) => {
+          /**
+           * ## IMPLEMENTATION INSTRUCTIONS ##
+           *
+           * - Replace the placeholder logic with the real implementation.
+           * - Send one or more commands via: messageBus.send({...})
+           * - If calling eventStore.aggregateStream(), type the evolve callback:
+           *   evolve: (s: Record<string, unknown>, e: { type: string; data: Record<string, unknown> }) => ...
+           * - NEVER hardcode values copied from test assertions.
+           * - Preserve all import paths above — they are generated from the model.
+           */
 
-              // await messageBus.send({
-              //   type: 'NotifyHost',
-              //   kind: 'Command',
-              //   data: {
-              //     // Map event fields to command fields here
-              //     // e.g., userId: event.data.userId,
-              //   },
-              // });
+          // await messageBus.send({
+          //   type: 'NotifyHost',
+          //   kind: 'Command',
+          //   data: {
+          //     // Map event fields to command fields here
+          //     // e.g., userId: event.data.userId,
+          //   },
+          // });
 
-              return;
-            }, 'BookingRequested');
-          }
-          "
-        `);
+          return;
+        }, 'BookingRequested');
+      }
+      "
+    `);
   });
 });

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

@@ -32,8 +32,12 @@ async (event: <%= pascalCase(eventType) %>) => {
 /**
 * ## IMPLEMENTATION INSTRUCTIONS ##
 *
-* - Replace the placeholder logic with the  real implementation.
+* - Replace the placeholder logic with the real implementation.
 * - Send one or more commands via: messageBus.send({...})
+* - If calling eventStore.aggregateStream(), type the evolve callback:
+*   evolve: (s: Record<string, unknown>, e: { type: string; data: Record<string, unknown> }) => ...
+* - NEVER hardcode values copied from test assertions.
+* - Preserve all import paths above — they are generated from the model.
 */
 
 // await messageBus.send({