create-auto-app 0.1.0 → 0.1.2

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

@@ -0,0 +1,36 @@
+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/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/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/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/handle.ts

@@ -0,0 +1,31 @@
+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/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/mutation.resolver.ts

@@ -0,0 +1,29 @@
+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/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/register.ts

@@ -0,0 +1,10 @@
+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/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/server/src/domain/flows/seasonal-assistant/creates-a-chat-session-/react.specs.ts

@@ -0,0 +1,63 @@
+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-08-28T04:56:47.408Z"),
+        },
+      })
+
+      .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/server/src/domain/flows/seasonal-assistant/creates-a-chat-session-/react.ts

@@ -0,0 +1,49 @@
+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/server/src/domain/flows/seasonal-assistant/creates-a-chat-session-/register.ts

@@ -0,0 +1,31 @@
+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/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;
+  }
+>;

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

@@ -0,0 +1,38 @@
+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 | enters shopping criteria into assistant", () => {
+  const given = DeciderSpecification.for({
+    decide,
+    evolve,
+    initialState,
+  });
+
+  it("should emit ShoppingCriteriaEntered for valid EnterShoppingCriteria", () => {
+    given([])
+      .when({
+        type: "EnterShoppingCriteria",
+        data: {
+          sessionId: "shopper-123",
+          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.",
+        },
+        metadata: { now: new Date() },
+      })
+
+      .then([
+        {
+          type: "ShoppingCriteriaEntered",
+          data: {
+            sessionId: "shopper-123",
+            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-08-28T04:56:47.408Z"),
+          },
+        },
+      ]);
+  });
+});

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

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

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

@@ -0,0 +1,10 @@
+import type { Event } from "@event-driven-io/emmett";
+
+export type ShoppingCriteriaEntered = Event<
+  "ShoppingCriteriaEntered",
+  {
+    sessionId: string;
+    criteria: string;
+    timestamp: Date;
+  }
+>;

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

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

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

@@ -0,0 +1,31 @@
+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 { EnterShoppingCriteria } from "./commands";
+
+const handler = CommandHandler({
+  evolve,
+  initialState,
+});
+
+export const handle = async (
+  eventStore: EventStore,
+  command: EnterShoppingCriteria,
+): 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/server/src/domain/flows/seasonal-assistant/enters-shopping-criteria-into-assistant/mutation.resolver.ts

@@ -0,0 +1,30 @@
+import { Mutation, Resolver, Arg, Ctx, Field, InputType } from "type-graphql";
+import {
+  type GraphQLContext,
+  sendCommand,
+  MutationResponse,
+} from "../../../shared";
+
+@InputType()
+export class EnterShoppingCriteriaInput {
+  @Field(() => String)
+  sessionId!: string;
+  @Field(() => String)
+  criteria!: string;
+}
+
+@Resolver()
+export class EnterShoppingCriteriaResolver {
+  @Mutation(() => MutationResponse)
+  async enterShoppingCriteria(
+    @Arg("input", () => EnterShoppingCriteriaInput)
+    input: EnterShoppingCriteriaInput,
+    @Ctx() ctx: GraphQLContext,
+  ): Promise<MutationResponse> {
+    return await sendCommand(ctx.messageBus, {
+      type: "EnterShoppingCriteria",
+      kind: "Command",
+      data: { ...input },
+    });
+  }
+}

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

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

package/templates/shopping-app/server/src/domain/flows/seasonal-assistant/enters-shopping-criteria-into-assistant/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/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria-/commands.ts

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

package/templates/shopping-app/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria-/decide.specs.ts

@@ -0,0 +1,61 @@
+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 | selects items relevant to the shopping criteria ", () => {
+  const given = DeciderSpecification.for({
+    decide,
+    evolve,
+    initialState,
+  });
+
+  it("should emit ShoppingItemsSuggested for valid SuggestShoppingItems", () => {
+    given([])
+      .when({
+        type: "SuggestShoppingItems",
+        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.",
+        },
+        metadata: { now: new Date() },
+      })
+
+      .then([
+        {
+          type: "ShoppingItemsSuggested",
+          data: {
+            sessionId: "session-abc",
+            suggestedItems: [
+              {
+                productId: "prod-soccer-ball",
+                name: "Super Soccer Ball",
+                quantity: 1,
+                reason: "Perfect for your daughter who loves soccer",
+              },
+              {
+                productId: "prod-craft-kit",
+                name: "Deluxe Craft Kit",
+                quantity: 1,
+                reason: "Great for creative activities and crafts",
+              },
+              {
+                productId: "prod-laptop-bag",
+                name: "Tech Laptop Backpack",
+                quantity: 1,
+                reason: "Essential for your son's school computer needs",
+              },
+              {
+                productId: "prod-mtg-starter",
+                name: "Magic the Gathering Starter Set",
+                quantity: 1,
+                reason: "Ideal starter set for Magic the Gathering enthusiasts",
+              },
+            ],
+          },
+        },
+      ]);
+  });
+});