@vite-hub/workflow 0.0.0 → 0.0.2

package/dist/types-BUlYBZwH.d.ts

@@ -0,0 +1,163 @@
+//#region src/types.d.ts
+type WorkflowProvider = "cloudflare" | "openworkflow" | "vercel";
+interface CloudflareWorkflowBinding<TPayload = unknown> {
+  create: (options?: {
+    id?: string;
+    params?: TPayload;
+  }) => Promise<CloudflareWorkflowInstance>;
+  get: (id: string) => Promise<CloudflareWorkflowInstance>;
+}
+interface CloudflareWorkflowInstance {
+  id: string;
+  status: () => Promise<unknown>;
+}
+interface WorkflowSharedOptions {
+  binding?: string;
+  name?: string;
+}
+interface CloudflareWorkflowProviderOptions extends WorkflowSharedOptions {
+  provider: "cloudflare";
+}
+interface VercelWorkflowProviderOptions extends WorkflowSharedOptions {
+  provider: "vercel";
+}
+interface OpenWorkflowPostgresOptions {
+  namespaceId?: string;
+  runMigrations?: boolean;
+  schema?: string;
+  url?: WorkflowRuntimeConfigValue;
+}
+interface WorkflowRuntimeEnvDeclarationLike {
+  default?: unknown;
+  kind: "env-variable";
+  source?: {
+    kind: "env";
+    name: string;
+    names?: string[];
+  };
+}
+type WorkflowRuntimeConfigValue = string | WorkflowRuntimeEnvDeclarationLike;
+interface OpenWorkflowSqliteOptions {
+  namespaceId?: string;
+  path?: WorkflowRuntimeConfigValue;
+  runMigrations?: boolean;
+}
+interface OpenWorkflowWorkerOptions {
+  concurrency?: number;
+}
+interface OpenWorkflowProviderOptions extends WorkflowSharedOptions {
+  database?: string;
+  postgres?: OpenWorkflowPostgresOptions;
+  provider: "openworkflow";
+  sqlite?: OpenWorkflowSqliteOptions;
+  worker?: OpenWorkflowWorkerOptions;
+}
+interface InferredWorkflowProviderOptions extends WorkflowSharedOptions {
+  database?: string;
+  postgres?: OpenWorkflowPostgresOptions;
+  provider?: undefined;
+  sqlite?: OpenWorkflowSqliteOptions;
+  worker?: OpenWorkflowWorkerOptions;
+}
+type WorkflowProviderOptions = CloudflareWorkflowProviderOptions | OpenWorkflowProviderOptions | VercelWorkflowProviderOptions;
+type WorkflowModuleProviderOptions = InferredWorkflowProviderOptions | WorkflowProviderOptions;
+type WorkflowModuleOptions = false | WorkflowModuleProviderOptions;
+type ResolvedWorkflowOptions = WorkflowProviderOptions;
+interface WorkflowRun<TPayload = unknown, TResult = unknown> {
+  completedAt?: Date;
+  createdAt?: Date;
+  id: string;
+  provider: WorkflowProvider;
+  result?: TResult;
+  startedAt?: Date;
+  status: WorkflowRunStatus;
+  steps?: WorkflowRunStep[];
+  metadata?: unknown;
+  payload?: TPayload;
+}
+type WorkflowRunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "unknown";
+interface WorkflowRunStep {
+  attempt: number;
+  completedAt?: Date;
+  error?: {
+    code?: string;
+    message: string;
+  };
+  id: string;
+  name: string;
+  startedAt?: Date;
+  status: WorkflowRunStatus;
+}
+interface WorkflowStepOptions {
+  retries?: {
+    backoff?: string;
+    delay?: string;
+    limit?: number;
+  };
+}
+type WorkflowStepFunction<TInput = unknown, TResult = unknown> = (input: TInput) => TResult | Promise<TResult>;
+interface WorkflowProviderStep {
+  do?: <TResult>(name: string, options: WorkflowStepOptions, run: () => TResult | Promise<TResult>) => Promise<TResult>;
+}
+type WorkflowStepRunner<TSteps extends Record<string, WorkflowStepFunction> = Record<string, WorkflowStepFunction>> = { [TName in keyof TSteps]: TSteps[TName] };
+interface WorkflowExecutionContext<TPayload = unknown> {
+  id?: string;
+  name: string;
+  payload: TPayload;
+  provider: WorkflowProvider;
+  step?: WorkflowProviderStep;
+  steps?: WorkflowStepRunner;
+}
+type WorkflowHandler<TPayload = unknown, TResult = unknown> = (context: WorkflowExecutionContext<TPayload>) => TResult | Promise<TResult>;
+type WorkflowRunIdValue = boolean | null | number | string | undefined | {
+  readonly [key: string]: WorkflowRunIdValue;
+} | readonly WorkflowRunIdValue[];
+interface WorkflowCreateOptions<TPayload = unknown, TResult = unknown> {
+  handler?: WorkflowHandler<TPayload, TResult>;
+  id?: (context: {
+    name: string;
+    payload?: TPayload;
+  }) => Promise<WorkflowRunIdValue> | WorkflowRunIdValue;
+  name?: string;
+}
+interface WorkflowDefinitionOptions<TPayload = unknown, TResult = unknown> {
+  id?: string;
+  native?: WorkflowHandler<TPayload, TResult>;
+  rootStep?: boolean;
+}
+interface WorkflowDefinition<TPayload = unknown, TResult = unknown> {
+  handler: WorkflowHandler<TPayload, TResult>;
+  options?: WorkflowDefinitionOptions<TPayload, TResult>;
+}
+interface WorkflowHandle<TPayload = unknown, TResult = unknown> {
+  cancel: (id: string) => Promise<WorkflowRun<TPayload, TResult>>;
+  defer: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload>>;
+  getRun: (id: string) => Promise<WorkflowRun<TPayload, TResult>>;
+  name: string;
+  run: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload, TResult>>;
+}
+interface WorkflowStartOptions {
+  id?: string;
+}
+interface WorkflowDeferOptions extends WorkflowStartOptions {
+  deferred?: boolean;
+}
+interface WorkflowSignalResult {
+  id: string;
+  provider: WorkflowProvider;
+}
+interface WorkflowDefinitionRegistry {
+  [name: string]: () => Promise<{
+    default?: WorkflowDefinition;
+    [exportName: string]: unknown;
+  } | WorkflowDefinition>;
+}
+interface DiscoveredWorkflowDefinition {
+  agentIdentity?: string;
+  handler: string;
+  name: string;
+  source?: "agent-workflow" | "inline" | "server-workflows" | "vite-suffix";
+  steps?: string[];
+}
+//#endregion
+export { WorkflowStepFunction as A, WorkflowProviderStep as C, WorkflowSharedOptions as D, WorkflowRunStep as E, WorkflowStepRunner as M, WorkflowSignalResult as O, WorkflowProviderOptions as S, WorkflowRunStatus as T, WorkflowHandle as _, InferredWorkflowProviderOptions as a, WorkflowModuleProviderOptions as b, OpenWorkflowWorkerOptions as c, WorkflowCreateOptions as d, WorkflowDeferOptions as f, WorkflowExecutionContext as g, WorkflowDefinitionRegistry as h, DiscoveredWorkflowDefinition as i, WorkflowStepOptions as j, WorkflowStartOptions as k, ResolvedWorkflowOptions as l, WorkflowDefinitionOptions as m, CloudflareWorkflowInstance as n, OpenWorkflowPostgresOptions as o, WorkflowDefinition as p, CloudflareWorkflowProviderOptions as r, OpenWorkflowProviderOptions as s, CloudflareWorkflowBinding as t, VercelWorkflowProviderOptions as u, WorkflowHandler as v, WorkflowRun as w, WorkflowProvider as x, WorkflowModuleOptions as y };

