@lunora/workflow 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/WorkflowsRestError-b06i7K5j.mjs

@@ -0,0 +1,118 @@
+const API_BASE = "https://api.cloudflare.com/client/v4/accounts";
+const KNOWN_STATUSES = {
+  complete: true,
+  errored: true,
+  paused: true,
+  queued: true,
+  running: true,
+  terminated: true,
+  unknown: true,
+  waiting: true,
+  waitingForPause: true
+};
+const toStatus = (value) => typeof value === "string" && Object.hasOwn(KNOWN_STATUSES, value) ? value : "unknown";
+const asString = (value) => typeof value === "string" && value !== "" ? value : void 0;
+const stringOr = (value, fallback) => typeof value === "string" ? value : fallback;
+const asBoolean = (value) => typeof value === "boolean" ? value : void 0;
+const countAttempts = (value) => {
+  if (Array.isArray(value)) {
+    return value.length;
+  }
+  return typeof value === "number" ? value : void 0;
+};
+const toSummary = (raw) => {
+  return {
+    createdOn: asString(raw["created_on"]),
+    endedOn: asString(raw["ended_on"]),
+    id: stringOr(raw["id"], ""),
+    startedOn: asString(raw["started_on"]),
+    status: toStatus(raw["status"])
+  };
+};
+const toStep = (raw) => {
+  return {
+    attempts: countAttempts(raw["attempts"]),
+    end: asString(raw["end"]),
+    error: raw["error"],
+    name: stringOr(raw["name"], ""),
+    output: raw["output"],
+    start: asString(raw["start"]),
+    success: asBoolean(raw["success"]),
+    type: asString(raw["type"])
+  };
+};
+class WorkflowsRestError extends Error {
+  status;
+  constructor(status, body) {
+    super(`Cloudflare Workflows REST API returned ${String(status)}: ${body}`);
+    this.name = "WorkflowsRestError";
+    this.status = status;
+  }
+}
+const createWorkflowsRestClient = (config) => {
+  const fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+  const base = `${API_BASE}/${config.accountId}/workflows`;
+  const request = async (path, init) => {
+    const response = await fetchImpl(`${base}${path}`, {
+      ...init,
+      headers: { Authorization: `Bearer ${config.apiToken}`, "Content-Type": "application/json" }
+    });
+    const text = await response.text();
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new WorkflowsRestError(response.status, text);
+    }
+    if (!response.ok || body["success"] === false) {
+      throw new WorkflowsRestError(response.status, text);
+    }
+    return body;
+  };
+  return {
+    getInstance: async ({ instanceId, workflowName }) => {
+      const body = await request(`/${encodeURIComponent(workflowName)}/instances/${encodeURIComponent(instanceId)}`);
+      const result = body["result"] ?? {};
+      const steps = Array.isArray(result["steps"]) ? result["steps"] : [];
+      return {
+        ...toSummary(result),
+        error: result["error"],
+        output: result["output"],
+        params: result["params"],
+        steps: steps.map((step) => toStep(step))
+      };
+    },
+    listInstances: async ({ page, perPage, status, workflowName }) => {
+      const query = new URLSearchParams();
+      if (status !== void 0) {
+        query.set("status", status);
+      }
+      if (page !== void 0) {
+        query.set("page", String(page));
+      }
+      if (perPage !== void 0) {
+        query.set("per_page", String(perPage));
+      }
+      const suffix = query.toString() === "" ? "" : `?${query.toString()}`;
+      const body = await request(`/${encodeURIComponent(workflowName)}/instances${suffix}`);
+      const result = Array.isArray(body["result"]) ? body["result"] : [];
+      const info = body["result_info"] ?? {};
+      return {
+        instances: result.map((instance) => toSummary(instance)),
+        page: typeof info["page"] === "number" ? info["page"] : page ?? 1,
+        perPage: typeof info["per_page"] === "number" ? info["per_page"] : perPage ?? result.length,
+        totalCount: typeof info["total_count"] === "number" ? info["total_count"] : void 0
+      };
+    },
+    setInstanceStatus: async ({ action, instanceId, workflowName }) => {
+      const body = await request(`/${encodeURIComponent(workflowName)}/instances/${encodeURIComponent(instanceId)}`, {
+        body: JSON.stringify({ status: action }),
+        method: "PATCH"
+      });
+      const result = body["result"] ?? {};
+      return { status: toStatus(result["status"]) };
+    }
+  };
+};
+
+export { WorkflowsRestError, createWorkflowsRestClient };

package/dist/packem_shared/convertNonRetryableError-Dn2dTyBS.mjs

