@ewhauser/world-celld 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,10 +1,13 @@
-import { a as stringify, i as parse, n as rpcParse, r as rpcStringify, t as compact } from "./util-BvWlkqgV.js";
+import { c as globalRunIndexKey, d as workflowRunIndexKey, f as compact, g as stringify, h as parse, m as rpcStringify, o as correlationIndexKey, p as rpcParse } from "./retention-bLY1vcOu.js";
 import { EventSchema, HookSchema, MessageId, SPEC_VERSION_CURRENT, StepSchema, WorkflowRunSchema, parseQueueName } from "@workflow/world";
 import { EntityConflictError, HookNotFoundError, RunExpiredError, RunNotSupportedError, TooEarlyError, WorkflowRunNotFoundError, WorkflowWorldError } from "@workflow/errors";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { monotonicFactory } from "ulid";
 //#region src/config.ts
 function resolveConfig(config) {
+	const retentionRaw = config?.runRetentionMs ?? process.env.CELLD_RUN_RETENTION_MS ?? 0;
+	const runRetentionMs = typeof retentionRaw === "number" ? retentionRaw : Number.parseInt(retentionRaw, 10);
+	if (!Number.isSafeInteger(runRetentionMs) || runRetentionMs < 0) throw new Error("world-celld: runRetentionMs must be a non-negative safe integer");
 	return {
 		fleetUrl: config?.fleetUrl ?? process.env.CELLD_FLEET_URL,
 		secret: config?.secret ?? process.env.CELLD_WORLD_SECRET,
@@ -12,6 +15,7 @@ function resolveConfig(config) {
 		deploymentId: config?.deploymentId ?? process.env.CELLD_DEPLOYMENT_ID ?? "celld-default",
 		baseUrl: config?.baseUrl,
 		queueShards: config?.queueShards ?? 1,
+		runRetentionMs,
 		readPollMs: config?.readPollMs ?? 250,
 		rpcTimeoutMs: config?.rpcTimeoutMs ?? 3e4
 	};
@@ -113,9 +117,18 @@ const RUNS = {
 		"getEvent",
 		"listEvents",
 		"listSteps",
-		"listHooks"
+		"listHooks",
+		"getCleanupStatus",
+		"scheduleCleanup",
+		"cleanupNow",
+		"rearmCleanup"
 	],
-	mutating: /* @__PURE__ */ new Set(["applyEvent"])
+	mutating: /* @__PURE__ */ new Set([
+		"applyEvent",
+		"scheduleCleanup",
+		"cleanupNow",
+		"rearmCleanup"
+	])
 };
 const STREAMS = {
 	methods: [
@@ -124,12 +137,18 @@ const STREAMS = {
 		"getChunks",
 		"getInfo",
 		"registerStream",
-		"listStreams"
+		"listStreams",
+		"expireRegistry",
+		"finalizeRegistry",
+		"expireStream"
 	],
 	mutating: /* @__PURE__ */ new Set([
 		"writeChunk",
 		"closeStream",
-		"registerStream"
+		"registerStream",
+		"expireRegistry",
+		"finalizeRegistry",
+		"expireStream"
 	])
 };
 const QUEUE = {
@@ -139,13 +158,15 @@ const QUEUE = {
 		"listDeadLetters",
 		"redriveDeadLetter",
 		"purgeDeadLetters",
-		"rearmAlarm"
+		"rearmAlarm",
+		"expireRun"
 	],
 	mutating: /* @__PURE__ */ new Set([
 		"enqueue",
 		"redriveDeadLetter",
 		"purgeDeadLetters",
-		"rearmAlarm"
+		"rearmAlarm",
+		"expireRun"
 	])
 };
 function makeStub(transport, binding, name, spec) {
@@ -171,6 +192,12 @@ function makeIndexNamespace(transport) {
 		get: (key) => call("get", [key], true),
 		put: (key, value) => call("put", [key, value], false),
 		delete: (key) => call("delete", [key], false),
+		putOwned: (runId, key, value) => call("putOwned", [
+			runId,
+			key,
+			value
+		], false),
+		expireRun: (request) => call("expireRun", [request], false),
 		list: (options) => call("list", [options], true),
 		reserveHookToken: (token, owner) => call("reserveHookToken", [token, owner], false),
 		finalizeHookIndexes: (token, hookId, serializedHook, owner) => call("finalizeHookIndexes", [
@@ -430,6 +457,7 @@ function createQueue(config) {
 	return {
 		async queue(queueName, message, opts) {
 			const { kind } = parseQueueName(queueName);
+			const runId = "runId" in message ? message.runId : "workflowRunId" in message ? message.workflowRunId : void 0;
 			if (isTestMode()) {
 				const existing = testPump.inflight(opts?.idempotencyKey);
 				if (existing) return { messageId: existing };
@@ -450,6 +478,7 @@ function createQueue(config) {
 				queueName,
 				pathname: QUEUE_PATHNAMES[kind],
 				body: stringify(message),
+				runId,
 				idempotencyKey: opts?.idempotencyKey,
 				delaySeconds: opts?.delaySeconds,
 				config: {
@@ -457,7 +486,10 @@ function createQueue(config) {
 					queueShards
 				}
 			});
-			if (!outcome.ok) throw new WorkflowWorldError(outcome.message, { status: 409 });
+			if (!outcome.ok) {
+				if (outcome.code === "RUN_EXPIRED") throw new RunExpiredError(outcome.message);
+				throw new WorkflowWorldError(outcome.message, { status: 409 });
+			}
 			return { messageId: MessageId.parse(outcome.messageId) };
 		},
 		createQueueHandler(queueNamePrefix, handler) {
@@ -515,15 +547,6 @@ function createQueue(config) {
 }
 //#endregion
 //#region src/storage.ts
-function sortableTimestamp(date) {
-	return date.getTime().toString().padStart(13, "0");
-}
-function workflowRunIndexKey(run) {
-	return `run:${run.workflowName}:${sortableTimestamp(run.createdAt)}:${run.runId}`;
-}
-function globalRunIndexKey(run) {
-	return `runall:${sortableTimestamp(run.createdAt)}:${run.runId}`;
-}
 function hookOwner(hook) {
 	return {
 		runId: hook.runId,
@@ -577,15 +600,23 @@ const parseRun = (run) => WorkflowRunSchema.parse(compact(run));
 const parseStep = (step) => StepSchema.parse(compact(step));
 const parseHook = (hook) => HookSchema.parse(compact(hook));
 const parseEvent = (event) => EventSchema.parse(compact(event));
+function unwrapRead(outcome) {
+	if (!outcome.ok) throw new RunExpiredError(outcome.message);
+	return outcome.value;
+}
 function createStorage(config) {
 	const { env } = config;
+	const cleanup = {
+		retentionMs: config.runRetentionMs ?? 0,
+		queueShards: config.queueShards ?? 1
+	};
 	const ulid = monotonicFactory();
 	const getRunDO = (runId) => {
 		const id = env.WORKFLOW_DB.idFromName(runId);
 		return env.WORKFLOW_DB.get(id);
 	};
 	const runsGet = async (runId, params) => {
-		const run = await getRunDO(runId).getRun();
+		const run = unwrapRead(await getRunDO(runId).getRun());
 		if (!run) throw new WorkflowRunNotFoundError(runId);
 		return filterData(parseRun(run), params?.resolveData, ["input", "output"]);
 	};
@@ -624,7 +655,7 @@ function createStorage(config) {
 								if (matches.length > limit) break;
 							}
 						} catch (error) {
-							if (!WorkflowRunNotFoundError.is(error)) throw error;
+							if (!WorkflowRunNotFoundError.is(error) && !RunExpiredError.is(error)) throw error;
 						}
 					}
 					exhausted = kvList.list_complete;
@@ -661,7 +692,8 @@ function createStorage(config) {
 					outcome = await stub.applyEvent({
 						runId: effectiveRunId,
 						data,
-						tokenHolder
+						tokenHolder,
+						cleanup
 					});
 				} catch (error) {
 					if (hookReservation && data.eventType === "hook_created") await env.WORKFLOW_INDEX.releaseHookToken(data.eventData.token, hookReservation);
@@ -677,8 +709,8 @@ function createStorage(config) {
 						createdAt: outcome.run.createdAt.toISOString(),
 						status: outcome.run.status
 					});
-					await env.WORKFLOW_INDEX.put(workflowRunIndexKey(outcome.run), meta);
-					await env.WORKFLOW_INDEX.put(globalRunIndexKey(outcome.run), meta);
+					await env.WORKFLOW_INDEX.putOwned(effectiveRunId, workflowRunIndexKey(outcome.run), meta);
+					await env.WORKFLOW_INDEX.putOwned(effectiveRunId, globalRunIndexKey(outcome.run), meta);
 				}
 				if (outcome.hookToIndex) {
 					const serialized = stringify(outcome.hookToIndex);
@@ -689,8 +721,8 @@ function createStorage(config) {
 					hookId: released.hookId
 				});
 				if (outcome.event?.correlationId) {
-					const correlationKey = `correlation:${encodeURIComponent(outcome.event.correlationId)}:${sortableTimestamp(outcome.event.createdAt)}:${outcome.event.eventId}:${effectiveRunId}`;
-					await env.WORKFLOW_INDEX.put(correlationKey, JSON.stringify({
+					const correlationKey = correlationIndexKey(outcome.event.correlationId, outcome.event.createdAt, outcome.event.eventId, effectiveRunId);
+					await env.WORKFLOW_INDEX.putOwned(effectiveRunId, correlationKey, JSON.stringify({
 						runId: effectiveRunId,
 						eventId: outcome.event.eventId
 					}));
@@ -704,18 +736,18 @@ function createStorage(config) {
 				};
 			},
 			async get(runId, eventId, _params) {
-				const event = await getRunDO(runId).getEvent(eventId);
+				const event = unwrapRead(await getRunDO(runId).getEvent(eventId));
 				if (!event) throw new WorkflowWorldError(`Event not found: ${eventId}`, { status: 404 });
 				return parseEvent(event);
 			},
 			async list(params) {
 				const { runId } = params;
 				const limit = params?.pagination?.limit ?? 100;
-				const result = await getRunDO(runId).listEvents({
+				const result = unwrapRead(await getRunDO(runId).listEvents({
 					limit,
 					cursor: params?.pagination?.cursor || void 0,
 					sortOrder: params.pagination?.sortOrder || "asc"
-				});
+				}));
 				return {
 					data: result.data.map(parseEvent),
 					cursor: result.cursor,
@@ -736,7 +768,8 @@ function createStorage(config) {
 						const raw = await env.WORKFLOW_INDEX.get(name);
 						if (!raw) return null;
 						const { runId, eventId } = JSON.parse(raw);
-						return getRunDO(runId).getEvent(eventId);
+						const outcome = await getRunDO(runId).getEvent(eventId);
+						return outcome.ok ? outcome.value : null;
 					}))).filter((event) => event !== null).map(parseEvent),
 					cursor: listed.list_complete ? null : listed.cursor ?? null,
 					hasMore: !listed.list_complete
@@ -746,18 +779,18 @@ function createStorage(config) {
 		steps: {
 			async get(runId, stepId, params) {
 				if (!runId) throw new WorkflowWorldError("runId is required for Cloudflare step lookup", { status: 400 });
-				const step = await getRunDO(runId).getStep(stepId);
+				const step = unwrapRead(await getRunDO(runId).getStep(stepId));
 				if (!step) throw new WorkflowWorldError(`Step not found: ${stepId}`, { status: 404 });
 				return filterData(parseStep(step), params?.resolveData, ["input", "output"]);
 			},
 			async list(params) {
 				const { runId } = params;
 				const limit = params?.pagination?.limit ?? 20;
-				const result = await getRunDO(runId).listSteps({
+				const result = unwrapRead(await getRunDO(runId).listSteps({
 					limit,
 					cursor: params?.pagination?.cursor || void 0,
 					sortOrder: params?.pagination?.sortOrder ?? "asc"
-				});
+				}));
 				return {
 					data: result.data.map((s) => filterData(parseStep(s), params?.resolveData, ["input", "output"])),
 					cursor: result.cursor,
@@ -780,11 +813,11 @@ function createStorage(config) {
 				if (!params.runId) throw new WorkflowWorldError("runId is required for listing hooks", { status: 400 });
 				const runId = params.runId;
 				const limit = params?.pagination?.limit ?? 100;
-				const result = await getRunDO(runId).listHooks({
+				const result = unwrapRead(await getRunDO(runId).listHooks({
 					limit,
 					cursor: params?.pagination?.cursor || void 0,
 					sortOrder: params?.pagination?.sortOrder ?? "asc"
-				});
+				}));
 				return {
 					data: result.data.map((h) => filterHookData(parseHook(h), params?.resolveData ?? "all")),
 					cursor: result.cursor,
@@ -822,17 +855,19 @@ function createStreamer(config) {
 	async function registerStreamForRun(name, runId) {
 		const cacheKey = `${runId}\0${name}`;
 		if (registeredStreams.has(cacheKey)) return;
-		await getRunRegistryDO(runId).registerStream(name);
+		await getRunRegistryDO(runId).registerStream(runId, name);
 		registeredStreams.add(cacheKey);
 	}
 	return {
 		async writeToStream(name, runId, chunk) {
-			await registerStreamForRun(name, await runId);
-			await getStreamDO(name).writeChunk(toBytes(chunk));
+			const resolvedRunId = await runId;
+			await registerStreamForRun(name, resolvedRunId);
+			await getStreamDO(name).writeChunk(resolvedRunId, toBytes(chunk));
 		},
 		async closeStream(name, runId) {
-			await registerStreamForRun(name, await runId);
-			await getStreamDO(name).closeStream();
+			const resolvedRunId = await runId;
+			await registerStreamForRun(name, resolvedRunId);
+			await getStreamDO(name).closeStream(resolvedRunId);
 		},
 		async readFromStream(name, startIndex = 0) {
 			const stub = getStreamDO(name);
@@ -924,7 +959,9 @@ function createCelldWorld(config) {
 			WORKFLOW_DB: env.WORKFLOW_DB,
 			WORKFLOW_INDEX: env.WORKFLOW_INDEX
 		},
-		deploymentId: resolved.deploymentId
+		deploymentId: resolved.deploymentId,
+		runRetentionMs: resolved.runRetentionMs,
+		queueShards: resolved.queueShards
 	});
 	const queue = createQueue({
 		env: { WORKFLOW_QUEUE: env.WORKFLOW_QUEUE },
@@ -936,10 +973,27 @@ function createCelldWorld(config) {
 		env: { WORKFLOW_STREAMS: env.WORKFLOW_STREAMS },
 		readPollMs: resolved.readPollMs
 	});
+	const runStub = (runId) => env.WORKFLOW_DB.get(env.WORKFLOW_DB.idFromName(runId));
+	const retention = {
+		getStatus: (runId) => runStub(runId).getCleanupStatus(),
+		schedule: (runId) => {
+			if (resolved.runRetentionMs === 0) throw new Error("world-celld: runRetentionMs must be greater than zero to schedule cleanup");
+			return runStub(runId).scheduleCleanup({
+				retentionMs: resolved.runRetentionMs,
+				queueShards: resolved.queueShards
+			});
+		},
+		cleanupNow: (runId) => runStub(runId).cleanupNow({
+			retentionMs: Math.max(1, resolved.runRetentionMs),
+			queueShards: resolved.queueShards
+		}),
+		rearm: (runId) => runStub(runId).rearmCleanup()
+	};
 	return {
 		...storage,
 		...queue,
 		...streamer,
+		retention,
 		specVersion: SPEC_VERSION_CURRENT
 	};
 }