@auto-engineer/server-generator-apollo-emmett 0.10.4 → 0.11.0

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

@@ -173,15 +173,18 @@ describe('react.specs.ts.ejs (react slice)', () => {
       import type { BookingRequested } from '../guest-submits-booking-request/events';
       import type { NotifyHost } from '../send-notification-to-host/commands';
 
-      describe('ManageBookings | SendNotificationToHost', () => {
+      type ReactorEvent = BookingRequested;
+      type ReactorCommand = NotifyHost;
+
+      describe('Should send host notification on booking request', () => {
         let eventStore: InMemoryEventStore;
-        let given: ReactorSpecification<BookingRequested, NotifyHost, ReactorContext>;
+        let given: ReactorSpecification<ReactorEvent, ReactorCommand, ReactorContext>;
         let messageBus: CommandSender;
 
         beforeEach(() => {
           eventStore = getInMemoryEventStore({});
-          given = ReactorSpecification.for<BookingRequested, NotifyHost, ReactorContext>(
-            () => react({ eventStore, commandSender: messageBus }),
+          given = ReactorSpecification.for<ReactorEvent, ReactorCommand, ReactorContext>(
+            () => react({ eventStore, commandSender: messageBus, database: eventStore.database }),
             (commandSender) => {
               messageBus = commandSender;
               return {
@@ -193,7 +196,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
           );
         });
 
-        it('should send NotifyHost when BookingRequested is received', async () => {
+        it('Booking request triggers host notification', async () => {
           await given([])
             .when({
               type: 'BookingRequested',

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

@@ -223,12 +223,12 @@ describe('handle.ts.ejs (react slice)', () => {
       import type { BookingRequested } from '../guest-submits-booking-request/events';
       import type { ReactorContext } from '../../../shared';
 
-      export const react = ({ eventStore, commandSender }: ReactorContext) =>
+      export const react = ({ eventStore, commandSender, database }: ReactorContext) =>
         inMemoryReactor<BookingRequested>({
           processorId: 'manage-bookings-send-notification-to-host',
           canHandle: ['BookingRequested'],
           connectionOptions: {
-            database: eventStore.database,
+            database,
           },
           eachMessage: async (event, context): Promise<MessageHandlerResult> => {
             /**
@@ -236,7 +236,7 @@ describe('handle.ts.ejs (react slice)', () => {
              *
              * - 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({...})
+             * - Send one or more commands via: commandSender.send({...})
              * - Optionally return a MessageHandlerResult for SKIP or error cases.
              */
 
@@ -250,7 +250,7 @@ describe('handle.ts.ejs (react slice)', () => {
             //   };
             // }
 
-            // await context.commandSender.send({
+            // await commandSender.send({
             //   type: 'NotifyHost',
             //   kind: 'Command',
             //   data: {

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

@@ -1,88 +1,139 @@
 <%
-// Extract all examples from specs/rules structure
-const specs = slice.server?.specs;
-const gwtList = specs?.rules?.flatMap(rule => 
-  rule.examples.map(example => ({
-    given: example.given,
-    when: example.when,
-    then: example.then
-  }))
-) ?? [];
-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 ruleGroups = new Map();
+const rules = slice.server?.specs?.rules || [];
 
-const eventType = firstWhen?.eventRef;
-const commandType = firstThen?.commandRef;
+const allUsedEvents = new Set();
+const allUsedCommands = new Set();
 
-const event = events.find(e => e.type === eventType);
-const command = commands.find(c => c.type === commandType);
+for (const rule of rules) {
+    const ruleDescription = rule.description || `${flowName} | ${sliceName}`;
+    if (!ruleGroups.has(ruleDescription)) {
+        ruleGroups.set(ruleDescription, []);
+    }
 
-const eventImportPath = toKebabCase(event?.sourceSliceName ?? 'unknown');
-const commandImportPath = toKebabCase(command?.sourceSliceName ?? 'unknown');
+    for (const example of rule.examples || []) {
+        ruleGroups.get(ruleDescription).push({
+            description: example.description || 'should react correctly',
+            given: example.given || [],
+            when: example.when || [],
+            then: example.then || []
+        });
+
+        const whenEvents = Array.isArray(example.when) ? example.when : (example.when ? [example.when] : []);
+        for (const evt of whenEvents) {
+            if (evt.eventRef) allUsedEvents.add(evt.eventRef);
+        }
+
+        const thenCommands = Array.isArray(example.then) ? example.then : (example.then ? [example.then] : []);
+        for (const cmd of thenCommands) {
+            if (cmd.commandRef) allUsedCommands.add(cmd.commandRef);
+        }
+    }
+}
+
+const eventImportGroups = new Map();
+const commandImportGroups = new Map();
+
+for (const eventType of allUsedEvents) {
+    const event = events.find(e => e.type === eventType);
+    if (event) {
+        const importPath = event.sourceSliceName ? `../${toKebabCase(event.sourceSliceName)}/events` : './events';
+        if (!eventImportGroups.has(importPath)) {
+            eventImportGroups.set(importPath, []);
+        }
+        eventImportGroups.get(importPath).push(pascalCase(eventType));
+    }
+}
+
+for (const commandType of allUsedCommands) {
+    const command = commands.find(c => c.type === commandType);
+    if (command) {
+        const importPath = command.sourceSliceName ? `../${toKebabCase(command.sourceSliceName)}/commands` : './commands';
+        if (!commandImportGroups.has(importPath)) {
+            commandImportGroups.set(importPath, []);
+        }
+        commandImportGroups.get(importPath).push(pascalCase(commandType));
+    }
+}
+
+const allEventTypes = Array.from(allUsedEvents).map(e => pascalCase(e)).sort();
+const allCommandTypes = Array.from(allUsedCommands).map(c => pascalCase(c)).sort();
 %>
 import { describe, it, beforeEach } from 'vitest';
 import 'reflect-metadata';
 import {
-getInMemoryEventStore,
-type InMemoryEventStore,
-type CommandSender,
+  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';
+<% for (const [importPath, typeNames] of eventImportGroups.entries()) { -%>
+import type { <%= typeNames.sort().join(', ') %> } from '<%= importPath %>';
+<% } -%>
+<% for (const [importPath, typeNames] of commandImportGroups.entries()) { -%>
+import type { <%= typeNames.sort().join(', ') %> } from '<%= importPath %>';
+<% } -%>
 
-describe('<%= pascalCase(flowName) %> | <%= pascalCase(slice.name) %>', () => {
-let eventStore: InMemoryEventStore;
-let given: ReactorSpecification<<%= pascalCase(eventType) %>, <%= pascalCase(commandType) %>, ReactorContext>;
-let messageBus: CommandSender;
+type ReactorEvent = <%= allEventTypes.length ? allEventTypes.join(' | ') : 'never' %>;
+type ReactorCommand = <%= allCommandTypes.length ? allCommandTypes.join(' | ') : 'never' %>;
 
-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 [ruleDescription, ruleTests] of ruleGroups.entries()) { %>
+describe('<%= ruleDescription %>', () => {
+  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,
+        };
+      }
+    );
+  });
 
-<% 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`;
+<% for (const testCase of ruleTests) {
+    const whenEvents = Array.isArray(testCase.when) ? testCase.when : (testCase.when ? [testCase.when] : []);
+    const thenCommands = Array.isArray(testCase.then) ? testCase.then : (testCase.then ? [testCase.then] : []);
+
+    if (whenEvents.length > 0 && thenCommands.length > 0) {
+        const exampleEvent = whenEvents[0];
+        const description = testCase.description ||
+            `should send ${thenCommands.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];
+  it('<%= description %>', async () => {
+    await given([])
+      .when({
+        type: '<%= exampleEvent.eventRef %>',
+        data: <%- formatDataObject(exampleEvent.exampleData, events.find(e => e.type === exampleEvent.eventRef)) %>
+      })
+<% if (thenCommands.length === 1) {
+    const commandSchema = thenCommands[0];
 %>
-.then({
-type: '<%= commandSchema.commandRef %>',
-kind: 'Command',
-data: <%- formatDataObject(commandSchema.exampleData, messages.find(m => m.name === commandSchema.commandRef && m.type === 'command')) %>
-});
+      .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) { %>
+      .then([
+<% for (const cmd of thenCommands) { %>
         {
-        type: '<%= cmd.commandRef %>',
-        kind: 'Command',
-        data: <%- formatDataObject(cmd.exampleData, messages.find(m => m.name === cmd.commandRef && m.type === 'command')) %>
+          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

@@ -22,12 +22,12 @@ IllegalStateError,
 import type { <%= pascalCase(eventType) %> } from '../<%= toKebabCase(event?.sourceSliceName ?? 'unknown') %>/events';
 import type { ReactorContext } from '../../../shared';
 
-export const react = ({ eventStore, commandSender }: ReactorContext) =>
+export const react = ({ eventStore, commandSender, database }: ReactorContext) =>
 inMemoryReactor<<%= pascalCase(eventType) %>>({
 processorId: '<%= toKebabCase(flowName) %>-<%= toKebabCase(slice.name) %>',
 canHandle: ['<%= eventType %>'],
 connectionOptions: {
-database: eventStore.database,
+database,
 },
 eachMessage: async (event, context): Promise<MessageHandlerResult> => {
     /**
@@ -35,7 +35,7 @@ eachMessage: async (event, context): Promise<MessageHandlerResult> => {
     *
     * - 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({...})
+    * - Send one or more commands via: commandSender.send({...})
     * - Optionally return a MessageHandlerResult for SKIP or error cases.
     */
 
@@ -49,7 +49,7 @@ eachMessage: async (event, context): Promise<MessageHandlerResult> => {
     //   };
     // }
 
-    // await context.commandSender.send({
+    // await commandSender.send({
     //   type: '<%= commandType %>',
     //   kind: 'Command',
     //   data: {

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

@@ -219,10 +219,10 @@ 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 InMemoryEventStore } from '@event-driven-io/emmett';
+          "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: InMemoryEventStore) {
+          export async function register(messageBus: CommandSender & EventSubscription, eventStore: EventStore) {
             messageBus.subscribe(async (event: BookingRequested) => {
               /**
                * ## IMPLEMENTATION INSTRUCTIONS ##

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

@@ -14,12 +14,12 @@ const eventType = when?.eventRef;
 const commandType = then?.commandRef;
 const event = events.find(e => e.type === eventType);
 %>
-import { type CommandSender, type EventSubscription, type InMemoryEventStore } from '@event-driven-io/emmett';
+import { type CommandSender, type EventSubscription, type EventStore } from '@event-driven-io/emmett';
 import type { <%= pascalCase(eventType) %> } from '../<%= toKebabCase(event?.sourceSliceName ?? 'unknown') %>/events';
 
 export async function register(
 messageBus: CommandSender & EventSubscription,
-eventStore: InMemoryEventStore
+eventStore: EventStore
 ) {
 messageBus.subscribe(
 async (event: <%= pascalCase(eventType) %>) => {

package/src/codegen/types.ts

@@ -32,4 +32,6 @@ export interface GwtCondition {
   given?: Array<EventExample | StateExample>;
   when: CommandExample | EventExample[];
   then: Array<EventExample | StateExample | CommandExample | { errorType: string; message?: string }>;
+  description?: string;
+  ruleDescription?: string;
 }

package/src/commands/generate-server.ts

@@ -415,9 +415,11 @@ async function writePackage(dest: string): Promise<void> {
       'type-check': 'tsc --noEmit',
       test: 'vitest run',
       dev: 'tsx --no-deprecation src/server.ts',
+      postinstall: 'npm rebuild sqlite3 2>/dev/null || true',
     },
     dependencies: resolveDeps([
       '@event-driven-io/emmett',
+      '@event-driven-io/emmett-sqlite',
       'type-graphql',
       'graphql-type-json',
       'graphql',
@@ -426,6 +428,7 @@ async function writePackage(dest: string): Promise<void> {
       'zod',
       'apollo-server',
       'uuid',
+      'sqlite3',
     ]),
     devDependencies: resolveDeps(['typescript', 'vitest', 'tsx']),
   } as const;

package/src/domain/shared/ReadModel.ts

@@ -1,10 +1,10 @@
-import type { InMemoryEventStore } from '@event-driven-io/emmett';
+import type { InMemoryDatabase } from '@event-driven-io/emmett';
 
 export class ReadModel<T extends Record<string, unknown>> {
   private collection;
 
-  constructor(eventStore: InMemoryEventStore, collectionName: string) {
-    this.collection = eventStore.database.collection<T>(collectionName);
+  constructor(database: InMemoryDatabase, collectionName: string) {
+    this.collection = database.collection<T>(collectionName);
   }
 
   async getAll(): Promise<T[]> {

package/src/domain/shared/types.ts

@@ -1,15 +1,17 @@
-import { CommandSender, InMemoryEventStore } from '@event-driven-io/emmett';
+import { CommandSender, EventStore, type InMemoryDatabase } from '@event-driven-io/emmett';
 import { Field, ObjectType } from 'type-graphql';
 
 export interface ReactorContext {
-  eventStore: InMemoryEventStore;
+  eventStore: EventStore;
   commandSender: CommandSender;
+  database: InMemoryDatabase;
   [key: string]: unknown;
 }
 
 export interface GraphQLContext {
-  eventStore: InMemoryEventStore;
+  eventStore: EventStore;
   messageBus: CommandSender;
+  database: InMemoryDatabase;
 }
 
 @ObjectType()

package/src/server.ts

@@ -2,38 +2,76 @@ import 'reflect-metadata';
 import { ApolloServer } from 'apollo-server';
 import { buildSchema } from 'type-graphql';
 import { loadProjections, loadRegisterFiles, loadResolvers } from './utils';
-import {
-  getInMemoryEventStore,
-  getInMemoryMessageBus,
-  projections,
-  forwardToMessageBus,
-} from '@event-driven-io/emmett';
+import { getInMemoryMessageBus, getInMemoryDatabase, handleInMemoryProjections } from '@event-driven-io/emmett';
+import { getSQLiteEventStore } from '@event-driven-io/emmett-sqlite';
 
 async function start() {
   const loadedProjections = await loadProjections('src/domain/flows/**/projection.{ts,js}');
   const registrations = await loadRegisterFiles('src/domain/flows/**/register.{ts,js}');
 
   const messageBus = getInMemoryMessageBus();
+  const database = getInMemoryDatabase();
 
-  const eventStore = getInMemoryEventStore({
-    projections: projections.inline(loadedProjections),
-    hooks: {
-      onAfterCommit: forwardToMessageBus(messageBus),
-    },
+  const eventStore = getSQLiteEventStore({
+    fileName: './event-store.sqlite',
+    schema: { autoMigration: 'CreateOrUpdate' },
   });
-
+  try {
+    await eventStore.readStream('__init__');
+  } catch {
+    // Expected on fresh DB - schema gets created on first operation
+  }
   await Promise.all(registrations.map((r) => r.register(messageBus, eventStore)));
-
+  const consumer = eventStore.consumer();
+  consumer.processor({
+    processorId: 'projection-updater',
+    startFrom: 'BEGINNING',
+    eachMessage: async (event) => {
+      await handleInMemoryProjections({
+        projections: loadedProjections,
+        database,
+        events: [event],
+      });
+    },
+  });
+  consumer.processor({
+    processorId: 'forward-to-message-bus',
+    startFrom: 'BEGINNING',
+    eachMessage: async (evt) => {
+      await messageBus.publish(evt);
+    },
+  });
+  consumer.start().catch((err) => {
+    console.error('Consumer crashed:', err);
+    process.exit(1);
+  });
+  const shutdown = async () => {
+    console.log('Shutting down...');
+    try {
+      await consumer.stop?.();
+    } catch {
+      /* empty */
+    }
+    try {
+      await consumer.close?.();
+    } catch {
+      /* empty */
+    }
+    process.exit(0);
+  };
+  process.on('SIGINT', () => void shutdown());
+  process.on('SIGTERM', () => void shutdown());
   const resolvers = await loadResolvers('src/domain/flows/**/*.resolver.{ts,js}');
+  type ResolverClass = new (...args: unknown[]) => unknown;
   const schema = await buildSchema({
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    resolvers: resolvers as unknown as [(...args: any[]) => any, ...Array<(...args: any[]) => any>],
+    resolvers: resolvers as unknown as [ResolverClass, ...ResolverClass[]],
   });
   const server = new ApolloServer({
     schema,
     context: () => ({
       eventStore,
       messageBus,
+      database,
     }),
   });
   const { url } = await server.listen({ port: 4000 });