@dbx-tools/postgres 0.6.62

package/README.md

@@ -0,0 +1,225 @@
+# `@dbx-tools/postgres`
+
+Connection-correct PostgreSQL primitives for Node.js: advisory locks that hold the
+connection they lock, and a structured topic bus over `LISTEN`/`NOTIFY`.
+
+Both work against a plain `pg.Pool` or anything structurally compatible with one,
+including the pool AppKit's Lakebase plugin exports — so a Databricks App gets
+them without a second database client or connection pool.
+
+## Key Features
+
+- Converts an arbitrary structured key (string, array, object, `Date`, or an
+  explicit `bigint`) into a stable signed 64-bit advisory-lock identifier.
+- Derives a legal Postgres channel name from whatever identifies a channel, so no
+  call site has to sanitize an app name or a tenant id into an identifier.
+- Holds a session lock on one dedicated pooled connection for the whole callback,
+  and hands that connection to the callback so protected work runs on it.
+- Holds a transaction lock released atomically by `COMMIT` or `ROLLBACK`, which is
+  what one-time schema installation needs.
+- Broadcasts a `type`/`metadata`/`body` envelope to every listening process over
+  `pg_notify`, filtered by topic in-process.
+- Fills in project, machine, process, deployment, and optional AppKit sender
+  context automatically, with caller metadata always winning.
+- Rejects a payload that would not survive a JSON round trip unchanged, at the
+  call site rather than on the wire.
+- Reconnects a dropped listener with bounded backoff while subscribers remain.
+
+## Advisory Locks
+
+```ts
+import { withAdvisoryLock } from "@dbx-tools/postgres";
+import { Pool } from "pg";
+
+const pool = new Pool();
+
+await withAdvisoryLock(pool, ["invoice", invoiceId], async (client) => {
+  await client.query("UPDATE invoices SET status = 'sent' WHERE id = $1", [invoiceId]);
+});
+```
+
+Run the protected work on the `client` the callback receives. A `pool.query()`
+inside the callback may land on a different connection, which is not the one
+holding the lock.
+
+Use the transaction-scoped helper for one-time database work:
+
+```ts
+import { withAdvisoryTransactionLock } from "@dbx-tools/postgres";
+
+await withAdvisoryTransactionLock(pool, { schema: "my_feature", version: 1 }, async (client) => {
+  await client.query("CREATE TABLE IF NOT EXISTS my_feature.events (id bigint primary key)");
+});
+```
+
+`advisoryLockId(key)` exposes the same reduction on its own. A `bigint` key is
+used directly (narrowed to 64 bits) rather than hashed, so a lock can interoperate
+with another implementation that publishes its numeric lock id — `pgmq`'s
+installer lock, for instance. Anything else is canonicalized with
+`object.toStableKey` from `@dbx-tools/shared-core` and hashed, so key order in an
+object does not matter while a `1` and a `"1"` stay different locks. An array is
+read as several parts, so `["invoice", 7]` and `"invoice_7"` are different locks. A
+non-finite number or a cyclic key throws `TypeError` rather than yielding an
+identity two callers could disagree about.
+
+## Topic Bus
+
+```ts
+import { PostgresTopicBus } from "@dbx-tools/postgres";
+
+const bus = new PostgresTopicBus(pool, {
+  metadata: async () => ({ publicIp: await resolvePublicIp() }),
+  onError: (cause) => logger.error("bus", { cause }),
+});
+
+const unsubscribe = await bus.listen("orders", ({ type, metadata, body }) => {
+  console.log(type, metadata.project, body);
+});
+
+await bus.broadcast("orders", {
+  type: "order.updated",
+  metadata: { traceId: "abc-123" },
+  body: { orderId: "123", status: "ready" },
+});
+
+await unsubscribe();
+await bus.close();
+```
+
+Every process listening on the channel receives every message; there are no
+competing consumers. That makes the bus right for live fan-out — an SSE stream per
+browser tab, a cache invalidation, a presence ping — and wrong for work
+distribution. Use a table or a queue when a subscriber needs acks or replay.
+
+### The Envelope
+
+| Field         | Source | Notes                                                              |
+| ------------- | ------ | ------------------------------------------------------------------ |
+| `id`          | bus    | Unique per message across instances. Use it to dedupe or as `id:`. |
+| `topic`       | bus    | The `broadcast` topic. Listeners on other topics never see it.     |
+| `type`        | caller | Event name, e.g. `order.updated`. Required, non-blank.             |
+| `metadata`    | merged | Automatic context under the caller's. See below.                   |
+| `body`        | caller | Passed through unchanged.                                          |
+| `publishedAt` | bus    | ISO-8601, from the publisher's clock — not the database's.         |
+
+`publishedAt` and `id` are for display and dedupe. Neither orders messages from
+different instances reliably.
+
+### Metadata Precedence
+
+Weakest to strongest: automatic machine context, then AppKit sender identity, then
+the bus's `metadata` option, then the per-message `metadata`. A key present at a
+stronger layer is never overwritten, so passing `project` explicitly replaces the
+inferred one.
+
+Automatic keys, each omitted when it resolves to nothing: `project` (from
+`DATABRICKS_APP_NAME`, `DATABRICKS_BUNDLE_NAME`, `PROJECT_NAME`, or
+`npm_package_name`), `publicIp` (from `PUBLIC_IP`, `DATABRICKS_PUBLIC_IP`, or
+`HOST_IP`), `hostname`, `cwd`, `platform`, `pid`, `environment`, `appName`,
+`deploymentId`, and `databricksHost`. CPU architecture, runtime name, and runtime
+version are left out on purpose: they are constant per deployment and every
+message would pay for them against the payload limit.
+
+`publicIp` is only read from the environment. The bus makes no network call to
+discover one — pass a `metadata` function for that, which is also how to attach
+context a process learns after construction. The function runs on every broadcast,
+so memoize anything expensive.
+
+With the optional `@databricks/appkit` peer installed and a user execution context
+active, `senderId`, `senderName`, and `senderEmail` are added too. AppKit is
+imported lazily and never required; outside a request, or without the package, the
+bus just skips those keys.
+
+### What A Message May Contain
+
+The body and metadata must survive `JSON.parse(JSON.stringify(x))` unchanged, which
+is stricter than `JSON.stringify` not throwing. A `Date` becomes a string, `NaN`
+and `Infinity` become `null`, a `Map` becomes `{}`, and `undefined` vanishes — each
+reaches the listener as something other than what was sent, so all of them throw
+`TypeError` at the call instead. Cycles, functions, symbols, bigints, and class
+instances are rejected for the same reason.
+
+The rule lives in `@dbx-tools/shared-core` as `object.isSerializableValue` and
+`object.SerializableValue`, so a route can apply the same check to an untrusted
+request body and answer 400 rather than 500, and a browser-side caller can share
+the type.
+
+The encoded envelope is capped at 7900 bytes, under PostgreSQL's 8000-byte
+`NOTIFY` limit, and a larger one throws `RangeError`. Automatic metadata counts
+against that, so broadcast a reference and let the receiver fetch anything big.
+
+### Connections, Lifecycle, And Failure
+
+Publishing borrows a pooled connection per call. Listening cannot: `LISTEN` is
+session state, so the bus checks out ONE dedicated client and keeps it for as long
+as it has subscribers, however many topics and listeners are registered. Size the
+pool with that long-lived checkout in mind.
+
+Nothing connects until the first `listen`, or an explicit `start()` when you would
+rather find out about a connection problem at boot. `close()` releases the client
+and is required — register it with the host's shutdown hook. A closed bus stays
+closed and throws instead of silently reconnecting.
+
+When the notification connection drops, the bus reconnects on its own: immediately
+first, then doubling from 250ms to a 5s ceiling, indefinitely, for as long as
+subscribers remain. A Postgres restart or a rotated Lakebase credential recovers
+without intervention. Messages published during the gap are lost. Every failed
+attempt, every dropped connection, and every listener that throws is reported
+through `onError`, which defaults to swallowing them — wire it to a logger in
+anything long-running. A failing listener never affects the publisher or the other
+listeners.
+
+One channel carries many topics, so adding a topic costs nothing; give a genuinely
+high-volume unrelated stream its own channel instead, since every listening
+session decodes every message on the channel.
+
+### Naming A Channel
+
+`channel` takes whatever identifies the channel, not a pre-sanitized identifier —
+a name, a tenant id, a `[env, feature]` pair, a config object. One value or many:
+an array is read as several parts, anything else as one.
+
+```ts
+new PostgresTopicBus(pool, { channel: "billing-events" }).channelName;
+// "billing_events_3x55ck"
+new PostgresTopicBus(pool, { channel: ["billing", "production"] }).channelName;
+// "billing_production_008jgf"
+```
+
+The parts are tokenized into the readable half and a short hash of their canonical
+form (`object.toStableKey`) is appended. The hash is what makes the mapping
+trustworthy: tokenizing alone is lossy, so `my-app`, `my_app`, and `myApp` would
+collapse onto one channel, and a name long enough to hit Postgres's 63-character
+limit would collide with anything sharing its leading tokens. With the suffix the
+readable part stays readable and distinct inputs stay distinct — including
+`["billing", "prod"]` versus `"billing_prod"`, which differ in structure.
+
+Derivation is deterministic across processes and runs, so every participant that
+passes equivalent parts lands on the same channel without coordinating. Object key
+order does not matter; a different spelling does. Read `bus.channelName` to see
+what a set of parts resolved to, or to confirm two processes agree. Defaults to a
+shared `dbx_tools_topic_bus` channel.
+
+## Why A Separate Package?
+
+Advisory locks are connection-scoped, and that is easy to get wrong invisibly:
+taking the lock with `pool.query()` and doing the protected work with another
+`pool.query()` can use two different connections, so the lock protects nothing and
+the code looks correct. The same applies to `LISTEN`, which is session state a
+pooled query cannot hold. This package owns both lifecycles once, with no
+dependency beyond `pg`, so a consumer that only needs a lock does not pull in a
+message bus, an AppKit runtime, or a queue extension.
+
+AppKit exposes Lakebase but has no lock helper and no message bus, so there is no
+native surface to prefer here.
+
+## Module Map
+
+| Module         | Purpose                                                            |
+| -------------- | ------------------------------------------------------------------ |
+| `advisoryLock` | Stable lock IDs plus session- and transaction-scoped lock helpers. |
+| `topicBus`     | Structured topic broadcast/listen over PostgreSQL `NOTIFY`.        |
+
+Both modules are also flattened onto the package root, so
+`import { withAdvisoryLock, PostgresTopicBus } from "@dbx-tools/postgres"` works
+without the namespace.