@@ -0,0 +1,27 @@
+const NON_RETRYABLE_BRAND = "__lunoraNonRetryable";
+class NonRetryableError extends Error {
+  constructor(message, name = "NonRetryableError") {
+    super(message);
+    this.name = name;
+    this[NON_RETRYABLE_BRAND] = true;
+  }
+}
+const isNonRetryableError = (value) => value instanceof Error && value[NON_RETRYABLE_BRAND] === true;
+const toNativeNonRetryableError = (error, NativeNonRetryableError) => {
+  const native = new NativeNonRetryableError(error.message, error.name);
+  if (error.stack !== void 0) {
+    native.stack = error.stack;
+  }
+  if (error.cause !== void 0 && native.cause === void 0) {
+    native.cause = error.cause;
+  }
+  return native;
+};
+const convertNonRetryableError = (error, NativeNonRetryableError) => {
+  if (NativeNonRetryableError !== void 0 && isNonRetryableError(error)) {
+    throw toNativeNonRetryableError(error, NativeNonRetryableError);
+  }
+  throw error;
+};
+
+export { NonRetryableError, convertNonRetryableError, isNonRetryableError, toNativeNonRetryableError };

package/dist/packem_shared/createRunStep-BsK4LsUX.mjs

@@ -0,0 +1,54 @@
+import { parseValidatorMap } from '@lunora/values';
+import { convertNonRetryableError, NonRetryableError } from './convertNonRetryableError-Dn2dTyBS.mjs';
+
+const validateStepArgs = (validators, source) => parseValidatorMap(validators, source, "step args");
+const createRunStep = (deps) => async (step, args, options) => {
+  const config = options?.config ?? step.config;
+  const validatedArgs = validateStepArgs(step.args, args);
+  const callback = async (nativeContext) => {
+    const stepContext = {
+      attempt: nativeContext.attempt,
+      config: nativeContext.config,
+      env: deps.env,
+      log: deps.log,
+      run: deps.run,
+      step: nativeContext.step
+    };
+    let result;
+    try {
+      result = await step.handler(stepContext, validatedArgs);
+    } catch (error) {
+      return convertNonRetryableError(error, deps.nonRetryableErrorClass);
+    }
+    if (!step.returns) {
+      return result;
+    }
+    try {
+      return step.returns.parse(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const nonRetryable = new NonRetryableError(`step "${step.name}" returns validation failed: ${message}`);
+      if (error !== void 0) {
+        nonRetryable.cause = error;
+      }
+      return convertNonRetryableError(nonRetryable, deps.nonRetryableErrorClass);
+    }
+  };
+  const rollbackHandler = step.rollback;
+  const rollbackOptions = rollbackHandler ? {
+    rollback: async (rollbackContext) => {
+      await rollbackHandler({
+        args: validatedArgs,
+        env: deps.env,
+        error: rollbackContext.error,
+        log: deps.log,
+        output: rollbackContext.output,
+        run: deps.run
+      });
+    },
+    rollbackConfig: step.rollbackConfig
+  } : void 0;
+  return config === void 0 ? deps.step.do(step.name, callback, rollbackOptions) : deps.step.do(step.name, config, callback, rollbackOptions);
+};
+
+export { createRunStep, validateStepArgs };

package/dist/packem_shared/createWorkflowContext-D6thzmlF.mjs

@@ -0,0 +1,14 @@
+import createWorkflows from './createWorkflows-BoSYVIXg.mjs';
+
+const createWorkflowContext = (env, specs) => {
+  const bindings = {};
+  for (const spec of specs) {
+    const binding = env[spec.binding];
+    if (binding && typeof binding.create === "function" && typeof binding.createBatch === "function" && typeof binding.get === "function") {
+      bindings[spec.exportName] = binding;
+    }
+  }
+  return createWorkflows({ bindings });
+};
+
+export { createWorkflowContext };

package/dist/packem_shared/createWorkflowLogger-FktqxNLe.mjs

@@ -0,0 +1,76 @@
+import { createRunStep } from './createRunStep-BsK4LsUX.mjs';
+
+const trimTrailingSlashes = (value) => {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") {
+    end -= 1;
+  }
+  return value.slice(0, end);
+};
+const createWorkflowRunner = (options) => {
+  const globalFetch = globalThis.fetch;
+  const fetchImpl = options.fetchImpl ?? (typeof globalFetch === "function" ? globalFetch.bind(globalThis) : void 0);
+  return async (function_, args, runOptions = {}) => {
+    if (typeof fetchImpl !== "function") {
+      throw new TypeError("@lunora/workflow: no fetch implementation available — pass fetchImpl or run on a platform with global fetch");
+    }
+    const origin = options.env.LUNORA_ORIGIN_URL;
+    if (typeof origin !== "string" || origin.length === 0) {
+      throw new Error("@lunora/workflow: `LUNORA_ORIGIN_URL` must be set on the Worker env so a workflow can call back into Lunora functions");
+    }
+    const token = options.env.LUNORA_ADMIN_TOKEN;
+    if (typeof token !== "string" || token.length === 0) {
+      throw new Error("@lunora/workflow: `LUNORA_ADMIN_TOKEN` must be set on the Worker env to authenticate workflow function dispatch");
+    }
+    const url = `${trimTrailingSlashes(origin)}/_lunora/scheduler/dispatch`;
+    const response = await fetchImpl(url, {
+      body: JSON.stringify({ args: args ?? {}, functionPath: function_.__lunoraRef, shardKey: runOptions.shardKey }),
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      method: "POST"
+    });
+    if (!response.ok) {
+      throw new Error(`@lunora/workflow: function dispatch failed (${String(response.status)}): ${await response.text()}`);
+    }
+    const text = await response.text();
+    if (text.length === 0) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  };
+};
+const createWorkflowLogger = (exportName) => {
+  const prefix = `[workflow:${exportName}]`;
+  return {
+    debug: (message, ...rest) => {
+      console.debug(prefix, message, ...rest);
+    },
+    error: (message, ...rest) => {
+      console.error(prefix, message, ...rest);
+    },
+    info: (message, ...rest) => {
+      console.info(prefix, message, ...rest);
+    },
+    warn: (message, ...rest) => {
+      console.warn(prefix, message, ...rest);
+    }
+  };
+};
+const createWorkflowRunContext = (options) => {
+  const log = createWorkflowLogger(options.exportName);
+  const run = createWorkflowRunner({ env: options.env, fetchImpl: options.fetchImpl });
+  return {
+    env: options.env,
+    event: options.event,
+    log,
+    params: options.event.payload,
+    run,
+    runStep: createRunStep({ env: options.env, log, nonRetryableErrorClass: options.nonRetryableErrorClass, run, step: options.step }),
+    step: options.step
+  };
+};
+
+export { createWorkflowLogger, createWorkflowRunContext, createWorkflowRunner };

