@vite-hub/workflow 0.0.0 → 0.0.1

package/dist/index.js

@@ -0,0 +1,369 @@
+import { t as normalizeWorkflowOptions } from "./config-DkgsQuXz.js";
+import { a as encodeNameHex, i as getCloudflareWorkflowName, n as getCloudflareWorkflowBindingName, r as getCloudflareWorkflowClassName } from "./cloudflare-CeHVSHoN.js";
+import { n as getCloudflareEnv, r as resolveWaitUntil } from "./cloudflare-env-g0Rf3ClH.js";
+import { runWorkflowHandler } from "./runtime/execute.js";
+import { getOpenWorkflowRun, runOpenWorkflow } from "./runtime/openworkflow.js";
+import { getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, loadWorkflowDefinition, registerInlineWorkflowDefinition, runWithWorkflowRuntimeEvent, setWorkflowRun } from "./runtime/state.js";
+import { t as createWorkflowCloudflareWorker } from "./cloudflare-vite-DcM5YVTP.js";
+import { createOpenWorkflowWorker, startOpenWorkflowWorker } from "./runtime/openworkflow-worker.js";
+//#region src/definition.ts
+function defineWorkflow(handler, options) {
+	if (typeof handler !== "function") throw new TypeError("`defineWorkflow()` requires a workflow handler.");
+	if (typeof options !== "undefined" && (!options || typeof options !== "object" || Array.isArray(options))) throw new TypeError("`defineWorkflow()` options must be a plain object.");
+	return {
+		handler,
+		options
+	};
+}
+//#endregion
+//#region src/errors.ts
+var WorkflowError = class extends Error {
+	code;
+	details;
+	httpStatus;
+	provider;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "WorkflowError";
+		this.cause = options.cause;
+		this.code = options.code;
+		this.details = options.details;
+		this.httpStatus = options.httpStatus;
+		this.provider = options.provider;
+	}
+};
+//#endregion
+//#region src/integrations/vercel.ts
+function getVercelWorkflowName(name) {
+	return `workflow--${encodeNameHex(name)}`;
+}
+//#endregion
+//#region ../internal/src/runtime/random.ts
+function randomId(prefix) {
+	const body = `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+	return prefix ? `${prefix}_${body}` : body;
+}
+//#endregion
+//#region src/runtime/vercel-state.ts
+const RUNS_TTL_SECONDS = 300;
+function readEnv(name) {
+	const value = globalThis.process?.env?.[name];
+	return value && value.trim() ? value : void 0;
+}
+function getUpstashConfig() {
+	const url = readEnv("KV_REST_API_URL") || readEnv("UPSTASH_REDIS_REST_URL");
+	const token = readEnv("KV_REST_API_TOKEN") || readEnv("UPSTASH_REDIS_REST_TOKEN");
+	return url && token ? {
+		token,
+		url
+	} : void 0;
+}
+function getRunKey(name, id) {
+	return `vitehub:workflow:runs:${encodeURIComponent(name)}:${encodeURIComponent(id)}`;
+}
+async function command(body) {
+	const config = getUpstashConfig();
+	if (!config || typeof fetch !== "function") return;
+	try {
+		const response = await fetch(config.url, {
+			body: JSON.stringify(body),
+			headers: {
+				authorization: `Bearer ${config.token}`,
+				"content-type": "application/json"
+			},
+			method: "POST"
+		});
+		if (!response.ok) return;
+		return (await response.json()).result;
+	} catch {
+		return;
+	}
+}
+async function setVercelWorkflowRunState(name, id, run) {
+	const value = JSON.stringify(run);
+	await command([
+		"SET",
+		getRunKey(name, id),
+		value,
+		"EX",
+		RUNS_TTL_SECONDS
+	]);
+}
+async function getVercelWorkflowRunState(name, id) {
+	const value = await command(["GET", getRunKey(name, id)]);
+	if (!value) return;
+	try {
+		const parsed = JSON.parse(value);
+		return parsed && typeof parsed.status === "string" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/runtime/adapters.ts
+function resolveCloudflareBinding(event, binding, name) {
+	const bindingName = binding || getCloudflareWorkflowBindingName(name);
+	return getCloudflareEnv(event)?.[bindingName];
+}
+const cloudflareStatusMap = {
+	complete: "completed",
+	completed: "completed",
+	errored: "failed",
+	failed: "failed",
+	queued: "queued",
+	running: "running",
+	success: "completed",
+	terminated: "failed"
+};
+function normalizeCloudflareStatus(status) {
+	const value = typeof status === "object" && status ? status.status : status;
+	return cloudflareStatusMap[String(value || "").toLowerCase()] || "unknown";
+}
+function createCloudflareAdapter(config) {
+	return {
+		async get({ event, id, name }) {
+			const binding = resolveCloudflareBinding(event, config.binding, name);
+			if (binding) {
+				const metadata = await (await binding.get(id)).status();
+				return {
+					id,
+					metadata,
+					provider: "cloudflare",
+					status: normalizeCloudflareStatus(metadata)
+				};
+			}
+			return await inlineAdapter(config).get({
+				event,
+				id,
+				name
+			});
+		},
+		async run({ definition, event, id, name, options, payload }) {
+			const binding = resolveCloudflareBinding(event, config.binding, name);
+			if (binding) {
+				const start = binding.create({
+					id,
+					params: payload
+				});
+				const waitUntil = options.deferred ? resolveWaitUntil(event) : void 0;
+				if (waitUntil) waitUntil(start);
+				const instance = await start;
+				return {
+					id: instance.id,
+					metadata: await instance.status(),
+					payload,
+					provider: "cloudflare",
+					status: "queued"
+				};
+			}
+			return await inlineAdapter(config).run({
+				definition,
+				event,
+				id,
+				name,
+				options,
+				payload
+			});
+		}
+	};
+}
+function createOpenWorkflowAdapter(config) {
+	return {
+		get: async ({ id, name }) => await getOpenWorkflowRun(config, name, id),
+		run: async ({ definition, name, options, payload }) => await runOpenWorkflow(config, name, payload, definition, options)
+	};
+}
+function inlineAdapter(config) {
+	return {
+		async get({ id, name }) {
+			const run = getWorkflowRunState(name, id);
+			if (run) {
+				if (run.status === "running") return {
+					id,
+					provider: config.provider,
+					status: "running"
+				};
+				return {
+					id,
+					metadata: run.error,
+					provider: config.provider,
+					result: run.result,
+					status: run.status
+				};
+			}
+			if (config.provider === "vercel") {
+				const persisted = await getVercelWorkflowRunState(name, id);
+				if (persisted) return {
+					id,
+					metadata: persisted.error,
+					provider: "vercel",
+					result: persisted.result,
+					status: persisted.status
+				};
+			}
+			return {
+				id,
+				provider: config.provider,
+				status: "unknown"
+			};
+		},
+		async run({ definition, event, id, name, payload }) {
+			const runState = setWorkflowRun(name, id, Promise.resolve().then(() => runWorkflowHandler({
+				id,
+				name,
+				payload,
+				provider: config.provider
+			}, definition)).then((result) => ({
+				result,
+				status: "completed"
+			})).catch((error) => ({
+				error,
+				status: "failed"
+			})));
+			const persistStarted = config.provider === "vercel" ? setVercelWorkflowRunState(name, id, { status: "running" }).catch(() => {}) : Promise.resolve();
+			const persistFinished = config.provider === "vercel" ? runState.promise.then((result) => setVercelWorkflowRunState(name, id, result)).catch(() => {}) : Promise.resolve();
+			const waitUntil = resolveWaitUntil(event);
+			if (waitUntil) waitUntil(Promise.all([runState.promise, persistFinished]));
+			await persistStarted;
+			return {
+				id,
+				metadata: config.provider === "vercel" ? { workflow: getVercelWorkflowName(name) } : void 0,
+				payload,
+				provider: config.provider,
+				status: "queued"
+			};
+		}
+	};
+}
+function getWorkflowRuntimeAdapter(config) {
+	if (config.provider === "cloudflare") return createCloudflareAdapter(config);
+	if (config.provider === "openworkflow") return createOpenWorkflowAdapter(config);
+	return inlineAdapter(config);
+}
+//#endregion
+//#region src/runtime/client.ts
+function getActiveWorkflowConfig() {
+	const config = getWorkflowRuntimeConfig();
+	if (config === false) return false;
+	return config || normalizeWorkflowOptions(void 0, { hosting: "vercel" });
+}
+async function loadRequiredWorkflowDefinition(name) {
+	const definition = await loadWorkflowDefinition(name);
+	if (!definition) throw new WorkflowError(`Unknown workflow definition: ${name}`, {
+		code: "WORKFLOW_DEFINITION_NOT_FOUND",
+		details: { name },
+		httpStatus: 404
+	});
+	return definition;
+}
+function normalizeWorkflowRunIdValue(value) {
+	if (value === void 0) return null;
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((item) => normalizeWorkflowRunIdValue(item));
+	const record = value;
+	return Object.fromEntries(Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => [key, normalizeWorkflowRunIdValue(record[key])]));
+}
+async function sha256Hex(value) {
+	const data = new TextEncoder().encode(value);
+	const digest = await crypto.subtle.digest("SHA-256", data);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function createStableWorkflowRunId(name, value) {
+	const hash = await sha256Hex(`${name}:${JSON.stringify(normalizeWorkflowRunIdValue(value))}`);
+	return `${name.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "workflow"}-${hash.slice(0, 32)}`;
+}
+async function resolveWorkflowStartOptions(name, payload, createOptions, startOptions) {
+	if (startOptions.id || !createOptions?.id) return startOptions;
+	return {
+		...startOptions,
+		id: await createStableWorkflowRunId(name, await createOptions.id({
+			name,
+			payload
+		}))
+	};
+}
+function createWorkflow(nameOrOptions, handlerOrOptions, options) {
+	if (typeof nameOrOptions === "object" && nameOrOptions !== null) {
+		const createOptions = nameOrOptions;
+		const { handler, name } = createOptions;
+		if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
+		if (typeof handler !== "function") throw new TypeError("`createWorkflow()` requires a workflow handler.");
+		registerInlineWorkflowDefinition(name, { handler });
+		return {
+			name,
+			defer: async (payload, options = {}) => deferWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options)),
+			getRun: (id) => getWorkflowRun(name, id),
+			run: async (payload, options = {}) => runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options))
+		};
+	}
+	const name = nameOrOptions;
+	if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
+	const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : typeof handlerOrOptions === "object" && handlerOrOptions !== null ? handlerOrOptions.handler : void 0;
+	const createOptions = typeof handlerOrOptions === "function" ? options : handlerOrOptions;
+	if (handler !== void 0) {
+		if (typeof handler !== "function") throw new TypeError("`createWorkflow()` requires a workflow handler.");
+		registerInlineWorkflowDefinition(name, { handler });
+	} else if (handlerOrOptions !== void 0 && (typeof handlerOrOptions !== "object" || handlerOrOptions === null)) throw new TypeError("`createWorkflow()` options must be an object.");
+	return {
+		name,
+		defer: async (payload, options = {}) => deferWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options)),
+		getRun: (id) => getWorkflowRun(name, id),
+		run: async (payload, options = {}) => runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options))
+	};
+}
+async function runWorkflow(name, payload, options = {}) {
+	const config = getActiveWorkflowConfig();
+	if (config === false) throw new WorkflowError("Workflow is disabled.", {
+		code: "WORKFLOW_DISABLED",
+		httpStatus: 400
+	});
+	const id = options.id || randomId("wrun");
+	const definition = await loadRequiredWorkflowDefinition(name);
+	return await getWorkflowRuntimeAdapter(config).run({
+		definition,
+		event: getWorkflowRuntimeEvent(),
+		id,
+		name,
+		options,
+		payload
+	});
+}
+async function getWorkflowRun(name, id) {
+	const config = getActiveWorkflowConfig();
+	if (config === false) throw new WorkflowError("Workflow is disabled.", {
+		code: "WORKFLOW_DISABLED",
+		httpStatus: 400
+	});
+	return await getWorkflowRuntimeAdapter(config).get({
+		event: getWorkflowRuntimeEvent(),
+		id,
+		name
+	});
+}
+function deferWorkflow(name, payload, options = {}) {
+	return runWithWorkflowRuntimeEvent(getWorkflowRuntimeEvent(), () => runWorkflow(name, payload, {
+		...options,
+		deferred: true
+	}));
+}
+//#endregion
+//#region src/runtime/payload.ts
+async function readRequestPayload(request) {
+	if ((request.headers.get("content-type") || "").includes("application/json")) return await request.json();
+	return await request.text();
+}
+async function validatePayload(payload, schema) {
+	if (typeof schema === "function") return await schema(payload);
+	if ("safeParse" in schema && typeof schema.safeParse === "function") {
+		const result = schema.safeParse(payload);
+		if (!result.success) throw result.error || /* @__PURE__ */ new TypeError("Invalid workflow payload.");
+		return result.data;
+	}
+	if ("parse" in schema && typeof schema.parse === "function") return schema.parse(payload);
+	throw new TypeError("Invalid workflow payload schema.");
+}
+async function readValidatedPayload(request, schema) {
+	return await validatePayload(await readRequestPayload(request), schema);
+}
+//#endregion
+export { WorkflowError, createOpenWorkflowWorker, createWorkflow, createWorkflowCloudflareWorker, deferWorkflow, defineWorkflow, getCloudflareWorkflowBindingName, getCloudflareWorkflowClassName, getCloudflareWorkflowName, getVercelWorkflowName, getWorkflowRun, normalizeWorkflowOptions, readRequestPayload, readValidatedPayload, runWorkflow, startOpenWorkflowWorker, validatePayload };