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

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

@@ -1,26 +0,0 @@
-{
-  "name": "generated-server",
-  "version": "0.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "start": "tsx src/server.ts",
-    "type-check": "tsc --noEmit",
-    "test": "vitest run",
-    "dev": "tsx src/server.ts"
-  },
-  "dependencies": {
-    "@event-driven-io/emmett": "^0.38.2",
-    "type-graphql": "^2.0.0-rc.2",
-    "graphql": "^16.11.0",
-    "fast-glob": "^3.3.3",
-    "reflect-metadata": "^0.2.2",
-    "apollo-server": "^3.13.0",
-    "uuid": "^10.0.0"
-  },
-  "devDependencies": {
-    "typescript": "~5.5.0",
-    "vitest": "^3.2.3",
-    "tsx": "^4.7.1"
-  }
-}

package/.tmp/server-test-output/server/scripts/generate-schema.ts

@@ -1,31 +0,0 @@
-import 'reflect-metadata';
-import { buildSchema } from 'type-graphql';
-import { printSchema } from 'graphql';
-import { writeFile } from 'fs/promises';
-import * as path from 'path';
-import { loadResolvers } from '../src/utils/loadResolvers.js';
-
-async function main() {
-  try {
-    const resolvers = await loadResolvers('src/domain/flows/**/*.resolver.{ts,js}');
-    const schema = await buildSchema({
-      resolvers: resolvers as any,
-      emitSchemaFile: false,
-    });
-    const printedSchema = printSchema(schema);
-
-    const contextDir = path.resolve('/Users/sam/WebstormProjects/auto-engineer/packages/emmett-generator/.tmp/server-test-output', '.context');
-    const schemaPath = path.join(contextDir, 'schema.graphql');
-    await writeFile(schemaPath, printedSchema, 'utf-8');
-
-    console.log(`✅ GraphQL schema generated at: ${schemaPath}`);
-  } catch (error) {
-    console.error(`❌ GraphQL schema generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    process.exit(1);
-  }
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/commands.ts

@@ -1,8 +0,0 @@
-import { Command } from '@event-driven-io/emmett';
-export type CreateItem = Command<
-  'CreateItem',
-  {
-    itemId: string;
-    description: string;
-  }
->;

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/decide.specs.ts

@@ -1,36 +0,0 @@
-import { describe, it } from 'vitest';
-import { DeciderSpecification } from '@event-driven-io/emmett';
-import { decide } from './decide';
-import { evolve } from './evolve';
-import { initialState } from './state';
-
-describe('Add item | Create item', () => {
-  const given = DeciderSpecification.for({
-    decide,
-    evolve,
-    initialState,
-  });
-
-  it('should emit ItemCreated for valid CreateItem', () => {
-    given([])
-      .when({
-        type: 'CreateItem',
-        data: {
-          itemId: 'item_123',
-          description: 'A new item',
-        },
-        metadata: { now: new Date() },
-      })
-
-      .then([
-        {
-          type: 'ItemCreated',
-          data: {
-            id: 'item_123',
-            description: 'A new item',
-            addedAt: new Date('2024-01-15T10:00:00.000Z'),
-          },
-        },
-      ]);
-  });
-});

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/decide.ts

@@ -1,33 +0,0 @@
-import { IllegalStateError } from '@event-driven-io/emmett';
-import type { State } from './state';
-import type { CreateItem } from './commands';
-import type { ItemCreated } from './events';
-
-export const decide = (command: CreateItem, state: State): ItemCreated => {
-  switch (command.type) {
-    case 'CreateItem': {
-      /**
-       * ## IMPLEMENTATION INSTRUCTIONS ##
-       *
-       * This command can directly emit one or more events based on the input.
-       *
-       * You should:
-       * - Validate the command input fields
-       * - Inspect the current domain `state` to determine if the command is allowed
-       * - If invalid, throw one of the following domain errors: `NotFoundError`, `ValidationError`, or `IllegalStateError`
-       * - If valid, return one or more events with the correct structure
-       *
-       * ⚠️ Only read from inputs — never mutate them. `evolve.ts` handles state updates.
-       */
-
-      // return {
-      //   type: 'ItemCreated',
-      //   data: { ...command.data },
-      // } as ItemCreated;
-
-      throw new IllegalStateError('Not yet implemented: ' + command.type);
-    }
-    default:
-      throw new IllegalStateError('Unexpected command type: ' + command.type);
-  }
-};

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/events.ts

@@ -1,10 +0,0 @@
-import type { Event } from '@event-driven-io/emmett';
-
-export type ItemCreated = Event<
-  'ItemCreated',
-  {
-    id: string;
-    description: string;
-    addedAt: Date;
-  }
->;

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/evolve.ts

@@ -1,28 +0,0 @@
-import type { State } from './state';
-import type { ItemCreated } from './events';
-
-/**
- * ## IMPLEMENTATION INSTRUCTIONS ##
- *
- * This function defines how the domain state evolves in response to events.
- *
- * Guidelines:
- * - Apply only the **minimal** necessary changes for future decisions in `decide.ts`.
- * - Ignore any event fields not required for decision-making logic.
- * - If the event doesn’t change decision-relevant state, return the existing `state`.
- * - Prefer immutability: always return a **new state object**.
- * - Avoid spreading all of `event.data` unless all fields are relevant.
- */
-
-export const evolve = (state: State, event: ItemCreated): State => {
-  switch (event.type) {
-    case 'ItemCreated': {
-      // TODO: Update state based on ItemCreated
-      return {
-        ...state,
-      };
-    }
-    default:
-      return state;
-  }
-};

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/handle.ts

@@ -1,24 +0,0 @@
-import { CommandHandler, type EventStore, type MessageHandlerResult } from '@event-driven-io/emmett';
-import { evolve } from './evolve';
-import { initialState } from './state';
-import { decide } from './decide';
-import type { CreateItem } from './commands';
-
-const handler = CommandHandler({
-  evolve,
-  initialState,
-});
-
-export const handle = async (eventStore: EventStore, command: CreateItem): Promise<MessageHandlerResult> => {
-  const streamId = 'unknown-stream';
-
-  try {
-    await handler(eventStore, streamId, (state) => decide(command, state));
-    return; // success (returns void)
-  } catch (error: any) {
-    return {
-      type: 'SKIP',
-      reason: `Command failed: ${error?.message ?? 'Unknown'}`,
-    };
-  }
-};

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/mutation.resolver.ts

@@ -1,25 +0,0 @@
-import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
-import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
-
-@InputType()
-export class CreateItemInput {
-  @Field(() => String)
-  itemId!: string;
-  @Field(() => String)
-  description!: string;
-}
-
-@Resolver()
-export class CreateItemResolver {
-  @Mutation(() => MutationResponse)
-  async createItem(
-    @Arg('input', () => CreateItemInput) input: CreateItemInput,
-    @Ctx() ctx: GraphQLContext,
-  ): Promise<MutationResponse> {
-    return await sendCommand(ctx.messageBus, {
-      type: 'CreateItem',
-      kind: 'Command',
-      data: { ...input },
-    });
-  }
-}

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/register.ts

@@ -1,7 +0,0 @@
-import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
-import { handle } from './handle';
-import type { CreateItem } from './commands';
-
-export function register(messageBus: CommandProcessor, eventStore: EventStore) {
-  messageBus.handle((command: CreateItem) => handle(eventStore, command), 'CreateItem');
-}

package/.tmp/server-test-output/server/src/domain/flows/add-item/create-item/state.ts

@@ -1,47 +0,0 @@
-/**
- * ## IMPLEMENTATION INSTRUCTIONS ##
- *
- * Define the shape of the domain state for the current slice below. This state is used by `decide.ts`
- * to determine whether a command is valid.
- *
- * The state is evolved over time by applying domain events (in `evolve.ts`).
- * Each event updates the state incrementally based on business rules.
- *
- * Guidelines:
- * - Include only fields that are **read** during command validation.
- * - Use discriminated unions (e.g., `status: 'Pending' | 'Done'`) to model state transitions.
- * - Prefer primitive types: `string`, `boolean`, `number`.
- * - Use objects or maps only when structure is essential for decision logic.
- *
- * Do NOT include:
- * - Redundant data already emitted in events unless required to enforce business rules.
- * - Fields used only for projections, UI, or query purposes.
- *
- * ### Example (for a Task domain):
- *
- * ```ts
- * export type PendingTask = {
- *   status: 'Pending';
- * };
- *
- * export type InProgressTask = {
- *   status: 'InProgress';
- *   startedAt: string;
- * };
- *
- * export type CompletedTask = {
- *   status: 'Completed';
- *   completedAt: string;
- * };
- *
- * export type State = PendingTask | InProgressTask | CompletedTask;
- * ```
- */
-
-// TODO: Replace with a discriminated union of domain states for the current slice
-export type State = {};
-
-// TODO: Replace the Return with the initial domain state of the current slice
-export const initialState = (): State => {
-  return {};
-};

package/.tmp/server-test-output/server/src/domain/flows/add-item/get-available-items/projection.specs.ts

@@ -1,46 +0,0 @@
-import { describe, it, beforeEach, expect } from 'vitest';
-import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
-import { projection } from './projection';
-import type { ItemCreated } from '../create-item/events';
-import { AvailableItems } from './state';
-
-type ProjectionEvent = ItemCreated;
-
-describe('ItemCreated Projection', () => {
-  let given: InMemoryProjectionSpec<ProjectionEvent>;
-
-  beforeEach(() => {
-    given = InMemoryProjectionSpec.for({ projection });
-  });
-
-  it('creates or updates AvailableItems document - case 1', () =>
-    given([
-      {
-        type: 'ItemCreated',
-        data: {
-          id: 'item_123',
-          description: 'A new item',
-          addedAt: new Date('2024-01-15T10:00:00.000Z'),
-        },
-        metadata: {
-          streamName: 'ignored-stream',
-          streamPosition: 1n,
-          globalPosition: 1n,
-        },
-      },
-    ])
-      .when([])
-      .then(async (state) => {
-        const document = await state.database
-          .collection<AvailableItems>('item-created')
-          .findOne((doc) => doc.id === 'item_123');
-
-        const expected: AvailableItems = {
-          id: 'item_123',
-          description: 'A new item',
-          addedAt: new Date('2024-01-15T10:00:00.000Z'),
-        };
-
-        expect(document).toMatchObject(expected);
-      }));
-});

package/.tmp/server-test-output/server/src/domain/flows/add-item/get-available-items/projection.ts

@@ -1,38 +0,0 @@
-import {
-  inMemorySingleStreamProjection,
-  type ReadEvent,
-  type InMemoryReadEventMetadata,
-} from '@event-driven-io/emmett';
-import type { AvailableItems } from './state';
-import type { ItemCreated } from '../create-item/events';
-
-type AllEvents = ItemCreated;
-
-export const projection = inMemorySingleStreamProjection<AvailableItems, AllEvents>({
-  collectionName: 'item-created',
-  canHandle: ['ItemCreated'],
-  getDocumentId: (event) => event.data.id,
-  evolve: (
-    document: AvailableItems | null,
-    event: ReadEvent<AllEvents, InMemoryReadEventMetadata>,
-  ): AvailableItems | null => {
-    switch (event.type) {
-      case 'ItemCreated': {
-        /**
-         * ## IMPLEMENTATION INSTRUCTIONS ##
-         * This event adds or updates the document.
-         * Implement the correct fields as needed for your read model.
-         */
-        return {
-          id: /* TODO: map from event.data */ '',
-          description: /* TODO: map from event.data */ '',
-          addedAt: /* TODO: map from event.data */ new Date(),
-        };
-      }
-      default:
-        return document;
-    }
-  },
-});
-
-export default projection;

package/.tmp/server-test-output/server/src/domain/flows/add-item/get-available-items/query.resolver.ts

@@ -1,39 +0,0 @@
-import { Query, Resolver, Arg, Ctx, ObjectType, Field } from 'type-graphql';
-import { type GraphQLContext, ReadModel } from '../../../shared';
-
-@ObjectType()
-export class AvailableItems {
-  @Field(() => String)
-  id!: string;
-
-  @Field(() => String)
-  description!: string;
-
-  @Field(() => Date)
-  addedAt!: Date;
-
-  [key: string]: unknown;
-}
-
-@Resolver()
-export class GetAvailableItemsQueryResolver {
-  @Query(() => [AvailableItems])
-  async getAvailableItems(@Ctx() ctx: GraphQLContext): Promise<AvailableItems[]> {
-    const model = new ReadModel<AvailableItems>(ctx.eventStore, 'ItemCreated');
-
-    // ## 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) => {
-      return true;
-    });
-  }
-}

package/.tmp/server-test-output/server/src/domain/flows/add-item/get-available-items/state.ts

@@ -1,5 +0,0 @@
-export type AvailableItems = {
-  id: string;
-  description: string;
-  addedAt: Date;
-};

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

@@ -1,8 +0,0 @@
-import { Command } from '@event-driven-io/emmett';
-export type NotifyNewItem = Command<
-  'NotifyNewItem',
-  {
-    itemId: string;
-    message: string;
-  }
->;

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

@@ -1,36 +0,0 @@
-import { describe, it } from 'vitest';
-import { DeciderSpecification } from '@event-driven-io/emmett';
-import { decide } from './decide';
-import { evolve } from './evolve';
-import { initialState } from './state';
-
-describe('Add item | Notify new item', () => {
-  const given = DeciderSpecification.for({
-    decide,
-    evolve,
-    initialState,
-  });
-
-  it('should emit NotificationSent for valid NotifyNewItem', () => {
-    given([])
-      .when({
-        type: 'NotifyNewItem',
-        data: {
-          itemId: 'item_123',
-          message: 'A new item was added to the system.',
-        },
-        metadata: { now: new Date() },
-      })
-
-      .then([
-        {
-          type: 'NotificationSent',
-          data: {
-            itemId: 'item_123',
-            message: 'A new item was added to the system.',
-            sentAt: '2024-01-15T10:00:00.000Z',
-          },
-        },
-      ]);
-  });
-});

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

@@ -1,33 +0,0 @@
-import { IllegalStateError } from '@event-driven-io/emmett';
-import type { State } from './state';
-import type { NotifyNewItem } from './commands';
-import type { NotificationSent } from './events';
-
-export const decide = (command: NotifyNewItem, state: State): NotificationSent => {
-  switch (command.type) {
-    case 'NotifyNewItem': {
-      /**
-       * ## IMPLEMENTATION INSTRUCTIONS ##
-       *
-       * This command can directly emit one or more events based on the input.
-       *
-       * You should:
-       * - Validate the command input fields
-       * - Inspect the current domain `state` to determine if the command is allowed
-       * - If invalid, throw one of the following domain errors: `NotFoundError`, `ValidationError`, or `IllegalStateError`
-       * - If valid, return one or more events with the correct structure
-       *
-       * ⚠️ Only read from inputs — never mutate them. `evolve.ts` handles state updates.
-       */
-
-      // return {
-      //   type: 'NotificationSent',
-      //   data: { ...command.data },
-      // } as NotificationSent;
-
-      throw new IllegalStateError('Not yet implemented: ' + command.type);
-    }
-    default:
-      throw new IllegalStateError('Unexpected command type: ' + command.type);
-  }
-};

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

@@ -1,3 +0,0 @@
-import type { Event } from '@event-driven-io/emmett';
-
-export type NotificationSent = Event<'NotificationSent', {}>;

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

@@ -1,28 +0,0 @@
-import type { State } from './state';
-import type { NotificationSent } from './events';
-
-/**
- * ## IMPLEMENTATION INSTRUCTIONS ##
- *
- * This function defines how the domain state evolves in response to events.
- *
- * Guidelines:
- * - Apply only the **minimal** necessary changes for future decisions in `decide.ts`.
- * - Ignore any event fields not required for decision-making logic.
- * - If the event doesn’t change decision-relevant state, return the existing `state`.
- * - Prefer immutability: always return a **new state object**.
- * - Avoid spreading all of `event.data` unless all fields are relevant.
- */
-
-export const evolve = (state: State, event: NotificationSent): State => {
-  switch (event.type) {
-    case 'NotificationSent': {
-      // TODO: Update state based on NotificationSent
-      return {
-        ...state,
-      };
-    }
-    default:
-      return state;
-  }
-};

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

@@ -1,24 +0,0 @@
-import { CommandHandler, type EventStore, type MessageHandlerResult } from '@event-driven-io/emmett';
-import { evolve } from './evolve';
-import { initialState } from './state';
-import { decide } from './decide';
-import type { NotifyNewItem } from './commands';
-
-const handler = CommandHandler({
-  evolve,
-  initialState,
-});
-
-export const handle = async (eventStore: EventStore, command: NotifyNewItem): Promise<MessageHandlerResult> => {
-  const streamId = 'unknown-stream';
-
-  try {
-    await handler(eventStore, streamId, (state) => decide(command, state));
-    return; // success (returns void)
-  } catch (error: any) {
-    return {
-      type: 'SKIP',
-      reason: `Command failed: ${error?.message ?? 'Unknown'}`,
-    };
-  }
-};

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

@@ -1,25 +0,0 @@
-import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
-import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
-
-@InputType()
-export class NotifyNewItemInput {
-  @Field(() => String)
-  itemId!: string;
-  @Field(() => String)
-  message!: string;
-}
-
-@Resolver()
-export class NotifyNewItemResolver {
-  @Mutation(() => MutationResponse)
-  async notifyNewItem(
-    @Arg('input', () => NotifyNewItemInput) input: NotifyNewItemInput,
-    @Ctx() ctx: GraphQLContext,
-  ): Promise<MutationResponse> {
-    return await sendCommand(ctx.messageBus, {
-      type: 'NotifyNewItem',
-      kind: 'Command',
-      data: { ...input },
-    });
-  }
-}

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

@@ -1,7 +0,0 @@
-import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
-import { handle } from './handle';
-import type { NotifyNewItem } from './commands';
-
-export function register(messageBus: CommandProcessor, eventStore: EventStore) {
-  messageBus.handle((command: NotifyNewItem) => handle(eventStore, command), 'NotifyNewItem');
-}

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

@@ -1,47 +0,0 @@
-/**
- * ## IMPLEMENTATION INSTRUCTIONS ##
- *
- * Define the shape of the domain state for the current slice below. This state is used by `decide.ts`
- * to determine whether a command is valid.
- *
- * The state is evolved over time by applying domain events (in `evolve.ts`).
- * Each event updates the state incrementally based on business rules.
- *
- * Guidelines:
- * - Include only fields that are **read** during command validation.
- * - Use discriminated unions (e.g., `status: 'Pending' | 'Done'`) to model state transitions.
- * - Prefer primitive types: `string`, `boolean`, `number`.
- * - Use objects or maps only when structure is essential for decision logic.
- *
- * Do NOT include:
- * - Redundant data already emitted in events unless required to enforce business rules.
- * - Fields used only for projections, UI, or query purposes.
- *
- * ### Example (for a Task domain):
- *
- * ```ts
- * export type PendingTask = {
- *   status: 'Pending';
- * };
- *
- * export type InProgressTask = {
- *   status: 'InProgress';
- *   startedAt: string;
- * };
- *
- * export type CompletedTask = {
- *   status: 'Completed';
- *   completedAt: string;
- * };
- *
- * export type State = PendingTask | InProgressTask | CompletedTask;
- * ```
- */
-
-// TODO: Replace with a discriminated union of domain states for the current slice
-export type State = {};
-
-// TODO: Replace the Return with the initial domain state of the current slice
-export const initialState = (): State => {
-  return {};
-};