@auto-engineer/server-generator-apollo-emmett 0.1.4 → 0.2.0

package/.tmp/server-test-output/server/src/domain/flows/add-item/notify-on-new-item/react.specs.ts

@@ -1,49 +0,0 @@
-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 { ItemCreated } from '../create-item/events';
-import type { NotifyNewItem } from '../notify-new-item/commands';
-
-describe('AddItem | NotifyOnNewItem', () => {
-  let eventStore: InMemoryEventStore;
-  let given: ReactorSpecification<ItemCreated, NotifyNewItem, ReactorContext>;
-  let messageBus: CommandSender;
-
-  beforeEach(() => {
-    eventStore = getInMemoryEventStore({});
-    given = ReactorSpecification.for<ItemCreated, NotifyNewItem, ReactorContext>(
-      () => react({ eventStore, commandSender: messageBus }),
-      (commandSender) => {
-        messageBus = commandSender;
-        return {
-          eventStore,
-          commandSender,
-          database: eventStore.database,
-        };
-      },
-    );
-  });
-
-  it('should send NotifyNewItem when ItemCreated is received', async () => {
-    await given([])
-      .when({
-        type: 'ItemCreated',
-        data: {
-          id: 'item_123',
-          description: 'A new item',
-          addedAt: new Date('2024-01-15T10:00:00.000Z'),
-        },
-      })
-
-      .then({
-        type: 'NotifyNewItem',
-        kind: 'Command',
-        data: {
-          itemId: 'item_123',
-          message: 'A new item was added to the system.',
-        },
-      });
-  });
-});

package/.tmp/server-test-output/server/src/domain/flows/add-item/notify-on-new-item/react.ts

@@ -1,43 +0,0 @@
-import { inMemoryReactor, type MessageHandlerResult, IllegalStateError } from '@event-driven-io/emmett';
-import type { ItemCreated } from '../create-item/events';
-import type { ReactorContext } from '../../../shared';
-
-export const react = ({ eventStore, commandSender }: ReactorContext) =>
-  inMemoryReactor<ItemCreated>({
-    processorId: 'add-item-notify-on-new-item',
-    canHandle: ['ItemCreated'],
-    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 ItemCreated');
-
-      // Example:
-      // if (event.data.status !== 'expected') {
-      //   return {
-      //     type: 'SKIP',
-      //     reason: 'Condition not met',
-      //   };
-      // }
-
-      // await context.commandSender.send({
-      //   type: 'NotifyNewItem',
-      //   kind: 'Command',
-      //   data: {
-      //     // Map event fields to command fields here
-      //     // e.g., userId: event.data.userId,
-      //   },
-      // });
-
-      // return;
-    },
-  });

package/.tmp/server-test-output/server/src/domain/flows/add-item/notify-on-new-item/register.ts

@@ -1,24 +0,0 @@
-import { type CommandSender, type EventSubscription, type InMemoryEventStore } from '@event-driven-io/emmett';
-import type { ItemCreated } from '../create-item/events';
-
-export async function register(messageBus: CommandSender & EventSubscription, eventStore: InMemoryEventStore) {
-  messageBus.subscribe(async (event: ItemCreated) => {
-    /**
-     * ## IMPLEMENTATION INSTRUCTIONS ##
-     *
-     * - Replace the placeholder logic with the  real implementation.
-     * - Send one or more commands via: messageBus.send({...})
-     */
-
-    // await messageBus.send({
-    //   type: 'NotifyNewItem',
-    //   kind: 'Command',
-    //   data: {
-    //     // Map event fields to command fields here
-    //     // e.g., userId: event.data.userId,
-    //   },
-    // });
-
-    return;
-  }, 'ItemCreated');
-}

package/.tmp/server-test-output/server/src/domain/shared/ReadModel.ts

@@ -1,26 +0,0 @@
-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/.tmp/server-test-output/server/src/domain/shared/index.ts

@@ -1,4 +0,0 @@
-export * from './types';
-export * from './ReadModel';
-export * from './reactorSpecification';
-export * from './sendCommand';

package/.tmp/server-test-output/server/src/domain/shared/reactorSpecification.ts

