@vite-hub/workflow 0.0.4 → 0.1.0

package/dist/index.js

@@ -1,389 +1,45 @@
-import { t as normalizeWorkflowOptions } from "./config-BHknO_rT.js";
-import { a as encodeNameHex, i as getCloudflareWorkflowName, n as getCloudflareWorkflowBindingName, r as getCloudflareWorkflowClassName } from "./cloudflare-D0Di-QYL.js";
-import { t as hasRuntimeType } from "./runtime-type-DGUn8Ple.js";
-import { a as createWorkflowError, i as safeWorkflowName, r as runWorkflowProviderOperation } from "./provider-operation-CW2cYfVy.js";
-import { n as getCloudflareEnv, r as resolveWaitUntil } from "./cloudflare-env-DjxQNbrx.js";
-import { runWorkflowHandler } from "./runtime/execute.js";
-import { getOpenWorkflowRun, runOpenWorkflow } from "./runtime/openworkflow.js";
-import { getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, getWorkflowRuntimeRegistry, loadWorkflowDefinition, registerInlineWorkflowDefinition, runWithWorkflowRuntimeEvent, setWorkflowRun } from "./runtime/state.js";
-import { a as startVercelWorkflow, n as inspectVercelWorkflowRun, r as resumeVercelWorkflowSignal, t as cancelVercelWorkflow } from "./vercel-B0MuIVgJ.js";
-import { t as createWorkflowCloudflareWorker } from "./cloudflare-vite-BkDgB6Sr.js";
+import { t as normalizeWorkflowOptions } from "./config-IJMb0eeZ.js";
+import { t as workflowErrorDiagnostics } from "./error-diagnostics-pwNFvAHP.js";
+import { i as getCloudflareWorkflowName, n as getCloudflareWorkflowBindingName, r as getCloudflareWorkflowClassName } from "./cloudflare-nF4abPd4.js";
+import { a as resumeWorkflowSignal, i as getWorkflowRun, n as createWorkflow, o as runWorkflow, r as deferWorkflow, s as getVercelWorkflowName, t as cancelWorkflow } from "./client-DsGM3M4U.js";
+import { t as createWorkflowCloudflareWorker } from "./cloudflare-vite-B3IabBsv.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.");
-	if (options?.native !== void 0 && typeof options.native !== "function") throw new TypeError("`defineWorkflow()` native entry must be a workflow handler.");
+	if (typeof handler !== "function") throw workflowErrorDiagnostics.WORKFLOW_C0014({ message: "`defineWorkflow()` requires a workflow handler." });
+	if (typeof options !== "undefined" && (!options || typeof options !== "object" || Array.isArray(options))) throw workflowErrorDiagnostics.WORKFLOW_C0015({ message: "`defineWorkflow()` options must be a plain object." });
+	if (options?.native !== void 0 && typeof options.native !== "function") throw workflowErrorDiagnostics.WORKFLOW_C0016({ message: "`defineWorkflow()` native entry must be a workflow handler." });
 	return {
 		handler,
 		options
 	};
 }
 //#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/adapters.ts
