@supalive/core 0.1.3 → 0.1.5

package/dist/src/db/postgres.js

@@ -1,998 +0,0 @@
-import { Pool } from "pg";
-import { normalizeIdToBytes, OccConflictError, normalizeToBytes } from "./types_db";
-import { utf8Encode } from "./bytes";
-// pg's bytea encoder checks `Buffer.isBuffer`; a plain Uint8Array falls through
-// to its scalar path and corrupts the bytes. Wrap as a zero-copy Buffer view.
-function toBufferView(bytes) {
-    if (Buffer.isBuffer(bytes))
-        return bytes;
-    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-}
-import { checkLogsAffectReadSet, mapReadSetToRaw } from "../server/overlap-checker";
-import { supaliveStringify } from "../helper";
-export class PgDatabase {
-    constructor(logger, config, pool = undefined) {
-        this.logger = logger;
-        this.config = config;
-        if (pool) {
-            this.pool = pool;
-        }
-        else {
-            this.pool = new Pool(config);
-        }
-    }
-    logger;
-    config;
-    pool;
-    sqlBuilder = pgSql;
-    dbType = "postgres";
-    // Lazy per-table column-type cache. The apply path consults this for
-    // unnest carriers/casts in batched writes; we never re-query pg_attribute
-    // for a table we've already seen unless the cache is explicitly
-    // invalidated (e.g. after a migration). Shared with tx clients via
-    // adoptRegistries so a single startup load services all transactions.
-    columnTypes = new Map();
-    // Compiled-SQL cache keyed by (op, table, sorted column signature).
-    // Mirrors columnTypes — invalidated together when types change.
-    sqlCache = new Map();
-    /**
-     * Fetches actual column types from Postgres for `table` and returns a
-     * map of DB column name → PG type string (as produced by `format_type`,
-     * e.g. `bigint`, `integer`, `character varying(32)`, `text[]`, `jsonb`).
-     * No caching here — see {@link getColumnTypes} for the cached path.
-     */
-    async loadColumnTypesFromPg(table) {
-        const result = await this.query(`SELECT a.attname AS column_name, format_type(a.atttypid, a.atttypmod) AS pg_type
-       FROM pg_attribute a
-       WHERE a.attrelid = $1::regclass AND a.attnum > 0 AND NOT a.attisdropped
-       ORDER BY a.attnum`, [table]);
-        // PG folds unquoted identifiers to lowercase on the server side, so
-        // pg_attribute.attname comes back lowercase. JS-side column keys
-        // (`entry.data`) often arrive in camelCase from the schema layer; we
-        // lookup via lowercase to bridge the two cases without making callers
-        // worry about it.
-        const out = new Map();
-        for (const row of result.rows)
-            out.set(row.column_name.toLowerCase(), row.pg_type);
-        return out;
-    }
-    /**
-     * Synchronous column-type lookup. The apply path calls this on every
-     * batched write, so it can't await — populate the cache via
-     * {@link bootstrapColumnTypes} at server start. Throws if `table` is
-     * missing (programmer error / bootstrap skipped).
-     */
-    getColumnTypes(table) {
-        const hit = this.columnTypes.get(table);
-        if (!hit) {
-            this.logger.warn({ table }, "PgDatabase: no cached column types fallback to non-batched writes");
-            return null;
-        }
-        return hit;
-    }
-    /**
-     * Eagerly load column types into the in-memory cache. With a Redis
-     * client supplied, attempts the cache key first and falls through to
-     * Postgres on miss (writing the result back to Redis). This is the
-     * "one server queries PG, the rest read from Redis" pattern for cold
-     * starts in a multi-instance deploy. Without Redis, always queries PG.
-     *
-     * Pass `tables` to limit the load to a specific list; otherwise every
-     * user table in the connected database is loaded.
-     *
-     * The Redis cache key should encode whatever invalidates types in your
-     * environment (typically a schema version / deploy version). The
-     * subscriber in supalive-server.ts is expected to publish a reload
-     * signal after migrations and invoke {@link invalidateColumnTypes}.
-     */
-    async bootstrapColumnTypes(opts) {
-        this.invalidateColumnTypes();
-        const { redis, cacheKey, tables } = opts;
-        // Redis hit path: deserialize the full table → column → pgType map
-        // and populate in one shot, skipping any pg_attribute round-trips.
-        if (redis) {
-            const cached = await redis.getCachedTableColumnTypes(cacheKey);
-            if (cached) {
-                for (const [table, cols] of Object.entries(cached)) {
-                    this.columnTypes.set(table, new Map(Object.entries(cols)));
-                }
-                return;
-            }
-        }
-        // Cache miss (or no Redis): query Postgres for the listed tables
-        // (or enumerate all user tables) and populate.
-        const names = tables ?? await this.listUserTables();
-        for (const t of names) {
-            if (this.columnTypes.has(t))
-                continue;
-            const fresh = await this.loadColumnTypesFromPg(t);
-            this.columnTypes.set(t, fresh);
-        }
-        // Write back to Redis so subsequent server instances skip the PG hop.
-        if (redis) {
-            const dump = {};
-            for (const [table, cols] of this.columnTypes) {
-                dump[table] = Object.fromEntries([...cols.entries()].sort());
-            }
-            await redis.setCachedTableColumnsTypes(cacheKey, dump);
-        }
-    }
-    /**
-     * Invalidate cached types (and dependent SQL) for `table`, or the entire
-     * cache if `table` is omitted. The Redis-pubsub reload signal in
-     * supalive-server.ts is expected to call this on schema changes.
-     */
-    invalidateColumnTypes(table) {
-        if (table) {
-            this.columnTypes.delete(table);
-            for (const k of [...this.sqlCache.keys()]) {
-                if (k.includes(`:${table}:`) || k === `d:${table}`)
-                    this.sqlCache.delete(k);
-            }
-        }
-        else {
-            this.columnTypes.clear();
-            this.sqlCache.clear();
-        }
-    }
-    /** Enumerate the user-defined tables in the connected database — used
-     * by bootstrapColumnTypes() when no explicit list is provided. */
-    async listUserTables() {
-        const res = await this.query(`SELECT c.relname FROM pg_class c
-       JOIN pg_namespace n ON n.oid = c.relnamespace
-       WHERE c.relkind = 'r' AND n.nspname = ANY (current_schemas(false))
-         AND c.relname NOT IN ('commit_logs','metadata')`);
-        return res.rows.map((r) => r.relname);
-    }
-    migrationSql = [
-        // Core OCC timestamp sequence
-        `CREATE SEQUENCE IF NOT EXISTS global_commit_ts START 1 INCREMENT 1 NO CYCLE;`,
-        `CREATE TABLE IF NOT EXISTS commit_logs (
-      id BYTEA NOT NULL,
-      ts BIGINT NOT NULL,
-      table_id BYTEA NOT NULL,
-      data BYTEA NOT NULL,
-      PRIMARY KEY (ts, table_id, id)
-    )`,
-        `CREATE INDEX IF NOT EXISTS commit_logs_by_table_and_id ON commit_logs (table_id, id, ts)`,
-        `CREATE INDEX IF NOT EXISTS commit_logs_by_table_ts_and_id ON commit_logs (table_id, ts, id)`,
-        // Metadata table
-        `CREATE TABLE IF NOT EXISTS metadata (
-         meta_key TEXT PRIMARY KEY,
-         meta_value BIGINT NOT NULL
-       );`,
-        `INSERT INTO metadata (meta_key, meta_value) VALUES ('latest_committed_ts', 0) ON CONFLICT (meta_key) DO NOTHING;`
-    ];
-    async query(sql, params = []) {
-        const client = await this.pool.connect();
-        try {
-            const result = await client.query(sql, params);
-            return {
-                rows: result.rows,
-                rowCount: result.rowCount,
-            };
-        }
-        catch (err) {
-            throw translatePgError(err);
-        }
-        finally {
-            client.release();
-        }
-    }
-    async getClient() {
-        return await this.pool.connect();
-    }
-    async getTransactionClient() {
-        const client = await this.pool.connect();
-        const tx = new PgTxDatabase(this.logger, this.config, this.pool, client);
-        // Tx clients are short-lived. Share the parent's caches by reference so
-        // (a) types loaded once at startup are visible inside transactions, and
-        // (b) the SQL cache grows across the process rather than per-tx.
-        tx.adoptCaches(this.columnTypes, this.sqlCache);
-        return tx;
-    }
-    /** Internal: replace this instance's caches with shared references from
-     * a parent. Used by PgDatabase.getTransactionClient. */
-    adoptCaches(columnTypes, sqlCache) {
-        this.columnTypes = columnTypes;
-        this.sqlCache = sqlCache;
-    }
-    async getLatestSnapshotTimestamp() {
-        const result = await this.query("SELECT meta_value FROM metadata WHERE meta_key = 'latest_committed_ts'");
-        return BigInt(result.rows[0]?.meta_value ?? 0) || -1n;
-    }
-    async updateLatestSnapshotTimestamp(commitTs) {
-        await this.query("UPDATE metadata SET meta_value = $1 WHERE meta_key = 'latest_committed_ts' AND meta_value < $1", [commitTs]);
-    }
-    async getNextTimestamp() {
-        const result = await this.query("SELECT nextval('global_commit_ts') as nextval");
-        return BigInt(result.rows[0]?.nextval ?? "0") || -1n;
-    }
-    // Runs on the pool, not the tx client — intentionally. This keeps the
-    // transaction window short, but it means `prevData` is not snapshot-
-    // consistent with the eventual commitTs (a peer may have moved the row
-    // between beginTs and this SELECT). That's safe because:
-    //   1. The per-row CAS in pgApplyWrites is the real snapshot fence. If a
-    //      peer committed in our staleness window, the CAS sees a moved
-    //      commit_ts and throws OccConflictError → retry.
-    //   2. The only window where CAS passes with "stale" prevData is when
-    //      the current row at our SELECT moment matches `expectedCommitTs`;
-    //      by construction nobody committed between our captured ts and now,
-    //      so prevData IS consistent with the ts we're CAS-ing against.
-    //   3. The downstream consumer (overlap-checker.checkRowWriteAffectsRange)
-    //      is conservative on missing/odd prevData — "unknown" verdicts still
-    //      invalidate, so the worst case here is a spurious invalidation,
-    //      never a missed one.
-    // Locked in by postgres.attach-prev-data.test.ts.
-    async attachPrevDataToWriteSet(writeSet, readSet) {
-        // Index prior point reads by (table, id) so we can carry the
-        // read-time commit_ts onto matching writes. Iterate in reverse so the
-        // last read wins (handles handlers that read the same row twice).
-        const readTsByKey = new Map();
-        for (let i = readSet.length - 1; i >= 0; i--) {
-            const r = readSet[i];
-            if (r.kind !== "point" || r.expectedCommitTs === undefined)
-                continue;
-            const key = `${r.table} ${r.id}`;
-            if (!readTsByKey.has(key))
-                readTsByKey.set(key, r.expectedCommitTs);
-        }
-        const byTable = new Map();
-        for (const entry of writeSet) {
-            if (entry.op !== "update" && entry.op !== "delete")
-                continue;
-            const bucket = byTable.get(entry.table);
-            if (bucket)
-                bucket.push(entry);
-            else
-                byTable.set(entry.table, [entry]);
-        }
-        if (byTable.size === 0)
-            return;
-        for (const [table, entries] of byTable) {
-            const ids = entries.map((e) => e.id);
-            const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
-            // No FOR UPDATE — the per-row CAS on the subsequent UPDATE/DELETE is
-            // the fence. If a peer mutated the row since our read, the CAS will
-            // see a stale expected commit_ts and throw OCC.
-            const sql = `SELECT * FROM ${table} WHERE id IN (${placeholders})`;
-            const result = await this.query(sql, ids);
-            const byId = new Map();
-            for (const row of result.rows) {
-                byId.set(String(row.id), row);
-            }
-            for (const entry of entries) {
-                const row = byId.get(entry.id);
-                const key = `${entry.table} ${entry.id}`;
-                const priorReadTs = readTsByKey.get(key);
-                if (row) {
-                    entry.prevData = row;
-                    // Prefer the read-time ts so read-then-update patterns get
-                    // beginTs-level isolation; fall back to current row ts for
-                    // blind writes (no prior read).
-                    entry.expectedCommitTs = priorReadTs !== undefined
-                        ? priorReadTs
-                        : BigInt(row.commit_ts);
-                }
-                else if (priorReadTs !== undefined) {
-                    // Row gone now, but we had read it earlier: carry the read ts —
-                    // the CAS will then mismatch (row deleted) and throw OCC.
-                    entry.expectedCommitTs = priorReadTs;
-                }
-                // else: neither a prior read nor a current row → leave undefined
-                // so CAS misses and surfaces OCC.
-            }
-        }
-    }
-    // Prepare BEFORE the conflict scan: each write is a CAS against the row's
-    // commit_ts, so any concurrent peer that touched the row produces a
-    // 0-row-affected UPDATE/DELETE → OccConflictError. Inserts surface as
-    // PK violations, also translated to OCC.
-    async prepareCommitWrites(readSet, writeSet, commitTs) {
-        const result = [];
-        await this.pgPrepareBatchWrites(result, writeSet, commitTs);
-        await this.pgPrepareCommitLogs(result, writeSet, commitTs);
-        const hasRangeRead = readSet.some(r => r.kind === "range");
-        if (!hasRangeRead) {
-            const validateReads = this.pgPrepareValidatePointReadsByCommitTs(readSet, writeSet);
-            return { commits: result, validateReadPoints: validateReads, hasRangeRead: false };
-        }
-        // has atleast one range read so use scan, prepare data
-        const tableIds = [...new Set(readSet.map(r => r.tableId))];
-        const rawReadSet = mapReadSetToRaw(readSet);
-        return { commits: result, hasRangeRead: true, tableIds: tableIds, rawReadSet: rawReadSet };
-    }
-    ;
-    async pgPrepareBatchWrites(result, writeSet, commitTs) {
-        let i = 0;
-        let counter = 0;
-        while (i < writeSet.length) {
-            counter++;
-            const { table, op } = writeSet[i];
-            let j = i + 1;
-            while (j < writeSet.length && writeSet[j].table === table && writeSet[j].op === op)
-                j++;
-            const batch = writeSet.slice(i, j);
-            if (op === "insert")
-                await this.pgPrepareInsertBatch(result, table, batch, commitTs);
-            else if (op === "update")
-                await this.pgPrepareUpdateBatch(result, table, batch, commitTs);
-            else
-                await this.pgPrepareDeleteBatch(result, table, batch);
-            i = j;
-            if (counter % 50 == 0)
-                await new Promise((resolve) => setImmediate(resolve));
-        }
-    }
-    // N=1 INSERT fast-path: identical SQL shape to the original per-row
-    // code, no unnest overhead. PG infers param types from the column
-    // context directly, so we don't need pg_attribute either.
-    pgPrepareInsertSingle(result, table, entry, commitTs) {
-        const data = { ...(entry.data ?? {}), commit_ts: commitTs };
-        const cols = Object.keys(data);
-        const placeholders = cols.map((_, i) => `$${i + 1}`);
-        result.push({
-            sql: `INSERT INTO ${table} (${cols.join(", ")}) VALUES (${placeholders.join(", ")})`,
-            params: Object.values(data),
-            operation: "insertSingle",
-            table: table,
-            entryId: entry.id,
-        });
-    }
-    async pgPrepareInsertBatch(result, table, entries, commitTs) {
-        if (entries.length === 0)
-            return;
-        const types = this.getColumnTypes(table);
-        if (!types) {
-            this.logger.warn({ table }, "No column types found, falling back to non-batched writes for insert");
-            let counter = 0;
-            for (const entry of entries) {
-                counter++;
-                this.pgPrepareInsertSingle(result, table, entry, commitTs);
-                if (counter % 50 == 0) {
-                    await new Promise((resolve) => setImmediate(resolve));
-                }
-            }
-            return;
-        }
-        // Sub-bucket by sorted column signature: writes with different optional
-        // columns can't share a statement.
-        const groups = new Map();
-        for (const entry of entries) {
-            const cols = [...Object.keys(entry.data ?? {}), 'commit_ts'].sort();
-            const key = cols.join("|");
-            let g = groups.get(key);
-            if (!g) {
-                g = { cols, rows: [] };
-                groups.set(key, g);
-            }
-            g.rows.push(entry);
-        }
-        let counter = 0;
-        for (const { cols, rows } of groups.values()) {
-            counter++;
-            const sql = this.buildOrGetInsertSql(table, types, cols);
-            // Params layout: one carrier array per column, each of length N.
-            const params = cols.map(() => new Array(rows.length));
-            for (let r = 0; r < rows.length; r++) {
-                const data = { ...(rows[r].data ?? {}), commit_ts: commitTs };
-                for (let c = 0; c < cols.length; c++) {
-                    const pgType = types.get(cols[c].toLowerCase()) ?? "text";
-                    params[c][r] = encodeForCarrier(data[cols[c]], pgType);
-                }
-            }
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-            result.push({
-                sql: sql,
-                params: params,
-                operation: "insertBatch",
-                table: table,
-            });
-        }
-    }
-    // N=1 UPDATE fast-path: same shape as the original per-row CAS.
-    pgPrepareUpdateSingle(result, table, entry, commitTs) {
-        const data = { ...(entry.data ?? {}), commit_ts: commitTs };
-        const cols = Object.keys(data);
-        const sets = cols.map((col, i) => `${col} = $${i + 1}`);
-        const values = Object.values(data);
-        const idP = `$${values.length + 1}`;
-        const tsP = `$${values.length + 2}`;
-        const expected = entry.expectedCommitTs ?? -1n;
-        result.push({
-            sql: `UPDATE ${table} SET ${sets.join(", ")} WHERE id = ${idP} AND commit_ts = ${tsP}`,
-            params: [...values, entry.id, expected],
-            operation: "updateSingle",
-            table: table,
-            entryId: entry.id,
-            expectedTs: expected,
-        });
-    }
-    async pgPrepareUpdateBatch(result, table, entries, commitTs) {
-        if (entries.length === 0)
-            return;
-        const types = this.getColumnTypes(table);
-        if (!types) {
-            this.logger.warn({ table }, "No column types found, falling back to non-batched writes for update");
-            let counter = 0;
-            for (const entry of entries) {
-                counter++;
-                this.pgPrepareUpdateSingle(result, table, entry, commitTs);
-                if (counter % 50 == 0) {
-                    await new Promise((resolve) => setImmediate(resolve));
-                }
-            }
-            return;
-        }
-        const groups = new Map();
-        for (const entry of entries) {
-            const cols = [...Object.keys(entry.data ?? {}), 'commit_ts'].sort();
-            const key = cols.join("|");
-            let g = groups.get(key);
-            if (!g) {
-                g = { cols, rows: [] };
-                groups.set(key, g);
-            }
-            g.rows.push(entry);
-        }
-        let counter = 0;
-        for (const { cols, rows } of groups.values()) {
-            counter++;
-            const sql = this.buildOrGetUpdateSql(table, types, cols);
-            const idType = types.get("id") ?? "text";
-            const idArr = new Array(rows.length);
-            const expArr = new Array(rows.length);
-            const colArrs = cols.map(() => new Array(rows.length));
-            for (let r = 0; r < rows.length; r++) {
-                const entry = rows[r];
-                const data = { ...(entry.data ?? {}), commit_ts: commitTs };
-                const expected = entry.expectedCommitTs ?? -1n;
-                idArr[r] = encodeForCarrier(entry.id, idType);
-                expArr[r] = encodeForCarrier(expected, "bigint");
-                for (let c = 0; c < cols.length; c++) {
-                    const pgType = types.get(cols[c].toLowerCase()) ?? "text";
-                    colArrs[c][r] = encodeForCarrier(data[cols[c]], pgType);
-                }
-            }
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-            const params = [idArr, expArr, ...colArrs];
-            result.push({
-                sql: sql,
-                params: params,
-                operation: "updateBatch",
-                table: table,
-                entries: rows,
-            });
-        }
-    }
-    // N=1 DELETE fast-path: original per-row CAS shape.
-    pgPrepareDeleteSingle(result, table, entry) {
-        const expected = entry.expectedCommitTs ?? -1n;
-        result.push({
-            sql: `DELETE FROM ${table} WHERE id = $1 AND commit_ts = $2`,
-            params: [entry.id, expected],
-            operation: "deleteSingle",
-            table: table,
-            entryId: entry.id,
-            expectedTs: expected,
-        });
-    }
-    async pgPrepareDeleteBatch(result, table, entries) {
-        if (entries.length === 0)
-            return;
-        const types = this.getColumnTypes(table);
-        if (!types) {
-            this.logger.warn({ table }, "No column types found, falling back to non-batched writes for delete");
-            let counter = 0;
-            for (const entry of entries) {
-                counter++;
-                this.pgPrepareDeleteSingle(result, table, entry);
-                if (counter % 50 == 0) {
-                    await new Promise((resolve) => setImmediate(resolve));
-                }
-            }
-            return;
-        }
-        const sql = this.buildOrGetDeleteSql(table, types);
-        const idType = types.get("id") ?? "text";
-        const idArr = new Array(entries.length);
-        const expArr = new Array(entries.length);
-        let counter = 0;
-        for (let i = 0; i < entries.length; i++) {
-            counter++;
-            const entry = entries[i];
-            const expected = entry.expectedCommitTs ?? -1n;
-            idArr[i] = encodeForCarrier(entry.id, idType);
-            expArr[i] = encodeForCarrier(expected, "bigint");
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-        }
-        result.push({
-            sql: sql,
-            params: [idArr, expArr],
-            operation: "deleteBatch",
-            table: table,
-            entries: entries,
-        });
-    }
-    buildOrGetInsertSql(table, types, cols) {
-        const key = `i:${table}:${cols.join(",")}`;
-        let sql = this.sqlCache.get(key);
-        if (sql)
-            return sql;
-        const placeholders = cols.map((c, i) => {
-            const pgType = types.get(c.toLowerCase()) ?? "text";
-            return `$${i + 1}::${pgCarrierType(pgType)}`;
-        });
-        const aliases = cols.map((_, i) => `c${i}`);
-        const selectExprs = cols.map((c, i) => {
-            const pgType = types.get(c.toLowerCase()) ?? "text";
-            return pgSelectExpr(aliases[i], pgType);
-        });
-        sql = `INSERT INTO ${table} (${cols.join(", ")}) ` +
-            `SELECT ${selectExprs.join(", ")} ` +
-            `FROM unnest(${placeholders.join(", ")}) AS u(${aliases.join(", ")})`;
-        this.sqlCache.set(key, sql);
-        return sql;
-    }
-    buildOrGetUpdateSql(table, types, cols) {
-        const key = `u:${table}:${cols.join(",")}`;
-        let sql = this.sqlCache.get(key);
-        if (sql)
-            return sql;
-        const idType = types.get("id") ?? "text";
-        const idCarrier = `$1::${pgCarrierType(idType)}`;
-        const expCarrier = `$2::bigint[]`;
-        const dataCarriers = cols.map((c, i) => {
-            const pgType = types.get(c.toLowerCase()) ?? "text";
-            return `$${i + 3}::${pgCarrierType(pgType)}`;
-        });
-        const aliases = ["id_c", "exp_c", ...cols.map((_, i) => `c${i}`)];
-        const setClause = cols
-            .map((c, i) => {
-            const pgType = types.get(c.toLowerCase()) ?? "text";
-            return `${c} = ${pgSelectExpr(`u.${aliases[i + 2]}`, pgType)}`;
-        })
-            .join(", ");
-        sql =
-            `UPDATE ${table} AS t SET ${setClause} ` +
-                `FROM unnest(${idCarrier}, ${expCarrier}, ${dataCarriers.join(", ")}) AS u(${aliases.join(", ")}) ` +
-                `WHERE t.id = u.id_c AND t.commit_ts = u.exp_c ` +
-                `RETURNING t.id AS id`;
-        this.sqlCache.set(key, sql);
-        return sql;
-    }
-    buildOrGetDeleteSql(table, types) {
-        const key = `d:${table}`;
-        let sql = this.sqlCache.get(key);
-        if (sql)
-            return sql;
-        const idType = types.get("id") ?? "text";
-        sql =
-            `DELETE FROM ${table} AS t ` +
-                `USING unnest($1::${pgCarrierType(idType)}, $2::bigint[]) AS u(id_c, exp_c) ` +
-                `WHERE t.id = u.id_c AND t.commit_ts = u.exp_c ` +
-                `RETURNING t.id AS id`;
-        this.sqlCache.set(key, sql);
-        return sql;
-    }
-    async pgPrepareCommitLogs(result, writeEntries, commitTs) {
-        if (writeEntries.length === 0)
-            return;
-        // unnest with column-typed arrays: 4 placeholders regardless of N
-        // (vs 4N for multi-row VALUES). All four columns have fixed driver-side
-        // types so no per-table metadata lookup is needed.
-        const ids = new Array(writeEntries.length);
-        const tss = new Array(writeEntries.length);
-        const tableIds = new Array(writeEntries.length);
-        const datas = new Array(writeEntries.length);
-        let counter = 0;
-        for (let i = 0; i < writeEntries.length; i++) {
-            counter++;
-            const entry = writeEntries[i];
-            ids[i] = toBufferView(normalizeIdToBytes(entry.id));
-            tss[i] = commitTs;
-            tableIds[i] = toBufferView(entry.tableId);
-            datas[i] = toBufferView(utf8Encode(supaliveStringify(entry)));
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-        }
-        result.push({
-            sql: `INSERT INTO commit_logs (id, ts, table_id, data) ` +
-                `SELECT * FROM unnest($1::bytea[], $2::bigint[], $3::bytea[], $4::bytea[])`,
-            params: [ids, tss, tableIds, datas],
-            table: 'commit_logs',
-            operation: 'commit_logs',
-        });
-    }
-    /**
-     * Point-only OCC check. For each genuine point read, compare the row's
-     * current commit_ts against the value captured at read time. A `null`
-     * expectedCommitTs means "row didn't exist when we read"; any row found
-     * now is a conflict. Reads whose row is being written in this same txn
-     * are skipped — the CAS UPDATE/DELETE already validated those.
-     */
-    pgPrepareValidatePointReadsByCommitTs(readSet, writeSet) {
-        const result = [];
-        // Skip reads whose row is being mutated in this same tx — CAS already
-        // fenced them. We dedupe per (table, id) so duplicate reads of the same
-        // row don't cause extra fetches.
-        const writeKeys = new Set();
-        for (const w of writeSet) {
-            writeKeys.add(`${w.table} ${w.id}`);
-        }
-        const byTable = new Map();
-        const seen = new Set();
-        for (const entry of readSet) {
-            if (entry.kind !== "point")
-                continue;
-            const key = `${entry.table} ${entry.id}`;
-            if (writeKeys.has(key) || seen.has(key))
-                continue;
-            seen.add(key);
-            // expectedCommitTs === undefined → no commit_ts captured at read time
-            // (synthetic or pre-migration). Skip — we cannot CAS-validate it. This
-            // path should only fire when callers construct PointReads externally.
-            if (entry.expectedCommitTs === undefined)
-                continue;
-            const bucket = byTable.get(entry.table);
-            if (bucket)
-                bucket.push({ entry, key });
-            else
-                byTable.set(entry.table, [{ entry, key }]);
-        }
-        for (const [table, pendings] of byTable) {
-            const ids = pendings.map((p) => p.entry.id);
-            const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
-            result.push({
-                sql: `SELECT id, commit_ts FROM ${table} WHERE id IN (${placeholders})`,
-                params: ids,
-                table: table,
-                operation: "pointReadValidation",
-                pendingsEntry: pendings,
-            });
-        }
-        return result;
-    }
-    async commitWrites(beginTs, queries, commitTs) {
-        await this.pgApplyWrites(queries.commits);
-        // Fast path: when the readSet has no range reads, we don't need a
-        // commit-log scan at all — point reads validate via per-row commit_ts,
-        // and writes already self-validated via CAS above. This is the dominant
-        // shape (most mutations target known ids) and eliminates the heaviest
-        // OCC cost in the previous design.
-        if (!queries.hasRangeRead) {
-            if ((queries.validateReadPoints?.length ?? 0) > 0) {
-                await this.validatePointReadsByCommitTs(queries.validateReadPoints ?? []);
-            }
-            return { success: true };
-        }
-        // Slow path: at least one range read present. Fall back to the
-        // commit-log scan so phantom inserts and predicate transitions-in are
-        // still caught. Point reads in the same set are covered by the same
-        // scan, so no separate validation is needed.
-        const logs = await this.getCommitLogsSinceTs(beginTs, commitTs, queries.tableIds ?? []);
-        const hasConflict = checkLogsAffectReadSet(logs, queries.rawReadSet ?? []);
-        if (hasConflict) {
-            throw new OccConflictError(`Conflict detected: overlapping commit logs since ${beginTs}`, { logs });
-        }
-        return { success: true };
-    }
-    ;
-    // Walks the writeSet in order and coalesces consecutive entries with the
-    // same (table, op) into one batched statement. Order is preserved across
-    // batch boundaries so replace-patterns (delete-then-insert of the same
-    // id) behave identically to the per-row code path. Single-row batches
-    // take a direct INSERT/UPDATE/DELETE fast-path to avoid the unnest+join
-    // overhead, which matters under high contention.
-    async pgApplyWrites(result) {
-        for (const q of result) {
-            switch (q.operation) {
-                case 'insertSingle': {
-                    try {
-                        await this.query(q.sql, q.params);
-                    }
-                    catch (err) {
-                        if (err && typeof err === "object" && err.code === "23505") {
-                            throw new OccConflictError(`Conflict: insert into ${q.table}/${q.entryId} hit duplicate key`, err);
-                        }
-                        throw err;
-                    }
-                    break;
-                }
-                case 'insertBatch': {
-                    try {
-                        await this.query(q.sql, q.params);
-                    }
-                    catch (err) {
-                        if (err && typeof err === "object" && err.code === "23505") {
-                            const detail = err.detail;
-                            const idMatch = detail?.match(/Key \([^)]+\)=\(([^)]+)\)/);
-                            const failedId = idMatch?.[1];
-                            throw new OccConflictError(failedId !== undefined
-                                ? `Conflict: insert into ${q.table}/${failedId} hit duplicate key`
-                                : `Conflict: batch insert into ${q.table} hit duplicate key`, err);
-                        }
-                        throw err;
-                    }
-                    break;
-                }
-                case 'updateSingle': {
-                    const result = await this.query(q.sql, q.params);
-                    if ((result.rowCount ?? 0) === 0) {
-                        throw new OccConflictError(`Conflict: CAS update of ${q.table}/${q.entryId} (expected commit_ts=${q.expectedTs}) matched no rows`, { table: q.table, id: q.entryId, expectedTs: q.expectedTs });
-                    }
-                    break;
-                }
-                case 'updateBatch': {
-                    const result = await this.query(q.sql, q.params);
-                    const returned = new Set();
-                    for (const r of result.rows) {
-                        returned.add(r.id);
-                    }
-                    for (const entry of q.entries) {
-                        if (!returned.has(entry.id)) {
-                            const expected = entry.expectedCommitTs ?? -1n;
-                            throw new OccConflictError(`Conflict: CAS update of ${q.table}/${entry.id} (expected commit_ts=${expected}) matched no rows`, { table: q.table, id: q.entryId, expectedTs: q.expectedTs });
-                        }
-                    }
-                    break;
-                }
-                case 'deleteSingle': {
-                    const result = await this.query(q.sql, q.params);
-                    if ((result.rowCount ?? 0) === 0) {
-                        throw new OccConflictError(`Conflict: CAS delete of ${q.table}/${q.entryId} (expected commit_ts=${q.expectedTs}) matched no rows`, { table: q.table, id: q.entryId, expectedTs: q.expectedTs });
-                    }
-                    break;
-                }
-                case 'deleteBatch': {
-                    const result = await this.query(q.sql, q.params);
-                    const returned = new Set();
-                    for (const r of result.rows)
-                        returned.add(r.id);
-                    for (const entry of q.entries) {
-                        if (!returned.has(entry.id)) {
-                            const expected = entry.expectedCommitTs ?? -1n;
-                            throw new OccConflictError(`Conflict: CAS delete of ${q.table}/${entry.id} (expected commit_ts=${expected}) matched no rows`, { table: q.table, id: entry.id, expected });
-                        }
-                    }
-                    break;
-                }
-                case 'commit_logs': {
-                    await this.query(q.sql, q.params);
-                    break;
-                }
-                default:
-                    throw new Error("Unhandled Postgres Operation: " + q.operation);
-            }
-        }
-    }
-    /**
-     * Point-only OCC check. For each genuine point read, compare the row's
-     * current commit_ts against the value captured at read time. A `null`
-     * expectedCommitTs means "row didn't exist when we read"; any row found
-     * now is a conflict. Reads whose row is being written in this same txn
-     * are skipped — the CAS UPDATE/DELETE already validated those.
-     */
-    async validatePointReadsByCommitTs(queries) {
-        for (const q of queries) {
-            const result = await this.query(q.sql, q.params);
-            const currentById = new Map();
-            for (const row of result.rows) {
-                currentById.set(row.id, BigInt(row.commit_ts));
-            }
-            for (const { entry } of (q.pendingsEntry ?? [])) {
-                const current = currentById.get(entry.id);
-                const expected = entry.expectedCommitTs;
-                if (expected === null) {
-                    // We read "no row"; conflict if a row now exists.
-                    if (current !== undefined) {
-                        throw new OccConflictError(`Conflict: row ${entry.table}/${entry.id} was inserted concurrently`, { table: entry.table, id: entry.id });
-                    }
-                }
-                else {
-                    if (current === undefined) {
-                        throw new OccConflictError(`Conflict: row ${entry.table}/${entry.id} was deleted concurrently`, { table: entry.table, id: entry.id, expected });
-                    }
-                    if (current !== expected) {
-                        throw new OccConflictError(`Conflict: row ${entry.table}/${entry.id} changed from ts=${expected} to ts=${current}`, { table: entry.table, id: entry.id, expected, current });
-                    }
-                }
-            }
-        }
-    }
-    async pruneCommitLogsBefore(ts) {
-        const result = await this.query(`DELETE FROM commit_logs WHERE ts < $1`, [ts]);
-        return BigInt(result.rowCount ?? 0);
-    }
-    async getCommitLogsBetweenTs(beginTs, endTs, tableIds) {
-        if (tableIds.length === 0)
-            return [];
-        const placeholders = tableIds.map((_, i) => `$${i + 3}`).join(", ");
-        const sql = `SELECT id, ts, table_id, data FROM commit_logs WHERE ts >= $1 AND ts < $2 AND table_id IN (${placeholders})`;
-        const result = await this.query(sql, [beginTs, endTs, ...tableIds.map(toBufferView)]);
-        return result.rows.map((row) => ({
-            id: normalizeToBytes(row.id),
-            ts: BigInt(row.ts),
-            tableId: normalizeToBytes(row.table_id),
-            data: normalizeToBytes(row.data),
-        }));
-    }
-    async getCommitLogsSinceTs(sinceTs, excludeTs, tableIds) {
-        if (tableIds.length === 0)
-            return [];
-        const placeholders = tableIds.map((_, i) => `$${i + 3}`).join(", ");
-        const sql = `SELECT id, ts, table_id, data FROM commit_logs WHERE ts >= $1 AND ts <> $2 AND table_id IN (${placeholders})`;
-        const result = await this.query(sql, [sinceTs, excludeTs, ...tableIds.map(toBufferView)]);
-        return result.rows.map((row) => ({
-            id: normalizeToBytes(row.id),
-            ts: BigInt(row.ts),
-            tableId: normalizeToBytes(row.table_id),
-            data: normalizeToBytes(row.data),
-        }));
-    }
-    async close() {
-        await this.pool.end();
-    }
-}
-export class PgTxDatabase extends PgDatabase {
-    constructor(logger, config, pool, client) {
-        super(logger, config, pool);
-        this.client = client;
-    }
-    client;
-    async query(sql, params = []) {
-        try {
-            const result = await this.client.query(sql, params);
-            return {
-                rows: result.rows,
-                rowCount: result.rowCount,
-            };
-        }
-        catch (err) {
-            throw translatePgError(err);
-        }
-    }
-    async begin() {
-        await this.client.query("BEGIN");
-    }
-    async commit() {
-        await this.client.query("COMMIT");
-    }
-    async rollback() {
-        await this.client.query("ROLLBACK");
-    }
-    release() {
-        this.client.release();
-    }
-}
-/**
- * Returns the unnest carrier array type for a column of `pgType`.
- * Scalars ride as their own array type so PG infers cleanly without an
- * extra cast on the SELECT/SET side. Array and jsonb columns can't ride
- * as their own array type (ragged 2D arrays aren't permitted, and the
- * driver can't tag jsonb sub-elements correctly inside a typed array),
- * so they get the universal `text[]` carrier with an explicit cast in
- * the SELECT/SET clause. Bytea rides natively as `bytea[]`.
- */
-function pgCarrierType(pgType) {
-    const base = pgType.trim().toLowerCase();
-    if (base === "bytea")
-        return "bytea[]";
-    if (base === "jsonb" || base === "json")
-        return "text[]";
-    if (base.endsWith("[]"))
-        return "text[]";
-    return `${pgType}[]`;
-}
-/** SELECT/SET expression for an unnest alias of a column with `pgType`.
- * When the carrier matches the column type (scalar / bytea), no cast is
- * needed and the alias passes through. When the carrier is text[] (jsonb
- * or array column), we cast back to the declared type. */
-function pgSelectExpr(alias, pgType) {
-    const base = pgType.trim().toLowerCase();
-    if (base === "jsonb" || base === "json" || base.endsWith("[]")) {
-        return `(${alias})::${pgType}`;
-    }
-    return alias;
-}
-/**
- * Encodes a JS runtime value for transport via the chosen unnest carrier.
- * For scalar columns the pg driver handles type coercion directly (bigint,
- * number, boolean, Date, etc. all serialize cleanly). For jsonb columns we
- * stringify; for array columns we build a PG array literal. For bytea
- * columns we forward the bytes.
- *
- * Codecs declared by the upstream schema layer run before this point, so
- * `value` is already in the driver-side shape for its declared column.
- */
-function encodeForCarrier(value, pgTypeBase) {
-    if (value === null || value === undefined)
-        return null;
-    if (pgTypeBase === "bytea") {
-        return toBufferView(normalizeToBytes(value));
-    }
-    if (pgTypeBase === "jsonb" || pgTypeBase === "json") {
-        return typeof value === "string" ? value : supaliveStringify(value);
-    }
-    if (pgTypeBase.endsWith("[]")) {
-        if (!Array.isArray(value)) {
-            throw new Error(`Expected array for column of type ${pgTypeBase}, got ${typeof value}`);
-        }
-        return pgArrayLiteral(value);
-    }
-    return value;
-}
-/** Serializes a JS array to a Postgres array literal `{a,b,c}`. Strings
- * are double-quoted with backslash/quote escaping; primitives stringify
- * directly; null becomes the literal NULL. */
-function pgArrayLiteral(arr) {
-    const parts = new Array(arr.length);
-    for (let i = 0; i < arr.length; i++) {
-        const v = arr[i];
-        if (v === null || v === undefined) {
-            parts[i] = "NULL";
-        }
-        else if (typeof v === "string") {
-            parts[i] = `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-        }
-        else if (typeof v === "number" || typeof v === "bigint" || typeof v === "boolean") {
-            parts[i] = String(v);
-        }
-        else {
-            const s = supaliveStringify(v);
-            parts[i] = `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-        }
-    }
-    return `{${parts.join(",")}}`;
-}
-/**
- * Postgres deadlock_detected (40P01) is transient and semantically equivalent
- * to an OCC conflict from the mutation runner's perspective: re-execute the
- * handler with a fresh snapshot. Wrapping here lets realtime_db.ts stay
- * driver-agnostic — its retry loop already handles OccConflictError.
- */
-function translatePgError(err) {
-    if (err && typeof err === "object" && err.code === "40P01") {
-        return new OccConflictError("deadlock detected", err);
-    }
-    return err;
-}
-// PG: when a sub-path is set, scope the target via `jsonb_path_query_first`
-// (returns the value at the path, or NULL → falsy in WHERE) before the
-// containment / array-membership check. Cast bound text to jsonb so the
-// same code path works for both `json` and `jsonb` columns.
-function pgScopedTarget(col, pathIndex) {
-    return pathIndex === undefined
-        ? col
-        : `jsonb_path_query_first(${col}::jsonb, $${pathIndex}::jsonpath)`;
-}
-export const pgSql = {
-    placeholder: (i) => `$${i}`,
-    like: (col, i) => `${col} LIKE $${i}`,
-    ilike: (col, i) => `${col} ILIKE $${i}`,
-    icontains: (col, i) => `${col} ILIKE $${i}`,
-    jsonContains: (col, i, opts) => `${pgScopedTarget(col, opts?.pathIndex)} @> $${i}::jsonb`,
-    jsonContainedBy: (col, i, opts) => `${pgScopedTarget(col, opts?.pathIndex)} <@ $${i}::jsonb`,
-    jsonHasKey: (col, i, opts) => {
-        if (opts?.pathCount && opts.pathCount > 0) {
-            const joiner = opts.mode === "all" ? " AND " : " OR ";
-            const parts = [];
-            for (let k = 0; k < opts.pathCount; k++) {
-                parts.push(`jsonb_path_exists(${col}, $${i + k}::jsonpath)`);
-            }
-            return `(${parts.join(joiner)})`;
-        }
-        return opts?.raw
-            ? `jsonb_path_exists(${col}, $${i}::jsonpath)`
-            : `${col} ? $${i}`;
-    },
-    jsonArrayContains: (col, i, opts) => `${pgScopedTarget(col, opts?.pathIndex)} @> jsonb_build_array($${i}::jsonb)`,
-};
-//# sourceMappingURL=postgres.js.map