@shirudo/ddd-kit 3.0.0-rc.6 → 3.0.0-rc.8

package/dist/chunks/ports.js

@@ -1668,6 +1668,130 @@ function mergeMetadata(...metadataObjects) {
 	return merged;
 }
 
+//#endregion
+//#region src/internal/async/abort.ts
+/**
+* The value to reject with when an `AbortSignal` has fired.
+*
+* Returns the signal's `reason` (a `DOMException` `AbortError` for
+* `controller.abort()`, `TimeoutError` for `AbortSignal.timeout`), falling
+* back to a plain `Error` with `fallbackMessage` when `reason` is nullish.
+* A spec-compliant signal always populates `reason` when aborted, so the
+* fallback only fires for a non-spec polyfill; without it, a bare
+* `throw undefined` would surface, breaking `instanceof Error` handling.
+*
+* Centralizes the `signal.reason ?? new Error(...)` idiom used at every
+* abort site (event bus, `withCommit`, `UnitOfWork.run`, the retrying
+* scope) so a single fix covers all of them.
+*/
+function abortReason(signal, fallbackMessage) {
+	return signal.reason ?? new Error(fallbackMessage);
+}
+
+//#endregion
+//#region src/internal/validate.ts
+/**
+* Shared construction-time guards for numeric options. `context` names
+* the throwing component so the error reads like the component's own
+* validation ("OutboxDispatcher: pollIntervalMs must be...").
+*/
+/** Guard for numeric options that must be a non-negative finite number. */
+function assertNonNegativeFinite(context, field, value) {
+	if (!Number.isFinite(value) || value < 0) throw new Error(`${context}: ${field} must be a non-negative finite number, got ${value}`);
+}
+/** Guard for count options that must be a whole number of at least 1. */
+function assertPositiveInteger(context, field, value) {
+	if (!Number.isInteger(value) || value < 1) throw new Error(`${context}: ${field} must be an integer >= 1, got ${value}`);
+}
+/** Guard for retained-record capacities that must fit exact JS integers. */
+function assertPositiveSafeInteger(context, field, value) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`${context}: ${field} must be a positive safe integer, got ${value}`);
+}
+
+//#endregion
+//#region src/internal/async/execution.ts
+/** Default bound for delivery and post-commit operations. */
+const DEFAULT_EXECUTION_TIMEOUT_MS = 3e4;
+/**
+* Owner signal of each child signal that {@link runBoundedExecution} minted.
+*
+* One bounded operation often wraps another, and every hop derives a fresh
+* signal. A consumer that follows a call chain by signal identity alone loses
+* the link at the first hop. Key and value are both weak: a long chain of
+* nested operations must not hold its whole ancestry alive.
+*/
+const executionOwners = /* @__PURE__ */ new WeakMap();
+/**
+* The signal that a bounded execution derived this one from, or `undefined`
+* when the signal did not come from {@link runBoundedExecution} or had no
+* owner. Walk it to follow a chain across nested bounded executions.
+*/
+function ownerSignalOf(signal) {
+	return executionOwners.get(signal)?.deref();
+}
+/**
+* Runs one operation with a child signal that combines owner cancellation and a
+* shell-owned timeout. The returned promise settles on abort even when an
+* adapter ignores the signal; the adapter promise remains observed so a later
+* rejection cannot become an unhandled rejection.
+*
+* This bounds how long the shell waits; JavaScript cannot forcibly terminate
+* an arbitrary promise. An I/O adapter that must prevent zombie work and
+* overlapping retries has to pass `context.signal` to its native operation or
+* enforce a native timeout no later than `context.deadlineAt`.
+*/
+function runBoundedExecution(label, options, operation) {
+	if (options.deadlineAt === void 0) assertNonNegativeFinite(label, "timeoutMs", options.timeoutMs);
+	else assertNonNegativeFinite(label, "deadlineAt", options.deadlineAt);
+	const startedAt = Date.now();
+	const deadlineAt = options.deadlineAt ?? startedAt + options.timeoutMs;
+	const timeoutMs = Math.max(0, deadlineAt - startedAt);
+	const timeoutError = () => new DOMException(`${label} timed out after ${timeoutMs}ms`, "TimeoutError");
+	const controller = new AbortController();
+	const context = Object.freeze({
+		signal: controller.signal,
+		deadlineAt
+	});
+	const ownerSignal = options.signal;
+	if (ownerSignal !== void 0) executionOwners.set(controller.signal, new WeakRef(ownerSignal));
+	const abortFromOwner = () => {
+		controller.abort(ownerSignal === void 0 ? /* @__PURE__ */ new Error(`${label} aborted`) : abortReason(ownerSignal, `${label} aborted`));
+	};
+	if (ownerSignal?.aborted) abortFromOwner();
+	else ownerSignal?.addEventListener("abort", abortFromOwner, { once: true });
+	if (!controller.signal.aborted && options.deadlineAt !== void 0 && deadlineAt <= startedAt) controller.abort(timeoutError());
+	const timer = setTimeout(() => {
+		controller.abort(timeoutError());
+	}, timeoutMs);
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const finish = (complete) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			ownerSignal?.removeEventListener("abort", abortFromOwner);
+			controller.signal.removeEventListener("abort", onAbort);
+			complete();
+		};
+		const onAbort = () => {
+			queueMicrotask(() => finish(() => reject(abortReason(controller.signal, `${label} aborted`))));
+		};
+		if (controller.signal.aborted) {
+			onAbort();
+			return;
+		}
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+		let outcome;
+		try {
+			outcome = Promise.resolve(operation(context));
+		} catch (error) {
+			finish(() => reject(error));
+			return;
+		}
+		outcome.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+	});
+}
+
 //#endregion
 //#region src/messaging/outbox/ports.ts
 /**
@@ -1687,5 +1811,5 @@ function isDispatchTrackingOutbox(outbox) {
 }
 
 //#endregion
-export { isBuiltInObject as A, voWithValidation as C, builtInTagWithoutInvokingAccessors as D, deepEqual as E, isWeakMap as M, findPropertyDescriptor as O, voEqualsExcept as S, deepOmit as T, stampCooperativeBrand as _, createDomainEvent as a, vo as b, createUncommittedDomainEvent as c, isUncommittedDomainEvent as d, mergeMetadata as f, hasCooperativeBrand as g, SnapshotTimeValidationError as h, copyMetadata as i, isIntrinsicConstructorPrototype as j, hasIntrinsicPrototypeChain as k, defaultDomainEventFactory as l, DomainEventValidationError as m, adoptRecordedDomainEvent as n, createDomainEventFactory as o, recordDomainEvent as p, adoptUncommittedDomainEvent as r, createDomainEventFromFacts as s, isDispatchTrackingOutbox as t, isRecordedDomainEvent as u, ValueObject as v, deepEqualExcept as w, voEquals as x, deepFreeze as y };
+export { voWithValidation as A, hasCooperativeBrand as C, vo as D, deepFreeze as E, findPropertyDescriptor as F, hasIntrinsicPrototypeChain as I, isBuiltInObject as L, deepOmit as M, deepEqual as N, voEquals as O, builtInTagWithoutInvokingAccessors as P, isIntrinsicConstructorPrototype as R, SnapshotTimeValidationError as S, ValueObject as T, isRecordedDomainEvent as _, assertNonNegativeFinite as a, recordDomainEvent as b, abortReason as c, copyMetadata as d, createDomainEvent as f, defaultDomainEventFactory as g, createUncommittedDomainEvent as h, runBoundedExecution as i, deepEqualExcept as j, voEqualsExcept as k, adoptRecordedDomainEvent as l, createDomainEventFromFacts as m, DEFAULT_EXECUTION_TIMEOUT_MS as n, assertPositiveInteger as o, createDomainEventFactory as p, ownerSignalOf as r, assertPositiveSafeInteger as s, isDispatchTrackingOutbox as t, adoptUncommittedDomainEvent as u, isUncommittedDomainEvent as v, stampCooperativeBrand as w, DomainEventValidationError as x, mergeMetadata as y, isWeakMap as z };
 //# sourceMappingURL=ports.js.map