-function resolveSettlementObserver(event) {
-	if (!event || !hasRuntimeType(event, "object")) return void 0;
-	const candidate = "settled" in event ? event.settled : void 0;
-	if (hasRuntimeType(candidate, "function")) return candidate;
-	const context = "context" in event ? event.context : void 0;
-	if (!context || !hasRuntimeType(context, "object")) return void 0;
-	const nested = "settled" in context ? context.settled : void 0;
-	return hasRuntimeType(nested, "function") ? nested : void 0;
-}
-function unsupportedOperation(provider, operation) {
-	throw createWorkflowError({
-		code: "WORKFLOW_OPERATION_UNSUPPORTED",
-		details: {
-			operation,
-			provider
-		}
-	});
-}
-function resolveCloudflareBinding(event, binding, name, definition) {
-	const env = getCloudflareEnv(event);
-	const bindingName = definition?.internalAgentInvocationRecovery ? getCloudflareWorkflowBindingName(name) : binding || getCloudflareWorkflowBindingName(name);
-	return env?.[bindingName];
-}
-function resolveCloudflareInspectionBinding(event, binding, name) {
-	return resolveCloudflareBinding(event, binding, name, getWorkflowRuntimeRegistry()?.[name]);
-}
-const cloudflareStatusMap = {
-	cancelled: "cancelled",
-	complete: "completed",
-	completed: "completed",
-	errored: "failed",
-	failed: "failed",
-	queued: "queued",
-	running: "running",
-	success: "completed",
-	terminated: "failed"
-};
-function normalizeCloudflareStatus(status) {
-	const value = hasRuntimeType(status, "object") && status ? status.status : status;
-	return cloudflareStatusMap[String(value || "").toLowerCase()] || "unknown";
-}
-function hasUnknownWorkflowAcknowledgement(error) {
-	if (!error || !hasRuntimeType(error, "object")) return false;
-	const details = error.details;
-	return Boolean(details && hasRuntimeType(details, "object") && details.acknowledgement === "unknown");
-}
-function createCloudflareAdapter(config) {
-	return {
-		cancel: () => unsupportedOperation("cloudflare", "cancellation"),
-		async get({ event, id, name }) {
-			const binding = resolveCloudflareInspectionBinding(event, config.binding, name);
-			if (binding) {
-				const instance = await runWorkflowProviderOperation("cloudflare", "get", () => binding.get(id));
-				const metadata = await runWorkflowProviderOperation("cloudflare", "status", () => instance.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, definition);
-			if (binding) {
-				const start = () => runWorkflowProviderOperation("cloudflare", "create", async () => (await binding.createBatch([{
-					id,
-					params: payload
-				}]))[0] || await binding.get(id), { acknowledgementUnknown: (_error, status) => status === void 0 });
-				const creation = start().catch(async (firstError) => {
-					try {
-						return await start();
-					} catch (retryError) {
-						if (hasUnknownWorkflowAcknowledgement(firstError)) throw firstError;
-						throw retryError;
-					}
-				});
-				const waitUntil = options.deferred ? resolveWaitUntil(event) : void 0;
-				if (waitUntil) waitUntil(creation);
-				return {
-					id: (await creation).id,
-					payload,
-					provider: "cloudflare",
-					status: "queued"
-				};
-			}
-			return await inlineAdapter(config).run({
-				definition,
-				event,
-				id,
-				name,
-				options,
-				payload
-			});
-		},
-		resume: () => unsupportedOperation("cloudflare", "signals")
-	};
-}
-function createOpenWorkflowAdapter(config) {
-	return {
-		cancel: () => unsupportedOperation("openworkflow", "cancellation"),
-		get: async ({ id, name }) => await getOpenWorkflowRun(config, name, id),
-		resume: () => unsupportedOperation("openworkflow", "signals"),
-		run: async ({ definition, name, options, payload }) => await runOpenWorkflow(config, name, payload, definition, options)
-	};
-}
-function inlineAdapter(config) {
-	return {
-		cancel: () => unsupportedOperation(config.provider, "cancellation"),
-		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
-				};
-			}
-			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 waitUntil = resolveWaitUntil(event);
-			if (waitUntil) waitUntil(runState.promise);
-			return {
-				id,
-				metadata: config.provider === "vercel" ? {
-					mode: "inline",
-					workflow: getVercelWorkflowName(name)
-				} : void 0,
-				payload,
-				provider: config.provider,
-				status: "queued"
-			};
-		},
-		resume: () => unsupportedOperation(config.provider, "signals")
-	};
-}
-function createVercelAdapter(config) {
-	const fallback = inlineAdapter(config);
-	return {
-		async cancel({ id, name }) {
-			const definition = await loadWorkflowDefinition(name);
-			if (!definition?.options?.native) return await fallback.cancel({
-				event: void 0,
-				id,
-				name
-			});
-			return await cancelVercelWorkflow(name, definition, id);
-		},
-		async get({ id, name }) {
-			const definition = await loadWorkflowDefinition(name);
-			return definition?.options?.native ? await inspectVercelWorkflowRun(name, definition, id) : await fallback.get({
-				event: void 0,
-				id,
-				name
-			});
-		},
-		resume: async (token, payload) => await resumeVercelWorkflowSignal(token, payload),
-		async run({ definition, event, id, name, options, payload }) {
-			if (!definition.options?.native) return await fallback.run({
-				definition,
-				event,
-				id,
-				name,
-				options,
-				payload
-			});
-			if (options.id) throw createWorkflowError({
-				code: "WORKFLOW_RUN_ID_UNSUPPORTED",
-				details: {
-					...safeWorkflowName(name) ? { name } : {},
-					provider: "vercel"
-				}
-			});
-			return await startVercelWorkflow(name, definition, payload, resolveSettlementObserver(event));
-		}
-	};
-}
-function getWorkflowRuntimeAdapter(config) {
-	if (config.provider === "cloudflare") return createCloudflareAdapter(config);
-	if (config.provider === "openworkflow") return createOpenWorkflowAdapter(config);
-	return createVercelAdapter(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 createWorkflowError({
-		code: "WORKFLOW_DEFINITION_NOT_FOUND",
-		details: safeWorkflowName(name) ? { name } : void 0
-	});
-	return definition;
-}
-function normalizeWorkflowRunIdValue(value) {
-	if (value === void 0) return null;
-	if (value === null || !hasRuntimeType(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 (hasRuntimeType(nameOrOptions, "object") && nameOrOptions !== null) {
-		const createOptions = nameOrOptions;
-		const { handler, name } = createOptions;
-		if (!name || !hasRuntimeType(name, "string")) throw new TypeError("`createWorkflow()` requires a workflow name.");
-		if (!hasRuntimeType(handler, "function")) throw new TypeError("`createWorkflow()` requires a workflow handler.");
-		registerInlineWorkflowDefinition(name, {
-			handler,
-			...createOptions.rootStep === void 0 ? {} : { options: { rootStep: createOptions.rootStep } }
-		});
-		return {
-			cancel: (id) => cancelWorkflow(name, id),
-			name,
-			defer: async (payload, options = {}) => deferWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options)),
-			getRun: (id) => getWorkflowRun(name, id),
-			async run(payload, options = {}) {
-				return await runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options));
-			}
-		};
-	}
-	const name = nameOrOptions;
-	if (!name || !hasRuntimeType(name, "string")) throw new TypeError("`createWorkflow()` requires a workflow name.");
-	const handler = hasRuntimeType(handlerOrOptions, "function") ? handlerOrOptions : hasRuntimeType(handlerOrOptions, "object") && handlerOrOptions !== null ? handlerOrOptions.handler : void 0;
-	const createOptions = hasRuntimeType(handlerOrOptions, "function") ? options : handlerOrOptions;
-	if (handler !== void 0) {
-		if (!hasRuntimeType(handler, "function")) throw new TypeError("`createWorkflow()` requires a workflow handler.");
-		registerInlineWorkflowDefinition(name, {
-			handler,
-			...createOptions?.rootStep === void 0 ? {} : { options: { rootStep: createOptions.rootStep } }
-		});
-	} else if (handlerOrOptions !== void 0 && (!hasRuntimeType(handlerOrOptions, "object") || handlerOrOptions === null)) throw new TypeError("`createWorkflow()` options must be an object.");
-	return {
-		cancel: (id) => cancelWorkflow(name, id),
-		name,
-		defer: async (payload, options = {}) => deferWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options)),
-		getRun: (id) => getWorkflowRun(name, id),
-		async run(payload, options = {}) {
-			return await runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options));
-		}
-	};
-}
-async function runWorkflow(name, payload, options = {}) {
-	const config = getActiveWorkflowConfig();
-	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
-	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 createWorkflowError({ code: "WORKFLOW_DISABLED" });
-	return await getWorkflowRuntimeAdapter(config).get({
-		event: getWorkflowRuntimeEvent(),
-		id,
-		name
-	});
-}
-async function cancelWorkflow(name, id) {
-	const config = getActiveWorkflowConfig();
-	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
-	await loadRequiredWorkflowDefinition(name);
-	return await getWorkflowRuntimeAdapter(config).cancel({
-		event: getWorkflowRuntimeEvent(),
-		id,
-		name
-	});
-}
-async function resumeWorkflowSignal(token, payload) {
-	if (!token || !hasRuntimeType(token, "string")) throw new TypeError("`resumeWorkflowSignal()` requires an opaque signal token.");
-	const config = getActiveWorkflowConfig();
-	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
-	return await getWorkflowRuntimeAdapter(config).resume(token, payload);
-}
-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();
+	if (request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === "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") {
+	if (hasSchemaMethod(schema, "safeParse") && typeof schema.safeParse === "function") {
 		const result = schema.safeParse(payload);
-		if (!result.success) throw result.error || /* @__PURE__ */ new TypeError("Invalid workflow payload.");
+		if (!result.success) throw result.error || workflowErrorDiagnostics.WORKFLOW_R0021({ message: "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.");
+	if (hasSchemaMethod(schema, "parse") && typeof schema.parse === "function") return schema.parse(payload);
+	throw workflowErrorDiagnostics.WORKFLOW_R0022({ message: "Invalid workflow payload schema." });
+}
+function hasSchemaMethod(value, key) {
+	if (Object.hasOwn(value, key)) return true;
+	let prototype = Object.getPrototypeOf(value);
+	while (prototype !== null) {
+		if (Object.hasOwn(prototype, key)) {
+			const constructor = Object.hasOwn(prototype, "constructor") ? prototype.constructor : void 0;
+			return typeof constructor === "function" && constructor.prototype === prototype && Function.prototype.toString.call(constructor) !== Function.prototype.toString.call(Object);
+		}
+		prototype = Object.getPrototypeOf(prototype);
+	}
+	return false;
 }
 async function readValidatedPayload(request, schema) {
 	return await validatePayload(await readRequestPayload(request), schema);

package/dist/inspect-B72iFyj-.js

@@ -0,0 +1,70 @@
+import { relative } from "pathe";
+//#region ../internal/src/inspect.ts
+function relativeDefinitionFile(projectRoot, file) {
+	return relative(projectRoot, file).replaceAll("\\", "/");
+}
+const redactedInspectionValue = "[redacted]";
+const secretKeyPattern = /secret|token|passw(?:or)?d|credential|api[-_\s]?key|private[-_\s]?key|authorization|cookie|signature|dsn|connection[-_\s]?string/i;
+const secretValuePattern = /^(?:[a-z][a-z0-9+.-]*:\/\/[^/\s?#]*@|bearer\s)/i;
+/** Whether an inspection field names a credential, regardless of its value. */
+function isSecretInspectionKey(key) {
+	return secretKeyPattern.test(key);
+}
+const embeddedUrlCredentialPattern = /\b([a-z][a-z0-9+.-]*:\/\/)[^/\s?#]*@/gi;
+const embeddedCookiePattern = /\b([\w-]*cookie[\w-]*["']?\s*[:=]\s*)(?:"(?:\\[^\r\n]|[^"\\\r\n])*"(?:\s*;\s*[\w.-]+\s*=[^;\r\n]*)*|'(?:\\[^\r\n]|[^'\\\r\n])*'(?:\s*;\s*[\w.-]+\s*=[^;\r\n]*)*|[^\r\n]+?(?=\s*(?:;\s*[^;=\r\n/]+\s*(?:\r?\n|$)|&|\r?\n|$)))/gi;
+const embeddedBearerPattern = /\bbearer\s+[^\s,;]+/gi;
+const embeddedAuthorizationPattern = new RegExp(String.raw`\b([\w-]*authorization[\w-]*["']?\s*[:=]\s*)(?!\[redacted\](?=$|[\s,;}&]))(?:"(?:\\[^\r\n]|[^"\\\r\n])*"|'(?:\\[^\r\n]|[^'\\\r\n])*'|[^\r\n]+?(?=\s*(?:[,;])?\s*(?:${secretKeyPattern.source})[\w-]*\s*[:=]|\s+rejected\b|$))`, "gi");
+const embeddedSecretAssignmentPattern = new RegExp(String.raw`\b([\w-]*(?:${secretKeyPattern.source})[\w-]*["']?\s*[:=]\s*)(?!\[redacted\](?=$|[\s,;}&]))(?:"(?:\\[^\r\n]|[^"\\\r\n])*"|'(?:\\[^\r\n]|[^'\\\r\n])*'|[^\s,;&#&]+)`, "gi");
+/**
+* Removes credentials inside free text, for example an error message. URL credentials, bearer tokens, and
+* `name=value` pairs with a secret name are replaced with `[redacted]`.
+*/
+function redactInspectionText(value) {
+	return value.replace(embeddedUrlCredentialPattern, `$1${redactedInspectionValue}@`).replace(embeddedAuthorizationPattern, `$1${redactedInspectionValue}`).replace(embeddedCookiePattern, `$1${redactedInspectionValue}`).replace(embeddedBearerPattern, `Bearer ${redactedInspectionValue}`).replace(embeddedSecretAssignmentPattern, `$1${redactedInspectionValue}`);
+}
+/**
+* Removes values that can carry credentials before inspection output leaves the process.
+* Keys that name secrets, plaintext Worker `vars`, and URLs with embedded credentials are redacted.
+*/
+function redactInspectionValue(value, key) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	let remaining = 1e3;
+	function visit(entry, entryKey, depth = 0) {
+		if (entryKey && isSecretInspectionKey(entryKey)) return redactedInspectionValue;
+		if (--remaining < 0 || depth > 10) return "[truncated]";
+		if (typeof entry === "string") {
+			const text = entry.slice(0, 1e4);
+			return secretValuePattern.test(text) ? redactedInspectionValue : redactInspectionText(text);
+		}
+		if (typeof entry === "bigint") return entry.toString();
+		if (typeof entry === "number") return Number.isFinite(entry) ? entry : String(entry);
+		if (entry === null || typeof entry === "boolean") return entry;
+		if (typeof entry !== "object") return entry === void 0 ? null : "[unsupported]";
+		if (seen.has(entry)) return "[circular]";
+		seen.add(entry);
+		try {
+			let dateTime;
+			try {
+				dateTime = Date.prototype.getTime.call(entry);
+			} catch {}
+			if (dateTime !== void 0) return Number.isNaN(dateTime) ? "Invalid Date" : Date.prototype.toISOString.call(entry);
+			if (Array.isArray(entry)) return entry.slice(0, 100).map((item) => visit(item, void 0, depth + 1));
+			let setValues;
+			try {
+				setValues = [...Set.prototype.values.call(entry)];
+			} catch {}
+			if (setValues) return setValues.slice(0, 100).map((item) => visit(item, void 0, depth + 1));
+			let mapEntries;
+			try {
+				mapEntries = [...Map.prototype.entries.call(entry)];
+			} catch {}
+			const entries = mapEntries ? mapEntries.map(([name, item]) => [String(name), item]) : Object.entries(entry);
+			return Object.fromEntries(entries.slice(0, 100).map(([name, item]) => [name, name === "vars" && item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).slice(0, 100).map((variable) => [variable, redactedInspectionValue])) : visit(item, name, depth + 1)]));
+		} finally {
+			seen.delete(entry);
+		}
+	}
+	return visit(value, key);
+}
+//#endregion
+export { redactInspectionValue as n, relativeDefinitionFile as r, redactInspectionText as t };