create-auto-app 0.2.2 → 0.3.0

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/views-suggested-items/query.resolver.ts

@@ -0,0 +1,56 @@
+import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from 'type-graphql';
+import { type GraphQLContext, ReadModel } from '../../../shared';
+
+@ObjectType()
+export class SuggestedItems {
+  @Field(() => String)
+  sessionId!: string;
+
+  @Field(() => [SuggestedItemsItems])
+  items!: SuggestedItemsItems[];
+
+  [key: string]: unknown;
+}
+
+@ObjectType()
+export class SuggestedItemsItems {
+  @Field(() => String)
+  productId!: string;
+
+  @Field(() => String)
+  name!: string;
+
+  @Field(() => Number)
+  quantity!: number;
+
+  @Field(() => String)
+  reason!: string;
+}
+
+@Resolver()
+export class ViewsSuggestedItemsQueryResolver {
+  @Query(() => [SuggestedItems])
+  async suggestedItems(
+    @Ctx() ctx: GraphQLContext,
+    @Arg('sessionId', () => ID, { nullable: true }) sessionId?: string,
+  ): Promise<SuggestedItems[]> {
+    const model = new ReadModel<SuggestedItems>(ctx.eventStore, 'SuggestedItemsProjection');
+
+    // ## IMPLEMENTATION INSTRUCTIONS ##
+    // You can query the projection using the ReadModel API:
+    //
+    // - model.getAll() — fetch all documents
+    // - model.getById(id) — fetch a single document by ID (default key: 'id')
+    // - model.find(filterFn) — filter documents using a predicate
+    // - model.first(filterFn) — fetch the first document matching a predicate
+    //
+    // Example below uses `.find()` to filter
+    // change the logic for the query as needed to meet the requirements for the current slice.
+
+    return model.find((item) => {
+      if (sessionId !== undefined && item.sessionId !== sessionId) return false;
+
+      return true;
+    });
+  }
+}

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/views-suggested-items/state.ts

@@ -0,0 +1,4 @@
+export type SuggestedItems = {
+  sessionId: string;
+  items: Array<{ productId: string; name: string; quantity: number; reason: string }>;
+};

package/templates/shopping-app/.context/server/server/src/domain/shared/ReadModel.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEventStore } 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);
+  }
+
+  async getAll(): Promise<T[]> {
+    return this.collection.find();
+  }
+
+  async getById(id: string, idField: keyof T = 'id' as keyof T): Promise<T | null> {
+    return this.collection.findOne((doc) => doc[idField] === id);
+  }
+
+  async find(filterFn: (item: T) => boolean): Promise<T[]> {
+    return this.collection.find(filterFn);
+  }
+
+  async first(filterFn: (item: T) => boolean): Promise<T | null> {
+    const all = await this.collection.find(filterFn);
+    return all[0] ?? null;
+  }
+}

package/templates/shopping-app/{server/src/domain/shared/index.d.ts → .context/server/server/src/domain/shared/index.ts}

@@ -2,4 +2,3 @@ export * from './types';
 export * from './ReadModel';
 export * from './reactorSpecification';
 export * from './sendCommand';
-//# sourceMappingURL=index.d.ts.map

package/templates/shopping-app/{server/src/domain/shared/reactorSpecification.js → .context/server/server/src/domain/shared/reactorSpecification.ts}

