@auto-engineer/server-generator-apollo-emmett 1.26.0 → 1.26.1

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

@@ -217,7 +217,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
                 guestId: 'guest_456',
                 checkIn: '2025-07-15',
                 checkOut: '2025-07-18',
-                guests: 2,
+                guests: '2',
                 message: 'Hey',
                 status: 'pending_host_approval',
                 requestedAt: '2025-06-10T16:30:00.000Z',
@@ -242,4 +242,130 @@ describe('react.specs.ts.ejs (react slice)', () => {
       "
     `);
   });
+
+  it('should use correct field types from commands array (number fields not strings)', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'tipping flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'complete appointment',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Complete appointment command',
+                    rules: [
+                      {
+                        name: 'Should complete appointment',
+                        examples: [
+                          {
+                            name: 'Appointment completed',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'CompleteAppointment',
+                                docString: { appointmentId: 'apt_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'AppointmentCompleted',
+                                docString: { appointmentId: 'apt_001' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'Process tip after completion',
+              server: {
+                description: 'Processes tip command after appointment completion',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'ProcessTip' },
+                      destination: { type: 'stream', pattern: 'tips-${appointmentId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Process tip reaction',
+                    rules: [
+                      {
+                        name: 'Should process tip on appointment completion',
+                        examples: [
+                          {
+                            name: 'Tip processed after completion',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'AppointmentCompleted',
+                                docString: { appointmentId: 'apt_001' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'ProcessTip',
+                                docString: {
+                                  appointmentId: 'apt_001',
+                                  tipAmount: '5.00',
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'CompleteAppointment',
+          fields: [{ name: 'appointmentId', type: 'string', required: true }],
+        },
+        {
+          type: 'command',
+          name: 'ProcessTip',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'tipAmount', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'AppointmentCompleted',
+          source: 'internal',
+          fields: [{ name: 'appointmentId', type: 'string', required: true }],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+
+    const specFile = plans.find((p) => p.outputPath.endsWith('react.specs.ts'));
+    expect(specFile?.contents).toBeDefined();
+
+    // tipAmount should be a number (5), not a string ("5.00")
+    expect(specFile?.contents).toContain('tipAmount: 5');
+    expect(specFile?.contents).not.toContain("tipAmount: '5.00'");
+    expect(specFile?.contents).not.toContain('tipAmount: "5.00"');
+  });
 });

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

@@ -254,6 +254,10 @@ describe('handle.ts.ejs (react slice)', () => {
              * - Optionally return a MessageHandlerResult for SKIP or error cases.
              */
 
+            // 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:

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

@@ -126,7 +126,7 @@ describe('<%= ruleDescription %>', () => {
       .then({
         type: '<%= commandSchema.commandRef %>',
         kind: 'Command',
-        data: <%- formatDataObject(commandSchema.exampleData, messages.find(m => m.name === commandSchema.commandRef && m.type === 'command')) %>
+        data: <%- formatDataObject(commandSchema.exampleData, commands.find(c => c.type === commandSchema.commandRef)) %>
       });
 <% } else { %>
       .then([
@@ -134,7 +134,7 @@ describe('<%= ruleDescription %>', () => {
         {
           type: '<%= cmd.commandRef %>',
           kind: 'Command',
-          data: <%- formatDataObject(cmd.exampleData, messages.find(m => m.name === cmd.commandRef && m.type === 'command')) %>
+          data: <%- formatDataObject(cmd.exampleData, commands.find(c => c.type === cmd.commandRef)) %>
         },
 <% } %>
       ]);

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

@@ -11,6 +11,12 @@ const then = Array.isArray(gwt?.then) ? gwt.then[0] : gwt?.then;
 
 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
@@ -44,6 +50,16 @@ eachMessage: async (event, context): Promise<MessageHandlerResult> => {
     * - Context state available: <%= states.map(s => pascalCase(s.type)).join(', ') %> (readable from database)
 <% } -%>
     */
+<%
+const eventDef = messages.find(m => m.name === eventType);
+const commandDef = messages.find(m => m.name === commandType && m.type === 'command');
+-%>
+<% if (eventDef?.fields?.length) { %>
+    // Event (<%= 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(', ') %>
+<% } -%>
 
     throw new IllegalStateError('Not yet implemented: react in response to <%= eventType %>');
 

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

@@ -0,0 +1,194 @@
+import type { Model as SpecsSchema } from '@auto-engineer/narrative';
+import { describe, expect, it } from 'vitest';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+
+describe('react.ts.ejs', () => {
+  it('should throw when react slice has no When event', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'broken flow',
+          slices: [
+            {
+              type: 'react',
+              name: 'missing-when-slice',
+              server: {
+                description: 'A react slice with no When step',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'DoSomething' },
+                      destination: { type: 'stream', pattern: 'things-${id}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Broken reaction',
+                    rules: [
+                      {
+                        name: 'Should fail gracefully',
+                        examples: [
+                          {
+                            name: 'No when step',
+                            steps: [
+                              {
+                                keyword: 'Then',
+                                text: 'DoSomething',
+                                docString: { id: '123' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'DoSomething',
+          fields: [{ name: 'id', type: 'string', required: true }],
+        },
+      ],
+    };
+
+    await expect(
+      generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows'),
+    ).rejects.toThrow('missing-when-slice');
+  });
+
+  it('should include field-type hint comments for event and command', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'order flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'place order',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Place order command',
+                    rules: [
+                      {
+                        name: 'Should place order',
+                        examples: [
+                          {
+                            name: 'Order placed',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'PlaceOrder',
+                                docString: { orderId: 'o1', total: 100 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'OrderPlaced',
+                                docString: { orderId: 'o1', total: 100 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'Send order confirmation',
+              server: {
+                description: 'Sends confirmation after order placed',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'SendConfirmation' },
+                      destination: { type: 'stream', pattern: 'confirmations-${orderId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Send confirmation reaction',
+                    rules: [
+                      {
+                        name: 'Should send confirmation',
+                        examples: [
+                          {
+                            name: 'Confirmation sent',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'OrderPlaced',
+                                docString: { orderId: 'o1', total: 100 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'SendConfirmation',
+                                docString: { orderId: 'o1', email: 'test@test.com' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'PlaceOrder',
+          fields: [
+            { name: 'orderId', type: 'string', required: true },
+            { name: 'total', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'SendConfirmation',
+          fields: [
+            { name: 'orderId', type: 'string', required: true },
+            { name: 'email', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'OrderPlaced',
+          source: 'internal',
+          fields: [
+            { name: 'orderId', type: 'string', required: true },
+            { name: 'total', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const reactFile = plans.find((p) => p.outputPath.endsWith('send-order-confirmation/react.ts'));
+    expect(reactFile?.contents).toBeDefined();
+
+    // Should contain field-type hints for event and command
+    expect(reactFile?.contents).toContain('// Event (OrderPlaced) fields:');
+    expect(reactFile?.contents).toContain('// Command (SendConfirmation) fields:');
+  });
+});