@cnstra/pg-boss 0.1.0 → 0.2.0

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.2.0",
   "description": "pg-boss (Postgres) integration for CNStra: run stimulations as jobs and stream per-hop progress",
   "keywords": [
     "cnstra",
@@ -18,34 +18,66 @@
       "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"
+  },
   "peerDependencies": {
     "@cnstra/core": "^2.4.0",
-    "pg-boss": ">=9"
-  },
-  "peerDependenciesMeta": {
-    "pg-boss": {
-      "optional": true
-    }
+    "@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"
   },
+  "peerDependenciesMeta": {
+    "pg-boss": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
   "author": "Andrei Baikov <abaikov23@gmail.com>",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "postgres-progress": [
+        "./dist/postgres-progress.d.ts"
+      ]
+    }
   }
 }