@cnstra/pg-boss 0.1.0 → 0.3.0

package/dist/postgres-progress.js

@@ -0,0 +1,142 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/postgres-progress.ts
+var postgres_progress_exports = {};
+__export(postgres_progress_exports, {
+  CNSPgBossProgressRepository: () => CNSPgBossProgressRepository,
+  DEFAULT_TABLE: () => DEFAULT_TABLE,
+  assertSafeTable: () => assertSafeTable,
+  ensureSchema: () => ensureSchema,
+  pgBossProgressSchemaSql: () => pgBossProgressSchemaSql
+});
+module.exports = __toCommonJS(postgres_progress_exports);
+
+// src/CNSPgBossProgressRepository.ts
+var import_pg = require("pg");
+
+// src/migrate.ts
+var DEFAULT_TABLE = "cns_pgboss_progress";
+function assertSafeTable(table) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table)) {
+    throw new Error(`[@cnstra/pg-boss] unsafe progress table name: ${JSON.stringify(table)}`);
+  }
+  return table;
+}
+__name(assertSafeTable, "assertSafeTable");
+function pgBossProgressSchemaSql(table = DEFAULT_TABLE) {
+  assertSafeTable(table);
+  return `CREATE TABLE IF NOT EXISTS ${table} (
+    key text PRIMARY KEY,
+    progress jsonb NOT NULL,
+    updated_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS ${table}_updated_idx ON ${table} (updated_at)`;
+}
+__name(pgBossProgressSchemaSql, "pgBossProgressSchemaSql");
+async function ensureSchema(db, table = DEFAULT_TABLE) {
+  await db.query(pgBossProgressSchemaSql(table));
+}
+__name(ensureSchema, "ensureSchema");
+
+// src/CNSPgBossProgressRepository.ts
+var _CNSPgBossProgressRepository = class _CNSPgBossProgressRepository {
+  constructor(opts) {
+    __publicField(this, "pool");
+    __publicField(this, "ownsPool");
+    __publicField(this, "table");
+    __publicField(this, "autoMigrate");
+    __publicField(this, "ready");
+    var _a, _b;
+    if (opts.pool) {
+      this.pool = opts.pool;
+      this.ownsPool = false;
+    } else if (opts.connectionString) {
+      this.pool = new import_pg.Pool({
+        connectionString: opts.connectionString
+      });
+      this.ownsPool = true;
+    } else {
+      throw new Error("[@cnstra/pg-boss] CNSPgBossProgressRepository needs `connectionString` or `pool`");
+    }
+    this.table = assertSafeTable((_a = opts.table) != null ? _a : DEFAULT_TABLE);
+    this.autoMigrate = (_b = opts.autoMigrate) != null ? _b : true;
+  }
+  ensure() {
+    var _a;
+    if (!this.autoMigrate) return Promise.resolve();
+    return (_a = this.ready) != null ? _a : this.ready = ensureSchema(this.pool, this.table);
+  }
+  async save(key, progress) {
+    await this.ensure();
+    await this.pool.query(`INSERT INTO ${this.table} (key, progress, updated_at)
+             VALUES ($1, $2::jsonb, now())
+             ON CONFLICT (key) DO UPDATE SET progress = EXCLUDED.progress, updated_at = now()`, [
+      key,
+      JSON.stringify(progress)
+    ]);
+  }
+  async load(key) {
+    var _a;
+    await this.ensure();
+    const res = await this.pool.query(`SELECT progress FROM ${this.table} WHERE key = $1`, [
+      key
+    ]);
+    return (_a = res.rows[0]) == null ? void 0 : _a.progress;
+  }
+  async delete(key) {
+    await this.ensure();
+    await this.pool.query(`DELETE FROM ${this.table} WHERE key = $1`, [
+      key
+    ]);
+  }
+  /**
+   * Prune rows not touched for `olderThanMs` — the safety net for jobs that failed
+   * PERMANENTLY (retries exhausted): their frontier row is never `delete`d (pg-boss
+   * has no terminal-failure hook), so it would leak. A still-retrying job keeps its
+   * `updated_at` fresh, so choose a threshold comfortably larger than your longest
+   * retry backoff window and run this on a schedule. Returns the number of rows removed.
+   */
+  async deleteStale(olderThanMs) {
+    var _a;
+    await this.ensure();
+    const res = await this.pool.query(`DELETE FROM ${this.table}
+             WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')`, [
+      Math.max(0, Math.floor(olderThanMs))
+    ]);
+    return (_a = res.rowCount) != null ? _a : 0;
+  }
+  /** Close the owned pool (no-op when a pool was injected). */
+  async close() {
+    if (this.ownsPool) await this.pool.end();
+  }
+};
+__name(_CNSPgBossProgressRepository, "CNSPgBossProgressRepository");
+var CNSPgBossProgressRepository = _CNSPgBossProgressRepository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CNSPgBossProgressRepository,
+  DEFAULT_TABLE,
+  assertSafeTable,
+  ensureSchema,
+  pgBossProgressSchemaSql
+});
+//# sourceMappingURL=postgres-progress.js.map

