@usehelical/workflows 0.0.1-alpha.12 → 0.0.1-alpha.2

package/dist/chunk-WKVKC6AI.js

@@ -1,650 +0,0 @@
-import { serializeError as serializeError$1, deserializeError as deserializeError$1 } from 'serialize-error';
-import { AsyncLocalStorage } from 'async_hooks';
-import { sql } from 'kysely';
-
-// core/workflow.ts
-var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
-  WorkflowStatus2["PENDING"] = "PENDING";
-  WorkflowStatus2["QUEUED"] = "QUEUED";
-  WorkflowStatus2["SUCCESS"] = "SUCCESS";
-  WorkflowStatus2["ERROR"] = "ERROR";
-  WorkflowStatus2["CANCELLED"] = "CANCELLED";
-  WorkflowStatus2["MAX_RECOVERY_ATTEMPTS_EXCEEDED"] = "MAX_RECOVERY_ATTEMPTS_EXCEEDED";
-  return WorkflowStatus2;
-})(WorkflowStatus || {});
-function defineWorkflow(fn, options = {}) {
-  return () => {
-    return {
-      fn,
-      maxRecoveryAttempts: options.maxRecoveryAttempts
-    };
-  };
-}
-
-// core/internal/errors.ts
-var RunCancelledError = class extends Error {
-  constructor() {
-    super("This workflow run has been cancelled");
-    this.name = "RUN_CANCELLED" /* RUN_CANCELLED */;
-  }
-};
-var RunNotFoundError = class extends Error {
-  constructor(runId) {
-    super(`Workflow run "${runId}" not found`);
-    this.name = "RUN_NOT_FOUND" /* RUN_NOT_FOUND */;
-  }
-};
-var RunOutsideOfWorkflowError = class extends Error {
-  constructor() {
-    super("This function must be called within a workflow");
-    this.name = "RUN_OUTSIDE_OF_WORKFLOW" /* RUN_OUTSIDE_OF_WORKFLOW */;
-  }
-};
-var FatalError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FATAL_ERROR" /* FATAL_ERROR */;
-  }
-};
-var MaxRetriesExceededError = class extends Error {
-  attemptErrors;
-  stepName;
-  maxAttempts;
-  constructor(stepName, maxAttempts, errors) {
-    const formattedErrors = errors.map((error, index) => `Attempt ${index + 1}: ${error.message}`).join(". ");
-    super(`Step "${stepName}" failed after ${maxAttempts + 1} attempts. ${formattedErrors}`);
-    this.name = "MAX_RETRIES_EXCEEDED" /* MAX_RETRIES_EXCEEDED */;
-    this.attemptErrors = errors;
-    this.stepName = stepName;
-    this.maxAttempts = maxAttempts;
-  }
-};
-var ErrorThatShouldNeverHappen = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ERROR_THAT_SHOULD_NEVER_HAPPEN" /* ERROR_THAT_SHOULD_NEVER_HAPPEN */;
-  }
-};
-var SerializationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SERIALIZATION_ERROR" /* SERIALIZATION_ERROR */;
-  }
-};
-var MaxRecoveryAttemptsExceededError = class extends Error {
-  constructor(runId, maxAttempts) {
-    super(`Max recovery attempts exceeded for run "${runId}" after ${maxAttempts + 1} attempts`);
-    this.name = "MAX_RECOVERY_ATTEMPTS_EXCEEDED" /* MAX_RECOVERY_ATTEMPTS_EXCEEDED */;
-  }
-};
-var WorkflowNotFoundError = class extends Error {
-  constructor(workflowName) {
-    super(`Workflow "${workflowName}" not found`);
-    this.name = "WORKFLOW_NOT_FOUND" /* WORKFLOW_NOT_FOUND */;
-  }
-};
-var TimeoutError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TIMEOUT" /* TIMEOUT */;
-  }
-};
-var DeadlineError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "DEADLINE" /* DEADLINE */;
-  }
-};
-var QueueNotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "QUEUE_NOT_FOUND" /* QUEUE_NOT_FOUND */;
-  }
-};
-function serialize(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (error) {
-    throw new SerializationError(error.message);
-  }
-}
-function deserialize(value) {
-  try {
-    return JSON.parse(value);
-  } catch (error) {
-    throw new SerializationError(error.message);
-  }
-}
-function serializeError(error) {
-  try {
-    return JSON.stringify(serializeError$1(error));
-  } catch (error2) {
-    throw new SerializationError(error2.message);
-  }
-}
-function deserializeError(serialized) {
-  try {
-    return deserializeError$1(JSON.parse(serialized));
-  } catch (error) {
-    throw new SerializationError(error.message);
-  }
-}
-
-// core/internal/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// core/internal/db/retry.ts
-var RETRY_SQLSTATE_PREFIXES = /* @__PURE__ */ new Set([
-  "08",
-  // Connection Exception
-  "40",
-  // Transaction Rollback (deadlock_detected, serialization_failure)
-  "53",
-  // Insufficient Resources
-  "55",
-  // Object Not In Prerequisite State (lock_not_available)
-  "57"
-  // Operator Intervention (admin_shutdown, cannot_connect_now)
-]);
-var RETRY_SQLSTATE_CODES = /* @__PURE__ */ new Set([
-  "40003",
-  // statement_completion_unknown
-  "40001",
-  // serialization_failure
-  "40P01",
-  // deadlock_detected
-  "55P03"
-  // lock_not_available
-]);
-var RETRY_NODE_ERRNOS = /* @__PURE__ */ new Set([
-  "ECONNRESET",
-  "ECONNREFUSED",
-  "EHOSTUNREACH",
-  "ENETUNREACH",
-  "ETIMEDOUT",
-  "ECONNABORTED",
-  "EPIPE"
-]);
-function isPgDatabaseError(e) {
-  return !!e && typeof e === "object" && typeof e.code === "string" && e.code.length === 5;
-}
-function sqlStateLooksRetryable(sqlstate) {
-  if (!sqlstate) return false;
-  if (RETRY_SQLSTATE_CODES.has(sqlstate)) return true;
-  const prefix = sqlstate.toString().slice(0, 2);
-  return RETRY_SQLSTATE_PREFIXES.has(prefix);
-}
-function nodeErrnoLooksRetryable(e) {
-  const code = e.code;
-  return !!code && RETRY_NODE_ERRNOS.has(code);
-}
-function messageLooksRetryable(msg) {
-  const m = msg.toLowerCase();
-  return msg.includes("ECONNREFUSED") || msg.includes("ECONNRESET") || m.includes("connection timeout") || m.includes("server closed the connection") || m.includes("connection terminated unexpectedly") || m.includes("client has encountered a connection error") || m.includes("timeout exceeded when trying to connect") || m.includes("could not connect to server") || m.includes("connection pool exhausted") || m.includes("too many clients");
-}
-function* unwrapErrors(e) {
-  const queue = [e];
-  const seen = /* @__PURE__ */ new Set();
-  while (queue.length) {
-    const cur = queue.shift();
-    if (cur && typeof cur === "object") {
-      if (seen.has(cur)) continue;
-      seen.add(cur);
-      const ae = cur;
-      if (Array.isArray(ae.errors)) queue.push(...ae.errors);
-      const withCause = cur;
-      if (withCause.cause) queue.push(withCause.cause);
-      const wrapped = cur;
-      if (wrapped.error) queue.push(wrapped.error);
-    }
-    yield cur;
-  }
-}
-function isRetriableDBError(err) {
-  for (const e of unwrapErrors(err)) {
-    const anyErr = e;
-    if (isPgDatabaseError(anyErr) && sqlStateLooksRetryable(anyErr.code)) {
-      return true;
-    }
-    if (nodeErrnoLooksRetryable(anyErr)) {
-      return true;
-    }
-    if (e instanceof Error) {
-      if (e.stack && messageLooksRetryable(e.stack)) return true;
-      if (e.message && messageLooksRetryable(e.message)) return true;
-    }
-    if (messageLooksRetryable(String(e))) return true;
-  }
-  return false;
-}
-async function withDbRetry(fn, options = {}) {
-  const { initialBackoffMs = 1e3, maxBackoffMs = 6e4, onRetry } = options;
-  let attempt = 0;
-  let backoffMs = initialBackoffMs;
-  while (true) {
-    try {
-      return await fn();
-    } catch (error) {
-      if (!isRetriableDBError(error)) {
-        throw error;
-      }
-      attempt++;
-      const jitter = 0.5 + Math.random();
-      const delayMs = Math.min(backoffMs * jitter, maxBackoffMs);
-      if (onRetry) {
-        onRetry(error, attempt, delayMs);
-      } else {
-        console.warn(
-          `Database connection failed: ${error instanceof Error ? error.message : String(error)}. Retrying in ${(delayMs / 1e3).toFixed(2)}s (attempt ${attempt})`
-        );
-      }
-      await sleep(delayMs);
-      backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
-    }
-  }
-}
-function getExecutionContext() {
-  const store = asyncLocalStorage.getStore();
-  if (!store) {
-    throw new RunOutsideOfWorkflowError();
-  }
-  return store;
-}
-var asyncLocalStorage = new AsyncLocalStorage();
-function runWithExecutionContext(store, callback) {
-  return asyncLocalStorage.run(store, callback);
-}
-
-// core/internal/repository/get-run.ts
-async function getRun(db, runId) {
-  const result = await db.selectFrom("runs").select(["id", "inputs", "output", "error", "status", "change_id"]).where("id", "=", runId).executeTakeFirst();
-  if (!result) {
-    return void 0;
-  }
-  return {
-    id: result.id,
-    input: result.inputs ?? void 0,
-    output: result.output ?? void 0,
-    error: result.error ?? void 0,
-    status: result.status,
-    changeId: result.change_id
-  };
-}
-
-// core/internal/repository/insert-operation.ts
-async function insertOperation(tx, runId, operationName, sequenceId, result, error) {
-  await tx.insertInto("operations").values({
-    run_id: runId,
-    name: operationName,
-    sequence_id: sequenceId,
-    output: result,
-    error
-  }).execute();
-}
-
-// core/internal/operation-manager.ts
-var OperationManager = class {
-  constructor(db, runId, operations = []) {
-    this.db = db;
-    this.runId = runId;
-    this.operations = operations;
-  }
-  sequenceId = 0;
-  lastReservedSequenceId = null;
-  getOperationResult() {
-    const operation = this.operations.pop();
-    if (operation) {
-      this.sequenceId++;
-      return operation;
-    }
-    return null;
-  }
-  reserveSequenceId() {
-    const reserved = this.sequenceId++;
-    this.lastReservedSequenceId = reserved;
-    return reserved;
-  }
-  getCurrentSequenceId() {
-    return this.sequenceId;
-  }
-  /**
-   * Gets the sequence ID that was most recently reserved for the current operation.
-   * This is the ID that will be (or was) recorded in the database for this operation.
-   * Returns null if no sequence ID has been reserved yet.
-   */
-  getActiveSequenceId() {
-    return this.lastReservedSequenceId;
-  }
-  async recordResult(operationName, sequenceId, result, tx) {
-    if (tx) {
-      await insertOperation(tx, this.runId, operationName, sequenceId, result ?? void 0);
-    } else {
-      await withDbRetry(async () => {
-        await insertOperation(this.db, this.runId, operationName, sequenceId, result ?? void 0);
-      });
-    }
-  }
-  async recordError(operationName, sequenceId, error, tx) {
-    if (tx) {
-      await insertOperation(
-        tx,
-        this.runId,
-        operationName,
-        sequenceId,
-        void 0,
-        error ?? void 0
-      );
-    } else {
-      await withDbRetry(async () => {
-        await insertOperation(
-          this.db,
-          this.runId,
-          operationName,
-          sequenceId,
-          void 0,
-          error ?? void 0
-        );
-      });
-    }
-  }
-};
-function returnOrThrowOperationResult(op) {
-  if (op.error) {
-    throw deserializeError(op.error);
-  }
-  if (op.result === null || op.result === void 0) {
-    return void 0;
-  }
-  return deserialize(op.result);
-}
-async function executeAndRecordOperation(operationManager, operationName, callback) {
-  const seqId = operationManager.reserveSequenceId();
-  try {
-    const result = await callback();
-    const serializedResult = serialize(result);
-    await checkCancellation();
-    await operationManager.recordResult(operationName, seqId, serializedResult);
-    return result;
-  } catch (error) {
-    if (error instanceof RunCancelledError) {
-      throw error;
-    }
-    const err = error instanceof Error ? error : new Error(String(error));
-    await operationManager.recordError(operationName, seqId, serializeError(err));
-    throw error;
-  }
-}
-async function checkCancellation() {
-  const { abortSignal, runId, db } = getExecutionContext();
-  if (abortSignal.aborted) {
-    throw new RunCancelledError();
-  }
-  const run = await withDbRetry(async () => getRun(db, runId));
-  if (run?.status === "CANCELLED" /* CANCELLED */) {
-    throw new RunCancelledError();
-  }
-}
-
-// client/utils.ts
-function createExecutionContext({
-  ctx,
-  abortSignal,
-  runId,
-  runPath,
-  operations
-}) {
-  return {
-    runId,
-    runPath,
-    executorId: ctx.executorId,
-    abortSignal,
-    operationManager: new OperationManager(ctx.db, runId, operations || []),
-    messageEventBus: ctx.messageEventBus,
-    stateEventBus: ctx.stateEventBus,
-    workflowRegistry: ctx.workflowRegistry,
-    runEventBus: ctx.runEventBus,
-    runRegistry: ctx.runRegistry,
-    queueRegistry: ctx.queueRegistry,
-    db: ctx.db
-  };
-}
-async function recordRunResult(db, runId, result) {
-  const [{ change_id }] = await db.updateTable("runs").set({
-    output: result.result,
-    error: result.error,
-    status: result.error ? "ERROR" /* ERROR */ : "SUCCESS" /* SUCCESS */,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).where("id", "=", runId).returning(["change_id"]).execute();
-  return change_id;
-}
-async function cancelRun(runId, db) {
-  return withDbRetry(async () => {
-    return db.transaction().execute(async (tx) => {
-      const result = await tx.updateTable("runs").set({
-        status: "CANCELLED" /* CANCELLED */,
-        updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-      }).where(
-        (eb) => eb.and([
-          eb("id", "=", runId),
-          eb("status", "not in", [
-            "CANCELLED" /* CANCELLED */,
-            "SUCCESS" /* SUCCESS */,
-            "ERROR" /* ERROR */
-          ])
-        ])
-      ).returning(["change_id", "path"]).executeTakeFirst();
-      if (!result) {
-        const exists = await tx.selectFrom("runs").select([]).where("id", "=", runId).executeTakeFirst();
-        if (exists) {
-          return void 0;
-        }
-        throw new RunNotFoundError(runId);
-      }
-      await sql`
-                UPDATE runs
-                SET 
-                    status = ${"CANCELLED" /* CANCELLED */},
-                    updated_at = (extract(epoch from now()) * 1000)::bigint
-                WHERE path @> ARRAY[${runId}]::text[]
-                AND id != ${runId}
-                AND status NOT IN (${"CANCELLED" /* CANCELLED */}, ${"SUCCESS" /* SUCCESS */}, ${"ERROR" /* ERROR */})
-            `.execute(tx);
-      return {
-        path: result.path
-      };
-    });
-  });
-}
-
-// core/internal/execute-workflow.ts
-async function executeWorkflow(ctx, params) {
-  const { db, runRegistry } = ctx;
-  const { options, runId, runPath, fn, args, operations } = params;
-  const abortController = new AbortController();
-  const [deadline] = getDeadlineAndReason({
-    timeout: options?.timeout,
-    deadline: options?.deadline
-  });
-  const runStore = createExecutionContext({
-    ctx,
-    abortSignal: AbortSignal.any(
-      [abortController.signal].concat(deadline ? [AbortSignal.timeout(deadline - Date.now())] : [])
-    ),
-    runId,
-    runPath,
-    operations
-  });
-  const executionPromise = (async () => {
-    try {
-      const result = await runWithExecutionContext(runStore, async () => {
-        return await runWithTimeout(async () => {
-          return await fn(...args);
-        });
-      });
-      await recordRunResult(db, runId, { result: result ? serialize(result) : void 0 });
-      return result;
-    } catch (error) {
-      await recordRunResult(db, runId, { error: serializeError(error) });
-      throw error;
-    } finally {
-      runRegistry.unregisterRun(runId);
-    }
-  })();
-  runRegistry.registerRun(runId, {
-    store: runStore,
-    promise: executionPromise,
-    abortController
-  });
-}
-function getDeadlineAndReason({
-  timeout,
-  deadline
-}) {
-  const now = Date.now();
-  const timeoutDeadline = timeout ? now + timeout : void 0;
-  if (timeoutDeadline && deadline) {
-    return [
-      Math.min(timeoutDeadline, deadline),
-      timeoutDeadline < deadline ? "timeout" : "deadline"
-    ];
-  } else if (timeoutDeadline) {
-    return [timeoutDeadline, "timeout"];
-  } else if (deadline) {
-    return [deadline, "deadline"];
-  }
-  return [void 0, void 0];
-}
-async function runWithTimeout(fn) {
-  const { runId, db, abortSignal } = getExecutionContext();
-  const abortPromise = new Promise((_, reject) => {
-    abortSignal.throwIfAborted();
-    abortSignal.addEventListener(
-      "abort",
-      () => {
-        if (abortSignal.reason?.name === "TimeoutError") {
-          reject(new TimeoutError(`Workflow timed out`));
-          return;
-        }
-        reject(new RunCancelledError());
-      },
-      { once: true }
-    );
-  });
-  const callPromise = fn();
-  try {
-    return await Promise.race([callPromise, abortPromise]);
-  } catch (error) {
-    if (error instanceof TimeoutError || error instanceof DeadlineError) {
-      await cancelRun(runId, db);
-    }
-    await callPromise.catch(() => {
-    });
-    throw error;
-  }
-}
-
-// core/internal/repository/get-run-status.ts
-async function getRunStatus(db, runId) {
-  const run = await db.selectFrom("runs").select("status").where("id", "=", runId).executeTakeFirst();
-  if (!run) {
-    throw new RunNotFoundError(runId);
-  }
-  return run.status;
-}
-
-// client/run.ts
-function createRunHandle(runtimeContext, id) {
-  const { runRegistry, db, runEventBus } = runtimeContext;
-  const run = runRegistry.getRun(id);
-  if (run) {
-    return {
-      id,
-      status: () => getRunStatusFromRegistry(run),
-      result: () => run.promise
-    };
-  }
-  return {
-    id,
-    status: () => getRunStatus(db, id),
-    result: () => getRunResult(id, runEventBus, db)
-  };
-}
-async function getRunStatusFromRegistry(runEntry) {
-  if (runEntry.store.abortSignal.aborted) {
-    return "CANCELLED" /* CANCELLED */;
-  }
-  const promiseState = runEntry.getPromiseState();
-  if (promiseState === "pending") {
-    return "PENDING" /* PENDING */;
-  }
-  if (promiseState === "fulfilled") {
-    return "SUCCESS" /* SUCCESS */;
-  }
-  return "ERROR" /* ERROR */;
-}
-async function getRunResult(id, runEventBus, db) {
-  const run = await getRun(db, id);
-  if (!run) {
-    throw new RunNotFoundError(id);
-  }
-  if (run.status === "CANCELLED" /* CANCELLED */) {
-    throw new RunCancelledError();
-  }
-  if (run.status === "ERROR" /* ERROR */) {
-    throw run.error ? deserializeError(run.error) : void 0;
-  }
-  return new Promise((resolve, reject) => {
-    const unsubscribe = runEventBus.subscribe(id, "*", async (e) => {
-      if (e.status === "CANCELLED" /* CANCELLED */) {
-        unsubscribe();
-        reject(new RunCancelledError());
-        return;
-      }
-      if (e.status === "SUCCESS" /* SUCCESS */ || e.status === "ERROR" /* ERROR */) {
-        unsubscribe();
-        try {
-          const completedRun = await getRun(db, id);
-          if (!completedRun) {
-            reject(new RunNotFoundError(id));
-            return;
-          }
-          if (completedRun.status === "ERROR" /* ERROR */) {
-            reject(
-              completedRun.error ? deserializeError(completedRun.error) : new Error("error")
-            );
-            return;
-          }
-          resolve(
-            completedRun.output ? deserialize(completedRun.output) : void 0
-          );
-        } catch (error) {
-          reject(error);
-        }
-      }
-    });
-  });
-}
-async function insertPendingRun(db, options) {
-  const result = await db.insertInto("runs").values({
-    id: options.runId,
-    path: options.path,
-    inputs: options.inputs,
-    executor_id: options.executorId,
-    workflow_name: options.workflowName,
-    status: "PENDING" /* PENDING */,
-    started_at_epoch_ms: sql`(extract(epoch from now()) * 1000)::bigint`,
-    created_at: sql`(extract(epoch from now()) * 1000)::bigint`,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).returning(["id", "path", "change_id"]).executeTakeFirst();
-  return {
-    runId: result.id,
-    path: result.path,
-    changeId: result.change_id
-  };
-}
-
-export { ErrorThatShouldNeverHappen, FatalError, MaxRecoveryAttemptsExceededError, MaxRetriesExceededError, QueueNotFoundError, RunCancelledError, RunNotFoundError, TimeoutError, WorkflowNotFoundError, WorkflowStatus, cancelRun, createRunHandle, defineWorkflow, deserialize, deserializeError, executeAndRecordOperation, executeWorkflow, getExecutionContext, getRun, insertPendingRun, returnOrThrowOperationResult, serialize, serializeError, sleep, withDbRetry };
-//# sourceMappingURL=chunk-WKVKC6AI.js.map
-//# sourceMappingURL=chunk-WKVKC6AI.js.map