@arts-n-crafts/ts 3.18.0 → 3.19.0

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

@@ -148,8 +148,6 @@ interface Handling<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent
 interface EventHandler<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent, TReturnType = Promise<void>> extends Handling<TEvent, TReturnType> {
 }
 
-type Module = Record<symbol, unknown>;
-
 interface QueryMetadata extends BaseMetadata {
 }
 interface Query<TType = string, TPayload = unknown> extends WithIdentifier {
@@ -231,7 +229,7 @@ interface RejectionMetadata extends BaseMetadata {
     /** Aggregate id when known (for correlation/partitioning). */
     aggregateId?: string;
 }
-interface Rejection<TDetails = unknown> {
+interface Rejection<TDetails = object> {
     /** Unique id; derive from commandId if possible for dedupe. */
     id: string;
     /** Rejection type, format e.g., "{commandType}Rejected", "{commandType}Failed". Example "CreateUserRejected" */
@@ -266,8 +264,8 @@ interface Rejection<TDetails = unknown> {
     metadata?: RejectionMetadata;
 }
 
-interface Decider<TState, TCommand, TEvent extends DomainEvent, TRejection extends Rejection = never> {
-    decide(this: void, command: TCommand, currentState: TState): (TEvent | TRejection)[];
+interface Decider<TState, TCommand, TEvent extends DomainEvent> {
+    decide(this: void, command: TCommand, currentState: TState): TEvent[] | Rejection;
     evolve(this: void, currentState: TState, event: TEvent): TState;
     initialState(this: void, id: string): TState;
 }
@@ -346,6 +344,10 @@ declare function createQueryNode(type: 'eq' | 'gt' | 'lt', field: string | numbe
 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;
+
+declare function convertRejectionToIntegrationEvent(rejection: Rejection): IntegrationEvent;
+
 declare function createDomainEvent<TPayload = unknown>(type: string, aggregateId: string, aggregateType: string, payload: TPayload, metadata?: Partial<DomainEventMetadata>): DomainEvent<TPayload>;
 
 declare function createRejection<TDetails = unknown>(rejectionSpecifics: {
@@ -364,7 +366,7 @@ declare function isDomainEvent(event: unknown): event is DomainEvent;
 
 declare function isEvent(event: unknown): event is DomainEvent | IntegrationEvent | ExternalEvent | Rejection;
 
-declare function isRejection(event: unknown): event is Rejection;
+declare function isRejection(candidate: unknown): candidate is Rejection;
 
 interface Registerable$1<TCommand extends Command, TResult = void> {
     register(aTypeOfCommand: TCommand['type'], anHandler: CommandHandler<TCommand>): TResult;
@@ -448,10 +450,25 @@ declare class SimpleEventBus<TEvent extends DomainEvent | IntegrationEvent | Ext
     publish(stream: string, anEvent: TEvent): Promise<void>;
 }
 
+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 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}`;
 
 /**
@@ -482,14 +499,14 @@ interface EventStore<TEvent, TAppendReturnType = Promise<void>, TLoadReturnType
 
 interface OutboxEntry {
     id: string;
-    event: DomainEvent;
+    event: IntegrationEvent;
     published: boolean;
     retryCount: number;
     lastAttemptAt?: number;
 }
 
 interface Queueable<TReturnType = Promise<void>> {
-    enqueue(event: OutboxEntry['event']): TReturnType;
+    enqueue(event: DomainEvent | Rejection): TReturnType;
 }
 interface Outbox<TEnqueueReturnType = Promise<void>, TGetPendingReturnType = Promise<OutboxEntry[]>, TMarkAsPublishedReturnType = Promise<void>, TMarkAsFailedReturnType = Promise<void>> extends Queueable<TEnqueueReturnType> {
     getPending(limit?: number): TGetPendingReturnType;
@@ -533,13 +550,13 @@ declare class GenericOutboxWorker implements OutboxWorker {
 declare class InMemoryOutbox implements Outbox {
     protected entries: OutboxEntry[];
     protected idCounter: number;
-    enqueue(event: DomainEvent<unknown>): Promise<void>;
+    enqueue(event: DomainEvent | Rejection): Promise<void>;
     getPending(limit?: number): Promise<OutboxEntry[]>;
     markAsPublished(id: string): Promise<void>;
     markAsFailed(id: string): Promise<void>;
 }
 
-declare function createOutboxEntry(event: DomainEvent<unknown>): OutboxEntry;
+declare function createOutboxEntry(event: IntegrationEvent): OutboxEntry;
 
 interface Registerable<TQuery extends Query, TResult = void> {
     register(aTypeOfQuery: TQuery['type'], anHandler: QueryHandler<TQuery>): TResult;
@@ -556,16 +573,44 @@ declare class SimpleQueryBus<TQuery extends Query, TProjection> implements Query
     execute(aQuery: TQuery): Promise<TProjection>;
 }
 
-declare class SimpleRepository<TState, TCommand, TEvent extends DomainEvent, TRejection extends Rejection> implements Repository<TEvent, Promise<TState>, Promise<void>> {
+declare class SimpleRepository<TState, TCommand, TEvent extends DomainEvent> implements Repository<TEvent, Promise<TState>, Promise<void>> {
     private readonly eventStore;
     readonly streamName: string;
     private readonly evolveFn;
     private readonly initialState;
-    constructor(eventStore: EventStore<TEvent, Promise<void>, Promise<TEvent[]>>, streamName: string, evolveFn: Decider<TState, TCommand, TEvent, TRejection>['evolve'], initialState: Decider<TState, TCommand, TEvent, TRejection>['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>;
 }
 
+type GivenInput = DomainEvent[];
+type WhenInput = Command | Query | DomainEvent | IntegrationEvent | ExternalEvent;
+type ThenInput = DomainEvent | Rejection | Array<Record<string, unknown>>;
+declare class ScenarioTest<TState, TEvent extends DomainEvent> {
+    private readonly streamName;
+    private readonly eventBus;
+    private readonly eventStore;
+    private readonly commandBus;
+    private readonly queryBus;
+    private readonly repository;
+    private readonly outboxWorker;
+    private readonly outbox;
+    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>;
+    };
+    when(action: WhenInput): {
+        then(outcome: ThenInput): Promise<void>;
+    };
+    then(thenInput: ThenInput): Promise<void>;
+    private handleCommand;
+    private handleQuery;
+    private handleEvent;
+}
+
 declare function fail(anExpression: Error): () => never;
 
 declare function invariant(condition: boolean, onInvalid: () => never): asserts condition;
@@ -576,4 +621,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, type Module, 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, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, type Specification, type StoredEvent, type StreamKey, type UnixTimestampInSeconds, type WithIdentifier, createCommand, createDomainEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createRejection, createStoredEvent, fail, getTimestamp, invariant, isCommand, isDomainEvent, isEqual, isEvent, isIntegrationEvent, isQuery, isRejection, makeStreamKey, 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, mapDomainEventToIntegrationEvent, mapRejectionToIntegrationEvent, parseAsError };

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

@@ -148,8 +148,6 @@ interface Handling<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent
 interface EventHandler<TEvent extends DomainEvent | IntegrationEvent | ExternalEvent, TReturnType = Promise<void>> extends Handling<TEvent, TReturnType> {
 }
 
-type Module = Record<symbol, unknown>;
-
 interface QueryMetadata extends BaseMetadata {
 }
 interface Query<TType = string, TPayload = unknown> extends WithIdentifier {
@@ -231,7 +229,7 @@ interface RejectionMetadata extends BaseMetadata {
     /** Aggregate id when known (for correlation/partitioning). */
     aggregateId?: string;
 }
-interface Rejection<TDetails = unknown> {
+interface Rejection<TDetails = object> {
     /** Unique id; derive from commandId if possible for dedupe. */
     id: string;
     /** Rejection type, format e.g., "{commandType}Rejected", "{commandType}Failed". Example "CreateUserRejected" */
@@ -266,8 +264,8 @@ interface Rejection<TDetails = unknown> {
     metadata?: RejectionMetadata;
 }
 
-interface Decider<TState, TCommand, TEvent extends DomainEvent, TRejection extends Rejection = never> {
-    decide(this: void, command: TCommand, currentState: TState): (TEvent | TRejection)[];
+interface Decider<TState, TCommand, TEvent extends DomainEvent> {
+    decide(this: void, command: TCommand, currentState: TState): TEvent[] | Rejection;
     evolve(this: void, currentState: TState, event: TEvent): TState;
     initialState(this: void, id: string): TState;
 }
@@ -346,6 +344,10 @@ declare function createQueryNode(type: 'eq' | 'gt' | 'lt', field: string | numbe
 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;
+
+declare function convertRejectionToIntegrationEvent(rejection: Rejection): IntegrationEvent;
+
 declare function createDomainEvent<TPayload = unknown>(type: string, aggregateId: string, aggregateType: string, payload: TPayload, metadata?: Partial<DomainEventMetadata>): DomainEvent<TPayload>;
 
 declare function createRejection<TDetails = unknown>(rejectionSpecifics: {
@@ -364,7 +366,7 @@ declare function isDomainEvent(event: unknown): event is DomainEvent;
 
 declare function isEvent(event: unknown): event is DomainEvent | IntegrationEvent | ExternalEvent | Rejection;
 
-declare function isRejection(event: unknown): event is Rejection;
+declare function isRejection(candidate: unknown): candidate is Rejection;
 
 interface Registerable$1<TCommand extends Command, TResult = void> {
     register(aTypeOfCommand: TCommand['type'], anHandler: CommandHandler<TCommand>): TResult;
@@ -448,10 +450,25 @@ declare class SimpleEventBus<TEvent extends DomainEvent | IntegrationEvent | Ext
     publish(stream: string, anEvent: TEvent): Promise<void>;
 }
 
+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 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}`;
 
 /**
@@ -482,14 +499,14 @@ interface EventStore<TEvent, TAppendReturnType = Promise<void>, TLoadReturnType
 
 interface OutboxEntry {
     id: string;
-    event: DomainEvent;
+    event: IntegrationEvent;
     published: boolean;
     retryCount: number;
     lastAttemptAt?: number;
 }
 
 interface Queueable<TReturnType = Promise<void>> {
-    enqueue(event: OutboxEntry['event']): TReturnType;
+    enqueue(event: DomainEvent | Rejection): TReturnType;
 }
 interface Outbox<TEnqueueReturnType = Promise<void>, TGetPendingReturnType = Promise<OutboxEntry[]>, TMarkAsPublishedReturnType = Promise<void>, TMarkAsFailedReturnType = Promise<void>> extends Queueable<TEnqueueReturnType> {
     getPending(limit?: number): TGetPendingReturnType;
@@ -533,13 +550,13 @@ declare class GenericOutboxWorker implements OutboxWorker {
 declare class InMemoryOutbox implements Outbox {
     protected entries: OutboxEntry[];
     protected idCounter: number;
-    enqueue(event: DomainEvent<unknown>): Promise<void>;
+    enqueue(event: DomainEvent | Rejection): Promise<void>;
     getPending(limit?: number): Promise<OutboxEntry[]>;
     markAsPublished(id: string): Promise<void>;
     markAsFailed(id: string): Promise<void>;
 }
 
-declare function createOutboxEntry(event: DomainEvent<unknown>): OutboxEntry;
+declare function createOutboxEntry(event: IntegrationEvent): OutboxEntry;
 
 interface Registerable<TQuery extends Query, TResult = void> {
     register(aTypeOfQuery: TQuery['type'], anHandler: QueryHandler<TQuery>): TResult;
@@ -556,16 +573,44 @@ declare class SimpleQueryBus<TQuery extends Query, TProjection> implements Query
     execute(aQuery: TQuery): Promise<TProjection>;
 }
 
-declare class SimpleRepository<TState, TCommand, TEvent extends DomainEvent, TRejection extends Rejection> implements Repository<TEvent, Promise<TState>, Promise<void>> {
+declare class SimpleRepository<TState, TCommand, TEvent extends DomainEvent> implements Repository<TEvent, Promise<TState>, Promise<void>> {
     private readonly eventStore;
     readonly streamName: string;
     private readonly evolveFn;
     private readonly initialState;
-    constructor(eventStore: EventStore<TEvent, Promise<void>, Promise<TEvent[]>>, streamName: string, evolveFn: Decider<TState, TCommand, TEvent, TRejection>['evolve'], initialState: Decider<TState, TCommand, TEvent, TRejection>['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>;
 }
 
+type GivenInput = DomainEvent[];
+type WhenInput = Command | Query | DomainEvent | IntegrationEvent | ExternalEvent;
+type ThenInput = DomainEvent | Rejection | Array<Record<string, unknown>>;
+declare class ScenarioTest<TState, TEvent extends DomainEvent> {
+    private readonly streamName;
+    private readonly eventBus;
+    private readonly eventStore;
+    private readonly commandBus;
+    private readonly queryBus;
+    private readonly repository;
+    private readonly outboxWorker;
+    private readonly outbox;
+    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>;
+    };
+    when(action: WhenInput): {
+        then(outcome: ThenInput): Promise<void>;
+    };
+    then(thenInput: ThenInput): Promise<void>;
+    private handleCommand;
+    private handleQuery;
+    private handleEvent;
+}
+
 declare function fail(anExpression: Error): () => never;
 
 declare function invariant(condition: boolean, onInvalid: () => never): asserts condition;
@@ -576,4 +621,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, type Module, 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, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, type Specification, type StoredEvent, type StreamKey, type UnixTimestampInSeconds, type WithIdentifier, createCommand, createDomainEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createRejection, createStoredEvent, fail, getTimestamp, invariant, isCommand, isDomainEvent, isEqual, isEvent, isIntegrationEvent, isQuery, isRejection, makeStreamKey, 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, mapDomainEventToIntegrationEvent, mapRejectionToIntegrationEvent, parseAsError };

package/packages/v4/dist/index.js

@@ -3,7 +3,7 @@ import { randomUUID } from 'crypto';
 // src/core/utils/createCommand.ts
 
 // src/core/utils/getTimestamp.ts
-var getTimestamp = (date = /* @__PURE__ */ new Date()) => Math.floor(date.getTime() / 1e3);
+var getTimestamp = (date = /* @__PURE__ */ new Date()) => date.getTime();
 
 // src/core/utils/createCommand.ts
 function createCommand(type, aggregateId, aggregateType, payload, metadata = {}) {
@@ -178,6 +178,42 @@ var FieldGreaterThan = class extends CompositeSpecification {
     return createQueryNode("gt", this.field, this.value);
   }
 };
+function createIntegrationEvent(type, payload, metadata) {
+  return Object.freeze({
+    id: randomUUID(),
+    type,
+    payload,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: {
+      ...metadata
+    },
+    kind: "integration"
+  });
+}
+
+// src/domain/utils/convertDomainEventToIntegrationEvent.ts
+function convertDomainEventToIntegrationEvent(event) {
+  return createIntegrationEvent(event.type, event.payload, {
+    outcome: "accepted",
+    aggregateType: event.aggregateType,
+    aggregateId: event.aggregateId
+  });
+}
+
+// src/domain/utils/convertRejectionToIntegrationEvent.ts
+function convertRejectionToIntegrationEvent(rejection) {
+  return createIntegrationEvent(
+    rejection.commandType,
+    { ...rejection.details, reasonCode: rejection.reasonCode },
+    {
+      outcome: "rejected",
+      aggregateType: rejection.metadata?.aggregateType,
+      aggregateId: rejection.metadata?.aggregateId,
+      commandType: rejection.commandType,
+      commandId: rejection.commandId
+    }
+  );
+}
 function createDomainEvent(type, aggregateId, aggregateType, payload, metadata = {}) {
   return Object.freeze({
     id: randomUUID(),
@@ -225,8 +261,10 @@ function isDomainEvent(event) {
 }
 
 // src/domain/utils/isRejection.ts
-function isRejection(event) {
-  return isEvent(event) && "commandId" in event && "reasonCode" in event && event.kind === "rejection";
+function isRejection(candidate) {
+  if (candidate === null || typeof candidate !== "object")
+    return false;
+  return "commandId" in candidate && "commandType" in candidate && "reasonCode" in candidate && "timestamp" in candidate;
 }
 
 // src/infrastructure/CommandBus/implementations/SimpleCommandBus.ts
@@ -345,7 +383,7 @@ var SimpleEventBus = class {
     await this.consume(stream, anEvent);
   }
 };
-function createIntegrationEvent(type, payload, metadata) {
+function createExternalEvent(type, payload, metadata) {
   return Object.freeze({
     id: randomUUID(),
     type,
@@ -354,15 +392,63 @@ function createIntegrationEvent(type, payload, metadata) {
     metadata: {
       ...metadata
     },
-    kind: "integration"
+    kind: "external"
   });
 }
 
+// src/infrastructure/EventBus/utils/isExternalEvent.ts
+function isExternalEvent(event) {
+  return isEvent(event) && event.kind === "external";
+}
+
 // src/infrastructure/EventBus/utils/isIntegrationEvent.ts
 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,18 +553,23 @@ var GenericOutboxWorker = class {
     }, intervalMs);
   }
 };
+function createOutboxEntry(event) {
+  return {
+    id: randomUUID(),
+    event,
+    published: false,
+    retryCount: 0,
+    lastAttemptAt: void 0
+  };
+}
 
 // src/infrastructure/Outbox/implementations/InMemoryOutbox.ts
 var InMemoryOutbox = class {
   entries = [];
   idCounter = 0;
   async enqueue(event) {
-    this.entries.push({
-      id: (this.idCounter++).toString(),
-      event,
-      published: false,
-      retryCount: 0
-    });
+    const integrationEvent = isRejection(event) ? convertRejectionToIntegrationEvent(event) : convertDomainEventToIntegrationEvent(event);
+    this.entries.push(createOutboxEntry(integrationEvent));
   }
   async getPending(limit = 100) {
     return this.entries.filter((e) => !e.published).slice(0, limit);
@@ -497,15 +588,6 @@ var InMemoryOutbox = class {
     }
   }
 };
-function createOutboxEntry(event) {
-  return Object.freeze({
-    id: randomUUID(),
-    event,
-    published: false,
-    retryCount: 0,
-    lastAttemptAt: void 0
-  });
-}
 
 // src/infrastructure/QueryBus/implementations/SimpleQueryBus.ts
 var SimpleQueryBus = class {
@@ -549,6 +631,122 @@ var SimpleRepository = class {
   }
 };
 
-export { AndSpecification, CompositeSpecification, FieldEquals, FieldGreaterThan, GenericOutboxWorker, InMemoryOutbox, NotSpecification, Operation, OrSpecification, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, createCommand, createDomainEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createRejection, createStoredEvent, fail, getTimestamp, invariant, isCommand, isDomainEvent, isEqual, isEvent, isIntegrationEvent, isQuery, isRejection, makeStreamKey, parseAsError };
+// src/infrastructure/ScenarioTest/ScenarioTest.ts
+var ScenarioTest = class {
+  constructor(streamName, eventBus, eventStore, commandBus, queryBus, repository, outboxWorker, outbox) {
+    this.streamName = streamName;
+    this.eventBus = eventBus;
+    this.eventStore = eventStore;
+    this.commandBus = commandBus;
+    this.queryBus = queryBus;
+    this.repository = repository;
+    this.outboxWorker = outboxWorker;
+    this.outbox = outbox;
+  }
+  givenInput = [];
+  whenInput;
+  given(...events) {
+    this.givenInput = events;
+    return {
+      when: this.when.bind(this),
+      then: this.then.bind(this)
+    };
+  }
+  when(action) {
+    this.whenInput = action;
+    return {
+      then: this.then.bind(this)
+    };
+  }
+  async then(thenInput) {
+    await Promise.all([
+      this.repository.store(this.givenInput),
+      ...this.givenInput.map(async (event) => this.eventBus.consume(this.streamName, event))
+    ]);
+    if (!this.whenInput) {
+      throw new Error("In the ScenarioTest, the when-step cannot be empty");
+    }
+    if (isCommand(this.whenInput)) {
+      invariant(
+        isDomainEvent(thenInput) || isRejection(thenInput),
+        fail(new TypeError('When "command" expects a domain event or rejection in the then-step'))
+      );
+      await this.handleCommand(this.whenInput, thenInput);
+      return;
+    }
+    if (isQuery(this.whenInput)) {
+      invariant(
+        Array.isArray(thenInput),
+        fail(new TypeError('When "query" expects an array of expected results in the then-step'))
+      );
+      await this.handleQuery(this.whenInput, thenInput);
+      return;
+    }
+    invariant(
+      isDomainEvent(thenInput),
+      fail(new TypeError('When "domain event" or "integration event" expects a domain event in the then-step'))
+    );
+    await this.handleEvent(this.whenInput, thenInput);
+  }
+  async handleCommand(command, outcome) {
+    await this.commandBus.execute(command);
+    if (isRejection(outcome)) {
+      const pending = await this.outbox.getPending();
+      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")));
+      return;
+    }
+    const actualEvents = await this.eventStore.load(this.streamName, outcome.aggregateId);
+    const foundEvent = actualEvents.findLast(
+      (event) => isDomainEvent(event) && event.aggregateId === outcome.aggregateId && event.type === outcome.type
+    );
+    invariant(!!foundEvent, fail(new Error("ScenarioTest: event/command was not found")));
+    invariant(
+      outcome.type === foundEvent.type,
+      fail(new Error("ScenarioTest: event/command type was not equal"))
+    );
+    invariant(
+      outcome.aggregateId === foundEvent.aggregateId,
+      fail(new Error("ScenarioTest: event/command aggregate id was not equal"))
+    );
+    invariant(
+      isEqual(outcome.payload, foundEvent.payload),
+      fail(new Error("ScenarioTest: event/command payload was not equal"))
+    );
+  }
+  async handleQuery(query, expected) {
+    await this.outboxWorker.tick();
+    const actual = await this.queryBus.execute(query);
+    invariant(
+      isEqual(actual, expected),
+      fail(new Error("ScenarioTest: a different query result was returned"))
+    );
+  }
+  async handleEvent(event, outcome) {
+    await this.eventBus.publish(this.streamName, event);
+    const actualEvents = await this.eventStore.load(this.streamName, outcome.aggregateId);
+    const foundEvent = actualEvents.findLast(
+      (event2) => isEvent(event2) && event2.aggregateId === outcome.aggregateId && event2.type === outcome.type
+    );
+    invariant(!!foundEvent, fail(new Error("ScenarioTest: event was not found")));
+    invariant(isEvent(foundEvent), fail(new Error("ScenarioTest: event is not of type event")));
+    invariant(
+      outcome.type === foundEvent.type,
+      fail(new Error("ScenarioTest: event type was not equal"))
+    );
+    invariant(
+      outcome.aggregateId === foundEvent.aggregateId,
+      fail(new Error("ScenarioTest: event aggregate id was not equal"))
+    );
+    invariant(
+      isEqual(outcome.payload, foundEvent.payload),
+      fail(new Error("ScenarioTest: event payload was not equal"))
+    );
+  }
+};
+
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map