package/index.ts

@@ -0,0 +1,10 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+export * as advisoryLock from "./src/advisory-lock.ts";
+export * as topicBus from "./src/topic-bus.ts";
+export type { AdvisoryLockKey, PgPoolLike, PgQueryable } from "./src/advisory-lock.ts";
+export { PostgresTopicBus } from "./src/topic-bus.ts";
+export type { TopicMetadata, TopicMessage, TopicPublishInput, TopicListener, TopicMetadataProvider, PostgresTopicBusOptions } from "./src/topic-bus.ts";
+export * from "./exports.ts";

package/lib/exports.d.ts

@@ -0,0 +1 @@
+export { advisoryLockId, withAdvisoryLock, withAdvisoryTransactionLock, } from "./src/advisory-lock.ts";

package/lib/exports.js

@@ -0,0 +1,6 @@
+// Flat re-exports layered onto the generated `index.ts` barrel, which publishes
+// each module as a namespace (`advisoryLock`, `topicBus`) and does not lift
+// functions to the package root. These are the call-site names, so they are
+// importable directly from `@dbx-tools/postgres`.
+export { advisoryLockId, withAdvisoryLock, withAdvisoryTransactionLock, } from "./src/advisory-lock.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL2V4cG9ydHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZ0ZBQWdGO0FBQ2hGLDRFQUE0RTtBQUM1RSw0RUFBNEU7QUFDNUUsa0RBQWtEO0FBQ2xELE9BQU8sRUFDTCxjQUFjLEVBQ2QsZ0JBQWdCLEVBQ2hCLDJCQUEyQixHQUM1QixNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gRmxhdCByZS1leHBvcnRzIGxheWVyZWQgb250byB0aGUgZ2VuZXJhdGVkIGBpbmRleC50c2AgYmFycmVsLCB3aGljaCBwdWJsaXNoZXNcbi8vIGVhY2ggbW9kdWxlIGFzIGEgbmFtZXNwYWNlIChgYWR2aXNvcnlMb2NrYCwgYHRvcGljQnVzYCkgYW5kIGRvZXMgbm90IGxpZnRcbi8vIGZ1bmN0aW9ucyB0byB0aGUgcGFja2FnZSByb290LiBUaGVzZSBhcmUgdGhlIGNhbGwtc2l0ZSBuYW1lcywgc28gdGhleSBhcmVcbi8vIGltcG9ydGFibGUgZGlyZWN0bHkgZnJvbSBgQGRieC10b29scy9wb3N0Z3Jlc2AuXG5leHBvcnQge1xuICBhZHZpc29yeUxvY2tJZCxcbiAgd2l0aEFkdmlzb3J5TG9jayxcbiAgd2l0aEFkdmlzb3J5VHJhbnNhY3Rpb25Mb2NrLFxufSBmcm9tIFwiLi9zcmMvYWR2aXNvcnktbG9jay50c1wiO1xuIl19

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * as advisoryLock from "./src/advisory-lock.ts";
+export * as topicBus from "./src/topic-bus.ts";
+export type { AdvisoryLockKey, PgPoolLike, PgQueryable } from "./src/advisory-lock.ts";
+export { PostgresTopicBus } from "./src/topic-bus.ts";
+export type { TopicMetadata, TopicMessage, TopicPublishInput, TopicListener, TopicMetadataProvider, PostgresTopicBusOptions } from "./src/topic-bus.ts";
+export * from "./exports.ts";

