@voltro/sql-mssql 0.1.0

package/dist/index.js

@@ -0,0 +1,618 @@
+import { MssqlClient as e } from "@effect/sql-mssql";
+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 _, hasEagerLoads as v, id as y, qualifyTable as b, requireTable as x, table as S, text as C, timestamp as w } from "@voltro/database";
+//#region src/sqlLayer.ts
+var T = {
+	...e.defaultParameterTypes,
+	null: e.defaultParameterTypes.object
+}, E = (n) => e.layerConfig({
+	server: t.succeed(n.server),
+	parameterTypes: t.succeed(T),
+	...n.port === void 0 ? {} : { port: t.succeed(n.port) },
+	...n.database === void 0 ? {} : { database: t.succeed(n.database) },
+	...n.username === void 0 ? {} : { username: t.succeed(n.username) },
+	...n.password === void 0 ? {} : { password: t.succeed(o.make(n.password)) },
+	...n.encrypt === void 0 ? {} : { encrypt: t.succeed(n.encrypt) },
+	...n.trustServer === void 0 ? {} : { trustServer: t.succeed(n.trustServer) },
+	...n.maxConnections === void 0 ? {} : { maxConnections: t.succeed(n.maxConnections) }
+}), D = (e) => {
+	if (e.url) {
+		let t = new URL(e.url);
+		return {
+			server: t.hostname || "localhost",
+			port: t.port ? Number(t.port) : 1433,
+			username: decodeURIComponent(t.username || "sa"),
+			password: decodeURIComponent(t.password || ""),
+			database: t.pathname.replace(/^\//, "") || "master",
+			trustServer: !0,
+			...e.maxConnections === void 0 ? {} : { maxConnections: e.maxConnections }
+		};
+	}
+	return {
+		server: e.host ?? "localhost",
+		port: e.port ?? 1433,
+		username: e.username ?? "sa",
+		password: e.password ?? "",
+		database: e.database ?? "master",
+		trustServer: !0,
+		...e.maxConnections === void 0 ? {} : { maxConnections: e.maxConnections }
+	};
+}, O = (e) => E(D(e)), k = /* @__PURE__ */ new Set(["1205"]), A = (e) => {
+	let t = e;
+	for (let e = 0; e < 5 && typeof t == "object" && t; e++) {
+		let e = t.number;
+		if (typeof e == "number") return String(e);
+		let n = t.code;
+		if (typeof n == "string") return n;
+		t = t.cause;
+	}
+}, j = (e) => {
+	let t = A(e);
+	return t !== void 0 && k.has(t);
+}, M = /* @__PURE__ */ new Set(["2601", "2627"]), N = (e) => {
+	let t = A(e);
+	return t !== void 0 && M.has(t);
+}, P = (e) => j(e) ? "retry" : "noRetry", F = {
+	I: "insert",
+	U: "update",
+	D: "delete"
+}, I = (e, t) => e(n.gen(function* () {
+	let e = yield* u;
+	if (((yield* e`
+        SELECT COUNT(*) AS ${e("on")}
+        FROM sys.change_tracking_databases
+        WHERE database_id = DB_ID()`)[0]?.on ?? 0) === 0) return yield* n.fail(/* @__PURE__ */ Error("mssql Change Tracking CDC requires CT enabled on the database. Run `ALTER DATABASE <db> SET CHANGE_TRACKING = ON (CHANGE_RETENTION = 2 DAYS, AUTO_CLEANUP = ON)`, or set CDC=0 for inline emit."));
+	for (let n of t) yield* e.unsafe(`IF NOT EXISTS (
+             SELECT 1 FROM sys.change_tracking_tables
+             WHERE object_id = OBJECT_ID(${L(n)})
+           )
+           ALTER TABLE ${R(n)} ENABLE CHANGE_TRACKING WITH (TRACK_COLUMNS_UPDATED = OFF)`);
+})).then(() => void 0), L = (e) => `'${e.replace(/'/g, "''")}'`, R = (e) => `[${e.replace(/\]/g, "]]")}]`, z = async (e) => {
+	let t = l({ scope: "voltro:mssql:cdc" }), r = e.pollIntervalMs ?? 500;
+	await I(e.run, e.tables);
+	let i = async () => (await e.run(n.gen(function* () {
+		return yield* (yield* u)`SELECT CONVERT(VARCHAR(40), CHANGE_TRACKING_CURRENT_VERSION()) AS v`;
+	})))[0]?.v ?? "0", a = e.startVersion ?? await i(), o = !1, s = null, c = !1, d = (e, t) => BigInt(e) > BigInt(t), f = async (r, o) => {
+		let s = await e.run(n.gen(function* () {
+			let e = yield* u, t = e.unsafe(R(r)), n = (yield* e`
+          SELECT CONVERT(VARCHAR(40), CHANGE_TRACKING_MIN_VALID_VERSION(OBJECT_ID(${e.unsafe(L(r))}))) AS floor`)[0]?.floor;
+			return n != null && BigInt(o) < BigInt(n) ? {
+				resync: !0,
+				rows: []
+			} : {
+				resync: !1,
+				rows: yield* e`
+          SELECT ct.SYS_CHANGE_OPERATION AS __ct_op, ct.id AS __ct_id, t.*
+            FROM CHANGETABLE(CHANGES ${t}, ${BigInt(o)}) AS ct
+            LEFT JOIN ${t} AS t ON t.id = ct.id
+            ORDER BY ct.SYS_CHANGE_VERSION`.unprepared
+			};
+		}));
+		if (s.resync) {
+			t.warn("cdc: CT retention floor passed our cursor — resyncing to current version", { table: r }), a = await i(), e.onResync?.(), e.onVersion?.(a);
+			return;
+		}
+		for (let t of s.rows) {
+			let n = F[t.__ct_op];
+			if (!n) continue;
+			let { __ct_op: i, __ct_id: a, ...o } = t;
+			if (n === "delete") e.onChange({
+				table: r,
+				op: "delete",
+				old: { id: a },
+				new: null
+			});
+			else {
+				let t = _([o], r, "mssql")[0];
+				e.onChange({
+					table: r,
+					op: n,
+					old: null,
+					new: t
+				});
+			}
+		}
+	}, p = async () => {
+		if (!(o || c)) {
+			c = !0;
+			try {
+				let t = await i();
+				if (d(t, a)) {
+					for (let t of e.tables) {
+						if (o) break;
+						await f(t, a);
+					}
+					a = d(t, a) ? t : a, e.onVersion?.(a);
+				}
+			} catch (n) {
+				t.warn("cdc: poll cycle failed — retrying next tick", {}, n), e.onError?.(n);
+			} finally {
+				c = !1, o || (s = setTimeout(() => {
+					p();
+				}, r));
+			}
+		}
+	};
+	return s = setTimeout(() => {
+		p();
+	}, r), s.unref && s.unref(), t.info("cdc: Change Tracking reader attached", {
+		tables: e.tables.length,
+		from: e.startVersion ?? a
+	}), {
+		stop: async () => {
+			o = !0, s &&= (clearTimeout(s), null);
+		},
+		currentVersion: () => a
+	};
+}, B = "_voltro_cdc_offsets", V = S(B, {
+	id: y({ prefix: "cdcoff" }),
+	replicaId: C(),
+	streamName: C(),
+	ctVersion: C(),
+	updatedAt: w()
+}).index(["replicaId"]), H = l({ scope: "voltro:mssql" }), U = async (e) => {
+	let t = e.changeStrategy ?? "inline", n = t;
+	t === "cdc" && !e.cdcConfig && (H.warn("changeStrategy='cdc' requires cdcConfig (replicaId + includeTables); falling back to 'inline'."), n = "inline");
+	let a = e.tracerLayer ? r.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, o = i.make(a), s = new W(await o.runPromise(u), o, n);
+	return n === "cdc" && e.cdcConfig && await s.startCdcConsumer(e.cdcConfig), s;
+}, W = class e {
+	sql;
+	runtime;
+	changeStrategy;
+	namespace;
+	emitter;
+	inflightTxns = 0;
+	cdcHandle = null;
+	cdcCheckpointTimer = null;
+	cdcPendingVersion = null;
+	cdcReplicaId = "";
+	cdcStreamName = "default";
+	constructor(e, t, n = "inline", r = null, i) {
+		this.sql = e, this.runtime = t, this.changeStrategy = n, this.namespace = r, this.emitter = i ?? new c();
+	}
+	get inlineEmit() {
+		return this.changeStrategy === "inline";
+	}
+	withNamespace(t) {
+		return t === this.namespace ? this : new e(this.sql, this.runtime, this.changeStrategy, t, this.emitter);
+	}
+	nsT(e) {
+		return b(this.namespace, e);
+	}
+	__mssqlReplicationFriend = { runEffect: (e) => this.runtime.runPromise(e) };
+	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, "mssql");
+	}
+	async executeInsert(e, t, r, i) {
+		let a = this.sql, o = a`INSERT INTO ${a(this.nsT(e))} ${a.insert(t).returning("*")}`, s = r ? n.provideService(o, d, r) : o, c = (await this.runtime.runPromise(s))[0];
+		if (!c) throw Error(`MssqlStore.insert: row not returned post-insert in '${e}'`);
+		return this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: c
+		}, i), c;
+	}
+	async executeUpdate(e, t, r, i, a) {
+		let o = this.sql, s = o`UPDATE ${o(this.nsT(e))} SET ${o.update(r).returning("*")} WHERE ${o("id")} = ${t}`, 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;
+	}
+	async executeInsertMany(e, t, r, i) {
+		if (t.length === 0) return [];
+		let a = this.sql, o = a`INSERT INTO ${a(this.nsT(e))} ${a.insert(t).returning("*")}`, s = r ? n.provideService(o, d, r) : o, c = await this.runtime.runPromise(s), l = t.map((e) => e.id), u = new Map(c.map((e) => [e.id, e])), f = l.map((e) => u.get(e)).filter((e) => e !== void 0), p = f.length === c.length ? f : [...c];
+		for (let t of p) this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: t
+		}, i);
+		return p;
+	}
+	async executePatchJson(e, t, r, i, a, o) {
+		let s = this.sql, c = r.split("."), l = c[0], u = c.slice(1), f = u.length === 0 ? "$" : `$.${u.join(".")}`, p = JSON.stringify(i ?? null), m = s`UPDATE ${s(this.nsT(e))} SET ${s(l)} = JSON_MODIFY(${s(l)}, ${f}, JSON_QUERY(${p})) OUTPUT INSERTED.* WHERE ${s("id")} = ${t}`, h = a ? n.provideService(m, d, a) : m, g = (await this.runtime.runPromise(h))[0];
+		return g ? (this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: g
+		}, o), g) : null;
+	}
+	async executeDelete(e, t, r, i) {
+		let a = this.sql, o = a`DELETE FROM ${a(this.nsT(e))} OUTPUT DELETED.* WHERE ${a("id")} = ${t}`, 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;
+	}
+	routeEvent(e, t) {
+		t === null ? this.inlineEmit && this.emitter.emit("change", e) : t.push(e);
+	}
+	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 (!v(e)) return this.executeQuery(e, t);
+		let r = this.namespace === null ? p(e, this.sql, "mssql") : null;
+		if (r !== null) try {
+			let e = t ? n.provideService(r.fragment, d, t) : r.fragment, i = await this.runtime.runPromise(e);
+			return r.decode(i);
+		} catch (e) {
+			H.warn("mssql JSON-agg eager-load failed; falling back to walker", { err: e });
+		}
+		return f(await this.executeQuery(e, t), e.eager, e.sourceTable ?? x(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);
+	}
+	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, n) {
+		let r = this.sql, i = m(n.where, r, this.namespace), a = r`UPDATE ${r(this.nsT(e))} SET ${r.update(t)} OUTPUT INSERTED.* WHERE ${i}`, 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;
+	}
+	async deleteMany(e, t) {
+		let n = this.sql, r = m(t.where, n, this.namespace), i = n`DELETE FROM ${n(this.nsT(e))} OUTPUT DELETED.* WHERE ${r}`, a = await this.runtime.runPromise(i);
+		for (let t of a) this.routeEvent({
+			table: e,
+			op: "delete",
+			old: t,
+			new: null
+		}, null);
+		return a.length;
+	}
+	upsert(e, t, n) {
+		return this.executeUpsert(e, t, n, null, null);
+	}
+	insertIgnore(e, t, n) {
+		return this.executeInsertIgnore(e, t, n, null, null);
+	}
+	upsertPatch(e, t, n) {
+		if (typeof n.update == "function") return n.update(t);
+		if (Array.isArray(n.update)) {
+			let t = {};
+			for (let r of n.update) r in e && (t[r] = e[r]);
+			return t;
+		}
+		let r = {};
+		for (let [t, i] of Object.entries(e)) t !== "id" && (n.conflictColumns.includes(t) || (r[t] = i));
+		return r;
+	}
+	async executeUpsert(e, t, n, r, i) {
+		if (typeof n.update != "function" && n.conflictColumns.length > 0) return this.mergeUpsert(e, t, {
+			conflictColumns: n.conflictColumns,
+			...n.update ? { update: n.update } : {}
+		}, r, i);
+		let a = await this.findByConflict(e, t, n.conflictColumns, r);
+		if (a) return await this.executeUpdate(e, a.id, this.upsertPatch(t, a, n), r, i) ?? a;
+		try {
+			return await this.executeInsert(e, t, r, i);
+		} catch (a) {
+			if (!N(a)) throw a;
+			let o = await this.findByConflict(e, t, n.conflictColumns, r);
+			if (!o) throw a;
+			return await this.executeUpdate(e, o.id, this.upsertPatch(t, o, n), r, i) ?? o;
+		}
+	}
+	async mergeUpsert(e, t, r, i, a) {
+		let o = this.sql, s = Object.keys(t), c = Array.isArray(r.update) ? r.update.filter((e) => s.includes(e)) : s.filter((e) => e !== "id" && !r.conflictColumns.includes(e)), l = s.map((e) => o`${t[e]}`), u = s.map((e) => o`${o(e)}`), f = r.conflictColumns.map((e) => o`tgt.${o(e)} = src.${o(e)}`), p = s.map((e) => o`${o(e)}`), m = s.map((e) => o`src.${o(e)}`), h = (c.length > 0 ? c : [r.conflictColumns[0]]).map((e) => o`tgt.${o(e)} = src.${o(e)}`), g = o`
+      MERGE ${o(this.nsT(e))} WITH (HOLDLOCK) AS tgt
+      USING (VALUES (${o.csv(l)})) AS src (${o.csv(u)})
+      ON ${o.and(f)}
+      WHEN MATCHED THEN UPDATE SET ${o.csv(h)}
+      WHEN NOT MATCHED THEN INSERT (${o.csv(p)}) VALUES (${o.csv(m)})
+      OUTPUT $action AS ${o("__action")}, INSERTED.*;`, _ = i ? n.provideService(g, d, i) : g, v = (await this.runtime.runPromise(_))[0];
+		if (!v) throw Error(`MssqlStore.upsert: MERGE returned no row for '${e}'`);
+		let y = v.__action, { __action: b, ...x } = v;
+		return this.routeEvent({
+			table: e,
+			op: y === "INSERT" ? "insert" : "update",
+			old: null,
+			new: x
+		}, a), x;
+	}
+	async executeInsertIgnore(e, t, n, r, i) {
+		let a = await this.findByConflict(e, t, n.conflictColumns, r);
+		if (a) return a;
+		try {
+			return await this.executeInsert(e, t, r, i);
+		} catch (i) {
+			if (!N(i)) throw i;
+			let a = await this.findByConflict(e, t, n.conflictColumns, r);
+			if (!a) throw i;
+			return 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 TOP 1 * FROM ${a(this.nsT(e))} WHERE ${a.and(o)}`, c = i ? n.provideService(s, d, i) : s;
+		return (await this.runtime.runPromise(c))[0];
+	}
+	emitChange(e) {
+		this.emitter.emit("change", e);
+	}
+	async startCdcConsumer(e) {
+		if (this.cdcHandle) return;
+		this.cdcReplicaId = e.replicaId;
+		let t = e.includeTables ?? [];
+		t.length === 0 && H.warn("cdc: no reactive tables to tail; Change Tracking reader idle. Set includeTables to enable.");
+		let n = await this.readCdcOffset(e.replicaId);
+		this.cdcHandle = await z({
+			run: this.__mssqlReplicationFriend.runEffect,
+			tables: t,
+			startVersion: n,
+			onChange: (e) => this.injectExternalChange(e),
+			onVersion: (e) => {
+				this.cdcPendingVersion = e;
+			},
+			onError: (e) => H.warn("cdc: consumer error", {}, e),
+			onResync: () => {
+				H.warn("cdc: resynced to current CT version after retention gap — subscriptions self-heal on the next change");
+			}
+		}), this.cdcCheckpointTimer = setInterval(() => {
+			this.flushCdcOffset();
+		}, 1e3), this.cdcCheckpointTimer.unref && this.cdcCheckpointTimer.unref();
+	}
+	async readCdcOffset(e) {
+		try {
+			let t = this.sql, n = (await this.runtime.runPromise(t`
+          SELECT TOP 1 ${t("ctVersion")} FROM ${t(B)}
+          WHERE ${t("id")} = ${e}`))[0]?.ctVersion;
+			return n ? (H.info("cdc: resuming from persisted CT version", {
+				replicaId: e,
+				version: n
+			}), n) : null;
+		} catch (t) {
+			return H.warn("cdc: no readable offset; starting at current CT version", { replicaId: e }, t), null;
+		}
+	}
+	async flushCdcOffset() {
+		let e = this.cdcPendingVersion;
+		if (e !== null) {
+			this.cdcPendingVersion = null;
+			try {
+				let t = this.cdcReplicaId;
+				await this.executeUpsert(B, {
+					id: t,
+					replicaId: t,
+					streamName: this.cdcStreamName,
+					ctVersion: e,
+					updatedAt: /* @__PURE__ */ new Date()
+				}, {
+					conflictColumns: ["id"],
+					update: ["ctVersion", "updatedAt"]
+				}, null, null);
+			} catch (t) {
+				this.cdcPendingVersion = e, H.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("MssqlStore.transactional: TransactionConnection missing."));
+				let i = new G(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(j)), o = r.pipe(n.retry(i), n.withSpan("store.transactional", { attributes: {
+			"db.system": "mssql",
+			"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.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.currentVersion();
+			e !== null && (this.cdcPendingVersion = 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 && H.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`);
+	}
+}, G = 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("MssqlStore.transactional: nested transactions are not supported."));
+	}
+	onChange(e) {
+		throw Error("MssqlTransactionalView.onChange: not supported inside a transaction.");
+	}
+	injectExternalChange(e) {
+		throw Error("MssqlTransactionalView.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;
+		}
+	}
+}, K = (e) => e.__mssqlReplicationFriend ?? null, q = (e, t) => e === t ? 0 : e < t ? -1 : 1, J = () => ({
+	async capturePrimaryPosition(e) {
+		let t = K(e);
+		if (t === null) throw Error("mssqlReplicationAdapter: primary is not an MssqlStore (missing __mssqlReplicationFriend).");
+		return t.runEffect(n.gen(function* () {
+			return (yield* (yield* u)`
+          SELECT CONVERT(VARCHAR(40), end_of_log_lsn) AS lsn
+          FROM sys.dm_hadr_database_replica_states
+          WHERE database_id = DB_ID()
+            AND is_local = 1
+            AND is_primary_replica = 1
+        `)[0]?.lsn ?? "00000000:00000000:0000";
+		}));
+	},
+	async probeReplicaPosition(e) {
+		let t = K(e);
+		if (t === null) throw Error("mssqlReplicationAdapter: replica is not an MssqlStore.");
+		return t.runEffect(n.gen(function* () {
+			return (yield* (yield* u)`
+          SELECT CONVERT(VARCHAR(40), last_hardened_lsn) AS lsn
+          FROM sys.dm_hadr_database_replica_states
+          WHERE database_id = DB_ID()
+            AND is_local = 1
+        `)[0]?.lsn ?? "00000000:00000000:0000";
+		}));
+	},
+	compare(e, t) {
+		return q(t, e) >= 0 ? "caught-up" : "behind";
+	}
+}), Y = {
+	id: "mssql",
+	makeSqlLayer: (e) => O(e),
+	makeStore: (e) => U(e),
+	compileContains: (e, t, n) => n`${e} LIKE ${`%${t.replace(/[\\%_[\]]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
+	retryFilter: P
+};
+//#endregion
+export { B as CDC_OFFSETS_TABLE, e as MssqlClient, V as _voltroMssqlCdcOffsetsTable, D as connectionFromConfig, I as ensureChangeTracking, E as makeMssqlSqlLayer, O as makeMssqlSqlLayerFromConfig, U as makeMssqlStore, Y as mssqlDialect, J as mssqlReplicationAdapter, P as mssqlRetryFilter, z as startChangeTrackingCdc };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@voltro/sql-mssql",
+  "version": "0.1.0",
+  "description": "SQL Server (mssql) dialect adapter for Voltro's cross-dialect DataStore (OUTPUT-clause returning, OFFSET/FETCH paging, inline reactivity).",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@effect/sql": "^0.51.1",
+    "@effect/sql-mssql": "^0.52.0",
+    "@voltro/database": "0.1.0",
+    "@voltro/logger": "0.1.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}