@shirudo/ddd-kit 3.0.0-rc.13 → 3.0.0-rc.14

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { I as DeadlineStore, K as EventBus, St as AnyDomainEvent, Wt as AggregateIdentity, X as Aggregate, b as ProjectionCheckpointStore, bt as EventCommitCandidate, c as StreamReadResult, i as EventStore, k as IdempotencyStore, lt as CommandOutboxWriter, mt as Outbox, n as ReplayableStreamPages, nt as Id, pt as DispatchTrackingOutbox, qt as PublishedCommand, s as ReadStreamOptions, st as CommandOutboxCommitCandidate, t as SnapshotStore, w as IdempotencyClaimHandle, yt as CommittedDomainEvent } from "./chunks/snapshot-store.js";
+import { Ct as CommittedDomainEvent, Et as AnyDomainEvent, I as DeadlineStore, Jt as AggregateIdentity, X as EventBus, Zt as PublishedCommand, _t as DispatchTrackingOutbox, b as ProjectionCheckpointStore, c as StreamReadResult, dt as CommandOutboxCommitCandidate, et as Aggregate, i as EventStore, k as IdempotencyStore, n as ReplayableStreamPages, ot as Id, pt as CommandOutboxWriter, s as ReadStreamOptions, t as SnapshotStore, vt as Outbox, w as IdempotencyClaimHandle, wt as EventCommitCandidate } from "./chunks/snapshot-store.js";
 //#region src/testing/contract-assertions.d.ts
 /**
  * One entry of a contract test suite. Every suite (repository,

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { d as deepEqual, n as deepFreeze } from "./chunks/value-object.js";
-import { a as isDispatchTrackingOutbox, c as runBoundedExecution, f as assertPositiveSafeInteger, n as readStreamPages, w as isStampedDomainEvent } from "./chunks/read-stream-pages.js";
+import { a as isDispatchTrackingOutbox, c as runBoundedExecution, f as assertPositiveSafeInteger, n as readStreamPages, v as buildUnstampedDomainEvent, w as isStampedDomainEvent } from "./chunks/read-stream-pages.js";
 
 //#region src/testing/contract-assertions.ts
 /**
@@ -1003,7 +1003,7 @@ function createEsRepositoryContractTests(harness) {
 	const overlappingCallsBoundMs = harness.overlappingCallsBoundMs ?? 1e3;
 	const load = (repository, id) => loadAggregateOrFail(repository, id, "the stream was not appended or replayed correctly");
 	const streamFor = (id) => harness.streamKeyFor(id);
-	const recordedIds = (events) => stampedPendingEventIds(events, "pending events must be stamped before flush");
+	const registeredIds = (events) => stampedPendingEventIds(events, "the unit of work must stamp the batch that add registers");
 	const ids = (events) => events.map((event) => {
 		assert(typeof event.eventId === "string" && event.eventId.length > 0, "committed events must carry their persisted eventId");
 		return event.eventId;
@@ -1022,10 +1022,11 @@ function createEsRepositoryContractTests(harness) {
 			name: "add appends the exact creation batch to stream and outbox",
 			run: inEnvironment(async (environment) => {
 				const aggregate = harness.createAggregate();
-				const expectedIds = recordedIds(aggregate.pendingEvents);
-				assertEqual(expectedIds.length, 1, "createAggregate must record exactly one creation event");
+				assertEqual(aggregate.pendingEvents.length, 1, "createAggregate must record exactly one creation event");
+				let expectedIds = [];
 				await environment.run(async ({ repository }) => {
 					repository.add(aggregate);
+					expectedIds = registeredIds(aggregate.pendingEvents);
 				});
 				const stream = await environment.committedStreamEvents(streamFor(aggregate.id), readAll);
 				assert(stream.exists && deepEqual(ids(stream.events), expectedIds), "the stream must contain exactly the registered creation batch");
@@ -1068,9 +1069,10 @@ function createEsRepositoryContractTests(harness) {
 				const aggregate = harness.createAggregate();
 				harness.mutate(aggregate);
 				harness.mutate(aggregate);
-				const expectedIds = recordedIds(aggregate.pendingEvents);
+				let expectedIds = [];
 				await environment.run(async ({ repository }) => {
 					repository.add(aggregate);
+					expectedIds = registeredIds(aggregate.pendingEvents);
 				});
 				const reloaded = await environment.run(({ repository }) => load(repository, aggregate.id));
 				assertEqual(reloaded.version, expectedIds.length, "event-sourced version must equal the folded event count");
@@ -1085,9 +1087,10 @@ function createEsRepositoryContractTests(harness) {
 			run: inEnvironment(async (environment) => {
 				const aggregate = harness.createAggregate();
 				harness.mutate(aggregate);
-				const pending = [...aggregate.pendingEvents];
+				let pending = [];
 				await captureRejection(environment.run(async ({ repository }) => {
 					repository.add(aggregate);
+					pending = [...aggregate.pendingEvents];
 					throw new Error("rollback probe");
 				}));
 				const stream = await environment.committedStreamEvents(streamFor(aggregate.id), readAll);
@@ -1101,9 +1104,10 @@ function createEsRepositoryContractTests(harness) {
 			run: inEnvironment(async (environment) => {
 				const aggregate = harness.createAggregate();
 				harness.mutate(aggregate);
-				const expectedIds = recordedIds(aggregate.pendingEvents);
+				let expectedIds = [];
 				await captureRejection(environment.run(async ({ repository }) => {
 					repository.add(aggregate);
+					expectedIds = registeredIds(aggregate.pendingEvents);
 					throw new Error("rollback probe");
 				}));
 				await environment.run(async ({ repository }) => {
@@ -1118,10 +1122,11 @@ function createEsRepositoryContractTests(harness) {
 			name: "outbox failure rolls the already-appended stream batch back",
 			run: inEnvironment(async (environment) => {
 				const aggregate = harness.createAggregate();
-				const pending = [...aggregate.pendingEvents];
+				let pending = [];
 				environment.failNextOutboxWrite(/* @__PURE__ */ new Error("outbox failure probe"));
 				const rejection = await captureRejection(environment.run(async ({ repository }) => {
 					repository.add(aggregate);
+					pending = [...aggregate.pendingEvents];
 				}));
 				assert(rejection !== void 0, "the outbox failure must reject");
 				const stream = await environment.committedStreamEvents(streamFor(aggregate.id), readAll);