package/lib/index.js

@@ -0,0 +1,8 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as advisoryLock from "./src/advisory-lock.js";
+export * as topicBus from "./src/topic-bus.js";
+export { PostgresTopicBus } from "./src/topic-bus.js";
+export * from "./exports.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssWUFBWSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxRQUFRLE1BQU0sb0JBQW9CLENBQUM7QUFFL0MsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFdEQsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBHRU5FUkFURUQgYnkgcHJvamVuIHdhdGNoIC0gRE8gTk9UIEVESVQuXG4vLyBSZWdlbmVyYXRlZCBmcm9tIHRoZSBleHBvcnRpbmcgbW9kdWxlcyBpbiAuL3NyYy5cbi8vIEhhbmQgZWRpdHMgYXJlIG92ZXJ3cml0dGVuIG9uIHRoZSBuZXh0IHdhdGNoOyB0aGlzIGZpbGUgaXMgcmVhZC1vbmx5LlxuXG5leHBvcnQgKiBhcyBhZHZpc29yeUxvY2sgZnJvbSBcIi4vc3JjL2Fkdmlzb3J5LWxvY2sudHNcIjtcbmV4cG9ydCAqIGFzIHRvcGljQnVzIGZyb20gXCIuL3NyYy90b3BpYy1idXMudHNcIjtcbmV4cG9ydCB0eXBlIHsgQWR2aXNvcnlMb2NrS2V5LCBQZ1Bvb2xMaWtlLCBQZ1F1ZXJ5YWJsZSB9IGZyb20gXCIuL3NyYy9hZHZpc29yeS1sb2NrLnRzXCI7XG5leHBvcnQgeyBQb3N0Z3Jlc1RvcGljQnVzIH0gZnJvbSBcIi4vc3JjL3RvcGljLWJ1cy50c1wiO1xuZXhwb3J0IHR5cGUgeyBUb3BpY01ldGFkYXRhLCBUb3BpY01lc3NhZ2UsIFRvcGljUHVibGlzaElucHV0LCBUb3BpY0xpc3RlbmVyLCBUb3BpY01ldGFkYXRhUHJvdmlkZXIsIFBvc3RncmVzVG9waWNCdXNPcHRpb25zIH0gZnJvbSBcIi4vc3JjL3RvcGljLWJ1cy50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZXhwb3J0cy50c1wiO1xuIl19