package/dist/postgres-progress.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/postgres-progress.ts","../src/CNSPgBossProgressRepository.ts","../src/migrate.ts"],"sourcesContent":["/**\n * Opt-in Postgres progress store for pg-boss — import from\n * `@cnstra/pg-boss/postgres-progress` (this subpath pulls in `pg`; the main\n * `@cnstra/pg-boss` entry does not).\n */\nexport {\n    CNSPgBossProgressRepository,\n    type TCNSPgBossProgressRepositoryOptions,\n} from './CNSPgBossProgressRepository';\nexport {\n    ensureSchema,\n    pgBossProgressSchemaSql,\n    assertSafeTable,\n    DEFAULT_TABLE,\n    type IPgQueryable,\n} from './migrate';\n","/**\n * Postgres-backed resume-progress store for pg-boss, keyed by the pg-boss **job id**.\n *\n * In pg-boss a run = stimulation = job (one entity), so the checkpoint is keyed by\n * `job.id`; there is no separate run store. pg-boss can't hold arbitrary per-hop\n * progress on its job row (its `Job` has data/output/signal but no mutable progress\n * field), so the frontier lives in its own table (`cns_pgboss_progress`, default) on\n * the same Postgres. One upserted row per key; dropped when the job completes.\n *\n * OPTIONAL: this is an opt-in export (`@cnstra/pg-boss/postgres-progress`) — importing\n * `@cnstra/pg-boss` (worker/enqueue) does NOT pull in `pg`. It's just one\n * `ICNSProgressRepository`; the progress store is independent of the broker, so you can\n * run pg-boss with `@cnstra/progress-redis` (or any impl) instead.\n */\nimport { Pool } from 'pg';\nimport type { ICNSProgressRepository } from '@cnstra/persist';\nimport type { TCNSProgress } from '@cnstra/persist-dto';\nimport { DEFAULT_TABLE, assertSafeTable, ensureSchema } from './migrate';\n\nexport interface TCNSPgBossProgressRepositoryOptions {\n    /** Connection string (a Pool is created and owned by the repo). */\n    connectionString?: string;\n    /** Or inject an existing pg Pool (not closed by `close()`). */\n    pool?: Pool;\n    /** Table name (default `cns_pgboss_progress`). */\n    table?: string;\n    /** Lazily `ensureSchema` on first use (default true). Set false to manage migrations yourself. */\n    autoMigrate?: boolean;\n}\n\nexport class CNSPgBossProgressRepository implements ICNSProgressRepository {\n    private readonly pool: Pool;\n    private readonly ownsPool: boolean;\n    private readonly table: string;\n    private readonly autoMigrate: boolean;\n    private ready: Promise<void> | undefined;\n\n    constructor(opts: TCNSPgBossProgressRepositoryOptions) {\n        if (opts.pool) {\n            this.pool = opts.pool;\n            this.ownsPool = false;\n        } else if (opts.connectionString) {\n            this.pool = new Pool({ connectionString: opts.connectionString });\n            this.ownsPool = true;\n        } else {\n            throw new Error(\n                '[@cnstra/pg-boss] CNSPgBossProgressRepository needs `connectionString` or `pool`'\n            );\n        }\n        this.table = assertSafeTable(opts.table ?? DEFAULT_TABLE);\n        this.autoMigrate = opts.autoMigrate ?? true;\n    }\n\n    private ensure(): Promise<void> {\n        if (!this.autoMigrate) return Promise.resolve();\n        return (this.ready ??= ensureSchema(this.pool, this.table));\n    }\n\n    async save(key: string, progress: TCNSProgress): Promise<void> {\n        await this.ensure();\n        await this.pool.query(\n            `INSERT INTO ${this.table} (key, progress, updated_at)\n             VALUES ($1, $2::jsonb, now())\n             ON CONFLICT (key) DO UPDATE SET progress = EXCLUDED.progress, updated_at = now()`,\n            [key, JSON.stringify(progress)]\n        );\n    }\n\n    async load(key: string): Promise<TCNSProgress | undefined> {\n        await this.ensure();\n        const res = await this.pool.query<{ progress: TCNSProgress }>(\n            `SELECT progress FROM ${this.table} WHERE key = $1`,\n            [key]\n        );\n        return res.rows[0]?.progress;\n    }\n\n    async delete(key: string): Promise<void> {\n        await this.ensure();\n        await this.pool.query(`DELETE FROM ${this.table} WHERE key = $1`, [key]);\n    }\n\n    /**\n     * Prune rows not touched for `olderThanMs` — the safety net for jobs that failed\n     * PERMANENTLY (retries exhausted): their frontier row is never `delete`d (pg-boss\n     * has no terminal-failure hook), so it would leak. A still-retrying job keeps its\n     * `updated_at` fresh, so choose a threshold comfortably larger than your longest\n     * retry backoff window and run this on a schedule. Returns the number of rows removed.\n     */\n    async deleteStale(olderThanMs: number): Promise<number> {\n        await this.ensure();\n        const res = await this.pool.query(\n            `DELETE FROM ${this.table}\n             WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')`,\n            [Math.max(0, Math.floor(olderThanMs))]\n        );\n        return res.rowCount ?? 0;\n    }\n\n    /** Close the owned pool (no-op when a pool was injected). */\n    async close(): Promise<void> {\n        if (this.ownsPool) await this.pool.end();\n    }\n}\n","/**\n * Schema / migrations for the pg-boss progress table (`cns_pgboss_progress`).\n *\n * The package OWNS this schema so you can manage it explicitly (a migration step in\n * your own tooling) instead of relying on the repository's lazy auto-create. Run it\n * via the `cnstra-pgboss-progress migrate` CLI, or call `ensureSchema(db)` yourself\n * with any pg client/pool.\n */\n\n/** Minimal pg client surface (a `pg` Pool or Client satisfies it). */\nexport interface IPgQueryable {\n    query(text: string, params?: unknown[]): Promise<{ rows: unknown[] }>;\n}\n\nexport const DEFAULT_TABLE = 'cns_pgboss_progress';\n\n/** Guard the table identifier (it is interpolated into DDL/DML, not parameterised). */\nexport function assertSafeTable(table: string): string {\n    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table)) {\n        throw new Error(\n            `[@cnstra/pg-boss] unsafe progress table name: ${JSON.stringify(table)}`\n        );\n    }\n    return table;\n}\n\n/** The CREATE TABLE for the progress store. One upserted row per key (job id). */\nexport function pgBossProgressSchemaSql(table: string = DEFAULT_TABLE): string {\n    assertSafeTable(table);\n    // `updated_at` + its index back `deleteStale()`: a row is deleted when its job\n    // succeeds, but a job that fails PERMANENTLY (retries exhausted) leaves its row —\n    // pg-boss has no terminal-failure hook to key off. Pruning by staleness collects\n    // those, and the index keeps the sweep cheap.\n    return `CREATE TABLE IF NOT EXISTS ${table} (\n    key text PRIMARY KEY,\n    progress jsonb NOT NULL,\n    updated_at timestamptz NOT NULL DEFAULT now()\n);\nCREATE INDEX IF NOT EXISTS ${table}_updated_idx ON ${table} (updated_at)`;\n}\n\n/** Idempotently create the progress table. Safe to run repeatedly. */\nexport async function ensureSchema(\n    db: IPgQueryable,\n    table: string = DEFAULT_TABLE\n): Promise<void> {\n    await db.query(pgBossProgressSchemaSql(table));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;ACcA,gBAAqB;;;ACAd,IAAMA,gBAAgB;AAGtB,SAASC,gBAAgBC,OAAa;AACzC,MAAI,CAAC,2BAA2BC,KAAKD,KAAAA,GAAQ;AACzC,UAAM,IAAIE,MACN,iDAAiDC,KAAKC,UAAUJ,KAAAA,CAAAA,EAAQ;EAEhF;AACA,SAAOA;AACX;AAPgBD;AAUT,SAASM,wBAAwBL,QAAgBF,eAAa;AACjEC,kBAAgBC,KAAAA;AAKhB,SAAO,8BAA8BA,KAAAA;;;;;6BAKZA,KAAAA,mBAAwBA,KAAAA;AACrD;AAZgBK;AAehB,eAAsBC,aAClBC,IACAP,QAAgBF,eAAa;AAE7B,QAAMS,GAAGC,MAAMH,wBAAwBL,KAAAA,CAAAA;AAC3C;AALsBM;;;ADZf,IAAMG,+BAAN,MAAMA,6BAAAA;EAOT,YAAYC,MAA2C;AANtCC;AACAC;AACAC;AACAC;AACTC;AAnCZ;AAsCQ,QAAIL,KAAKC,MAAM;AACX,WAAKA,OAAOD,KAAKC;AACjB,WAAKC,WAAW;IACpB,WAAWF,KAAKM,kBAAkB;AAC9B,WAAKL,OAAO,IAAIM,eAAK;QAAED,kBAAkBN,KAAKM;MAAiB,CAAA;AAC/D,WAAKJ,WAAW;IACpB,OAAO;AACH,YAAM,IAAIM,MACN,kFAAA;IAER;AACA,SAAKL,QAAQM,iBAAgBT,UAAKG,UAALH,YAAcU,aAAAA;AAC3C,SAAKN,eAAcJ,UAAKI,gBAALJ,YAAoB;EAC3C;EAEQW,SAAwB;AArDpC;AAsDQ,QAAI,CAAC,KAAKP,YAAa,QAAOQ,QAAQC,QAAO;AAC7C,YAAQ,UAAKR,UAAL,iBAAKA,QAAUS,aAAa,KAAKb,MAAM,KAAKE,KAAK;EAC7D;EAEA,MAAMY,KAAKC,KAAaC,UAAuC;AAC3D,UAAM,KAAKN,OAAM;AACjB,UAAM,KAAKV,KAAKiB,MACZ,eAAe,KAAKf,KAAK;;gGAGzB;MAACa;MAAKG,KAAKC,UAAUH,QAAAA;KAAU;EAEvC;EAEA,MAAMI,KAAKL,KAAgD;AApE/D;AAqEQ,UAAM,KAAKL,OAAM;AACjB,UAAMW,MAAM,MAAM,KAAKrB,KAAKiB,MACxB,wBAAwB,KAAKf,KAAK,mBAClC;MAACa;KAAI;AAET,YAAOM,SAAIC,KAAK,CAAA,MAATD,mBAAaL;EACxB;EAEA,MAAMO,OAAOR,KAA4B;AACrC,UAAM,KAAKL,OAAM;AACjB,UAAM,KAAKV,KAAKiB,MAAM,eAAe,KAAKf,KAAK,mBAAmB;MAACa;KAAI;EAC3E;;;;;;;;EASA,MAAMS,YAAYC,aAAsC;AAzF5D;AA0FQ,UAAM,KAAKf,OAAM;AACjB,UAAMW,MAAM,MAAM,KAAKrB,KAAKiB,MACxB,eAAe,KAAKf,KAAK;kFAEzB;MAACwB,KAAKC,IAAI,GAAGD,KAAKE,MAAMH,WAAAA,CAAAA;KAAc;AAE1C,YAAOJ,SAAIQ,aAAJR,YAAgB;EAC3B;;EAGA,MAAMS,QAAuB;AACzB,QAAI,KAAK7B,SAAU,OAAM,KAAKD,KAAK+B,IAAG;EAC1C;AACJ;AAzEajC;AAAN,IAAMA,8BAAN;","names":["DEFAULT_TABLE","assertSafeTable","table","test","Error","JSON","stringify","pgBossProgressSchemaSql","ensureSchema","db","query","CNSPgBossProgressRepository","opts","pool","ownsPool","table","autoMigrate","ready","connectionString","Pool","Error","assertSafeTable","DEFAULT_TABLE","ensure","Promise","resolve","ensureSchema","save","key","progress","query","JSON","stringify","load","res","rows","delete","deleteStale","olderThanMs","Math","max","floor","rowCount","close","end"]}

package/dist/postgres-progress.mjs

@@ -0,0 +1,94 @@
+import {
+  DEFAULT_TABLE,
+  assertSafeTable,
+  ensureSchema,
+  pgBossProgressSchemaSql
+} from "./chunk-XJFC72LU.mjs";
+import {
+  __name,
+  __publicField
+} from "./chunk-2JTKI4GS.mjs";
+
+// src/CNSPgBossProgressRepository.ts
+import { Pool } from "pg";
+var _CNSPgBossProgressRepository = class _CNSPgBossProgressRepository {
+  constructor(opts) {
+    __publicField(this, "pool");
+    __publicField(this, "ownsPool");
+    __publicField(this, "table");
+    __publicField(this, "autoMigrate");
+    __publicField(this, "ready");
+    var _a, _b;
+    if (opts.pool) {
+      this.pool = opts.pool;
+      this.ownsPool = false;
+    } else if (opts.connectionString) {
+      this.pool = new Pool({
+        connectionString: opts.connectionString
+      });
+      this.ownsPool = true;
+    } else {
+      throw new Error("[@cnstra/pg-boss] CNSPgBossProgressRepository needs `connectionString` or `pool`");
+    }
+    this.table = assertSafeTable((_a = opts.table) != null ? _a : DEFAULT_TABLE);
+    this.autoMigrate = (_b = opts.autoMigrate) != null ? _b : true;
+  }
+  ensure() {
+    var _a;
+    if (!this.autoMigrate) return Promise.resolve();
+    return (_a = this.ready) != null ? _a : this.ready = ensureSchema(this.pool, this.table);
+  }
+  async save(key, progress) {
+    await this.ensure();
+    await this.pool.query(`INSERT INTO ${this.table} (key, progress, updated_at)
+             VALUES ($1, $2::jsonb, now())
+             ON CONFLICT (key) DO UPDATE SET progress = EXCLUDED.progress, updated_at = now()`, [
+      key,
+      JSON.stringify(progress)
+    ]);
+  }
+  async load(key) {
+    var _a;
+    await this.ensure();
+    const res = await this.pool.query(`SELECT progress FROM ${this.table} WHERE key = $1`, [
+      key
+    ]);
+    return (_a = res.rows[0]) == null ? void 0 : _a.progress;
+  }
+  async delete(key) {
+    await this.ensure();
+    await this.pool.query(`DELETE FROM ${this.table} WHERE key = $1`, [
+      key
+    ]);
+  }
+  /**
+   * Prune rows not touched for `olderThanMs` — the safety net for jobs that failed
+   * PERMANENTLY (retries exhausted): their frontier row is never `delete`d (pg-boss
+   * has no terminal-failure hook), so it would leak. A still-retrying job keeps its
+   * `updated_at` fresh, so choose a threshold comfortably larger than your longest
+   * retry backoff window and run this on a schedule. Returns the number of rows removed.
+   */
+  async deleteStale(olderThanMs) {
+    var _a;
+    await this.ensure();
+    const res = await this.pool.query(`DELETE FROM ${this.table}
+             WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')`, [
+      Math.max(0, Math.floor(olderThanMs))
+    ]);
+    return (_a = res.rowCount) != null ? _a : 0;
+  }
+  /** Close the owned pool (no-op when a pool was injected). */
+  async close() {
+    if (this.ownsPool) await this.pool.end();
+  }
+};
+__name(_CNSPgBossProgressRepository, "CNSPgBossProgressRepository");
+var CNSPgBossProgressRepository = _CNSPgBossProgressRepository;
+export {
+  CNSPgBossProgressRepository,
+  DEFAULT_TABLE,
+  assertSafeTable,
+  ensureSchema,
+  pgBossProgressSchemaSql
+};
+//# sourceMappingURL=postgres-progress.mjs.map

package/dist/postgres-progress.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/CNSPgBossProgressRepository.ts"],"sourcesContent":["/**\n * Postgres-backed resume-progress store for pg-boss, keyed by the pg-boss **job id**.\n *\n * In pg-boss a run = stimulation = job (one entity), so the checkpoint is keyed by\n * `job.id`; there is no separate run store. pg-boss can't hold arbitrary per-hop\n * progress on its job row (its `Job` has data/output/signal but no mutable progress\n * field), so the frontier lives in its own table (`cns_pgboss_progress`, default) on\n * the same Postgres. One upserted row per key; dropped when the job completes.\n *\n * OPTIONAL: this is an opt-in export (`@cnstra/pg-boss/postgres-progress`) — importing\n * `@cnstra/pg-boss` (worker/enqueue) does NOT pull in `pg`. It's just one\n * `ICNSProgressRepository`; the progress store is independent of the broker, so you can\n * run pg-boss with `@cnstra/progress-redis` (or any impl) instead.\n */\nimport { Pool } from 'pg';\nimport type { ICNSProgressRepository } from '@cnstra/persist';\nimport type { TCNSProgress } from '@cnstra/persist-dto';\nimport { DEFAULT_TABLE, assertSafeTable, ensureSchema } from './migrate';\n\nexport interface TCNSPgBossProgressRepositoryOptions {\n    /** Connection string (a Pool is created and owned by the repo). */\n    connectionString?: string;\n    /** Or inject an existing pg Pool (not closed by `close()`). */\n    pool?: Pool;\n    /** Table name (default `cns_pgboss_progress`). */\n    table?: string;\n    /** Lazily `ensureSchema` on first use (default true). Set false to manage migrations yourself. */\n    autoMigrate?: boolean;\n}\n\nexport class CNSPgBossProgressRepository implements ICNSProgressRepository {\n    private readonly pool: Pool;\n    private readonly ownsPool: boolean;\n    private readonly table: string;\n    private readonly autoMigrate: boolean;\n    private ready: Promise<void> | undefined;\n\n    constructor(opts: TCNSPgBossProgressRepositoryOptions) {\n        if (opts.pool) {\n            this.pool = opts.pool;\n            this.ownsPool = false;\n        } else if (opts.connectionString) {\n            this.pool = new Pool({ connectionString: opts.connectionString });\n            this.ownsPool = true;\n        } else {\n            throw new Error(\n                '[@cnstra/pg-boss] CNSPgBossProgressRepository needs `connectionString` or `pool`'\n            );\n        }\n        this.table = assertSafeTable(opts.table ?? DEFAULT_TABLE);\n        this.autoMigrate = opts.autoMigrate ?? true;\n    }\n\n    private ensure(): Promise<void> {\n        if (!this.autoMigrate) return Promise.resolve();\n        return (this.ready ??= ensureSchema(this.pool, this.table));\n    }\n\n    async save(key: string, progress: TCNSProgress): Promise<void> {\n        await this.ensure();\n        await this.pool.query(\n            `INSERT INTO ${this.table} (key, progress, updated_at)\n             VALUES ($1, $2::jsonb, now())\n             ON CONFLICT (key) DO UPDATE SET progress = EXCLUDED.progress, updated_at = now()`,\n            [key, JSON.stringify(progress)]\n        );\n    }\n\n    async load(key: string): Promise<TCNSProgress | undefined> {\n        await this.ensure();\n        const res = await this.pool.query<{ progress: TCNSProgress }>(\n            `SELECT progress FROM ${this.table} WHERE key = $1`,\n            [key]\n        );\n        return res.rows[0]?.progress;\n    }\n\n    async delete(key: string): Promise<void> {\n        await this.ensure();\n        await this.pool.query(`DELETE FROM ${this.table} WHERE key = $1`, [key]);\n    }\n\n    /**\n     * Prune rows not touched for `olderThanMs` — the safety net for jobs that failed\n     * PERMANENTLY (retries exhausted): their frontier row is never `delete`d (pg-boss\n     * has no terminal-failure hook), so it would leak. A still-retrying job keeps its\n     * `updated_at` fresh, so choose a threshold comfortably larger than your longest\n     * retry backoff window and run this on a schedule. Returns the number of rows removed.\n     */\n    async deleteStale(olderThanMs: number): Promise<number> {\n        await this.ensure();\n        const res = await this.pool.query(\n            `DELETE FROM ${this.table}\n             WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')`,\n            [Math.max(0, Math.floor(olderThanMs))]\n        );\n        return res.rowCount ?? 0;\n    }\n\n    /** Close the owned pool (no-op when a pool was injected). */\n    async close(): Promise<void> {\n        if (this.ownsPool) await this.pool.end();\n    }\n}\n"],"mappings":";;;;;;;;;;;;AAcA,SAASA,YAAY;AAgBd,IAAMC,+BAAN,MAAMA,6BAAAA;EAOT,YAAYC,MAA2C;AANtCC;AACAC;AACAC;AACAC;AACTC;AAnCZ;AAsCQ,QAAIL,KAAKC,MAAM;AACX,WAAKA,OAAOD,KAAKC;AACjB,WAAKC,WAAW;IACpB,WAAWF,KAAKM,kBAAkB;AAC9B,WAAKL,OAAO,IAAIM,KAAK;QAAED,kBAAkBN,KAAKM;MAAiB,CAAA;AAC/D,WAAKJ,WAAW;IACpB,OAAO;AACH,YAAM,IAAIM,MACN,kFAAA;IAER;AACA,SAAKL,QAAQM,iBAAgBT,UAAKG,UAALH,YAAcU,aAAAA;AAC3C,SAAKN,eAAcJ,UAAKI,gBAALJ,YAAoB;EAC3C;EAEQW,SAAwB;AArDpC;AAsDQ,QAAI,CAAC,KAAKP,YAAa,QAAOQ,QAAQC,QAAO;AAC7C,YAAQ,UAAKR,UAAL,iBAAKA,QAAUS,aAAa,KAAKb,MAAM,KAAKE,KAAK;EAC7D;EAEA,MAAMY,KAAKC,KAAaC,UAAuC;AAC3D,UAAM,KAAKN,OAAM;AACjB,UAAM,KAAKV,KAAKiB,MACZ,eAAe,KAAKf,KAAK;;gGAGzB;MAACa;MAAKG,KAAKC,UAAUH,QAAAA;KAAU;EAEvC;EAEA,MAAMI,KAAKL,KAAgD;AApE/D;AAqEQ,UAAM,KAAKL,OAAM;AACjB,UAAMW,MAAM,MAAM,KAAKrB,KAAKiB,MACxB,wBAAwB,KAAKf,KAAK,mBAClC;MAACa;KAAI;AAET,YAAOM,SAAIC,KAAK,CAAA,MAATD,mBAAaL;EACxB;EAEA,MAAMO,OAAOR,KAA4B;AACrC,UAAM,KAAKL,OAAM;AACjB,UAAM,KAAKV,KAAKiB,MAAM,eAAe,KAAKf,KAAK,mBAAmB;MAACa;KAAI;EAC3E;;;;;;;;EASA,MAAMS,YAAYC,aAAsC;AAzF5D;AA0FQ,UAAM,KAAKf,OAAM;AACjB,UAAMW,MAAM,MAAM,KAAKrB,KAAKiB,MACxB,eAAe,KAAKf,KAAK;kFAEzB;MAACwB,KAAKC,IAAI,GAAGD,KAAKE,MAAMH,WAAAA,CAAAA;KAAc;AAE1C,YAAOJ,SAAIQ,aAAJR,YAAgB;EAC3B;;EAGA,MAAMS,QAAuB;AACzB,QAAI,KAAK7B,SAAU,OAAM,KAAKD,KAAK+B,IAAG;EAC1C;AACJ;AAzEajC;AAAN,IAAMA,8BAAN;","names":["Pool","CNSPgBossProgressRepository","opts","pool","ownsPool","table","autoMigrate","ready","connectionString","Pool","Error","assertSafeTable","DEFAULT_TABLE","ensure","Promise","resolve","ensureSchema","save","key","progress","query","JSON","stringify","load","res","rows","delete","deleteStale","olderThanMs","Math","max","floor","rowCount","close","end"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cnstra/pg-boss",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "pg-boss (Postgres) integration for CNStra: run stimulations as jobs and stream per-hop progress",
   "keywords": [
     "cnstra",
@@ -18,34 +18,68 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
+    },
+    "./postgres-progress": {
+      "types": "./dist/postgres-progress.d.ts",
+      "import": "./dist/postgres-progress.mjs",
+      "require": "./dist/postgres-progress.js"
     }
   },
