@supalive/core 1.20.0 → 1.20.1

package/dist/mysql-BX3cm94v.js

@@ -0,0 +1,622 @@
+import { o as utf8Encode, r as supaliveStringify } from "./helper-zdJT5FUc.js";
+import { i as mapReadSetToRaw, s as CORE_INIT_LOCK_NAME, t as checkLogsAffectReadSet } from "./overlap-checker-CCgq_Tpa.js";
+import { C as normalizeIdToBytes, l as OccConflictError, w as normalizeToBytes } from "./types_db-OUou3o2Z.js";
+import mysql from "mysql2/promise";
+//#region src/db/mysql.ts
+function toBufferView(bytes) {
+	if (Buffer.isBuffer(bytes)) return bytes;
+	return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function encodeMysqlWriteParam(value) {
+	if (value == null) return value;
+	if (value instanceof Map) return JSON.stringify(Object.fromEntries(value));
+	if (Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype) return JSON.stringify(value);
+	return value;
+}
+/**
+* mysql2 returns `ResultSetHeader` for non-SELECT queries (carrying
+* `affectedRows`) and `RowDataPacket[]` for SELECTs. The previous shim
+* blindly cast to T[] which made `rowCount` zero for UPDATE/DELETE, breaking
+* CAS detection. This helper picks the right shape.
+*/
+function normalizeMysqlResult(raw) {
+	if (Array.isArray(raw)) return {
+		rows: raw,
+		rowCount: raw.length
+	};
+	if (raw && typeof raw === "object" && "affectedRows" in raw) {
+		const header = raw;
+		return {
+			rows: [],
+			rowCount: Number(header.affectedRows) || 0,
+			insertId: header.insertId
+		};
+	}
+	return {
+		rows: [],
+		rowCount: 0
+	};
+}
+var MySqlDatabase = class {
+	constructor(logger, config, pool = void 0) {
+		this.logger = logger;
+		const { queryTimeoutMs, ...poolConfig } = config;
+		this.queryTimeoutMs = queryTimeoutMs ?? 0;
+		this.config = poolConfig;
+		if (pool) this.pool = pool;
+		else this.pool = mysql.createPool(poolConfig);
+	}
+	logger;
+	config;
+	queryTimeoutMs;
+	pool;
+	dbType = "mysql";
+	sqlBuilder = mysqlSql;
+	columnTypes = /* @__PURE__ */ new Map();
+	sqlCache = /* @__PURE__ */ new Map();
+	/**
+	* Fetches actual column types from MySQL for `table` and returns a
+	* map of DB column name → MySQL type string (as produced by `COLUMN_TYPE`,
+	* e.g. `bigint`, `integer`, `varchar(32)`, `text`, `json`).
+	* No caching here — see {@link getColumnTypes} for the cached path.
+	*/
+	async loadColumnTypesFromMySql(table) {
+		const result = await this.query(`SELECT COLUMN_NAME AS column_name, COLUMN_TYPE AS mysql_type
+         FROM INFORMATION_SCHEMA.COLUMNS
+         WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
+         ORDER BY ORDINAL_POSITION`, [table]);
+		const out = /* @__PURE__ */ new Map();
+		for (const row of result.rows) out.set(row.column_name.toLowerCase(), row.mysql_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 }, "MySqlDatabase: 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
+	* MySQL on miss (writing the result back to Redis). This is the
+	* "one server queries MySQL, the rest read from Redis" pattern for cold
+	* starts in a multi-instance deploy. Without Redis, always queries MySQL.
+	*
+	* 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.loadColumnTypesFromMySql(t);
+			this.columnTypes.set(t, fresh);
+		}
+		if (redis) {
+			const dump = {};
+			for (const [table, cols] of this.columnTypes) dump[table] = Object.fromEntries(Object.entries(cols).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();
+		}
+	}
+	/** Replace this instance's caches with shared references from a parent.
+	*  Used by getTransactionClient so types loaded once at startup are
+	*  visible inside transactions. */
+	adoptCaches(columnTypes, sqlCache) {
+		this.columnTypes = columnTypes;
+		this.sqlCache = sqlCache;
+	}
+	/** Enumerate the user-defined tables in the connected database for mysql — used
+	* by bootstrapColumnTypes() when no explicit list is provided. */
+	async listUserTables() {
+		return (await this.query(`SELECT table_name FROM information_schema.tables
+       WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'
+         AND table_name NOT IN ('commit_logs', 'metadata', 'global_commit_ts')`)).rows.map((r) => r.table_name);
+	}
+	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 IGNORE INTO global_commit_ts SELECT 0 WHERE NOT EXISTS (SELECT 1 FROM global_commit_ts)`,
+			`INSERT IGNORE INTO metadata (meta_key, meta_value) VALUES ('latest_committed_ts', 0)`,
+			`INSERT IGNORE INTO metadata (meta_key, meta_value) VALUES ('min_retained_ts', 0)`
+		];
+		return [];
+	}
+	async withCoreInitLock(fn) {
+		const conn = await this.pool.getConnection();
+		try {
+			const [rows] = await conn.query("SELECT GET_LOCK(?, 30) AS locked", [CORE_INIT_LOCK_NAME]);
+			if ((Array.isArray(rows) ? rows[0]?.locked : void 0) !== 1) throw new Error(`Failed to acquire core-init lock '${CORE_INIT_LOCK_NAME}'`);
+			await fn({
+				exec: async (sql, params = []) => {
+					const [r] = await conn.query(sql, params);
+					return normalizeMysqlResult(r);
+				},
+				getVersion: async () => {
+					const [r] = await conn.query("SELECT meta_value FROM metadata WHERE meta_key = 'core_version'");
+					const row = Array.isArray(r) ? r[0] : void 0;
+					return BigInt(row?.meta_value ?? 0);
+				},
+				setVersion: async (version) => {
+					await conn.query(`INSERT INTO metadata (meta_key, meta_value) VALUES ('core_version', ?)
+             ON DUPLICATE KEY UPDATE meta_value = VALUES(meta_value)`, [version.toString()]);
+				}
+			});
+		} finally {
+			await conn.query("SELECT RELEASE_LOCK(?)", [CORE_INIT_LOCK_NAME]).catch(() => {});
+			conn.release();
+		}
+	}
+	async query(sql, params = []) {
+		const client = await this.pool.getConnection();
+		try {
+			const [rows] = this.queryTimeoutMs > 0 ? await client.query({
+				sql,
+				values: params,
+				timeout: this.queryTimeoutMs
+			}) : await client.query(sql, params);
+			return normalizeMysqlResult(rows);
+		} catch (err) {
+			throw translateMysqlError(err);
+		} finally {
+			client.release();
+		}
+	}
+	async getClient() {
+		return await this.pool.getConnection();
+	}
+	async getTransactionClient() {
+		const client = await this.pool.getConnection();
+		const tx = new MySqlTxDatabase(this.logger, {
+			...this.config,
+			queryTimeoutMs: this.queryTimeoutMs
+		}, this.pool, client);
+		tx.adoptCaches(this.columnTypes, this.sqlCache);
+		return tx;
+	}
+	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 = ? WHERE meta_key = 'latest_committed_ts' AND meta_value < ?`, [commitTs, 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 = ? WHERE meta_key = 'min_retained_ts' AND meta_value < ?`, [ts, ts]);
+	}
+	async getNextTimestamp() {
+		const result = await this.query("UPDATE global_commit_ts SET id = LAST_INSERT_ID(id + 1)");
+		return BigInt(result.insertId ?? 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(() => "?").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(String(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.mysqlPrepareBatchWrites(result, writeSet, commitTs);
+		await this.mysqlPrepareCommitLogs(result, writeSet, commitTs);
+		if (!readSet.some((r) => r.kind === "range")) return {
+			commits: result,
+			validateReadPoints: this.mysqlPrepareValidatePointReadsByCommitTs(readSet, writeSet),
+			hasRangeRead: false
+		};
+		const rawReadSet = mapReadSetToRaw(readSet);
+		return {
+			commits: result,
+			hasRangeRead: true,
+			tableIds: [...new Set(rawReadSet.map((r) => r.tableId))],
+			rawReadSet
+		};
+	}
+	async mysqlPrepareBatchWrites(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.mysqlPrepareInsertBatch(result, table, batch, commitTs);
+			else if (op === "update") await this.mysqlPrepareUpdateSingle(result, table, batch, commitTs);
+			else await this.mysqlPrepareDeleteBatch(result, table, batch);
+			i = j;
+			if (counter % 50 == 0) await new Promise((resolve) => setImmediate(resolve));
+		}
+	}
+	async mysqlPrepareInsertBatch(result, table, entries, commitTs) {
+		if (entries.length === 0) 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 values = [];
+			const tuples = [];
+			for (const entry of rows) {
+				const data = {
+					...entry.data ?? {},
+					commit_ts: commitTs
+				};
+				tuples.push(`(${cols.map(() => "?").join(", ")})`);
+				for (const col of cols) values.push(encodeMysqlWriteParam(data[col]));
+			}
+			if (counter % 50 == 0) await new Promise((resolve) => setImmediate(resolve));
+			result.push({
+				sql: `INSERT INTO ${table} (${cols.join(", ")}) VALUES ${tuples.join(", ")}`,
+				params: values,
+				operation: "insertBatch",
+				table
+			});
+		}
+	}
+	async mysqlPrepareUpdateSingle(result, table, entries, commitTs) {
+		if (entries.length === 0) return;
+		let counter = 0;
+		for (const entry of entries) {
+			counter++;
+			const data = {
+				...entry.data ?? {},
+				commit_ts: commitTs
+			};
+			const sets = Object.keys(data).map((c) => `${c} = ?`);
+			const values = Object.values(data).map(encodeMysqlWriteParam);
+			const expected = entry.expectedCommitTs ?? -1n;
+			if (counter % 50 == 0) await new Promise((resolve) => setImmediate(resolve));
+			result.push({
+				sql: `UPDATE ${table} SET ${sets.join(", ")} WHERE id = ? AND commit_ts = ?`,
+				params: [
+					...values,
+					entry.id,
+					expected
+				],
+				operation: "updateSingle",
+				table,
+				entryId: entry.id,
+				expectedTs: expected
+			});
+		}
+	}
+	async mysqlPrepareDeleteBatch(result, table, entries) {
+		if (entries.length === 0) return;
+		let counter = 0;
+		for (const entry of entries) {
+			counter++;
+			const expected = entry.expectedCommitTs ?? -1n;
+			if (counter % 50 == 0) await new Promise((resolve) => setImmediate(resolve));
+			result.push({
+				sql: `DELETE FROM ${table} WHERE id = ? AND commit_ts = ?`,
+				params: [entry.id, expected],
+				table,
+				operation: "deleteSingle",
+				entryId: entry.id,
+				expectedTs: expected
+			});
+		}
+	}
+	async mysqlPrepareCommitLogs(result, writeEntries, commitTs) {
+		if (writeEntries.length === 0) return;
+		const values = [];
+		const tuples = [];
+		let counter = 0;
+		for (const entry of writeEntries) {
+			counter++;
+			tuples.push(`(?, ?, ?, ?)`);
+			values.push(toBufferView(normalizeIdToBytes(entry.id)), commitTs, toBufferView(entry.tableId), 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) VALUES ${tuples.join(", ")}`,
+			params: values,
+			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.
+	*/
+	mysqlPrepareValidatePointReadsByCommitTs(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(() => "?").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.mysqlApplyWrites(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 mysqlApplyWrites(result) {
+		for (const q of result) switch (q.operation) {
+			case "insertBatch":
+				try {
+					await this.query(q.sql, q.params);
+				} catch (err) {
+					if (err && typeof err === "object" && (err.errno === 1062 || err.code === "ER_DUP_ENTRY")) {
+						const failedId = (err.message ?? "").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,
+					expected: 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,
+					expected: q.expectedTs
+				});
+				break;
+			case "commit_logs":
+				await this.query(q.sql, q.params);
+				break;
+			default: throw new Error("Unhandled MySQL Operation: " + q.operation);
+		}
+	}
+	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(String(row.id), BigInt(row.commit_ts));
+			for (const { entry } of q.pendingsEntry ?? []) {
+				const current = currentById.get(String(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 < ?`, [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 >= ? AND ts < ? AND table_id IN (${tableIds.map(() => "?").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 >= ? AND ts < ? AND (table_id, id) IN (${points.map(() => "(?, ?)").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 >= ? AND ts <> ? AND table_id IN (${tableIds.map(() => "?").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 MySqlTxDatabase = class extends MySqlDatabase {
+	constructor(logger, config, pool, client) {
+		super(logger, config, pool);
+		this.client = client;
+	}
+	client;
+	async query(sql, params = []) {
+		try {
+			const [rows] = this.queryTimeoutMs > 0 ? await this.client.query({
+				sql,
+				values: params,
+				timeout: this.queryTimeoutMs
+			}) : await this.client.query(sql, params);
+			return normalizeMysqlResult(rows);
+		} catch (err) {
+			throw translateMysqlError(err);
+		}
+	}
+	async begin() {
+		await this.client.beginTransaction();
+	}
+	async commit() {
+		await this.client.commit();
+	}
+	async rollback() {
+		await this.client.rollback();
+	}
+	release() {
+		this.client.release();
+	}
+};
+/**
+* MySQL InnoDB deadlock (errno 1213 / SQLSTATE 40001) 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 translateMysqlError(err) {
+	if (err && typeof err === "object" && (err.errno === 1213 || err.code === "ER_LOCK_DEADLOCK")) return new OccConflictError("deadlock detected", err);
+	return err;
+}
+const mysqlSql = {
+	placeholder: (i) => `?`,
+	like: (col, i) => `${col} LIKE ?`,
+	ilike: (col, i) => `${col} LIKE ?`,
+	icontains: (col, i) => `${col} LIKE ?`,
+	jsonContains: (col, _i, opts) => opts?.pathIndex !== void 0 ? `JSON_CONTAINS(${col}, CAST(? AS JSON), ?)` : `JSON_CONTAINS(${col}, CAST(? AS JSON))`,
+	jsonContainedBy: (col, _i, opts) => opts?.pathIndex !== void 0 ? `JSON_CONTAINS(CAST(? AS JSON), JSON_EXTRACT(${col}, ?))` : `JSON_CONTAINS(CAST(? AS JSON), ${col})`,
+	jsonHasKey: (col, _i, opts) => {
+		if (opts?.pathCount && opts.pathCount > 0) return `JSON_CONTAINS_PATH(${col}, ${opts.mode === "all" ? "'all'" : "'one'"}, ${new Array(opts.pathCount).fill("?").join(", ")})`;
+		return opts?.raw ? `JSON_CONTAINS_PATH(${col}, 'one', ?)` : `JSON_CONTAINS_PATH(${col}, 'one', CONCAT('$."', REPLACE(?, '"', '\\\\"'), '"'))`;
+	},
+	jsonArrayContains: (col, _i, opts) => opts?.pathIndex !== void 0 ? `JSON_CONTAINS(${col}, JSON_ARRAY(CAST(? AS JSON)), ?)` : `JSON_CONTAINS(${col}, JSON_ARRAY(CAST(? AS JSON)))`
+};
+//#endregion
+export { MySqlDatabase as t };
+
+//# sourceMappingURL=mysql-BX3cm94v.js.map