create-auto-app 0.2.2 → 0.3.0

package/templates/shopping-app/.context/server/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-09-02T00:39:41.677Z'),
+          },
+        },
+      ]);
+  });
+});

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

@@ -0,0 +1,33 @@
+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/.context/server/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/.context/server/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/.context/server/server/src/domain/flows/seasonal-assistant/enters-shopping-criteria-into-assistant/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 { 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/.context/server/server/src/domain/flows/seasonal-assistant/enters-shopping-criteria-into-assistant/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 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/.context/server/server/src/domain/flows/seasonal-assistant/enters-shopping-criteria-into-assistant/register.ts

@@ -0,0 +1,7 @@
+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/.context/server/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/.context/server/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/.context/server/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',
+              },
+            ],
+          },
+        },
+      ]);
+  });
+});

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

@@ -0,0 +1,35 @@
+import { IllegalStateError } from '@event-driven-io/emmett';
+import type { State } from './state';
+import type { SuggestShoppingItems } from './commands';
+import type { ShoppingItemsSuggested } from './events';
+import type { Products } from '@auto-engineer/product-catalog-integration';
+
+export const decide = (command: SuggestShoppingItems, state: State, products?: Products): ShoppingItemsSuggested => {
+  switch (command.type) {
+    case 'SuggestShoppingItems': {
+      /**
+       * ## 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
+       * - Use `products` (integration result) to enrich or filter the output
+       * - 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: 'ShoppingItemsSuggested',
+      //   data: { ...command.data },
+      // } as ShoppingItemsSuggested;
+
+      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/selects-items-relevant-to-the-shopping-criteria-/events.ts

@@ -0,0 +1,9 @@
+import type { Event } from '@event-driven-io/emmett';
+
+export type ShoppingItemsSuggested = Event<
+  'ShoppingItemsSuggested',
+  {
+    sessionId: string;
+    suggestedItems: Array<{ productId: string; name: string; quantity: number; reason: string }>;
+  }
+>;

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

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

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

@@ -0,0 +1,49 @@
+import '@auto-engineer/product-catalog-integration';
+
+import { AI } from '@auto-engineer/ai-integration';
+
+import { Products } from '@auto-engineer/product-catalog-integration';
+
+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 { SuggestShoppingItems } from './commands';
+
+/**
+ * ## IMPLEMENTATION INSTRUCTIONS ##
+ * add the following to the DoChat: schemaName: Products, systemPrompt: use the PRODUCT_CATALOGUE_PRODUCTS MCP tool to get product data
+ */
+
+const handler = CommandHandler({
+  evolve,
+  initialState,
+});
+
+export const handle = async (eventStore: EventStore, command: SuggestShoppingItems): Promise<MessageHandlerResult> => {
+  const streamId = `shopping-session-${command.data.sessionId}`;
+
+  try {
+    // TODO: Map fields from the incoming command to this integration input.
+    // - Use relevant fields from `command.data` to populate the required inputs below.
+    // - Some fields may require transformation or enrichment.
+    // - If additional context is needed, construct it here.
+    // const products: Products | undefined = await AI.Commands?.DoChat<Products>({
+    //   type: 'DoChat',
+    //   data: {
+    //
+    //   },
+    // });
+
+    await handler(eventStore, streamId, (state) =>
+      // TODO: add products as a parameter to decide once implemented above
+      decide(command, state /* products */),
+    );
+    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/selects-items-relevant-to-the-shopping-criteria-/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 SuggestShoppingItemsInput {
+  @Field(() => String)
+  sessionId!: string;
+  @Field(() => String)
+  prompt!: string;
+}
+
+@Resolver()
+export class SuggestShoppingItemsResolver {
+  @Mutation(() => MutationResponse)
+  async suggestShoppingItems(
+    @Arg('input', () => SuggestShoppingItemsInput) input: SuggestShoppingItemsInput,
+    @Ctx() ctx: GraphQLContext,
+  ): Promise<MutationResponse> {
+    return await sendCommand(ctx.messageBus, {
+      type: 'SuggestShoppingItems',
+      kind: 'Command',
+      data: { ...input },
+    });
+  }
+}

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

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

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria-/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/views-suggested-items/projection.specs.ts

@@ -0,0 +1,94 @@
+import { describe, it, beforeEach, expect } from 'vitest';
+import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
+import { projection } from './projection';
+import type { ShoppingItemsSuggested } from '../selects-items-relevant-to-the-shopping-criteria-/events';
+import { SuggestedItems } from './state';
+
+type ProjectionEvent = ShoppingItemsSuggested;
+
+describe('SuggestedItemsProjection Projection', () => {
+  let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+  beforeEach(() => {
+    given = InMemoryProjectionSpec.for({ projection });
+  });
+
+  it('creates or updates SuggestedItems document - case 1', () =>
+    given([
+      {
+        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',
+            },
+          ],
+        },
+        metadata: {
+          streamName: 'ignored-stream',
+          streamPosition: 1n,
+          globalPosition: 1n,
+        },
+      },
+    ])
+      .when([])
+      .then(async (state) => {
+        const document = await state.database
+          .collection<SuggestedItems>('SuggestedItemsProjection')
+          .findOne((doc) => doc.sessionId === 'session-abc');
+
+        const expected: SuggestedItems = {
+          sessionId: 'session-abc',
+          items: [
+            {
+              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',
+            },
+          ],
+        };
+
+        expect(document).toMatchObject(expected);
+      }));
+});

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

@@ -0,0 +1,37 @@
+import {
+  inMemorySingleStreamProjection,
+  type ReadEvent,
+  type InMemoryReadEventMetadata,
+} from '@event-driven-io/emmett';
+import type { SuggestedItems } from './state';
+import type { ShoppingItemsSuggested } from '../selects-items-relevant-to-the-shopping-criteria-/events';
+
+type AllEvents = ShoppingItemsSuggested;
+
+export const projection = inMemorySingleStreamProjection<SuggestedItems, AllEvents>({
+  collectionName: 'SuggestedItemsProjection',
+  canHandle: ['ShoppingItemsSuggested'],
+  getDocumentId: (event) => event.data.sessionId,
+  evolve: (
+    document: SuggestedItems | null,
+    event: ReadEvent<AllEvents, InMemoryReadEventMetadata>,
+  ): SuggestedItems | null => {
+    switch (event.type) {
+      case 'ShoppingItemsSuggested': {
+        /**
+         * ## IMPLEMENTATION INSTRUCTIONS ##
+         * This event adds or updates the document.
+         * Implement the correct fields as needed for your read model.
+         */
+        return {
+          sessionId: /* TODO: map from event.data */ '',
+          items: /* TODO: map from event.data */ [],
+        };
+      }
+      default:
+        return document;
+    }
+  },
+});
+
+export default projection;