package/dist/packem_shared/createWorkflows-BoSYVIXg.mjs

@@ -0,0 +1,23 @@
+const handleFor = (binding) => {
+  return {
+    create: async (options) => binding.create(options),
+    createBatch: async (batch) => binding.createBatch(batch),
+    get: async (id) => binding.get(id)
+  };
+};
+const createWorkflows = (options) => {
+  const bindings = options.bindings ?? {};
+  return {
+    get: (name) => {
+      const binding = bindings[name];
+      if (binding === void 0) {
+        const known = Object.keys(bindings);
+        const suffix = known.length === 0 ? "no workflows are declared" : `known workflows: ${known.join(", ")}`;
+        throw new Error(`@lunora/workflow: no workflow named "${name}" (${suffix})`);
+      }
+      return handleFor(binding);
+    }
+  };
+};
+
+export { createWorkflows as default };

package/dist/packem_shared/defineStep-DJQtLw7g.mjs

@@ -0,0 +1,28 @@
+const defineStep = (name, config) => {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new TypeError("defineStep: `name` must be a non-empty string (the durable step label)");
+  }
+  const declaredArgs = config.args;
+  if (typeof declaredArgs !== "object" || declaredArgs === null) {
+    throw new TypeError("defineStep: `args` must be a validator map (e.g. `{ id: v.string() }`)");
+  }
+  if (typeof config.handler !== "function") {
+    throw new TypeError("defineStep: `handler` must be a function (the step body)");
+  }
+  if (config.rollback !== void 0 && typeof config.rollback !== "function") {
+    throw new TypeError("defineStep: `rollback` must be a function when provided");
+  }
+  return {
+    args: config.args,
+    config: config.config,
+    handler: config.handler,
+    isLunoraStep: true,
+    name,
+    returns: config.returns,
+    rollback: config.rollback,
+    rollbackConfig: config.rollbackConfig
+  };
+};
+const isStepDefinition = (value) => typeof value === "object" && value !== null && value.isLunoraStep === true;
+
+export { defineStep, isStepDefinition };

package/dist/packem_shared/defineWorkflow-DbUC-oCN.mjs

@@ -0,0 +1,15 @@
+const workflowClassName = (exportName) => `${exportName.charAt(0).toUpperCase()}${exportName.slice(1)}Workflow`;
+const workflowBindingName = (exportName) => `WORKFLOW_${exportName.replaceAll(/(?<=[a-z0-9])(?=[A-Z])/g, "_").toUpperCase()}`;
+const workflowDefaultName = (exportName) => exportName.replaceAll(/(?<=[a-z0-9])(?=[A-Z])/g, "-").toLowerCase();
+const defineWorkflow = (config) => {
+  if (typeof config.handler !== "function") {
+    throw new TypeError("defineWorkflow: `handler` must be a function (the workflow body)");
+  }
+  if (config.name !== void 0 && (typeof config.name !== "string" || config.name.length === 0)) {
+    throw new TypeError("defineWorkflow: `name` must be a non-empty string when provided");
+  }
+  return { ...config, isLunoraWorkflow: true };
+};
+const isWorkflowDefinition = (value) => typeof value === "object" && value !== null && value.isLunoraWorkflow === true;
+
+export { defineWorkflow, isWorkflowDefinition, workflowBindingName, workflowClassName, workflowDefaultName };