create-auto-app 0.1.4 → 0.1.6

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

@@ -1,53 +1,53 @@
-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";
+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", () => {
+describe('SuggestedItemsProjection Projection', () => {
   let given: InMemoryProjectionSpec<ProjectionEvent>;
 
   beforeEach(() => {
     given = InMemoryProjectionSpec.for({ projection });
   });
 
-  it("creates or updates SuggestedItems document - case 1", () =>
+  it('creates or updates SuggestedItems document - case 1', () =>
     given([
       {
-        type: "ShoppingItemsSuggested",
+        type: 'ShoppingItemsSuggested',
         data: {
-          sessionId: "session-abc",
+          sessionId: 'session-abc',
           suggestedItems: [
             {
-              productId: "prod-soccer-ball",
-              name: "Super Soccer Ball",
+              productId: 'prod-soccer-ball',
+              name: 'Super Soccer Ball',
               quantity: 1,
-              reason: "Perfect for your daughter who loves soccer",
+              reason: 'Perfect for your daughter who loves soccer',
             },
             {
-              productId: "prod-craft-kit",
-              name: "Deluxe Craft Kit",
+              productId: 'prod-craft-kit',
+              name: 'Deluxe Craft Kit',
               quantity: 1,
-              reason: "Great for creative activities and crafts",
+              reason: 'Great for creative activities and crafts',
             },
             {
-              productId: "prod-laptop-bag",
-              name: "Tech Laptop Backpack",
+              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",
+              productId: 'prod-mtg-starter',
+              name: 'Magic the Gathering Starter Set',
               quantity: 1,
-              reason: "Ideal starter set for Magic the Gathering enthusiasts",
+              reason: 'Ideal starter set for Magic the Gathering enthusiasts',
             },
           ],
         },
         metadata: {
-          streamName: "ignored-stream",
+          streamName: 'ignored-stream',
           streamPosition: 1n,
           globalPosition: 1n,
         },
@@ -56,35 +56,35 @@ describe("SuggestedItemsProjection Projection", () => {
       .when([])
       .then(async (state) => {
         const document = await state.database
-          .collection<SuggestedItems>("SuggestedItemsProjection")
-          .findOne((doc) => doc.sessionId === "session-abc");
+          .collection<SuggestedItems>('SuggestedItemsProjection')
+          .findOne((doc) => doc.sessionId === 'session-abc');
 
         const expected: SuggestedItems = {
-          sessionId: "session-abc",
+          sessionId: 'session-abc',
           items: [
             {
-              productId: "prod-soccer-ball",
-              name: "Super Soccer Ball",
+              productId: 'prod-soccer-ball',
+              name: 'Super Soccer Ball',
               quantity: 1,
-              reason: "Perfect for your daughter who loves soccer",
+              reason: 'Perfect for your daughter who loves soccer',
             },
             {
-              productId: "prod-craft-kit",
-              name: "Deluxe Craft Kit",
+              productId: 'prod-craft-kit',
+              name: 'Deluxe Craft Kit',
               quantity: 1,
-              reason: "Great for creative activities and crafts",
+              reason: 'Great for creative activities and crafts',
             },
             {
-              productId: "prod-laptop-bag",
-              name: "Tech Laptop Backpack",
+              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",
+              productId: 'prod-mtg-starter',
+              name: 'Magic the Gathering Starter Set',
               quantity: 1,
-              reason: "Ideal starter set for Magic the Gathering enthusiasts",
+              reason: 'Ideal starter set for Magic the Gathering enthusiasts',
             },
           ],
         };

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

@@ -2,32 +2,29 @@ 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";
+} 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"],
+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": {
+      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 */ "",
+          sessionId: /* TODO: map from event.data */ '',
           items: /* TODO: map from event.data */ [],
         };
       }

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

@@ -1,5 +1,5 @@
-import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from "type-graphql";
-import { type GraphQLContext, ReadModel } from "../../../shared";
+import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from 'type-graphql';
+import { type GraphQLContext, ReadModel } from '../../../shared';
 
 @ObjectType()
 export class SuggestedItems {
@@ -32,12 +32,9 @@ export class ViewsSuggestedItemsQueryResolver {
   @Query(() => [SuggestedItems])
   async suggestedItems(
     @Ctx() ctx: GraphQLContext,
-    @Arg("sessionId", () => ID, { nullable: true }) sessionId?: string,
+    @Arg('sessionId', () => ID, { nullable: true }) sessionId?: string,
   ): Promise<SuggestedItems[]> {
-    const model = new ReadModel<SuggestedItems>(
-      ctx.eventStore,
-      "SuggestedItemsProjection",
-    );
+    const model = new ReadModel<SuggestedItems>(ctx.eventStore, 'SuggestedItemsProjection');
 
     // ## IMPLEMENTATION INSTRUCTIONS ##
     // You can query the projection using the ReadModel API:

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

@@ -1,10 +1,10 @@
 import type { InMemoryEventStore } from '@event-driven-io/emmett';
 export declare class ReadModel<T extends Record<string, unknown>> {
-    private collection;
-    constructor(eventStore: InMemoryEventStore, collectionName: string);
-    getAll(): Promise<T[]>;
-    getById(id: string, idField?: keyof T): Promise<T | null>;
-    find(filterFn: (item: T) => boolean): Promise<T[]>;
-    first(filterFn: (item: T) => boolean): Promise<T | null>;
+  private collection;
+  constructor(eventStore: InMemoryEventStore, collectionName: string);
+  getAll(): Promise<T[]>;
+  getById(id: string, idField?: keyof T): Promise<T | null>;
+  find(filterFn: (item: T) => boolean): Promise<T[]>;
+  first(filterFn: (item: T) => boolean): Promise<T | null>;
 }
-//# sourceMappingURL=ReadModel.d.ts.map
+//# sourceMappingURL=ReadModel.d.ts.map

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

@@ -1,19 +1,19 @@
 export class ReadModel {
-    constructor(eventStore, collectionName) {
-        this.collection = eventStore.database.collection(collectionName);
-    }
-    async getAll() {
-        return this.collection.find();
-    }
-    async getById(id, idField = 'id') {
-        return this.collection.findOne((doc) => doc[idField] === id);
-    }
-    async find(filterFn) {
-        return this.collection.find(filterFn);
-    }
-    async first(filterFn) {
-        const all = await this.collection.find(filterFn);
-        return all[0] ?? null;
-    }
+  constructor(eventStore, collectionName) {
+    this.collection = eventStore.database.collection(collectionName);
+  }
+  async getAll() {
+    return this.collection.find();
+  }
+  async getById(id, idField = 'id') {
+    return this.collection.findOne((doc) => doc[idField] === id);
+  }
+  async find(filterFn) {
+    return this.collection.find(filterFn);
+  }
+  async first(filterFn) {
+    const all = await this.collection.find(filterFn);
+    return all[0] ?? null;
+  }
 }
-//# sourceMappingURL=ReadModel.js.map
+//# sourceMappingURL=ReadModel.js.map

package/templates/shopping-app/server/src/domain/shared/index.d.ts

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

package/templates/shopping-app/server/src/domain/shared/index.js

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

package/templates/shopping-app/server/src/domain/shared/reactorSpecification.d.ts

@@ -1,35 +1,56 @@
 import { CommandSender, type ErrorConstructor, type MessageProcessor } from '@event-driven-io/emmett';
 interface CommandCheck<CommandType> {
-    (command: CommandType): boolean;
+  (command: CommandType): boolean;
 }
 interface ErrorCheck<ErrorType> {
-    (error: ErrorType): boolean;
+  (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);
+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>;
-    };
+  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 {
+export interface ReactorSpecification<
+  Event,
+  Command,
+  Context extends {
     commandSender: CommandSender;
-} = {
+  } = {
     commandSender: CommandSender;
-}> {
-    (givenEvents: Event | Event[]): ReactorSpecificationReturn<Event, Command, Context>;
+  },
+> {
+  (givenEvents: Event | Event[]): ReactorSpecificationReturn<Event, Command, Context>;
 }
 export declare const ReactorSpecification: {
-    for: typeof reactorSpecificationFor;
+  for: typeof reactorSpecificationFor;
 };
-type ReactorLike<Event, Context> = {
-    handle: (events: Event[], context: Context) => Promise<any>;
-} | {
-    eachMessage: (event: Event, context: Context) => Promise<any>;
-} | MessageProcessor<any, any, any>;
-declare function reactorSpecificationFor<Event, Command, Context extends {
+type ReactorLike<Event, Context> =
+  | {
+      handle: (events: Event[], context: Context) => Promise<any>;
+    }
+  | {
+      eachMessage: (event: Event, context: Context) => Promise<any>;
+    }
+  | MessageProcessor<any, any, any>;
+declare function reactorSpecificationFor<
+  Event,
+  Command,
+  Context extends {
     commandSender: CommandSender;
-}>(processorOrReactor: ReactorLike<Event, Context> | (() => ReactorLike<Event, Context>), createContext: (commandSender: CommandSender) => Context): ReactorSpecification<Event, Command, Context>;
+  },
+>(
+  processorOrReactor: ReactorLike<Event, Context> | (() => ReactorLike<Event, Context>),
+  createContext: (commandSender: CommandSender) => Context,
+): ReactorSpecification<Event, Command, Context>;
 export {};
-//# sourceMappingURL=reactorSpecification.d.ts.map
+//# sourceMappingURL=reactorSpecification.d.ts.map

package/templates/shopping-app/server/src/domain/shared/reactorSpecification.js

@@ -1,155 +1,163 @@
-import { isErrorConstructor, AssertionError, assertTrue, } from '@event-driven-io/emmett';
+import { isErrorConstructor, AssertionError, assertTrue } from '@event-driven-io/emmett';
 export const ReactorSpecification = {
-    for: reactorSpecificationFor,
+  for: reactorSpecificationFor,
 };
 function createMockCommandSender() {
-    const sentCommands = [];
-    const send = async (command) => {
-        sentCommands.push(command);
-    };
-    return {
-        send,
-        sentCommands,
-        reset: () => {
-            sentCommands.length = 0;
-        },
-    };
+  const sentCommands = [];
+  const send = async (command) => {
+    sentCommands.push(command);
+  };
+  return {
+    send,
+    sentCommands,
+    reset: () => {
+      sentCommands.length = 0;
+    },
+  };
 }
 function reactorSpecificationFor(processorOrReactor, createContext) {
-    return (givenEvents) => {
-        return {
-            when: (whenEvent, contextOverride) => {
-                const mockCommandSender = createMockCommandSender();
-                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',
-                        metadata: {
-                            streamName: 'test-stream',
-                            messageId: `test-${index}`,
-                            streamPosition: BigInt(index + 1),
-                            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
-                        await reactor.handle(eventsWithMetadata, contextWithMock);
-                    }
-                    else if ('eachMessage' in reactor && typeof reactor.eachMessage === 'function') {
-                        // It has eachMessage
-                        for (const event of eventsWithMetadata) {
-                            await reactor.eachMessage(event, contextWithMock);
-                        }
-                    }
-                    else {
-                        throw new Error('Reactor must have either a handle or eachMessage method');
-                    }
-                    return mockCommandSender.sentCommands;
-                };
-                return {
-                    then: async (expectedCommand) => {
-                        try {
-                            const sentCommands = await handle();
-                            if (typeof expectedCommand === 'function') {
-                                const checkFn = expectedCommand;
-                                if (sentCommands.length === 1) {
-                                    assertTrue(checkFn(sentCommands[0]), `Sent command did not match the expected condition: ${JSON.stringify(sentCommands[0])}`);
-                                }
-                                else {
-                                    assertTrue(checkFn(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 () => {
-                        try {
-                            const sentCommands = await handle();
-                            if (sentCommands.length > 0) {
-                                throw new AssertionError(`Expected no commands to be sent, but ${sentCommands.length} command(s) were sent: ${JSON.stringify(sentCommands)}`);
-                            }
-                        }
-                        finally {
-                            mockCommandSender.reset();
-                        }
-                    },
-                    thenThrows: async (...args) => {
-                        try {
-                            await handle();
-                            throw new AssertionError('Reactor did not fail as expected');
-                        }
-                        catch (error) {
-                            thenThrowsErrorHandler(error, args);
-                        }
-                        finally {
-                            mockCommandSender.reset();
-                        }
-                    },
-                };
+  return (givenEvents) => {
+    return {
+      when: (whenEvent, contextOverride) => {
+        const mockCommandSender = createMockCommandSender();
+        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',
+            metadata: {
+              streamName: 'test-stream',
+              messageId: `test-${index}`,
+              streamPosition: BigInt(index + 1),
+              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
+            await reactor.handle(eventsWithMetadata, contextWithMock);
+          } else if ('eachMessage' in reactor && typeof reactor.eachMessage === 'function') {
+            // It has eachMessage
+            for (const event of eventsWithMetadata) {
+              await reactor.eachMessage(event, contextWithMock);
+            }
+          } else {
+            throw new Error('Reactor must have either a handle or eachMessage method');
+          }
+          return mockCommandSender.sentCommands;
         };
+        return {
+          then: async (expectedCommand) => {
+            try {
+              const sentCommands = await handle();
+              if (typeof expectedCommand === 'function') {
+                const checkFn = expectedCommand;
+                if (sentCommands.length === 1) {
+                  assertTrue(
+                    checkFn(sentCommands[0]),
+                    `Sent command did not match the expected condition: ${JSON.stringify(sentCommands[0])}`,
+                  );
+                } else {
+                  assertTrue(
+                    checkFn(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 () => {
+            try {
+              const sentCommands = await handle();
+              if (sentCommands.length > 0) {
+                throw new AssertionError(
+                  `Expected no commands to be sent, but ${sentCommands.length} command(s) were sent: ${JSON.stringify(sentCommands)}`,
+                );
+              }
+            } finally {
+              mockCommandSender.reset();
+            }
+          },
+          thenThrows: async (...args) => {
+            try {
+              await handle();
+              throw new AssertionError('Reactor did not fail as expected');
+            } catch (error) {
+              thenThrowsErrorHandler(error, args);
+            } finally {
+              mockCommandSender.reset();
+            }
+          },
+        };
+      },
     };
+  };
 }
 // eslint-disable-next-line complexity
 function assertCommandsMatch(actual, expected, index) {
-    const actualCopy = { ...actual };
-    const expectedCopy = { ...expected };
-    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}`);
-        }
-        delete actualCopy.metadata;
-        delete expectedCopy.metadata;
-    }
-    else if (actualCopy.metadata !== undefined && expectedCopy.metadata === undefined) {
-        delete actualCopy.metadata;
+  const actualCopy = { ...actual };
+  const expectedCopy = { ...expected };
+  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}`,
+      );
     }
-    assertTrue(JSON.stringify(actualCopy) === JSON.stringify(expectedCopy), `Command${index !== undefined ? ` at index ${index}` : ''} does not match.\nExpected: ${JSON.stringify(expected)}\nActual: ${JSON.stringify(actual)}`);
+    delete actualCopy.metadata;
+    delete expectedCopy.metadata;
+  } 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) {
-    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()}`);
-        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()}`);
-    }
+  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()}`);
+    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()}`);
+  }
 }
-//# sourceMappingURL=reactorSpecification.js.map
+//# sourceMappingURL=reactorSpecification.js.map