create-auto-app 0.2.3 → 0.8.4

package/templates/shopping-app/.context/server/.context/auto-ia-scheme.json

@@ -0,0 +1,79 @@
+{
+  "components": {
+    "atoms": {
+      "items": {}
+    },
+    "molecules": {
+      "items": {
+        "ShoppingCriteriaInput": {
+          "description": "Input component for shoppers to describe their shopping criteria.",
+          "composition": {
+            "atoms": ["TextInput", "Button"],
+            "molecules": []
+          },
+          "specs": [
+            "allow shopper to describe their shopping needs in natural language",
+            "provide a text input for entering criteria",
+            "show examples of what to include (age, interests, budget)",
+            "show a button to submit the criteria"
+          ]
+        },
+        "SuggestedItemsList": {
+          "description": "Displays a list of suggested shopping items with quantity selectors.",
+          "composition": {
+            "atoms": ["Text", "QuantitySelector", "Button"],
+            "molecules": []
+          },
+          "specs": [
+            "display all suggested items with names and reasons",
+            "show quantity selectors for each item",
+            "have an 'Add to Cart' button for selected items",
+            "allow removing items from the suggestions"
+          ]
+        }
+      }
+    },
+    "organisms": {
+      "items": {
+        "ShoppingAssistant": {
+          "description": "Main component that manages the shopping criteria input and suggested items display.",
+          "composition": {
+            "molecules": ["ShoppingCriteriaInput", "SuggestedItemsList"]
+          },
+          "data_requirements": [
+            {
+              "type": "query",
+              "description": "Fetch suggested items based on shopper's criteria.",
+              "trigger": "When shopping criteria is entered.",
+              "details": {
+                "source": "AI integration",
+                "gql": "query GetSuggestedItems($sessionId: ID!) { suggestedItems(sessionId: $sessionId) { items { productId name quantity reason } } }"
+              }
+            }
+          ]
+        }
+      }
+    }
+  },
+  "pages": {
+    "ShoppingAssistantPage": {
+      "route": "/shopping-assistant",
+      "description": "Page for shoppers to interact with the shopping assistant.",
+      "layout": {
+        "organisms": ["ShoppingAssistant"]
+      },
+      "navigation": [],
+      "data_requirements": [
+        {
+          "type": "mutation",
+          "description": "Enter shopping criteria.",
+          "trigger": "When shopper submits their criteria.",
+          "details": {
+            "source": "User input",
+            "gql": "mutation EnterShoppingCriteria($input: EnterShoppingCriteriaInput!) { enterShoppingCriteria(input: $input) { success error { type message } } }"
+          }
+        }
+      ]
+    }
+  }
+}

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

@@ -0,0 +1,26 @@
+{
+  "name": "generated-server",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "tsx --no-deprecation src/server.ts",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run --reporter=dot",
+    "dev": "tsx --no-deprecation 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.8.3",
+    "vitest": "^3.2.3",
+    "tsx": "^4.7.1"
+  }
+}

package/templates/shopping-app/.context/server/server/scripts/generate-schema.ts

@@ -0,0 +1,34 @@
+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/ramihatoum/WebstormProjects/xolvio/auto-engineer/examples/shopping-app/.context/server',
+      '.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/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/commands.ts

@@ -0,0 +1,8 @@
+import { Command } from '@event-driven-io/emmett';
+export type AddItemsToCart = Command<
+  'AddItemsToCart',
+  {
+    sessionId: string;
+    items: Array<{ productId: string; quantity: number }>;
+  }
+>;

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/decide.specs.ts

@@ -0,0 +1,46 @@
+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('Seasonal Assistant | accepts items and adds to their cart', () => {
+  const given = DeciderSpecification.for({
+    decide,
+    evolve,
+    initialState,
+  });
+
+  it('should emit ItemsAddedToCart for valid AddItemsToCart', () => {
+    given([])
+      .when({
+        type: 'AddItemsToCart',
+        data: {
+          sessionId: 'session-abc',
+          items: [
+            { productId: 'prod-soccer-ball', quantity: 1 },
+            { productId: 'prod-craft-kit', quantity: 1 },
+            { productId: 'prod-laptop-bag', quantity: 1 },
+            { productId: 'prod-mtg-starter', quantity: 1 },
+          ],
+        },
+        metadata: { now: new Date() },
+      })
+
+      .then([
+        {
+          type: 'ItemsAddedToCart',
+          data: {
+            sessionId: 'session-abc',
+            items: [
+              { productId: 'prod-soccer-ball', quantity: 1 },
+              { productId: 'prod-craft-kit', quantity: 1 },
+              { productId: 'prod-laptop-bag', quantity: 1 },
+              { productId: 'prod-mtg-starter', quantity: 1 },
+            ],
+            timestamp: new Date('2025-09-04T21:20:20.310Z'),
+          },
+        },
+      ]);
+  });
+});

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/decide.ts

