@voltro/sql-mysql 0.1.0

package/dist/index.js

@@ -0,0 +1,946 @@
+import { MysqlClient as e } from "@effect/sql-mysql2";
+import { Config as t, Effect as n, Layer as r, ManagedRuntime as i, Option as a, Redacted as o, Schedule as s } from "effect";
+import { EventEmitter as c } from "node:events";
+import { createLogger as l } from "@voltro/logger";
+import { SqlClient as u, TransactionConnection as d } from "@effect/sql/SqlClient";
+import { attachEagerLoads as f, compileEagerJson as p, compilePredicate as m, compileRawFragment as h, compileSelect as g, decodeRowsFromSchema as _, encodeRowForSchema as v, hasEagerLoads as y, id as b, qualifyTable as x, requireTable as S, table as C, text as w, timestamp as T } from "@voltro/database";
+//#region src/sqlLayer.ts
+var E = (n) => e.layerConfig({
+	host: t.succeed(n.host),
+	port: t.succeed(n.port),
+	username: t.succeed(n.username),
+	password: t.succeed(o.make(n.password)),
+	database: t.succeed(n.database),
+	...n.maxConnections === void 0 ? {} : { maxConnections: t.succeed(n.maxConnections) }
+}), D = (e) => {
+	if (e.url) {
+		let t = new URL(e.url);
+		return {
+			host: t.hostname || "localhost",
+			port: t.port ? Number(t.port) : 3306,
+			username: decodeURIComponent(t.username || "app"),
+			password: decodeURIComponent(t.password || "app"),
+			database: t.pathname.replace(/^\//, "") || "app",
+			...e.maxConnections === void 0 ? {} : { maxConnections: e.maxConnections }
+		};
+	}
+	return {
+		host: e.host ?? "localhost",
+		port: e.port ?? 3306,
+		username: e.username ?? "app",
+		password: e.password ?? "app",
+		database: e.database ?? "app",
+		...e.maxConnections === void 0 ? {} : { maxConnections: e.maxConnections }
+	};
+}, O = (e) => E(D(e)), k = (e, t) => e === null ? !1 : t === null ? !0 : e.filename === t.filename ? e.position > t.position : e.filename > t.filename, A = (e) => e.msSinceProgress < e.stallThresholdMs ? "healthy" : e.primary !== null && !k(e.primary, e.reader) ? "idle-caught-up" : "reconnect", j = (e) => (e instanceof Error ? e.message : String(e ?? "")).includes("schema changed between binlog event and metadata fetch"), M = /* @__PURE__ */ new Set([
+	"writerows",
+	"updaterows",
+	"deleterows"
+]), N = /\b(alter|rename|drop|create)\s+(table|column)?/i, P = (e) => new Promise((t) => setTimeout(t, e)), F = async (e) => {
+	let t = l({ scope: `voltro:${e.variant}:cdc` }), n;
+	try {
+		n = (await import("@vlasky/zongji")).default;
+	} catch (t) {
+		throw Error(`changeStrategy='cdc' on ${e.variant} requires the '@vlasky/zongji' optional dependency. Install it (it ships as an optionalDependency of @voltro/sql-mysql) to enable binlog CDC.`, { cause: t });
+	}
+	let r = e.includeTables ? new Set(e.includeTables) : null, i = e.connection.database, a = e.startPosition?.filename ?? null, o = e.startPosition ?? null, s = (t, n) => _([n], t, e.variant)[0], c = null, u = !1, d = 0, f = Date.now(), p = !1, m = null, h = e.stallThresholdMs ?? 25e3, g = e.watchdogIntervalMs ?? 15e3, v = () => {
+		f = Date.now();
+	}, y = (n) => {
+		v();
+		let l = n.getEventName();
+		if (l === "rotate" && n.binlogName) {
+			a = n.binlogName;
+			return;
+		}
+		if (l === "query" && n.query && N.test(n.query)) {
+			c && (c.tableMap = {});
+			return;
+		}
+		if (n.nextPosition && a && (o = {
+			filename: a,
+			position: n.nextPosition
+		}, e.onPosition?.(o)), !M.has(l)) return;
+		let u = n.tableMap[n.tableId];
+		if (!u || u.parentSchema !== i) return;
+		let d = u.tableName;
+		if (!d.startsWith("_voltro_") && !(r && !r.has(d))) try {
+			if (l === "writerows") for (let t of n.rows) e.onChange({
+				table: d,
+				op: "insert",
+				old: null,
+				new: s(d, t)
+			});
+			else if (l === "deleterows") for (let t of n.rows) e.onChange({
+				table: d,
+				op: "delete",
+				old: s(d, t),
+				new: null
+			});
+			else for (let t of n.rows) e.onChange({
+				table: d,
+				op: "update",
+				old: s(d, t.before),
+				new: s(d, t.after)
+			});
+		} catch (n) {
+			t.warn("cdc: failed to map a row event", {
+				table: d,
+				name: l
+			}, n), e.onError?.(n);
+		}
+	}, b = (t) => {
+		let n = {
+			serverId: e.serverId,
+			includeEvents: [
+				"rotate",
+				"tablemap",
+				"writerows",
+				"updaterows",
+				"deleterows",
+				"xid",
+				"query"
+			]
+		};
+		return e.includeTables && e.includeTables.length > 0 && (n.includeSchema = { [i]: [...e.includeTables] }), t ? (n.filename = t.filename, n.position = t.position) : n.startAtEnd = !0, n;
+	}, x = (e) => {
+		let t = e;
+		return t?.errno === 1236 || String(t?.code ?? "").includes("ER_MASTER_FATAL_ERROR_READING_BINLOG");
+	}, S = (r) => new Promise((i, a) => {
+		let o = new n({
+			host: e.connection.host,
+			port: e.connection.port,
+			user: e.connection.username,
+			password: e.connection.password,
+			enableKeepAlive: !0,
+			keepAliveInitialDelay: e.keepAliveInitialDelayMs ?? 1e4
+		});
+		c = o;
+		let s = !1;
+		o.on("binlog", y), o.on("ready", () => {
+			v(), !s && (s = !0, d = 0, t.info("cdc: binlog reader attached", {
+				serverId: e.serverId,
+				from: r ?? "current-end"
+			}), i());
+		}), o.on("error", (e) => {
+			if (!s) {
+				s = !0, a(e instanceof Error ? e : Error(String(e)));
+				return;
+			}
+			C("binlog reader error", e);
+		}), o.start(b(r));
+	}), C = async (n, r) => {
+		if (!(u || p)) {
+			p = !0, t.warn(`cdc: reconnecting — ${n}`, {}, r instanceof Error ? r : void 0), e.onError?.(r);
+			try {
+				let n = r;
+				for (; !u;) {
+					try {
+						c?.stop();
+					} catch {}
+					if (d++, await P(Math.min(3e4, 500 * 2 ** Math.min(d, 6))), u) return;
+					let r = o, i = x(n), s = !i && j(n);
+					(i || s) && (t.warn(s ? "cdc: un-replayable backlog event (schema moved past it) — jumping to current end + self-heal" : "cdc: binlog gap (purged/failover) — jumping to current end + self-heal"), r = e.resolveStartPosition ? await e.resolveStartPosition().catch(() => null) : null, a = r?.filename ?? null, e.onResync?.());
+					try {
+						await S(r), d = 0, v();
+						return;
+					} catch (e) {
+						n = e;
+					}
+				}
+			} finally {
+				p = !1;
+			}
+		}
+	};
+	try {
+		await S(e.startPosition ?? null);
+	} catch (n) {
+		if (x(n) && e.startPosition) {
+			t.warn("cdc: persisted offset purged — starting at current end + self-heal");
+			try {
+				c?.stop();
+			} catch {}
+			let n = e.resolveStartPosition ? await e.resolveStartPosition().catch(() => null) : null;
+			a = n?.filename ?? null, e.onResync?.(), await P(500), await S(n);
+		} else throw n;
+	}
+	let w = async () => {
+		if (u || p || Date.now() - f < h) return;
+		let n = null;
+		if (e.resolveStartPosition && (n = await e.resolveStartPosition().catch(() => null)), u || p) return;
+		let r = A({
+			msSinceProgress: Date.now() - f,
+			stallThresholdMs: h,
+			primary: n,
+			reader: o
+		});
+		if (r !== "reconnect") {
+			r === "idle-caught-up" && v();
+			return;
+		}
+		t.warn("cdc: watchdog detected a stalled reader — forcing reconnect", {
+			reader: o,
+			primary: n,
+			stalledForMs: Date.now() - f
+		}), C("watchdog: stream stalled (no events while primary advanced)", /* @__PURE__ */ Error("cdc watchdog stall"));
+	};
+	return m = setInterval(() => {
+		w();
+	}, g), m.unref && m.unref(), {
+		stop: async () => {
+			u = !0, m &&= (clearInterval(m), null);
+			try {
+				c?.stop();
+			} catch (e) {
+				t.warn("cdc: error stopping binlog reader", {}, e);
+			}
+		},
+		currentPosition: () => o
+	};
+}, I = "_voltro_cdc_offsets", L = C(I, {
+	id: b({ prefix: "cdcoff" }),
+	replicaId: w(),
+	streamName: w(),
+	binlogFile: w(),
+	binlogPosition: w(),
+	updatedAt: T()
+}).index(["replicaId"]), R = /* @__PURE__ */ new Set(["1213", "1205"]), z = (e) => {
+	let t = e;
+	for (let e = 0; e < 5 && typeof t == "object" && t; e++) {
+		let e = t.errno;
+		if (typeof e == "number") return String(e);
+		let n = t.code;
+		if (typeof n == "string") return n;
+		t = t.cause;
+	}
+}, B = (e) => {
+	let t = z(e);
+	return t !== void 0 && R.has(t);
+}, V = (e) => B(e) ? "retry" : "noRetry", H = (e) => {
+	if (e == null) return "null";
+	let t = typeof e;
+	if (t === "bigint") return `${e}n`;
+	if (t !== "object") return JSON.stringify(e);
+	if (e instanceof Date) return `"${e.toISOString()}"`;
+	if (Array.isArray(e)) return `[${e.map(H).join(",")}]`;
+	let n = e;
+	return `{${Object.keys(n).sort().map((e) => `${JSON.stringify(e)}:${H(n[e])}`).join(",")}}`;
+}, U = (e) => {
+	let t = H(e), n = 2166136261;
+	for (let e = 0; e < t.length; e++) n ^= t.charCodeAt(e), n = Math.imul(n, 16777619);
+	return (n >>> 0).toString(36);
+}, W = (e, t) => {
+	let n = setTimeout(e, t);
+	typeof n.unref == "function" && n.unref();
+}, G = class {
+	variant;
+	ttlMs;
+	schedule;
+	seen = /* @__PURE__ */ new Map();
+	constructor(e, t = 6e4, n = W) {
+		this.variant = e, this.ttlMs = t, this.schedule = n;
+	}
+	key(e) {
+		let t = e.op === "delete" ? e.old : e.new;
+		if (t == null) return null;
+		let n = t.id;
+		if (n == null) return null;
+		let r = t;
+		try {
+			r = _([t], e.table, this.variant)[0] ?? t;
+		} catch {
+			r = t;
+		}
+		return `${e.table} ${e.op} ${String(n)} ${U(r)}`;
+	}
+	admit(e) {
+		let t = this.key(e);
+		if (t === null) return !0;
+		let n = this.seen.get(t) ?? 0;
+		return n > 0 ? (n <= 1 ? this.seen.delete(t) : this.seen.set(t, n - 1), !1) : (this.seen.set(t, 1), this.schedule(() => this.expireOne(t), this.ttlMs), !0);
+	}
+	expireOne(e) {
+		let t = this.seen.get(e);
+		t !== void 0 && (t <= 1 ? this.seen.delete(e) : this.seen.set(e, t - 1));
+	}
+	get pending() {
+		return this.seen.size;
+	}
+}, K = async (e) => {
+	let t = e.variant ?? "mysql", n = l({ scope: `voltro:${t}` }), a = e.changeStrategy ?? "inline", o = a;
+	a === "cdc" && !e.cdcConfig && (n.warn("changeStrategy='cdc' requires cdcConfig (serverId + connection); falling back to 'inline'."), o = "inline");
+	let s = e.tracerLayer ? r.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, c = i.make(s), d = new q(await c.runPromise(u), c, t, o);
+	return o === "cdc" && e.cdcConfig && await d.startCdcConsumer(e.cdcConfig), d;
+}, q = class e {
+	sql;
+	runtime;
+	variant;
+	changeStrategy;
+	namespace;
+	emitter;
+	inflightTxns = 0;
+	log;
+	cdcHandle = null;
+	cdcCheckpointTimer = null;
+	cdcPendingPosition = null;
+	cdcReplicaId = "";
+	cdcStreamName = "default";
+	cdcGate;
+	constructor(e, t, n, r = "inline", i = null, a, o) {
+		this.sql = e, this.runtime = t, this.variant = n, this.changeStrategy = r, this.namespace = i, this.log = l({ scope: `voltro:${n}` }), this.emitter = a ?? new c(), this.cdcGate = o ?? new G(n);
+	}
+	withNamespace(t) {
+		return t === this.namespace ? this : new e(this.sql, this.runtime, this.variant, this.changeStrategy, t, this.emitter, this.cdcGate);
+	}
+	nsT(e) {
+		return x(this.namespace, e);
+	}
+	get dialectId() {
+		return this.variant;
+	}
+	get __mysqlReplicationFriend() {
+		return {
+			runEffect: (e) => this.runtime.runPromise(e),
+			variant: this.variant
+		};
+	}
+	async executeQuery(e, t) {
+		let r = g(e, this.sql, this.namespace), i = t ? n.provideService(r, d, t) : r;
+		return _(await this.runtime.runPromise(i), e.table, this.variant);
+	}
+	get supportsInsertReturning() {
+		return this.variant === "mariadb";
+	}
+	get supportsDeleteReturning() {
+		return this.variant === "mariadb";
+	}
+	get supportsUpdateReturning() {
+		return !1;
+	}
+	async executeInsert(e, t, r, i) {
+		let a = this.sql;
+		if (this.supportsInsertReturning) {
+			let o = a`INSERT INTO ${a(this.nsT(e))} ${a.insert(v(t, e))} RETURNING *`, s = r ? n.provideService(o, d, r) : o, c = (await this.runtime.runPromise(s))[0];
+			if (!c) throw Error(`MysqlStore.insert: no row returned for table '${e}'`);
+			return this.routeEvent({
+				table: e,
+				op: "insert",
+				old: null,
+				new: c
+			}, i), c;
+		}
+		let o = v(t, e), s = t.id;
+		if (s === void 0) {
+			let t = await this.insertRecoverAutoId(e, o, r);
+			return this.routeEvent({
+				table: e,
+				op: "insert",
+				old: null,
+				new: t
+			}, i), t;
+		}
+		let c = a`INSERT INTO ${a(this.nsT(e))} ${a.insert(o)}`, l = r ? n.provideService(c, d, r) : c;
+		await this.runtime.runPromise(l);
+		let u = a`SELECT * FROM ${a(this.nsT(e))} WHERE ${a("id")} = ${s}`, f = r ? n.provideService(u, d, r) : u, p = (await this.runtime.runPromise(f))[0];
+		if (!p) throw Error(`MysqlStore.insert: row not found post-insert in '${e}'`);
+		return this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: p
+		}, i), p;
+	}
+	async insertRecoverAutoId(e, t, r) {
+		let i = this.sql;
+		return this.runPinned(r, (r) => n.gen(this, function* () {
+			let a = i`INSERT INTO ${i(this.nsT(e))} ${i.insert(t)}`;
+			yield* n.provideService(a, d, r);
+			let o = (yield* n.provideService(i`SELECT LAST_INSERT_ID() AS ${i("lastId")}`, d, r))[0]?.lastId;
+			return o === void 0 || Number(o) === 0 ? yield* n.fail(/* @__PURE__ */ Error(`MysqlStore.insert: LAST_INSERT_ID() returned no id for '${e}' — is the primary key AUTO_INCREMENT?`)) : (yield* n.provideService(i`SELECT * FROM ${i(this.nsT(e))} WHERE ${i("id")} = ${o}`, d, r))[0] || (yield* n.fail(/* @__PURE__ */ Error(`MysqlStore.insert: row not found post-insert in '${e}'`)));
+		}), "insert");
+	}
+	async runPinned(e, t, r) {
+		if (e) return this.runtime.runPromise(t(e));
+		this.inflightTxns++;
+		try {
+			let e = n.suspend(() => this.sql.withTransaction(n.flatMap(n.serviceOption(d), (e) => a.isNone(e) ? n.fail(/* @__PURE__ */ Error("MysqlStore.insert: TransactionConnection missing.")) : t(e.value)))), i = s.exponential("10 millis").pipe(s.compose(s.recurs(3)), s.whileInput(B)), o = e.pipe(n.retry(i), n.withSpan("store.insert", { attributes: {
+				"db.system": this.variant,
+				"db.operation": r
+			} }));
+			return await this.runtime.runPromise(o);
+		} finally {
+			this.inflightTxns--;
+		}
+	}
+	async executeInsertMany(e, t, r, i) {
+		if (t.length === 0) return [];
+		let a = this.sql, o = t.map((t) => v(t, e));
+		if (this.supportsInsertReturning) {
+			let t = a`INSERT INTO ${a(this.nsT(e))} ${a.insert(o)} RETURNING *`, s = r ? n.provideService(t, d, r) : t, c = await this.runtime.runPromise(s);
+			for (let t of c) this.routeEvent({
+				table: e,
+				op: "insert",
+				old: null,
+				new: t
+			}, i);
+			return c;
+		}
+		let s = t.map((e) => e.id);
+		if (s.every((e) => e === void 0)) {
+			let t = await this.insertManyRecoverAutoIds(e, o, r);
+			for (let n of t) this.routeEvent({
+				table: e,
+				op: "insert",
+				old: null,
+				new: n
+			}, i);
+			return t;
+		}
+		if (s.some((e) => e === void 0)) throw Error("MysqlStore.insertMany: rows mix client-supplied and missing 'id's — supply an id for every row or none (AUTO_INCREMENT recovery).");
+		let c = a`INSERT INTO ${a(this.nsT(e))} ${a.insert(o)}`, l = r ? n.provideService(c, d, r) : c;
+		await this.runtime.runPromise(l);
+		let u = a`SELECT * FROM ${a(this.nsT(e))} WHERE ${a("id")} IN ${a.in(s)}`, f = r ? n.provideService(u, d, r) : u, p = await this.runtime.runPromise(f), m = new Map(p.map((e) => [e.id, e])), h = s.map((e) => m.get(e)).filter((e) => e !== void 0);
+		for (let t of h) this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: t
+		}, i);
+		return h;
+	}
+	async insertManyRecoverAutoIds(e, t, r) {
+		let i = this.sql, a = t.length;
+		return this.runPinned(r, (r) => n.gen(this, function* () {
+			let o = i`INSERT INTO ${i(this.nsT(e))} ${i.insert(t)}`;
+			yield* n.provideService(o, d, r);
+			let s = (yield* n.provideService(i`SELECT LAST_INSERT_ID() AS ${i("firstId")}`, d, r))[0]?.firstId;
+			if (s === void 0 || Number(s) === 0) return yield* n.fail(/* @__PURE__ */ Error(`MysqlStore.insertMany: LAST_INSERT_ID() returned no id for '${e}' — is the primary key AUTO_INCREMENT?`));
+			let c = Number(s);
+			return yield* n.provideService(i`SELECT * FROM ${i(this.nsT(e))} WHERE ${i("id")} BETWEEN ${c} AND ${c + a - 1} ORDER BY ${i("id")} ASC`, d, r);
+		}), "insert");
+	}
+	async executePatchJson(e, t, r, i, a, o) {
+		let s = this.sql, c = r.split("."), l = c[0], u = c.slice(1), f = JSON.stringify(i ?? null), p = u.length === 0 ? "$" : `$.${u.join(".")}`, m = s`UPDATE ${s(this.nsT(e))} SET ${s(l)} = JSON_SET(COALESCE(${s(l)}, '{}'), ${p}, CAST(${f} AS JSON)) WHERE ${s("id")} = ${t}`, h = a ? n.provideService(m, d, a) : m, g = await this.runtime.runPromise(h);
+		if (g && typeof g.affectedRows == "number" && g.affectedRows === 0) return null;
+		let _ = s`SELECT * FROM ${s(this.nsT(e))} WHERE ${s("id")} = ${t}`, v = a ? n.provideService(_, d, a) : _, y = (await this.runtime.runPromise(v))[0];
+		return y ? (this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: y
+		}, o), y) : null;
+	}
+	async executeUpdate(e, t, r, i, a) {
+		let o = this.sql;
+		if (this.supportsUpdateReturning) {
+			let s = o`UPDATE ${o(this.nsT(e))} SET ${o.update(v(r, e))} WHERE ${o("id")} = ${t} RETURNING *`, c = i ? n.provideService(s, d, i) : s, l = (await this.runtime.runPromise(c))[0];
+			return l ? (this.routeEvent({
+				table: e,
+				op: "update",
+				old: null,
+				new: l
+			}, a), l) : null;
+		}
+		let s = o`UPDATE ${o(this.nsT(e))} SET ${o.update(v(r, e))} WHERE ${o("id")} = ${t}`, c = i ? n.provideService(s, d, i) : s, l = await this.runtime.runPromise(c);
+		if (l && typeof l.affectedRows == "number" && l.affectedRows === 0) return null;
+		let u = o`SELECT * FROM ${o(this.nsT(e))} WHERE ${o("id")} = ${t}`, f = i ? n.provideService(u, d, i) : u, p = (await this.runtime.runPromise(f))[0];
+		return p ? (this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: p
+		}, a), p) : null;
+	}
+	async executeDelete(e, t, r, i) {
+		let a = this.sql;
+		if (this.supportsDeleteReturning) {
+			let o = a`DELETE FROM ${a(this.nsT(e))} WHERE ${a("id")} = ${t} RETURNING *`, s = r ? n.provideService(o, d, r) : o, c = (await this.runtime.runPromise(s))[0];
+			return c ? (this.routeEvent({
+				table: e,
+				op: "delete",
+				old: c,
+				new: null
+			}, i), !0) : !1;
+		}
+		let o = a`SELECT * FROM ${a(this.nsT(e))} WHERE ${a("id")} = ${t}`, s = r ? n.provideService(o, d, r) : o, c = (await this.runtime.runPromise(s))[0];
+		if (!c) return !1;
+		let l = a`DELETE FROM ${a(this.nsT(e))} WHERE ${a("id")} = ${t}`, u = r ? n.provideService(l, d, r) : l;
+		return await this.runtime.runPromise(u), this.routeEvent({
+			table: e,
+			op: "delete",
+			old: c,
+			new: null
+		}, i), !0;
+	}
+	routeEvent(e, t) {
+		if (t !== null) {
+			t.push(e);
+			return;
+		}
+		this.emitChange(e);
+	}
+	async executeUpsert(e, t, n, r, i) {
+		if (this.variant === "mariadb" && typeof n.update != "function") return this.executeMariadbUpsert(e, t, {
+			conflictColumns: n.conflictColumns,
+			...n.update === void 0 ? {} : { update: n.update }
+		}, r, i);
+		let a = await this.findByConflict(e, t, n.conflictColumns, r);
+		if (a) {
+			let o;
+			if (typeof n.update == "function") o = n.update(a);
+			else if (Array.isArray(n.update)) {
+				let e = {};
+				for (let r of n.update) r in t && (e[r] = t[r]);
+				o = e;
+			} else {
+				let e = {};
+				for (let [r, i] of Object.entries(t)) r !== "id" && (n.conflictColumns.includes(r) || (e[r] = i));
+				o = e;
+			}
+			return await this.executeUpdate(e, a.id, o, r, i) ?? a;
+		}
+		return this.executeInsert(e, t, r, i);
+	}
+	async executeMariadbUpsert(e, t, r, i, a) {
+		let o = this.sql, s = v(t, e), c = Object.keys(s).filter((e) => s[e] !== void 0), l = r.update === void 0 ? c.filter((e) => e !== "id" && !r.conflictColumns.includes(e)) : r.update, u = l.length > 0 ? o.csv(l.map((e) => o`${o(e)} = VALUES(${o(e)})`)) : o`${o(r.conflictColumns[0])} = VALUES(${o(r.conflictColumns[0])})`, f = o`INSERT INTO ${o(this.nsT(e))} ${o.insert(s)} ON DUPLICATE KEY UPDATE ${u} RETURNING *`, p = i ? n.provideService(f, d, i) : f, m = (await this.runtime.runPromise(p))[0];
+		if (!m) throw Error(`MysqlStore.upsert: no row returned for table '${e}'`);
+		let h = t.id !== void 0 && t.id === m.id ? "insert" : "update";
+		return this.routeEvent({
+			table: e,
+			op: h,
+			old: null,
+			new: m
+		}, a), m;
+	}
+	async executeInsertIgnore(e, t, r, i, a) {
+		if (this.variant === "mariadb") {
+			let o = this.sql, s = o`INSERT IGNORE INTO ${o(this.nsT(e))} ${o.insert(v(t, e))} RETURNING *`, c = i ? n.provideService(s, d, i) : s, l = (await this.runtime.runPromise(c))[0];
+			if (l) return this.routeEvent({
+				table: e,
+				op: "insert",
+				old: null,
+				new: l
+			}, a), l;
+			let u = await this.findByConflict(e, t, r.conflictColumns, i);
+			if (!u) throw Error("MysqlStore.insertIgnore: row conflicted but lookup found nothing");
+			return u;
+		}
+		return await this.findByConflict(e, t, r.conflictColumns, i) || this.executeInsert(e, t, i, a);
+	}
+	async findByConflict(e, t, r, i) {
+		if (r.length === 0) return;
+		let a = this.sql, o = r.map((e) => a`${a(e)} = ${t[e]}`), s = a`SELECT * FROM ${a(this.nsT(e))} WHERE ${a.and(o)} LIMIT 1`, c = i ? n.provideService(s, d, i) : s;
+		return (await this.runtime.runPromise(c))[0];
+	}
+	query(e) {
+		return this.runWithEager(e, null);
+	}
+	raw(e, t) {
+		let n = h(e, this.sql);
+		return this.runtime.runPromise(n);
+	}
+	async runWithEager(e, t) {
+		if (!y(e)) return this.executeQuery(e, t);
+		let r = this.variant === "mariadb" ? "mariadb" : "mysql", i = this.namespace === null ? p(e, this.sql, r) : null;
+		if (i !== null) try {
+			let e = t ? n.provideService(i.fragment, d, t) : i.fragment, r = await this.runtime.runPromise(e);
+			return i.decode(r);
+		} catch (e) {
+			this.log.warn(`${this.variant} JSON-agg eager-load failed; falling back to walker`, { err: e });
+		}
+		return f(await this.executeQuery(e, t), e.eager, e.sourceTable ?? S(e.table), (e) => this.executeQuery(e, t));
+	}
+	getInternalRunWithEager() {
+		return this.runWithEager.bind(this);
+	}
+	insert(e, t) {
+		return this.executeInsert(e, t, null, null);
+	}
+	insertMany(e, t) {
+		return this.executeInsertMany(e, t, null, null);
+	}
+	patchJson(e, t, n, r) {
+		return this.executePatchJson(e, t, n, r, null, null);
+	}
+	upsert(e, t, n) {
+		return this.executeUpsert(e, t, n, null, null);
+	}
+	insertIgnore(e, t, n) {
+		return this.executeInsertIgnore(e, t, n, null, null);
+	}
+	update(e, t, n) {
+		return this.executeUpdate(e, t, n, null, null);
+	}
+	delete(e, t) {
+		return this.executeDelete(e, t, null, null);
+	}
+	async updateMany(e, t, r) {
+		if (this.supportsUpdateReturning) {
+			let n = this.sql, i = m(r.where, n, this.namespace), a = n`UPDATE ${n(this.nsT(e))} SET ${n.update(v(t, e))} WHERE ${i} RETURNING *`, o = await this.runtime.runPromise(a);
+			for (let t of o) this.routeEvent({
+				table: e,
+				op: "update",
+				old: null,
+				new: t
+			}, null);
+			return o.length;
+		}
+		let i = this.sql, o = m(r.where, i, this.namespace);
+		this.inflightTxns++;
+		try {
+			let r = n.suspend(() => this.sql.withTransaction(n.flatMap(n.serviceOption(d), (r) => {
+				if (a.isNone(r)) return n.fail(/* @__PURE__ */ Error("MysqlStore.updateMany: TransactionConnection missing."));
+				let s = r.value, c = i`SELECT id FROM ${i(this.nsT(e))} WHERE ${o} FOR UPDATE`, l = i`UPDATE ${i(this.nsT(e))} SET ${i.update(v(t, e))} WHERE ${o}`;
+				return n.flatMap(n.provideService(c, d, s), (t) => {
+					if (t.length === 0) return n.succeed([]);
+					let r = t.map((e) => e.id), a = i`SELECT * FROM ${i(this.nsT(e))} WHERE ${i("id")} IN ${i.in(r)}`;
+					return n.flatMap(n.provideService(l, d, s), () => n.provideService(a, d, s));
+				});
+			}))), c = s.exponential("10 millis").pipe(s.compose(s.recurs(3)), s.whileInput(B)), l = r.pipe(n.retry(c), n.withSpan("store.updateMany", { attributes: {
+				"db.system": this.variant,
+				"db.operation": "update"
+			} })), u = await this.runtime.runPromise(l);
+			if (u.length === 0) return 0;
+			let f = _(u, e, this.variant);
+			for (let t of f) this.routeEvent({
+				table: e,
+				op: "update",
+				old: null,
+				new: t
+			}, null);
+			return f.length;
+		} finally {
+			this.inflightTxns--;
+		}
+	}
+	async deleteMany(e, t) {
+		let r = this.sql, i = m(t.where, r, this.namespace);
+		if (this.supportsDeleteReturning) {
+			let t = r`DELETE FROM ${r(this.nsT(e))} WHERE ${i} RETURNING *`, n = _(await this.runtime.runPromise(t), e, this.variant);
+			for (let t of n) this.routeEvent({
+				table: e,
+				op: "delete",
+				old: t,
+				new: null
+			}, null);
+			return n.length;
+		}
+		this.inflightTxns++;
+		try {
+			let t = n.suspend(() => this.sql.withTransaction(n.flatMap(n.serviceOption(d), (t) => {
+				if (a.isNone(t)) return n.fail(/* @__PURE__ */ Error("MysqlStore.deleteMany: TransactionConnection missing."));
+				let o = t.value, s = r`SELECT * FROM ${r(this.nsT(e))} WHERE ${i} FOR UPDATE`, c = r`DELETE FROM ${r(this.nsT(e))} WHERE ${i}`;
+				return n.flatMap(n.provideService(s, d, o), (e) => e.length === 0 ? n.succeed(e) : n.as(n.provideService(c, d, o), e));
+			}))), o = s.exponential("10 millis").pipe(s.compose(s.recurs(3)), s.whileInput(B)), c = t.pipe(n.retry(o), n.withSpan("store.deleteMany", { attributes: {
+				"db.system": this.variant,
+				"db.operation": "delete"
+			} })), l = await this.runtime.runPromise(c);
+			if (l.length === 0) return 0;
+			let u = _(l, e, this.variant);
+			for (let t of u) this.routeEvent({
+				table: e,
+				op: "delete",
+				old: t,
+				new: null
+			}, null);
+			return u.length;
+		} finally {
+			this.inflightTxns--;
+		}
+	}
+	emitChange(e) {
+		this.changeStrategy === "cdc" && !this.cdcGate.admit(e) || this.emitter.emit("change", e);
+	}
+	async startCdcConsumer(e) {
+		if (this.cdcHandle) return;
+		await this.assertBinlogConfig(), this.cdcReplicaId = e.replicaId;
+		let t = await this.readCdcOffset(e.replicaId) ?? await this.resolveBinlogEnd();
+		this.cdcHandle = await F({
+			connection: e.connection,
+			serverId: e.serverId,
+			variant: this.variant,
+			...e.includeTables ? { includeTables: e.includeTables } : {},
+			...e.watchdogIntervalMs === void 0 ? {} : { watchdogIntervalMs: e.watchdogIntervalMs },
+			...e.stallThresholdMs === void 0 ? {} : { stallThresholdMs: e.stallThresholdMs },
+			...e.keepAliveInitialDelayMs === void 0 ? {} : { keepAliveInitialDelayMs: e.keepAliveInitialDelayMs },
+			startPosition: t,
+			onChange: (e) => this.injectExternalChange(e),
+			onPosition: (e) => {
+				this.cdcPendingPosition = e;
+			},
+			onError: (e) => this.log.warn("cdc: consumer error", {}, e),
+			resolveStartPosition: () => this.resolveBinlogEnd(),
+			onResync: () => {
+				this.log.warn("cdc: resynced to current binlog end after a gap — subscriptions self-heal on the next change (purge/failover recovery)");
+			}
+		}), this.cdcCheckpointTimer = setInterval(() => {
+			this.flushCdcOffset();
+		}, 1e3), this.cdcCheckpointTimer.unref && this.cdcCheckpointTimer.unref();
+	}
+	async assertBinlogConfig() {
+		let e = this.sql, t = (await this.runtime.runPromise(e`
+        SELECT @@binlog_format AS format, @@binlog_row_image AS rowImage, @@log_bin AS logBin`))[0];
+		if (!t || Number(t.logBin) !== 1) throw Error(`${this.variant} binlog CDC requires log_bin=ON. Start ${this.variant} with --log-bin (and --binlog-format=ROW --binlog-row-image=FULL), or set CDC=0 to use inline emit. (MySQL 8.0+ enables log_bin by default; MariaDB does not.)`);
+		if (t.format !== "ROW") throw Error(`${this.variant} binlog CDC requires binlog_format=ROW (got '${t.format}'). Set --binlog-format=ROW, or CDC=0 for inline emit.`);
+		t.rowImage !== "FULL" && this.log.warn(`cdc: binlog_row_image='${t.rowImage}' (expected FULL) — UPDATE/DELETE before-images may be incomplete. Set --binlog-row-image=FULL.`);
+	}
+	async resolveBinlogEnd() {
+		let e = this.sql, t = this.variant === "mysql" ? e`SHOW BINARY LOG STATUS`.unprepared : e`SHOW MASTER STATUS`.unprepared, n = this.variant === "mysql" ? e`SHOW MASTER STATUS`.unprepared : e`SHOW BINARY LOG STATUS`.unprepared, r = async (e) => {
+			let t = (await this.runtime.runPromise(e))[0];
+			return t?.File ? {
+				filename: t.File,
+				position: Number(t.Position)
+			} : null;
+		};
+		try {
+			return await r(t);
+		} catch {
+			try {
+				return await r(n);
+			} catch {
+				return this.log.debug("cdc: binlog-status query unavailable (needs REPLICATION CLIENT); using startAtEnd"), null;
+			}
+		}
+	}
+	async readCdcOffset(e) {
+		try {
+			let t = this.sql, n = (await this.runtime.runPromise(t`
+          SELECT ${t("binlogFile")}, ${t("binlogPosition")}
+          FROM ${t(I)}
+          WHERE ${t("id")} = ${e} LIMIT 1`))[0];
+			if (!n) return null;
+			let r = Number(n.binlogPosition);
+			return !n.binlogFile || !Number.isFinite(r) ? null : (this.log.info("cdc: resuming from persisted offset", {
+				replicaId: e,
+				file: n.binlogFile,
+				position: r
+			}), {
+				filename: n.binlogFile,
+				position: r
+			});
+		} catch (t) {
+			return this.log.warn("cdc: no readable offset; starting at binlog end", { replicaId: e }, t), null;
+		}
+	}
+	async flushCdcOffset() {
+		let e = this.cdcPendingPosition;
+		if (e) {
+			this.cdcPendingPosition = null;
+			try {
+				let t = this.sql, n = this.cdcReplicaId;
+				await this.runtime.runPromise(t`INSERT INTO ${t(I)} ${t.insert({
+					id: n,
+					replicaId: n,
+					streamName: this.cdcStreamName,
+					binlogFile: e.filename,
+					binlogPosition: String(e.position),
+					updatedAt: /* @__PURE__ */ new Date()
+				})}
+        ON DUPLICATE KEY UPDATE
+          ${t("binlogFile")} = ${e.filename},
+          ${t("binlogPosition")} = ${String(e.position)},
+          ${t("updatedAt")} = ${/* @__PURE__ */ new Date()}`);
+			} catch (t) {
+				this.cdcPendingPosition = e, this.log.warn("cdc: checkpoint write failed", {}, t);
+			}
+		}
+	}
+	getInternalExecuteQuery() {
+		return this.executeQuery.bind(this);
+	}
+	getInternalExecuteInsert() {
+		return this.executeInsert.bind(this);
+	}
+	getInternalExecuteInsertMany() {
+		return this.executeInsertMany.bind(this);
+	}
+	getInternalExecutePatchJson() {
+		return this.executePatchJson.bind(this);
+	}
+	getInternalExecuteUpdate() {
+		return this.executeUpdate.bind(this);
+	}
+	getInternalExecuteDelete() {
+		return this.executeDelete.bind(this);
+	}
+	getInternalExecuteUpsert() {
+		return this.executeUpsert.bind(this);
+	}
+	getInternalExecuteInsertIgnore() {
+		return this.executeInsertIgnore.bind(this);
+	}
+	async transactional(e) {
+		this.inflightTxns++;
+		let t = 0, r = n.suspend(() => {
+			let r = ++t;
+			return this.sql.withTransaction(n.flatMap(n.serviceOption(d), (t) => {
+				if (a.isNone(t)) return n.fail(/* @__PURE__ */ Error("MysqlStore.transactional: TransactionConnection missing."));
+				let i = new J(this, t.value);
+				return n.tryPromise({
+					try: () => e(i).then((e) => ({
+						result: e,
+						view: i,
+						attempt: r
+					})),
+					catch: (e) => e
+				});
+			}));
+		}), i = s.exponential("10 millis").pipe(s.compose(s.recurs(3)), s.whileInput(B)), o = r.pipe(n.retry(i), n.withSpan("store.transactional", { attributes: {
+			"db.system": this.variant,
+			"db.operation": "transaction"
+		} }));
+		try {
+			let e = await this.runtime.runPromise(o);
+			return e.view.commitEvents(), e.result;
+		} finally {
+			this.inflightTxns--;
+		}
+	}
+	onChange(e) {
+		return this.emitter.on("change", e), () => {
+			this.emitter.off("change", e);
+		};
+	}
+	get changeScope() {
+		return this.changeStrategy === "cdc" ? "fleet" : "local";
+	}
+	injectExternalChange(e) {
+		this.changeStrategy === "cdc" && !this.cdcGate.admit(e) || this.emitter.emit("change", {
+			...e,
+			origin: "injected"
+		});
+	}
+	run(e) {
+		return this.runtime.runPromise(e);
+	}
+	async close(e = 5e3) {
+		if (this.cdcCheckpointTimer &&= (clearInterval(this.cdcCheckpointTimer), null), this.cdcHandle) {
+			let e = this.cdcHandle.currentPosition();
+			e && (this.cdcPendingPosition = e), await this.flushCdcOffset(), await this.cdcHandle.stop(), this.cdcHandle = null;
+		}
+		if (this.inflightTxns > 0) {
+			let t = Date.now() + e;
+			for (; this.inflightTxns > 0 && Date.now() < t;) await new Promise((e) => setTimeout(e, 25));
+			this.inflightTxns > 0 && this.log.warn("close: grace period expired with in-flight transactions", {
+				gracePeriodMs: e,
+				inflight: this.inflightTxns
+			});
+		}
+		await this.runtime.dispose();
+	}
+	async ping() {
+		await this.runtime.runPromise(this.sql`SELECT 1`);
+	}
+}, J = class {
+	parent;
+	txn;
+	events = [];
+	committed = !1;
+	constructor(e, t) {
+		this.parent = e, this.txn = t;
+	}
+	query(e) {
+		return this.parent.getInternalRunWithEager()(e, this.txn);
+	}
+	insert(e, t) {
+		return this.parent.getInternalExecuteInsert()(e, t, this.txn, this.events);
+	}
+	insertMany(e, t) {
+		return this.parent.getInternalExecuteInsertMany()(e, t, this.txn, this.events);
+	}
+	patchJson(e, t, n, r) {
+		return this.parent.getInternalExecutePatchJson()(e, t, n, r, this.txn, this.events);
+	}
+	update(e, t, n) {
+		return this.parent.getInternalExecuteUpdate()(e, t, n, this.txn, this.events);
+	}
+	delete(e, t) {
+		return this.parent.getInternalExecuteDelete()(e, t, this.txn, this.events);
+	}
+	async updateMany(e, t, n) {
+		let r = await this.query({
+			table: e,
+			predicate: n.where,
+			order: [],
+			take: void 0,
+			skip: void 0,
+			projection: ["id"]
+		}), i = 0;
+		for (let n of r) await this.update(e, n.id, t) && i++;
+		return i;
+	}
+	async deleteMany(e, t) {
+		let n = await this.query({
+			table: e,
+			predicate: t.where,
+			order: [],
+			take: void 0,
+			skip: void 0,
+			projection: ["id"]
+		}), r = 0;
+		for (let t of n) await this.delete(e, t.id) && r++;
+		return r;
+	}
+	upsert(e, t, n) {
+		return this.parent.getInternalExecuteUpsert()(e, t, n, this.txn, this.events);
+	}
+	insertIgnore(e, t, n) {
+		return this.parent.getInternalExecuteInsertIgnore()(e, t, n, this.txn, this.events);
+	}
+	transactional(e) {
+		return Promise.reject(/* @__PURE__ */ Error("MysqlStore.transactional: nested transactions are not supported."));
+	}
+	onChange(e) {
+		throw Error("MysqlTransactionalView.onChange: not supported inside a transaction.");
+	}
+	injectExternalChange(e) {
+		throw Error("MysqlTransactionalView.injectExternalChange: not supported inside a transaction.");
+	}
+	commitEvents() {
+		if (!this.committed) {
+			this.committed = !0;
+			for (let e of this.events) this.parent.emitChange(e);
+			this.events.length = 0;
+		}
+	}
+}, Y = (e) => e.__mysqlReplicationFriend ?? null, X = () => ({
+	async capturePrimaryPosition(e) {
+		let t = Y(e);
+		if (t === null) throw Error("mysqlReplicationAdapter: primary is not a MysqlStore (missing __mysqlReplicationFriend).");
+		return t.runEffect(n.gen(function* () {
+			let e = yield* u, r = (t.variant === "mariadb" ? yield* e`SELECT @@global.gtid_current_pos AS gtid` : yield* e`SELECT @@global.gtid_executed AS gtid`)[0]?.gtid;
+			return typeof r == "string" ? r : yield* n.die("mysql/mariadb did not return a GTID set");
+		}));
+	},
+	async probeReplicaPosition(e) {
+		let t = Y(e);
+		if (t === null) throw Error("mysqlReplicationAdapter: replica is not a MysqlStore.");
+		return t.runEffect(n.gen(function* () {
+			let e = yield* u, r = (t.variant === "mariadb" ? yield* e`SELECT @@global.gtid_current_pos AS gtid` : yield* e`SELECT @@global.gtid_executed AS gtid`)[0]?.gtid;
+			return typeof r == "string" ? r : yield* n.die("mysql/mariadb replica did not return a GTID set");
+		}));
+	},
+	compare(e, t) {
+		return "behind";
+	}
+}), Z = {
+	id: "mysql",
+	makeSqlLayer: (e) => O(e),
+	makeStore: (e) => K({
+		...e,
+		variant: "mysql"
+	}),
+	compileContains: (e, t, n) => n`${e} LIKE ${`%${t.replace(/[\\%_]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
+	retryFilter: V
+}, Q = {
+	id: "mariadb",
+	makeSqlLayer: (e) => O(e),
+	makeStore: (e) => K({
+		...e,
+		variant: "mariadb"
+	}),
+	compileContains: (e, t, n) => n`${e} LIKE ${`%${t.replace(/[\\%_]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
+	retryFilter: V
+};
+//#endregion
+export { I as CDC_OFFSETS_TABLE, e as MysqlClient, L as _voltroCdcOffsetsTable, D as connectionFromConfig, E as makeMysqlSqlLayer, O as makeMysqlSqlLayerFromConfig, K as makeMysqlStore, Q as mariadbDialect, Z as mysqlDialect, X as mysqlReplicationAdapter, V as mysqlRetryFilter, F as startBinlogCdc };