@supalive/core 1.15.0 → 1.17.0

package/dist/postgres-CRPJdZx2.js

@@ -0,0 +1,868 @@
+import { o as utf8Encode, r as supaliveStringify } from "./helper-zdJT5FUc.js";
+import { t as CORE_INIT_LOCK_KEY } from "./db-ClCicssQ.js";
+import { C as normalizeIdToBytes, l as OccConflictError, w as normalizeToBytes } from "./types_db-OUou3o2Z.js";
+import { i as mapReadSetToRaw, t as checkLogsAffectReadSet } from "./overlap-checker-CGlxWcyb.js";
+import { Pool } from "pg";
+//#region src/db/postgres.ts
+function toBufferView(bytes) {
+	if (Buffer.isBuffer(bytes)) return bytes;
+	return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+var PgDatabase = class {
+	constructor(logger, config, pool = void 0) {
+		this.logger = logger;
+		this.config = config;
+		if (pool) this.pool = pool;
+		else this.pool = new Pool(config);
+	}
+	logger;
+	config;
+	pool;
+	sqlBuilder = pgSql;
+	dbType = "postgres";
+	columnTypes = /* @__PURE__ */ new Map();
+	sqlCache = /* @__PURE__ */ 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]);
+		const out = /* @__PURE__ */ 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;
+		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;
+			}
+		}
+		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);
+		}
+		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() {
+		return (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')`)).rows.map((r) => r.relname);
+	}
+	async getCoreVersion() {
+		const result = await this.query("SELECT meta_value FROM metadata WHERE meta_key = 'core_version'");
+		return BigInt(result.rows[0]?.meta_value ?? 0);
+	}
+	async getAppMigration() {
+		const result = await this.query("SELECT meta_value FROM metadata WHERE meta_key = 'app_migration'");
+		return BigInt(result.rows[0]?.meta_value ?? 0);
+	}
+	coreMigrationStatements(toVersion) {
+		if (toVersion === 1n) return [`INSERT INTO metadata (meta_key, meta_value) VALUES ('latest_committed_ts', 0) ON CONFLICT (meta_key) DO NOTHING;`, `INSERT INTO metadata (meta_key, meta_value) VALUES ('min_retained_ts', 0) ON CONFLICT (meta_key) DO NOTHING;`];
+		return [];
+	}
+	async withCoreInitLock(fn) {
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			await client.query("SELECT pg_advisory_xact_lock($1)", [CORE_INIT_LOCK_KEY]);
+			await fn({
+				exec: async (sql, params = []) => {
+					const r = await client.query(sql, params);
+					return {
+						rows: r.rows,
+						rowCount: r.rowCount
+					};
+				},
+				getVersion: async () => {
+					const r = await client.query("SELECT meta_value FROM metadata WHERE meta_key = 'core_version'");
+					return BigInt(r.rows[0]?.meta_value ?? 0);
+				},
+				setVersion: async (version) => {
+					await client.query(`INSERT INTO metadata (meta_key, meta_value) VALUES ('core_version', $1)
+             ON CONFLICT (meta_key) DO UPDATE SET meta_value = EXCLUDED.meta_value`, [version.toString()]);
+				}
+			});
+			await client.query("COMMIT");
+		} catch (err) {
+			await client.query("ROLLBACK").catch(() => {});
+			throw translatePgError(err);
+		} finally {
+			client.release();
+		}
+	}
+	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.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);
+	}
+	async updateLatestSnapshotTimestamp(commitTs) {
+		await this.query("UPDATE metadata SET meta_value = $1 WHERE meta_key = 'latest_committed_ts' AND meta_value < $1", [commitTs]);
+	}
+	async getMinSnapshotTimestamp() {
+		const result = await this.query("SELECT meta_value FROM metadata WHERE meta_key = 'min_retained_ts'");
+		return BigInt(result.rows[0]?.meta_value ?? 0);
+	}
+	async updateMinSnapshotTimestamp(ts) {
+		await this.query("UPDATE metadata SET meta_value = $1 WHERE meta_key = 'min_retained_ts' AND meta_value < $1", [ts]);
+	}
+	async getNextTimestamp() {
+		const result = await this.query("SELECT nextval('global_commit_ts') as nextval");
+		return BigInt(result.rows[0]?.nextval ?? "0");
+	}
+	async attachPrevDataToWriteSet(writeSet, readSet) {
+		const readTsByKey = /* @__PURE__ */ new Map();
+		for (let i = readSet.length - 1; i >= 0; i--) {
+			const r = readSet[i];
+			if (r.kind !== "point" || r.expectedCommitTs === void 0) continue;
+			const key = `${r.table} ${r.id}`;
+			if (!readTsByKey.has(key)) readTsByKey.set(key, r.expectedCommitTs);
+		}
+		const byTable = /* @__PURE__ */ 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 sql = `SELECT * FROM ${table} WHERE id IN (${ids.map((_, i) => `$${i + 1}`).join(", ")})`;
+			const result = await this.query(sql, ids);
+			const byId = /* @__PURE__ */ 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;
+					entry.expectedCommitTs = priorReadTs !== void 0 ? priorReadTs : BigInt(row.commit_ts);
+				} else if (priorReadTs !== void 0) entry.expectedCommitTs = priorReadTs;
+			}
+		}
+	}
+	async prepareCommitWrites(readSet, writeSet, commitTs) {
+		const result = [];
+		await this.pgPrepareBatchWrites(result, writeSet, commitTs);
+		await this.pgPrepareCommitLogs(result, writeSet, commitTs);
+		if (!readSet.some((r) => r.kind === "range")) return {
+			commits: result,
+			validateReadPoints: this.pgPrepareValidatePointReadsByCommitTs(readSet, writeSet),
+			hasRangeRead: false
+		};
+		const rawReadSet = mapReadSetToRaw(readSet);
+		return {
+			commits: result,
+			hasRangeRead: true,
+			tableIds: [...new Set(rawReadSet.map((r) => r.tableId))],
+			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));
+		}
+	}
+	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,
+			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;
+		}
+		const groups = /* @__PURE__ */ 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);
+			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,
+				params,
+				operation: "insertBatch",
+				table
+			});
+		}
+	}
+	pgPrepareUpdateSingle(result, table, entry, commitTs) {
+		const data = {
+			...entry.data ?? {},
+			commit_ts: commitTs
+		};
+		const sets = Object.keys(data).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,
+			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 = /* @__PURE__ */ 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,
+				params,
+				operation: "updateBatch",
+				table,
+				entries: rows
+			});
+		}
+	}
+	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,
+			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,
+			params: [idArr, expArr],
+			operation: "deleteBatch",
+			table,
+			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 idCarrier = `$1::${pgCarrierType(types.get("id") ?? "text")}`;
+		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}`)
+		];
+		sql = `UPDATE ${table} AS t SET ${cols.map((c, i) => {
+			const pgType = types.get(c.toLowerCase()) ?? "text";
+			return `${c} = ${pgSelectExpr(`u.${aliases[i + 2]}`, pgType)}`;
+		}).join(", ")} 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;
+		sql = `DELETE FROM ${table} AS t USING unnest($1::${pgCarrierType(types.get("id") ?? "text")}, $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;
+		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 = [];
+		const writeKeys = /* @__PURE__ */ new Set();
+		for (const w of writeSet) writeKeys.add(`${w.table} ${w.id}`);
+		const byTable = /* @__PURE__ */ new Map();
+		const seen = /* @__PURE__ */ 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);
+			if (entry.expectedCommitTs === void 0) 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,
+				operation: "pointReadValidation",
+				pendingsEntry: pendings
+			});
+		}
+		return result;
+	}
+	async commitWrites(beginTs, queries, commitTs) {
+		await this.pgApplyWrites(queries.commits);
+		if (!queries.hasRangeRead) {
+			if ((queries.validateReadPoints?.length ?? 0) > 0) await this.validatePointReadsByCommitTs(queries.validateReadPoints ?? []);
+			return { success: true };
+		}
+		const logs = await this.getCommitLogsSinceTs(beginTs, commitTs, queries.tableIds ?? []);
+		if (checkLogsAffectReadSet(logs, queries.rawReadSet ?? [])) throw new OccConflictError(`Conflict detected: overlapping commit logs since ${beginTs}`, { logs });
+		return { success: true };
+	}
+	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 failedId = (err.detail?.match(/Key \([^)]+\)=\(([^)]+)\)/))?.[1];
+						throw new OccConflictError(failedId !== void 0 ? `Conflict: insert into ${q.table}/${failedId} hit duplicate key` : `Conflict: batch insert into ${q.table} hit duplicate key`, err);
+					}
+					throw err;
+				}
+				break;
+			case "updateSingle":
+				if (((await this.query(q.sql, q.params)).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 = /* @__PURE__ */ 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":
+				if (((await this.query(q.sql, q.params)).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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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) {
+					if (current !== void 0) throw new OccConflictError(`Conflict: row ${entry.table}/${entry.id} was inserted concurrently`, {
+						table: entry.table,
+						id: entry.id
+					});
+				} else {
+					if (current === void 0) 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 getMinCommitLogTs() {
+		const min = (await this.query(`SELECT min(ts) AS min FROM commit_logs`)).rows[0]?.min;
+		return min === null || min === void 0 ? null : BigInt(min);
+	}
+	async getCommitLogsBetweenTs(beginTs, endTs, tableIds) {
+		if (tableIds.length === 0) return [];
+		const sql = `SELECT id, ts, table_id, data FROM commit_logs WHERE ts >= $1 AND ts < $2 AND table_id IN (${tableIds.map((_, i) => `$${i + 3}`).join(", ")})`;
+		return (await this.query(sql, [
+			beginTs,
+			endTs,
+			...tableIds.map(toBufferView)
+		])).rows.map((row) => ({
+			id: normalizeToBytes(row.id),
+			ts: BigInt(row.ts),
+			tableId: normalizeToBytes(row.table_id),
+			data: normalizeToBytes(row.data)
+		}));
+	}
+	async hasCommitForPoints(beginTs, endTs, points) {
+		if (points.length === 0) return false;
+		const sql = `SELECT 1 FROM commit_logs WHERE ts >= $1 AND ts < $2 AND (table_id, id) IN (${points.map((_, i) => `($${i * 2 + 3}, $${i * 2 + 4})`).join(", ")}) LIMIT 1`;
+		const params = [beginTs, endTs];
+		for (const p of points) params.push(toBufferView(p.tableId), toBufferView(p.id));
+		return (await this.query(sql, params)).rows.length > 0;
+	}
+	async getCommitLogsSinceTs(sinceTs, excludeTs, tableIds) {
+		if (tableIds.length === 0) return [];
+		const sql = `SELECT id, ts, table_id, data FROM commit_logs WHERE ts >= $1 AND ts <> $2 AND table_id IN (${tableIds.map((_, i) => `$${i + 3}`).join(", ")})`;
+		return (await this.query(sql, [
+			sinceTs,
+			excludeTs,
+			...tableIds.map(toBufferView)
+		])).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();
+	}
+};
+var PgTxDatabase = class 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 === void 0) 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 === void 0) 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 parts[i] = `"${supaliveStringify(v).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;
+}
+function pgScopedTarget(col, pathIndex) {
+	return pathIndex === void 0 ? col : `jsonb_path_query_first(${col}::jsonb, $${pathIndex}::jsonpath)`;
+}
+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)`
+};
+//#endregion
+export { PgDatabase as t };
+
+//# sourceMappingURL=postgres-CRPJdZx2.js.map