@dudousxd/nestjs-durable-transport-db 0.1.1 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Davide Carvalho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,323 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DbTransport: () => DbTransport,
+  mikroOrmExecutor: () => mikroOrmExecutor,
+  typeOrmExecutor: () => typeOrmExecutor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/db-transport.ts
+var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
+
+// src/executors.ts
+function typeOrmExecutor(ds) {
+  return {
+    dialect: /postgres/.test(String(ds.options.type)) ? "postgres" : "mysql",
+    escapeId: /* @__PURE__ */ __name((id) => ds.driver.escape(id), "escapeId"),
+    query: /* @__PURE__ */ __name((sql, params) => ds.query(sql, params), "query"),
+    transaction: /* @__PURE__ */ __name(async (fn) => {
+      const qr = ds.createQueryRunner();
+      await qr.connect();
+      await qr.startTransaction();
+      try {
+        const result = await fn({
+          query: /* @__PURE__ */ __name((sql, params) => qr.query(sql, params), "query")
+        });
+        await qr.commitTransaction();
+        return result;
+      } catch (err) {
+        await qr.rollbackTransaction();
+        throw err;
+      } finally {
+        await qr.release();
+      }
+    }, "transaction")
+  };
+}
+__name(typeOrmExecutor, "typeOrmExecutor");
+function mikroOrmExecutor(em) {
+  const platform = em.getPlatform();
+  return {
+    dialect: /postgre/i.test(platform.constructor.name) ? "postgres" : "mysql",
+    escapeId: /* @__PURE__ */ __name((id) => platform.quoteIdentifier(id), "escapeId"),
+    query: /* @__PURE__ */ __name((sql, params) => em.getConnection().execute(sql, params ?? [], "all"), "query"),
+    transaction: /* @__PURE__ */ __name((fn) => em.transactional((txEm) => fn({
+      query: /* @__PURE__ */ __name((sql, params) => txEm.getConnection().execute(sql, params ?? [], "all", txEm.getTransactionContext?.()), "query")
+    })), "transaction")
+  };
+}
+__name(mikroOrmExecutor, "mikroOrmExecutor");
+
+// src/db-transport.ts
+var DbTransport = class {
+  static {
+    __name(this, "DbTransport");
+  }
+  exec;
+  group;
+  tasksTable;
+  resultsTable;
+  pollMs;
+  leaseMs;
+  batchSize;
+  autoCreate;
+  instanceId;
+  isPg;
+  handlers = /* @__PURE__ */ new Map();
+  running = true;
+  schemaReady;
+  taskLoop;
+  resultLoop;
+  constructor(options) {
+    this.exec = options.executor;
+    this.group = options.group;
+    const prefix = options.prefix ?? "durable";
+    this.tasksTable = `${prefix}_transport_tasks`;
+    this.resultsTable = `${prefix}_transport_results`;
+    this.pollMs = options.pollMs ?? 500;
+    this.leaseMs = options.leaseMs ?? 3e4;
+    this.batchSize = options.batchSize ?? 10;
+    this.autoCreate = options.autoCreate ?? true;
+    this.instanceId = options.instanceId ?? `db-${Math.floor(Date.now()).toString(36)}`;
+    this.isPg = this.exec.dialect === "postgres";
+  }
+  // ── dialect helpers ──────────────────────────────────────────────────────────────────────────
+  /** Positional placeholder for param `i` (1-based): `$i` on Postgres, `?` elsewhere. */
+  ph(i) {
+    return this.isPg ? `$${i}` : "?";
+  }
+  q(id) {
+    return this.exec.escapeId(id);
+  }
+  now() {
+    return Math.floor(Date.now());
+  }
+  // ── schema ───────────────────────────────────────────────────────────────────────────────────
+  ensureSchema() {
+    if (!this.schemaReady) this.schemaReady = this.createTables();
+    return this.schemaReady;
+  }
+  async createTables() {
+    if (!this.autoCreate) return;
+    const str = "varchar(191)";
+    const txt = this.isPg ? "text" : "longtext";
+    const tasks = this.q(this.tasksTable);
+    const results = this.q(this.resultsTable);
+    await this.exec.query(`CREATE TABLE IF NOT EXISTS ${tasks} (
+        ${this.q("step_id")} ${str} PRIMARY KEY,
+        ${this.q("run_id")} ${str} NOT NULL,
+        ${this.q("seq")} integer NOT NULL,
+        ${this.q("name")} ${str} NOT NULL,
+        ${this.q("grp")} ${str} NOT NULL,
+        ${this.q("input")} ${txt},
+        ${this.q("attempt")} integer NOT NULL,
+        ${this.q("status")} varchar(32) NOT NULL,
+        ${this.q("claimed_by")} ${str},
+        ${this.q("claimed_at")} bigint,
+        ${this.q("created_at")} bigint NOT NULL
+      )`);
+    await this.exec.query(`CREATE TABLE IF NOT EXISTS ${results} (
+        ${this.q("step_id")} ${str} PRIMARY KEY,
+        ${this.q("run_id")} ${str} NOT NULL,
+        ${this.q("seq")} integer NOT NULL,
+        ${this.q("status")} varchar(32) NOT NULL,
+        ${this.q("output")} ${txt},
+        ${this.q("error")} ${txt},
+        ${this.q("started_at")} bigint,
+        ${this.q("claimed_by")} ${str},
+        ${this.q("claimed_at")} bigint,
+        ${this.q("created_at")} bigint NOT NULL
+      )`);
+    await this.exec.query(`CREATE INDEX ${this.q(`${this.tasksTable}_grp_idx`)} ON ${tasks} (${this.q("grp")}, ${this.q("status")}, ${this.q("created_at")})`).catch(() => {
+    });
+  }
+  // ── engine → worker ────────────────────────────────────────────────────────────────────────
+  async dispatch(task) {
+    await this.ensureSchema();
+    const t = this.q(this.tasksTable);
+    const ignore = this.isPg ? `INSERT INTO ${t} (...) ON CONFLICT (${this.q("step_id")}) DO NOTHING` : `INSERT IGNORE INTO ${t} (...)`;
+    const cols = [
+      "step_id",
+      "run_id",
+      "seq",
+      "name",
+      "grp",
+      "input",
+      "attempt",
+      "status",
+      "created_at"
+    ];
+    const sql = ignore.replace("(...)", `(${cols.map((c) => this.q(c)).join(", ")}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(", ")})`);
+    await this.exec.query(sql, [
+      task.stepId,
+      task.runId,
+      task.seq,
+      task.name,
+      task.group,
+      JSON.stringify(task.input ?? null),
+      task.attempt,
+      "pending",
+      this.now()
+    ]);
+  }
+  // ── worker → engine ────────────────────────────────────────────────────────────────────────
+  handle(name, fn) {
+    if (!this.group) throw new Error("DbTransport needs a `group` to register handlers");
+    this.handlers.set(name, fn);
+    if (!this.taskLoop) this.taskLoop = this.loop(() => this.drainTasks(this.group));
+  }
+  onResult(handler) {
+    if (!this.resultLoop) this.resultLoop = this.loop(() => this.drainResults(handler));
+  }
+  onHeartbeat(_handler) {
+  }
+  // ── polling ──────────────────────────────────────────────────────────────────────────────────
+  /** Run `tick` repeatedly; sleep `pollMs` when it reports an empty queue. Stops on `close()`. */
+  async loop(tick) {
+    await this.ensureSchema();
+    while (this.running) {
+      let processed = 0;
+      try {
+        processed = await tick();
+      } catch (err) {
+        if (this.running) console.error("[DbTransport] poll failed", err);
+      }
+      if (processed === 0) await this.sleep(this.pollMs);
+    }
+  }
+  /** Claim a batch of tasks (FOR UPDATE SKIP LOCKED), then run each outside the lock. */
+  async drainTasks(group) {
+    const claimed = await this.claim(this.tasksTable, `${this.q("grp")} = ${this.ph(1)}`, [
+      group
+    ]);
+    for (const row of claimed) {
+      const task = {
+        runId: row.run_id,
+        seq: Number(row.seq),
+        stepId: row.step_id,
+        name: row.name,
+        group,
+        input: row.input == null ? void 0 : JSON.parse(row.input),
+        attempt: Number(row.attempt)
+      };
+      const result = await (0, import_nestjs_durable_core.runStepHandler)(task, this.handlers.get(task.name));
+      await this.insertResult(result);
+      await this.exec.query(`DELETE FROM ${this.q(this.tasksTable)} WHERE ${this.q("step_id")} = ${this.ph(1)}`, [
+        task.stepId
+      ]);
+    }
+    return claimed.length;
+  }
+  /** Claim a batch of results, deliver each to the engine, then delete it. */
+  async drainResults(handler) {
+    const claimed = await this.claim(this.resultsTable, "1 = 1", []);
+    for (const row of claimed) {
+      const result = {
+        runId: row.run_id,
+        seq: Number(row.seq),
+        stepId: row.step_id,
+        status: row.status,
+        output: row.output == null ? void 0 : JSON.parse(row.output),
+        error: row.error == null ? void 0 : JSON.parse(row.error),
+        startedAt: row.started_at == null ? void 0 : Number(row.started_at)
+      };
+      await handler(result);
+      await this.exec.query(`DELETE FROM ${this.q(this.resultsTable)} WHERE ${this.q("step_id")} = ${this.ph(1)}`, [
+        result.stepId
+      ]);
+    }
+    return claimed.length;
+  }
+  /**
+  * Atomically claim up to `batchSize` un-leased rows matching `where` and stamp them with this
+  * instance's lease. `SELECT … FOR UPDATE SKIP LOCKED` inside the txn means concurrent instances
+  * skip each other's locked rows instead of blocking, so no row is claimed twice.
+  */
+  async claim(table, where, whereParams) {
+    const t = this.q(table);
+    const staleBefore = this.now() - this.leaseMs;
+    return this.exec.transaction(async (tx) => {
+      const leaseClause = `(${this.q("claimed_at")} IS NULL OR ${this.q("claimed_at")} < ${this.ph(whereParams.length + 1)})`;
+      const rows = await tx.query(`SELECT * FROM ${t} WHERE ${where} AND ${leaseClause}
+         ORDER BY ${this.q("created_at")} ASC LIMIT ${this.batchSize} FOR UPDATE SKIP LOCKED`, [
+        ...whereParams,
+        staleBefore
+      ]);
+      if (rows.length > 0) {
+        const ids = rows.map((r) => r.step_id);
+        const placeholders = ids.map((_, i) => this.ph(i + 3)).join(", ");
+        await tx.query(`UPDATE ${t} SET ${this.q("claimed_by")} = ${this.ph(1)}, ${this.q("claimed_at")} = ${this.ph(2)}
+           WHERE ${this.q("step_id")} IN (${placeholders})`, [
+          this.instanceId,
+          this.now(),
+          ...ids
+        ]);
+      }
+      return rows;
+    });
+  }
+  async insertResult(result) {
+    const t = this.q(this.resultsTable);
+    const cols = [
+      "step_id",
+      "run_id",
+      "seq",
+      "status",
+      "output",
+      "error",
+      "started_at",
+      "created_at"
+    ];
+    const head = this.isPg ? `INSERT INTO ${t} (...) ON CONFLICT (${this.q("step_id")}) DO NOTHING` : `INSERT IGNORE INTO ${t} (...)`;
+    const sql = head.replace("(...)", `(${cols.map((c) => this.q(c)).join(", ")}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(", ")})`);
+    await this.exec.query(sql, [
+      result.stepId,
+      result.runId,
+      result.seq,
+      result.status,
+      result.output === void 0 ? null : JSON.stringify(result.output),
+      result.error === void 0 ? null : JSON.stringify(result.error),
+      result.startedAt ?? null,
+      this.now()
+    ]);
+  }
+  sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+  /** Stop the pollers and wait for the current ticks to settle. Does not close the shared DataSource. */
+  async close() {
+    this.running = false;
+    await Promise.allSettled([
+      this.taskLoop,
+      this.resultLoop
+    ]);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DbTransport,
+  mikroOrmExecutor,
+  typeOrmExecutor
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/db-transport.ts","../src/executors.ts"],"sourcesContent":["export * from './db-transport';\n","import {\n  type Heartbeat,\n  type RemoteTask,\n  type StepHandler,\n  type StepResult,\n  type Transport,\n  runStepHandler,\n} from '@dudousxd/nestjs-durable-core';\nimport type { SqlExecutor } from './executors';\n\nexport { mikroOrmExecutor, type SqlExecutor, type SqlTx, typeOrmExecutor } from './executors';\n\n/** Raw row shapes returned by `SELECT *` (declared fields, so they're not `| undefined` under noUncheckedIndexedAccess). */\ninterface TaskRow {\n  step_id: string;\n  run_id: string;\n  seq: string | number;\n  name: string;\n  input: string | null;\n  attempt: string | number;\n}\ninterface ResultRow {\n  step_id: string;\n  run_id: string;\n  seq: string | number;\n  status: string;\n  output: string | null;\n  error: string | null;\n  started_at: string | number | null;\n}\n\nexport interface DbTransportOptions {\n  /**\n   * How to run SQL — built from the app's **own** ORM/connection (no broker, no extra connection).\n   * Use `mikroOrmExecutor(em)` to ride the app's MikroORM, `typeOrmExecutor(dataSource)` for TypeORM,\n   * or implement `SqlExecutor` for anything else.\n   */\n  executor: SqlExecutor;\n  /** The worker group this instance serves. Required to register `handle()` consumers. */\n  group?: string;\n  /** Table-name prefix. Tables: `${prefix}_transport_tasks` / `${prefix}_transport_results`. Default `durable`. */\n  prefix?: string;\n  /** Poll interval in ms when a queue is empty. Default 500. */\n  pollMs?: number;\n  /** How long a claimed row is owned before it's reclaimable (crash recovery), in ms. Default 30_000. */\n  leaseMs?: number;\n  /** Max rows claimed per poll. Default 10. */\n  batchSize?: number;\n  /** Create the two tables on first use if missing. Default true. */\n  autoCreate?: boolean;\n  /** Identifies this instance in `claimed_by` (for debugging). Defaults to a random id. */\n  instanceId?: string;\n}\n\n/**\n * A SQL-backed `Transport` — DBOS-style. Instead of a broker (Redis/SQS), remote steps are **rows**\n * in the same database the durable store already uses: `dispatch` inserts a task row, a worker\n * claims it with `SELECT … FOR UPDATE SKIP LOCKED` (so instances never double-claim), runs it, and\n * writes a result row the engine polls. Zero new infrastructure — the DB you already have IS the\n * queue.\n *\n * Trade-off vs a real broker: throughput is bounded by polling + row contention. Great for\n * workflow/pipeline scale (modest rate, long steps); not for high-fanout firehoses.\n *\n * Requires `FOR UPDATE SKIP LOCKED` — **MySQL 8+** or **Postgres 9.5+** (not SQLite). Run one\n * instance engine-side (`onResult`, dispatches) and one per worker process (`handle()` for its group).\n */\nexport class DbTransport implements Transport {\n  private readonly exec: SqlExecutor;\n  private readonly group?: string | undefined;\n  private readonly tasksTable: string;\n  private readonly resultsTable: string;\n  private readonly pollMs: number;\n  private readonly leaseMs: number;\n  private readonly batchSize: number;\n  private readonly autoCreate: boolean;\n  private readonly instanceId: string;\n  private readonly isPg: boolean;\n\n  private readonly handlers = new Map<string, StepHandler>();\n  private running = true;\n  private schemaReady?: Promise<void>;\n  private taskLoop?: Promise<void>;\n  private resultLoop?: Promise<void>;\n\n  constructor(options: DbTransportOptions) {\n    this.exec = options.executor;\n    this.group = options.group;\n    const prefix = options.prefix ?? 'durable';\n    this.tasksTable = `${prefix}_transport_tasks`;\n    this.resultsTable = `${prefix}_transport_results`;\n    this.pollMs = options.pollMs ?? 500;\n    this.leaseMs = options.leaseMs ?? 30_000;\n    this.batchSize = options.batchSize ?? 10;\n    this.autoCreate = options.autoCreate ?? true;\n    this.instanceId = options.instanceId ?? `db-${Math.floor(Date.now()).toString(36)}`;\n    this.isPg = this.exec.dialect === 'postgres';\n  }\n\n  // ── dialect helpers ──────────────────────────────────────────────────────────────────────────\n  /** Positional placeholder for param `i` (1-based): `$i` on Postgres, `?` elsewhere. */\n  private ph(i: number): string {\n    return this.isPg ? `$${i}` : '?';\n  }\n  private q(id: string): string {\n    return this.exec.escapeId(id);\n  }\n  private now(): number {\n    return Math.floor(Date.now());\n  }\n\n  // ── schema ───────────────────────────────────────────────────────────────────────────────────\n  private ensureSchema(): Promise<void> {\n    if (!this.schemaReady) this.schemaReady = this.createTables();\n    return this.schemaReady;\n  }\n\n  private async createTables(): Promise<void> {\n    if (!this.autoCreate) return;\n    const str = 'varchar(191)';\n    const txt = this.isPg ? 'text' : 'longtext';\n    const tasks = this.q(this.tasksTable);\n    const results = this.q(this.resultsTable);\n    await this.exec.query(\n      `CREATE TABLE IF NOT EXISTS ${tasks} (\n        ${this.q('step_id')} ${str} PRIMARY KEY,\n        ${this.q('run_id')} ${str} NOT NULL,\n        ${this.q('seq')} integer NOT NULL,\n        ${this.q('name')} ${str} NOT NULL,\n        ${this.q('grp')} ${str} NOT NULL,\n        ${this.q('input')} ${txt},\n        ${this.q('attempt')} integer NOT NULL,\n        ${this.q('status')} varchar(32) NOT NULL,\n        ${this.q('claimed_by')} ${str},\n        ${this.q('claimed_at')} bigint,\n        ${this.q('created_at')} bigint NOT NULL\n      )`,\n    );\n    await this.exec.query(\n      `CREATE TABLE IF NOT EXISTS ${results} (\n        ${this.q('step_id')} ${str} PRIMARY KEY,\n        ${this.q('run_id')} ${str} NOT NULL,\n        ${this.q('seq')} integer NOT NULL,\n        ${this.q('status')} varchar(32) NOT NULL,\n        ${this.q('output')} ${txt},\n        ${this.q('error')} ${txt},\n        ${this.q('started_at')} bigint,\n        ${this.q('claimed_by')} ${str},\n        ${this.q('claimed_at')} bigint,\n        ${this.q('created_at')} bigint NOT NULL\n      )`,\n    );\n    // Best-effort index for the group poll (MySQL has no CREATE INDEX IF NOT EXISTS < 8.0.13).\n    await this.exec\n      .query(\n        `CREATE INDEX ${this.q(`${this.tasksTable}_grp_idx`)} ON ${tasks} (${this.q('grp')}, ${this.q('status')}, ${this.q('created_at')})`,\n      )\n      .catch(() => {});\n  }\n\n  // ── engine → worker ────────────────────────────────────────────────────────────────────────\n  async dispatch(task: RemoteTask): Promise<void> {\n    await this.ensureSchema();\n    const t = this.q(this.tasksTable);\n    // Idempotent: a redelivered dispatch for the same step_id is ignored (the row already exists).\n    const ignore = this.isPg\n      ? `INSERT INTO ${t} (...) ON CONFLICT (${this.q('step_id')}) DO NOTHING`\n      : `INSERT IGNORE INTO ${t} (...)`;\n    const cols = ['step_id', 'run_id', 'seq', 'name', 'grp', 'input', 'attempt', 'status', 'created_at'];\n    const sql = ignore.replace(\n      '(...)',\n      `(${cols.map((c) => this.q(c)).join(', ')}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(', ')})`,\n    );\n    await this.exec.query(sql, [\n      task.stepId,\n      task.runId,\n      task.seq,\n      task.name,\n      task.group,\n      JSON.stringify(task.input ?? null),\n      task.attempt,\n      'pending',\n      this.now(),\n    ]);\n  }\n\n  // ── worker → engine ────────────────────────────────────────────────────────────────────────\n  handle(name: string, fn: StepHandler): void {\n    if (!this.group) throw new Error('DbTransport needs a `group` to register handlers');\n    this.handlers.set(name, fn);\n    if (!this.taskLoop) this.taskLoop = this.loop(() => this.drainTasks(this.group as string));\n  }\n\n  onResult(handler: (result: StepResult) => Promise<void>): void {\n    if (!this.resultLoop) this.resultLoop = this.loop(() => this.drainResults(handler));\n  }\n\n  onHeartbeat(_handler: (beat: Heartbeat) => Promise<void>): void {\n    // Not modelled; the lease/reclaim on `claimed_at` is the liveness mechanism.\n  }\n\n  // ── polling ──────────────────────────────────────────────────────────────────────────────────\n  /** Run `tick` repeatedly; sleep `pollMs` when it reports an empty queue. Stops on `close()`. */\n  private async loop(tick: () => Promise<number>): Promise<void> {\n    await this.ensureSchema();\n    while (this.running) {\n      let processed = 0;\n      try {\n        processed = await tick();\n      } catch (err) {\n        if (this.running) console.error('[DbTransport] poll failed', err);\n      }\n      if (processed === 0) await this.sleep(this.pollMs);\n    }\n  }\n\n  /** Claim a batch of tasks (FOR UPDATE SKIP LOCKED), then run each outside the lock. */\n  private async drainTasks(group: string): Promise<number> {\n    const claimed = await this.claim<TaskRow>(\n      this.tasksTable,\n      `${this.q('grp')} = ${this.ph(1)}`,\n      [group],\n    );\n    for (const row of claimed) {\n      const task: RemoteTask = {\n        runId: row.run_id,\n        seq: Number(row.seq),\n        stepId: row.step_id,\n        name: row.name,\n        group,\n        input: row.input == null ? undefined : JSON.parse(row.input),\n        attempt: Number(row.attempt),\n      };\n      const result = await runStepHandler(task, this.handlers.get(task.name));\n      await this.insertResult(result);\n      await this.exec.query(\n        `DELETE FROM ${this.q(this.tasksTable)} WHERE ${this.q('step_id')} = ${this.ph(1)}`,\n        [task.stepId],\n      );\n    }\n    return claimed.length;\n  }\n\n  /** Claim a batch of results, deliver each to the engine, then delete it. */\n  private async drainResults(handler: (result: StepResult) => Promise<void>): Promise<number> {\n    const claimed = await this.claim<ResultRow>(this.resultsTable, '1 = 1', []);\n    for (const row of claimed) {\n      const result: StepResult = {\n        runId: row.run_id,\n        seq: Number(row.seq),\n        stepId: row.step_id,\n        status: row.status as StepResult['status'],\n        output: row.output == null ? undefined : JSON.parse(row.output),\n        error: row.error == null ? undefined : JSON.parse(row.error),\n        startedAt: row.started_at == null ? undefined : Number(row.started_at),\n      };\n      await handler(result);\n      await this.exec.query(\n        `DELETE FROM ${this.q(this.resultsTable)} WHERE ${this.q('step_id')} = ${this.ph(1)}`,\n        [result.stepId],\n      );\n    }\n    return claimed.length;\n  }\n\n  /**\n   * Atomically claim up to `batchSize` un-leased rows matching `where` and stamp them with this\n   * instance's lease. `SELECT … FOR UPDATE SKIP LOCKED` inside the txn means concurrent instances\n   * skip each other's locked rows instead of blocking, so no row is claimed twice.\n   */\n  private async claim<T extends { step_id: string }>(\n    table: string,\n    where: string,\n    whereParams: unknown[],\n  ): Promise<T[]> {\n    const t = this.q(table);\n    const staleBefore = this.now() - this.leaseMs;\n    return this.exec.transaction(async (tx) => {\n      const leaseClause = `(${this.q('claimed_at')} IS NULL OR ${this.q('claimed_at')} < ${this.ph(whereParams.length + 1)})`;\n      const rows = await tx.query<T>(\n        `SELECT * FROM ${t} WHERE ${where} AND ${leaseClause}\n         ORDER BY ${this.q('created_at')} ASC LIMIT ${this.batchSize} FOR UPDATE SKIP LOCKED`,\n        [...whereParams, staleBefore],\n      );\n      if (rows.length > 0) {\n        const ids = rows.map((r) => r.step_id);\n        const placeholders = ids.map((_, i) => this.ph(i + 3)).join(', ');\n        await tx.query(\n          `UPDATE ${t} SET ${this.q('claimed_by')} = ${this.ph(1)}, ${this.q('claimed_at')} = ${this.ph(2)}\n           WHERE ${this.q('step_id')} IN (${placeholders})`,\n          [this.instanceId, this.now(), ...ids],\n        );\n      }\n      return rows;\n    });\n  }\n\n  private async insertResult(result: StepResult): Promise<void> {\n    const t = this.q(this.resultsTable);\n    const cols = ['step_id', 'run_id', 'seq', 'status', 'output', 'error', 'started_at', 'created_at'];\n    const head = this.isPg\n      ? `INSERT INTO ${t} (...) ON CONFLICT (${this.q('step_id')}) DO NOTHING`\n      : `INSERT IGNORE INTO ${t} (...)`;\n    const sql = head.replace(\n      '(...)',\n      `(${cols.map((c) => this.q(c)).join(', ')}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(', ')})`,\n    );\n    await this.exec.query(sql, [\n      result.stepId,\n      result.runId,\n      result.seq,\n      result.status,\n      result.output === undefined ? null : JSON.stringify(result.output),\n      result.error === undefined ? null : JSON.stringify(result.error),\n      result.startedAt ?? null,\n      this.now(),\n    ]);\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise((r) => setTimeout(r, ms));\n  }\n\n  /** Stop the pollers and wait for the current ticks to settle. Does not close the shared DataSource. */\n  async close(): Promise<void> {\n    this.running = false;\n    await Promise.allSettled([this.taskLoop, this.resultLoop]);\n  }\n}\n","/**\n * The tiny SQL surface `DbTransport` needs, so it rides **whatever ORM/connection the app already\n * has** instead of forcing a specific one. Implement it for your ORM (adapters for TypeORM and\n * MikroORM ship below) and hand it to `new DbTransport({ executor })`. Mirrors how the durable\n * *store* is ORM-pluggable (store-typeorm / store-mikro-orm / …).\n */\nexport interface SqlExecutor {\n  /** Drives placeholder style (`$n` vs `?`) and a couple of DDL type choices. */\n  readonly dialect: 'mysql' | 'postgres';\n  /** Quote/escape an identifier (table/column name) for this dialect. */\n  escapeId(id: string): string;\n  /** Run a statement outside a transaction. */\n  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;\n  /** Run `fn` inside a transaction — the claim uses `FOR UPDATE SKIP LOCKED` within it. */\n  transaction<T>(fn: (tx: SqlTx) => Promise<T>): Promise<T>;\n}\n\nexport interface SqlTx {\n  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;\n}\n\n// ── TypeORM ──────────────────────────────────────────────────────────────────────────────────────\n\n/** Structural slice of a TypeORM `DataSource` — avoids a hard dependency on typeorm. */\ninterface TypeOrmDataSourceLike {\n  options: { type: string };\n  driver: { escape(id: string): string };\n  query(sql: string, params?: unknown[]): Promise<unknown>;\n  createQueryRunner(): {\n    connect(): Promise<void>;\n    startTransaction(): Promise<void>;\n    commitTransaction(): Promise<void>;\n    rollbackTransaction(): Promise<void>;\n    release(): Promise<void>;\n    query(sql: string, params?: unknown[]): Promise<unknown>;\n  };\n}\n\n/** Build an executor from a TypeORM `DataSource` (e.g. the one the durable store already uses). */\nexport function typeOrmExecutor(ds: TypeOrmDataSourceLike): SqlExecutor {\n  return {\n    dialect: /postgres/.test(String(ds.options.type)) ? 'postgres' : 'mysql',\n    escapeId: (id) => ds.driver.escape(id),\n    query: <T>(sql: string, params?: unknown[]) => ds.query(sql, params) as Promise<T[]>,\n    transaction: async <T>(fn: (tx: SqlTx) => Promise<T>) => {\n      const qr = ds.createQueryRunner();\n      await qr.connect();\n      await qr.startTransaction();\n      try {\n        const result = await fn({\n          query: <U>(sql: string, params?: unknown[]) => qr.query(sql, params) as Promise<U[]>,\n        });\n        await qr.commitTransaction();\n        return result;\n      } catch (err) {\n        await qr.rollbackTransaction();\n        throw err;\n      } finally {\n        await qr.release();\n      }\n    },\n  };\n}\n\n// ── MikroORM ─────────────────────────────────────────────────────────────────────────────────────\n\n/** Structural slice of a MikroORM `EntityManager` — avoids a hard dependency on @mikro-orm/core. */\ninterface MikroOrmEmLike {\n  getPlatform(): { constructor: { name: string }; quoteIdentifier(id: string): string };\n  getConnection(): {\n    execute(sql: string, params?: unknown[], method?: 'all', ctx?: unknown): Promise<unknown>;\n  };\n  getTransactionContext?(): unknown;\n  transactional<T>(cb: (em: MikroOrmEmLike) => Promise<T>): Promise<T>;\n}\n\n/**\n * Build an executor from a MikroORM `EntityManager` — i.e. **the app's own configured ORM**. Runs\n * raw SQL through `em.getConnection().execute(...)` and wraps the claim in `em.transactional(...)`,\n * threading the transaction context so `FOR UPDATE SKIP LOCKED` locks within the tx.\n */\nexport function mikroOrmExecutor(em: MikroOrmEmLike): SqlExecutor {\n  const platform = em.getPlatform();\n  return {\n    dialect: /postgre/i.test(platform.constructor.name) ? 'postgres' : 'mysql',\n    escapeId: (id) => platform.quoteIdentifier(id),\n    query: <T>(sql: string, params?: unknown[]) =>\n      em.getConnection().execute(sql, params ?? [], 'all') as Promise<T[]>,\n    transaction: <T>(fn: (tx: SqlTx) => Promise<T>) =>\n      em.transactional((txEm) =>\n        fn({\n          query: <U>(sql: string, params?: unknown[]) =>\n            txEm\n              .getConnection()\n              .execute(sql, params ?? [], 'all', txEm.getTransactionContext?.()) as Promise<U[]>,\n        }),\n      ),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;ACAA,iCAOO;;;ACgCA,SAASA,gBAAgBC,IAAyB;AACvD,SAAO;IACLC,SAAS,WAAWC,KAAKC,OAAOH,GAAGI,QAAQC,IAAI,CAAA,IAAK,aAAa;IACjEC,UAAU,wBAACC,OAAOP,GAAGQ,OAAOC,OAAOF,EAAAA,GAAzB;IACVG,OAAO,wBAAIC,KAAaC,WAAuBZ,GAAGU,MAAMC,KAAKC,MAAAA,GAAtD;IACPC,aAAa,8BAAUC,OAAAA;AACrB,YAAMC,KAAKf,GAAGgB,kBAAiB;AAC/B,YAAMD,GAAGE,QAAO;AAChB,YAAMF,GAAGG,iBAAgB;AACzB,UAAI;AACF,cAAMC,SAAS,MAAML,GAAG;UACtBJ,OAAO,wBAAIC,KAAaC,WAAuBG,GAAGL,MAAMC,KAAKC,MAAAA,GAAtD;QACT,CAAA;AACA,cAAMG,GAAGK,kBAAiB;AAC1B,eAAOD;MACT,SAASE,KAAK;AACZ,cAAMN,GAAGO,oBAAmB;AAC5B,cAAMD;MACR,UAAA;AACE,cAAMN,GAAGQ,QAAO;MAClB;IACF,GAhBa;EAiBf;AACF;AAvBgBxB;AA0CT,SAASyB,iBAAiBC,IAAkB;AACjD,QAAMC,WAAWD,GAAGE,YAAW;AAC/B,SAAO;IACL1B,SAAS,WAAWC,KAAKwB,SAAS,YAAYE,IAAI,IAAI,aAAa;IACnEtB,UAAU,wBAACC,OAAOmB,SAASG,gBAAgBtB,EAAAA,GAAjC;IACVG,OAAO,wBAAIC,KAAaC,WACtBa,GAAGK,cAAa,EAAGC,QAAQpB,KAAKC,UAAU,CAAA,GAAI,KAAA,GADzC;IAEPC,aAAa,wBAAIC,OACfW,GAAGO,cAAc,CAACC,SAChBnB,GAAG;MACDJ,OAAO,wBAAIC,KAAaC,WACtBqB,KACGH,cAAa,EACbC,QAAQpB,KAAKC,UAAU,CAAA,GAAI,OAAOqB,KAAKC,wBAAqB,CAAA,GAH1D;IAIT,CAAA,CAAA,GAPS;EASf;AACF;AAjBgBV;;;ADdT,IAAMW,cAAN,MAAMA;EAnEb,OAmEaA;;;EACMC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EAEAC,WAAW,oBAAIC,IAAAA;EACxBC,UAAU;EACVC;EACAC;EACAC;EAER,YAAYC,SAA6B;AACvC,SAAKhB,OAAOgB,QAAQC;AACpB,SAAKhB,QAAQe,QAAQf;AACrB,UAAMiB,SAASF,QAAQE,UAAU;AACjC,SAAKhB,aAAa,GAAGgB,MAAAA;AACrB,SAAKf,eAAe,GAAGe,MAAAA;AACvB,SAAKd,SAASY,QAAQZ,UAAU;AAChC,SAAKC,UAAUW,QAAQX,WAAW;AAClC,SAAKC,YAAYU,QAAQV,aAAa;AACtC,SAAKC,aAAaS,QAAQT,cAAc;AACxC,SAAKC,aAAaQ,QAAQR,cAAc,MAAMW,KAAKC,MAAMC,KAAKC,IAAG,CAAA,EAAIC,SAAS,EAAA,CAAA;AAC9E,SAAKd,OAAO,KAAKT,KAAKwB,YAAY;EACpC;;;EAIQC,GAAGC,GAAmB;AAC5B,WAAO,KAAKjB,OAAO,IAAIiB,CAAAA,KAAM;EAC/B;EACQC,EAAEC,IAAoB;AAC5B,WAAO,KAAK5B,KAAK6B,SAASD,EAAAA;EAC5B;EACQN,MAAc;AACpB,WAAOH,KAAKC,MAAMC,KAAKC,IAAG,CAAA;EAC5B;;EAGQQ,eAA8B;AACpC,QAAI,CAAC,KAAKjB,YAAa,MAAKA,cAAc,KAAKkB,aAAY;AAC3D,WAAO,KAAKlB;EACd;EAEA,MAAckB,eAA8B;AAC1C,QAAI,CAAC,KAAKxB,WAAY;AACtB,UAAMyB,MAAM;AACZ,UAAMC,MAAM,KAAKxB,OAAO,SAAS;AACjC,UAAMyB,QAAQ,KAAKP,EAAE,KAAKzB,UAAU;AACpC,UAAMiC,UAAU,KAAKR,EAAE,KAAKxB,YAAY;AACxC,UAAM,KAAKH,KAAKoC,MACd,8BAA8BF,KAAAA;UAC1B,KAAKP,EAAE,SAAA,CAAA,IAAcK,GAAAA;UACrB,KAAKL,EAAE,QAAA,CAAA,IAAaK,GAAAA;UACpB,KAAKL,EAAE,KAAA,CAAA;UACP,KAAKA,EAAE,MAAA,CAAA,IAAWK,GAAAA;UAClB,KAAKL,EAAE,KAAA,CAAA,IAAUK,GAAAA;UACjB,KAAKL,EAAE,OAAA,CAAA,IAAYM,GAAAA;UACnB,KAAKN,EAAE,SAAA,CAAA;UACP,KAAKA,EAAE,QAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA,IAAiBK,GAAAA;UACxB,KAAKL,EAAE,YAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA;QACT;AAEJ,UAAM,KAAK3B,KAAKoC,MACd,8BAA8BD,OAAAA;UAC1B,KAAKR,EAAE,SAAA,CAAA,IAAcK,GAAAA;UACrB,KAAKL,EAAE,QAAA,CAAA,IAAaK,GAAAA;UACpB,KAAKL,EAAE,KAAA,CAAA;UACP,KAAKA,EAAE,QAAA,CAAA;UACP,KAAKA,EAAE,QAAA,CAAA,IAAaM,GAAAA;UACpB,KAAKN,EAAE,OAAA,CAAA,IAAYM,GAAAA;UACnB,KAAKN,EAAE,YAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA,IAAiBK,GAAAA;UACxB,KAAKL,EAAE,YAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA;QACT;AAGJ,UAAM,KAAK3B,KACRoC,MACC,gBAAgB,KAAKT,EAAE,GAAG,KAAKzB,UAAU,UAAU,CAAA,OAAQgC,KAAAA,KAAU,KAAKP,EAAE,KAAA,CAAA,KAAW,KAAKA,EAAE,QAAA,CAAA,KAAc,KAAKA,EAAE,YAAA,CAAA,GAAgB,EAEpIU,MAAM,MAAA;IAAO,CAAA;EAClB;;EAGA,MAAMC,SAASC,MAAiC;AAC9C,UAAM,KAAKT,aAAY;AACvB,UAAMU,IAAI,KAAKb,EAAE,KAAKzB,UAAU;AAEhC,UAAMuC,SAAS,KAAKhC,OAChB,eAAe+B,CAAAA,uBAAwB,KAAKb,EAAE,SAAA,CAAA,iBAC9C,sBAAsBa,CAAAA;AAC1B,UAAME,OAAO;MAAC;MAAW;MAAU;MAAO;MAAQ;MAAO;MAAS;MAAW;MAAU;;AACvF,UAAMC,MAAMF,OAAOG,QACjB,SACA,IAAIF,KAAKG,IAAI,CAACC,MAAM,KAAKnB,EAAEmB,CAAAA,CAAAA,EAAIC,KAAK,IAAA,CAAA,aAAkBL,KAAKG,IAAI,CAACG,GAAGtB,MAAM,KAAKD,GAAGC,IAAI,CAAA,CAAA,EAAIqB,KAAK,IAAA,CAAA,GAAQ;AAExG,UAAM,KAAK/C,KAAKoC,MAAMO,KAAK;MACzBJ,KAAKU;MACLV,KAAKW;MACLX,KAAKY;MACLZ,KAAKa;MACLb,KAAKtC;MACLoD,KAAKC,UAAUf,KAAKgB,SAAS,IAAA;MAC7BhB,KAAKiB;MACL;MACA,KAAKlC,IAAG;KACT;EACH;;EAGAmC,OAAOL,MAAcM,IAAuB;AAC1C,QAAI,CAAC,KAAKzD,MAAO,OAAM,IAAI0D,MAAM,kDAAA;AACjC,SAAKjD,SAASkD,IAAIR,MAAMM,EAAAA;AACxB,QAAI,CAAC,KAAK5C,SAAU,MAAKA,WAAW,KAAK+C,KAAK,MAAM,KAAKC,WAAW,KAAK7D,KAAK,CAAA;EAChF;EAEA8D,SAASC,SAAsD;AAC7D,QAAI,CAAC,KAAKjD,WAAY,MAAKA,aAAa,KAAK8C,KAAK,MAAM,KAAKI,aAAaD,OAAAA,CAAAA;EAC5E;EAEAE,YAAYC,UAAoD;EAEhE;;;EAIA,MAAcN,KAAKO,MAA4C;AAC7D,UAAM,KAAKtC,aAAY;AACvB,WAAO,KAAKlB,SAAS;AACnB,UAAIyD,YAAY;AAChB,UAAI;AACFA,oBAAY,MAAMD,KAAAA;MACpB,SAASE,KAAK;AACZ,YAAI,KAAK1D,QAAS2D,SAAQC,MAAM,6BAA6BF,GAAAA;MAC/D;AACA,UAAID,cAAc,EAAG,OAAM,KAAKI,MAAM,KAAKrE,MAAM;IACnD;EACF;;EAGA,MAAc0D,WAAW7D,OAAgC;AACvD,UAAMyE,UAAU,MAAM,KAAKC,MACzB,KAAKzE,YACL,GAAG,KAAKyB,EAAE,KAAA,CAAA,MAAY,KAAKF,GAAG,CAAA,CAAA,IAC9B;MAACxB;KAAM;AAET,eAAW2E,OAAOF,SAAS;AACzB,YAAMnC,OAAmB;QACvBW,OAAO0B,IAAIC;QACX1B,KAAK2B,OAAOF,IAAIzB,GAAG;QACnBF,QAAQ2B,IAAIG;QACZ3B,MAAMwB,IAAIxB;QACVnD;QACAsD,OAAOqB,IAAIrB,SAAS,OAAOyB,SAAY3B,KAAK4B,MAAML,IAAIrB,KAAK;QAC3DC,SAASsB,OAAOF,IAAIpB,OAAO;MAC7B;AACA,YAAM0B,SAAS,UAAMC,2CAAe5C,MAAM,KAAK7B,SAAS0E,IAAI7C,KAAKa,IAAI,CAAA;AACrE,YAAM,KAAKiC,aAAaH,MAAAA;AACxB,YAAM,KAAKlF,KAAKoC,MACd,eAAe,KAAKT,EAAE,KAAKzB,UAAU,CAAA,UAAW,KAAKyB,EAAE,SAAA,CAAA,MAAgB,KAAKF,GAAG,CAAA,CAAA,IAC/E;QAACc,KAAKU;OAAO;IAEjB;AACA,WAAOyB,QAAQY;EACjB;;EAGA,MAAcrB,aAAaD,SAAiE;AAC1F,UAAMU,UAAU,MAAM,KAAKC,MAAiB,KAAKxE,cAAc,SAAS,CAAA,CAAE;AAC1E,eAAWyE,OAAOF,SAAS;AACzB,YAAMQ,SAAqB;QACzBhC,OAAO0B,IAAIC;QACX1B,KAAK2B,OAAOF,IAAIzB,GAAG;QACnBF,QAAQ2B,IAAIG;QACZQ,QAAQX,IAAIW;QACZC,QAAQZ,IAAIY,UAAU,OAAOR,SAAY3B,KAAK4B,MAAML,IAAIY,MAAM;QAC9DhB,OAAOI,IAAIJ,SAAS,OAAOQ,SAAY3B,KAAK4B,MAAML,IAAIJ,KAAK;QAC3DiB,WAAWb,IAAIc,cAAc,OAAOV,SAAYF,OAAOF,IAAIc,UAAU;MACvE;AACA,YAAM1B,QAAQkB,MAAAA;AACd,YAAM,KAAKlF,KAAKoC,MACd,eAAe,KAAKT,EAAE,KAAKxB,YAAY,CAAA,UAAW,KAAKwB,EAAE,SAAA,CAAA,MAAgB,KAAKF,GAAG,CAAA,CAAA,IACjF;QAACyD,OAAOjC;OAAO;IAEnB;AACA,WAAOyB,QAAQY;EACjB;;;;;;EAOA,MAAcX,MACZgB,OACAC,OACAC,aACc;AACd,UAAMrD,IAAI,KAAKb,EAAEgE,KAAAA;AACjB,UAAMG,cAAc,KAAKxE,IAAG,IAAK,KAAKjB;AACtC,WAAO,KAAKL,KAAK+F,YAAY,OAAOC,OAAAA;AAClC,YAAMC,cAAc,IAAI,KAAKtE,EAAE,YAAA,CAAA,eAA4B,KAAKA,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAGoE,YAAYP,SAAS,CAAA,CAAA;AAClH,YAAMY,OAAO,MAAMF,GAAG5D,MACpB,iBAAiBI,CAAAA,UAAWoD,KAAAA,QAAaK,WAAAA;oBAC7B,KAAKtE,EAAE,YAAA,CAAA,cAA2B,KAAKrB,SAAS,2BAC5D;WAAIuF;QAAaC;OAAY;AAE/B,UAAII,KAAKZ,SAAS,GAAG;AACnB,cAAMa,MAAMD,KAAKrD,IAAI,CAACuD,MAAMA,EAAErB,OAAO;AACrC,cAAMsB,eAAeF,IAAItD,IAAI,CAACG,GAAGtB,MAAM,KAAKD,GAAGC,IAAI,CAAA,CAAA,EAAIqB,KAAK,IAAA;AAC5D,cAAMiD,GAAG5D,MACP,UAAUI,CAAAA,QAAS,KAAKb,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,KAAO,KAAKE,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA;mBACrF,KAAKE,EAAE,SAAA,CAAA,QAAkB0E,YAAAA,KAClC;UAAC,KAAK7F;UAAY,KAAKc,IAAG;aAAO6E;SAAI;MAEzC;AACA,aAAOD;IACT,CAAA;EACF;EAEA,MAAcb,aAAaH,QAAmC;AAC5D,UAAM1C,IAAI,KAAKb,EAAE,KAAKxB,YAAY;AAClC,UAAMuC,OAAO;MAAC;MAAW;MAAU;MAAO;MAAU;MAAU;MAAS;MAAc;;AACrF,UAAM4D,OAAO,KAAK7F,OACd,eAAe+B,CAAAA,uBAAwB,KAAKb,EAAE,SAAA,CAAA,iBAC9C,sBAAsBa,CAAAA;AAC1B,UAAMG,MAAM2D,KAAK1D,QACf,SACA,IAAIF,KAAKG,IAAI,CAACC,MAAM,KAAKnB,EAAEmB,CAAAA,CAAAA,EAAIC,KAAK,IAAA,CAAA,aAAkBL,KAAKG,IAAI,CAACG,GAAGtB,MAAM,KAAKD,GAAGC,IAAI,CAAA,CAAA,EAAIqB,KAAK,IAAA,CAAA,GAAQ;AAExG,UAAM,KAAK/C,KAAKoC,MAAMO,KAAK;MACzBuC,OAAOjC;MACPiC,OAAOhC;MACPgC,OAAO/B;MACP+B,OAAOK;MACPL,OAAOM,WAAWR,SAAY,OAAO3B,KAAKC,UAAU4B,OAAOM,MAAM;MACjEN,OAAOV,UAAUQ,SAAY,OAAO3B,KAAKC,UAAU4B,OAAOV,KAAK;MAC/DU,OAAOO,aAAa;MACpB,KAAKnE,IAAG;KACT;EACH;EAEQmD,MAAM8B,IAA2B;AACvC,WAAO,IAAIC,QAAQ,CAACJ,MAAMK,WAAWL,GAAGG,EAAAA,CAAAA;EAC1C;;EAGA,MAAMG,QAAuB;AAC3B,SAAK9F,UAAU;AACf,UAAM4F,QAAQG,WAAW;MAAC,KAAK7F;MAAU,KAAKC;KAAW;EAC3D;AACF;","names":["typeOrmExecutor","ds","dialect","test","String","options","type","escapeId","id","driver","escape","query","sql","params","transaction","fn","qr","createQueryRunner","connect","startTransaction","result","commitTransaction","err","rollbackTransaction","release","mikroOrmExecutor","em","platform","getPlatform","name","quoteIdentifier","getConnection","execute","transactional","txEm","getTransactionContext","DbTransport","exec","group","tasksTable","resultsTable","pollMs","leaseMs","batchSize","autoCreate","instanceId","isPg","handlers","Map","running","schemaReady","taskLoop","resultLoop","options","executor","prefix","Math","floor","Date","now","toString","dialect","ph","i","q","id","escapeId","ensureSchema","createTables","str","txt","tasks","results","query","catch","dispatch","task","t","ignore","cols","sql","replace","map","c","join","_","stepId","runId","seq","name","JSON","stringify","input","attempt","handle","fn","Error","set","loop","drainTasks","onResult","handler","drainResults","onHeartbeat","_handler","tick","processed","err","console","error","sleep","claimed","claim","row","run_id","Number","step_id","undefined","parse","result","runStepHandler","get","insertResult","length","status","output","startedAt","started_at","table","where","whereParams","staleBefore","transaction","tx","leaseClause","rows","ids","r","placeholders","head","ms","Promise","setTimeout","close","allSettled"]}

package/dist/{db-transport.d.ts → index.d.cts}

@@ -1,7 +1,66 @@
-import { type Heartbeat, type RemoteTask, type StepHandler, type StepResult, type Transport } from '@dudousxd/nestjs-durable-core';
-import type { SqlExecutor } from './executors';
-export { mikroOrmExecutor, type SqlExecutor, type SqlTx, typeOrmExecutor } from './executors';
-export interface DbTransportOptions {
+import { Transport, RemoteTask, StepHandler, StepResult, Heartbeat } from '@dudousxd/nestjs-durable-core';
+
+/**
+ * The tiny SQL surface `DbTransport` needs, so it rides **whatever ORM/connection the app already
+ * has** instead of forcing a specific one. Implement it for your ORM (adapters for TypeORM and
+ * MikroORM ship below) and hand it to `new DbTransport({ executor })`. Mirrors how the durable
+ * *store* is ORM-pluggable (store-typeorm / store-mikro-orm / …).
+ */
+interface SqlExecutor {
+    /** Drives placeholder style (`$n` vs `?`) and a couple of DDL type choices. */
+    readonly dialect: 'mysql' | 'postgres';
+    /** Quote/escape an identifier (table/column name) for this dialect. */
+    escapeId(id: string): string;
+    /** Run a statement outside a transaction. */
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+    /** Run `fn` inside a transaction — the claim uses `FOR UPDATE SKIP LOCKED` within it. */
+    transaction<T>(fn: (tx: SqlTx) => Promise<T>): Promise<T>;
+}
+interface SqlTx {
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+}
+/** Structural slice of a TypeORM `DataSource` — avoids a hard dependency on typeorm. */
+interface TypeOrmDataSourceLike {
+    options: {
+        type: string;
+    };
+    driver: {
+        escape(id: string): string;
+    };
+    query(sql: string, params?: unknown[]): Promise<unknown>;
+    createQueryRunner(): {
+        connect(): Promise<void>;
+        startTransaction(): Promise<void>;
+        commitTransaction(): Promise<void>;
+        rollbackTransaction(): Promise<void>;
+        release(): Promise<void>;
+        query(sql: string, params?: unknown[]): Promise<unknown>;
+    };
+}
+/** Build an executor from a TypeORM `DataSource` (e.g. the one the durable store already uses). */
+declare function typeOrmExecutor(ds: TypeOrmDataSourceLike): SqlExecutor;
+/** Structural slice of a MikroORM `EntityManager` — avoids a hard dependency on @mikro-orm/core. */
+interface MikroOrmEmLike {
+    getPlatform(): {
+        constructor: {
+            name: string;
+        };
+        quoteIdentifier(id: string): string;
+    };
+    getConnection(): {
+        execute(sql: string, params?: unknown[], method?: 'all', ctx?: unknown): Promise<unknown>;
+    };
+    getTransactionContext?(): unknown;
+    transactional<T>(cb: (em: MikroOrmEmLike) => Promise<T>): Promise<T>;
+}
+/**
+ * Build an executor from a MikroORM `EntityManager` — i.e. **the app's own configured ORM**. Runs
+ * raw SQL through `em.getConnection().execute(...)` and wraps the claim in `em.transactional(...)`,
+ * threading the transaction context so `FOR UPDATE SKIP LOCKED` locks within the tx.
+ */
+declare function mikroOrmExecutor(em: MikroOrmEmLike): SqlExecutor;
+
+interface DbTransportOptions {
     /**
      * How to run SQL — built from the app's **own** ORM/connection (no broker, no extra connection).
      * Use `mikroOrmExecutor(em)` to ride the app's MikroORM, `typeOrmExecutor(dataSource)` for TypeORM,
@@ -36,7 +95,7 @@ export interface DbTransportOptions {
  * Requires `FOR UPDATE SKIP LOCKED` — **MySQL 8+** or **Postgres 9.5+** (not SQLite). Run one
  * instance engine-side (`onResult`, dispatches) and one per worker process (`handle()` for its group).
  */
-export declare class DbTransport implements Transport {
+declare class DbTransport implements Transport {
     private readonly exec;
     private readonly group?;
     private readonly tasksTable;
@@ -80,4 +139,5 @@ export declare class DbTransport implements Transport {
     /** Stop the pollers and wait for the current ticks to settle. Does not close the shared DataSource. */
     close(): Promise<void>;
 }
-//# sourceMappingURL=db-transport.d.ts.map
+
+export { DbTransport, type DbTransportOptions, type SqlExecutor, type SqlTx, mikroOrmExecutor, typeOrmExecutor };

package/dist/index.d.ts

@@ -1,2 +1,143 @@
-export * from './db-transport';
-//# sourceMappingURL=index.d.ts.map
+import { Transport, RemoteTask, StepHandler, StepResult, Heartbeat } from '@dudousxd/nestjs-durable-core';
+
+/**
+ * The tiny SQL surface `DbTransport` needs, so it rides **whatever ORM/connection the app already
+ * has** instead of forcing a specific one. Implement it for your ORM (adapters for TypeORM and
+ * MikroORM ship below) and hand it to `new DbTransport({ executor })`. Mirrors how the durable
+ * *store* is ORM-pluggable (store-typeorm / store-mikro-orm / …).
+ */
+interface SqlExecutor {
+    /** Drives placeholder style (`$n` vs `?`) and a couple of DDL type choices. */
+    readonly dialect: 'mysql' | 'postgres';
+    /** Quote/escape an identifier (table/column name) for this dialect. */
+    escapeId(id: string): string;
+    /** Run a statement outside a transaction. */
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+    /** Run `fn` inside a transaction — the claim uses `FOR UPDATE SKIP LOCKED` within it. */
+    transaction<T>(fn: (tx: SqlTx) => Promise<T>): Promise<T>;
+}
+interface SqlTx {
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+}
+/** Structural slice of a TypeORM `DataSource` — avoids a hard dependency on typeorm. */
+interface TypeOrmDataSourceLike {
+    options: {
+        type: string;
+    };
+    driver: {
+        escape(id: string): string;
+    };
+    query(sql: string, params?: unknown[]): Promise<unknown>;
+    createQueryRunner(): {
+        connect(): Promise<void>;
+        startTransaction(): Promise<void>;
+        commitTransaction(): Promise<void>;
+        rollbackTransaction(): Promise<void>;
+        release(): Promise<void>;
+        query(sql: string, params?: unknown[]): Promise<unknown>;
+    };
+}
+/** Build an executor from a TypeORM `DataSource` (e.g. the one the durable store already uses). */
+declare function typeOrmExecutor(ds: TypeOrmDataSourceLike): SqlExecutor;
+/** Structural slice of a MikroORM `EntityManager` — avoids a hard dependency on @mikro-orm/core. */
+interface MikroOrmEmLike {
+    getPlatform(): {
+        constructor: {
+            name: string;
+        };
+        quoteIdentifier(id: string): string;
+    };
+    getConnection(): {
+        execute(sql: string, params?: unknown[], method?: 'all', ctx?: unknown): Promise<unknown>;
+    };
+    getTransactionContext?(): unknown;
+    transactional<T>(cb: (em: MikroOrmEmLike) => Promise<T>): Promise<T>;
+}
+/**
+ * Build an executor from a MikroORM `EntityManager` — i.e. **the app's own configured ORM**. Runs
+ * raw SQL through `em.getConnection().execute(...)` and wraps the claim in `em.transactional(...)`,
+ * threading the transaction context so `FOR UPDATE SKIP LOCKED` locks within the tx.
+ */
+declare function mikroOrmExecutor(em: MikroOrmEmLike): SqlExecutor;
+
+interface DbTransportOptions {
+    /**
+     * How to run SQL — built from the app's **own** ORM/connection (no broker, no extra connection).
+     * Use `mikroOrmExecutor(em)` to ride the app's MikroORM, `typeOrmExecutor(dataSource)` for TypeORM,
+     * or implement `SqlExecutor` for anything else.
+     */
+    executor: SqlExecutor;
+    /** The worker group this instance serves. Required to register `handle()` consumers. */
+    group?: string;
+    /** Table-name prefix. Tables: `${prefix}_transport_tasks` / `${prefix}_transport_results`. Default `durable`. */
+    prefix?: string;
+    /** Poll interval in ms when a queue is empty. Default 500. */
+    pollMs?: number;
+    /** How long a claimed row is owned before it's reclaimable (crash recovery), in ms. Default 30_000. */
+    leaseMs?: number;
+    /** Max rows claimed per poll. Default 10. */
+    batchSize?: number;
+    /** Create the two tables on first use if missing. Default true. */
+    autoCreate?: boolean;
+    /** Identifies this instance in `claimed_by` (for debugging). Defaults to a random id. */
+    instanceId?: string;
+}
+/**
+ * A SQL-backed `Transport` — DBOS-style. Instead of a broker (Redis/SQS), remote steps are **rows**
+ * in the same database the durable store already uses: `dispatch` inserts a task row, a worker
+ * claims it with `SELECT … FOR UPDATE SKIP LOCKED` (so instances never double-claim), runs it, and
+ * writes a result row the engine polls. Zero new infrastructure — the DB you already have IS the
+ * queue.
+ *
+ * Trade-off vs a real broker: throughput is bounded by polling + row contention. Great for
+ * workflow/pipeline scale (modest rate, long steps); not for high-fanout firehoses.
+ *
+ * Requires `FOR UPDATE SKIP LOCKED` — **MySQL 8+** or **Postgres 9.5+** (not SQLite). Run one
+ * instance engine-side (`onResult`, dispatches) and one per worker process (`handle()` for its group).
+ */
+declare class DbTransport implements Transport {
+    private readonly exec;
+    private readonly group?;
+    private readonly tasksTable;
+    private readonly resultsTable;
+    private readonly pollMs;
+    private readonly leaseMs;
+    private readonly batchSize;
+    private readonly autoCreate;
+    private readonly instanceId;
+    private readonly isPg;
+    private readonly handlers;
+    private running;
+    private schemaReady?;
+    private taskLoop?;
+    private resultLoop?;
+    constructor(options: DbTransportOptions);
+    /** Positional placeholder for param `i` (1-based): `$i` on Postgres, `?` elsewhere. */
+    private ph;
+    private q;
+    private now;
+    private ensureSchema;
+    private createTables;
+    dispatch(task: RemoteTask): Promise<void>;
+    handle(name: string, fn: StepHandler): void;
+    onResult(handler: (result: StepResult) => Promise<void>): void;
+    onHeartbeat(_handler: (beat: Heartbeat) => Promise<void>): void;
+    /** Run `tick` repeatedly; sleep `pollMs` when it reports an empty queue. Stops on `close()`. */
+    private loop;
+    /** Claim a batch of tasks (FOR UPDATE SKIP LOCKED), then run each outside the lock. */
+    private drainTasks;
+    /** Claim a batch of results, deliver each to the engine, then delete it. */
+    private drainResults;
+    /**
+     * Atomically claim up to `batchSize` un-leased rows matching `where` and stamp them with this
+     * instance's lease. `SELECT … FOR UPDATE SKIP LOCKED` inside the txn means concurrent instances
+     * skip each other's locked rows instead of blocking, so no row is claimed twice.
+     */
+    private claim;
+    private insertResult;
+    private sleep;
+    /** Stop the pollers and wait for the current ticks to settle. Does not close the shared DataSource. */
+    close(): Promise<void>;
+}
+
+export { DbTransport, type DbTransportOptions, type SqlExecutor, type SqlTx, mikroOrmExecutor, typeOrmExecutor };