semola 0.5.4 → 0.6.1

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

@@ -1,10 +1,5 @@
 //#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;
@@ -32,10 +27,57 @@ type WorkflowHandlerContext<TInput> = {
 };
 type SerializeValue<T> = (value: T) => string;
 type DeserializeValue<T> = (raw: string) => T;
+type WorkflowStepErrorRecord = {
+  attempt: number;
+  error: string;
+  timestamp: number;
+};
+type WorkflowStepRetryContext<TInput> = {
+  executionId: string;
+  input: TInput;
+  stepName: string;
+  error: string;
+  attempt: number;
+  nextRetryDelayMs: number;
+  retriesRemaining: number;
+};
+type WorkflowStepErrorContext<TInput> = {
+  executionId: string;
+  input: TInput;
+  stepName: string;
+  error: string;
+  totalAttempts: number;
+  errorHistory: WorkflowStepErrorRecord[];
+};
+type WorkflowHooks<TInput, TResult> = {
+  onStart?: (context: {
+    executionId: string;
+    input: TInput;
+  }) => void | Promise<void>;
+  onRetry?: (context: WorkflowStepRetryContext<TInput>) => void | Promise<void>;
+  onError?: (context: WorkflowStepErrorContext<TInput>) => void | Promise<void>;
+  onComplete?: (context: {
+    executionId: string;
+    input: TInput;
+    result: TResult;
+  }) => void | Promise<void>;
+  onCancel?: (context: {
+    executionId: string;
+    input: TInput;
+  }) => void | Promise<void>;
+};
+type WorkflowRetryBackoff = {
+  baseDelay?: number;
+  multiplier?: number;
+  maxDelay?: number;
+};
 type WorkflowOptions<TInput, TResult> = {
   name: string;
   redis: Bun.RedisClient;
   handler: (context: WorkflowHandlerContext<TInput>) => TResult | Promise<TResult>;
+  retries?: number;
+  retryBackoff?: WorkflowRetryBackoff;
+  hooks?: WorkflowHooks<TInput, TResult>;
   lockTTL?: number;
   serializeInput?: SerializeValue<TInput>;
   deserializeInput?: DeserializeValue<TInput>;
@@ -72,14 +114,37 @@ type WorkflowMeta = {
 };
 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]>;
+  start: (input: TInput, options?: WorkflowStartOptions) => Promise<WorkflowStartResult>;
+  run: (input: TInput, options?: WorkflowStartOptions) => Promise<TResult | null>;
+  resume: (executionId: string) => Promise<WorkflowStartResult>;
+  get: (executionId: string) => Promise<WorkflowExecution<TInput, TResult>>;
+  cancel: (executionId: string) => Promise<WorkflowCancelResult>;
 };
 //#endregion
+//#region src/lib/workflow/errors.d.ts
+declare class WorkflowError extends Error {
+  constructor(message: string);
+}
+declare class NotFoundError extends Error {
+  constructor(message: string);
+}
+declare class StateError extends Error {
+  constructor(message: string);
+}
+declare class SerializationError extends Error {
+  constructor(message: string);
+}
+declare class ExecutionError extends Error {
+  constructor(message: string);
+}
+declare class LockError extends Error {
+  constructor(message: string);
+}
+declare class CancelledError extends Error {
+  constructor(message: string);
+}
+//#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 { CancelledError, ExecutionError, LockError, NotFoundError, SerializationError, StateError, type StepHandler, type Workflow, WorkflowError, type WorkflowExecution, type WorkflowHandlerContext, type WorkflowHooks, type WorkflowMeta, type WorkflowMetaField, type WorkflowOptions, type WorkflowRetryBackoff, type WorkflowStartOptions, type WorkflowStartResult, type WorkflowStatus, type WorkflowStepErrorContext, type WorkflowStepErrorRecord, type WorkflowStepRetryContext, defineWorkflow };

package/dist/lib/workflow/index.mjs