@@ -1622,6 +1627,12 @@ function createEventBusContractTests(harness) {
 function createEventStoreContractTests(harness) {
 	const inEnv = bindContractEnvironment(() => harness.createEnvironment());
 	const fixtureRead = { limit: 100 };
+	/** The decision of `event` without its stamp: no event id and no time. */
+	const unstampedTwin = (event) => buildUnstampedDomainEvent(event.type, event.payload, {
+		aggregateId: event.aggregateId,
+		aggregateType: event.aggregateType,
+		schemaVersion: event.schemaVersion
+	}, "createEventStoreContractTests");
 	const hasSameEventIds = (actual, expected) => actual.length === expected.length && actual.every((event, index) => event.eventId === expected[index]?.eventId);
 	return [
 		{
@@ -1643,6 +1654,18 @@ function createEventStoreContractTests(harness) {
 				assert(stored.exists && stored.lastVersion === 1 && stored.events.length === 1 && stored.events[0]?.eventId === event.eventId, "an empty append must not check OCC or create an empty stream");
 			})
 		},
+		{
+			name: "unstamped event: an append rejects an event without an eventId with TypeError and writes nothing",
+			run: inEnv(async ({ store }) => {
+				const [firstKey] = harness.createCollidingStreamKeys();
+				const stamped = harness.createEvent(firstKey, 50);
+				const unstamped = unstampedTwin(harness.createEvent(firstKey, 51));
+				const rejection = await captureRejection(store.append(firstKey, [stamped, unstamped], { expectedVersion: 0 }));
+				assert(rejection instanceof TypeError, "an append must reject an event without an eventId with TypeError");
+				const stored = await store.readStream(firstKey, fixtureRead);
+				assert(!stored.exists && stored.lastVersion === 0, "an append with an unstamped event must write none of the batch");
+			})
+		},
 		{
 			name: "qualified stream key: equal aggregate ids remain isolated by aggregate type",
 			run: inEnv(async ({ store }) => {
@@ -3112,7 +3135,7 @@ function createRepositoryContractTests(harness) {
 	}
 	const reload = (environment, id) => environment.run(({ repository }) => load(repository, id));
 	const eventIds = (events) => sortedCommittedEventIds(events);
-	const pendingEventIds = (events) => stampedPendingEventIds(events, "the harness must stamp pending events before persistence");
+	const pendingEventIds = (events) => stampedPendingEventIds(events, "the unit of work must stamp the batch that add registers");
 	const tests = [
 		overlappingCallsPreflight(inEnvironment, () => harness.createAggregate().id, overlappingCallsBoundMs),
 		{
@@ -3120,9 +3143,10 @@ function createRepositoryContractTests(harness) {
 			run: inEnvironment(async (environment) => {
 				const aggregate = harness.createAggregate();
 				harness.mutate(aggregate);
-				const registeredEvents = [...aggregate.pendingEvents];
+				let registeredEvents = [];
 				await environment.run(async ({ repository }) => {
 					repository.add(aggregate);
+					registeredEvents = [...aggregate.pendingEvents];
 				});
 				const reloaded = await reload(environment, aggregate.id);
 				assertEqual(reloaded.version, aggregate.version, "add must store the version registered by the Unit of Work");
@@ -3184,9 +3208,10 @@ function createRepositoryContractTests(harness) {
 			run: inEnvironment(async (environment) => {
 				const aggregate = harness.createAggregate();
 				harness.mutate(aggregate);
-				const pending = [...aggregate.pendingEvents];
+				let pending = [];
 				await captureRejection(environment.run(async ({ repository }) => {
 					repository.add(aggregate);
+					pending = [...aggregate.pendingEvents];
 					throw new Error("rollback probe");
 				}));
 				const absent = await environment.run(({ repository }) => repository.findById(aggregate.id));
@@ -3200,10 +3225,11 @@ function createRepositoryContractTests(harness) {
 			run: inEnvironment(async (environment) => {
 				const aggregate = harness.createAggregate();
 				harness.mutate(aggregate);
-				const pending = [...aggregate.pendingEvents];
+				let pending = [];
 				environment.failNextOutboxWrite(/* @__PURE__ */ new Error("outbox failure probe"));
 				const rejection = await captureRejection(environment.run(async ({ repository }) => {
 					repository.add(aggregate);
+					pending = [...aggregate.pendingEvents];
 				}));
 				assert(rejection !== void 0, "the outbox failure must reject");
 				const absent = await environment.run(({ repository }) => repository.findById(aggregate.id));