+  "bin": {
+    "cnstra-pgboss-progress": "./dist/cli.js"
+  },
   "sideEffects": false,
   "files": [
     "dist"
   ],
   "scripts": {
     "build": "tsup",
+    "test": "jest",
     "test:types": "tsc --noEmit",
     "clean": "rm -rf dist"
   },
+  "dependencies": {
+    "@cnstra/types": "^0.1.0",
+    "@cnstra/broker": "^0.1.0"
+  },
   "peerDependencies": {
     "@cnstra/core": "^2.4.0",
-    "pg-boss": ">=9"
+    "@cnstra/persist": "^0.1.0",
+    "@cnstra/persist-dto": "^0.1.0",
+    "pg-boss": ">=9",
+    "pg": ">=8"
+  },
+  "devDependencies": {
+    "@cnstra/core": "^2.4.0",
+    "@cnstra/persist": "^0.1.0",
+    "@cnstra/persist-dto": "^0.1.0",
+    "@types/jest": "29.5.12",
+    "@types/pg": "^8.11.0",
+    "jest": "29.7.0",
+    "pg": "^8.11.0",
+    "ts-jest": "29.1.2",
+    "tsup": "8.5.1",
+    "typescript": "5.7.2",
+    "@cnstra/broker": "^0.1.0"
   },
   "peerDependenciesMeta": {
     "pg-boss": {
       "optional": true
+    },
+    "pg": {
+      "optional": true
     }
   },
-  "devDependencies": {
-    "@cnstra/core": "^2.4.0",
-    "tsup": "8.5.1",
-    "typescript": "5.7.2"
-  },
   "author": "Andrei Baikov <abaikov23@gmail.com>",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "postgres-progress": [
+        "./dist/postgres-progress.d.ts"
+      ]
+    }
   }
 }