@shirudo/ddd-kit 3.0.0-rc.10 → 3.0.0-rc.12

package/dist/money.d.ts

@@ -1,4 +1,4 @@
-import { u as DomainError } from "./chunks/kit-errors.js";
+import { f as DomainError } from "./chunks/kit-errors.js";
 import { Result } from "@shirudo/result";
 //#region src/domain/value-object/money/money.d.ts
 /**

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { Lt as PublishedCommand, P as EventBus, Pt as AggregateAddress, R as Aggregate, W as Id, Y as CommandOutboxCommitCandidate, Z as CommandOutboxWriter, _ as IdempotencyStore, a as StreamReadResult, c as ProjectionCheckpointStore, ct as EventCommitCandidate, f as IdempotencyClaimHandle, i as ReadStreamOptions, n as EventStore, nt as Outbox, st as CommittedDomainEvent, t as SnapshotStore, tt as DispatchTrackingOutbox, ut as AnyDomainEvent, w as DeadlineStore } from "./chunks/snapshot-store.js";
+import { A as IdempotencyClaimHandle, E as ProjectionCheckpointStore, Et as EventCommitCandidate, F as IdempotencyStore, H as DeadlineStore, Ot as AnyDomainEvent, Q as EventBus, Qt as AggregateIdentity, Tt as CommittedDomainEvent, bt as Outbox, c as StreamReadResult, ct as Id, ht as CommandOutboxWriter, i as EventStore, n as ReplayableStreamPages, nt as Aggregate, pt as CommandOutboxCommitCandidate, s as ReadStreamOptions, t as SnapshotStore, tn as PublishedCommand, yt as DispatchTrackingOutbox } from "./chunks/snapshot-store.js";
 //#region src/testing/contract-assertions.d.ts
 /**
  * One entry of a contract test suite. Every suite (repository,
@@ -20,6 +20,10 @@ interface CommandOutboxContractEnvironment<C extends PublishedCommand> {
   readonly outbox: CommandOutboxWriter<C>;
   readonly addCommitted: (commits: ReadonlyArray<CommandOutboxCommitCandidate<C>>) => Promise<void>;
   readonly addRolledBack?: (commits: ReadonlyArray<CommandOutboxCommitCandidate<C>>) => Promise<void>;
+  /** Runs `outbox.endEventSources(sources)` in a transaction that commits. */
+  readonly endEventSourcesCommitted: (sources: ReadonlyArray<AggregateIdentity>) => Promise<void>;
+  /** Runs `outbox.endEventSources(sources)` in a transaction that rolls back. */
+  readonly endEventSourcesRolledBack?: (sources: ReadonlyArray<AggregateIdentity>) => Promise<void>;
   readonly readAll: () => Promise<ReadonlyArray<CommandOutboxCommitCandidate<C>>>;
   readonly teardown?: () => Promise<void>;
 }
@@ -35,6 +39,8 @@ interface CommandOutboxContractHarness<C extends PublishedCommand> {
    */
   readonly createCommand: (seed: number) => C;
   readonly providesRolledBackAdds?: boolean;
+  /** Declare `true` when environments provide `endEventSourcesRolledBack`. */
+  readonly providesRolledBackEnds?: boolean;
 }
 type CommandOutboxContractTest = ContractTest;
 declare function createCommandOutboxContractTests<C extends PublishedCommand>(harness: CommandOutboxContractHarness<C>): ReadonlyArray<CommandOutboxContractTest>;
