semola 0.6.0 → 0.6.1

package/dist/lib/workflow/index.mjs

@@ -1,527 +1 @@
-import { mightThrow, mightThrowSync } from "../errors/index.mjs";
-import assert from "node:assert";
-//#region src/lib/workflow/errors.ts
-var WorkflowError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "WorkflowError";
-	}
-};
-var NotFoundError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "NotFoundError";
-	}
-};
-var StateError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "StateError";
-	}
-};
-var SerializationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "SerializationError";
-	}
-};
-var ExecutionError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "ExecutionError";
-	}
-};
-var LockError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "LockError";
-	}
-};
-var CancelledError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "CancelledError";
-	}
-};
-//#endregion
-//#region src/lib/workflow/index.ts
-const DEFAULT_LOCK_TTL = 300 * 1e3;
-const DEFAULT_RETRIES = 3;
-const DEFAULT_RETRY_BASE_DELAY = 1e3;
-const DEFAULT_RETRY_MULTIPLIER = 2;
-const DEFAULT_RETRY_MAX_DELAY = 3e4;
-const now = () => Date.now();
-const delay = async (ms, signal, isCancelled) => {
-	if (signal.aborted) throw new CancelledError("Workflow execution was aborted during retry backoff");
-	const deadline = now() + ms;
-	const pollInterval = 50;
-	while (now() < deadline) {
-		if (signal.aborted) throw new CancelledError("Workflow execution was aborted during retry backoff");
-		if (isCancelled) {
-			if (await isCancelled()) throw new CancelledError("Workflow execution was cancelled during retry backoff");
-		}
-		const remaining = deadline - now();
-		await new Promise((resolve) => {
-			setTimeout(resolve, Math.min(pollInterval, remaining));
-		});
-	}
-};
-const envelopeSerialize = (value) => {
-	return JSON.stringify({ value });
-};
-const envelopeDeserialize = (raw) => {
-	const [parseError, parsed] = mightThrowSync(() => JSON.parse(raw));
-	if (parseError) throw parseError;
-	if (parsed === null) return;
-	if (typeof parsed !== "object") return;
-	if ("value" in parsed) return parsed.value;
-};
-const knownStatuses = [
-	"pending",
-	"running",
-	"completed",
-	"failed",
-	"cancelled"
-];
-var WorkflowDefinition = class {
-	options;
-	lockTTL;
-	retries;
-	retryBaseDelay;
-	retryMultiplier;
-	retryMaxDelay;
-	constructor(options) {
-		this.options = options;
-		this.lockTTL = options.lockTTL ?? DEFAULT_LOCK_TTL;
-		this.retries = options.retries ?? DEFAULT_RETRIES;
-		this.retryBaseDelay = options.retryBackoff?.baseDelay ?? DEFAULT_RETRY_BASE_DELAY;
-		this.retryMultiplier = options.retryBackoff?.multiplier ?? DEFAULT_RETRY_MULTIPLIER;
-		this.retryMaxDelay = options.retryBackoff?.maxDelay ?? DEFAULT_RETRY_MAX_DELAY;
-		assert.ok(Number.isFinite(this.retries) && this.retries >= 0, "Invalid retries: must be a non-negative finite number");
-		assert.ok(Number.isFinite(this.retryBaseDelay) && this.retryBaseDelay > 0, "Invalid retryBackoff.baseDelay: must be a positive finite number");
-		assert.ok(Number.isFinite(this.retryMultiplier) && this.retryMultiplier > 0, "Invalid retryBackoff.multiplier: must be a positive finite number");
-		assert.ok(Number.isFinite(this.retryMaxDelay) && this.retryMaxDelay > 0, "Invalid retryBackoff.maxDelay: must be a positive finite number");
-	}
-	runHook(hook) {
-		return mightThrow(Promise.resolve().then(() => hook()));
-	}
-	computeBackoffDelay(attempt) {
-		return Math.min(this.retryBaseDelay * this.retryMultiplier ** (attempt - 1), this.retryMaxDelay);
-	}
-	async start(input, options) {
-		const executionId = options?.executionId ?? crypto.randomUUID();
-		await this.createExecution(executionId, input);
-		return this.execute(executionId, input);
-	}
-	async run(input, options) {
-		const startData = await this.start(input, options);
-		if (startData.status === "cancelled") throw new CancelledError(`Workflow execution ${startData.executionId} was cancelled`);
-		return (await this.get(startData.executionId)).result;
-	}
-	async resume(executionId) {
-		const execution = await this.get(executionId);
-		if (execution.status === "completed") return {
-			executionId,
-			status: execution.status
-		};
-		if (execution.status === "cancelled") return {
-			executionId,
-			status: execution.status
-		};
-		return this.execute(executionId, execution.input);
-	}
-	async get(executionId) {
-		const status = await this.getMeta(executionId, "status");
-		if (!status) throw new NotFoundError(`Workflow execution ${executionId} not found`);
-		const normalizedStatus = this.normalizeStatus(status);
-		if (!normalizedStatus) throw new StateError(`Workflow execution ${executionId} has invalid status ${status}`);
-		const input = await this.readInput(executionId);
-		const result = await this.readResult(executionId);
-		const steps = await this.readStepSnapshots(executionId);
-		const createdAt = await this.readNumberMeta(executionId, "createdAt");
-		const updatedAt = await this.readNumberMeta(executionId, "updatedAt");
-		const errorMessage = await this.getMeta(executionId, "error");
-		const completedAt = await this.readNumberMeta(executionId, "completedAt");
-		const failedAt = await this.readNumberMeta(executionId, "failedAt");
-		const cancelledAt = await this.readNumberMeta(executionId, "cancelledAt");
-		if (createdAt === null) throw new StateError(`Workflow execution ${executionId} is missing createdAt`);
-		if (updatedAt === null) throw new StateError(`Workflow execution ${executionId} is missing updatedAt`);
-		return {
-			id: executionId,
-			name: this.options.name,
-			status: normalizedStatus,
-			input,
-			result,
-			error: errorMessage,
-			createdAt,
-			updatedAt,
-			completedAt,
-			failedAt,
-			cancelledAt,
-			steps
-		};
-	}
-	async cancel(executionId) {
-		const execution = await this.get(executionId);
-		if (execution.status === "completed") throw new StateError(`Workflow execution ${executionId} is already completed`);
-		const timestamp = now();
-		await this.setMeta(executionId, "status", "cancelled");
-		await this.setMeta(executionId, "updatedAt", String(timestamp));
-		await this.setMeta(executionId, "cancelledAt", String(timestamp));
-		await this.setMeta(executionId, "error", "");
-		await this.setMeta(executionId, "failedAt", "");
-		return {
-			executionId,
-			createdAt: execution.createdAt,
-			cancelledAt: timestamp,
-			updatedAt: timestamp,
-			status: "cancelled"
-		};
-	}
-	executionKey(executionId) {
-		return `workflow:${this.options.name}:execution:${executionId}`;
-	}
-	metaKey(executionId) {
-		return `${this.executionKey(executionId)}:meta`;
-	}
-	stepsKey(executionId) {
-		return `${this.executionKey(executionId)}:steps`;
-	}
-	lockKey(executionId) {
-		return `${this.executionKey(executionId)}:lock`;
-	}
-	async createExecution(executionId, input) {
-		const serializedInput = this.serializeInput(input);
-		const timestamp = now();
-		if (await this.getMeta(executionId, "status")) throw new StateError(`Workflow execution ${executionId} already exists`);
-		const metadata = {
-			status: "pending",
-			input: serializedInput,
-			result: "",
-			error: "",
-			createdAt: String(timestamp),
-			updatedAt: String(timestamp),
-			completedAt: "",
-			failedAt: "",
-			cancelledAt: "",
-			steps: "[]"
-		};
-		const [writeError] = await mightThrow(this.options.redis.hset(this.metaKey(executionId), metadata));
-		if (writeError) throw new WorkflowError(`Unable to persist metadata for execution ${executionId}`);
-	}
-	async execute(executionId, input) {
-		const token = crypto.randomUUID();
-		await this.acquireLock(executionId, token);
-		if (await this.getMeta(executionId, "status") === "cancelled") {
-			await this.releaseLock(executionId, token);
-			throw new StateError(`Workflow execution ${executionId} was cancelled`);
-		}
-		const timestamp = now();
-		await this.setMeta(executionId, "status", "running");
-		await this.setMeta(executionId, "updatedAt", String(timestamp));
-		const controller = new AbortController();
-		const renewInterval = Math.floor(this.lockTTL / 3);
-		let lockLost = false;
-		const renewTimer = setInterval(async () => {
-			const [renewError] = await mightThrow(this.extendLock(executionId, token));
-			if (renewError) {
-				lockLost = true;
-				controller.abort();
-				clearInterval(renewTimer);
-			}
-		}, renewInterval);
-		if (this.options.hooks?.onStart) await this.runHook(() => this.options.hooks?.onStart?.({
-			executionId,
-			input
-		}));
-		const step = async (name, handler) => {
-			await this.throwIfCancelled(executionId, () => {
-				controller.abort();
-			});
-			const cachedStep = await this.readStepOutput(executionId, name);
-			if (cachedStep.found) return cachedStep.value;
-			return this.runStepWithRetries(executionId, input, name, handler, controller.signal, () => {
-				controller.abort();
-			});
-		};
-		const handlerOutcome = await mightThrow(Promise.resolve(this.options.handler({
-			input,
-			executionId,
-			signal: controller.signal,
-			step
-		})));
-		clearInterval(renewTimer);
-		if (lockLost) {
-			await this.releaseLock(executionId, token);
-			throw new LockError(`Lock expired during execution ${executionId}`);
-		}
-		if (await this.isCancelled(executionId)) {
-			const cancelledAt = now();
-			await this.setMeta(executionId, "status", "cancelled");
-			await this.setMeta(executionId, "updatedAt", String(cancelledAt));
-			await this.setMeta(executionId, "cancelledAt", String(cancelledAt));
-			if (this.options.hooks?.onCancel) await this.runHook(() => this.options.hooks?.onCancel?.({
-				executionId,
-				input
-			}));
-			await this.releaseLock(executionId, token);
-			return {
-				executionId,
-				status: "cancelled"
-			};
-		}
-		const [handlerError, result] = handlerOutcome;
-		if (handlerError) {
-			const failedAt = now();
-			await this.setMeta(executionId, "status", "failed");
-			await this.setMeta(executionId, "error", handlerError.message);
-			await this.setMeta(executionId, "updatedAt", String(failedAt));
-			await this.setMeta(executionId, "failedAt", String(failedAt));
-			await this.releaseLock(executionId, token);
-			throw new ExecutionError(`Workflow execution ${executionId} failed: ${handlerError.message}`);
-		}
-		const [serializeResultError, serializedResult] = mightThrowSync(() => this.serializeResult(result));
-		if (serializeResultError) {
-			const failedAt = now();
-			await this.setMeta(executionId, "status", "failed");
-			await this.setMeta(executionId, "error", serializeResultError.message);
-			await this.setMeta(executionId, "updatedAt", String(failedAt));
-			await this.setMeta(executionId, "failedAt", String(failedAt));
-			await this.releaseLock(executionId, token);
-			throw new SerializationError(`Unable to serialize workflow result for ${executionId}`);
-		}
-		const completedAt = now();
-		await this.setMeta(executionId, "result", serializedResult);
-		await this.setMeta(executionId, "status", "completed");
-		await this.setMeta(executionId, "error", "");
-		await this.setMeta(executionId, "failedAt", "");
-		await this.setMeta(executionId, "updatedAt", String(completedAt));
-		await this.setMeta(executionId, "completedAt", String(completedAt));
-		if (this.options.hooks?.onComplete) await this.runHook(() => this.options.hooks?.onComplete?.({
-			executionId,
-			input,
-			result
-		}));
-		await this.releaseLock(executionId, token);
-		return {
-			executionId,
-			status: "completed"
-		};
-	}
-	async throwIfCancelled(executionId, abort) {
-		if (await this.isCancelled(executionId)) {
-			abort();
-			throw new CancelledError(`Workflow execution ${executionId} was cancelled`);
-		}
-	}
-	async runStepWithRetries(executionId, input, stepName, handler, signal, abort) {
-		let attempt = 1;
-		const errorHistory = [];
-		while (true) {
-			await this.throwIfCancelled(executionId, abort);
-			const [stepError, output] = await mightThrow(Promise.resolve(handler(input, signal)));
-			if (!stepError) {
-				await this.writeStepOutput(executionId, stepName, output);
-				return output;
-			}
-			const errorMsg = stepError.message;
-			errorHistory.push({
-				attempt,
-				error: errorMsg,
-				timestamp: now()
-			});
-			if (attempt <= this.retries) {
-				const nextRetryDelayMs = this.computeBackoffDelay(attempt);
-				if (this.options.hooks?.onRetry) await this.runHook(() => this.options.hooks?.onRetry?.({
-					executionId,
-					input,
-					stepName,
-					error: errorMsg,
-					attempt,
-					nextRetryDelayMs,
-					retriesRemaining: this.retries - attempt
-				}));
-				const [delayError] = await mightThrow(delay(nextRetryDelayMs, signal, () => this.isCancelled(executionId)));
-				if (delayError) throw delayError;
-				attempt++;
-				continue;
-			}
-			if (this.options.hooks?.onError) await this.runHook(() => this.options.hooks?.onError?.({
-				executionId,
-				input,
-				stepName,
-				error: errorMsg,
-				totalAttempts: attempt,
-				errorHistory
-			}));
-			throw stepError;
-		}
-	}
-	async acquireLock(executionId, token) {
-		const [lockError, lockResult] = await mightThrow(this.options.redis.set(this.lockKey(executionId), token, "PX", String(this.lockTTL), "NX"));
-		if (lockError) throw new LockError(`Unable to acquire lock for execution ${executionId}`);
-		if (lockResult !== "OK") throw new LockError(`Workflow execution ${executionId} is already running`);
-	}
-	async releaseLock(executionId, token) {
-		await mightThrow(this.options.redis.send("EVAL", [
-			"if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end",
-			"1",
-			this.lockKey(executionId),
-			token
-		]));
-	}
-	async extendLock(executionId, token) {
-		const [evalError, extendResult] = await mightThrow(this.options.redis.send("EVAL", [
-			"if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('PEXPIRE', KEYS[1], ARGV[2]) else return 0 end",
-			"1",
-			this.lockKey(executionId),
-			token,
-			String(this.lockTTL)
-		]));
-		if (evalError) throw new LockError(`Unable to extend lock for execution ${executionId}`);
-		if (extendResult === 0) throw new LockError(`Lock ownership lost for execution ${executionId}`);
-	}
-	async isCancelled(executionId) {
-		return await this.getMeta(executionId, "status") === "cancelled";
-	}
-	async setMeta(executionId, field, value) {
-		const [writeError] = await mightThrow(this.options.redis.hset(this.metaKey(executionId), field, value));
-		if (writeError) throw new WorkflowError(`Unable to persist ${field} for execution ${executionId}`);
-	}
-	async getMeta(executionId, field) {
-		const [readError, value] = await mightThrow(this.options.redis.hget(this.metaKey(executionId), field));
-		if (readError) throw new WorkflowError(`Unable to read ${field} for execution ${executionId}`);
-		if (value === null || value === void 0) return null;
-		if (typeof value !== "string") throw new StateError(`Invalid ${field} value for execution ${executionId}`);
-		if (value.length === 0) return null;
-		return value;
-	}
-	async readNumberMeta(executionId, field) {
-		const value = await this.getMeta(executionId, field);
-		if (!value) return null;
-		const parsed = Number(value);
-		if (!Number.isFinite(parsed)) throw new StateError(`Invalid ${field} value for execution ${executionId}`);
-		return parsed;
-	}
-	runSerializer(value, serializer, label) {
-		const [serializeError, serialized] = mightThrowSync(() => serializer(value));
-		if (serializeError) throw new SerializationError(`Unable to serialize ${label}: ${serializeError.message}`);
-		if (typeof serialized !== "string") throw new SerializationError(`${label} serializer must return a string`);
-		return serialized;
-	}
-	runDeserializer(raw, deserializer, label) {
-		const result = mightThrowSync(() => deserializer(raw));
-		if (result[0]) throw new SerializationError(`Unable to deserialize ${label}: ${result[0].message}`);
-		return result[1];
-	}
-	serializeInput(input) {
-		return this.runSerializer(input, this.options.serializeInput ?? envelopeSerialize, "workflow input");
-	}
-	deserializeInput(raw) {
-		const deserializer = this.options.deserializeInput ?? ((value) => envelopeDeserialize(value));
-		return this.runDeserializer(raw, deserializer, "workflow input");
-	}
-	serializeResult(result) {
-		if (result === null) return envelopeSerialize(null);
-		return this.runSerializer(result, this.options.serializeResult ?? envelopeSerialize, "workflow result");
-	}
-	deserializeResult(raw) {
-		const deserializer = this.options.deserializeResult ?? ((value) => envelopeDeserialize(value));
-		return this.runDeserializer(raw, deserializer, "workflow result");
-	}
-	serializeStepOutput(output) {
-		return this.runSerializer(output, this.options.serializeStepOutput ?? envelopeSerialize, "step output");
-	}
-	deserializeStepOutput(raw) {
-		const deserializer = this.options.deserializeStepOutput ?? ((value) => envelopeDeserialize(value));
-		return this.runDeserializer(raw, deserializer, "step output");
-	}
-	async readInput(executionId) {
-		const raw = await this.getMeta(executionId, "input");
-		if (!raw) throw new StateError(`Workflow execution ${executionId} input not found`);
-		return this.deserializeInput(raw);
-	}
-	async readResult(executionId) {
-		const raw = await this.getMeta(executionId, "result");
-		if (!raw) return null;
-		return this.deserializeResult(raw);
-	}
-	async writeStepOutput(executionId, stepName, output) {
-		const payload = {
-			output: this.serializeStepOutput(output),
-			completedAt: now()
-		};
-		const [payloadError, payloadRaw] = mightThrowSync(() => JSON.stringify(payload));
-		if (payloadError || typeof payloadRaw !== "string") throw new SerializationError(`Unable to persist step ${stepName} output`);
-		const [writeError] = await mightThrow(this.options.redis.hset(this.stepsKey(executionId), stepName, payloadRaw));
-		if (writeError) throw new WorkflowError(`Unable to persist step ${stepName} for execution ${executionId}`);
-		const stepNames = await this.readStepNames(executionId);
-		if (!stepNames.includes(stepName)) {
-			const nextStepNames = [...stepNames, stepName];
-			const [serializeStepsError, serializedSteps] = mightThrowSync(() => JSON.stringify(nextStepNames));
-			if (serializeStepsError || typeof serializedSteps !== "string") throw new SerializationError(`Unable to persist step history for execution ${executionId}`);
-			await this.setMeta(executionId, "steps", serializedSteps);
-		}
-		await this.setMeta(executionId, "updatedAt", String(now()));
-	}
-	async readStepOutput(executionId, stepName) {
-		const [readError, payloadRaw] = await mightThrow(this.options.redis.hget(this.stepsKey(executionId), stepName));
-		if (readError) throw new WorkflowError(`Unable to read step ${stepName} for execution ${executionId}`);
-		if (!payloadRaw) return {
-			found: false,
-			value: null
-		};
-		if (typeof payloadRaw !== "string") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
-		const [parseError, parsed] = mightThrowSync(() => JSON.parse(payloadRaw));
-		if (parseError || parsed === null || typeof parsed !== "object") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
-		if (typeof parsed.output !== "string") throw new StateError(`Invalid step output for ${stepName} in execution ${executionId}`);
-		const outputRaw = parsed.output;
-		return {
-			found: true,
-			value: this.deserializeStepOutput(outputRaw)
-		};
-	}
-	async readStepNames(executionId) {
-		const stepsRaw = await this.getMeta(executionId, "steps");
-		if (!stepsRaw) return [];
-		const [parseError, values] = mightThrowSync(() => JSON.parse(stepsRaw));
-		if (parseError || !Array.isArray(values)) throw new StateError(`Invalid step index for execution ${executionId}`);
-		const stepNames = [];
-		for (const value of values) if (typeof value === "string") stepNames.push(value);
-		return stepNames;
-	}
-	async readStepSnapshots(executionId) {
-		const stepNames = await this.readStepNames(executionId);
-		const steps = [];
-		for (const stepName of stepNames) {
-			const [readError, payloadRaw] = await mightThrow(this.options.redis.hget(this.stepsKey(executionId), stepName));
-			if (readError) throw new WorkflowError(`Unable to read step ${stepName} for execution ${executionId}`);
-			if (!payloadRaw) continue;
-			if (typeof payloadRaw !== "string") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
-			const [parseError, parsed] = mightThrowSync(() => JSON.parse(payloadRaw));
-			if (parseError || parsed === null || typeof parsed !== "object") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
-			if (typeof parsed.completedAt !== "number") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
-			steps.push({
-				name: stepName,
-				completedAt: parsed.completedAt
-			});
-		}
-		return steps;
-	}
-	normalizeStatus(value) {
-		for (const status of knownStatuses) if (status === value) return status;
-		return null;
-	}
-};
-const defineWorkflow = (options) => {
-	const workflow = new WorkflowDefinition(options);
-	return {
-		start: (input, startOptions) => workflow.start(input, startOptions),
-		run: (input, startOptions) => workflow.run(input, startOptions),
-		resume: (executionId) => workflow.resume(executionId),
-		get: (executionId) => workflow.get(executionId),
-		cancel: (executionId) => workflow.cancel(executionId)
-	};
-};
-//#endregion
-export { CancelledError, ExecutionError, LockError, NotFoundError, SerializationError, StateError, WorkflowError, defineWorkflow };
+import{mightThrow as e,mightThrowSync as t}from"../errors/index.mjs";import n from"node:assert";var r=class extends Error{constructor(e){super(e),this.name=`WorkflowError`}},i=class extends Error{constructor(e){super(e),this.name=`NotFoundError`}},a=class extends Error{constructor(e){super(e),this.name=`StateError`}},o=class extends Error{constructor(e){super(e),this.name=`SerializationError`}},s=class extends Error{constructor(e){super(e),this.name=`ExecutionError`}},c=class extends Error{constructor(e){super(e),this.name=`LockError`}},l=class extends Error{constructor(e){super(e),this.name=`CancelledError`}};const u=()=>Date.now(),d=async(e,t,n)=>{if(t.aborted)throw new l(`Workflow execution was aborted during retry backoff`);let r=u()+e;for(;u()<r;){if(t.aborted)throw new l(`Workflow execution was aborted during retry backoff`);if(n&&await n())throw new l(`Workflow execution was cancelled during retry backoff`);let e=r-u();await new Promise(t=>{setTimeout(t,Math.min(50,e))})}},f=e=>JSON.stringify({value:e}),p=e=>{let[n,r]=t(()=>JSON.parse(e));if(n)throw n;if(typeof r==`object`&&r&&`value`in r)return r.value},m=[`pending`,`running`,`completed`,`failed`,`cancelled`];var h=class{options;lockTTL;retries;retryBaseDelay;retryMultiplier;retryMaxDelay;constructor(e){this.options=e,this.lockTTL=e.lockTTL??3e5,this.retries=e.retries??3,this.retryBaseDelay=e.retryBackoff?.baseDelay??1e3,this.retryMultiplier=e.retryBackoff?.multiplier??2,this.retryMaxDelay=e.retryBackoff?.maxDelay??3e4,n.ok(Number.isFinite(this.retries)&&this.retries>=0,`Invalid retries: must be a non-negative finite number`),n.ok(Number.isFinite(this.retryBaseDelay)&&this.retryBaseDelay>0,`Invalid retryBackoff.baseDelay: must be a positive finite number`),n.ok(Number.isFinite(this.retryMultiplier)&&this.retryMultiplier>0,`Invalid retryBackoff.multiplier: must be a positive finite number`),n.ok(Number.isFinite(this.retryMaxDelay)&&this.retryMaxDelay>0,`Invalid retryBackoff.maxDelay: must be a positive finite number`)}runHook(t){return e(Promise.resolve().then(()=>t()))}computeBackoffDelay(e){return Math.min(this.retryBaseDelay*this.retryMultiplier**(e-1),this.retryMaxDelay)}async start(e,t){let n=t?.executionId??crypto.randomUUID();return await this.createExecution(n,e),this.execute(n,e)}async run(e,t){let n=await this.start(e,t);if(n.status===`cancelled`)throw new l(`Workflow execution ${n.executionId} was cancelled`);return(await this.get(n.executionId)).result}async resume(e){let t=await this.get(e);return t.status===`completed`||t.status===`cancelled`?{executionId:e,status:t.status}:this.execute(e,t.input)}async get(e){let t=await this.getMeta(e,`status`);if(!t)throw new i(`Workflow execution ${e} not found`);let n=this.normalizeStatus(t);if(!n)throw new a(`Workflow execution ${e} has invalid status ${t}`);let r=await this.readInput(e),o=await this.readResult(e),s=await this.readStepSnapshots(e),c=await this.readNumberMeta(e,`createdAt`),l=await this.readNumberMeta(e,`updatedAt`),u=await this.getMeta(e,`error`),d=await this.readNumberMeta(e,`completedAt`),f=await this.readNumberMeta(e,`failedAt`),p=await this.readNumberMeta(e,`cancelledAt`);if(c===null)throw new a(`Workflow execution ${e} is missing createdAt`);if(l===null)throw new a(`Workflow execution ${e} is missing updatedAt`);return{id:e,name:this.options.name,status:n,input:r,result:o,error:u,createdAt:c,updatedAt:l,completedAt:d,failedAt:f,cancelledAt:p,steps:s}}async cancel(e){let t=await this.get(e);if(t.status===`completed`)throw new a(`Workflow execution ${e} is already completed`);let n=u();return await this.setMeta(e,`status`,`cancelled`),await this.setMeta(e,`updatedAt`,String(n)),await this.setMeta(e,`cancelledAt`,String(n)),await this.setMeta(e,`error`,``),await this.setMeta(e,`failedAt`,``),{executionId:e,createdAt:t.createdAt,cancelledAt:n,updatedAt:n,status:`cancelled`}}executionKey(e){return`workflow:${this.options.name}:execution:${e}`}metaKey(e){return`${this.executionKey(e)}:meta`}stepsKey(e){return`${this.executionKey(e)}:steps`}lockKey(e){return`${this.executionKey(e)}:lock`}async createExecution(t,n){let i=this.serializeInput(n),o=u();if(await this.getMeta(t,`status`))throw new a(`Workflow execution ${t} already exists`);let s={status:`pending`,input:i,result:``,error:``,createdAt:String(o),updatedAt:String(o),completedAt:``,failedAt:``,cancelledAt:``,steps:`[]`},[c]=await e(this.options.redis.hset(this.metaKey(t),s));if(c)throw new r(`Unable to persist metadata for execution ${t}`)}async execute(n,r){let i=crypto.randomUUID();if(await this.acquireLock(n,i),await this.getMeta(n,`status`)===`cancelled`)throw await this.releaseLock(n,i),new a(`Workflow execution ${n} was cancelled`);let l=u();await this.setMeta(n,`status`,`running`),await this.setMeta(n,`updatedAt`,String(l));let d=new AbortController,f=Math.floor(this.lockTTL/3),p=!1,m=setInterval(async()=>{let[t]=await e(this.extendLock(n,i));t&&(p=!0,d.abort(),clearInterval(m))},f);this.options.hooks?.onStart&&await this.runHook(()=>this.options.hooks?.onStart?.({executionId:n,input:r}));let h=await e(Promise.resolve(this.options.handler({input:r,executionId:n,signal:d.signal,step:async(e,t)=>{await this.throwIfCancelled(n,()=>{d.abort()});let i=await this.readStepOutput(n,e);return i.found?i.value:this.runStepWithRetries(n,r,e,t,d.signal,()=>{d.abort()})}})));if(clearInterval(m),p)throw await this.releaseLock(n,i),new c(`Lock expired during execution ${n}`);if(await this.isCancelled(n)){let e=u();return await this.setMeta(n,`status`,`cancelled`),await this.setMeta(n,`updatedAt`,String(e)),await this.setMeta(n,`cancelledAt`,String(e)),this.options.hooks?.onCancel&&await this.runHook(()=>this.options.hooks?.onCancel?.({executionId:n,input:r})),await this.releaseLock(n,i),{executionId:n,status:`cancelled`}}let[g,_]=h;if(g){let e=u();throw await this.setMeta(n,`status`,`failed`),await this.setMeta(n,`error`,g.message),await this.setMeta(n,`updatedAt`,String(e)),await this.setMeta(n,`failedAt`,String(e)),await this.releaseLock(n,i),new s(`Workflow execution ${n} failed: ${g.message}`)}let[v,y]=t(()=>this.serializeResult(_));if(v){let e=u();throw await this.setMeta(n,`status`,`failed`),await this.setMeta(n,`error`,v.message),await this.setMeta(n,`updatedAt`,String(e)),await this.setMeta(n,`failedAt`,String(e)),await this.releaseLock(n,i),new o(`Unable to serialize workflow result for ${n}`)}let b=u();return await this.setMeta(n,`result`,y),await this.setMeta(n,`status`,`completed`),await this.setMeta(n,`error`,``),await this.setMeta(n,`failedAt`,``),await this.setMeta(n,`updatedAt`,String(b)),await this.setMeta(n,`completedAt`,String(b)),this.options.hooks?.onComplete&&await this.runHook(()=>this.options.hooks?.onComplete?.({executionId:n,input:r,result:_})),await this.releaseLock(n,i),{executionId:n,status:`completed`}}async throwIfCancelled(e,t){if(await this.isCancelled(e))throw t(),new l(`Workflow execution ${e} was cancelled`)}async runStepWithRetries(t,n,r,i,a,o){let s=1,c=[];for(;;){await this.throwIfCancelled(t,o);let[l,f]=await e(Promise.resolve(i(n,a)));if(!l)return await this.writeStepOutput(t,r,f),f;let p=l.message;if(c.push({attempt:s,error:p,timestamp:u()}),s<=this.retries){let i=this.computeBackoffDelay(s);this.options.hooks?.onRetry&&await this.runHook(()=>this.options.hooks?.onRetry?.({executionId:t,input:n,stepName:r,error:p,attempt:s,nextRetryDelayMs:i,retriesRemaining:this.retries-s}));let[o]=await e(d(i,a,()=>this.isCancelled(t)));if(o)throw o;s++;continue}throw this.options.hooks?.onError&&await this.runHook(()=>this.options.hooks?.onError?.({executionId:t,input:n,stepName:r,error:p,totalAttempts:s,errorHistory:c})),l}}async acquireLock(t,n){let[r,i]=await e(this.options.redis.set(this.lockKey(t),n,`PX`,String(this.lockTTL),`NX`));if(r)throw new c(`Unable to acquire lock for execution ${t}`);if(i!==`OK`)throw new c(`Workflow execution ${t} is already running`)}async releaseLock(t,n){await e(this.options.redis.send(`EVAL`,[`if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end`,`1`,this.lockKey(t),n]))}async extendLock(t,n){let[r,i]=await e(this.options.redis.send(`EVAL`,[`if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('PEXPIRE', KEYS[1], ARGV[2]) else return 0 end`,`1`,this.lockKey(t),n,String(this.lockTTL)]));if(r)throw new c(`Unable to extend lock for execution ${t}`);if(i===0)throw new c(`Lock ownership lost for execution ${t}`)}async isCancelled(e){return await this.getMeta(e,`status`)===`cancelled`}async setMeta(t,n,i){let[a]=await e(this.options.redis.hset(this.metaKey(t),n,i));if(a)throw new r(`Unable to persist ${n} for execution ${t}`)}async getMeta(t,n){let[i,o]=await e(this.options.redis.hget(this.metaKey(t),n));if(i)throw new r(`Unable to read ${n} for execution ${t}`);if(o==null)return null;if(typeof o!=`string`)throw new a(`Invalid ${n} value for execution ${t}`);return o.length===0?null:o}async readNumberMeta(e,t){let n=await this.getMeta(e,t);if(!n)return null;let r=Number(n);if(!Number.isFinite(r))throw new a(`Invalid ${t} value for execution ${e}`);return r}runSerializer(e,n,r){let[i,a]=t(()=>n(e));if(i)throw new o(`Unable to serialize ${r}: ${i.message}`);if(typeof a!=`string`)throw new o(`${r} serializer must return a string`);return a}runDeserializer(e,n,r){let i=t(()=>n(e));if(i[0])throw new o(`Unable to deserialize ${r}: ${i[0].message}`);return i[1]}serializeInput(e){return this.runSerializer(e,this.options.serializeInput??f,`workflow input`)}deserializeInput(e){let t=this.options.deserializeInput??(e=>p(e));return this.runDeserializer(e,t,`workflow input`)}serializeResult(e){return e===null?f(null):this.runSerializer(e,this.options.serializeResult??f,`workflow result`)}deserializeResult(e){let t=this.options.deserializeResult??(e=>p(e));return this.runDeserializer(e,t,`workflow result`)}serializeStepOutput(e){return this.runSerializer(e,this.options.serializeStepOutput??f,`step output`)}deserializeStepOutput(e){let t=this.options.deserializeStepOutput??(e=>p(e));return this.runDeserializer(e,t,`step output`)}async readInput(e){let t=await this.getMeta(e,`input`);if(!t)throw new a(`Workflow execution ${e} input not found`);return this.deserializeInput(t)}async readResult(e){let t=await this.getMeta(e,`result`);return t?this.deserializeResult(t):null}async writeStepOutput(n,i,a){let s={output:this.serializeStepOutput(a),completedAt:u()},[c,l]=t(()=>JSON.stringify(s));if(c||typeof l!=`string`)throw new o(`Unable to persist step ${i} output`);let[d]=await e(this.options.redis.hset(this.stepsKey(n),i,l));if(d)throw new r(`Unable to persist step ${i} for execution ${n}`);let f=await this.readStepNames(n);if(!f.includes(i)){let e=[...f,i],[r,a]=t(()=>JSON.stringify(e));if(r||typeof a!=`string`)throw new o(`Unable to persist step history for execution ${n}`);await this.setMeta(n,`steps`,a)}await this.setMeta(n,`updatedAt`,String(u()))}async readStepOutput(n,i){let[o,s]=await e(this.options.redis.hget(this.stepsKey(n),i));if(o)throw new r(`Unable to read step ${i} for execution ${n}`);if(!s)return{found:!1,value:null};if(typeof s!=`string`)throw new a(`Invalid step payload for ${i} in execution ${n}`);let[c,l]=t(()=>JSON.parse(s));if(c||typeof l!=`object`||!l)throw new a(`Invalid step payload for ${i} in execution ${n}`);if(typeof l.output!=`string`)throw new a(`Invalid step output for ${i} in execution ${n}`);let u=l.output;return{found:!0,value:this.deserializeStepOutput(u)}}async readStepNames(e){let n=await this.getMeta(e,`steps`);if(!n)return[];let[r,i]=t(()=>JSON.parse(n));if(r||!Array.isArray(i))throw new a(`Invalid step index for execution ${e}`);let o=[];for(let e of i)typeof e==`string`&&o.push(e);return o}async readStepSnapshots(n){let i=await this.readStepNames(n),o=[];for(let s of i){let[i,c]=await e(this.options.redis.hget(this.stepsKey(n),s));if(i)throw new r(`Unable to read step ${s} for execution ${n}`);if(!c)continue;if(typeof c!=`string`)throw new a(`Invalid step payload for ${s} in execution ${n}`);let[l,u]=t(()=>JSON.parse(c));if(l||typeof u!=`object`||!u||typeof u.completedAt!=`number`)throw new a(`Invalid step payload for ${s} in execution ${n}`);o.push({name:s,completedAt:u.completedAt})}return o}normalizeStatus(e){for(let t of m)if(t===e)return t;return null}};const g=e=>{let t=new h(e);return{start:(e,n)=>t.start(e,n),run:(e,n)=>t.run(e,n),resume:e=>t.resume(e),get:e=>t.get(e),cancel:e=>t.cancel(e)}};export{l as CancelledError,s as ExecutionError,c as LockError,i as NotFoundError,o as SerializationError,a as StateError,r as WorkflowError,g as defineWorkflow};

package/dist/rolldown-runtime-CMqjfN_6.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return s}});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semola",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Zero-dependency TypeScript utilities for Bun. Type-safe APIs, Redis queues, pub/sub, i18n, caching & auth with tree-shakeable imports.",
   "type": "module",
   "bin": {
@@ -179,12 +179,14 @@
   "devDependencies": {
     "@biomejs/biome": "2.3.10",
     "@standard-schema/spec": "^1.1.0",
+    "@standard-schema/utils": "^0.3.0",
     "@types/bun": "latest",
+    "@typescript/native-preview": "^7.0.0-dev.20260624.1",
+    "@valibot/to-json-schema": "^1.7.1",
+    "arktype": "^2.2.1",
     "openapi-types": "^12.1.3",
-    "tsdown": "^0.21.7",
+    "tsdown": "^0.22.3",
+    "valibot": "^1.4.1",
     "zod": "^4.3.6"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
   }
 }

package/dist/chunk-CKQMccvm.cjs

@@ -1,28 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});