package/dist/vercel-D2_J5D_Y.js

@@ -0,0 +1,217 @@
+import { i as createWorkflowError, n as runWorkflowProviderOperation, r as safeWorkflowName, t as isWorkflowBoundaryError } from "./provider-operation-CWIV4k42.js";
+//#region src/runtime/vercel.ts
+async function loadVercelWorkflowRuntime() {
+	const importVercelWorkflow = new Function("specifier", "return import(specifier)");
+	const [api, runtime] = await Promise.all([importVercelWorkflow("workflow/api"), importVercelWorkflow("workflow/runtime")]);
+	return createVercelWorkflowRuntime(api, runtime);
+}
+function createVercelWorkflowRuntime(api, runtime) {
+	const { getRun, resumeHook, start } = api;
+	const { getWorld } = runtime;
+	return {
+		getRun,
+		async listSteps(id) {
+			const steps = [];
+			let cursor;
+			do {
+				const page = await (await getWorld()).steps.list({
+					pagination: {
+						cursor,
+						limit: 1e3,
+						sortOrder: "asc"
+					},
+					resolveData: "none",
+					runId: id
+				});
+				steps.push(...page.data);
+				cursor = page.hasMore && page.cursor ? page.cursor : void 0;
+			} while (cursor);
+			return steps;
+		},
+		resumeHook,
+		start
+	};
+}
+let runtimeLoader = loadVercelWorkflowRuntime;
+function setVercelWorkflowRuntimeModules(api, runtime) {
+	runtimeLoader = async () => createVercelWorkflowRuntime(api, runtime);
+}
+async function getVercelWorkflowRuntime() {
+	try {
+		return await runtimeLoader();
+	} catch (error) {
+		if (isWorkflowBoundaryError(error)) throw error;
+		throw createWorkflowError({
+			cause: error,
+			code: "VERCEL_WORKFLOW_SDK_LOAD_FAILED",
+			details: { provider: "vercel" }
+		});
+	}
+}
+const statusMap = {
+	cancelled: "cancelled",
+	completed: "completed",
+	failed: "failed",
+	pending: "queued",
+	running: "running"
+};
+function invalidVercelResult(field) {
+	return /* @__PURE__ */ new TypeError(`Vercel Workflow provider returned an invalid ${field}.`);
+}
+function normalizeStatus(status) {
+	if (typeof status !== "string") throw invalidVercelResult("status");
+	return statusMap[status.toLowerCase()] || "unknown";
+}
+function normalizeRunId(id) {
+	if (typeof id !== "string" || !id) throw invalidVercelResult("run ID");
+	return id;
+}
+function normalizeDate(value, field) {
+	if (value === void 0) return void 0;
+	if (!(value instanceof Date) || !Number.isFinite(value.getTime())) throw invalidVercelResult(field);
+	return value;
+}
+function normalizeStepError(error) {
+	if (error === void 0 || error === null) return void 0;
+	if (error instanceof Error) return { message: error.message };
+	if (typeof error === "string") try {
+		return normalizeStepError(JSON.parse(error)) || { message: error };
+	} catch {
+		return { message: error };
+	}
+	if (typeof error === "object") {
+		const value = error;
+		if (typeof value.message === "string") return {
+			...typeof value.code === "string" ? { code: value.code } : {},
+			message: value.message
+		};
+		if (value.error !== void 0) return normalizeStepError(value.error);
+	}
+	return { message: "Workflow step failed." };
+}
+function normalizeSteps(steps) {
+	if (!Array.isArray(steps)) throw invalidVercelResult("step list");
+	return steps.map((step) => {
+		if (typeof step !== "object" || step === null) throw invalidVercelResult("step");
+		const value = step;
+		if (typeof value.attempt !== "number" || !Number.isFinite(value.attempt)) throw invalidVercelResult("step attempt");
+		if (typeof value.stepId !== "string" || !value.stepId) throw invalidVercelResult("step ID");
+		if (typeof value.stepName !== "string" || !value.stepName) throw invalidVercelResult("step name");
+		return {
+			attempt: value.attempt,
+			completedAt: normalizeDate(value.completedAt, "step completion date"),
+			error: normalizeStepError(value.error),
+			id: value.stepId,
+			name: value.stepName,
+			startedAt: normalizeDate(value.startedAt, "step start date"),
+			status: normalizeStatus(value.status)
+		};
+	});
+}
+async function readRunIdentity(run) {
+	const exists = await run.exists;
+	if (typeof exists !== "boolean") throw invalidVercelResult("existence state");
+	if (!exists) return { exists };
+	const workflowName = await run.workflowName;
+	if (typeof workflowName !== "string") throw invalidVercelResult("workflow name");
+	return {
+		exists,
+		workflowName
+	};
+}
+function getNativeWorkflowName(name, definition) {
+	const workflowName = (definition.options?.native)?.workflowId;
+	if (!workflowName) throw createWorkflowError({
+		code: "WORKFLOW_NATIVE_ENTRY_INVALID",
+		details: {
+			...safeWorkflowName(name) ? { name } : {},
+			provider: "vercel"
+		}
+	});
+	return workflowName;
+}
+async function inspectVercelWorkflowRun(name, definition, id, payload) {
+	const runtime = await getVercelWorkflowRuntime();
+	const run = await runWorkflowProviderOperation("vercel", "get-run", () => runtime.getRun(id));
+	const identity = await runWorkflowProviderOperation("vercel", "get-run", () => readRunIdentity(run));
+	if (!identity.exists || identity.workflowName !== getNativeWorkflowName(name, definition)) return {
+		id,
+		provider: "vercel",
+		status: "unknown"
+	};
+	const [snapshot, steps] = await Promise.all([runWorkflowProviderOperation("vercel", "get-run", async () => {
+		const [status, createdAt, startedAt, completedAt] = await Promise.all([
+			run.status,
+			run.createdAt,
+			run.startedAt,
+			run.completedAt
+		]);
+		return {
+			completedAt: normalizeDate(completedAt, "completion date"),
+			createdAt: normalizeDate(createdAt, "creation date"),
+			startedAt: normalizeDate(startedAt, "start date"),
+			status: normalizeStatus(status)
+		};
+	}), runWorkflowProviderOperation("vercel", "list-steps", async () => normalizeSteps(await runtime.listSteps(id)))]);
+	const result = snapshot.status === "completed" ? await runWorkflowProviderOperation("vercel", "get-run", () => run.returnValue) : void 0;
+	return {
+		completedAt: snapshot.completedAt,
+		createdAt: snapshot.createdAt,
+		id,
+		metadata: { workflow: name },
+		payload,
+		provider: "vercel",
+		result,
+		startedAt: snapshot.startedAt,
+		status: snapshot.status,
+		steps
+	};
+}
+async function startVercelWorkflow(name, definition, payload) {
+	const native = definition.options?.native;
+	if (!native) throw createWorkflowError({
+		code: "WORKFLOW_NATIVE_ENTRY_REQUIRED",
+		details: {
+			...safeWorkflowName(name) ? { name } : {},
+			provider: "vercel"
+		}
+	});
+	const context = {
+		name,
+		payload,
+		provider: "vercel"
+	};
+	const runtime = await getVercelWorkflowRuntime();
+	return {
+		id: await runWorkflowProviderOperation("vercel", "start", async () => {
+			return normalizeRunId((await runtime.start(native, [context])).runId);
+		}),
+		metadata: { workflow: name },
+		payload,
+		provider: "vercel",
+		status: "queued"
+	};
+}
+async function cancelVercelWorkflow(name, definition, id) {
+	const runtime = await getVercelWorkflowRuntime();
+	const run = await runWorkflowProviderOperation("vercel", "get-run", () => runtime.getRun(id));
+	const identity = await runWorkflowProviderOperation("vercel", "get-run", () => readRunIdentity(run));
+	if (!identity.exists || identity.workflowName !== getNativeWorkflowName(name, definition)) return {
+		id,
+		provider: "vercel",
+		status: "unknown"
+	};
+	await runWorkflowProviderOperation("vercel", "cancel", () => run.cancel());
+	return await inspectVercelWorkflowRun(name, definition, id);
+}
+async function resumeVercelWorkflowSignal(token, payload) {
+	const runtime = await getVercelWorkflowRuntime();
+	return {
+		id: await runWorkflowProviderOperation("vercel", "resume-signal", async () => {
+			return normalizeRunId((await runtime.resumeHook(token, payload)).runId);
+		}),
+		provider: "vercel"
+	};
+}
+//#endregion
+export { startVercelWorkflow as a, setVercelWorkflowRuntimeModules as i, inspectVercelWorkflowRun as n, resumeVercelWorkflowSignal as r, cancelVercelWorkflow as t };

package/dist/vite.d.ts

@@ -0,0 +1,13 @@
+import { y as WorkflowModuleOptions } from "./types-BUlYBZwH.js";
+import { Plugin } from "vite";
+
+//#region src/vite.d.ts
+type WorkflowVitePlugin = Plugin;
+declare function hubWorkflow(options?: WorkflowModuleOptions): WorkflowVitePlugin;
+declare module "vite" {
+  interface UserConfig {
+    workflow?: WorkflowModuleOptions;
+  }
+}
+//#endregion
+export { WorkflowVitePlugin, hubWorkflow };