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

package/package.json

@@ -11,8 +11,10 @@
   },
   "dependencies": {
     "@event-driven-io/emmett": "^0.38.2",
+    "@event-driven-io/emmett-sqlite": "^0.38.5",
     "apollo-server": "^3.13.0",
     "apollo-server-express": "^3.13.0",
+    "better-sqlite3": "^12.4.1",
     "change-case": "^5.4.4",
     "ejs": "^3.1.10",
     "execa": "^9.6.0",
@@ -23,13 +25,14 @@
     "graphql-scalars": "^1.24.2",
     "prettier": "^3.6.1",
     "reflect-metadata": "^0.2.2",
+    "sqlite3": "^5.1.7",
     "type-fest": "^4.41.0",
     "type-graphql": "^2.0.0-rc.2",
     "graphql-type-json": "^0.3.2",
-    "uuid": "^10.0.0",
+    "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
-    "@auto-engineer/flow": "0.10.5",
-    "@auto-engineer/message-bus": "0.10.5"
+    "@auto-engineer/flow": "0.11.0",
+    "@auto-engineer/message-bus": "0.11.0"
   },
   "publishConfig": {
     "access": "public"
@@ -37,9 +40,9 @@
   "devDependencies": {
     "@types/ejs": "^3.1.5",
     "@types/fs-extra": "^11.0.4",
-    "@auto-engineer/cli": "0.10.5"
+    "@auto-engineer/cli": "0.11.0"
   },
-  "version": "0.10.5",
+  "version": "0.11.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/query/projection.specs.ts

@@ -339,7 +339,7 @@ describe('projection.ts.ejs', () => {
           @Ctx() ctx: GraphQLContext,
           @Arg('sessionId', () => ID, { nullable: true }) sessionId?: string,
         ): Promise<Wishlist[]> {
-          const model = new ReadModel<Wishlist>(ctx.eventStore, 'WishlistProjection');
+          const model = new ReadModel<Wishlist>(ctx.database, 'WishlistProjection');
 
           // ## IMPLEMENTATION INSTRUCTIONS ##
           // You can query the projection using the ReadModel API:

package/src/codegen/templates/query/projection.specs.ts.ejs

@@ -176,6 +176,8 @@ if (idField.includes('-')) {
        formattedValue = `'${value}'`;
      } else if (tsType === 'number' || tsType === 'boolean') {
        formattedValue = String(value);
+     } else if (tsType === 'Date') {
+       formattedValue = `new Date('${value}')`;
      } else if (Array.isArray(value)) {
        formattedValue = JSON.stringify(value);
      } else {

package/src/codegen/templates/query/query.resolver.specs.ts

@@ -67,7 +67,7 @@ describe('query.resolver.ts.ejs', () => {
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toMatchInlineSnapshot(`
-      "import { Query, Resolver, Arg, Ctx, ObjectType, Field } from 'type-graphql';
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, Float } from 'type-graphql';
       import { type GraphQLContext, ReadModel } from '../../../shared';
 
       @ObjectType()
@@ -99,7 +99,7 @@ describe('query.resolver.ts.ejs', () => {
           @Arg('maxPrice', () => Float, { nullable: true }) maxPrice?: number,
           @Arg('minGuests', () => Float, { nullable: true }) minGuests?: number,
         ): Promise<AvailableListings[]> {
-          const model = new ReadModel<AvailableListings>(ctx.eventStore, 'AvailablePropertiesProjection');
+          const model = new ReadModel<AvailableListings>(ctx.database, 'AvailablePropertiesProjection');
 
           // ## IMPLEMENTATION INSTRUCTIONS ##
           // You can query the projection using the ReadModel API:
@@ -190,7 +190,8 @@ describe('query.resolver.ts.ejs', () => {
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toMatchInlineSnapshot(`
-      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from 'type-graphql';
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID, Float } from 'type-graphql';
+      import { GraphQLJSON } from 'graphql-type-json';
       import { type GraphQLContext, ReadModel } from '../../../shared';
 
       @ObjectType()
@@ -226,7 +227,7 @@ describe('query.resolver.ts.ejs', () => {
           @Ctx() ctx: GraphQLContext,
           @Arg('sessionId', () => ID, { nullable: true }) sessionId?: string,
         ): Promise<SuggestedItems[]> {
-          const model = new ReadModel<SuggestedItems>(ctx.eventStore, 'SuggestedItemsProjection');
+          const model = new ReadModel<SuggestedItems>(ctx.database, 'SuggestedItemsProjection');
 
           // ## IMPLEMENTATION INSTRUCTIONS ##
           // You can query the projection using the ReadModel API:
@@ -400,7 +401,7 @@ describe('query.resolver.ts.ejs', () => {
           @Ctx() ctx: GraphQLContext,
           @Arg('participantId', () => ID, { nullable: true }) participantId?: string,
         ): Promise<QuestionnaireProgress[]> {
-          const model = new ReadModel<QuestionnaireProgress>(ctx.eventStore, 'Questionnaires');
+          const model = new ReadModel<QuestionnaireProgress>(ctx.database, 'Questionnaires');
 
           // ## IMPLEMENTATION INSTRUCTIONS ##
           // You can query the projection using the ReadModel API:
@@ -422,4 +423,188 @@ describe('query.resolver.ts.ejs', () => {
       "
     `);
   });
+  it('should import Float when Float fields are used', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'product-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'get-product-price',
+              request: `
+                query GetProductPrice($productId: ID!) {
+                  productPrice(productId: $productId) {
+                    productId
+                    price
+                    discount
+                  }
+                }
+              `,
+              client: {
+                description: '',
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'productId',
+                      name: 'ProductPricesProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'ProductPrice',
+                    },
+                  },
+                ],
+                specs: { name: '', rules: [] },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'ProductPrice',
+          fields: [
+            { name: 'productId', type: 'string', required: true },
+            { name: 'price', type: 'number', required: true },
+            { name: 'discount', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain(
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID, Float } from 'type-graphql';",
+    );
+    expect(resolverFile?.contents).toContain('@Field(() => Float)');
+  });
+  it('should import Float when array of numbers is used', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'stats-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'get-stats',
+              request: `
+                query GetStats($userId: ID!) {
+                  stats(userId: $userId) {
+                    userId
+                    scores
+                  }
+                }
+              `,
+              client: {
+                description: '',
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'userId',
+                      name: 'StatsProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'Stats',
+                    },
+                  },
+                ],
+                specs: { name: '', rules: [] },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'Stats',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'scores', type: 'Array<number>', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain('Float');
+    expect(resolverFile?.contents).toContain('@Field(() => [Float])');
+  });
+  it('should import Float when Float query arg is used', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'search-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'search-products',
+              request: `
+                query SearchProducts($minPrice: Float, $maxPrice: Float) {
+                  searchProducts(minPrice: $minPrice, maxPrice: $maxPrice) {
+                    productId
+                    name
+                  }
+                }
+              `,
+              client: {
+                description: '',
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'productId',
+                      name: 'ProductsProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'Product',
+                    },
+                  },
+                ],
+                specs: { name: '', rules: [] },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'Product',
+          fields: [
+            { name: 'productId', type: 'string', required: true },
+            { name: 'name', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain('Float');
+    expect(resolverFile?.contents).toContain("@Arg('minPrice', () => Float");
+  });
 });

package/src/codegen/templates/query/query.resolver.ts.ejs

@@ -20,23 +20,46 @@ function baseTs(ts) {
 }
 function fieldUsesDate(ts) {
     const b = baseTs(ts);
-    if (b === 'Date') return true;
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('GraphQLISODateTime')) return true;
     if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*Date\b/.test(b);
     return false;
 }
 function fieldUsesJSON(ts) {
     const b = baseTs(ts);
-    if (b === 'unknown' || b === 'any' || b === 'object') return true;
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('GraphQLJSON') || gqlType.includes('JSON')) return true;
     if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*(unknown|any|object)\b/.test(b);
     return false;
 }
+function fieldUsesFloat(ts) {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('Float')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) {
+        const inner = b.trim().startsWith('Array<')
+            ? b.trim().replace(/^Array<\{/, '{').replace(/}>$/, '}')
+            : b.trim().replace(/\[\]$/, '');
+        const match = inner.match(/^\{([\s\S]*)\}$/);
+        const body = match ? match[1] : '';
+        const rawFields = body.split(/[,;]\s*/).filter(Boolean);
+        return rawFields.some(f => {
+            const parts = f.split(':');
+            const type = parts.slice(1).join(':').trim();
+            return type && graphqlType(type).includes('Float');
+        });
+    }
+    return false;
+}
 
 const messageFields = message?.fields ?? [];
 const usesDate = messageFields.some(f => fieldUsesDate(f.type)) ||
-        (parsedRequest?.args ?? []).some(a => baseTs(a.tsType) === 'Date');
-const usesJSON = messageFields.some(f => fieldUsesJSON(f.type));
+        (parsedRequest?.args ?? []).some(a => fieldUsesDate(a.tsType));
+const usesJSON = messageFields.some(f => fieldUsesJSON(f.type)) ||
+        (parsedRequest?.args ?? []).some(a => fieldUsesJSON(a.tsType));
+const usesFloat = messageFields.some(f => fieldUsesFloat(f.type)) ||
+        (parsedRequest?.args ?? []).some(a => fieldUsesFloat(a.tsType));
 
-// Collect embedded types up-front so we can emit them before the parent
 const embeddedTypes = [];
 for (const field of messageFields) {
     const tsType = field.type ?? 'string';
@@ -48,13 +71,12 @@ for (const field of messageFields) {
     }
 }
 %>
-import { Query, Resolver, Arg, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
+import { Query, Resolver, Arg, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesFloat) { %>, Float<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
 <% if (usesJSON) { %>import { GraphQLJSON } from 'graphql-type-json';
 <% } %>import { type GraphQLContext, ReadModel } from '../../../shared';
 
-<% // Emit embedded types FIRST — this matches your snapshot order
+<%
         for (const { typeName, tsType } of embeddedTypes) {
-    // Extract inner "{ ... }" whether Array<{...}> or "{...}[]"
     const inner = tsType.trim().startsWith('Array<')
             ? tsType.trim().replace(/^Array<\{/, '{').replace(/}>$/, '}')
             : tsType.trim().replace(/\[\]$/, '');
@@ -114,7 +136,7 @@ async <%= queryName %>(
 %>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
 <%   } } %>
 ): Promise<<%= viewType %>[]> {
-const model = new ReadModel<<%= viewType %>>(ctx.eventStore, '<%= projectionType %>');
+const model = new ReadModel<<%= viewType %>>(ctx.database, '<%= projectionType %>');
 
 // ## IMPLEMENTATION INSTRUCTIONS ##
 // You can query the projection using the ReadModel API:

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

@@ -184,7 +184,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
         beforeEach(() => {
           eventStore = getInMemoryEventStore({});
           given = ReactorSpecification.for<ReactorEvent, ReactorCommand, ReactorContext>(
-            () => react({ eventStore, commandSender: messageBus }),
+            () => react({ eventStore, commandSender: messageBus, database: eventStore.database }),
             (commandSender) => {
               messageBus = commandSender;
               return {

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

@@ -87,7 +87,7 @@ describe('<%= ruleDescription %>', () => {
   beforeEach(() => {
     eventStore = getInMemoryEventStore({});
     given = ReactorSpecification.for<ReactorEvent, ReactorCommand, ReactorContext>(
-      () => react({ eventStore, commandSender: messageBus }),
+      () => react({ eventStore, commandSender: messageBus, database: eventStore.database }),
       (commandSender) => {
         messageBus = commandSender;
         return {

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/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 });