pg-workflows 0.7.1 → 0.8.0

package/dist/client.entry.cjs

@@ -0,0 +1,822 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/client.entry.ts
+var exports_client_entry = {};
+__export(exports_client_entry, {
+  createWorkflowRef: () => createWorkflowRef,
+  WorkflowStatus: () => WorkflowStatus,
+  WorkflowClient: () => WorkflowClient
+});
+module.exports = __toCommonJS(exports_client_entry);
+
+// src/client.ts
+var import_es_toolkit = require("es-toolkit");
+var import_pg = __toESM(require("pg"));
+var import_pg_boss = require("pg-boss");
+
+// src/constants.ts
+var PAUSE_EVENT_NAME = "__internal_pause";
+var WORKFLOW_RUN_QUEUE_NAME = "workflow-run";
+var DEFAULT_PGBOSS_SCHEMA = "pgboss_v12_pgworkflow";
+
+// src/db/migration.ts
+var MIGRATION_LOCK_ID = 738291645;
+var CURRENT_SCHEMA_VERSION = 2;
+async function runMigrations(db) {
+  if (await isSchemaUpToDate(db)) {
+    return;
+  }
+  const currentVersion = await getCurrentVersion(db);
+  const commands = [];
+  if (currentVersion < 1) {
+    commands.push(`
+      CREATE TABLE IF NOT EXISTS workflow_runs (
+        id varchar(32) PRIMARY KEY NOT NULL,
+        created_at timestamp with time zone DEFAULT now() NOT NULL,
+        updated_at timestamp with time zone DEFAULT now() NOT NULL,
+        resource_id varchar(32),
+        workflow_id varchar(32) NOT NULL,
+        status text DEFAULT 'pending' NOT NULL,
+        input jsonb NOT NULL,
+        output jsonb,
+        error text,
+        current_step_id varchar(256) NOT NULL,
+        timeline jsonb DEFAULT '{}'::jsonb NOT NULL,
+        paused_at timestamp with time zone,
+        resumed_at timestamp with time zone,
+        completed_at timestamp with time zone,
+        timeout_at timestamp with time zone,
+        retry_count integer DEFAULT 0 NOT NULL,
+        max_retries integer DEFAULT 0 NOT NULL,
+        job_id varchar(256)
+      )
+    `);
+    commands.push(`
+      CREATE INDEX IF NOT EXISTS workflow_runs_created_at_idx ON workflow_runs USING btree (created_at)
+    `);
+    commands.push(`
+      CREATE INDEX IF NOT EXISTS workflow_runs_resource_id_created_at_idx ON workflow_runs USING btree (resource_id, created_at DESC)
+    `);
+    commands.push(`
+      CREATE INDEX IF NOT EXISTS workflow_runs_status_created_at_idx ON workflow_runs USING btree (status, created_at DESC)
+    `);
+    commands.push(`
+      CREATE INDEX IF NOT EXISTS workflow_runs_workflow_id_created_at_idx ON workflow_runs USING btree (workflow_id, created_at DESC)
+    `);
+    commands.push(`
+      CREATE INDEX IF NOT EXISTS workflow_runs_resource_id_workflow_id_created_at_idx ON workflow_runs USING btree (resource_id, workflow_id, created_at DESC)
+    `);
+  }
+  if (currentVersion < 2) {
+    commands.push("DROP INDEX IF EXISTS workflow_runs_workflow_id_idx");
+    commands.push("DROP INDEX IF EXISTS workflow_runs_resource_id_idx");
+    commands.push("ALTER TABLE workflow_runs ADD COLUMN IF NOT EXISTS idempotency_key varchar(256)");
+    commands.push(`
+      CREATE UNIQUE INDEX IF NOT EXISTS workflow_runs_idempotency_key_idx ON workflow_runs (idempotency_key) WHERE idempotency_key IS NOT NULL
+    `);
+  }
+  if (currentVersion === 0) {
+    commands.push(`INSERT INTO workflow_schema_version (version) VALUES (${CURRENT_SCHEMA_VERSION})`);
+  } else {
+    commands.push(`UPDATE workflow_schema_version SET version = ${CURRENT_SCHEMA_VERSION}`);
+  }
+  if (commands.length === 0) {
+    return;
+  }
+  const sql = [
+    "BEGIN",
+    "SET LOCAL lock_timeout = '30s'",
+    "SET LOCAL idle_in_transaction_session_timeout = '30s'",
+    `SELECT pg_advisory_xact_lock(${MIGRATION_LOCK_ID})`,
+    "CREATE TABLE IF NOT EXISTS workflow_schema_version (version integer NOT NULL)",
+    ...commands,
+    "COMMIT"
+  ].join(`;
+`);
+  await db.executeSql(sql, []);
+}
+async function isSchemaUpToDate(db) {
+  try {
+    const result = await db.executeSql("SELECT version FROM workflow_schema_version LIMIT 1", []);
+    return (result.rows[0]?.version ?? 0) >= CURRENT_SCHEMA_VERSION;
+  } catch {
+    return false;
+  }
+}
+async function getCurrentVersion(db) {
+  try {
+    const result = await db.executeSql("SELECT version FROM workflow_schema_version LIMIT 1", []);
+    return result.rows[0]?.version ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/db/queries.ts
+var import_ksuid = __toESM(require("ksuid"));
+function generateKSUID(prefix) {
+  return `${prefix ? `${prefix}_` : ""}${import_ksuid.default.randomSync().string}`;
+}
+function mapRowToWorkflowRun(row) {
+  return {
+    id: row.id,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+    resourceId: row.resource_id,
+    workflowId: row.workflow_id,
+    status: row.status,
+    input: typeof row.input === "string" ? JSON.parse(row.input) : row.input,
+    output: typeof row.output === "string" ? row.output.trim().startsWith("{") || row.output.trim().startsWith("[") ? JSON.parse(row.output) : row.output : row.output ?? null,
+    error: row.error,
+    currentStepId: row.current_step_id,
+    timeline: typeof row.timeline === "string" ? JSON.parse(row.timeline) : row.timeline,
+    pausedAt: row.paused_at ? new Date(row.paused_at) : null,
+    resumedAt: row.resumed_at ? new Date(row.resumed_at) : null,
+    completedAt: row.completed_at ? new Date(row.completed_at) : null,
+    timeoutAt: row.timeout_at ? new Date(row.timeout_at) : null,
+    retryCount: row.retry_count,
+    maxRetries: row.max_retries,
+    jobId: row.job_id,
+    idempotencyKey: row.idempotency_key
+  };
+}
+async function insertWorkflowRun({
+  resourceId,
+  workflowId,
+  currentStepId,
+  status,
+  input,
+  maxRetries,
+  timeoutAt,
+  idempotencyKey
+}, db) {
+  const runId = generateKSUID("run");
+  const now = new Date;
+  const result = await db.executeSql(`INSERT INTO workflow_runs (
+      id,
+      resource_id,
+      workflow_id,
+      current_step_id,
+      status,
+      input,
+      max_retries,
+      timeout_at,
+      created_at,
+      updated_at,
+      timeline,
+      retry_count,
+      idempotency_key
+    )
+    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+    ON CONFLICT (idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING
+    RETURNING *`, [
+    runId,
+    resourceId ?? null,
+    workflowId,
+    currentStepId,
+    status,
+    JSON.stringify(input),
+    maxRetries,
+    timeoutAt,
+    now,
+    now,
+    "{}",
+    0,
+    idempotencyKey ?? null
+  ]);
+  if (result.rows[0]) {
+    return { run: mapRowToWorkflowRun(result.rows[0]), created: true };
+  }
+  const existing = await db.executeSql("SELECT * FROM workflow_runs WHERE idempotency_key = $1", [
+    idempotencyKey
+  ]);
+  if (!existing.rows[0]) {
+    throw new Error(`Idempotency conflict: existing run not found for key "${idempotencyKey}"`);
+  }
+  return { run: mapRowToWorkflowRun(existing.rows[0]), created: false };
+}
+async function getWorkflowRun({
+  runId,
+  resourceId
+}, { exclusiveLock = false, db }) {
+  const lockSuffix = exclusiveLock ? "FOR UPDATE" : "";
+  const result = resourceId ? await db.executeSql(`SELECT * FROM workflow_runs 
+        WHERE id = $1 AND resource_id = $2
+        ${lockSuffix}`, [runId, resourceId]) : await db.executeSql(`SELECT * FROM workflow_runs 
+        WHERE id = $1
+        ${lockSuffix}`, [runId]);
+  const run = result.rows[0];
+  if (!run) {
+    return null;
+  }
+  return mapRowToWorkflowRun(run);
+}
+async function updateWorkflowRun({
+  runId,
+  resourceId,
+  data,
+  expectedStatuses
+}, db) {
+  const now = new Date;
+  const updates = ["updated_at = $1"];
+  const values = [now];
+  let paramIndex = 2;
+  if (data.status !== undefined) {
+    updates.push(`status = $${paramIndex}`);
+    values.push(data.status);
+    paramIndex++;
+  }
+  if (data.currentStepId !== undefined) {
+    updates.push(`current_step_id = $${paramIndex}`);
+    values.push(data.currentStepId);
+    paramIndex++;
+  }
+  if (data.timeline !== undefined) {
+    updates.push(`timeline = $${paramIndex}`);
+    values.push(JSON.stringify(data.timeline));
+    paramIndex++;
+  }
+  if (data.pausedAt !== undefined) {
+    updates.push(`paused_at = $${paramIndex}`);
+    values.push(data.pausedAt);
+    paramIndex++;
+  }
+  if (data.resumedAt !== undefined) {
+    updates.push(`resumed_at = $${paramIndex}`);
+    values.push(data.resumedAt);
+    paramIndex++;
+  }
+  if (data.completedAt !== undefined) {
+    updates.push(`completed_at = $${paramIndex}`);
+    values.push(data.completedAt);
+    paramIndex++;
+  }
+  if (data.output !== undefined) {
+    updates.push(`output = $${paramIndex}`);
+    values.push(JSON.stringify(data.output));
+    paramIndex++;
+  }
+  if (data.error !== undefined) {
+    updates.push(`error = $${paramIndex}`);
+    values.push(data.error);
+    paramIndex++;
+  }
+  if (data.retryCount !== undefined) {
+    updates.push(`retry_count = $${paramIndex}`);
+    values.push(data.retryCount);
+    paramIndex++;
+  }
+  if (data.jobId !== undefined) {
+    updates.push(`job_id = $${paramIndex}`);
+    values.push(data.jobId);
+    paramIndex++;
+  }
+  values.push(runId);
+  const idParam = paramIndex;
+  paramIndex++;
+  if (resourceId) {
+    values.push(resourceId);
+    paramIndex++;
+  }
+  if (expectedStatuses && expectedStatuses.length > 0) {
+    values.push(expectedStatuses);
+    paramIndex++;
+  }
+  let whereClause = resourceId ? `WHERE id = $${idParam} AND resource_id = $${idParam + 1}` : `WHERE id = $${idParam}`;
+  if (expectedStatuses && expectedStatuses.length > 0) {
+    whereClause += ` AND status = ANY($${paramIndex - 1})`;
+  }
+  const query = `
+    UPDATE workflow_runs 
+    SET ${updates.join(", ")}
+    ${whereClause}
+    RETURNING *
+  `;
+  const result = await db.executeSql(query, values);
+  const run = result.rows[0];
+  if (!run) {
+    return null;
+  }
+  return mapRowToWorkflowRun(run);
+}
+async function getWorkflowRuns({
+  resourceId,
+  startingAfter,
+  endingBefore,
+  limit = 20,
+  statuses,
+  workflowId
+}, db) {
+  const conditions = [];
+  const values = [];
+  let paramIndex = 1;
+  if (resourceId) {
+    conditions.push(`resource_id = $${paramIndex}`);
+    values.push(resourceId);
+    paramIndex++;
+  }
+  if (statuses && statuses.length > 0) {
+    conditions.push(`status = ANY($${paramIndex})`);
+    values.push(statuses);
+    paramIndex++;
+  }
+  if (workflowId) {
+    conditions.push(`workflow_id = $${paramIndex}`);
+    values.push(workflowId);
+    paramIndex++;
+  }
+  const cursorIds = [startingAfter, endingBefore].filter(Boolean);
+  if (cursorIds.length > 0) {
+    const cursorResult = await db.executeSql("SELECT id, created_at FROM workflow_runs WHERE id = ANY($1)", [cursorIds]);
+    const cursorMap = new Map;
+    for (const row of cursorResult.rows) {
+      cursorMap.set(row.id, typeof row.created_at === "string" ? new Date(row.created_at) : row.created_at);
+    }
+    if (startingAfter) {
+      const cursor = cursorMap.get(startingAfter);
+      if (cursor) {
+        conditions.push(`created_at < $${paramIndex}`);
+        values.push(cursor);
+        paramIndex++;
+      }
+    }
+    if (endingBefore) {
+      const cursor = cursorMap.get(endingBefore);
+      if (cursor) {
+        conditions.push(`created_at > $${paramIndex}`);
+        values.push(cursor);
+        paramIndex++;
+      }
+    }
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const actualLimit = Math.min(Math.max(limit, 1), 100) + 1;
+  const isBackward = !!endingBefore && !startingAfter;
+  const query = `
+    SELECT * FROM workflow_runs
+    ${whereClause}
+    ORDER BY created_at ${isBackward ? "ASC" : "DESC"}
+    LIMIT $${paramIndex}
+  `;
+  values.push(actualLimit);
+  const result = await db.executeSql(query, values);
+  const rows = result.rows;
+  const hasExtraRow = rows.length > (limit ?? 20);
+  const rawItems = hasExtraRow ? rows.slice(0, limit) : rows;
+  if (isBackward) {
+    rawItems.reverse();
+  }
+  const items = rawItems.map((row) => mapRowToWorkflowRun(row));
+  const hasMore = isBackward ? items.length > 0 : hasExtraRow;
+  const hasPrev = isBackward ? hasExtraRow : !!startingAfter && items.length > 0;
+  const nextCursor = hasMore && items.length > 0 ? items[items.length - 1]?.id ?? null : null;
+  const prevCursor = hasPrev && items.length > 0 ? items[0]?.id ?? null : null;
+  return { items, nextCursor, prevCursor, hasMore, hasPrev };
+}
+async function withPostgresTransaction(db, callback, pool) {
+  let txDb;
+  let release;
+  if (pool) {
+    const client = await pool.connect();
+    txDb = {
+      executeSql: (text, values) => client.query(text, values)
+    };
+    release = () => client.release();
+  } else {
+    txDb = db;
+  }
+  try {
+    await txDb.executeSql("BEGIN", []);
+    const result = await callback(txDb);
+    await txDb.executeSql("COMMIT", []);
+    return result;
+  } catch (error) {
+    await txDb.executeSql("ROLLBACK", []);
+    throw error;
+  } finally {
+    release?.();
+  }
+}
+
+// src/error.ts
+class WorkflowEngineError extends Error {
+  workflowId;
+  runId;
+  cause;
+  issues;
+  constructor(message, workflowId, runId, cause = undefined, issues) {
+    super(message);
+    this.workflowId = workflowId;
+    this.runId = runId;
+    this.cause = cause;
+    this.issues = issues;
+    this.name = "WorkflowEngineError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, WorkflowEngineError);
+    }
+  }
+}
+
+class WorkflowRunNotFoundError extends WorkflowEngineError {
+  constructor(runId, workflowId) {
+    super("Workflow run not found", workflowId, runId);
+    this.name = "WorkflowRunNotFoundError";
+  }
+}
+
+// src/types.ts
+var WorkflowStatus;
+((WorkflowStatus2) => {
+  WorkflowStatus2["PENDING"] = "pending";
+  WorkflowStatus2["RUNNING"] = "running";
+  WorkflowStatus2["PAUSED"] = "paused";
+  WorkflowStatus2["COMPLETED"] = "completed";
+  WorkflowStatus2["FAILED"] = "failed";
+  WorkflowStatus2["CANCELLED"] = "cancelled";
+})(WorkflowStatus ||= {});
+var StepType;
+((StepType2) => {
+  StepType2["PAUSE"] = "pause";
+  StepType2["RUN"] = "run";
+  StepType2["WAIT_FOR"] = "waitFor";
+  StepType2["WAIT_UNTIL"] = "waitUntil";
+  StepType2["DELAY"] = "delay";
+  StepType2["POLL"] = "poll";
+})(StepType ||= {});
+
+// src/client.ts
+var LOG_PREFIX = "[WorkflowClient]";
+var defaultLogger = {
+  log: (_message) => console.warn(_message),
+  error: (message, error) => console.error(message, error)
+};
+var defaultExpireInSeconds = process.env.WORKFLOW_RUN_EXPIRE_IN_SECONDS ? Number.parseInt(process.env.WORKFLOW_RUN_EXPIRE_IN_SECONDS, 10) : 5 * 60;
+
+class WorkflowClient {
+  boss;
+  db;
+  pool;
+  _ownsPool = false;
+  _started = false;
+  logger;
+  constructor({ logger, ...connectionOptions }) {
+    this.logger = logger ?? defaultLogger;
+    if ("pool" in connectionOptions && connectionOptions.pool) {
+      this.pool = connectionOptions.pool;
+    } else if ("connectionString" in connectionOptions && connectionOptions.connectionString) {
+      this.pool = new import_pg.default.Pool({ connectionString: connectionOptions.connectionString });
+      this._ownsPool = true;
+    } else {
+      throw new WorkflowEngineError("Either pool or connectionString must be provided");
+    }
+    const db = {
+      executeSql: (text, values) => this.pool.query(text, values)
+    };
+    this.boss = new import_pg_boss.PgBoss({ db, schema: DEFAULT_PGBOSS_SCHEMA });
+    this.db = db;
+  }
+  async start() {
+    if (this._started) {
+      return;
+    }
+    await this.boss.start();
+    this.db = this.boss.getDb();
+    await runMigrations(this.db);
+    await this.boss.createQueue(WORKFLOW_RUN_QUEUE_NAME);
+    this._started = true;
+    this.logger.log(`${LOG_PREFIX} Client started`);
+  }
+  async stop() {
+    await this.boss.stop();
+    if (this._ownsPool) {
+      await this.pool.end();
+    }
+    this._started = false;
+    this.logger.log(`${LOG_PREFIX} Client stopped`);
+  }
+  async startWorkflow(refOrParams, inputArg, optionsArg) {
+    await this.ensureStarted();
+    let workflowId;
+    let input;
+    let resourceId;
+    let options;
+    if (typeof refOrParams === "function" && "id" in refOrParams) {
+      const ref = refOrParams;
+      workflowId = ref.id;
+      input = inputArg;
+      options = optionsArg;
+      resourceId = optionsArg?.resourceId;
+      if (ref.inputSchema) {
+        const result = await ref.inputSchema["~standard"].validate(input);
+        if (result.issues) {
+          throw new WorkflowEngineError(JSON.stringify(result.issues), workflowId, undefined, undefined, result.issues);
+        }
+      }
+    } else {
+      const params = refOrParams;
+      workflowId = params.workflowId;
+      input = params.input;
+      resourceId = params.resourceId;
+      options = params.options;
+    }
+    const run = await withPostgresTransaction(this.db, async (_db) => {
+      const timeoutAt = options?.timeout ? new Date(Date.now() + options.timeout) : null;
+      const { run: insertedRun, created } = await insertWorkflowRun({
+        resourceId,
+        workflowId,
+        currentStepId: "__start__",
+        status: "running" /* RUNNING */,
+        input,
+        maxRetries: options?.retries ?? 0,
+        timeoutAt
+      }, _db);
+      if (created) {
+        const job = {
+          runId: insertedRun.id,
+          resourceId,
+          workflowId,
+          input
+        };
+        await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
+          startAfter: new Date,
+          expireInSeconds: options?.expireInSeconds ?? defaultExpireInSeconds
+        });
+      }
+      return insertedRun;
+    }, this.pool);
+    this.logger.log(`${LOG_PREFIX} Started workflow run ${run.id} for ${workflowId}`);
+    return run;
+  }
+  async triggerEvent({
+    runId,
+    resourceId,
+    eventName,
+    data,
+    options
+  }) {
+    await this.ensureStarted();
+    const run = await this.getRun({ runId, resourceId });
+    const job = {
+      runId: run.id,
+      resourceId: resourceId ?? run.resourceId ?? undefined,
+      workflowId: run.workflowId,
+      input: run.input,
+      event: {
+        name: eventName,
+        data
+      }
+    };
+    await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
+      expireInSeconds: options?.expireInSeconds ?? defaultExpireInSeconds
+    });
+    this.logger.log(`${LOG_PREFIX} Event ${eventName} sent for workflow run ${runId}`);
+    return run;
+  }
+  async pauseWorkflow({
+    runId,
+    resourceId
+  }) {
+    await this.ensureStarted();
+    const run = await updateWorkflowRun({
+      runId,
+      resourceId,
+      data: {
+        status: "paused" /* PAUSED */,
+        pausedAt: new Date
+      },
+      expectedStatuses: ["running" /* RUNNING */, "pending" /* PENDING */]
+    }, this.db);
+    if (!run) {
+      throw new WorkflowRunNotFoundError(runId);
+    }
+    this.logger.log(`${LOG_PREFIX} Paused workflow run ${runId}`);
+    return run;
+  }
+  async resumeWorkflow({
+    runId,
+    resourceId,
+    options
+  }) {
+    await this.ensureStarted();
+    const current = await this.getRun({ runId, resourceId });
+    if (current.status !== "paused" /* PAUSED */) {
+      throw new WorkflowEngineError(`Cannot resume workflow run in '${current.status}' status, must be 'paused'`, current.workflowId, runId);
+    }
+    return this.triggerEvent({
+      runId,
+      resourceId,
+      eventName: PAUSE_EVENT_NAME,
+      data: {},
+      options
+    });
+  }
+  async fastForwardWorkflow({
+    runId,
+    resourceId,
+    data
+  }) {
+    await this.ensureStarted();
+    const run = await this.getRun({ runId, resourceId });
+    if (run.status !== "paused" /* PAUSED */) {
+      return run;
+    }
+    const stepId = run.currentStepId;
+    const waitForEntry = run.timeline[`${stepId}-wait-for`];
+    if (!waitForEntry || typeof waitForEntry !== "object" || !("waitFor" in waitForEntry)) {
+      return run;
+    }
+    const { eventName, timeoutEvent, skipOutput } = waitForEntry.waitFor;
+    if (eventName === PAUSE_EVENT_NAME) {
+      return this.resumeWorkflow({ runId, resourceId });
+    }
+    if (skipOutput && timeoutEvent) {
+      await withPostgresTransaction(this.db, async (db) => {
+        const freshRun = await getWorkflowRun({ runId, resourceId }, { exclusiveLock: true, db });
+        if (!freshRun)
+          throw new WorkflowRunNotFoundError(runId);
+        return updateWorkflowRun({
+          runId,
+          resourceId,
+          data: {
+            timeline: import_es_toolkit.merge(freshRun.timeline, {
+              [stepId]: {
+                output: data ?? {},
+                timestamp: new Date
+              }
+            })
+          }
+        }, db);
+      }, this.pool);
+      return this.triggerEvent({ runId, resourceId, eventName: timeoutEvent });
+    }
+    if (eventName) {
+      return this.triggerEvent({ runId, resourceId, eventName, data: data ?? {} });
+    }
+    if (timeoutEvent) {
+      return this.triggerEvent({ runId, resourceId, eventName: timeoutEvent, data: data ?? {} });
+    }
+    return run;
+  }
+  async cancelWorkflow({
+    runId,
+    resourceId
+  }) {
+    await this.ensureStarted();
+    const run = await updateWorkflowRun({
+      runId,
+      resourceId,
+      data: {
+        status: "cancelled" /* CANCELLED */
+      },
+      expectedStatuses: ["pending" /* PENDING */, "running" /* RUNNING */, "paused" /* PAUSED */]
+    }, this.db);
+    if (!run) {
+      throw new WorkflowRunNotFoundError(runId);
+    }
+    this.logger.log(`${LOG_PREFIX} Cancelled workflow run ${runId}`);
+    return run;
+  }
+  async getRun({
+    runId,
+    resourceId
+  }) {
+    await this.ensureStarted();
+    const run = await getWorkflowRun({ runId, resourceId }, { db: this.db });
+    if (!run) {
+      throw new WorkflowRunNotFoundError(runId);
+    }
+    return run;
+  }
+  async checkProgress({
+    runId,
+    resourceId
+  }) {
+    const run = await this.getRun({ runId, resourceId });
+    const completedSteps = Object.values(run.timeline).filter((entry) => typeof entry === "object" && entry !== null && ("output" in entry) && entry.output !== undefined).length;
+    const totalSteps = run.status === "completed" /* COMPLETED */ ? completedSteps : 0;
+    const completionPercentage = run.status === "completed" /* COMPLETED */ ? 100 : run.status === "failed" /* FAILED */ || run.status === "cancelled" /* CANCELLED */ ? 0 : 0;
+    return {
+      ...run,
+      completedSteps,
+      completionPercentage,
+      totalSteps
+    };
+  }
+  async getRuns({
+    resourceId,
+    startingAfter,
+    endingBefore,
+    limit = 20,
+    statuses,
+    workflowId
+  }) {
+    await this.ensureStarted();
+    return getWorkflowRuns({
+      resourceId,
+      startingAfter,
+      endingBefore,
+      limit,
+      statuses,
+      workflowId
+    }, this.db);
+  }
+  async ensureStarted() {
+    if (!this._started) {
+      await this.start();
+    }
+  }
+}
+// src/definition.ts
+function createWorkflowRef(id, options) {
+  const ref = (handler, defineOptions) => ({
+    id,
+    handler,
+    inputSchema: options?.inputSchema,
+    timeout: defineOptions?.timeout,
+    retries: defineOptions?.retries
+  });
+  Object.defineProperty(ref, "id", { value: id, enumerable: true });
+  Object.defineProperty(ref, "inputSchema", { value: options?.inputSchema, enumerable: true });
+  return ref;
+}
+function createWorkflowFactory(plugins = []) {
+  const factory = (id, handler, { inputSchema, timeout, retries } = {}) => ({
+    id,
+    handler,
+    inputSchema,
+    timeout,
+    retries,
+    plugins: plugins.length > 0 ? plugins : undefined
+  });
+  factory.use = (plugin) => createWorkflowFactory([
+    ...plugins,
+    plugin
+  ]);
+  factory.ref = createWorkflowRef;
+  return factory;
+}
+var workflow = createWorkflowFactory();
+
+//# debugId=3BB2ABF6C479FA4D64756E2164756E21
+//# sourceMappingURL=client.entry.js.map