@@ -1,35 +1,98 @@
-import { isErrorConstructor, AssertionError, assertTrue } from '@event-driven-io/emmett';
+import {
+  CommandSender,
+  isErrorConstructor,
+  type ErrorConstructor,
+  AssertionError,
+  assertTrue,
+  type MessageProcessor,
+} from '@event-driven-io/emmett';
+
+interface CommandCheck<CommandType> {
+  (command: CommandType): boolean;
+}
+
+interface ErrorCheck<ErrorType> {
+  (error: ErrorType): boolean;
+}
+
+export type ThenThrows<ErrorType extends Error> =
+  | (() => void)
+  | ((errorConstructor: ErrorConstructor<ErrorType>) => void)
+  | ((errorCheck: ErrorCheck<ErrorType>) => void)
+  | ((errorConstructor: ErrorConstructor<ErrorType>, errorCheck?: ErrorCheck<ErrorType>) => void);
+
+interface ReactorSpecificationReturn<Event, Command, Context> {
+  when: (
+    event: Event | Event[],
+    context?: Context,
+  ) => {
+    then: (expectedCommand: Command | Command[] | CommandCheck<Command> | CommandCheck<Command[]>) => Promise<void>;
+    thenNothingHappened: () => Promise<void>;
+    thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+  };
+}
+
+export interface ReactorSpecification<
+  Event,
+  Command,
+  Context extends { commandSender: CommandSender } = { commandSender: CommandSender },
+> {
+  (givenEvents: Event | Event[]): ReactorSpecificationReturn<Event, Command, Context>;
+}
+
 export const ReactorSpecification = {
   for: reactorSpecificationFor,
 };
