semola 0.5.4 → 0.6.1

package/dist/lib/workflow/index.cjs

@@ -1,534 +1 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_lib_errors_index = require("../errors/index.cjs");
-//#region src/lib/workflow/index.ts
-const DEFAULT_LOCK_TTL = 300 * 1e3;
-const now = () => Date.now();
-const toErrorMessage = (error) => {
-	if (error instanceof Error) return error.message;
-	return String(error);
-};
-const envelopeSerialize = (value) => {
-	return JSON.stringify({ value });
-};
-const envelopeDeserialize = (raw) => {
-	const [parseError, parsed] = require_lib_errors_index.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;
-	constructor(options) {
-		this.options = options;
-		this.lockTTL = options.lockTTL ?? DEFAULT_LOCK_TTL;
-	}
-	async start(input, options) {
-		const executionId = options?.executionId ?? crypto.randomUUID();
-		const [createError] = await this.createExecution(executionId, input);
-		if (createError) return require_lib_errors_index.err(createError.type, createError.message);
-		return this.execute(executionId, input);
-	}
-	async run(input, options) {
-		const [startError, startData] = await this.start(input, options);
-		if (startError) return require_lib_errors_index.err(startError.type, startError.message);
-		if (!startData) return require_lib_errors_index.err("WorkflowError", "Unexpected empty start result");
-		if (startData.status === "cancelled") return require_lib_errors_index.err("WorkflowCancelledError", `Workflow execution ${startData.executionId} was cancelled`);
-		if (startData.status !== "completed") return require_lib_errors_index.err("WorkflowExecutionError", `Workflow execution ${startData.executionId} did not complete`);
-		const [getError, execution] = await this.get(startData.executionId);
-		if (getError) return require_lib_errors_index.err(getError.type, getError.message);
-		if (!execution) return require_lib_errors_index.err("WorkflowError", "Unexpected empty execution");
-		return require_lib_errors_index.ok(execution.result);
-	}
-	async resume(executionId) {
-		const [getError, execution] = await this.get(executionId);
-		if (getError) return require_lib_errors_index.err(getError.type, getError.message);
-		if (!execution) return require_lib_errors_index.err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
-		if (execution.status === "completed") return require_lib_errors_index.ok({
-			executionId,
-			status: execution.status
-		});
-		if (execution.status === "cancelled") return require_lib_errors_index.ok({
-			executionId,
-			status: execution.status
-		});
-		return this.execute(executionId, execution.input);
-	}
-	async get(executionId) {
-		const [statusError, status] = await this.getMeta(executionId, "status");
-		if (statusError) return require_lib_errors_index.err(statusError.type, statusError.message);
-		if (!status) return require_lib_errors_index.err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
-		const normalizedStatus = this.normalizeStatus(status);
-		if (!normalizedStatus) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} has invalid status ${status}`);
-		const [inputError, input] = await this.readInput(executionId);
-		if (inputError) return require_lib_errors_index.err(inputError.type, inputError.message);
-		if (input === null) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} has invalid input`);
-		const [resultError, result] = await this.readResult(executionId);
-		if (resultError) return require_lib_errors_index.err(resultError.type, resultError.message);
-		const [stepsError, steps] = await this.readStepSnapshots(executionId);
-		if (stepsError) return require_lib_errors_index.err(stepsError.type, stepsError.message);
-		const [createdAtError, createdAt] = await this.readNumberMeta(executionId, "createdAt");
-		if (createdAtError) return require_lib_errors_index.err(createdAtError.type, createdAtError.message);
-		if (createdAt === null) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} is missing createdAt`);
-		const [updatedAtError, updatedAt] = await this.readNumberMeta(executionId, "updatedAt");
-		if (updatedAtError) return require_lib_errors_index.err(updatedAtError.type, updatedAtError.message);
-		if (updatedAt === null) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} is missing updatedAt`);
-		const [metaError, errorMessage] = await this.getMeta(executionId, "error");
-		if (metaError) return require_lib_errors_index.err(metaError.type, metaError.message);
-		const [completedAtError, completedAt] = await this.readNumberMeta(executionId, "completedAt");
-		if (completedAtError) return require_lib_errors_index.err(completedAtError.type, completedAtError.message);
-		const [failedAtError, failedAt] = await this.readNumberMeta(executionId, "failedAt");
-		if (failedAtError) return require_lib_errors_index.err(failedAtError.type, failedAtError.message);
-		const [cancelledAtError, cancelledAt] = await this.readNumberMeta(executionId, "cancelledAt");
-		if (cancelledAtError) return require_lib_errors_index.err(cancelledAtError.type, cancelledAtError.message);
-		return require_lib_errors_index.ok({
-			id: executionId,
-			name: this.options.name,
-			status: normalizedStatus,
-			input,
-			result,
-			error: errorMessage,
-			createdAt,
-			updatedAt,
-			completedAt,
-			failedAt,
-			cancelledAt,
-			steps
-		});
-	}
-	async cancel(executionId) {
-		const [getError, execution] = await this.get(executionId);
-		if (getError) return require_lib_errors_index.err(getError.type, getError.message);
-		if (!execution) return require_lib_errors_index.err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
-		if (execution.status === "completed") return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} is already completed`);
-		const timestamp = now();
-		const [statusError] = await this.setMeta(executionId, "status", "cancelled");
-		if (statusError) return require_lib_errors_index.err(statusError.type, statusError.message);
-		const [updatedAtError] = await this.setMeta(executionId, "updatedAt", String(timestamp));
-		if (updatedAtError) return require_lib_errors_index.err(updatedAtError.type, updatedAtError.message);
-		const [cancelledAtError] = await this.setMeta(executionId, "cancelledAt", String(timestamp));
-		if (cancelledAtError) return require_lib_errors_index.err(cancelledAtError.type, cancelledAtError.message);
-		const [clearErrorError] = await this.setMeta(executionId, "error", "");
-		if (clearErrorError) return require_lib_errors_index.err(clearErrorError.type, clearErrorError.message);
-		const [clearFailedAtError] = await this.setMeta(executionId, "failedAt", "");
-		if (clearFailedAtError) return require_lib_errors_index.err(clearFailedAtError.type, clearFailedAtError.message);
-		return require_lib_errors_index.ok({
-			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 [serializeError, serializedInput] = this.serializeInput(input);
-		if (serializeError) return require_lib_errors_index.err("WorkflowSerializationError", `Unable to serialize workflow input for ${executionId}`);
-		const timestamp = now();
-		const [statusReadError, existingStatus] = await this.getMeta(executionId, "status");
-		if (statusReadError) return require_lib_errors_index.err(statusReadError.type, statusReadError.message);
-		if (existingStatus) return require_lib_errors_index.err("WorkflowStateError", `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 require_lib_errors_index.mightThrow(this.options.redis.hset(this.metaKey(executionId), metadata));
-		if (writeError) return require_lib_errors_index.err("WorkflowError", `Unable to persist metadata for execution ${executionId}`);
-		return require_lib_errors_index.ok(null);
-	}
-	async execute(executionId, input) {
-		const token = crypto.randomUUID();
-		const [lockError] = await this.acquireLock(executionId, token);
-		if (lockError) return require_lib_errors_index.err(lockError.type, lockError.message);
-		const [statusCheckError, currentStatus] = await this.getMeta(executionId, "status");
-		if (statusCheckError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(statusCheckError.type, statusCheckError.message);
-		}
-		if (currentStatus === "cancelled") {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} was cancelled`);
-		}
-		const timestamp = now();
-		const [runningStatusError] = await this.setMeta(executionId, "status", "running");
-		if (runningStatusError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(runningStatusError.type, runningStatusError.message);
-		}
-		const [runningUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(timestamp));
-		if (runningUpdatedAtError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(runningUpdatedAtError.type, runningUpdatedAtError.message);
-		}
-		const controller = new AbortController();
-		const renewInterval = Math.floor(this.lockTTL / 3);
-		let lockLost = false;
-		const renewTimer = setInterval(async () => {
-			const [renewError] = await this.extendLock(executionId, token);
-			if (renewError) {
-				lockLost = true;
-				controller.abort();
-				clearInterval(renewTimer);
-			}
-		}, renewInterval);
-		const step = async (name, handler) => {
-			const [cancelledError, cancelled] = await this.isCancelled(executionId);
-			if (cancelledError) return Promise.reject(new Error(cancelledError.message));
-			if (cancelled) {
-				controller.abort();
-				return Promise.reject(/* @__PURE__ */ new Error("Workflow cancelled"));
-			}
-			const [readError, cachedStep] = await this.readStepOutput(executionId, name);
-			if (readError) return Promise.reject(new Error(readError.message));
-			if (cachedStep.found) return cachedStep.value;
-			const [stepError, output] = await require_lib_errors_index.mightThrow(Promise.resolve(handler(input, controller.signal)));
-			if (stepError) return Promise.reject(stepError);
-			const [writeError] = await this.writeStepOutput(executionId, name, output);
-			if (writeError) return Promise.reject(new Error(writeError.message));
-			return output;
-		};
-		const [handlerError, result] = await require_lib_errors_index.mightThrow(Promise.resolve(this.options.handler({
-			input,
-			executionId,
-			signal: controller.signal,
-			step
-		})));
-		clearInterval(renewTimer);
-		if (lockLost) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err("WorkflowLockError", `Lock expired during execution ${executionId}`);
-		}
-		const [cancelledError, cancelled] = await this.isCancelled(executionId);
-		if (cancelledError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(cancelledError.type, cancelledError.message);
-		}
-		if (cancelled) {
-			const cancelledAt = now();
-			const [cancelledStatusError] = await this.setMeta(executionId, "status", "cancelled");
-			if (cancelledStatusError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(cancelledStatusError.type, cancelledStatusError.message);
-			}
-			const [cancelledUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(cancelledAt));
-			if (cancelledUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(cancelledUpdatedAtError.type, cancelledUpdatedAtError.message);
-			}
-			const [cancelledAtError] = await this.setMeta(executionId, "cancelledAt", String(cancelledAt));
-			if (cancelledAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(cancelledAtError.type, cancelledAtError.message);
-			}
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.ok({
-				executionId,
-				status: "cancelled"
-			});
-		}
-		if (handlerError) {
-			const failedAt = now();
-			const [failedStatusError] = await this.setMeta(executionId, "status", "failed");
-			if (failedStatusError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedStatusError.type, failedStatusError.message);
-			}
-			const [failedMessageError] = await this.setMeta(executionId, "error", toErrorMessage(handlerError));
-			if (failedMessageError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedMessageError.type, failedMessageError.message);
-			}
-			const [failedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(failedAt));
-			if (failedUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedUpdatedAtError.type, failedUpdatedAtError.message);
-			}
-			const [failedAtError] = await this.setMeta(executionId, "failedAt", String(failedAt));
-			if (failedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedAtError.type, failedAtError.message);
-			}
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err("WorkflowExecutionError", `Workflow execution ${executionId} failed: ${toErrorMessage(handlerError)}`);
-		}
-		const [serializeResultError, serializedResult] = this.serializeResult(result);
-		if (serializeResultError) {
-			const failedAt = now();
-			const [failedStatusError] = await this.setMeta(executionId, "status", "failed");
-			if (failedStatusError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedStatusError.type, failedStatusError.message);
-			}
-			const [failedMessageError] = await this.setMeta(executionId, "error", serializeResultError.message);
-			if (failedMessageError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedMessageError.type, failedMessageError.message);
-			}
-			const [failedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(failedAt));
-			if (failedUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedUpdatedAtError.type, failedUpdatedAtError.message);
-			}
-			const [failedAtError] = await this.setMeta(executionId, "failedAt", String(failedAt));
-			if (failedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedAtError.type, failedAtError.message);
-			}
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err("WorkflowSerializationError", `Unable to serialize workflow result for ${executionId}`);
-		}
-		const completedAt = now();
-		const [completedResultError] = await this.setMeta(executionId, "result", serializedResult);
-		if (completedResultError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedResultError.type, completedResultError.message);
-		}
-		const [completedStatusError] = await this.setMeta(executionId, "status", "completed");
-		if (completedStatusError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedStatusError.type, completedStatusError.message);
-		}
-		const [completedClearErrorError] = await this.setMeta(executionId, "error", "");
-		if (completedClearErrorError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedClearErrorError.type, completedClearErrorError.message);
-		}
-		const [completedClearFailedAtError] = await this.setMeta(executionId, "failedAt", "");
-		if (completedClearFailedAtError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedClearFailedAtError.type, completedClearFailedAtError.message);
-		}
-		const [completedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(completedAt));
-		if (completedUpdatedAtError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedUpdatedAtError.type, completedUpdatedAtError.message);
-		}
-		const [completedAtError] = await this.setMeta(executionId, "completedAt", String(completedAt));
-		if (completedAtError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedAtError.type, completedAtError.message);
-		}
-		await this.releaseLock(executionId, token);
-		return require_lib_errors_index.ok({
-			executionId,
-			status: "completed"
-		});
-	}
-	async acquireLock(executionId, token) {
-		const [lockError, lockResult] = await require_lib_errors_index.mightThrow(this.options.redis.set(this.lockKey(executionId), token, "PX", String(this.lockTTL), "NX"));
-		if (lockError) return require_lib_errors_index.err("WorkflowLockError", `Unable to acquire lock for execution ${executionId}`);
-		if (lockResult !== "OK") return require_lib_errors_index.err("WorkflowLockError", `Workflow execution ${executionId} is already running`);
-		return require_lib_errors_index.ok(null);
-	}
-	async releaseLock(executionId, token) {
-		const [evalError] = await require_lib_errors_index.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
-		]));
-		if (evalError) return require_lib_errors_index.err("WorkflowLockError", `Unable to release lock for execution ${executionId}`);
-		return require_lib_errors_index.ok(null);
-	}
-	async extendLock(executionId, token) {
-		const [evalError, result] = await require_lib_errors_index.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) return require_lib_errors_index.err("WorkflowLockError", `Unable to extend lock for execution ${executionId}`);
-		if (result === 0) return require_lib_errors_index.err("WorkflowLockError", `Lock ownership lost for execution ${executionId}`);
-		return require_lib_errors_index.ok(null);
-	}
-	async isCancelled(executionId) {
-		const [statusError, status] = await this.getMeta(executionId, "status");
-		if (statusError) return require_lib_errors_index.err(statusError.type, statusError.message);
-		return require_lib_errors_index.ok(status === "cancelled");
-	}
-	async setMeta(executionId, field, value) {
-		const [writeError] = await require_lib_errors_index.mightThrow(this.options.redis.hset(this.metaKey(executionId), field, value));
-		if (writeError) return require_lib_errors_index.err("WorkflowError", `Unable to persist ${field} for execution ${executionId}`);
-		return require_lib_errors_index.ok(null);
-	}
-	async getMeta(executionId, field) {
-		const [readError, value] = await require_lib_errors_index.mightThrow(this.options.redis.hget(this.metaKey(executionId), field));
-		if (readError) return require_lib_errors_index.err("WorkflowError", `Unable to read ${field} for execution ${executionId}`);
-		if (value === null || value === void 0) return require_lib_errors_index.ok(null);
-		if (typeof value !== "string") return require_lib_errors_index.err("WorkflowStateError", `Invalid ${field} value for execution ${executionId}`);
-		if (value.length === 0) return require_lib_errors_index.ok(null);
-		return require_lib_errors_index.ok(value);
-	}
-	async readNumberMeta(executionId, field) {
-		const [readError, value] = await this.getMeta(executionId, field);
-		if (readError) return require_lib_errors_index.err(readError.type, readError.message);
-		if (!value) return require_lib_errors_index.ok(null);
-		const parsed = Number(value);
-		if (!Number.isFinite(parsed)) return require_lib_errors_index.err("WorkflowStateError", `Invalid ${field} value for execution ${executionId}`);
-		return require_lib_errors_index.ok(parsed);
-	}
-	runSerializer(value, serializer, label) {
-		const [serializeError, serialized] = require_lib_errors_index.mightThrowSync(() => serializer(value));
-		if (serializeError) return require_lib_errors_index.err("WorkflowSerializationError", `Unable to serialize ${label}: ${toErrorMessage(serializeError)}`);
-		if (typeof serialized !== "string") return require_lib_errors_index.err("WorkflowSerializationError", `${label} serializer must return a string`);
-		return require_lib_errors_index.ok(serialized);
-	}
-	runDeserializer(raw, deserializer, label) {
-		const [deserializeError, value] = require_lib_errors_index.mightThrowSync(() => deserializer(raw));
-		if (deserializeError) return require_lib_errors_index.err("WorkflowSerializationError", `Unable to deserialize ${label}: ${toErrorMessage(deserializeError)}`);
-		return require_lib_errors_index.ok(value);
-	}
-	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 require_lib_errors_index.ok(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 [readError, raw] = await this.getMeta(executionId, "input");
-		if (readError) return require_lib_errors_index.err(readError.type, readError.message);
-		if (!raw) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} input not found`);
-		return this.deserializeInput(raw);
-	}
-	async readResult(executionId) {
-		const [readError, raw] = await this.getMeta(executionId, "result");
-		if (readError) return require_lib_errors_index.err(readError.type, readError.message);
-		if (!raw) return require_lib_errors_index.ok(null);
-		const [deserializeError, result] = this.deserializeResult(raw);
-		if (deserializeError) return require_lib_errors_index.err(deserializeError.type, deserializeError.message);
-		return require_lib_errors_index.ok(result);
-	}
-	async writeStepOutput(executionId, stepName, output) {
-		const [serializeError, serializedOutput] = this.serializeStepOutput(output);
-		if (serializeError) return require_lib_errors_index.err("WorkflowSerializationError", `Unable to serialize step ${stepName} output`);
-		const payload = {
-			output: serializedOutput,
-			completedAt: now()
-		};
-		const [payloadError, payloadRaw] = require_lib_errors_index.mightThrowSync(() => JSON.stringify(payload));
-		if (payloadError || typeof payloadRaw !== "string") return require_lib_errors_index.err("WorkflowSerializationError", `Unable to persist step ${stepName} output`);
-		const [writeError] = await require_lib_errors_index.mightThrow(this.options.redis.hset(this.stepsKey(executionId), stepName, payloadRaw));
-		if (writeError) return require_lib_errors_index.err("WorkflowError", `Unable to persist step ${stepName} for execution ${executionId}`);
-		const [stepNamesError, stepNames] = await this.readStepNames(executionId);
-		if (stepNamesError) return require_lib_errors_index.err(stepNamesError.type, stepNamesError.message);
-		if (!stepNames.includes(stepName)) {
-			const nextStepNames = [...stepNames, stepName];
-			const [serializeStepsError, serializedSteps] = require_lib_errors_index.mightThrowSync(() => JSON.stringify(nextStepNames));
-			if (serializeStepsError || typeof serializedSteps !== "string") return require_lib_errors_index.err("WorkflowSerializationError", `Unable to persist step history for execution ${executionId}`);
-			const [updateStepsError] = await this.setMeta(executionId, "steps", serializedSteps);
-			if (updateStepsError) return require_lib_errors_index.err(updateStepsError.type, updateStepsError.message);
-		}
-		const [updatedError] = await this.setMeta(executionId, "updatedAt", String(now()));
-		if (updatedError) return require_lib_errors_index.err(updatedError.type, updatedError.message);
-		return require_lib_errors_index.ok(null);
-	}
-	async readStepOutput(executionId, stepName) {
-		const [readError, payloadRaw] = await require_lib_errors_index.mightThrow(this.options.redis.hget(this.stepsKey(executionId), stepName));
-		if (readError) return require_lib_errors_index.err("WorkflowError", `Unable to read step ${stepName} for execution ${executionId}`);
-		if (!payloadRaw) return require_lib_errors_index.ok({
-			found: false,
-			value: null
-		});
-		if (typeof payloadRaw !== "string") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-		const [parseError, parsed] = require_lib_errors_index.mightThrowSync(() => JSON.parse(payloadRaw));
-		if (parseError || parsed === null || typeof parsed !== "object") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-		if (typeof parsed.output !== "string") return require_lib_errors_index.err("WorkflowStateError", `Invalid step output for ${stepName} in execution ${executionId}`);
-		const outputRaw = parsed.output;
-		const [deserializeError, value] = this.deserializeStepOutput(outputRaw);
-		if (deserializeError) return require_lib_errors_index.err(deserializeError.type, deserializeError.message);
-		return require_lib_errors_index.ok({
-			found: true,
-			value
-		});
-	}
-	async readStepNames(executionId) {
-		const [readError, stepsRaw] = await this.getMeta(executionId, "steps");
-		if (readError) return [readError, []];
-		if (!stepsRaw) return require_lib_errors_index.ok([]);
-		const [parseError, values] = require_lib_errors_index.mightThrowSync(() => JSON.parse(stepsRaw));
-		if (parseError || !Array.isArray(values)) return require_lib_errors_index.err("WorkflowStateError", `Invalid step index for execution ${executionId}`);
-		const stepNames = [];
-		for (const value of values) if (typeof value === "string") stepNames.push(value);
-		return require_lib_errors_index.ok(stepNames);
-	}
-	async readStepSnapshots(executionId) {
-		const [stepNamesError, stepNames] = await this.readStepNames(executionId);
-		if (stepNamesError) return [stepNamesError, []];
-		const steps = [];
-		for (const stepName of stepNames) {
-			const [readError, payloadRaw] = await require_lib_errors_index.mightThrow(this.options.redis.hget(this.stepsKey(executionId), stepName));
-			if (readError) return require_lib_errors_index.err("WorkflowError", `Unable to read step ${stepName} for execution ${executionId}`);
-			if (!payloadRaw) continue;
-			if (typeof payloadRaw !== "string") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-			const [parseError, parsed] = require_lib_errors_index.mightThrowSync(() => JSON.parse(payloadRaw));
-			if (parseError || parsed === null || typeof parsed !== "object") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-			if (typeof parsed.completedAt !== "number") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-			const completedAt = parsed.completedAt;
-			steps.push({
-				name: stepName,
-				completedAt
-			});
-		}
-		return require_lib_errors_index.ok(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
-exports.defineWorkflow = defineWorkflow;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../../rolldown-runtime-CMqjfN_6.cjs"),t=require("../errors/index.cjs");let n=require("node:assert");n=e.t(n,1);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.mightThrowSync(()=>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.default.ok(Number.isFinite(this.retries)&&this.retries>=0,`Invalid retries: must be a non-negative finite number`),n.default.ok(Number.isFinite(this.retryBaseDelay)&&this.retryBaseDelay>0,`Invalid retryBackoff.baseDelay: must be a positive finite number`),n.default.ok(Number.isFinite(this.retryMultiplier)&&this.retryMultiplier>0,`Invalid retryBackoff.multiplier: must be a positive finite number`),n.default.ok(Number.isFinite(this.retryMaxDelay)&&this.retryMaxDelay>0,`Invalid retryBackoff.maxDelay: must be a positive finite number`)}runHook(e){return t.mightThrow(Promise.resolve().then(()=>e()))}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(e,n){let i=this.serializeInput(n),o=u();if(await this.getMeta(e,`status`))throw new a(`Workflow execution ${e} already exists`);let s={status:`pending`,input:i,result:``,error:``,createdAt:String(o),updatedAt:String(o),completedAt:``,failedAt:``,cancelledAt:``,steps:`[]`},[c]=await t.mightThrow(this.options.redis.hset(this.metaKey(e),s));if(c)throw new r(`Unable to persist metadata for execution ${e}`)}async execute(e,n){let r=crypto.randomUUID();if(await this.acquireLock(e,r),await this.getMeta(e,`status`)===`cancelled`)throw await this.releaseLock(e,r),new a(`Workflow execution ${e} was cancelled`);let i=u();await this.setMeta(e,`status`,`running`),await this.setMeta(e,`updatedAt`,String(i));let l=new AbortController,d=Math.floor(this.lockTTL/3),f=!1,p=setInterval(async()=>{let[n]=await t.mightThrow(this.extendLock(e,r));n&&(f=!0,l.abort(),clearInterval(p))},d);this.options.hooks?.onStart&&await this.runHook(()=>this.options.hooks?.onStart?.({executionId:e,input:n}));let m=await t.mightThrow(Promise.resolve(this.options.handler({input:n,executionId:e,signal:l.signal,step:async(t,r)=>{await this.throwIfCancelled(e,()=>{l.abort()});let i=await this.readStepOutput(e,t);return i.found?i.value:this.runStepWithRetries(e,n,t,r,l.signal,()=>{l.abort()})}})));if(clearInterval(p),f)throw await this.releaseLock(e,r),new c(`Lock expired during execution ${e}`);if(await this.isCancelled(e)){let t=u();return await this.setMeta(e,`status`,`cancelled`),await this.setMeta(e,`updatedAt`,String(t)),await this.setMeta(e,`cancelledAt`,String(t)),this.options.hooks?.onCancel&&await this.runHook(()=>this.options.hooks?.onCancel?.({executionId:e,input:n})),await this.releaseLock(e,r),{executionId:e,status:`cancelled`}}let[h,g]=m;if(h){let t=u();throw await this.setMeta(e,`status`,`failed`),await this.setMeta(e,`error`,h.message),await this.setMeta(e,`updatedAt`,String(t)),await this.setMeta(e,`failedAt`,String(t)),await this.releaseLock(e,r),new s(`Workflow execution ${e} failed: ${h.message}`)}let[_,v]=t.mightThrowSync(()=>this.serializeResult(g));if(_){let t=u();throw await this.setMeta(e,`status`,`failed`),await this.setMeta(e,`error`,_.message),await this.setMeta(e,`updatedAt`,String(t)),await this.setMeta(e,`failedAt`,String(t)),await this.releaseLock(e,r),new o(`Unable to serialize workflow result for ${e}`)}let y=u();return await this.setMeta(e,`result`,v),await this.setMeta(e,`status`,`completed`),await this.setMeta(e,`error`,``),await this.setMeta(e,`failedAt`,``),await this.setMeta(e,`updatedAt`,String(y)),await this.setMeta(e,`completedAt`,String(y)),this.options.hooks?.onComplete&&await this.runHook(()=>this.options.hooks?.onComplete?.({executionId:e,input:n,result:g})),await this.releaseLock(e,r),{executionId:e,status:`completed`}}async throwIfCancelled(e,t){if(await this.isCancelled(e))throw t(),new l(`Workflow execution ${e} was cancelled`)}async runStepWithRetries(e,n,r,i,a,o){let s=1,c=[];for(;;){await this.throwIfCancelled(e,o);let[l,f]=await t.mightThrow(Promise.resolve(i(n,a)));if(!l)return await this.writeStepOutput(e,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:e,input:n,stepName:r,error:p,attempt:s,nextRetryDelayMs:i,retriesRemaining:this.retries-s}));let[o]=await t.mightThrow(d(i,a,()=>this.isCancelled(e)));if(o)throw o;s++;continue}throw this.options.hooks?.onError&&await this.runHook(()=>this.options.hooks?.onError?.({executionId:e,input:n,stepName:r,error:p,totalAttempts:s,errorHistory:c})),l}}async acquireLock(e,n){let[r,i]=await t.mightThrow(this.options.redis.set(this.lockKey(e),n,`PX`,String(this.lockTTL),`NX`));if(r)throw new c(`Unable to acquire lock for execution ${e}`);if(i!==`OK`)throw new c(`Workflow execution ${e} is already running`)}async releaseLock(e,n){await t.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(e),n]))}async extendLock(e,n){let[r,i]=await t.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(e),n,String(this.lockTTL)]));if(r)throw new c(`Unable to extend lock for execution ${e}`);if(i===0)throw new c(`Lock ownership lost for execution ${e}`)}async isCancelled(e){return await this.getMeta(e,`status`)===`cancelled`}async setMeta(e,n,i){let[a]=await t.mightThrow(this.options.redis.hset(this.metaKey(e),n,i));if(a)throw new r(`Unable to persist ${n} for execution ${e}`)}async getMeta(e,n){let[i,o]=await t.mightThrow(this.options.redis.hget(this.metaKey(e),n));if(i)throw new r(`Unable to read ${n} for execution ${e}`);if(o==null)return null;if(typeof o!=`string`)throw new a(`Invalid ${n} value for execution ${e}`);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.mightThrowSync(()=>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.mightThrowSync(()=>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(e,n,i){let a={output:this.serializeStepOutput(i),completedAt:u()},[s,c]=t.mightThrowSync(()=>JSON.stringify(a));if(s||typeof c!=`string`)throw new o(`Unable to persist step ${n} output`);let[l]=await t.mightThrow(this.options.redis.hset(this.stepsKey(e),n,c));if(l)throw new r(`Unable to persist step ${n} for execution ${e}`);let d=await this.readStepNames(e);if(!d.includes(n)){let r=[...d,n],[i,a]=t.mightThrowSync(()=>JSON.stringify(r));if(i||typeof a!=`string`)throw new o(`Unable to persist step history for execution ${e}`);await this.setMeta(e,`steps`,a)}await this.setMeta(e,`updatedAt`,String(u()))}async readStepOutput(e,n){let[i,o]=await t.mightThrow(this.options.redis.hget(this.stepsKey(e),n));if(i)throw new r(`Unable to read step ${n} for execution ${e}`);if(!o)return{found:!1,value:null};if(typeof o!=`string`)throw new a(`Invalid step payload for ${n} in execution ${e}`);let[s,c]=t.mightThrowSync(()=>JSON.parse(o));if(s||typeof c!=`object`||!c)throw new a(`Invalid step payload for ${n} in execution ${e}`);if(typeof c.output!=`string`)throw new a(`Invalid step output for ${n} in execution ${e}`);let l=c.output;return{found:!0,value:this.deserializeStepOutput(l)}}async readStepNames(e){let n=await this.getMeta(e,`steps`);if(!n)return[];let[r,i]=t.mightThrowSync(()=>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(e){let n=await this.readStepNames(e),i=[];for(let o of n){let[n,s]=await t.mightThrow(this.options.redis.hget(this.stepsKey(e),o));if(n)throw new r(`Unable to read step ${o} for execution ${e}`);if(!s)continue;if(typeof s!=`string`)throw new a(`Invalid step payload for ${o} in execution ${e}`);let[c,l]=t.mightThrowSync(()=>JSON.parse(s));if(c||typeof l!=`object`||!l||typeof l.completedAt!=`number`)throw new a(`Invalid step payload for ${o} in execution ${e}`);i.push({name:o,completedAt:l.completedAt})}return i}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)}};exports.CancelledError=l,exports.ExecutionError=s,exports.LockError=c,exports.NotFoundError=i,exports.SerializationError=o,exports.StateError=a,exports.WorkflowError=r,exports.defineWorkflow=g;

package/dist/lib/workflow/index.d.cts

@@ -1,85 +1 @@
-//#region src/lib/workflow/types.d.ts
-type WorkflowStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
-type WorkflowErrorType = "WorkflowError" | "WorkflowNotFoundError" | "WorkflowStateError" | "WorkflowSerializationError" | "WorkflowLockError" | "WorkflowExecutionError" | "WorkflowCancelledError";
-type WorkflowError = {
-  type: WorkflowErrorType;
-  message: string;
-};
-type StepSnapshot = {
-  name: string;
-  completedAt: number;
-};
-type WorkflowExecution<TInput, TResult> = {
-  id: string;
-  name: string;
-  status: WorkflowStatus;
-  input: TInput;
-  result: TResult | null;
-  error: string | null;
-  createdAt: number;
-  updatedAt: number;
-  completedAt: number | null;
-  failedAt: number | null;
-  cancelledAt: number | null;
-  steps: StepSnapshot[];
-};
-type StepHandler<TInput, TStep> = (input: TInput, signal: AbortSignal) => TStep | Promise<TStep>;
-type WorkflowHandlerContext<TInput> = {
-  input: TInput;
-  executionId: string;
-  signal: AbortSignal;
-  step: <TStep>(name: string, handler: StepHandler<TInput, TStep>) => Promise<TStep>;
-};
-type SerializeValue<T> = (value: T) => string;
-type DeserializeValue<T> = (raw: string) => T;
-type WorkflowOptions<TInput, TResult> = {
-  name: string;
-  redis: Bun.RedisClient;
-  handler: (context: WorkflowHandlerContext<TInput>) => TResult | Promise<TResult>;
-  lockTTL?: number;
-  serializeInput?: SerializeValue<TInput>;
-  deserializeInput?: DeserializeValue<TInput>;
-  serializeResult?: SerializeValue<TResult>;
-  deserializeResult?: DeserializeValue<TResult>;
-  serializeStepOutput?: SerializeValue<unknown>;
-  deserializeStepOutput?: DeserializeValue<unknown>;
-};
-type WorkflowStartOptions = {
-  executionId?: string;
-};
-type WorkflowStartResult = {
-  executionId: string;
-  status: WorkflowStatus;
-};
-type WorkflowCancelResult = {
-  status: WorkflowStatus;
-  executionId: string;
-  updatedAt: number;
-  cancelledAt: number;
-  createdAt: number;
-};
-type WorkflowMeta = {
-  status: string;
-  input: string;
-  result: string;
-  error: string;
-  createdAt: string;
-  updatedAt: string;
-  completedAt: string;
-  failedAt: string;
-  cancelledAt: string;
-  steps: string;
-};
-type WorkflowMetaField = keyof WorkflowMeta;
-type Workflow<TInput, TResult> = {
-  start: (input: TInput, options?: WorkflowStartOptions) => Promise<readonly [WorkflowError | null, WorkflowStartResult | null]>;
-  run: (input: TInput, options?: WorkflowStartOptions) => Promise<readonly [WorkflowError | null, TResult | null]>;
-  resume: (executionId: string) => Promise<readonly [WorkflowError | null, WorkflowStartResult | null]>;
-  get: (executionId: string) => Promise<readonly [WorkflowError | null, WorkflowExecution<TInput, TResult> | null]>;
-  cancel: (executionId: string) => Promise<readonly [WorkflowError | null, WorkflowCancelResult | null]>;
-};
-//#endregion
-//#region src/lib/workflow/index.d.ts
-declare const defineWorkflow: <TInput, TResult = void>(options: WorkflowOptions<TInput, TResult>) => Workflow<TInput, TResult>;
-//#endregion
-export { type StepHandler, type Workflow, type WorkflowError, type WorkflowExecution, type WorkflowHandlerContext, type WorkflowMeta, type WorkflowMetaField, type WorkflowOptions, type WorkflowStartOptions, type WorkflowStartResult, type WorkflowStatus, defineWorkflow };
+export type * from './index.d.mts'