@voltro/workflow 0.85.0 → 0.87.0

package/dist/admission.js

@@ -0,0 +1,140 @@
+//#region src/admission.ts
+var e = class extends Error {
+	workflowName;
+	field;
+	constructor(e, t, n) {
+		super(`workflow '${e}': ${t}(payload) threw — a flow-control key function must be total over every payload the workflow accepts, because it runs before the run exists and there is nowhere to report a partial failure to. Cause: ${n instanceof Error ? n.message : String(n)}`), this.name = "FlowControlKeyError", this.workflowName = e, this.field = t, this.cause = n;
+	}
+}, t = (t, n, r, i) => {
+	try {
+		let e = r(i);
+		if (typeof e != "string" || e.length === 0) throw Error(`returned ${e === "" ? "an empty string" : String(e)}; expected a non-empty string`);
+		return e;
+	} catch (r) {
+		throw new e(t, n, r);
+	}
+}, n = (e, t) => JSON.stringify([e ?? null, t]), r = (r, i) => {
+	let a = r.workflowName, o = 0;
+	if (r.priority !== void 0) try {
+		let e = r.priority(i);
+		if (!Number.isFinite(e)) throw Error(`returned ${String(e)}; expected a finite number`);
+		o = Math.trunc(e);
+	} catch (t) {
+		throw new e(a, "priority", t);
+	}
+	return {
+		...r.debounce === void 0 ? {} : { debounceKey: t(a, "debounce.key", r.debounce.key, i) },
+		...r.singleton === void 0 ? {} : { singletonKey: t(a, "singleton.key", r.singleton.key, i) },
+		...r.concurrency === void 0 ? {} : { concurrencyKey: n(r.concurrency.pool, r.concurrency.key === void 0 ? "" : t(a, "concurrency.key", r.concurrency.key, i)) },
+		...r.throttle?.key === void 0 ? r.throttle === void 0 ? {} : { throttleKey: "" } : { throttleKey: t(a, "throttle.key", r.throttle.key, i) },
+		...r.rateLimit?.key === void 0 ? r.rateLimit === void 0 ? {} : { rateLimitKey: "" } : { rateLimitKey: t(a, "rateLimit.key", r.rateLimit.key, i) },
+		...r.batch?.key === void 0 ? r.batch === void 0 ? {} : { batchKey: "" } : { batchKey: t(a, "batch.key", r.batch.key, i) },
+		priority: o
+	};
+}, i = (e, t, n, r) => {
+	let i = e.filter((e) => e > r - n);
+	if (i.length < t) return;
+	let a = [...i].sort((e, t) => t - e)[t - 1];
+	if (a !== void 0) return a + n;
+}, a = (e) => {
+	let { control: t, keys: n, state: r, now: a, reconsidering: c } = e;
+	if (r.paused === !0) return {
+		kind: "defer",
+		mode: "paused",
+		dueAt: a,
+		collapse: c ? "hold" : "append",
+		keys: n
+	};
+	if (t.rateLimit !== void 0) {
+		let e = i(r.recentAdmissions ?? [], t.rateLimit.limit, t.rateLimit.periodMs, a);
+		if (e !== void 0) return {
+			kind: "drop",
+			reason: "rate-limit",
+			retryAfterMs: Math.max(0, e - a),
+			keys: n
+		};
+	}
+	if (t.singleton !== void 0 && r.singletonUnacknowledged === !0) return {
+		kind: "defer",
+		mode: "singleton",
+		dueAt: a,
+		collapse: c ? "hold" : "append",
+		keys: n
+	};
+	if (t.singleton !== void 0 && t.singleton.mode === "skip" && r.singletonHolder !== void 0) return {
+		kind: "skip",
+		incumbent: r.singletonHolder,
+		keys: n
+	};
+	if (t.debounce !== void 0) {
+		let e = r.debouncePending, i = e?.firstSeenAt ?? a, o = e?.deadlineAt ?? (t.debounce.timeoutMs === void 0 ? void 0 : i + t.debounce.timeoutMs);
+		return c ? o !== void 0 && a >= o ? {
+			kind: "admit",
+			reason: "debounce-deadline",
+			keys: n,
+			...s(t, r)
+		} : {
+			kind: "admit",
+			reason: "debounce-elapsed",
+			keys: n,
+			...s(t, r)
+		} : {
+			kind: "defer",
+			mode: "debounce",
+			dueAt: o === void 0 ? a + t.debounce.periodMs : Math.min(a + t.debounce.periodMs, o),
+			...o === void 0 ? {} : { deadlineAt: o },
+			collapse: "replace",
+			keys: n
+		};
+	}
+	if (t.batch !== void 0) {
+		let e = r.batchPending, i = (e?.count ?? 0) + +!c, o = (e?.firstSeenAt ?? a) + t.batch.timeoutMs;
+		return i >= t.batch.maxSize ? {
+			kind: "admit",
+			reason: "batch-full",
+			keys: n,
+			...s(t, r)
+		} : c && a >= o ? {
+			kind: "admit",
+			reason: "batch-timeout",
+			keys: n,
+			...s(t, r)
+		} : {
+			kind: "defer",
+			mode: "batch",
+			dueAt: o,
+			collapse: c ? "hold" : "append",
+			keys: n
+		};
+	}
+	if (t.throttle !== void 0) {
+		let e = i(r.recentAdmissions ?? [], t.throttle.limit, t.throttle.periodMs, a);
+		if (e !== void 0) return {
+			kind: "defer",
+			mode: "throttle",
+			dueAt: e,
+			collapse: c ? "hold" : "append",
+			keys: n
+		};
+	}
+	return t.concurrency !== void 0 && (r.inFlight ?? 0) >= t.concurrency.limit ? {
+		kind: "defer",
+		mode: "concurrency",
+		dueAt: a,
+		collapse: c ? "hold" : "append",
+		keys: n
+	} : {
+		kind: "admit",
+		reason: o(t) ? "under-limits" : "no-controls",
+		keys: n,
+		...s(t, r)
+	};
+}, o = (e) => e.debounce !== void 0 || e.singleton !== void 0 || e.concurrency !== void 0 || e.throttle !== void 0 || e.rateLimit !== void 0 || e.batch !== void 0, s = (e, t) => e.singleton?.mode === "cancel" && t.singletonHolder !== void 0 ? { evict: t.singletonHolder } : {}, c = (e, t, n) => {
+	let r = e.timeouts?.startMs;
+	return r !== void 0 && n - t.firstSeenAt >= r;
+}, l = (e, t, n) => {
+	let r = e.timeouts?.finishMs;
+	return r === void 0 || t.terminal ? !1 : n - t.startedAt >= r;
+}, u = (e, t) => e.priority === t.priority ? e.firstSeenAt === t.firstSeenAt ? e.id < t.id ? -1 : +(e.id > t.id) : e.firstSeenAt - t.firstSeenAt : t.priority - e.priority;
+//#endregion
+export { e as FlowControlKeyError, u as comparePendingOrder, a as decideAdmission, l as isFinishExpired, c as isStartExpired, i as nextSlotAt, n as pooledConcurrencyKey, r as resolveAdmissionKeys };