-function createMockCommandSender() {
-  const sentCommands = [];
-  const send = async (command) => {
+
+interface MockCommandSender<Command> extends CommandSender {
+  sentCommands: Command[];
+  reset: () => void;
+}
+
+function createMockCommandSender<Command>(): MockCommandSender<Command> {
+  const sentCommands: Command[] = [];
+
+  const send = async <CommandType extends Command = Command>(command: CommandType): Promise<void> => {
     sentCommands.push(command);
   };
+
   return {
     send,
     sentCommands,
     reset: () => {
       sentCommands.length = 0;
     },
-  };
+  } as MockCommandSender<Command>;
 }
-function reactorSpecificationFor(processorOrReactor, createContext) {
-  return (givenEvents) => {
+
+type ReactorLike<Event, Context> =
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | { handle: (events: Event[], context: Context) => Promise<any> }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | { eachMessage: (event: Event, context: Context) => Promise<any> }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | MessageProcessor<any, any, any>;
+
+function reactorSpecificationFor<Event, Command, Context extends { commandSender: CommandSender }>(
+  processorOrReactor: ReactorLike<Event, Context> | (() => ReactorLike<Event, Context>),
+  createContext: (commandSender: CommandSender) => Context,
+): ReactorSpecification<Event, Command, Context> {
+  return (givenEvents: Event | Event[]) => {
     return {
-      when: (whenEvent, contextOverride) => {
-        const mockCommandSender = createMockCommandSender();
+      when: (whenEvent: Event | Event[], contextOverride?: Context) => {
+        const mockCommandSender = createMockCommandSender<Command>();
         const defaultContext = createContext(mockCommandSender);
         const context = contextOverride || defaultContext;
+
         const handle = async () => {
           const givenArray = Array.isArray(givenEvents) ? givenEvents : givenEvents != null ? [givenEvents] : [];
           const whenArray = Array.isArray(whenEvent) ? whenEvent : [whenEvent];
           const allEvents = [...givenArray, ...whenArray];
+
           // Transform events to have metadata
           const eventsWithMetadata = allEvents.map((event, index) => ({
             ...event,
-            kind: 'Event',
+            kind: 'Event' as const,
             metadata: {
               streamName: 'test-stream',
               messageId: `test-${index}`,
@@ -37,9 +100,12 @@ function reactorSpecificationFor(processorOrReactor, createContext) {
               globalPosition: BigInt(index + 1),
             },
           }));
+
           const contextWithMock = { ...context, commandSender: mockCommandSender };
+
           // Get the actual reactor instance
           const reactor = typeof processorOrReactor === 'function' ? processorOrReactor() : processorOrReactor;
+
           // Handle different reactor types
           if ('handle' in reactor && typeof reactor.handle === 'function') {
             // It's a MessageProcessor or has a handle method
@@ -52,50 +118,61 @@ function reactorSpecificationFor(processorOrReactor, createContext) {
           } else {
             throw new Error('Reactor must have either a handle or eachMessage method');
           }
+
           return mockCommandSender.sentCommands;
         };
+
         return {
-          then: async (expectedCommand) => {
+          then: async (
+            expectedCommand: Command | Command[] | CommandCheck<Command> | CommandCheck<Command[]>,
+          ): Promise<void> => {
             try {
               const sentCommands = await handle();
+
               if (typeof expectedCommand === 'function') {
                 const checkFn = expectedCommand;
                 if (sentCommands.length === 1) {
                   assertTrue(
-                    checkFn(sentCommands[0]),
+                    (checkFn as CommandCheck<Command>)(sentCommands[0]),
                     `Sent command did not match the expected condition: ${JSON.stringify(sentCommands[0])}`,
                   );
                 } else {
                   assertTrue(
-                    checkFn(sentCommands),
+                    (checkFn as CommandCheck<Command[]>)(sentCommands),
                     `Sent commands did not match the expected condition: ${JSON.stringify(sentCommands)}`,
                   );
                 }
                 return;
               }
+
               if (Array.isArray(expectedCommand)) {
                 assertTrue(
                   sentCommands.length === expectedCommand.length,
                   `Expected ${expectedCommand.length} command(s) to be sent, but ${sentCommands.length} were sent`,
                 );
+
                 expectedCommand.forEach((expected, index) => {
                   const sent = sentCommands[index];
                   assertCommandsMatch(sent, expected, index);
                 });
                 return;
               }
+
               if (sentCommands.length === 0) {
                 throw new AssertionError('No commands were sent');
               }
+
               if (sentCommands.length > 1) {
                 throw new AssertionError(`Expected 1 command to be sent, but ${sentCommands.length} were sent`);
               }
+
               assertCommandsMatch(sentCommands[0], expectedCommand);
             } finally {
               mockCommandSender.reset();
             }
           },
-          thenNothingHappened: async () => {
+
+          thenNothingHappened: async (): Promise<void> => {
             try {
               const sentCommands = await handle();
               if (sentCommands.length > 0) {
@@ -107,7 +184,8 @@ function reactorSpecificationFor(processorOrReactor, createContext) {
               mockCommandSender.reset();
             }
           },
-          thenThrows: async (...args) => {
+
+          thenThrows: async <ErrorType extends Error>(...args: Parameters<ThenThrows<ErrorType>>): Promise<void> => {
             try {
               await handle();
               throw new AssertionError('Reactor did not fail as expected');
@@ -122,17 +200,25 @@ function reactorSpecificationFor(processorOrReactor, createContext) {
     };
   };
 }
+
+interface CommandWithMetadata {
+  metadata?: Record<string, unknown>;
+}
+
 // eslint-disable-next-line complexity
-function assertCommandsMatch(actual, expected, index) {
-  const actualCopy = { ...actual };
-  const expectedCopy = { ...expected };
+function assertCommandsMatch<Command>(actual: Command, expected: Command, index?: number): void {
+  const actualCopy = { ...actual } as CommandWithMetadata & Record<string, unknown>;
+  const expectedCopy = { ...expected } as CommandWithMetadata & Record<string, unknown>;
+
   if (actualCopy.metadata !== undefined && expectedCopy.metadata !== undefined) {
     for (const key in expectedCopy.metadata) {
       const expectedValue = expectedCopy.metadata[key];
       const actualValue = actualCopy.metadata[key];
+
       const expectedStr =
         expectedValue === undefined ? 'undefined' : expectedValue === null ? 'null' : String(expectedValue);
       const actualStr = actualValue === undefined ? 'undefined' : actualValue === null ? 'null' : String(actualValue);
+
       assertTrue(
         actualValue === expectedValue,
         `Command${index !== undefined ? ` at index ${index}` : ''} metadata.${key} does not match.\nExpected: ${expectedStr}\nActual: ${actualStr}`,
@@ -143,21 +229,29 @@ function assertCommandsMatch(actual, expected, index) {
   } else if (actualCopy.metadata !== undefined && expectedCopy.metadata === undefined) {
     delete actualCopy.metadata;
   }
+
   assertTrue(
     JSON.stringify(actualCopy) === JSON.stringify(expectedCopy),
     `Command${index !== undefined ? ` at index ${index}` : ''} does not match.\nExpected: ${JSON.stringify(expected)}\nActual: ${JSON.stringify(actual)}`,
   );
 }
-function thenThrowsErrorHandler(error, args) {
+
+function thenThrowsErrorHandler<ErrorType extends Error>(
+  error: unknown,
+  args: Parameters<ThenThrows<ErrorType>>,
+): void {
   if (error instanceof AssertionError) throw error;
+
   if (args.length === 0) return;
+
   if (!isErrorConstructor(args[0])) {
-    assertTrue(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
+    assertTrue(args[0](error as ErrorType), `Error didn't match the error condition: ${error?.toString()}`);
     return;
   }
+
   assertTrue(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
+
   if (args[1]) {
-    assertTrue(args[1](error), `Error didn't match the error condition: ${error?.toString()}`);
+    assertTrue(args[1](error as ErrorType), `Error didn't match the error condition: ${error?.toString()}`);
   }
 }
-//# sourceMappingURL=reactorSpecification.js.map

package/templates/shopping-app/.context/server/server/src/domain/shared/sendCommand.ts

@@ -0,0 +1,21 @@
+import type { Command, CommandSender } from '@event-driven-io/emmett';
+import type { MutationResponse } from './types';
+
+export async function sendCommand<T extends Command>(
+  commandSender: CommandSender,
+  command: T,
+): Promise<MutationResponse> {
+  try {
+    await commandSender.send(command);
+    return { success: true };
+  } catch (error: unknown) {
+    const err = error as { name?: string; message?: string };
+    return {
+      success: false,
+      error: {
+        type: err?.name ?? 'UnknownError',
+        message: err?.message ?? 'An unexpected error occurred',
+      },
+    };
+  }
+}

package/templates/shopping-app/{server/src/domain/shared/types.d.ts → .context/server/server/src/domain/shared/types.ts}

@@ -1,19 +1,31 @@
 import { CommandSender, InMemoryEventStore } from '@event-driven-io/emmett';
+import { Field, ObjectType } from 'type-graphql';
+
 export interface ReactorContext {
   eventStore: InMemoryEventStore;
   commandSender: CommandSender;
   [key: string]: unknown;
 }
+
 export interface GraphQLContext {
   eventStore: InMemoryEventStore;
   messageBus: CommandSender;
 }
-export declare class MutationError {
-  type: string;
+
+@ObjectType()
+export class MutationError {
+  @Field(() => String)
+  type!: string;
+
+  @Field(() => String, { nullable: true })
   message?: string;
 }
-export declare class MutationResponse {
-  success: boolean;
+
+@ObjectType()
+export class MutationResponse {
+  @Field(() => Boolean)
+  success!: boolean;
+
+  @Field(() => MutationError, { nullable: true })
   error?: MutationError;
 }
-//# sourceMappingURL=types.d.ts.map

package/templates/shopping-app/.context/server/server/src/server.ts

@@ -0,0 +1,43 @@
+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';
+
+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 eventStore = getInMemoryEventStore({
+    projections: projections.inline(loadedProjections),
+    hooks: {
+      onAfterCommit: forwardToMessageBus(messageBus),
+    },
+  });
+
+  await Promise.all(registrations.map((r) => r.register(messageBus, eventStore)));
+
+  const resolvers = await loadResolvers('src/domain/flows/**/*.resolver.{ts,js}');
+  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>],
+  });
+  const server = new ApolloServer({
+    schema,
+    context: () => ({
+      eventStore,
+      messageBus,
+    }),
+  });
+  const { url } = await server.listen({ port: 4000 });
+  console.log(`🚀 GraphQL server ready at ${url}`);
+}
+
+void start();

package/templates/shopping-app/{server/src/utils/index.d.ts → .context/server/server/src/utils/index.ts}

@@ -1,4 +1,3 @@
 export * from './loadResolvers';
 export * from './loadRegisterFiles';
 export * from './loadProjections';
-//# sourceMappingURL=index.d.ts.map

package/templates/shopping-app/{server/src/utils/loadProjections.js → .context/server/server/src/utils/loadProjections.ts}

@@ -1,12 +1,16 @@
 import fg from 'fast-glob';
 import path from 'path';
-export async function loadProjections(source) {
+import type { ProjectionDefinition } from '@event-driven-io/emmett';
+
+export async function loadProjections(source: string): Promise<ProjectionDefinition[]> {
   const files = await fg(source, { absolute: true });
+
   const modules = await Promise.all(
     files.map(async (file) => {
-      const mod = await import(pathToFileUrl(file).href);
+      const mod: unknown = await import(pathToFileUrl(file).href);
+
       if (typeof mod === 'object' && mod !== null && 'projection' in mod) {
-        const projectionModule = mod;
+        const projectionModule = mod as { projection?: ProjectionDefinition };
         if (projectionModule.projection == null) {
           console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
         }
@@ -16,10 +20,11 @@ export async function loadProjections(source) {
       return undefined;
     }),
   );
-  return modules.filter((p) => p != null);
+
+  return modules.filter((p): p is ProjectionDefinition => p != null);
 }
-function pathToFileUrl(filePath) {
+
+function pathToFileUrl(filePath: string): URL {
   const resolved = path.resolve(filePath);
   return new URL(`file://${resolved}`);
 }
-//# sourceMappingURL=loadProjections.js.map

package/templates/shopping-app/.context/server/server/src/utils/loadRegisterFiles.ts

@@ -0,0 +1,41 @@
+import fg from 'fast-glob';
+import path from 'path';
+import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
+
+export interface SliceRegistration {
+  register: (messageBus: CommandProcessor, eventStore: EventStore) => Promise<unknown> | void;
+}
+
+export async function loadRegisterFiles(source: string): Promise<SliceRegistration[]> {
+  const files = await fg(source, { absolute: true });
+
+  const modules = await Promise.all(
+    files.map(async (file) => {
+      try {
+        const mod: unknown = await import(pathToFileUrl(file).href);
+
+        if (
+          typeof mod === 'object' &&
+          mod !== null &&
+          'register' in mod &&
+          typeof (mod as SliceRegistration).register === 'function'
+        ) {
+          return mod as SliceRegistration;
+        }
+
+        console.warn('⚠️ Skipping invalid register.ts at', file);
+        return null;
+      } catch (error) {
+        console.error('❌ Failed to import', file, ':', error);
+        return null;
+      }
+    }),
+  );
+
+  return modules.filter((m): m is SliceRegistration => m !== null);
+}
+
+function pathToFileUrl(filePath: string): URL {
+  const resolved = path.resolve(filePath);
+  return new URL(`file://${resolved}`);
+}

package/templates/shopping-app/{server/src/utils/loadResolvers.js → .context/server/server/src/utils/loadResolvers.ts}

@@ -1,27 +1,36 @@
 import fg from 'fast-glob';
-export async function loadResolvers(source) {
+
+export interface Resolver {
+  (...args: unknown[]): unknown;
+}
+
+export async function loadResolvers(source: string): Promise<Resolver[]> {
   const files = await fg(source, {
     absolute: true,
   });
-  const modules = await Promise.all(files.map((file) => import(file)));
-  const allResolvers = [];
+  const modules: unknown[] = await Promise.all(files.map((file) => import(file)));
+  const allResolvers: Resolver[] = [];
+
   for (const mod of modules) {
     if (typeof mod !== 'object' || mod === null) {
       continue;
     }
+
     for (const key of Object.keys(mod)) {
-      const exported = mod[key];
+      const exported = (mod as Record<string, unknown>)[key];
+
       if (typeof exported === 'function') {
-        allResolvers.push(exported);
+        allResolvers.push(exported as Resolver);
       }
+
       if (Array.isArray(exported) && exported.every((r) => typeof r === 'function')) {
-        allResolvers.push(...exported);
+        allResolvers.push(...(exported as Resolver[]));
       }
     }
   }
+
   if (allResolvers.length === 0) {
     throw new Error('❌ No resolvers found for any slices.');
   }
   return allResolvers;
 }
-//# sourceMappingURL=loadResolvers.js.map

package/templates/shopping-app/.context/server/server/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true
+  },
+  "include": ["src/**/*", "vitest.config.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/templates/shopping-app/.context/server/server/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.specs.ts'],
+  },
+});