@@ -89,8 +95,8 @@ interface DeadlineStoreContractHarness {
   /**
    * Declare `true` when environments provide {@link
    * DeadlineStoreContractEnvironment.runRolledBack}. Without it, the
-   * rollback tests are marked skipped: the honest state of an
-   * in-memory fake, and a loud gap for a transactional adapter.
+   * rollback tests are marked skipped: the honest state of a store
+   * without a rollback, and a loud gap for a transactional adapter.
    */
   providesRolledBackRuns?: boolean;
   /**
@@ -129,7 +135,7 @@ interface EsRepositoryContractEnvironment<TAggregate extends Aggregate<Id<string
   }) => Promise<R>): Promise<R>;
   committedOutboxEvents(): Promise<ReadonlyArray<CommittedDomainEvent<TEvent>>>;
   failNextOutboxWrite(error: Error): void;
-  committedStreamEvents(stream: AggregateAddress<TAggregate["id"]>, options: ReadStreamOptions): Promise<StreamReadResult<TEvent>>;
+  committedStreamEvents(stream: AggregateIdentity<TAggregate["id"]>, options: ReadStreamOptions): Promise<StreamReadResult<TEvent>>;
   teardown?(): Promise<void>;
 }
 interface EsRepositoryContractHarness<TAggregate extends Aggregate<Id<string>, TEvent>, TEvent extends AnyDomainEvent = AnyDomainEvent> {
@@ -137,7 +143,7 @@ interface EsRepositoryContractHarness<TAggregate extends Aggregate<Id<string>, T
   /** Fresh aggregate with exactly one recorded creation event. */
   createAggregate(): TAggregate;
   createAggregateWithId?(id: TAggregate["id"]): TAggregate;
-  streamKeyFor(id: TAggregate["id"]): AggregateAddress<TAggregate["id"]>;
+  streamKeyFor(id: TAggregate["id"]): AggregateIdentity<TAggregate["id"]>;
   /** Applies exactly one event and advances the aggregate version by one. */
   mutate(aggregate: TAggregate): void;
   snapshotState?(aggregate: TAggregate): unknown;
@@ -225,13 +231,13 @@ interface EventStoreContractEnvironment<Evt extends AnyDomainEvent> {
  *
  * `createCollidingStreamKeys` must return two valid stream keys with the same
  * raw aggregate id and different aggregate types. `createEvent` must return an
- * event addressed to the supplied key; different sequence values must produce
+ * event that belongs to the supplied key; different sequence values must produce
  * different event ids.
  */
 interface EventStoreContractHarness<Evt extends AnyDomainEvent> {
   createEnvironment(): Promise<EventStoreContractEnvironment<Evt>>;
-  createCollidingStreamKeys(): readonly [AggregateAddress, AggregateAddress];
-  createEvent(stream: AggregateAddress, sequence: number): Evt;
+  createCollidingStreamKeys(): readonly [AggregateIdentity, AggregateIdentity];
+  createEvent(stream: AggregateIdentity, sequence: number): Evt;
 }
 /**
  * Reusable proof of an EventStore adapter's portable semantics: qualified
@@ -339,10 +345,21 @@ interface OutboxContractEnvironment<Evt extends AnyDomainEvent> {
    * Optional capability: runs `outbox.add(candidates)` inside a
    * transaction that ROLLS BACK. Enables the rollback-purity test: a
    * rolled-back add must leave nothing behind. Transactional adapters
-   * should always provide this; it is the half of the outbox promise
-   * that in-memory fakes cannot keep.
+   * should always provide this.
    */
   addRolledBack?(events: ReadonlyArray<EventCommitCandidate<Evt>>): Promise<void>;
+  /**
+   * Runs `outbox.endEventSources(sources)` inside a transaction that
+   * COMMITS, the way `withCommit` calls it for a removal. For a
+   * non-transactional store this is simply `outbox.endEventSources(sources)`.
+   */
+  endEventSourcesCommitted(sources: ReadonlyArray<AggregateIdentity>): Promise<void>;
+  /**
+   * Optional capability: runs `outbox.endEventSources(sources)` inside a
+   * transaction that ROLLS BACK. Enables the test that a rolled-back
+   * removal leaves its event source open.
+   */
+  endEventSourcesRolledBack?(sources: ReadonlyArray<AggregateIdentity>): Promise<void>;
   /** Release connections, drop schemas, etc. Called in a finally. */
   teardown?(): Promise<void>;
 }
@@ -380,10 +397,16 @@ interface OutboxContractHarness<Evt extends AnyDomainEvent> {
   /**
    * Declare `true` when environments provide {@link
    * OutboxContractEnvironment.addRolledBack}. Without it, the
-   * rollback-purity test is marked skipped: the honest state of an
-   * in-memory fake, and a loud gap for a transactional adapter.
+   * rollback-purity test is marked skipped: the honest state of a store
+   * without a rollback, and a loud gap for a transactional adapter.
    */
   providesRolledBackAdds?: boolean;
+  /**
+   * Declare `true` when environments provide {@link
+   * OutboxContractEnvironment.endEventSourcesRolledBack}. Without it, the
+   * test that a rolled-back end leaves the source open is marked skipped.
+   */
+  providesRolledBackEnds?: boolean;
   /**
    * Declare `true` when the adapter's `getPending` CLAIMS the returned
    * records for competing dispatchers (lease, visibility timeout,
@@ -447,7 +470,7 @@ interface ProjectionCheckpointStoreContractEnvironment<TCtx> {
    * BACK. Enables the rollback test: a rolled-back save must leave no
    * checkpoint behind, the half of the atomic update+checkpoint
    * promise the store contributes. Transactional adapters should
-   * always provide this; in-memory fakes cannot.
+   * always provide this.
    */
   runRolledBack?<R>(work: (ctx: TCtx) => Promise<R>): Promise<R>;
   /** Release connections, drop schemas, etc. Called in a finally. */
@@ -466,7 +489,8 @@ interface ProjectionCheckpointStoreContractHarness<TCtx> {
    * Declare `true` when environments provide {@link
    * ProjectionCheckpointStoreContractEnvironment.runRolledBack}.
    * Without it, the rollback test is marked skipped: the honest state
-   * of an in-memory fake, and a loud gap for a transactional adapter.
+   * of a store without a rollback, and a loud gap for a transactional
+   * adapter.
    */
   providesRolledBackRuns?: boolean;
   /**
@@ -497,6 +521,73 @@ interface ProjectionCheckpointStoreContractHarness<TCtx> {
  */
 declare function createProjectionCheckpointStoreContractTests<TCtx>(harness: ProjectionCheckpointStoreContractHarness<TCtx>): ProjectionCheckpointStoreContractTest[];
 //#endregion
+//#region src/testing/replayable-stream-pages.d.ts
+/** Options for {@link createReplayableStreamPages}. */
+interface CreateReplayableStreamPagesOptions<Evt extends AnyDomainEvent> extends Pick<ReplayableStreamPages<Evt>, "fromVersion" | "targetVersion"> {
+  /** The events after the cursor through the target, in append order. */
+  readonly tail: ReadonlyArray<Evt>;
+  /**
+   * The maximum number of events per page. Without it, the tail comes back
+   * as one page. Set it to make a test cross a page boundary. Must be a
+   * positive safe integer when present.
+   */
+  readonly limit?: number;
+}
+/**
+ * Builds a replayable stream read from an in-memory tail, for a test of the
+ * code that consumes a read: a repository, or the replay over a fixed window.
+ * It stands in for `readStreamPages` or an adapter that pages on its own,
+ * and it tests neither. The tail is copied once and frozen deeply, and it
+ * comes back in the same pages on every iteration. So a consumer that
+ * changes an event in place fails at the write in its own test. An empty
+ * tail yields no page, as `readStreamPages` does.
+ */
+declare function createReplayableStreamPages<Evt extends AnyDomainEvent>(stream: AggregateIdentity, options: CreateReplayableStreamPagesOptions<Evt>): ReplayableStreamPages<Evt>;
+//#endregion
+//#region src/testing/replayable-stream-pages-contract.d.ts
+/** One named contract test for code that builds replayable stream reads. */
+type ReplayableStreamPagesContractTest = ContractTest;
+/** The window the suite asks the code under test for. */
+interface ReplayableStreamPagesContractWindow {
+  /** The cursor: the pages hold the events after this version. */
+  readonly fromVersion: number;
+  /** The version a point-in-time read asks for. Absent for a read to the head. */
+  readonly toVersion?: number;
+  /** The maximum number of events per page. */
+  readonly limit: number;
+}
+/** The code under test and the store it reads. The suite creates one per test. */
+interface ReplayableStreamPagesContractEnvironment<Evt extends AnyDomainEvent> {
+  /** Appends events to the end of the stream in the store that the code reads. */
+  append(stream: AggregateIdentity, events: ReadonlyArray<Evt>): Promise<void>;
+  /**
+   * Reads the stream through the code under test. Returns `undefined`
+   * for an absent stream and for a window that lies outside the stream.
+   */
+  read(stream: AggregateIdentity, window: ReplayableStreamPagesContractWindow): Promise<ReplayableStreamPages<Evt> | undefined>;
+  teardown?(): Promise<void>;
+}
+/**
+ * Inputs the suite needs. `createStream` returns an aggregate identity that no
+ * other test uses. `createEvent` returns an event that belongs to that
+ * stream; different sequence values give different event ids.
+ */
+interface ReplayableStreamPagesContractHarness<Evt extends AnyDomainEvent> {
+  createEnvironment(): Promise<ReplayableStreamPagesContractEnvironment<Evt>>;
+  createStream(): AggregateIdentity;
+  createEvent(stream: AggregateIdentity, sequence: number): Evt;
+}
+/**
+ * Reusable proof of code that builds `ReplayableStreamPages` values:
+ * `readStreamPages`, or an adapter that pages on its own.
+ * The suite proves that the pages hold the events after the cursor
+ * through the target version in append order, that no page is empty or
+ * larger than the limit, that every iteration yields the same prefix, and
+ * that an append during the iteration stays out. It also proves that an
+ * absent stream and a window outside the stream give no replayable read.
+ */
+declare function createReplayableStreamPagesContractTests<Evt extends AnyDomainEvent>(harness: ReplayableStreamPagesContractHarness<Evt>): ReplayableStreamPagesContractTest[];
+//#endregion
 //#region src/testing/repository-contract.d.ts
 /** Application-facing state-stored repository exercised by the suite. */
 interface ContractRepository<TAggregate extends Aggregate<Id<string>, AnyDomainEvent>> {
@@ -627,5 +718,5 @@ interface SnapshotStoreContractHarness {
  */
 declare function createSnapshotStoreContractTests(harness: SnapshotStoreContractHarness): SnapshotStoreContractTest[];
 //#endregion
-export { type CommandOutboxContractEnvironment, type CommandOutboxContractHarness, type CommandOutboxContractTest, type ContractRepository, type DeadlineStoreContractEnvironment, type DeadlineStoreContractHarness, type DeadlineStoreContractTest, type EsContractRepository, type EsRepositoryContractEnvironment, type EsRepositoryContractHarness, type EsRepositoryContractTest, type EventBusContractEnvironment, type EventBusContractHarness, type EventBusContractTest, type EventStoreContractEnvironment, type EventStoreContractHarness, type EventStoreContractTest, type IdempotencyStoreContractEnvironment, type IdempotencyStoreContractHarness, type IdempotencyStoreContractTest, type OutboxContractEnvironment, type OutboxContractHarness, type OutboxContractTest, type ProjectionCheckpointStoreContractEnvironment, type ProjectionCheckpointStoreContractHarness, type ProjectionCheckpointStoreContractTest, type RepositoryContractEnvironment, type RepositoryContractHarness, type RepositoryContractTest, type SnapshotStoreContractEnvironment, type SnapshotStoreContractHarness, type SnapshotStoreContractTest, createCommandOutboxContractTests, createDeadlineStoreContractTests, createEsRepositoryContractTests, createEventBusContractTests, createEventStoreContractTests, createIdempotencyStoreContractTests, createOutboxContractTests, createProjectionCheckpointStoreContractTests, createRepositoryContractTests, createSnapshotStoreContractTests };
+export { type CommandOutboxContractEnvironment, type CommandOutboxContractHarness, type CommandOutboxContractTest, type ContractRepository, type CreateReplayableStreamPagesOptions, type DeadlineStoreContractEnvironment, type DeadlineStoreContractHarness, type DeadlineStoreContractTest, type EsContractRepository, type EsRepositoryContractEnvironment, type EsRepositoryContractHarness, type EsRepositoryContractTest, type EventBusContractEnvironment, type EventBusContractHarness, type EventBusContractTest, type EventStoreContractEnvironment, type EventStoreContractHarness, type EventStoreContractTest, type IdempotencyStoreContractEnvironment, type IdempotencyStoreContractHarness, type IdempotencyStoreContractTest, type OutboxContractEnvironment, type OutboxContractHarness, type OutboxContractTest, type ProjectionCheckpointStoreContractEnvironment, type ProjectionCheckpointStoreContractHarness, type ProjectionCheckpointStoreContractTest, type ReplayableStreamPagesContractEnvironment, type ReplayableStreamPagesContractHarness, type ReplayableStreamPagesContractTest, type ReplayableStreamPagesContractWindow, type RepositoryContractEnvironment, type RepositoryContractHarness, type RepositoryContractTest, type SnapshotStoreContractEnvironment, type SnapshotStoreContractHarness, type SnapshotStoreContractTest, createCommandOutboxContractTests, createDeadlineStoreContractTests, createEsRepositoryContractTests, createEventBusContractTests, createEventStoreContractTests, createIdempotencyStoreContractTests, createOutboxContractTests, createProjectionCheckpointStoreContractTests, createReplayableStreamPages, createReplayableStreamPagesContractTests, createRepositoryContractTests, createSnapshotStoreContractTests };
 //# sourceMappingURL=testing.d.ts.map