create-auto-app 0.2.3 → 0.8.4

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

@@ -0,0 +1,43 @@
+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 requires evaluating prior state to determine if it can proceed.
+       *
+       * 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.
+       *
+       * Integration result shape (Products):
+       * products?.data = {
+       *   type: "Products";
+       *   products: Array<{
+       *     productId: string; name;
+       *   }>;
+       * }
+       */
+
+      // 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,52 @@
+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: {
+    //    // sessionId: ???
+    // prompt: ???
+    // systemPrompt: ???
+    // schemaName: ???
+    //   },
+    // });
+
+    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,56 @@
+import { describe, it, beforeEach, expect } from 'vitest';
+import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
+import { projection } from './projection';
+import type {} from '../unknown/events';
+import { SuggestedItems } from './state';
+
+type ProjectionEvent = never;
+
+describe('SuggestedItemsProjection Projection', () => {
+  let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+  beforeEach(() => {
+    given = InMemoryProjectionSpec.for({ projection });
+  });
+
+  it('creates or updates SuggestedItems document - case 1', () =>
+    given([])
+      .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,24 @@
+import {
+  inMemorySingleStreamProjection,
+  type ReadEvent,
+  type InMemoryReadEventMetadata,
+} from '@event-driven-io/emmett';
+import type { SuggestedItems } from './state';
+type AllEvents = never;
+
+export const projection = inMemorySingleStreamProjection<SuggestedItems, AllEvents>({
+  collectionName: 'SuggestedItemsProjection',
+  canHandle: [],
+  getDocumentId: (event) => event.data.sessionId,
+  evolve: (
+    document: SuggestedItems | null,
+    event: ReadEvent<AllEvents, InMemoryReadEventMetadata>,
+  ): SuggestedItems | null => {
+    switch (event.type) {
+      default:
+        return document;
+    }
+  },
+});
+
+export default projection;

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

@@ -0,0 +1,56 @@
+import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from 'type-graphql';
+import { type GraphQLContext, ReadModel } from '../../../shared';
+
+@ObjectType()
+export class SuggestedItems {
+  @Field(() => String)
+  sessionId!: string;
+
+  @Field(() => [SuggestedItemsItems])
+  items!: SuggestedItemsItems[];
+
+  [key: string]: unknown;
+}
+
+@ObjectType()
+export class SuggestedItemsItems {
+  @Field(() => String)
+  productId!: string;
+
+  @Field(() => String)
+  name!: string;
+
+  @Field(() => Number)
+  quantity!: number;
+
+  @Field(() => String)
+  reason!: string;
+}
+
+@Resolver()
+export class ViewsSuggestedItemsQueryResolver {
+  @Query(() => [SuggestedItems])
+  async suggestedItems(
+    @Ctx() ctx: GraphQLContext,
+    @Arg('sessionId', () => ID, { nullable: true }) sessionId?: string,
+  ): Promise<SuggestedItems[]> {
+    const model = new ReadModel<SuggestedItems>(ctx.eventStore, 'SuggestedItemsProjection');
+
+    // ## 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) => {
+      if (sessionId !== undefined && item.sessionId !== sessionId) return false;
+
+      return true;
+    });
+  }
+}

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

@@ -0,0 +1,4 @@
+export type SuggestedItems = {
+  sessionId: string;
+  items: Array<{ productId: string; name: string; quantity: number; reason: string }>;
+};

package/templates/shopping-app/.context/server/server/src/domain/shared/ReadModel.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEventStore } from '@event-driven-io/emmett';
+
+export class ReadModel<T extends Record<string, unknown>> {
+  private collection;
+
+  constructor(eventStore: InMemoryEventStore, collectionName: string) {
+    this.collection = eventStore.database.collection<T>(collectionName);
+  }
+
+  async getAll(): Promise<T[]> {
+    return this.collection.find();
+  }
+
+  async getById(id: string, idField: keyof T = 'id' as keyof T): Promise<T | null> {
+    return this.collection.findOne((doc) => doc[idField] === id);
+  }
+
+  async find(filterFn: (item: T) => boolean): Promise<T[]> {
+    return this.collection.find(filterFn);
+  }
+
+  async first(filterFn: (item: T) => boolean): Promise<T | null> {
+    const all = await this.collection.find(filterFn);
+    return all[0] ?? null;
+  }
+}

package/templates/shopping-app/{server/src/domain/shared/index.d.ts → .context/server/server/src/domain/shared/index.ts}

@@ -2,4 +2,3 @@ export * from './types';
 export * from './ReadModel';
 export * from './reactorSpecification';
 export * from './sendCommand';
-//# sourceMappingURL=index.d.ts.map

package/templates/shopping-app/{server/src/domain/shared/reactorSpecification.js → .context/server/server/src/domain/shared/reactorSpecification.ts}

@@ -1,35 +1,98 @@
-import { isErrorConstructor, AssertionError, assertTrue } from '@event-driven-io/emmett';
+import {
+  CommandSender,
+  isErrorConstructor,
+  type ErrorConstructor,
+  AssertionError,
+  assertTrue,
+  type MessageProcessor,
+} from '@event-driven-io/emmett';
+
+interface CommandCheck<CommandType> {
+  (command: CommandType): boolean;
+}
+
+interface ErrorCheck<ErrorType> {
+  (error: ErrorType): boolean;
+}
+
+export type ThenThrows<ErrorType extends Error> =
+  | (() => void)
+  | ((errorConstructor: ErrorConstructor<ErrorType>) => void)
+  | ((errorCheck: ErrorCheck<ErrorType>) => void)
+  | ((errorConstructor: ErrorConstructor<ErrorType>, errorCheck?: ErrorCheck<ErrorType>) => void);
+
+interface ReactorSpecificationReturn<Event, Command, Context> {
+  when: (
+    event: Event | Event[],
+    context?: Context,
+  ) => {
+    then: (expectedCommand: Command | Command[] | CommandCheck<Command> | CommandCheck<Command[]>) => Promise<void>;
+    thenNothingHappened: () => Promise<void>;
+    thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+  };
+}
+
+export interface ReactorSpecification<
+  Event,
+  Command,
+  Context extends { commandSender: CommandSender } = { commandSender: CommandSender },
+> {
+  (givenEvents: Event | Event[]): ReactorSpecificationReturn<Event, Command, Context>;
+}
+
 export const ReactorSpecification = {
   for: reactorSpecificationFor,
 };
-function createMockCommandSender() {
-  const sentCommands = [];
-  const send = async (command) => {
+
+interface MockCommandSender<Command> extends CommandSender {
+  sentCommands: Command[];
+  reset: () => void;
+}
+
+function createMockCommandSender<Command>(): MockCommandSender<Command> {
+  const sentCommands: Command[] = [];
+
+  const send = async <CommandType extends Command = Command>(command: CommandType): Promise<void> => {
     sentCommands.push(command);
   };
+
   return {
     send,
     sentCommands,
     reset: () => {
       sentCommands.length = 0;
     },
-  };
+  } as MockCommandSender<Command>;
 }
-function reactorSpecificationFor(processorOrReactor, createContext) {
-  return (givenEvents) => {
+
+type ReactorLike<Event, Context> =
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | { handle: (events: Event[], context: Context) => Promise<any> }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | { eachMessage: (event: Event, context: Context) => Promise<any> }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | MessageProcessor<any, any, any>;
+
+function reactorSpecificationFor<Event, Command, Context extends { commandSender: CommandSender }>(
+  processorOrReactor: ReactorLike<Event, Context> | (() => ReactorLike<Event, Context>),
+  createContext: (commandSender: CommandSender) => Context,
+): ReactorSpecification<Event, Command, Context> {
+  return (givenEvents: Event | Event[]) => {
     return {
-      when: (whenEvent, contextOverride) => {
-        const mockCommandSender = createMockCommandSender();
+      when: (whenEvent: Event | Event[], contextOverride?: Context) => {
+        const mockCommandSender = createMockCommandSender<Command>();
         const defaultContext = createContext(mockCommandSender);
         const context = contextOverride || defaultContext;
+
         const handle = async () => {
           const givenArray = Array.isArray(givenEvents) ? givenEvents : givenEvents != null ? [givenEvents] : [];
           const whenArray = Array.isArray(whenEvent) ? whenEvent : [whenEvent];
           const allEvents = [...givenArray, ...whenArray];
+
           // Transform events to have metadata
           const eventsWithMetadata = allEvents.map((event, index) => ({
             ...event,
-            kind: 'Event',
+            kind: 'Event' as const,
             metadata: {
               streamName: 'test-stream',
               messageId: `test-${index}`,
@@ -37,9 +100,12 @@ function reactorSpecificationFor(processorOrReactor, createContext) {
               globalPosition: BigInt(index + 1),
             },
           }));
+
           const contextWithMock = { ...context, commandSender: mockCommandSender };
+
           // Get the actual reactor instance
           const reactor = typeof processorOrReactor === 'function' ? processorOrReactor() : processorOrReactor;
+
           // Handle different reactor types
           if ('handle' in reactor && typeof reactor.handle === 'function') {
             // It's a MessageProcessor or has a handle method
@@ -52,50 +118,61 @@ function reactorSpecificationFor(processorOrReactor, createContext) {
           } else {
             throw new Error('Reactor must have either a handle or eachMessage method');
           }
+
           return mockCommandSender.sentCommands;
         };
+
         return {
-          then: async (expectedCommand) => {
+          then: async (
+            expectedCommand: Command | Command[] | CommandCheck<Command> | CommandCheck<Command[]>,
+          ): Promise<void> => {
             try {
               const sentCommands = await handle();
+
               if (typeof expectedCommand === 'function') {
                 const checkFn = expectedCommand;
                 if (sentCommands.length === 1) {
                   assertTrue(
-                    checkFn(sentCommands[0]),
+                    (checkFn as CommandCheck<Command>)(sentCommands[0]),
                     `Sent command did not match the expected condition: ${JSON.stringify(sentCommands[0])}`,
                   );
                 } else {
                   assertTrue(
-                    checkFn(sentCommands),
+                    (checkFn as CommandCheck<Command[]>)(sentCommands),
                     `Sent commands did not match the expected condition: ${JSON.stringify(sentCommands)}`,
                   );
                 }
                 return;
               }
+
               if (Array.isArray(expectedCommand)) {
                 assertTrue(
                   sentCommands.length === expectedCommand.length,
                   `Expected ${expectedCommand.length} command(s) to be sent, but ${sentCommands.length} were sent`,
                 );
+
                 expectedCommand.forEach((expected, index) => {
                   const sent = sentCommands[index];
                   assertCommandsMatch(sent, expected, index);
                 });
                 return;
               }
+
               if (sentCommands.length === 0) {
                 throw new AssertionError('No commands were sent');
               }
+
               if (sentCommands.length > 1) {
                 throw new AssertionError(`Expected 1 command to be sent, but ${sentCommands.length} were sent`);
               }
+
               assertCommandsMatch(sentCommands[0], expectedCommand);
             } finally {
               mockCommandSender.reset();
             }
           },
-          thenNothingHappened: async () => {
+
+          thenNothingHappened: async (): Promise<void> => {
             try {
               const sentCommands = await handle();
               if (sentCommands.length > 0) {
@@ -107,7 +184,8 @@ function reactorSpecificationFor(processorOrReactor, createContext) {
               mockCommandSender.reset();
             }
           },
-          thenThrows: async (...args) => {
+
+          thenThrows: async <ErrorType extends Error>(...args: Parameters<ThenThrows<ErrorType>>): Promise<void> => {
             try {
               await handle();
               throw new AssertionError('Reactor did not fail as expected');
@@ -122,17 +200,25 @@ function reactorSpecificationFor(processorOrReactor, createContext) {
     };
   };
 }
+
+interface CommandWithMetadata {
+  metadata?: Record<string, unknown>;
+}
+
 // eslint-disable-next-line complexity
-function assertCommandsMatch(actual, expected, index) {
-  const actualCopy = { ...actual };
-  const expectedCopy = { ...expected };
+function assertCommandsMatch<Command>(actual: Command, expected: Command, index?: number): void {
+  const actualCopy = { ...actual } as CommandWithMetadata & Record<string, unknown>;
+  const expectedCopy = { ...expected } as CommandWithMetadata & Record<string, unknown>;
+
   if (actualCopy.metadata !== undefined && expectedCopy.metadata !== undefined) {
     for (const key in expectedCopy.metadata) {
       const expectedValue = expectedCopy.metadata[key];
       const actualValue = actualCopy.metadata[key];
+
       const expectedStr =
         expectedValue === undefined ? 'undefined' : expectedValue === null ? 'null' : String(expectedValue);
       const actualStr = actualValue === undefined ? 'undefined' : actualValue === null ? 'null' : String(actualValue);
+
       assertTrue(
         actualValue === expectedValue,
         `Command${index !== undefined ? ` at index ${index}` : ''} metadata.${key} does not match.\nExpected: ${expectedStr}\nActual: ${actualStr}`,
@@ -143,21 +229,29 @@ function assertCommandsMatch(actual, expected, index) {
   } else if (actualCopy.metadata !== undefined && expectedCopy.metadata === undefined) {
     delete actualCopy.metadata;
   }
+
   assertTrue(
     JSON.stringify(actualCopy) === JSON.stringify(expectedCopy),
     `Command${index !== undefined ? ` at index ${index}` : ''} does not match.\nExpected: ${JSON.stringify(expected)}\nActual: ${JSON.stringify(actual)}`,
   );
 }
-function thenThrowsErrorHandler(error, args) {
+
+function thenThrowsErrorHandler<ErrorType extends Error>(
+  error: unknown,
+  args: Parameters<ThenThrows<ErrorType>>,
+): void {
   if (error instanceof AssertionError) throw error;
+
   if (args.length === 0) return;
+
   if (!isErrorConstructor(args[0])) {
-    assertTrue(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
+    assertTrue(args[0](error as ErrorType), `Error didn't match the error condition: ${error?.toString()}`);
     return;
   }
+
   assertTrue(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
+
   if (args[1]) {
-    assertTrue(args[1](error), `Error didn't match the error condition: ${error?.toString()}`);
+    assertTrue(args[1](error as ErrorType), `Error didn't match the error condition: ${error?.toString()}`);
   }
 }
-//# sourceMappingURL=reactorSpecification.js.map

package/templates/shopping-app/.context/server/server/src/domain/shared/sendCommand.ts

@@ -0,0 +1,21 @@
+import type { Command, CommandSender } from '@event-driven-io/emmett';
+import type { MutationResponse } from './types';
+
+export async function sendCommand<T extends Command>(
+  commandSender: CommandSender,
+  command: T,
+): Promise<MutationResponse> {
+  try {
+    await commandSender.send(command);
+    return { success: true };
+  } catch (error: unknown) {
+    const err = error as { name?: string; message?: string };
+    return {
+      success: false,
+      error: {
+        type: err?.name ?? 'UnknownError',
+        message: err?.message ?? 'An unexpected error occurred',
+      },
+    };
+  }
+}