package/lib/src/advisory-lock.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Advisory-lock helpers for any `pg.Pool`-compatible pool.
+ *
+ * PostgreSQL advisory locks belong to a connection, not a pool. These helpers
+ * reserve one pooled client for the full callback, acquire the lock on that
+ * client, and release both in the correct order.
+ *
+ * @module
+ */
+import type { Pool, PoolClient, QueryResult, QueryResultRow } from "pg";
+/**
+ * What names a lock. Anything reducible to a stable identity: a string, an id, a
+ * `["invoice", id]` pair, a config object, or an explicit `bigint` to interoperate
+ * with another implementation's published lock id.
+ *
+ * One value or many: an array is read as multiple parts, anything else as a single
+ * part. So `["invoice", 7]` and `"invoice_7"` are different locks, since the
+ * canonical form sees different structure.
+ */
+export type AdvisoryLockKey = unknown;
+/** Structural pool shape accepted by the lock helpers. */
+export type PgPoolLike = Pick<Pool, "connect">;
+/** Structural query shape shared by `pg.PoolClient` and AppKit Lakebase. */
+export interface PgQueryable {
+    query<T extends QueryResultRow = QueryResultRow>(text: string, values?: unknown[]): Promise<QueryResult<T>>;
+}
+/**
+ * Convert an arbitrary structured key into PostgreSQL's signed 64-bit advisory
+ * lock namespace. A bigint is preserved directly so callers can interoperate
+ * with another implementation that publishes its lock ID.
+ *
+ * Everything else is canonicalized with `object.toStableKey` and hashed, so key
+ * order in an object does not matter while a `1` and a `"1"` stay different locks.
+ * A cycle, a non-finite number, or a function/symbol key throws `TypeError`
+ * rather than yielding an identity two callers could disagree about.
+ */
+export declare function advisoryLockId(key: AdvisoryLockKey): bigint;
+/**
+ * Hold a session advisory lock for the duration of `fn`.
+ *
+ * The callback receives the dedicated `PoolClient` that owns the lock. Use it
+ * for any operation that must be protected by the lock.
+ */
+export declare function withAdvisoryLock<T>(pool: PgPoolLike, key: AdvisoryLockKey, fn: (client: PoolClient) => Promise<T> | T): Promise<T>;
+/**
+ * Run `fn` in a transaction while holding a transaction advisory lock.
+ *
+ * The lock is released atomically by `COMMIT` or `ROLLBACK`, making this the
+ * right primitive for one-time schema installation and migrations.
+ */
+export declare function withAdvisoryTransactionLock<T>(pool: PgPoolLike, key: AdvisoryLockKey, fn: (client: PoolClient) => Promise<T> | T): Promise<T>;

