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

package/dist/chunks/read-stream-pages.js

@@ -276,6 +276,55 @@ function constructorName(prototype) {
 	return typeof name === "string" && name !== "" ? name : void 0;
 }
 
+//#endregion
+//#region src/internal/uuid-v7.ts
+const COUNTER_LIMIT = 2 ** 42;
+let lastMilliseconds = Number.NEGATIVE_INFINITY;
+let counter = 0;
+/**
+* RFC 9562 UUID version 7: the Unix time in milliseconds in the first 48 bits,
+* then random bits from Web Crypto. A B-tree index on such ids stays
+* clustered.
+*
+* The ids of one process sort in creation order. Ids from several processes
+* interleave within one millisecond and depend on their clocks. Within one
+* millisecond of one process, a 42-bit counter increases by one per id: the
+* 12 bits of `rand_a` and the first 30 bits of `rand_b`. It starts at a random
+* value with its top bit clear, so it does not run out in practice, also not
+* on a runtime that stops the clock during a request. If it runs out, the time
+* field moves one millisecond ahead. A clock that goes back does not move the
+* time field back. This is method 1 of RFC 9562, section 6.2.
+*/
+function uuidV7() {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	globalThis.crypto.getRandomValues(bytes);
+	const view = new DataView(bytes.buffer);
+	const seed = (view.getUint16(0) & 511) * 2 ** 32 + view.getUint32(2);
+	const now = Date.now();
+	if (now > lastMilliseconds) {
+		lastMilliseconds = now;
+		counter = seed;
+	} else if (counter + 1 < COUNTER_LIMIT) counter += 1;
+	else {
+		lastMilliseconds += 1;
+		counter = seed;
+	}
+	let time = lastMilliseconds;
+	for (let index = 5; index >= 0; index -= 1) {
+		bytes[index] = time % 256;
+		time = Math.floor(time / 256);
+	}
+	const counterHigh = Math.floor(counter / 2 ** 24);
+	const counterLow = counter % 2 ** 24;
+	view.setUint16(6, 28672 | counterHigh >>> 6);
+	view.setUint8(8, 128 | counterHigh & 63);
+	view.setUint8(9, counterLow >>> 16);
+	view.setUint16(10, counterLow & 65535);
+	let hex = "";
+	for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
 //#endregion
 //#region src/domain/event/clock.ts
 /** Immutable library default captured by the default domain-event factory. */
@@ -320,14 +369,14 @@ var SnapshotTimeValidationError = class extends TypeError {
 
 //#endregion
 //#region src/domain/event/domain-event.ts
-const defaultEventIdFactory = () => crypto.randomUUID();
+const defaultEventIdFactory = uuidV7;
 /**
 * Creates an immutable, instance-bound domain-event factory.
 *
 * The supplied functions are read once and captured by value. The returned
 * object is frozen, so another request, test, or library cannot replace its
 * policy. Its {@link DomainEventFactory.createStamp} method is the
-* application-shell bridge that records an accepted aggregate decision.
+* application-shell bridge that stamps an accepted aggregate decision.
 * Passing the factory through `AggregateConfig`
 * enables the explicitly named convenience methods, whose defaults read time
 * and randomness.
@@ -338,8 +387,7 @@ const defaultEventIdFactory = () => crypto.randomUUID();
 *   eventIdFactory: () => uuidv7(),
 *   clock: () => new Date(),
 * });
-* order.confirm();
-* stampPendingEvents(order, domainEvents);
+* const uow = new UnitOfWork({ ...deps, eventStampFactory: domainEvents });
 * ```
 */
 function createDomainEventFactory(options = {}) {