@auto-engineer/server-generator-apollo-emmett 0.1.1

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

@@ -0,0 +1,214 @@
+import { describe, it, expect } from 'vitest';
+import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+
+describe('react.specs.ts.ejs (react slice)', () => {
+  it('should generate correct react.specs.ts', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'manage bookings',
+          slices: [
+            {
+              type: 'command',
+              name: 'guest submits booking request',
+              client: { description: '', specs: [] },
+              server: {
+                description: '',
+                gwt: [
+                  {
+                    when: {
+                      commandRef: 'RequestBooking',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                        hostId: 'host_123',
+                        guestId: 'guest_456',
+                        checkIn: '2025-07-15',
+                        checkOut: '2025-07-18',
+                        guests: 2,
+                        message: 'Looking forward to my stay!',
+                        metadata: { now: 'bar', bookingId: '123' },
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'BookingRequested',
+                        exampleData: {
+                          bookingId: 'book_xyz789',
+                          hostId: 'host_123',
+                          propertyId: 'prop_789',
+                          guestId: 'guest_456',
+                          checkIn: '2025-07-15',
+                          checkOut: '2025-07-18',
+                          guests: 2,
+                          message: 'Hey',
+                          status: 'pending_host_approval',
+                          requestedAt: '2025-06-10T16:30:00.000Z',
+                          expiresAt: '2025-06-11T16:30:00.000Z',
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'Send notification to host',
+              server: {
+                description: 'Sends a host notification command in response to BookingRequested',
+                data: [
+                  {
+                    target: { type: 'Command', name: 'NotifyHost' },
+                    destination: { type: 'stream', pattern: 'booking-${hostId}' },
+                  },
+                ],
+                gwt: [
+                  {
+                    when: [
+                      {
+                        eventRef: 'BookingRequested',
+                        exampleData: {
+                          bookingId: 'book_xyz789',
+                          hostId: 'host_123',
+                          propertyId: 'prop_789',
+                          guestId: 'guest_456',
+                          checkIn: '2025-07-15',
+                          checkOut: '2025-07-18',
+                          guests: 2,
+                          message: 'Hey',
+                          status: 'pending_host_approval',
+                          requestedAt: '2025-06-10T16:30:00.000Z',
+                          expiresAt: '2025-06-11T16:30:00.000Z',
+                        },
+                      },
+                    ],
+                    then: [
+                      {
+                        commandRef: 'NotifyHost',
+                        exampleData: {
+                          hostId: 'host_123',
+                          notificationType: 'booking_request',
+                          priority: 'high',
+                          channels: ['email', 'push'],
+                          message: 'A guest has requested to book your place.',
+                          actionRequired: true,
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'RequestBooking',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'hostId', type: 'string', required: true },
+            { name: 'guestId', type: 'string', required: true },
+            { name: 'checkIn', type: 'date', required: true },
+            { name: 'checkOut', type: 'date', required: true },
+            { name: 'guests', type: 'number', required: true },
+            { name: 'message', type: 'string', required: false },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'NotifyHost',
+          fields: [
+            { name: 'hostId', type: 'string', required: true },
+            { name: 'notificationType', type: 'string', required: true },
+            { name: 'priority', type: 'string', required: true },
+            { name: 'channels', type: 'string[]', required: true },
+            { name: 'message', type: 'string', required: true },
+            { name: 'actionRequired', type: 'boolean', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'BookingRequested',
+          source: 'internal',
+          fields: [
+            { name: 'bookingId', type: 'string', required: true },
+            { name: 'hostId', type: 'string', required: true },
+            { name: 'message', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+
+    const specFile = plans.find((p) => p.outputPath.endsWith('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 { BookingRequested } from '../guest-submits-booking-request/events';
+      import type { NotifyHost } from '../send-notification-to-host/commands';
+
+      describe('ManageBookings | SendNotificationToHost', () => {
+        let eventStore: InMemoryEventStore;
+        let given: ReactorSpecification<BookingRequested, NotifyHost, ReactorContext>;
+        let messageBus: CommandSender;
+
+        beforeEach(() => {
+          eventStore = getInMemoryEventStore({});
+          given = ReactorSpecification.for<BookingRequested, NotifyHost, ReactorContext>(
+            () => react({ eventStore, commandSender: messageBus }),
+            (commandSender) => {
+              messageBus = commandSender;
+              return {
+                eventStore,
+                commandSender,
+                database: eventStore.database,
+              };
+            },
+          );
+        });
+
+        it('should send NotifyHost when BookingRequested is received', async () => {
+          await given([])
+            .when({
+              type: 'BookingRequested',
+              data: {
+                bookingId: 'book_xyz789',
+                hostId: 'host_123',
+                propertyId: 'prop_789',
+                guestId: 'guest_456',
+                checkIn: '2025-07-15',
+                checkOut: '2025-07-18',
+                guests: 2,
+                message: 'Hey',
+                status: 'pending_host_approval',
+                requestedAt: '2025-06-10T16:30:00.000Z',
+                expiresAt: '2025-06-11T16:30:00.000Z',
+              },
+            })
+
+            .then({
+              type: 'NotifyHost',
+              kind: 'Command',
+              data: {
+                hostId: 'host_123',
+                notificationType: 'booking_request',
+                priority: 'high',
+                channels: ['email', 'push'],
+                message: 'A guest has requested to book your place.',
+                actionRequired: true,
+              },
+            });
+        });
+      });
+      "
+    `);
+  });
+});

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

@@ -0,0 +1,241 @@
+import { describe, it, expect } from 'vitest';
+import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+
+describe('handle.ts.ejs (react slice)', () => {
+  it('should generate correct react.ts', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'manage bookings',
+          slices: [
+            {
+              type: 'command',
+              name: 'guest submits booking request',
+              client: { description: '', specs: [] },
+              server: {
+                description: '',
+                gwt: [
+                  {
+                    when: {
+                      commandRef: 'RequestBooking',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                        hostId: 'host_123',
+                        guestId: 'guest_456',
+                        checkIn: '2025-07-15',
+                        checkOut: '2025-07-18',
+                        guests: 2,
+                        message: 'Looking forward to my stay!',
+                        metadata: { now: 'bar', bookingId: '123' },
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'BookingRequested',
+                        exampleData: {
+                          bookingId: 'book_xyz789',
+                          hostId: 'host_123',
+                          propertyId: 'prop_789',
+                          guestId: 'guest_456',
+                          checkIn: '2025-07-15',
+                          checkOut: '2025-07-18',
+                          guests: 2,
+                          message: 'Hey',
+                          status: 'pending_host_approval',
+                          requestedAt: '2025-06-10T16:30:00.000Z',
+                          expiresAt: '2025-06-11T16:30:00.000Z',
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'Send notification to host',
+              server: {
+                description: 'Sends a host notification command in response to BookingRequested',
+                gwt: [
+                  {
+                    when: [
+                      {
+                        eventRef: 'BookingRequested',
+                        exampleData: {
+                          bookingId: 'book_xyz789',
+                          hostId: 'host_123',
+                          propertyId: 'prop_789',
+                          guestId: 'guest_456',
+                          checkIn: '2025-07-15',
+                          checkOut: '2025-07-18',
+                          guests: 2,
+                          message: 'Hey',
+                          status: 'pending_host_approval',
+                          requestedAt: '2025-06-10T16:30:00.000Z',
+                          expiresAt: '2025-06-11T16:30:00.000Z',
+                        },
+                      },
+                    ],
+                    then: [
+                      {
+                        commandRef: 'NotifyHost',
+                        exampleData: {
+                          hostId: 'host_123',
+                          notificationType: 'booking_request',
+                          priority: 'high',
+                          channels: ['email', 'push'],
+                          message: 'A guest has requested to book your place.',
+                          actionRequired: true,
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'command',
+              name: 'notify host',
+              client: { description: '', specs: [] },
+              server: {
+                description: '',
+                gwt: [
+                  {
+                    when: {
+                      commandRef: 'NotifyHost',
+                      exampleData: {
+                        hostId: 'host_123',
+                        notificationType: 'booking_request',
+                        priority: 'high',
+                        channels: ['email', 'push'],
+                        message: 'A guest has requested to book your place.',
+                        actionRequired: true,
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'HostNotified',
+                        exampleData: {
+                          bookingId: 'book_xyz789',
+                          hostId: 'host_123',
+                          notificationType: 'booking_request',
+                          channels: ['email', 'push'],
+                          message: 'hi.',
+                          notifiedAt: '2025-06-10T16:30:00.000Z',
+                          actionRequired: true,
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'RequestBooking',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'hostId', type: 'string', required: true },
+            { name: 'guestId', type: 'string', required: true },
+            { name: 'checkIn', type: 'date', required: true },
+            { name: 'checkOut', type: 'date', required: true },
+            { name: 'guests', type: 'number', required: true },
+            { name: 'message', type: 'string', required: false },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'NotifyHost',
+          fields: [
+            { name: 'hostId', type: 'string', required: true },
+            { name: 'notificationType', type: 'string', required: true },
+            { name: 'priority', type: 'string', required: true },
+            { name: 'channels', type: 'string[]', required: true },
+            { name: 'message', type: 'string', required: true },
+            { name: 'actionRequired', type: 'boolean', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'BookingRequested',
+          source: 'internal',
+          fields: [
+            { name: 'bookingId', type: 'string', required: true },
+            { name: 'hostId', type: 'string', required: true },
+            { name: 'message', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'HostNotified',
+          source: 'internal',
+          fields: [
+            { name: 'bookingId', type: 'string', required: true },
+            { name: 'hostId', type: 'string', required: true },
+            { name: 'notificationType', type: 'string', required: true },
+            { name: 'channels', type: 'string[]', required: true },
+            { name: 'notifiedAt', type: 'date', required: true },
+            { name: 'actionRequired', type: 'boolean', required: true },
+            { name: 'message', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    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 type { BookingRequested } from '../guest-submits-booking-request/events';
+      import type { ReactorContext } from '../../../shared';
+
+      export const react = ({ eventStore, commandSender }: ReactorContext) =>
+        inMemoryReactor<BookingRequested>({
+          processorId: 'manage-bookings-send-notification-to-host',
+          canHandle: ['BookingRequested'],
+          connectionOptions: {
+            database: eventStore.database,
+          },
+          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: context.commandSender.send({...})
+             * - Optionally return a MessageHandlerResult for SKIP or error cases.
+             */
+
+            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 context.commandSender.send({
+            //   type: 'NotifyHost',
+            //   kind: 'Command',
+            //   data: {
+            //     // Map event fields to command fields here
+            //     // e.g., userId: event.data.userId,
+            //   },
+            // });
+
+            // return;
+          },
+        });
+      "
+    `);
+  });
+});

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

@@ -0,0 +1,80 @@
+<%
+const gwtList = slice.server?.gwt ?? [];
+const firstGwt = gwtList[0];
+const firstWhen = Array.isArray(firstGwt?.when) ? firstGwt.when[0] : firstGwt?.when;
+const firstThen = Array.isArray(firstGwt?.then) ? firstGwt.then[0] : firstGwt?.then;
+
+const eventType = firstWhen?.eventRef;
+const commandType = firstThen?.commandRef;
+
+const event = events.find(e => e.type === eventType);
+const command = commands.find(c => c.type === commandType);
+
+const eventImportPath = toKebabCase(event?.sourceSliceName ?? 'unknown');
+const commandImportPath = toKebabCase(command?.sourceSliceName ?? 'unknown');
+%>
+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 { <%= pascalCase(eventType) %> } from '../<%= eventImportPath %>/events';
+import type { <%= pascalCase(commandType) %> } from '../<%= commandImportPath %>/commands';
+
+describe('<%= pascalCase(flowName) %> | <%= pascalCase(slice.name) %>', () => {
+let eventStore: InMemoryEventStore;
+let given: ReactorSpecification<<%= pascalCase(eventType) %>, <%= pascalCase(commandType) %>, ReactorContext>;
+let messageBus: CommandSender;
+
+beforeEach(() => {
+eventStore = getInMemoryEventStore({});
+given = ReactorSpecification.for<<%= pascalCase(eventType) %>, <%= pascalCase(commandType) %>, ReactorContext>(
+() => react({ eventStore, commandSender: messageBus }),
+(commandSender) => {
+messageBus = commandSender;
+return {
+eventStore,
+commandSender,
+database: eventStore.database,
+};
+}
+);
+});
+
+<% for (const example of gwtList) {
+    const exampleEvent = Array.isArray(example.when) ? example.when[0] : example.when;
+    const commands = example.then;
+    const description = `should send ${commands.map(c => c.commandRef).join(', ')} when ${exampleEvent.eventRef} is received`;
+%>
+it('<%= description %>', async () => {
+await given([])
+.when({
+type: '<%= exampleEvent.eventRef %>',
+data: <%- formatDataObject(exampleEvent.exampleData, events.find(e => e.type === exampleEvent.eventRef)) %>
+})
+<% if (commands.length === 1) {
+    const commandSchema = commands[0];
+%>
+.then({
+type: '<%= commandSchema.commandRef %>',
+kind: 'Command',
+data: <%- formatDataObject(commandSchema.exampleData, messages.find(m => m.name === commandSchema.commandRef && m.type === 'command')) %>
+});
+<% } else { %>
+    .then([
+    <% for (const cmd of commands) { %>
+        {
+        type: '<%= cmd.commandRef %>',
+        kind: 'Command',
+        data: <%- formatDataObject(cmd.exampleData, messages.find(m => m.name === cmd.commandRef && m.type === 'command')) %>
+        },
+    <% } %>
+    ]);
+<% } %>
+});
+<% } %>
+});

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

@@ -0,0 +1,56 @@
+<%
+const gwt = slice.server?.gwt?.[0];
+const when = Array.isArray(gwt?.when) ? gwt.when[0] : gwt?.when;
+const then = Array.isArray(gwt?.then) ? gwt.then[0] : gwt?.then;
+
+const eventType = when?.eventRef;
+const commandType = then?.commandRef;
+const event = events.find(e => e.type === eventType);
+-%>
+import {
+inMemoryReactor,
+type MessageHandlerResult,
+IllegalStateError,
+} from '@event-driven-io/emmett';
+import type { <%= pascalCase(eventType) %> } from '../<%= toKebabCase(event?.sourceSliceName ?? 'unknown') %>/events';
+import type { ReactorContext } from '../../../shared';
+
+export const react = ({ eventStore, commandSender }: ReactorContext) =>
+inMemoryReactor<<%= pascalCase(eventType) %>>({
+processorId: '<%= toKebabCase(flowName) %>-<%= toKebabCase(slice.name) %>',
+canHandle: ['<%= eventType %>'],
+connectionOptions: {
+database: eventStore.database,
+},
+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: context.commandSender.send({...})
+    * - Optionally return a MessageHandlerResult for SKIP or error cases.
+    */
+
+    throw new IllegalStateError('Not yet implemented: react in response to <%= eventType %>');
+
+    // Example:
+    // if (event.data.status !== 'expected') {
+    //   return {
+    //     type: 'SKIP',
+    //     reason: 'Condition not met',
+    //   };
+    // }
+
+    // await context.commandSender.send({
+    //   type: '<%= commandType %>',
+    //   kind: 'Command',
+    //   data: {
+    //     // Map event fields to command fields here
+    //     // e.g., userId: event.data.userId,
+    //   },
+    // });
+
+    // return;
+    },
+    });