package/lib/src/advisory-lock.js

@@ -0,0 +1,111 @@
+/**
+ * Advisory-lock helpers for any `pg.Pool`-compatible pool.
+ *
+ * PostgreSQL advisory locks belong to a connection, not a pool. These helpers
+ * reserve one pooled client for the full callback, acquire the lock on that
+ * client, and release both in the correct order.
+ *
+ * @module
+ */
+import { createHash } from "node:crypto";
+import { object } from "@dbx-tools/shared-core";
+const SIGNED_BIGINT_BITS = 64;
+/**
+ * Convert an arbitrary structured key into PostgreSQL's signed 64-bit advisory
+ * lock namespace. A bigint is preserved directly so callers can interoperate
+ * with another implementation that publishes its lock ID.
+ *
+ * Everything else is canonicalized with `object.toStableKey` and hashed, so key
+ * order in an object does not matter while a `1` and a `"1"` stay different locks.
+ * A cycle, a non-finite number, or a function/symbol key throws `TypeError`
+ * rather than yielding an identity two callers could disagree about.
+ */
+export function advisoryLockId(key) {
+    if (typeof key === "bigint")
+        return BigInt.asIntN(SIGNED_BIGINT_BITS, key);
+    const parts = object.toOneOrMany(key);
+    const digest = createHash("sha256")
+        .update(parts.map((part) => object.toStableKey(part)).join("\u0000"))
+        .digest();
+    return digest.readBigInt64BE(0);
+}
+async function acquire(client, id, transaction) {
+    const fn = transaction ? "pg_advisory_xact_lock" : "pg_advisory_lock";
+    await client.query(`SELECT ${fn}($1::bigint)`, [id.toString()]);
+}
+async function unlock(client, id) {
+    const result = await client.query("SELECT pg_advisory_unlock($1::bigint) AS unlocked", [id.toString()]);
+    if (result.rows[0]?.unlocked !== true) {
+        throw new Error(`Postgres advisory lock ${id} was not held by this connection`);
+    }
+}
+/**
+ * Hold a session advisory lock for the duration of `fn`.
+ *
+ * The callback receives the dedicated `PoolClient` that owns the lock. Use it
+ * for any operation that must be protected by the lock.
+ */
+export async function withAdvisoryLock(pool, key, fn) {
+    const id = advisoryLockId(key);
+    const client = await pool.connect();
+    let acquired = false;
+    let failed = false;
+    let failure;
+    let value;
+    try {
+        await acquire(client, id, false);
+        acquired = true;
+        value = await fn(client);
+    }
+    catch (error) {
+        failed = true;
+        failure = error;
+    }
+    let unlockFailure;
+    if (acquired) {
+        try {
+            await unlock(client, id);
+        }
+        catch (error) {
+            unlockFailure = error;
+        }
+    }
+    client.release(unlockFailure instanceof Error ? unlockFailure : undefined);
+    if (failed)
+        throw failure;
+    if (unlockFailure !== undefined)
+        throw unlockFailure;
+    return value;
+}
+/**
+ * Run `fn` in a transaction while holding a transaction advisory lock.
+ *
+ * The lock is released atomically by `COMMIT` or `ROLLBACK`, making this the
+ * right primitive for one-time schema installation and migrations.
+ */
+export async function withAdvisoryTransactionLock(pool, key, fn) {
+    const id = advisoryLockId(key);
+    const client = await pool.connect();
+    let releaseError;
+    try {
+        await client.query("BEGIN");
+        await acquire(client, id, true);
+        const value = await fn(client);
+        await client.query("COMMIT");
+        return value;
+    }
+    catch (error) {
+        try {
+            await client.query("ROLLBACK");
+        }
+        catch (rollbackError) {
+            releaseError =
+                rollbackError instanceof Error ? rollbackError : new Error(String(rollbackError));
+        }
+        throw error;
+    }
+    finally {
+        client.release(releaseError);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock.js","sourceRoot":"","sources":["../../src/advisory-lock.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Advisory-lock helpers for any `pg.Pool`-compatible pool.\n *\n * PostgreSQL advisory locks belong to a connection, not a pool. These helpers\n * reserve one pooled client for the full callback, acquire the lock on that\n * client, and release both in the correct order.\n *\n * @module\n */\n\nimport { createHash } from \"node:crypto\";\nimport { object } from \"@dbx-tools/shared-core\";\nimport type { Pool, PoolClient, QueryResult, QueryResultRow } from \"pg\";\n\nconst SIGNED_BIGINT_BITS = 64;\n\n/**\n * What names a lock. Anything reducible to a stable identity: a string, an id, a\n * `[\"invoice\", id]` pair, a config object, or an explicit `bigint` to interoperate\n * with another implementation's published lock id.\n *\n * One value or many: an array is read as multiple parts, anything else as a single\n * part. So `[\"invoice\", 7]` and `\"invoice_7\"` are different locks, since the\n * canonical form sees different structure.\n */\nexport type AdvisoryLockKey = unknown;\n\n/** Structural pool shape accepted by the lock helpers. */\nexport type PgPoolLike = Pick<Pool, \"connect\">;\n\n/** Structural query shape shared by `pg.PoolClient` and AppKit Lakebase. */\nexport interface PgQueryable {\n  query<T extends QueryResultRow = QueryResultRow>(\n    text: string,\n    values?: unknown[],\n  ): Promise<QueryResult<T>>;\n}\n\ntype UnlockRow = QueryResultRow & { unlocked: boolean };\n\n/**\n * Convert an arbitrary structured key into PostgreSQL's signed 64-bit advisory\n * lock namespace. A bigint is preserved directly so callers can interoperate\n * with another implementation that publishes its lock ID.\n *\n * Everything else is canonicalized with `object.toStableKey` and hashed, so key\n * order in an object does not matter while a `1` and a `\"1\"` stay different locks.\n * A cycle, a non-finite number, or a function/symbol key throws `TypeError`\n * rather than yielding an identity two callers could disagree about.\n */\nexport function advisoryLockId(key: AdvisoryLockKey): bigint {\n  if (typeof key === \"bigint\") return BigInt.asIntN(SIGNED_BIGINT_BITS, key);\n  const parts = object.toOneOrMany(key);\n  const digest = createHash(\"sha256\")\n    .update(parts.map((part) => object.toStableKey(part)).join(\"\\u0000\"))\n    .digest();\n  return digest.readBigInt64BE(0);\n}\n\nasync function acquire(client: PgQueryable, id: bigint, transaction: boolean): Promise<void> {\n  const fn = transaction ? \"pg_advisory_xact_lock\" : \"pg_advisory_lock\";\n  await client.query(`SELECT ${fn}($1::bigint)`, [id.toString()]);\n}\n\nasync function unlock(client: PgQueryable, id: bigint): Promise<void> {\n  const result = await client.query<UnlockRow>(\n    \"SELECT pg_advisory_unlock($1::bigint) AS unlocked\",\n    [id.toString()],\n  );\n  if (result.rows[0]?.unlocked !== true) {\n    throw new Error(`Postgres advisory lock ${id} was not held by this connection`);\n  }\n}\n\n/**\n * Hold a session advisory lock for the duration of `fn`.\n *\n * The callback receives the dedicated `PoolClient` that owns the lock. Use it\n * for any operation that must be protected by the lock.\n */\nexport async function withAdvisoryLock<T>(\n  pool: PgPoolLike,\n  key: AdvisoryLockKey,\n  fn: (client: PoolClient) => Promise<T> | T,\n): Promise<T> {\n  const id = advisoryLockId(key);\n  const client = await pool.connect();\n  let acquired = false;\n  let failed = false;\n  let failure: unknown;\n  let value: T | undefined;\n\n  try {\n    await acquire(client, id, false);\n    acquired = true;\n    value = await fn(client);\n  } catch (error) {\n    failed = true;\n    failure = error;\n  }\n\n  let unlockFailure: unknown;\n  if (acquired) {\n    try {\n      await unlock(client, id);\n    } catch (error) {\n      unlockFailure = error;\n    }\n  }\n  client.release(unlockFailure instanceof Error ? unlockFailure : undefined);\n\n  if (failed) throw failure;\n  if (unlockFailure !== undefined) throw unlockFailure;\n  return value as T;\n}\n\n/**\n * Run `fn` in a transaction while holding a transaction advisory lock.\n *\n * The lock is released atomically by `COMMIT` or `ROLLBACK`, making this the\n * right primitive for one-time schema installation and migrations.\n */\nexport async function withAdvisoryTransactionLock<T>(\n  pool: PgPoolLike,\n  key: AdvisoryLockKey,\n  fn: (client: PoolClient) => Promise<T> | T,\n): Promise<T> {\n  const id = advisoryLockId(key);\n  const client = await pool.connect();\n  let releaseError: Error | undefined;\n  try {\n    await client.query(\"BEGIN\");\n    await acquire(client, id, true);\n    const value = await fn(client);\n    await client.query(\"COMMIT\");\n    return value;\n  } catch (error) {\n    try {\n      await client.query(\"ROLLBACK\");\n    } catch (rollbackError) {\n      releaseError =\n        rollbackError instanceof Error ? rollbackError : new Error(String(rollbackError));\n    }\n    throw error;\n  } finally {\n    client.release(releaseError);\n  }\n}\n"]}