@arts-n-crafts/ts 3.19.0 → 5.0.0-rc.2

package/packages/v4/dist/index.d.ts

@@ -44,7 +44,7 @@ interface Command<TType = string, TPayload = unknown> extends WithIdentifier {
     /** Optional metadata. */
     metadata?: Partial<CommandMetadata>;
     /** Discriminator for the message intent. */
-    kind: 'command';
+    kind: "command";
 }
 
 interface CommandHandler<CommandType extends Command, TReturnType = Promise<void>> {
@@ -81,7 +81,7 @@ interface DomainEvent<TPayload = unknown> {
     /** Optional metadata; keep it small and stable. */
     metadata: Partial<DomainEventMetadata>;
     /** Discriminator for the message intent. */
-    kind: 'domain';
+    kind: "domain";
 }
 
 /**
@@ -108,7 +108,7 @@ interface ExternalEvent<TPayload = unknown> {
     /** Optional metadata from the producer. */
     metadata?: Partial<ExternalEventMetadata>;
     /** Discriminator for the message intent. */
-    kind: 'external';
+    kind: "external";
 }
 
 /**
@@ -118,7 +118,7 @@ interface ExternalEvent<TPayload = unknown> {
  */
 interface IntegrationEventMetadata extends BaseMetadata {
     /** Outcome of the decision. */
-    outcome?: 'accepted' | 'rejected';
+    outcome?: "accepted" | "rejected";
     /** Correlation and routing fields. */
     aggregateType?: string;
     aggregateId?: string;
@@ -139,7 +139,7 @@ interface IntegrationEvent<TPayload = unknown> {
     /** Standardized, extensible metadata. */
     metadata: Partial<IntegrationEventMetadata>;
     /** Discriminator for the message intent. */
-    kind: 'integration';
+    kind: "integration";
 }
 
 interface Handling<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent, TReturnType> {
@@ -156,7 +156,7 @@ interface Query<TType = string, TPayload = unknown> extends WithIdentifier {
     timestamp: number;
     metadata: Partial<QueryMetadata>;
     /** Discriminator for the message intent. */
-    kind: 'query';
+    kind: "query";
 }
 
 interface QueryHandler<TQuery extends Query, TProjection = Promise<unknown>> {
@@ -235,17 +235,17 @@ interface Rejection<TDetails = object> {
     /** Rejection type, format e.g., "{commandType}Rejected", "{commandType}Failed". Example "CreateUserRejected" */
     type: string;
     /** Discriminator for the message intent. */
-    kind: 'rejection';
+    kind: "rejection";
     /** The command that was rejected. */
     commandId: string;
     /** The command type, e.g., "CreateOrder". */
     commandType: string;
     /** Short machine-readable code, e.g., "VERSION_CONFLICT", "VALIDATION_FAILED". */
-    reasonCode: string | 'VERSION_CONFLICT' | 'VALIDATION_FAILED';
+    reasonCode: string | "VERSION_CONFLICT" | "VALIDATION_FAILED";
     /** Human-readable summary (avoid PII if externalized). */
     reason?: string;
     /** Classification for routing/metrics. */
-    classification?: 'business' | 'validation' | 'concurrency' | 'technical';
+    classification?: "business" | "validation" | "concurrency" | "technical";
     /** Hint to infra/ops whether retry makes sense. */
     retryable?: boolean;
     /** Structured details specific to this rejection. */
@@ -281,14 +281,14 @@ interface Repository<TEvent, TLoadReturnType, TStoreReturnType = Promise<void>>
 }
 
 type QueryNode = {
-    type: 'eq' | 'gt' | 'lt';
+    type: "eq" | "gt" | "lt";
     field: string | number | symbol;
     value: Primitive;
 } | {
-    type: 'and' | 'or';
+    type: "and" | "or";
     nodes: QueryNode[];
 } | {
-    type: 'not';
+    type: "not";
     node: QueryNode;
 };
 
@@ -340,9 +340,9 @@ declare class FieldGreaterThan<T> extends CompositeSpecification<T> {
     toQuery(): QueryNode;
 }
 
-declare function createQueryNode(type: 'eq' | 'gt' | 'lt', field: string | number | symbol, value: Primitive): QueryNode;
-declare function createQueryNode(type: 'and' | 'or', field: undefined, value: QueryNode[]): QueryNode;
-declare function createQueryNode(type: 'not', field: undefined, value: QueryNode): QueryNode;
+declare function createQueryNode(type: "eq" | "gt" | "lt", field: string | number | symbol, value: Primitive): QueryNode;
+declare function createQueryNode(type: "and" | "or", field: undefined, value: QueryNode[]): QueryNode;
+declare function createQueryNode(type: "not", field: undefined, value: QueryNode): QueryNode;
 
 declare function convertDomainEventToIntegrationEvent(event: DomainEvent): IntegrationEvent;
 
@@ -351,14 +351,14 @@ declare function convertRejectionToIntegrationEvent(rejection: Rejection): Integ
 declare function createDomainEvent<TPayload = unknown>(type: string, aggregateId: string, aggregateType: string, payload: TPayload, metadata?: Partial<DomainEventMetadata>): DomainEvent<TPayload>;
 
 declare function createRejection<TDetails = unknown>(rejectionSpecifics: {
-    commandId: Rejection['commandId'];
-    commandType: Rejection['commandType'];
-    reasonCode: Rejection['reasonCode'];
-    reason?: Rejection['reason'];
-    classification: Rejection['classification'];
-    retryable?: Rejection['retryable'];
-    validationErrors?: Rejection['validationErrors'];
-    type: 'Failed' | 'Rejected' | string;
+    commandId: Rejection["commandId"];
+    commandType: Rejection["commandType"];
+    reasonCode: Rejection["reasonCode"];
+    reason?: Rejection["reason"];
+    classification: Rejection["classification"];
+    retryable?: Rejection["retryable"];
+    validationErrors?: Rejection["validationErrors"];
+    type: "Failed" | "Rejected" | string;
     details?: TDetails;
 }, metadata?: Partial<RejectionMetadata>): Rejection<TDetails>;
 
@@ -369,7 +369,7 @@ declare function isEvent(event: unknown): event is DomainEvent | IntegrationEven
 declare function isRejection(candidate: unknown): candidate is Rejection;
 
 interface Registerable$1<TCommand extends Command, TResult = void> {
-    register(aTypeOfCommand: TCommand['type'], anHandler: CommandHandler<TCommand>): TResult;
+    register(aTypeOfCommand: TCommand["type"], anHandler: CommandHandler<TCommand>): TResult;
 }
 interface Executable$3<TCommand extends Command, TResult = Promise<void>> {
     execute(aCommand: TCommand): TResult;
@@ -379,7 +379,7 @@ interface CommandBus<TCommand extends Command, TExecutionResult = Promise<void>,
 
 declare class SimpleCommandBus<TCommand extends Command> implements CommandBus<TCommand> {
     private handlers;
-    register(aTypeOfCommand: TCommand['type'], anHandler: CommandHandler<TCommand>): void;
+    register(aTypeOfCommand: TCommand["type"], anHandler: CommandHandler<TCommand>): void;
     execute(aCommand: TCommand): Promise<void>;
 }
 
@@ -452,23 +452,12 @@ declare class SimpleEventBus<TEvent extends DomainEvent | IntegrationEvent | Ext
 
 declare function createExternalEvent<TPayload = unknown>(type: string, payload: TPayload, metadata?: Partial<ExternalEventMetadata>): ExternalEvent<TPayload>;
 
-declare function createIntegrationEvent<TPayload = unknown>(type: string, payload: TPayload, metadata?: Partial<IntegrationEventMetadata>): IntegrationEvent<TPayload>;
+declare function createIntegrationEvent<TPayload = unknown>(type: string, payload: TPayload, metadata?: Partial<IntegrationEventMetadata>, timestamp?: string): IntegrationEvent<TPayload>;
 
 declare function isExternalEvent<TPayload>(event: unknown): event is ExternalEvent<TPayload>;
 
 declare function isIntegrationEvent<TPayload>(event: unknown): event is IntegrationEvent<TPayload>;
 
-declare function mapDomainEventToIntegrationEvent<TPayload>(domainEvent: DomainEvent<TPayload>): IntegrationEvent<TPayload>;
-
-declare function mapRejectionToIntegrationEvent<TDetails>(rejection: Rejection<TDetails>): IntegrationEvent<{
-    reasonCode: Rejection<TDetails>['reasonCode'];
-    reason?: string;
-    classification?: Rejection<TDetails>['classification'];
-    retryable?: boolean;
-    details?: TDetails;
-    validationErrors?: Rejection<TDetails>['validationErrors'];
-}>;
-
 type StreamKey = `${string}#${string}`;
 
 /**
@@ -559,7 +548,7 @@ declare class InMemoryOutbox implements Outbox {
 declare function createOutboxEntry(event: IntegrationEvent): OutboxEntry;
 
 interface Registerable<TQuery extends Query, TResult = void> {
-    register(aTypeOfQuery: TQuery['type'], anHandler: QueryHandler<TQuery>): TResult;
+    register(aTypeOfQuery: TQuery["type"], anHandler: QueryHandler<TQuery>): TResult;
 }
 interface Executable<TQuery extends Query, TResult = Promise<unknown>> {
     execute(aQuery: TQuery): TResult;
@@ -569,7 +558,7 @@ interface QueryBus<TQuery extends Query, TExecutionResult, TRegisterResult = voi
 
 declare class SimpleQueryBus<TQuery extends Query, TProjection> implements QueryBus<TQuery, Promise<TProjection>> {
     private handlers;
-    register(aTypeOfQuery: TQuery['type'], anHandler: QueryHandler<TQuery, Promise<TProjection>>): void;
+    register(aTypeOfQuery: TQuery["type"], anHandler: QueryHandler<TQuery, Promise<TProjection>>): void;
     execute(aQuery: TQuery): Promise<TProjection>;
 }
 
@@ -578,7 +567,7 @@ declare class SimpleRepository<TState, TCommand, TEvent extends DomainEvent> imp
     readonly streamName: string;
     private readonly evolveFn;
     private readonly initialState;
-    constructor(eventStore: EventStore<TEvent, Promise<void>, Promise<TEvent[]>>, streamName: string, evolveFn: Decider<TState, TCommand, TEvent>['evolve'], initialState: Decider<TState, TCommand, TEvent>['initialState']);
+    constructor(eventStore: EventStore<TEvent, Promise<void>, Promise<TEvent[]>>, streamName: string, evolveFn: Decider<TState, TCommand, TEvent>["evolve"], initialState: Decider<TState, TCommand, TEvent>["initialState"]);
     load(aggregateId: string): Promise<TState>;
     store(events: TEvent[]): Promise<void>;
 }
@@ -598,14 +587,14 @@ declare class ScenarioTest<TState, TEvent extends DomainEvent> {
     private givenInput;
     private whenInput;
     constructor(streamName: string, eventBus: EventProducer<DomainEvent | IntegrationEvent | ExternalEvent> & EventConsumer<DomainEvent | IntegrationEvent | ExternalEvent>, eventStore: EventStore<TEvent, Promise<void>, Promise<TEvent[]>>, commandBus: CommandBus<Command>, queryBus: QueryBus<Query, Promise<Record<string, unknown>[]>>, repository: Repository<DomainEvent, Promise<TState>>, outboxWorker: OutboxWorker, outbox: Outbox);
-    given(...events: GivenInput): {
-        when(action: WhenInput): ReturnType<ScenarioTest<TState, TEvent>['when']>;
-        then(outcome: ThenInput): Promise<void>;
+    Given(...events: GivenInput): {
+        When(action: WhenInput): ReturnType<ScenarioTest<TState, TEvent>["When"]>;
+        Then(outcome: ThenInput): Promise<void>;
     };
-    when(action: WhenInput): {
-        then(outcome: ThenInput): Promise<void>;
+    When(action: WhenInput): {
+        Then(outcome: ThenInput): Promise<void>;
     };
-    then(thenInput: ThenInput): Promise<void>;
+    Then(thenInput: ThenInput): Promise<void>;
     private handleCommand;
     private handleQuery;
     private handleEvent;
@@ -621,4 +610,4 @@ declare function parseAsError(value: unknown): Error;
 
 declare function makeStreamKey(streamName: string, aggregateId: string): StreamKey;
 
-export { type AggregateRoot, AndSpecification, type BaseMetadata, type Command, type CommandBus, type CommandHandler, type CommandMetadata, CompositeSpecification, type CreateStatement, type Database, type Decider, type DeleteStatement, type Directive, type DomainEvent, type DomainEventMetadata, type EventBasedAggregateRoot, type EventConsumer, type EventHandler, type EventProducer, type EventStore, FieldEquals, FieldGreaterThan, type FilledArray, GenericOutboxWorker, type ISODateTime, InMemoryOutbox, type IntegrationEvent, type IntegrationEventMetadata, type Maybe, NotSpecification, type Nullable, Operation, OrSpecification, type Outbox, type OutboxEntry, type OutboxWorker, type PatchStatement, type Primitive, type PutStatement, type Query, type QueryBus, type QueryHandler, type QueryMetadata, type QueryNode, type Rejection, type RejectionMetadata, type Repository, ScenarioTest, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, type Specification, type StoredEvent, type StreamKey, type UnixTimestampInSeconds, type WithIdentifier, convertDomainEventToIntegrationEvent, convertRejectionToIntegrationEvent, createCommand, createDomainEvent, createExternalEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createRejection, createStoredEvent, fail, getTimestamp, invariant, isCommand, isDomainEvent, isEqual, isEvent, isExternalEvent, isIntegrationEvent, isQuery, isRejection, makeStreamKey, mapDomainEventToIntegrationEvent, mapRejectionToIntegrationEvent, parseAsError };
+export { type AggregateRoot, AndSpecification, type BaseMetadata, type Command, type CommandBus, type CommandHandler, type CommandMetadata, CompositeSpecification, type CreateStatement, type Database, type Decider, type DeleteStatement, type Directive, type DomainEvent, type DomainEventMetadata, type EventBasedAggregateRoot, type EventConsumer, type EventHandler, type EventProducer, type EventStore, FieldEquals, FieldGreaterThan, type FilledArray, GenericOutboxWorker, type ISODateTime, InMemoryOutbox, type IntegrationEvent, type IntegrationEventMetadata, type Maybe, NotSpecification, type Nullable, Operation, OrSpecification, type Outbox, type OutboxEntry, type OutboxWorker, type PatchStatement, type Primitive, type PutStatement, type Query, type QueryBus, type QueryHandler, type QueryMetadata, type QueryNode, type Rejection, type RejectionMetadata, type Repository, ScenarioTest, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, type Specification, type StoredEvent, type StreamKey, type UnixTimestampInSeconds, type WithIdentifier, convertDomainEventToIntegrationEvent, convertRejectionToIntegrationEvent, createCommand, createDomainEvent, createExternalEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createRejection, createStoredEvent, fail, getTimestamp, invariant, isCommand, isDomainEvent, isEqual, isEvent, isExternalEvent, isIntegrationEvent, isQuery, isRejection, makeStreamKey, parseAsError };

package/packages/v4/dist/index.js

@@ -31,23 +31,17 @@ function createQuery(type, payload, metadata = {}) {
 
 // src/core/utils/isCommand.ts
 function isCommand(candidate) {
-  if (candidate === null)
-    return false;
-  if (typeof candidate !== "object")
-    return false;
-  if (!("type" in candidate))
-    return false;
+  if (candidate === null) return false;
+  if (typeof candidate !== "object") return false;
+  if (!("type" in candidate)) return false;
   return "kind" in candidate && candidate.kind === "command";
 }
 
 // src/core/utils/isQuery.ts
 function isQuery(candidate) {
-  if (candidate === null)
-    return false;
-  if (typeof candidate !== "object")
-    return false;
-  if (!("type" in candidate))
-    return false;
+  if (candidate === null) return false;
+  if (typeof candidate !== "object") return false;
+  if (!("type" in candidate)) return false;
   return "kind" in candidate && candidate.kind === "query";
 }
 
@@ -150,8 +144,7 @@ function fail(anExpression) {
 
 // src/utils/invariant/invariant.ts
 function invariant(condition, onInvalid) {
-  if (!condition)
-    onInvalid();
+  if (!condition) onInvalid();
 }
 
 // src/domain/Specification/implementations/FieldGreaterThan.specification.ts
@@ -168,9 +161,7 @@ var FieldGreaterThan = class extends CompositeSpecification {
     const field = entity[this.field];
     invariant(
       this.isNumber(field),
-      fail(
-        new TypeError(`Field ${String(this.field)} is not a number`)
-      )
+      fail(new TypeError(`Field ${String(this.field)} is not a number`))
     );
     return field > this.value;
   }
@@ -178,12 +169,12 @@ var FieldGreaterThan = class extends CompositeSpecification {
     return createQueryNode("gt", this.field, this.value);
   }
 };
-function createIntegrationEvent(type, payload, metadata) {
+function createIntegrationEvent(type, payload, metadata = {}, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
   return Object.freeze({
     id: randomUUID(),
     type,
     payload,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    timestamp,
     metadata: {
       ...metadata
     },
@@ -193,11 +184,16 @@ function createIntegrationEvent(type, payload, metadata) {
 
 // src/domain/utils/convertDomainEventToIntegrationEvent.ts
 function convertDomainEventToIntegrationEvent(event) {
-  return createIntegrationEvent(event.type, event.payload, {
-    outcome: "accepted",
-    aggregateType: event.aggregateType,
-    aggregateId: event.aggregateId
-  });
+  return createIntegrationEvent(
+    event.type,
+    event.payload,
+    {
+      outcome: "accepted",
+      aggregateType: event.aggregateType,
+      aggregateId: event.aggregateId
+    },
+    new Date(event.timestamp).toISOString()
+  );
 }
 
 // src/domain/utils/convertRejectionToIntegrationEvent.ts
@@ -211,7 +207,8 @@ function convertRejectionToIntegrationEvent(rejection) {
       aggregateId: rejection.metadata?.aggregateId,
       commandType: rejection.commandType,
       commandId: rejection.commandId
-    }
+    },
+    new Date(rejection.timestamp).toISOString()
   );
 }
 function createDomainEvent(type, aggregateId, aggregateType, payload, metadata = {}) {
@@ -246,12 +243,9 @@ function createRejection(rejectionSpecifics, metadata = {}) {
 
 // src/domain/utils/isEvent.ts
 function isEvent(event) {
-  if (typeof event !== "object")
-    return false;
-  if (event === null)
-    return false;
-  if (!("type" in event))
-    return false;
+  if (typeof event !== "object") return false;
+  if (event === null) return false;
+  if (!("type" in event)) return false;
   return "kind" in event;
 }
 
@@ -262,8 +256,7 @@ function isDomainEvent(event) {
 
 // src/domain/utils/isRejection.ts
 function isRejection(candidate) {
-  if (candidate === null || typeof candidate !== "object")
-    return false;
+  if (candidate === null || typeof candidate !== "object") return false;
   return "commandId" in candidate && "commandType" in candidate && "reasonCode" in candidate && "timestamp" in candidate;
 }
 
@@ -316,43 +309,36 @@ var SimpleDatabase = class {
   datasource = /* @__PURE__ */ new Map();
   simulateOffline = false;
   async query(tableName, specification) {
-    if (this.simulateOffline)
-      throw new DatabaseOfflineException();
+    if (this.simulateOffline) throw new DatabaseOfflineException();
     const tableRecords = this.datasource.get(tableName) || [];
     return tableRecords.filter((record) => specification.isSatisfiedBy(record));
   }
   async execute(tableName, statement) {
-    if (this.simulateOffline)
-      throw new DatabaseOfflineException();
-    if (!this.datasource.has(tableName))
-      this.datasource.set(tableName, []);
+    if (this.simulateOffline) throw new DatabaseOfflineException();
+    if (!this.datasource.has(tableName)) this.datasource.set(tableName, []);
     const table = this.datasource.get(tableName);
     switch (statement.operation) {
       case "CREATE" /* CREATE */: {
         const isDuplicate = table.some((item) => item.id === statement.payload.id);
-        if (isDuplicate)
-          throw new DuplicateRecordException(statement.payload.id);
+        if (isDuplicate) throw new DuplicateRecordException(statement.payload.id);
         table.push(statement.payload);
         break;
       }
       case "PUT" /* PUT */: {
         const index = table.findIndex((item) => item.id === statement.payload.id);
-        if (index === -1)
-          throw new RecordNotFoundException(statement.payload.id);
+        if (index === -1) throw new RecordNotFoundException(statement.payload.id);
         table[index] = statement.payload;
         break;
       }
       case "PATCH" /* PATCH */: {
         const index = table.findIndex((item) => item.id === statement.payload.id);
-        if (index === -1)
-          throw new RecordNotFoundException(statement.payload.id);
+        if (index === -1) throw new RecordNotFoundException(statement.payload.id);
         table[index] = { ...table[index], ...statement.payload };
         break;
       }
       case "DELETE" /* DELETE */: {
         const index = table.findIndex((item) => item.id === statement.payload.id);
-        if (index === -1)
-          throw new RecordNotFoundException(statement.payload.id);
+        if (index === -1) throw new RecordNotFoundException(statement.payload.id);
         table.splice(index, 1);
         break;
       }
@@ -372,12 +358,13 @@ var SimpleEventBus = class {
     this.handlers.set(stream, handlersForType);
   }
   async consume(stream, anEvent) {
-    if (!this.handlers.has(stream))
-      return;
+    if (!this.handlers.has(stream)) return;
     const handlers = this.handlers.get(stream);
-    await Promise.all(handlers.map(async (handler) => {
-      return handler.handle(anEvent);
-    }));
+    await Promise.all(
+      handlers.map(async (handler) => {
+        return handler.handle(anEvent);
+      })
+    );
   }
   async publish(stream, anEvent) {
     await this.consume(stream, anEvent);
@@ -406,49 +393,6 @@ function isIntegrationEvent(event) {
   return isEvent(event) && event.kind === "integration";
 }
 
-// src/infrastructure/EventBus/utils/mapDomainEventToIntegrationEvent.ts
-function mapDomainEventToIntegrationEvent(domainEvent) {
-  const metadata = {
-    ...domainEvent.metadata,
-    aggregateType: domainEvent.aggregateType,
-    aggregateId: domainEvent.aggregateId,
-    outcome: "accepted"
-  };
-  return {
-    id: domainEvent.id,
-    type: domainEvent.type,
-    payload: domainEvent.payload,
-    timestamp: new Date(domainEvent.timestamp).toISOString(),
-    metadata,
-    kind: "integration"
-  };
-}
-
-// src/infrastructure/EventBus/utils/mapRejectionToIntegrationEvent.ts
-function mapRejectionToIntegrationEvent(rejection) {
-  const metadata = {
-    ...rejection.metadata,
-    outcome: "rejected",
-    commandId: rejection.commandId,
-    commandType: rejection.commandType
-  };
-  return {
-    id: rejection.id,
-    type: rejection.type,
-    payload: {
-      reasonCode: rejection.reasonCode,
-      reason: rejection.reason,
-      classification: rejection.classification,
-      retryable: rejection.retryable,
-      details: rejection.details,
-      validationErrors: rejection.validationErrors
-    },
-    timestamp: new Date(rejection.timestamp).toISOString(),
-    metadata,
-    kind: "integration"
-  };
-}
-
 // src/utils/streamKey/makeStreamKey.ts
 function makeStreamKey(streamName, aggregateId) {
   return `${streamName}#${aggregateId}`;
@@ -467,10 +411,8 @@ function isEqual(a, b) {
 
 // src/utils/parseAsError/parseAsError.ts
 function parseAsError(value) {
-  if (value instanceof Error)
-    return value;
-  if (typeof value === "string")
-    return new Error(value);
+  if (value instanceof Error) return value;
+  if (typeof value === "string") return new Error(value);
   try {
     const json = JSON.stringify(value);
     return new Error(json ?? String(value));
@@ -512,11 +454,12 @@ var SimpleEventStore = class {
   }
   async append(streamName, events) {
     const uniqueAggregateIds = new Set(events.map((event2) => event2.aggregateId));
-    if (uniqueAggregateIds.size > 1)
-      throw new MultipleAggregatesException();
+    if (uniqueAggregateIds.size > 1) throw new MultipleAggregatesException();
     const event = events[0];
     const currentStream = await this.load(streamName, event.aggregateId);
-    const eventsToStore = events.map((event2) => createStoredEvent(streamName, currentStream.length + 1, event2));
+    const eventsToStore = events.map(
+      (event2) => createStoredEvent(streamName, currentStream.length + 1, event2)
+    );
     await Promise.all(
       eventsToStore.map(
         async (payload) => this.database.execute(this.tableName, { operation: "CREATE" /* CREATE */, payload })
@@ -535,14 +478,16 @@ var GenericOutboxWorker = class {
   }
   async runOnce() {
     const pending = await this.outbox.getPending();
-    await Promise.all(pending.map(async (entry) => {
-      try {
-        await this.eventBus.publish(this.stream, entry.event);
-        await this.outbox.markAsPublished(entry.id);
-      } catch {
-        await this.outbox.markAsFailed(entry.id);
-      }
-    }));
+    await Promise.all(
+      pending.map(async (entry) => {
+        try {
+          await this.eventBus.publish(this.stream, entry.event);
+          await this.outbox.markAsPublished(entry.id);
+        } catch {
+          await this.outbox.markAsFailed(entry.id);
+        }
+      })
+    );
   }
   async tick() {
     await this.runOnce();
@@ -621,12 +566,7 @@ var SimpleRepository = class {
   }
   async store(events) {
     await Promise.all(
-      events.map(
-        async (event) => this.eventStore.append(
-          this.streamName,
-          [event]
-        )
-      )
+      events.map(async (event) => this.eventStore.append(this.streamName, [event]))
     );
   }
 };
@@ -645,20 +585,20 @@ var ScenarioTest = class {
   }
   givenInput = [];
   whenInput;
-  given(...events) {
+  Given(...events) {
     this.givenInput = events;
     return {
-      when: this.when.bind(this),
-      then: this.then.bind(this)
+      When: this.When.bind(this),
+      Then: this.Then.bind(this)
     };
   }
-  when(action) {
+  When(action) {
     this.whenInput = action;
     return {
-      then: this.then.bind(this)
+      Then: this.Then.bind(this)
     };
   }
-  async then(thenInput) {
+  async Then(thenInput) {
     await Promise.all([
       this.repository.store(this.givenInput),
       ...this.givenInput.map(async (event) => this.eventBus.consume(this.streamName, event))
@@ -684,7 +624,11 @@ var ScenarioTest = class {
     }
     invariant(
       isDomainEvent(thenInput),
-      fail(new TypeError('When "domain event" or "integration event" expects a domain event in the then-step'))
+      fail(
+        new TypeError(
+          'When "domain event" or "integration event" expects a domain event in the then-step'
+        )
+      )
     );
     await this.handleEvent(this.whenInput, thenInput);
   }
@@ -695,7 +639,10 @@ var ScenarioTest = class {
       const foundRejection = pending.find(
         (entry) => entry.event.metadata.outcome === "rejected" && entry.event.metadata.commandType === outcome.commandType && entry.event.payload.reasonCode === outcome.reasonCode
       );
-      invariant(!!foundRejection, fail(new Error("ScenarioTest: rejection was not found in outbox")));
+      invariant(
+        !!foundRejection,
+        fail(new Error("ScenarioTest: rejection was not found in outbox"))
+      );
       return;
     }
     const actualEvents = await this.eventStore.load(this.streamName, outcome.aggregateId);
@@ -747,6 +694,6 @@ var ScenarioTest = class {
   }
 };
 
-export { AndSpecification, CompositeSpecification, FieldEquals, FieldGreaterThan, GenericOutboxWorker, InMemoryOutbox, NotSpecification, Operation, OrSpecification, ScenarioTest, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, convertDomainEventToIntegrationEvent, convertRejectionToIntegrationEvent, createCommand, createDomainEvent, createExternalEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createRejection, createStoredEvent, fail, getTimestamp, invariant, isCommand, isDomainEvent, isEqual, isEvent, isExternalEvent, isIntegrationEvent, isQuery, isRejection, makeStreamKey, mapDomainEventToIntegrationEvent, mapRejectionToIntegrationEvent, parseAsError };
+export { AndSpecification, CompositeSpecification, FieldEquals, FieldGreaterThan, GenericOutboxWorker, InMemoryOutbox, NotSpecification, Operation, OrSpecification, ScenarioTest, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, convertDomainEventToIntegrationEvent, convertRejectionToIntegrationEvent, createCommand, createDomainEvent, createExternalEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createRejection, createStoredEvent, fail, getTimestamp, invariant, isCommand, isDomainEvent, isEqual, isEvent, isExternalEvent, isIntegrationEvent, isQuery, isRejection, makeStreamKey, parseAsError };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map