@@ -1,533 +1 @@
-import { err, mightThrow, mightThrowSync, ok } from "../errors/index.mjs";
-//#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] = 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 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 err(startError.type, startError.message);
-		if (!startData) return err("WorkflowError", "Unexpected empty start result");
-		if (startData.status === "cancelled") return err("WorkflowCancelledError", `Workflow execution ${startData.executionId} was cancelled`);
-		if (startData.status !== "completed") return err("WorkflowExecutionError", `Workflow execution ${startData.executionId} did not complete`);
-		const [getError, execution] = await this.get(startData.executionId);
-		if (getError) return err(getError.type, getError.message);
-		if (!execution) return err("WorkflowError", "Unexpected empty execution");
-		return ok(execution.result);
-	}
-	async resume(executionId) {
-		const [getError, execution] = await this.get(executionId);
-		if (getError) return err(getError.type, getError.message);
-		if (!execution) return err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
-		if (execution.status === "completed") return ok({
-			executionId,
-			status: execution.status
-		});
-		if (execution.status === "cancelled") return 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 err(statusError.type, statusError.message);
-		if (!status) return err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
-		const normalizedStatus = this.normalizeStatus(status);
-		if (!normalizedStatus) return err("WorkflowStateError", `Workflow execution ${executionId} has invalid status ${status}`);
-		const [inputError, input] = await this.readInput(executionId);
-		if (inputError) return err(inputError.type, inputError.message);
-		if (input === null) return err("WorkflowStateError", `Workflow execution ${executionId} has invalid input`);
-		const [resultError, result] = await this.readResult(executionId);
-		if (resultError) return err(resultError.type, resultError.message);
-		const [stepsError, steps] = await this.readStepSnapshots(executionId);
-		if (stepsError) return err(stepsError.type, stepsError.message);
-		const [createdAtError, createdAt] = await this.readNumberMeta(executionId, "createdAt");
-		if (createdAtError) return err(createdAtError.type, createdAtError.message);
-		if (createdAt === null) return err("WorkflowStateError", `Workflow execution ${executionId} is missing createdAt`);
-		const [updatedAtError, updatedAt] = await this.readNumberMeta(executionId, "updatedAt");
-		if (updatedAtError) return err(updatedAtError.type, updatedAtError.message);
-		if (updatedAt === null) return err("WorkflowStateError", `Workflow execution ${executionId} is missing updatedAt`);
-		const [metaError, errorMessage] = await this.getMeta(executionId, "error");
-		if (metaError) return err(metaError.type, metaError.message);
-		const [completedAtError, completedAt] = await this.readNumberMeta(executionId, "completedAt");
-		if (completedAtError) return err(completedAtError.type, completedAtError.message);
-		const [failedAtError, failedAt] = await this.readNumberMeta(executionId, "failedAt");
-		if (failedAtError) return err(failedAtError.type, failedAtError.message);
-		const [cancelledAtError, cancelledAt] = await this.readNumberMeta(executionId, "cancelledAt");
-		if (cancelledAtError) return err(cancelledAtError.type, cancelledAtError.message);
-		return 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 err(getError.type, getError.message);
-		if (!execution) return err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
-		if (execution.status === "completed") return err("WorkflowStateError", `Workflow execution ${executionId} is already completed`);
-		const timestamp = now();
-		const [statusError] = await this.setMeta(executionId, "status", "cancelled");
-		if (statusError) return err(statusError.type, statusError.message);
-		const [updatedAtError] = await this.setMeta(executionId, "updatedAt", String(timestamp));
-		if (updatedAtError) return err(updatedAtError.type, updatedAtError.message);
-		const [cancelledAtError] = await this.setMeta(executionId, "cancelledAt", String(timestamp));
-		if (cancelledAtError) return err(cancelledAtError.type, cancelledAtError.message);
-		const [clearErrorError] = await this.setMeta(executionId, "error", "");
-		if (clearErrorError) return err(clearErrorError.type, clearErrorError.message);
-		const [clearFailedAtError] = await this.setMeta(executionId, "failedAt", "");
-		if (clearFailedAtError) return err(clearFailedAtError.type, clearFailedAtError.message);
-		return 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 err("WorkflowSerializationError", `Unable to serialize workflow input for ${executionId}`);
-		const timestamp = now();
-		const [statusReadError, existingStatus] = await this.getMeta(executionId, "status");
-		if (statusReadError) return err(statusReadError.type, statusReadError.message);
-		if (existingStatus) return 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 mightThrow(this.options.redis.hset(this.metaKey(executionId), metadata));
-		if (writeError) return err("WorkflowError", `Unable to persist metadata for execution ${executionId}`);
-		return ok(null);
-	}
-	async execute(executionId, input) {
-		const token = crypto.randomUUID();
-		const [lockError] = await this.acquireLock(executionId, token);
-		if (lockError) return err(lockError.type, lockError.message);
-		const [statusCheckError, currentStatus] = await this.getMeta(executionId, "status");
-		if (statusCheckError) {
-			await this.releaseLock(executionId, token);
-			return err(statusCheckError.type, statusCheckError.message);
-		}
-		if (currentStatus === "cancelled") {
-			await this.releaseLock(executionId, token);
-			return 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 err(runningStatusError.type, runningStatusError.message);
-		}
-		const [runningUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(timestamp));
-		if (runningUpdatedAtError) {
-			await this.releaseLock(executionId, token);
-			return 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 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 mightThrow(Promise.resolve(this.options.handler({
-			input,
-			executionId,
-			signal: controller.signal,
-			step
-		})));
-		clearInterval(renewTimer);
-		if (lockLost) {
-			await this.releaseLock(executionId, token);
-			return err("WorkflowLockError", `Lock expired during execution ${executionId}`);
-		}
-		const [cancelledError, cancelled] = await this.isCancelled(executionId);
-		if (cancelledError) {
-			await this.releaseLock(executionId, token);
-			return 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 err(cancelledStatusError.type, cancelledStatusError.message);
-			}
-			const [cancelledUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(cancelledAt));
-			if (cancelledUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return err(cancelledUpdatedAtError.type, cancelledUpdatedAtError.message);
-			}
-			const [cancelledAtError] = await this.setMeta(executionId, "cancelledAt", String(cancelledAt));
-			if (cancelledAtError) {
-				await this.releaseLock(executionId, token);
-				return err(cancelledAtError.type, cancelledAtError.message);
-			}
-			await this.releaseLock(executionId, token);
-			return 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 err(failedStatusError.type, failedStatusError.message);
-			}
-			const [failedMessageError] = await this.setMeta(executionId, "error", toErrorMessage(handlerError));
-			if (failedMessageError) {
-				await this.releaseLock(executionId, token);
-				return err(failedMessageError.type, failedMessageError.message);
-			}
-			const [failedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(failedAt));
-			if (failedUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return err(failedUpdatedAtError.type, failedUpdatedAtError.message);
-			}
-			const [failedAtError] = await this.setMeta(executionId, "failedAt", String(failedAt));
-			if (failedAtError) {
-				await this.releaseLock(executionId, token);
-				return err(failedAtError.type, failedAtError.message);
-			}
-			await this.releaseLock(executionId, token);
-			return 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 err(failedStatusError.type, failedStatusError.message);
-			}
-			const [failedMessageError] = await this.setMeta(executionId, "error", serializeResultError.message);
-			if (failedMessageError) {
-				await this.releaseLock(executionId, token);
-				return err(failedMessageError.type, failedMessageError.message);
-			}
-			const [failedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(failedAt));
-			if (failedUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return err(failedUpdatedAtError.type, failedUpdatedAtError.message);
-			}
-			const [failedAtError] = await this.setMeta(executionId, "failedAt", String(failedAt));
-			if (failedAtError) {
-				await this.releaseLock(executionId, token);
-				return err(failedAtError.type, failedAtError.message);
-			}
-			await this.releaseLock(executionId, token);
-			return 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 err(completedResultError.type, completedResultError.message);
-		}
-		const [completedStatusError] = await this.setMeta(executionId, "status", "completed");
-		if (completedStatusError) {
-			await this.releaseLock(executionId, token);
-			return err(completedStatusError.type, completedStatusError.message);
-		}
-		const [completedClearErrorError] = await this.setMeta(executionId, "error", "");
-		if (completedClearErrorError) {
-			await this.releaseLock(executionId, token);
-			return err(completedClearErrorError.type, completedClearErrorError.message);
-		}
-		const [completedClearFailedAtError] = await this.setMeta(executionId, "failedAt", "");
-		if (completedClearFailedAtError) {
-			await this.releaseLock(executionId, token);
-			return err(completedClearFailedAtError.type, completedClearFailedAtError.message);
-		}
-		const [completedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(completedAt));
-		if (completedUpdatedAtError) {
-			await this.releaseLock(executionId, token);
-			return err(completedUpdatedAtError.type, completedUpdatedAtError.message);
-		}
-		const [completedAtError] = await this.setMeta(executionId, "completedAt", String(completedAt));
-		if (completedAtError) {
-			await this.releaseLock(executionId, token);
-			return err(completedAtError.type, completedAtError.message);
-		}
-		await this.releaseLock(executionId, token);
-		return ok({
-			executionId,
-			status: "completed"
-		});
-	}
-	async acquireLock(executionId, token) {
-		const [lockError, lockResult] = await mightThrow(this.options.redis.set(this.lockKey(executionId), token, "PX", String(this.lockTTL), "NX"));
-		if (lockError) return err("WorkflowLockError", `Unable to acquire lock for execution ${executionId}`);
-		if (lockResult !== "OK") return err("WorkflowLockError", `Workflow execution ${executionId} is already running`);
-		return ok(null);
-	}
-	async releaseLock(executionId, token) {
-		const [evalError] = 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
-		]));
-		if (evalError) return err("WorkflowLockError", `Unable to release lock for execution ${executionId}`);
-		return ok(null);
-	}
-	async extendLock(executionId, token) {
-		const [evalError, result] = 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) return err("WorkflowLockError", `Unable to extend lock for execution ${executionId}`);
-		if (result === 0) return err("WorkflowLockError", `Lock ownership lost for execution ${executionId}`);
-		return ok(null);
-	}
-	async isCancelled(executionId) {
-		const [statusError, status] = await this.getMeta(executionId, "status");
-		if (statusError) return err(statusError.type, statusError.message);
-		return ok(status === "cancelled");
-	}
-	async setMeta(executionId, field, value) {
-		const [writeError] = await mightThrow(this.options.redis.hset(this.metaKey(executionId), field, value));
-		if (writeError) return err("WorkflowError", `Unable to persist ${field} for execution ${executionId}`);
-		return ok(null);
-	}
-	async getMeta(executionId, field) {
-		const [readError, value] = await mightThrow(this.options.redis.hget(this.metaKey(executionId), field));
-		if (readError) return err("WorkflowError", `Unable to read ${field} for execution ${executionId}`);
-		if (value === null || value === void 0) return ok(null);
-		if (typeof value !== "string") return err("WorkflowStateError", `Invalid ${field} value for execution ${executionId}`);
-		if (value.length === 0) return ok(null);
-		return ok(value);
-	}
-	async readNumberMeta(executionId, field) {
-		const [readError, value] = await this.getMeta(executionId, field);
-		if (readError) return err(readError.type, readError.message);
-		if (!value) return ok(null);
-		const parsed = Number(value);
-		if (!Number.isFinite(parsed)) return err("WorkflowStateError", `Invalid ${field} value for execution ${executionId}`);
-		return ok(parsed);
-	}
-	runSerializer(value, serializer, label) {
-		const [serializeError, serialized] = mightThrowSync(() => serializer(value));
-		if (serializeError) return err("WorkflowSerializationError", `Unable to serialize ${label}: ${toErrorMessage(serializeError)}`);
-		if (typeof serialized !== "string") return err("WorkflowSerializationError", `${label} serializer must return a string`);
-		return ok(serialized);
-	}
-	runDeserializer(raw, deserializer, label) {
-		const [deserializeError, value] = mightThrowSync(() => deserializer(raw));
-		if (deserializeError) return err("WorkflowSerializationError", `Unable to deserialize ${label}: ${toErrorMessage(deserializeError)}`);
-		return 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 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 err(readError.type, readError.message);
-		if (!raw) return 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 err(readError.type, readError.message);
-		if (!raw) return ok(null);
-		const [deserializeError, result] = this.deserializeResult(raw);
-		if (deserializeError) return err(deserializeError.type, deserializeError.message);
-		return ok(result);
-	}
-	async writeStepOutput(executionId, stepName, output) {
-		const [serializeError, serializedOutput] = this.serializeStepOutput(output);
-		if (serializeError) return err("WorkflowSerializationError", `Unable to serialize step ${stepName} output`);
-		const payload = {
-			output: serializedOutput,
-			completedAt: now()
-		};
-		const [payloadError, payloadRaw] = mightThrowSync(() => JSON.stringify(payload));
-		if (payloadError || typeof payloadRaw !== "string") return err("WorkflowSerializationError", `Unable to persist step ${stepName} output`);
-		const [writeError] = await mightThrow(this.options.redis.hset(this.stepsKey(executionId), stepName, payloadRaw));
-		if (writeError) return err("WorkflowError", `Unable to persist step ${stepName} for execution ${executionId}`);
-		const [stepNamesError, stepNames] = await this.readStepNames(executionId);
-		if (stepNamesError) return err(stepNamesError.type, stepNamesError.message);
-		if (!stepNames.includes(stepName)) {
-			const nextStepNames = [...stepNames, stepName];
-			const [serializeStepsError, serializedSteps] = mightThrowSync(() => JSON.stringify(nextStepNames));
-			if (serializeStepsError || typeof serializedSteps !== "string") return err("WorkflowSerializationError", `Unable to persist step history for execution ${executionId}`);
-			const [updateStepsError] = await this.setMeta(executionId, "steps", serializedSteps);
-			if (updateStepsError) return err(updateStepsError.type, updateStepsError.message);
-		}
-		const [updatedError] = await this.setMeta(executionId, "updatedAt", String(now()));
-		if (updatedError) return err(updatedError.type, updatedError.message);
-		return ok(null);
-	}
-	async readStepOutput(executionId, stepName) {
-		const [readError, payloadRaw] = await mightThrow(this.options.redis.hget(this.stepsKey(executionId), stepName));
-		if (readError) return err("WorkflowError", `Unable to read step ${stepName} for execution ${executionId}`);
-		if (!payloadRaw) return ok({
-			found: false,
-			value: null
-		});
-		if (typeof payloadRaw !== "string") return err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-		const [parseError, parsed] = mightThrowSync(() => JSON.parse(payloadRaw));
-		if (parseError || parsed === null || typeof parsed !== "object") return err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-		if (typeof parsed.output !== "string") return err("WorkflowStateError", `Invalid step output for ${stepName} in execution ${executionId}`);
-		const outputRaw = parsed.output;
-		const [deserializeError, value] = this.deserializeStepOutput(outputRaw);
-		if (deserializeError) return err(deserializeError.type, deserializeError.message);
-		return ok({
-			found: true,
-			value
-		});
-	}
-	async readStepNames(executionId) {
-		const [readError, stepsRaw] = await this.getMeta(executionId, "steps");
-		if (readError) return [readError, []];
-		if (!stepsRaw) return ok([]);
-		const [parseError, values] = mightThrowSync(() => JSON.parse(stepsRaw));
-		if (parseError || !Array.isArray(values)) return err("WorkflowStateError", `Invalid step index for execution ${executionId}`);
-		const stepNames = [];
-		for (const value of values) if (typeof value === "string") stepNames.push(value);
-		return 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 mightThrow(this.options.redis.hget(this.stepsKey(executionId), stepName));
-			if (readError) return err("WorkflowError", `Unable to read step ${stepName} for execution ${executionId}`);
-			if (!payloadRaw) continue;
-			if (typeof payloadRaw !== "string") return err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-			const [parseError, parsed] = mightThrowSync(() => JSON.parse(payloadRaw));
-			if (parseError || parsed === null || typeof parsed !== "object") return err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-			if (typeof parsed.completedAt !== "number") return err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-			const completedAt = parsed.completedAt;
-			steps.push({
-				name: stepName,
-				completedAt
-			});
-		}
-		return 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
-export { 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}});