@@ -0,0 +1,33 @@
+import { IllegalStateError } from '@event-driven-io/emmett';
+import type { State } from './state';
+import type { AddItemsToCart } from './commands';
+import type { ItemsAddedToCart } from './events';
+
+export const decide = (command: AddItemsToCart, state: State): ItemsAddedToCart => {
+  switch (command.type) {
+    case 'AddItemsToCart': {
+      /**
+       * ## 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: 'ItemsAddedToCart',
+      //   data: { ...command.data },
+      // } as ItemsAddedToCart;
+
+      throw new IllegalStateError('Not yet implemented: ' + command.type);
+    }
+    default:
+      throw new IllegalStateError('Unexpected command type: ' + command.type);
+  }
+};

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/events.ts

@@ -0,0 +1,10 @@
+import type { Event } from '@event-driven-io/emmett';
+
+export type ItemsAddedToCart = Event<
+  'ItemsAddedToCart',
+  {
+    sessionId: string;
+    items: Array<{ productId: string; quantity: number }>;
+    timestamp: Date;
+  }
+>;

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/evolve.ts

@@ -0,0 +1,28 @@
+import type { State } from './state';
+import type { ItemsAddedToCart } 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: ItemsAddedToCart): State => {
+  switch (event.type) {
+    case 'ItemsAddedToCart': {
+      // TODO: Update state based on ItemsAddedToCart
+      return {
+        ...state,
+      };
+    }
+    default:
+      return state;
+  }
+};

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/handle.ts

@@ -0,0 +1,24 @@
+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 { AddItemsToCart } from './commands';
+
+const handler = CommandHandler({
+  evolve,
+  initialState,
+});
+
+export const handle = async (eventStore: EventStore, command: AddItemsToCart): Promise<MessageHandlerResult> => {
+  const streamId = `shopping-session-${command.data.sessionId}`;
+
+  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/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/mutation.resolver.ts

@@ -0,0 +1,25 @@
+import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
+import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+
+@InputType()
+export class AddItemsToCartInput {
+  @Field(() => String)
+  sessionId!: string;
+  @Field(() => String)
+  items!: Array<{ productId: string; quantity: number }>;
+}
+
+@Resolver()
+export class AddItemsToCartResolver {
+  @Mutation(() => MutationResponse)
+  async addItemsToCart(
+    @Arg('input', () => AddItemsToCartInput) input: AddItemsToCartInput,
+    @Ctx() ctx: GraphQLContext,
+  ): Promise<MutationResponse> {
+    return await sendCommand(ctx.messageBus, {
+      type: 'AddItemsToCart',
+      kind: 'Command',
+      data: { ...input },
+    });
+  }
+}

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/register.ts

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

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/state.ts

@@ -0,0 +1,47 @@
+/**
+ * ## 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/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session/react.specs.ts

@@ -0,0 +1,51 @@
+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 { ShoppingCriteriaEntered } from '../enters-shopping-criteria-into-assistant/events';
+import type { SuggestShoppingItems } from '../selects-items-relevant-to-the-shopping-criteria/commands';
+
+describe('SeasonalAssistant | CreatesAChatSession', () => {
+  let eventStore: InMemoryEventStore;
+  let given: ReactorSpecification<ShoppingCriteriaEntered, SuggestShoppingItems, ReactorContext>;
+  let messageBus: CommandSender;
+
+  beforeEach(() => {
+    eventStore = getInMemoryEventStore({});
+    given = ReactorSpecification.for<ShoppingCriteriaEntered, SuggestShoppingItems, ReactorContext>(
+      () => react({ eventStore, commandSender: messageBus }),
+      (commandSender) => {
+        messageBus = commandSender;
+        return {
+          eventStore,
+          commandSender,
+          database: eventStore.database,
+        };
+      },
+    );
+  });
+
+  it('should send SuggestShoppingItems when ShoppingCriteriaEntered is received', async () => {
+    await given([])
+      .when({
+        type: 'ShoppingCriteriaEntered',
+        data: {
+          sessionId: 'session-abc',
+          criteria:
+            'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
+          timestamp: new Date('2025-09-04T21:20:20.309Z'),
+        },
+      })
+
+      .then({
+        type: 'SuggestShoppingItems',
+        kind: 'Command',
+        data: {
+          sessionId: 'session-abc',
+          prompt:
+            'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
+        },
+      });
+  });
+});

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session/react.ts

@@ -0,0 +1,43 @@
+import { inMemoryReactor, type MessageHandlerResult, IllegalStateError } from '@event-driven-io/emmett';
+import type { ShoppingCriteriaEntered } from '../enters-shopping-criteria-into-assistant/events';
+import type { ReactorContext } from '../../../shared';
+
+export const react = ({ eventStore, commandSender }: ReactorContext) =>
+  inMemoryReactor<ShoppingCriteriaEntered>({
+    processorId: 'seasonal-assistant-creates-a-chat-session',
+    canHandle: ['ShoppingCriteriaEntered'],
+    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 ShoppingCriteriaEntered');
+
+      // Example:
+      // if (event.data.status !== 'expected') {
+      //   return {
+      //     type: 'SKIP',
+      //     reason: 'Condition not met',
+      //   };
+      // }
+
+      // await context.commandSender.send({
+      //   type: 'SuggestShoppingItems',
+      //   kind: 'Command',
+      //   data: {
+      //     // Map event fields to command fields here
+      //     // e.g., userId: event.data.userId,
+      //   },
+      // });
+
+      // return;
+    },
+  });

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session/register.ts

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

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session-/react.specs.ts

@@ -0,0 +1,51 @@
+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 { ShoppingCriteriaEntered } from '../enters-shopping-criteria-into-assistant/events';
+import type { SuggestShoppingItems } from '../selects-items-relevant-to-the-shopping-criteria-/commands';
+
+describe('SeasonalAssistant | CreatesAChatSession', () => {
+  let eventStore: InMemoryEventStore;
+  let given: ReactorSpecification<ShoppingCriteriaEntered, SuggestShoppingItems, ReactorContext>;
+  let messageBus: CommandSender;
+
+  beforeEach(() => {
+    eventStore = getInMemoryEventStore({});
+    given = ReactorSpecification.for<ShoppingCriteriaEntered, SuggestShoppingItems, ReactorContext>(
+      () => react({ eventStore, commandSender: messageBus }),
+      (commandSender) => {
+        messageBus = commandSender;
+        return {
+          eventStore,
+          commandSender,
+          database: eventStore.database,
+        };
+      },
+    );
+  });
+
+  it('should send SuggestShoppingItems when ShoppingCriteriaEntered is received', async () => {
+    await given([])
+      .when({
+        type: 'ShoppingCriteriaEntered',
+        data: {
+          sessionId: 'session-abc',
+          criteria:
+            'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
+          timestamp: new Date('2025-09-04T20:53:48.700Z'),
+        },
+      })
+
+      .then({
+        type: 'SuggestShoppingItems',
+        kind: 'Command',
+        data: {
+          sessionId: 'session-abc',
+          prompt:
+            'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
+        },
+      });
+  });
+});

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session-/react.ts

@@ -0,0 +1,43 @@
+import { inMemoryReactor, type MessageHandlerResult, IllegalStateError } from '@event-driven-io/emmett';
+import type { ShoppingCriteriaEntered } from '../enters-shopping-criteria-into-assistant/events';
+import type { ReactorContext } from '../../../shared';
+
+export const react = ({ eventStore, commandSender }: ReactorContext) =>
+  inMemoryReactor<ShoppingCriteriaEntered>({
+    processorId: 'seasonal-assistant-creates-a-chat-session-',
+    canHandle: ['ShoppingCriteriaEntered'],
+    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 ShoppingCriteriaEntered');
+
+      // Example:
+      // if (event.data.status !== 'expected') {
+      //   return {
+      //     type: 'SKIP',
+      //     reason: 'Condition not met',
+      //   };
+      // }
+
+      // await context.commandSender.send({
+      //   type: 'SuggestShoppingItems',
+      //   kind: 'Command',
+      //   data: {
+      //     // Map event fields to command fields here
+      //     // e.g., userId: event.data.userId,
+      //   },
+      // });
+
+      // return;
+    },
+  });

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session-/register.ts

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

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/enters-shopping-criteria-into-assistant/commands.ts

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