@dbx-tools/postgres 0.6.62

package/lib/src/topic-bus.js

@@ -0,0 +1,506 @@
+/**
+ * Topic fan-out over PostgreSQL `LISTEN`/`NOTIFY`, for telling every running
+ * instance of an app that something happened.
+ *
+ * The sibling `advisory-lock` module is about making sure only ONE connection
+ * does a thing; this one is the opposite - EVERY listening session gets every
+ * notification. That makes it the right primitive for live UI updates
+ * (an SSE stream per browser tab, a cache invalidation, a presence ping) and the
+ * wrong one for work distribution: there are no competing consumers, no acks, and
+ * no replay.
+ *
+ * Delivery is best-effort and live. `NOTIFY` reaches sessions that are listening
+ * at the moment it commits, so a listener that connects a second later never sees
+ * it, and a listener whose connection drops misses everything until the bus
+ * reconnects. Use a table or a queue when a subscriber needs durability.
+ *
+ * ONE CHANNEL, MANY TOPICS. Every bus instance listens on a single Postgres
+ * channel (`channel`, default `dbx_tools_topic_bus`) and filters by the
+ * envelope's `topic` in-process, so adding a topic costs no connection and no
+ * `LISTEN`. The tradeoff is that every listening session decodes every message on
+ * the channel; give a genuinely high-volume, unrelated stream its own `channel`
+ * rather than a topic.
+ *
+ * @module
+ */
+import { hostname } from "node:os";
+import { async as asyncUtil, error, hash, json, object, string } from "@dbx-tools/shared-core";
+/** Channel parts used when a caller names no channel of its own. */
+const DEFAULT_CHANNEL = "dbx_tools_topic_bus";
+/**
+ * `NAMEDATALEN - 1`. Postgres TRUNCATES a longer channel name rather than
+ * rejecting it, which would split publishers and listeners onto different
+ * channels while every call looked like it succeeded.
+ */
+const MAX_CHANNEL_LENGTH = 63;
+/** Base-32 chars of the channel's identity suffix. Max 7 - the digest is 32 bits. */
+const CHANNEL_HASH_LENGTH = 6;
+/** Body used when the parts tokenize to nothing, or lead with a digit. */
+const CHANNEL_FALLBACK = "bus";
+/**
+ * Encoded-envelope ceiling. PostgreSQL caps a `NOTIFY` payload at 8000 bytes and
+ * fails the statement past that, so the bus rejects the message first with a size
+ * it can name. The margin below 8000 covers the server's own accounting.
+ */
+const MAX_NOTIFY_BYTES = 7_900;
+const MIN_RECONNECT_DELAY_MS = 250;
+const MAX_RECONNECT_DELAY_MS = 5_000;
+/**
+ * Cached result of the one optional-peer import, resolved to `undefined` when
+ * AppKit is not installed. Memoized so a bus in a plain Postgres process pays for
+ * the failed resolution once instead of per broadcast.
+ */
+let appKitModule;
+/**
+ * Drop keys whose value is `undefined`, so an unset environment variable leaves
+ * the key ABSENT rather than present-and-null. Absence is what lets caller
+ * metadata and later merge layers supply the key instead.
+ */
+function definedMetadata(values) {
+    return Object.fromEntries(Object.entries(values).filter((entry) => {
+        return entry[1] !== undefined;
+    }));
+}
+/**
+ * Context every message gets for free: which project, host, process, and
+ * deployment published it.
+ *
+ * Read fresh per broadcast rather than cached, because a long-lived process can
+ * be re-parented (a deployment id appearing after boot). Keys that resolve to
+ * nothing are omitted. Public IP is only read from the environment here - the bus
+ * never makes a network call to discover it; a process that wants a discovered IP
+ * passes a {@link TopicMetadataProvider}.
+ *
+ * Deliberately NOT included: CPU architecture, runtime name, and runtime version.
+ * They are constant per deployment and cost payload bytes against the `NOTIFY`
+ * limit on every single message.
+ */
+function machineMetadata() {
+    return definedMetadata({
+        project: string.firstNonEmpty([
+            process.env.DATABRICKS_APP_NAME,
+            process.env.DATABRICKS_BUNDLE_NAME,
+            process.env.PROJECT_NAME,
+            process.env.npm_package_name,
+        ]) ?? undefined,
+        publicIp: string.firstNonEmpty([
+            process.env.PUBLIC_IP,
+            process.env.DATABRICKS_PUBLIC_IP,
+            process.env.HOST_IP,
+        ]) ?? undefined,
+        hostname: hostname(),
+        cwd: process.cwd(),
+        platform: process.platform,
+        pid: process.pid,
+        environment: string.trimToNull(process.env.NODE_ENV) ?? undefined,
+        appName: string.trimToNull(process.env.DATABRICKS_APP_NAME) ?? undefined,
+        deploymentId: string.trimToNull(process.env.DATABRICKS_APP_DEPLOYMENT_ID) ?? undefined,
+        databricksHost: string.trimToNull(process.env.DATABRICKS_HOST) ?? undefined,
+    });
+}
+/**
+ * Identity of the signed-in user on whose behalf this broadcast happens, when the
+ * process can tell.
+ *
+ * `@databricks/appkit` is an OPTIONAL peer, so the import is lazy and a missing
+ * module is not an error - this is a plain Postgres package that adds sender
+ * identity when it happens to run inside an AppKit app. Outside an active
+ * per-request execution context AppKit throws, which means "no user here", so the
+ * result is empty metadata rather than a failed broadcast.
+ */
+async function senderMetadata() {
+    appKitModule ??= import("@databricks/appkit")
+        .then((module) => module)
+        .catch(() => undefined);
+    const appkit = await appKitModule;
+    if (!appkit)
+        return {};
+    try {
+        const context = appkit.getExecutionContext();
+        return definedMetadata({
+            senderId: string.trimToNull(context.userId) ?? undefined,
+            senderName: string.trimToNull(context.userName) ?? undefined,
+            senderEmail: string.trimToNull(context.userEmail) ?? undefined,
+        });
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Derive a legal Postgres channel name from whatever a caller used to identify
+ * the channel.
+ *
+ * Callers think in terms of what the channel IS - an app name, a tenant id, a
+ * `[env, feature]` pair, a config object - and none of those are identifiers.
+ * Rejecting them pushed the sanitizing onto every call site, which is how two
+ * services end up disagreeing about whether the channel is `my-app`, `my_app`,
+ * or `myApp` and silently never hear each other.
+ *
+ * The parts are tokenized and joined into an identifier, then a short hash of the
+ * ORIGINAL parts is appended. The hash is what makes the mapping trustworthy:
+ * tokenizing alone is lossy, so `my-app` and `my_app` and `myApp` would collapse
+ * onto one channel, and a name long enough to hit `NAMEDATALEN` would collide
+ * with anything sharing its leading tokens. With the suffix, the readable part
+ * stays readable and distinct inputs stay distinct.
+ *
+ * Deterministic across processes and runs, which is the whole point - two
+ * services given the same parts must land on the same channel without
+ * coordinating. Hash inputs are structure-aware, so `["a", "b"]` and `["a_b"]`
+ * differ, and object key order does not.
+ */
+function channelName(parts) {
+    // Hash the CANONICAL form, the same rule `advisoryLockId` uses, so structure and
+    // types decide identity: `["a","b"]` differs from `["ab"]`, `1` from `"1"`, and
+    // object key order does not matter. Hashing the raw parts would instead lean on
+    // the hash module's canonicalizer, which folds every `Date` onto one token.
+    const suffix = hash.fnvHashWithOptions({ length: CHANNEL_HASH_LENGTH }, parts.map((part) => object.toStableKey(part)).join("\u0000"));
+    // Only parts that stringify to something a reader recognizes contribute to the
+    // readable half. An object would tokenize from `String(value)` as
+    // `object_object`, which is noise - it still shapes the hash, so identity is
+    // unaffected.
+    const labelled = parts.filter((part) => {
+        const type = typeof part;
+        return type === "string" || type === "number" || type === "boolean" || type === "bigint";
+    });
+    // Truncate rather than cap through the tokenizer: `trim` would DROP a single
+    // token longer than the budget, turning one long name into the bare fallback and
+    // making every long name look alike. The hash still separates them, but the
+    // channel is unreadable in a log.
+    const body = string
+        .toIdentifierWithOptions({ delimiter: "_" }, ...labelled)
+        .slice(0, MAX_CHANNEL_LENGTH - suffix.length - 1)
+        .replace(/_+$/, "");
+    // An identifier cannot start with a digit and the hash alphabet is
+    // digit-leading, so a numeric or empty body needs a letter in front.
+    const prefix = /^[A-Za-z_]/.test(body) ? body : `${CHANNEL_FALLBACK}_${body}`;
+    return `${prefix}_${suffix}`.replace(/_+/g, "_");
+}
+/** Quote a validated channel for `LISTEN`/`UNLISTEN`, which take no parameters. */
+function quoteIdentifier(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+/**
+ * Parse a `NOTIFY` payload into an envelope, returning `undefined` for anything
+ * that is not one.
+ *
+ * The channel is shared and any Postgres session can `pg_notify` on it, so an
+ * unrecognized payload is expected input, not an exception. Publishers run this
+ * over their own encoded message too, which is how a body that stringifies but
+ * does not round-trip is caught before it ships.
+ */
+function decode(value) {
+    if (!value)
+        return undefined;
+    const record = json.parseRecord(value);
+    if (!record ||
+        typeof record.id !== "string" ||
+        typeof record.topic !== "string" ||
+        typeof record.type !== "string" ||
+        typeof record.publishedAt !== "string" ||
+        !record.metadata ||
+        typeof record.metadata !== "object" ||
+        Array.isArray(record.metadata) ||
+        !("body" in record) ||
+        !object.isSerializableValue(record.metadata) ||
+        !object.isSerializableValue(record.body)) {
+        return undefined;
+    }
+    return {
+        id: record.id,
+        topic: record.topic,
+        type: record.type,
+        metadata: record.metadata,
+        body: record.body,
+        publishedAt: record.publishedAt,
+    };
+}
+/**
+ * Broadcasts structured messages by topic and delivers them to every process
+ * listening on the same channel.
+ *
+ * CONNECTION SHAPE. Publishing borrows a pooled connection per call, like any
+ * other query. Listening cannot: `LISTEN` is session state, so the bus holds ONE
+ * dedicated client out of the pool for as long as it has subscribers, no matter
+ * how many topics or listeners are registered. Size the pool with that one
+ * long-lived checkout in mind.
+ *
+ * LIFECYCLE. Construction is inert - nothing connects until the first
+ * {@link listen} (or an explicit {@link start}). {@link close} is required to give
+ * the connection back; a closed bus stays closed and throws on further use rather
+ * than silently reconnecting. Register it with the host's shutdown hook.
+ *
+ * FAILURE HANDLING. A lost notification connection reconnects on its own with
+ * bounded backoff while subscribers remain, reporting each failed attempt through
+ * `onError`. Messages published during the gap are lost - `NOTIFY` has no replay.
+ * A throwing or rejecting listener never affects the publisher or the other
+ * listeners; its failure goes to `onError`.
+ *
+ * Not safe to share one instance across unrelated channels - construct one bus
+ * per channel. The channel itself is DERIVED from the `channel` option rather
+ * than taken literally; see {@link PostgresTopicBusOptions.channel} and
+ * {@link PostgresTopicBus.channelName}.
+ */
+export class PostgresTopicBus {
+    pool;
+    /**
+     * The resolved Postgres channel this bus listens and publishes on, derived from
+     * the `channel` option. Read it to confirm two processes agree, or to log what a
+     * set of parts actually resolved to.
+     */
+    channelName;
+    metadata;
+    onError;
+    listeners = new Map();
+    client;
+    starting;
+    reconnecting;
+    reconnectAbort = new AbortController();
+    closed = false;
+    constructor(pool, options = {}) {
+        this.pool = pool;
+        this.channelName = channelName(object.toOneOrMany(options.channel === undefined ? DEFAULT_CHANNEL : options.channel));
+        this.metadata = options.metadata;
+        this.onError = options.onError ?? (() => undefined);
+    }
+    /**
+     * Open the dedicated notification connection and `LISTEN`.
+     *
+     * Idempotent, and safe to call concurrently - overlapping calls await the same
+     * in-flight connect. {@link listen} calls this, so it is only needed to surface
+     * a connection problem at startup rather than on first subscribe. Throws if the
+     * bus is closed, or if the pool cannot hand out a connection.
+     */
+    async start() {
+        if (this.client)
+            return;
+        if (this.closed)
+            throw new Error("Postgres topic bus is closed");
+        this.starting ??= this.connect().finally(() => {
+            this.starting = undefined;
+        });
+        await this.starting;
+    }
+    /**
+     * Publish a message to `topic`, returning the envelope that was sent.
+     *
+     * Resolves once Postgres has accepted the `NOTIFY`, which says nothing about
+     * anyone receiving it: sessions not listening at that moment miss it. Publishing
+     * needs no {@link start} and no subscribers.
+     *
+     * Validation is deliberately front-loaded, since a message that fails on the
+     * wire is far harder to diagnose than one rejected at the call: `TypeError` for a
+     * blank topic or type, or a body/metadata that would not round-trip through JSON
+     * unchanged (`object.isSerializableValue`); `RangeError` when the encoded
+     * envelope exceeds the `NOTIFY` payload limit, which the automatic metadata
+     * counts against - send a reference and let the receiver fetch the payload.
+     * Throws if the bus is closed.
+     */
+    async broadcast(topic, input) {
+        if (!topic.trim())
+            throw new TypeError("Topic must not be empty");
+        if (!input.type.trim())
+            throw new TypeError("Message type must not be empty");
+        if (!object.isSerializableValue(input.metadata ?? {}) ||
+            !object.isSerializableValue(input.body)) {
+            throw new TypeError("Message metadata and body must be JSON serializable without coercion");
+        }
+        if (this.closed)
+            throw new Error("Postgres topic bus is closed");
+        const automatic = await this.resolveMetadata();
+        const message = {
+            id: hash.id(),
+            topic,
+            type: input.type,
+            metadata: { ...automatic, ...input.metadata },
+            body: input.body,
+            publishedAt: new Date().toISOString(),
+        };
+        let encoded;
+        try {
+            encoded = JSON.stringify(message);
+        }
+        catch (cause) {
+            throw new TypeError(`Message must be JSON serializable: ${error.errorMessage(cause)}`);
+        }
+        if (!decode(encoded)) {
+            throw new TypeError("Message type, metadata, and body must be JSON serializable");
+        }
+        if (Buffer.byteLength(encoded, "utf8") > MAX_NOTIFY_BYTES) {
+            throw new RangeError(`Postgres notification exceeds ${MAX_NOTIFY_BYTES} bytes`);
+        }
+        await this.pool.query("SELECT pg_notify($1, $2)", [this.channelName, encoded]);
+        return message;
+    }
+    /**
+     * Subscribe to `topic`, returning the function that unsubscribes.
+     *
+     * Connects on first use. Several listeners may share a topic; each is called
+     * once per message. Only messages published AFTER this resolves arrive, so
+     * subscribe before triggering whatever you expect to observe.
+     *
+     * The returned function removes just this listener and is safe to call twice.
+     * The connection stays open once the last listener leaves - {@link close}
+     * releases it - so a bus that subscribes and unsubscribes per request does not
+     * churn connections.
+     */
+    async listen(topic, listener) {
+        if (!topic.trim())
+            throw new TypeError("Topic must not be empty");
+        await this.start();
+        const listeners = this.listeners.get(topic) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(topic, listeners);
+        return async () => {
+            listeners.delete(listener);
+            if (listeners.size === 0)
+                this.listeners.delete(topic);
+        };
+    }
+    /**
+     * Build the automatic half of a message's metadata.
+     *
+     * Precedence, weakest first: machine/process context, then AppKit sender
+     * identity, then this bus's configured metadata. The caller's per-message
+     * metadata is layered over the result in {@link broadcast}, so the most specific
+     * source always wins and nothing here can overwrite an explicit key.
+     */
+    async resolveMetadata() {
+        const sender = await senderMetadata();
+        const configured = typeof this.metadata === "function" ? await this.metadata() : (this.metadata ?? {});
+        return { ...machineMetadata(), ...sender, ...configured };
+    }
+    /**
+     * Release the notification connection and stop delivering messages. Idempotent.
+     *
+     * Cancels any pending reconnect, drops all listeners, then `UNLISTEN`s and
+     * returns the client to the pool. A failed `UNLISTEN` is reported to the pool as
+     * a release error so the connection is DISCARDED rather than handed to the next
+     * caller still subscribed to the channel. Does not throw; the bus stays closed.
+     */
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.reconnectAbort.abort(new Error("Postgres topic bus is closed"));
+        await this.starting?.catch(() => undefined);
+        await this.reconnecting?.catch(() => undefined);
+        const client = this.client;
+        this.client = undefined;
+        this.listeners.clear();
+        if (!client)
+            return;
+        client.removeListener("notification", this.handleNotification);
+        client.removeListener("error", this.handleClientError);
+        let releaseError;
+        try {
+            await client.query(`UNLISTEN ${quoteIdentifier(this.channelName)}`);
+        }
+        catch (cause) {
+            releaseError = error.toError(cause);
+        }
+        client.release(releaseError);
+    }
+    /**
+     * Check out one client, attach the handlers, and `LISTEN`.
+     *
+     * The handlers are attached BEFORE the `LISTEN` round trip so a notification or
+     * error arriving mid-setup is not missed. Any failure - including the bus being
+     * closed while the connect was in flight - detaches the handlers and releases
+     * the client as errored, so a half-configured connection never returns to the
+     * pool.
+     */
+    async connect() {
+        const client = await this.pool.connect();
+        try {
+            client.on("notification", this.handleNotification);
+            client.on("error", this.handleClientError);
+            await client.query(`LISTEN ${quoteIdentifier(this.channelName)}`);
+            if (this.closed)
+                throw new Error("Postgres topic bus is closed");
+            this.client = client;
+        }
+        catch (cause) {
+            client.removeListener("notification", this.handleNotification);
+            client.removeListener("error", this.handleClientError);
+            client.release(error.toError(cause));
+            throw cause;
+        }
+    }
+    /**
+     * Route one inbound notification to the topic's listeners.
+     *
+     * Ignores other channels and undecodable payloads - the channel is shared, so
+     * both are ordinary traffic. Listeners are invoked concurrently and their
+     * rejections go to `onError`, keeping one slow or broken subscriber from
+     * stalling the notification connection.
+     */
+    handleNotification = (notification) => {
+        if (notification.channel !== this.channelName)
+            return;
+        const message = decode(notification.payload);
+        if (!message)
+            return;
+        for (const listener of this.listeners.get(message.topic) ?? []) {
+            Promise.resolve(listener(message)).catch(this.onError);
+        }
+    };
+    /**
+     * Handle the notification connection dying, which `pg` reports as an `error`
+     * event rather than a rejected query.
+     *
+     * The client is unusable at this point, so it is detached and released as
+     * errored (which discards it) before anything else. Reconnection only starts
+     * when there is still someone to deliver to, so an idle or closing bus does not
+     * hold a connection open chasing a channel nobody reads.
+     */
+    handleClientError = (cause) => {
+        this.onError(cause);
+        const client = this.client;
+        if (!client)
+            return;
+        this.client = undefined;
+        client.removeListener("notification", this.handleNotification);
+        client.removeListener("error", this.handleClientError);
+        client.release(cause);
+        if (this.closed || this.listeners.size === 0)
+            return;
+        this.reconnecting ??= this.reconnect().finally(() => {
+            this.reconnecting = undefined;
+        });
+    };
+    /**
+     * Re-establish the notification connection with bounded exponential backoff.
+     *
+     * The first attempt is immediate, since the common case is a single dropped
+     * connection that reconnects at once; subsequent delays double from 250ms up to
+     * 5s and stay there. Retries indefinitely rather than giving up, because a Postgres restart
+     * or a rotated Lakebase credential is a recoverable outage and a silently dead
+     * listener is worse than a noisy one. Stops when the bus closes or the last
+     * listener leaves, and reports every failed attempt through `onError`.
+     */
+    async reconnect() {
+        let delay = 0;
+        while (!this.closed && this.listeners.size > 0) {
+            if (delay > 0) {
+                try {
+                    await asyncUtil.sleep(delay, this.reconnectAbort.signal);
+                }
+                catch {
+                    return;
+                }
+            }
+            try {
+                await this.start();
+                return;
+            }
+            catch (cause) {
+                if (this.closed)
+                    return;
+                this.onError(cause);
+                delay = delay === 0 ? MIN_RECONNECT_DELAY_MS : Math.min(delay * 2, MAX_RECONNECT_DELAY_MS);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"topic-bus.js","sourceRoot":"","sources":["../../src/topic-bus.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Topic fan-out over PostgreSQL `LISTEN`/`NOTIFY`, for telling every running\n * instance of an app that something happened.\n *\n * The sibling `advisory-lock` module is about making sure only ONE connection\n * does a thing; this one is the opposite - EVERY listening session gets every\n * notification. That makes it the right primitive for live UI updates\n * (an SSE stream per browser tab, a cache invalidation, a presence ping) and the\n * wrong one for work distribution: there are no competing consumers, no acks, and\n * no replay.\n *\n * Delivery is best-effort and live. `NOTIFY` reaches sessions that are listening\n * at the moment it commits, so a listener that connects a second later never sees\n * it, and a listener whose connection drops misses everything until the bus\n * reconnects. Use a table or a queue when a subscriber needs durability.\n *\n * ONE CHANNEL, MANY TOPICS. Every bus instance listens on a single Postgres\n * channel (`channel`, default `dbx_tools_topic_bus`) and filters by the\n * envelope's `topic` in-process, so adding a topic costs no connection and no\n * `LISTEN`. The tradeoff is that every listening session decodes every message on\n * the channel; give a genuinely high-volume, unrelated stream its own `channel`\n * rather than a topic.\n *\n * @module\n */\n\nimport { hostname } from \"node:os\";\nimport { async as asyncUtil, error, hash, json, object, string } from \"@dbx-tools/shared-core\";\nimport type { Notification, PoolClient } from \"pg\";\n\nimport type { PgPoolLike, PgQueryable } from \"./advisory-lock.ts\";\n\n/**\n * `@dbx-tools/shared-core` owns the JSON-round-trip rule; this alias just keeps the\n * generic signatures below readable. Consumers import the type from shared-core.\n */\ntype SerializableValue = object.SerializableValue;\n\n/** Channel parts used when a caller names no channel of its own. */\nconst DEFAULT_CHANNEL = \"dbx_tools_topic_bus\";\n/**\n * `NAMEDATALEN - 1`. Postgres TRUNCATES a longer channel name rather than\n * rejecting it, which would split publishers and listeners onto different\n * channels while every call looked like it succeeded.\n */\nconst MAX_CHANNEL_LENGTH = 63;\n/** Base-32 chars of the channel's identity suffix. Max 7 - the digest is 32 bits. */\nconst CHANNEL_HASH_LENGTH = 6;\n/** Body used when the parts tokenize to nothing, or lead with a digit. */\nconst CHANNEL_FALLBACK = \"bus\";\n/**\n * Encoded-envelope ceiling. PostgreSQL caps a `NOTIFY` payload at 8000 bytes and\n * fails the statement past that, so the bus rejects the message first with a size\n * it can name. The margin below 8000 covers the server's own accounting.\n */\nconst MAX_NOTIFY_BYTES = 7_900;\nconst MIN_RECONNECT_DELAY_MS = 250;\nconst MAX_RECONNECT_DELAY_MS = 5_000;\n\n/**\n * The subset of AppKit's per-request execution context the bus reads for sender\n * identity. Fields are `unknown` because this is a structural view of an OPTIONAL\n * peer: the values are trimmed and validated rather than trusted.\n */\ntype AppKitExecutionContext = {\n  userEmail?: unknown;\n  userId?: unknown;\n  userName?: unknown;\n};\n\n/** Structural view of `@databricks/appkit`, imported lazily and never required. */\ntype AppKitModule = {\n  getExecutionContext(): AppKitExecutionContext;\n};\n\n/**\n * Cached result of the one optional-peer import, resolved to `undefined` when\n * AppKit is not installed. Memoized so a bus in a plain Postgres process pays for\n * the failed resolution once instead of per broadcast.\n */\nlet appKitModule: Promise<AppKitModule | undefined> | undefined;\n\n/**\n * Flat-keyed context travelling alongside a message body: who sent it, from\n * where, in which deployment. Values may nest, but the keys are the addressable\n * part - a listener filtering or labelling messages reads `metadata.user`, not a\n * path into the body.\n */\nexport type TopicMetadata = Record<string, SerializableValue>;\n\n/**\n * The wire envelope every subscriber receives, and what {@link\n * PostgresTopicBus.broadcast} returns to the publisher.\n *\n * `id`, `topic`, and `publishedAt` are assigned by the bus; `type`, `metadata`,\n * and `body` come from the caller (with automatic context merged under\n * `metadata`). The shape is stable enough to hand straight to an SSE `data:`\n * frame.\n */\nexport interface TopicMessage<TBody extends SerializableValue = SerializableValue> {\n  /**\n   * Per-message identity generated by the publisher, unique across instances.\n   * Suitable for dedupe when a client reconnects and for an SSE `id:` field. Not\n   * ordered, and not a database key.\n   */\n  id: string;\n  /** The topic this was broadcast on; listeners on other topics never see it. */\n  topic: string;\n  /** Caller-chosen event name, e.g. `order.updated`. Never empty. */\n  type: string;\n  /** Automatic context merged with caller metadata. See {@link TopicMetadata}. */\n  metadata: TopicMetadata;\n  /** The caller's payload, unchanged. */\n  body: TBody;\n  /**\n   * ISO-8601 publish time from the PUBLISHING process's clock, not the database's.\n   * Fine for display; do not order messages from different instances by it.\n   */\n  publishedAt: string;\n}\n\n/** What a caller supplies to {@link PostgresTopicBus.broadcast}. */\nexport interface TopicPublishInput<TBody extends SerializableValue = SerializableValue> {\n  /** Event name, e.g. `chat.message`. Must be non-blank. */\n  type: string;\n  /**\n   * Context to attach. Wins over any automatic key of the same name, so a caller\n   * can override a machine default (`project`) or add its own (`traceId`).\n   */\n  metadata?: TopicMetadata;\n  /** The payload. Must satisfy `object.isSerializableValue`. */\n  body: TBody;\n}\n\n/**\n * Subscriber callback. Invoked once per matching message on the notification\n * connection's callback, so it should not block: a returned promise is awaited\n * only to route a rejection to `onError`, and listeners for one message run\n * concurrently rather than in registration order.\n *\n * `TBody` is unchecked at runtime. The bus guarantees the body is serializable,\n * not that it matches the type parameter, so validate anything a listener\n * branches on.\n */\nexport type TopicListener<TBody extends SerializableValue = SerializableValue> = (\n  message: TopicMessage<TBody>,\n) => void | PromiseLike<void>;\n\n/**\n * Resolves metadata at publish time instead of construction time, for context a\n * process learns late or asynchronously - a discovered public IP, an instance id\n * from a control plane. Called on every broadcast, so memoize anything expensive;\n * a rejection fails the broadcast.\n */\nexport type TopicMetadataProvider = () => TopicMetadata | PromiseLike<TopicMetadata>;\n\n/** Construction options for {@link PostgresTopicBus}. */\nexport interface PostgresTopicBusOptions {\n  /**\n   * What identifies this channel - anything, not just an identifier: a name, an\n   * id, a `[env, feature]` pair, a config object. The parts are tokenized into a\n   * legal Postgres channel name with a short hash of the originals appended, so\n   * the derivation is deterministic and no call site has to sanitize. See\n   * {@link PostgresTopicBus.channelName} for the resolved name.\n   *\n   * One value or many: an array is read as multiple parts\n   * ({@link object.OneOrMany}), anything else as a single part. So\n   * `[\"billing\", \"prod\"]` and `\"billing_prod\"` are different channels, since the\n   * hash sees different structure.\n   *\n   * Every participating process must pass EQUIVALENT parts, since a different\n   * spelling hashes to a different channel. Defaults to a shared\n   * `dbx_tools_topic_bus` channel.\n   */\n  channel?: unknown;\n  /**\n   * Extra context added to every message this bus publishes, either a fixed\n   * record or a {@link TopicMetadataProvider} called per broadcast. Overrides\n   * automatic machine keys; per-call `metadata` overrides this.\n   */\n  metadata?: TopicMetadata | TopicMetadataProvider;\n  /**\n   * Sink for failures that have no caller to throw to: a listener that rejected,\n   * a dropped notification connection, a failed reconnect attempt. Defaults to\n   * swallowing them, so wire this to a logger in anything long-running.\n   */\n  onError?: (cause: unknown) => void;\n}\n\n/**\n * Drop keys whose value is `undefined`, so an unset environment variable leaves\n * the key ABSENT rather than present-and-null. Absence is what lets caller\n * metadata and later merge layers supply the key instead.\n */\nfunction definedMetadata(values: Record<string, SerializableValue | undefined>): TopicMetadata {\n  return Object.fromEntries(\n    Object.entries(values).filter((entry): entry is [string, SerializableValue] => {\n      return entry[1] !== undefined;\n    }),\n  );\n}\n\n/**\n * Context every message gets for free: which project, host, process, and\n * deployment published it.\n *\n * Read fresh per broadcast rather than cached, because a long-lived process can\n * be re-parented (a deployment id appearing after boot). Keys that resolve to\n * nothing are omitted. Public IP is only read from the environment here - the bus\n * never makes a network call to discover it; a process that wants a discovered IP\n * passes a {@link TopicMetadataProvider}.\n *\n * Deliberately NOT included: CPU architecture, runtime name, and runtime version.\n * They are constant per deployment and cost payload bytes against the `NOTIFY`\n * limit on every single message.\n */\nfunction machineMetadata(): TopicMetadata {\n  return definedMetadata({\n    project:\n      string.firstNonEmpty([\n        process.env.DATABRICKS_APP_NAME,\n        process.env.DATABRICKS_BUNDLE_NAME,\n        process.env.PROJECT_NAME,\n        process.env.npm_package_name,\n      ]) ?? undefined,\n    publicIp:\n      string.firstNonEmpty([\n        process.env.PUBLIC_IP,\n        process.env.DATABRICKS_PUBLIC_IP,\n        process.env.HOST_IP,\n      ]) ?? undefined,\n    hostname: hostname(),\n    cwd: process.cwd(),\n    platform: process.platform,\n    pid: process.pid,\n    environment: string.trimToNull(process.env.NODE_ENV) ?? undefined,\n    appName: string.trimToNull(process.env.DATABRICKS_APP_NAME) ?? undefined,\n    deploymentId: string.trimToNull(process.env.DATABRICKS_APP_DEPLOYMENT_ID) ?? undefined,\n    databricksHost: string.trimToNull(process.env.DATABRICKS_HOST) ?? undefined,\n  });\n}\n\n/**\n * Identity of the signed-in user on whose behalf this broadcast happens, when the\n * process can tell.\n *\n * `@databricks/appkit` is an OPTIONAL peer, so the import is lazy and a missing\n * module is not an error - this is a plain Postgres package that adds sender\n * identity when it happens to run inside an AppKit app. Outside an active\n * per-request execution context AppKit throws, which means \"no user here\", so the\n * result is empty metadata rather than a failed broadcast.\n */\nasync function senderMetadata(): Promise<TopicMetadata> {\n  appKitModule ??= import(\"@databricks/appkit\")\n    .then((module) => module as AppKitModule)\n    .catch(() => undefined);\n  const appkit = await appKitModule;\n  if (!appkit) return {};\n  try {\n    const context = appkit.getExecutionContext();\n    return definedMetadata({\n      senderId: string.trimToNull(context.userId) ?? undefined,\n      senderName: string.trimToNull(context.userName) ?? undefined,\n      senderEmail: string.trimToNull(context.userEmail) ?? undefined,\n    });\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Derive a legal Postgres channel name from whatever a caller used to identify\n * the channel.\n *\n * Callers think in terms of what the channel IS - an app name, a tenant id, a\n * `[env, feature]` pair, a config object - and none of those are identifiers.\n * Rejecting them pushed the sanitizing onto every call site, which is how two\n * services end up disagreeing about whether the channel is `my-app`, `my_app`,\n * or `myApp` and silently never hear each other.\n *\n * The parts are tokenized and joined into an identifier, then a short hash of the\n * ORIGINAL parts is appended. The hash is what makes the mapping trustworthy:\n * tokenizing alone is lossy, so `my-app` and `my_app` and `myApp` would collapse\n * onto one channel, and a name long enough to hit `NAMEDATALEN` would collide\n * with anything sharing its leading tokens. With the suffix, the readable part\n * stays readable and distinct inputs stay distinct.\n *\n * Deterministic across processes and runs, which is the whole point - two\n * services given the same parts must land on the same channel without\n * coordinating. Hash inputs are structure-aware, so `[\"a\", \"b\"]` and `[\"a_b\"]`\n * differ, and object key order does not.\n */\nfunction channelName(parts: object.OneOrMany<unknown>): string {\n  // Hash the CANONICAL form, the same rule `advisoryLockId` uses, so structure and\n  // types decide identity: `[\"a\",\"b\"]` differs from `[\"ab\"]`, `1` from `\"1\"`, and\n  // object key order does not matter. Hashing the raw parts would instead lean on\n  // the hash module's canonicalizer, which folds every `Date` onto one token.\n  const suffix = hash.fnvHashWithOptions(\n    { length: CHANNEL_HASH_LENGTH },\n    parts.map((part) => object.toStableKey(part)).join(\"\\u0000\"),\n  );\n  // Only parts that stringify to something a reader recognizes contribute to the\n  // readable half. An object would tokenize from `String(value)` as\n  // `object_object`, which is noise - it still shapes the hash, so identity is\n  // unaffected.\n  const labelled = parts.filter((part) => {\n    const type = typeof part;\n    return type === \"string\" || type === \"number\" || type === \"boolean\" || type === \"bigint\";\n  });\n  // Truncate rather than cap through the tokenizer: `trim` would DROP a single\n  // token longer than the budget, turning one long name into the bare fallback and\n  // making every long name look alike. The hash still separates them, but the\n  // channel is unreadable in a log.\n  const body = string\n    .toIdentifierWithOptions({ delimiter: \"_\" }, ...labelled)\n    .slice(0, MAX_CHANNEL_LENGTH - suffix.length - 1)\n    .replace(/_+$/, \"\");\n  // An identifier cannot start with a digit and the hash alphabet is\n  // digit-leading, so a numeric or empty body needs a letter in front.\n  const prefix = /^[A-Za-z_]/.test(body) ? body : `${CHANNEL_FALLBACK}_${body}`;\n  return `${prefix}_${suffix}`.replace(/_+/g, \"_\");\n}\n\n/** Quote a validated channel for `LISTEN`/`UNLISTEN`, which take no parameters. */\nfunction quoteIdentifier(value: string): string {\n  return `\"${value.replaceAll('\"', '\"\"')}\"`;\n}\n\n/**\n * Parse a `NOTIFY` payload into an envelope, returning `undefined` for anything\n * that is not one.\n *\n * The channel is shared and any Postgres session can `pg_notify` on it, so an\n * unrecognized payload is expected input, not an exception. Publishers run this\n * over their own encoded message too, which is how a body that stringifies but\n * does not round-trip is caught before it ships.\n */\nfunction decode(value: string | undefined): TopicMessage | undefined {\n  if (!value) return undefined;\n  const record = json.parseRecord(value);\n  if (\n    !record ||\n    typeof record.id !== \"string\" ||\n    typeof record.topic !== \"string\" ||\n    typeof record.type !== \"string\" ||\n    typeof record.publishedAt !== \"string\" ||\n    !record.metadata ||\n    typeof record.metadata !== \"object\" ||\n    Array.isArray(record.metadata) ||\n    !(\"body\" in record) ||\n    !object.isSerializableValue(record.metadata) ||\n    !object.isSerializableValue(record.body)\n  ) {\n    return undefined;\n  }\n  return {\n    id: record.id,\n    topic: record.topic,\n    type: record.type,\n    metadata: record.metadata as TopicMetadata,\n    body: record.body as SerializableValue,\n    publishedAt: record.publishedAt,\n  };\n}\n\n/**\n * Broadcasts structured messages by topic and delivers them to every process\n * listening on the same channel.\n *\n * CONNECTION SHAPE. Publishing borrows a pooled connection per call, like any\n * other query. Listening cannot: `LISTEN` is session state, so the bus holds ONE\n * dedicated client out of the pool for as long as it has subscribers, no matter\n * how many topics or listeners are registered. Size the pool with that one\n * long-lived checkout in mind.\n *\n * LIFECYCLE. Construction is inert - nothing connects until the first\n * {@link listen} (or an explicit {@link start}). {@link close} is required to give\n * the connection back; a closed bus stays closed and throws on further use rather\n * than silently reconnecting. Register it with the host's shutdown hook.\n *\n * FAILURE HANDLING. A lost notification connection reconnects on its own with\n * bounded backoff while subscribers remain, reporting each failed attempt through\n * `onError`. Messages published during the gap are lost - `NOTIFY` has no replay.\n * A throwing or rejecting listener never affects the publisher or the other\n * listeners; its failure goes to `onError`.\n *\n * Not safe to share one instance across unrelated channels - construct one bus\n * per channel. The channel itself is DERIVED from the `channel` option rather\n * than taken literally; see {@link PostgresTopicBusOptions.channel} and\n * {@link PostgresTopicBus.channelName}.\n */\nexport class PostgresTopicBus {\n  /**\n   * The resolved Postgres channel this bus listens and publishes on, derived from\n   * the `channel` option. Read it to confirm two processes agree, or to log what a\n   * set of parts actually resolved to.\n   */\n  readonly channelName: string;\n  private readonly metadata: TopicMetadata | TopicMetadataProvider | undefined;\n  private readonly onError: (cause: unknown) => void;\n  private readonly listeners = new Map<string, Set<TopicListener>>();\n  private client: PoolClient | undefined;\n  private starting: Promise<void> | undefined;\n  private reconnecting: Promise<void> | undefined;\n  private readonly reconnectAbort = new AbortController();\n  private closed = false;\n\n  constructor(\n    private readonly pool: PgPoolLike & PgQueryable,\n    options: PostgresTopicBusOptions = {},\n  ) {\n    this.channelName = channelName(\n      object.toOneOrMany(options.channel === undefined ? DEFAULT_CHANNEL : options.channel),\n    );\n    this.metadata = options.metadata;\n    this.onError = options.onError ?? (() => undefined);\n  }\n\n  /**\n   * Open the dedicated notification connection and `LISTEN`.\n   *\n   * Idempotent, and safe to call concurrently - overlapping calls await the same\n   * in-flight connect. {@link listen} calls this, so it is only needed to surface\n   * a connection problem at startup rather than on first subscribe. Throws if the\n   * bus is closed, or if the pool cannot hand out a connection.\n   */\n  async start(): Promise<void> {\n    if (this.client) return;\n    if (this.closed) throw new Error(\"Postgres topic bus is closed\");\n    this.starting ??= this.connect().finally(() => {\n      this.starting = undefined;\n    });\n    await this.starting;\n  }\n\n  /**\n   * Publish a message to `topic`, returning the envelope that was sent.\n   *\n   * Resolves once Postgres has accepted the `NOTIFY`, which says nothing about\n   * anyone receiving it: sessions not listening at that moment miss it. Publishing\n   * needs no {@link start} and no subscribers.\n   *\n   * Validation is deliberately front-loaded, since a message that fails on the\n   * wire is far harder to diagnose than one rejected at the call: `TypeError` for a\n   * blank topic or type, or a body/metadata that would not round-trip through JSON\n   * unchanged (`object.isSerializableValue`); `RangeError` when the encoded\n   * envelope exceeds the `NOTIFY` payload limit, which the automatic metadata\n   * counts against - send a reference and let the receiver fetch the payload.\n   * Throws if the bus is closed.\n   */\n  async broadcast<TBody extends SerializableValue>(\n    topic: string,\n    input: TopicPublishInput<TBody>,\n  ): Promise<TopicMessage<TBody>> {\n    if (!topic.trim()) throw new TypeError(\"Topic must not be empty\");\n    if (!input.type.trim()) throw new TypeError(\"Message type must not be empty\");\n    if (\n      !object.isSerializableValue(input.metadata ?? {}) ||\n      !object.isSerializableValue(input.body)\n    ) {\n      throw new TypeError(\"Message metadata and body must be JSON serializable without coercion\");\n    }\n    if (this.closed) throw new Error(\"Postgres topic bus is closed\");\n    const automatic = await this.resolveMetadata();\n    const message: TopicMessage<TBody> = {\n      id: hash.id(),\n      topic,\n      type: input.type,\n      metadata: { ...automatic, ...input.metadata },\n      body: input.body,\n      publishedAt: new Date().toISOString(),\n    };\n    let encoded: string;\n    try {\n      encoded = JSON.stringify(message);\n    } catch (cause) {\n      throw new TypeError(`Message must be JSON serializable: ${error.errorMessage(cause)}`);\n    }\n    if (!decode(encoded)) {\n      throw new TypeError(\"Message type, metadata, and body must be JSON serializable\");\n    }\n    if (Buffer.byteLength(encoded, \"utf8\") > MAX_NOTIFY_BYTES) {\n      throw new RangeError(`Postgres notification exceeds ${MAX_NOTIFY_BYTES} bytes`);\n    }\n    await this.pool.query(\"SELECT pg_notify($1, $2)\", [this.channelName, encoded]);\n    return message;\n  }\n\n  /**\n   * Subscribe to `topic`, returning the function that unsubscribes.\n   *\n   * Connects on first use. Several listeners may share a topic; each is called\n   * once per message. Only messages published AFTER this resolves arrive, so\n   * subscribe before triggering whatever you expect to observe.\n   *\n   * The returned function removes just this listener and is safe to call twice.\n   * The connection stays open once the last listener leaves - {@link close}\n   * releases it - so a bus that subscribes and unsubscribes per request does not\n   * churn connections.\n   */\n  async listen<TBody extends SerializableValue>(\n    topic: string,\n    listener: TopicListener<TBody>,\n  ): Promise<() => Promise<void>> {\n    if (!topic.trim()) throw new TypeError(\"Topic must not be empty\");\n    await this.start();\n    const listeners = this.listeners.get(topic) ?? new Set<TopicListener>();\n    listeners.add(listener as TopicListener);\n    this.listeners.set(topic, listeners);\n    return async () => {\n      listeners.delete(listener as TopicListener);\n      if (listeners.size === 0) this.listeners.delete(topic);\n    };\n  }\n\n  /**\n   * Build the automatic half of a message's metadata.\n   *\n   * Precedence, weakest first: machine/process context, then AppKit sender\n   * identity, then this bus's configured metadata. The caller's per-message\n   * metadata is layered over the result in {@link broadcast}, so the most specific\n   * source always wins and nothing here can overwrite an explicit key.\n   */\n  private async resolveMetadata(): Promise<TopicMetadata> {\n    const sender = await senderMetadata();\n    const configured =\n      typeof this.metadata === \"function\" ? await this.metadata() : (this.metadata ?? {});\n    return { ...machineMetadata(), ...sender, ...configured };\n  }\n\n  /**\n   * Release the notification connection and stop delivering messages. Idempotent.\n   *\n   * Cancels any pending reconnect, drops all listeners, then `UNLISTEN`s and\n   * returns the client to the pool. A failed `UNLISTEN` is reported to the pool as\n   * a release error so the connection is DISCARDED rather than handed to the next\n   * caller still subscribed to the channel. Does not throw; the bus stays closed.\n   */\n  async close(): Promise<void> {\n    if (this.closed) return;\n    this.closed = true;\n    this.reconnectAbort.abort(new Error(\"Postgres topic bus is closed\"));\n    await this.starting?.catch(() => undefined);\n    await this.reconnecting?.catch(() => undefined);\n    const client = this.client;\n    this.client = undefined;\n    this.listeners.clear();\n    if (!client) return;\n    client.removeListener(\"notification\", this.handleNotification);\n    client.removeListener(\"error\", this.handleClientError);\n    let releaseError: Error | undefined;\n    try {\n      await client.query(`UNLISTEN ${quoteIdentifier(this.channelName)}`);\n    } catch (cause) {\n      releaseError = error.toError(cause);\n    }\n    client.release(releaseError);\n  }\n\n  /**\n   * Check out one client, attach the handlers, and `LISTEN`.\n   *\n   * The handlers are attached BEFORE the `LISTEN` round trip so a notification or\n   * error arriving mid-setup is not missed. Any failure - including the bus being\n   * closed while the connect was in flight - detaches the handlers and releases\n   * the client as errored, so a half-configured connection never returns to the\n   * pool.\n   */\n  private async connect(): Promise<void> {\n    const client = await this.pool.connect();\n    try {\n      client.on(\"notification\", this.handleNotification);\n      client.on(\"error\", this.handleClientError);\n      await client.query(`LISTEN ${quoteIdentifier(this.channelName)}`);\n      if (this.closed) throw new Error(\"Postgres topic bus is closed\");\n      this.client = client;\n    } catch (cause) {\n      client.removeListener(\"notification\", this.handleNotification);\n      client.removeListener(\"error\", this.handleClientError);\n      client.release(error.toError(cause));\n      throw cause;\n    }\n  }\n\n  /**\n   * Route one inbound notification to the topic's listeners.\n   *\n   * Ignores other channels and undecodable payloads - the channel is shared, so\n   * both are ordinary traffic. Listeners are invoked concurrently and their\n   * rejections go to `onError`, keeping one slow or broken subscriber from\n   * stalling the notification connection.\n   */\n  private readonly handleNotification = (notification: Notification): void => {\n    if (notification.channel !== this.channelName) return;\n    const message = decode(notification.payload);\n    if (!message) return;\n    for (const listener of this.listeners.get(message.topic) ?? []) {\n      Promise.resolve(listener(message)).catch(this.onError);\n    }\n  };\n\n  /**\n   * Handle the notification connection dying, which `pg` reports as an `error`\n   * event rather than a rejected query.\n   *\n   * The client is unusable at this point, so it is detached and released as\n   * errored (which discards it) before anything else. Reconnection only starts\n   * when there is still someone to deliver to, so an idle or closing bus does not\n   * hold a connection open chasing a channel nobody reads.\n   */\n  private readonly handleClientError = (cause: Error): void => {\n    this.onError(cause);\n    const client = this.client;\n    if (!client) return;\n    this.client = undefined;\n    client.removeListener(\"notification\", this.handleNotification);\n    client.removeListener(\"error\", this.handleClientError);\n    client.release(cause);\n    if (this.closed || this.listeners.size === 0) return;\n    this.reconnecting ??= this.reconnect().finally(() => {\n      this.reconnecting = undefined;\n    });\n  };\n\n  /**\n   * Re-establish the notification connection with bounded exponential backoff.\n   *\n   * The first attempt is immediate, since the common case is a single dropped\n   * connection that reconnects at once; subsequent delays double from 250ms up to\n   * 5s and stay there. Retries indefinitely rather than giving up, because a Postgres restart\n   * or a rotated Lakebase credential is a recoverable outage and a silently dead\n   * listener is worse than a noisy one. Stops when the bus closes or the last\n   * listener leaves, and reports every failed attempt through `onError`.\n   */\n  private async reconnect(): Promise<void> {\n    let delay = 0;\n    while (!this.closed && this.listeners.size > 0) {\n      if (delay > 0) {\n        try {\n          await asyncUtil.sleep(delay, this.reconnectAbort.signal);\n        } catch {\n          return;\n        }\n      }\n      try {\n        await this.start();\n        return;\n      } catch (cause) {\n        if (this.closed) return;\n        this.onError(cause);\n        delay = delay === 0 ? MIN_RECONNECT_DELAY_MS : Math.min(delay * 2, MAX_RECONNECT_DELAY_MS);\n      }\n    }\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/advisory-lock.ts","../src/topic-bus.ts","../index.ts"],"version":"5.9.3"}