@@ -1,257 +0,0 @@
-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,
-};
-
-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>;
-}
-
-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: 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' as const,
-            metadata: {
-              streamName: 'test-stream',
-              messageId: `test-${index}`,
-              streamPosition: BigInt(index + 1),
-              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
-            await reactor.handle(eventsWithMetadata, contextWithMock);
-          } else if ('eachMessage' in reactor && typeof reactor.eachMessage === 'function') {
-            // It has eachMessage
-            for (const event of eventsWithMetadata) {
-              await reactor.eachMessage(event, contextWithMock);
-            }
-          } else {
-            throw new Error('Reactor must have either a handle or eachMessage method');
-          }
-
-          return mockCommandSender.sentCommands;
-        };
-
-        return {
-          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 as CommandCheck<Command>)(sentCommands[0]),
-                    `Sent command did not match the expected condition: ${JSON.stringify(sentCommands[0])}`,
-                  );
-                } else {
-                  assertTrue(
-                    (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 (): Promise<void> => {
-            try {
-              const sentCommands = await handle();
-              if (sentCommands.length > 0) {
-                throw new AssertionError(
-                  `Expected no commands to be sent, but ${sentCommands.length} command(s) were sent: ${JSON.stringify(sentCommands)}`,
-                );
-              }
-            } finally {
-              mockCommandSender.reset();
-            }
-          },
-
-          thenThrows: async <ErrorType extends Error>(...args: Parameters<ThenThrows<ErrorType>>): Promise<void> => {
-            try {
-              await handle();
-              throw new AssertionError('Reactor did not fail as expected');
-            } catch (error) {
-              thenThrowsErrorHandler(error, args);
-            } finally {
-              mockCommandSender.reset();
-            }
-          },
-        };
-      },
-    };
-  };
-}
-
-interface CommandWithMetadata {
-  metadata?: Record<string, unknown>;
-}
-
-// eslint-disable-next-line complexity
-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}`,
-      );
-    }
-    delete actualCopy.metadata;
-    delete expectedCopy.metadata;
-  } 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<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 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 as ErrorType), `Error didn't match the error condition: ${error?.toString()}`);
-  }
-}

package/.tmp/server-test-output/server/src/domain/shared/sendCommand.ts

@@ -1,21 +0,0 @@
-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/.tmp/server-test-output/server/src/domain/shared/types.ts

@@ -1,31 +0,0 @@
-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;
-}
-
-@ObjectType()
-export class MutationError {
-  @Field(() => String)
-  type!: string;
-
-  @Field(() => String, { nullable: true })
-  message?: string;
-}
-
-@ObjectType()
-export class MutationResponse {
-  @Field(() => Boolean)
-  success!: boolean;
-
-  @Field(() => MutationError, { nullable: true })
-  error?: MutationError;
-}

package/.tmp/server-test-output/server/src/server.ts

@@ -1,43 +0,0 @@
-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/.tmp/server-test-output/server/src/utils/index.ts

@@ -1,3 +0,0 @@
-export * from './loadResolvers';
-export * from './loadRegisterFiles';
-export * from './loadProjections';

package/.tmp/server-test-output/server/src/utils/loadProjections.ts

@@ -1,30 +0,0 @@
-import fg from 'fast-glob';
-import path from 'path';
-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: unknown = await import(pathToFileUrl(file).href);
-
-      if (typeof mod === 'object' && mod !== null && 'projection' in mod) {
-        const projectionModule = mod as { projection?: ProjectionDefinition };
-        if (projectionModule.projection == null) {
-          console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
-        }
-        return projectionModule.projection;
-      }
-      console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
-      return undefined;
-    }),
-  );
-
-  return modules.filter((p): p is ProjectionDefinition => p != null);
-}
-
-function pathToFileUrl(filePath: string): URL {
-  const resolved = path.resolve(filePath);
-  return new URL(`file://${resolved}`);
-}

package/.tmp/server-test-output/server/src/utils/loadRegisterFiles.ts

@@ -1,41 +0,0 @@
-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/.tmp/server-test-output/server/src/utils/loadResolvers.ts

@@ -1,36 +0,0 @@
-import fg from 'fast-glob';
-
-export interface Resolver {
-  (...args: unknown[]): unknown;
-}
-
-export async function loadResolvers(source: string): Promise<Resolver[]> {
-  const files = await fg(source, {
-    absolute: true,
-  });
-  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 as Record<string, unknown>)[key];
-
-      if (typeof exported === 'function') {
-        allResolvers.push(exported as Resolver);
-      }
-
-      if (Array.isArray(exported) && exported.every((r) => typeof r === 'function')) {
-        allResolvers.push(...(exported as Resolver[]));
-      }
-    }
-  }
-
-  if (allResolvers.length === 0) {
-    throw new Error('❌ No resolvers found for any slices.');
-  }
-  return allResolvers;
-}

package/.tmp/server-test-output/server/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "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/.tmp/server-test-output/server/vitest.config.ts

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