@voltro/sql-mssql 0.85.0 → 0.87.0

package/dist/store.js

@@ -0,0 +1,576 @@
+import { writeOutput as e } from "./writeOutput.js";
+import { isDuplicateKeyMssqlFailure as t, isRetryableMssqlFailure as n } from "./retry.js";
+import { startChangeTrackingCdc as r } from "./changeTrackingCdc.js";
+import { CDC_OFFSETS_TABLE as i } from "./cdcOffsetsTable.js";
+import { Effect as a, Layer as o, ManagedRuntime as s, Option as c } from "effect";
+import { EagerCardinalityError as l, attachEagerLoads as u, attributionFields as d, bulkInsertLimitsFor as f, chunkRowsForInsert as p, compileEagerJson as m, compileJsonPatch as h, compilePredicate as g, compileRawFragment as _, compileSelect as v, decodeRowsFromSchema as y, decodeSelectRows as b, emitCommittedChanges as x, encodeRowForSchema as S, externalChangeEvent as C, hasEagerLoads as w, isTableReactive as T, jsonPatchAssignments as E, makeEagerFallbackReporter as D, makeTransactionAbortTracker as O, observeDbOp as k, onTransaction as A, qualifyTable as j, quoteIdent as M, raiseChangeListenerCeiling as N, recordsTable as P, requireTable as F, rowKeyColumns as I, runSavepoint as L, runStoreTransaction as R, runWriteRecorders as z, stampGeneratedId as B, stampGeneratedIds as V, upsertUpdatePatch as H, upsertUpdateValues as U, withCapturedAttribution as W, writeImagesObserved as G } from "@voltro/database";
+import { EventEmitter as K } from "node:events";
+import { createLogger as q } from "@voltro/logger";
+import { SqlClient as J } from "effect/sql/SqlClient";
+//#region src/store.ts
+var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
+	let t = e.changeStrategy ?? "inline", n = t;
+	t === "cdc" && !e.cdcConfig && (Y.warn("changeStrategy='cdc' requires cdcConfig (replicaId + includeTables); falling back to 'inline'."), n = "inline");
+	let r = e.tracerLayer ? o.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, i = s.make(r), a = new Z(await i.runPromise(J), i, n);
+	return n === "cdc" && e.cdcConfig && await a.startCdcConsumer(e.cdcConfig), a;
+}, Z = class o {
+	sql;
+	runtime;
+	changeStrategy;
+	namespace;
+	emitter;
+	inflightTxns = 0;
+	reportEagerFallback = D(Y);
+	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 K(), N(this.emitter);
+	}
+	get inlineEmit() {
+		return this.changeStrategy === "inline";
+	}
+	withNamespace(e) {
+		return e === this.namespace ? this : new o(this.sql, this.runtime, this.changeStrategy, e, this.emitter);
+	}
+	nsT(e) {
+		return j(this.namespace, e);
+	}
+	__mssqlReplicationFriend = { runEffect: (e) => this.runtime.runPromise(e) };
+	async executeQuery(e, t) {
+		let n = v(e, this.sql, this.namespace), r = t ? a.provideService(n, this.sql.transactionService, t) : n, i = await k("mssql", "select", () => this.runtime.runPromise(r));
+		return b(i, e, "mssql");
+	}
+	decodeWritten(e, t) {
+		return y([t], e, "mssql")[0] ?? t;
+	}
+	async executeInsert(t, n, r, i, o) {
+		n = B(t, n);
+		let s = this.sql, c = e(s, this.nsT(t), (e) => s`INSERT INTO ${s(this.nsT(t))} ${s.insert(S(n, t)).returning(s`INSERTED.* INTO ${e}`)}`), l = r ? a.provideService(c, this.sql.transactionService, r) : c, u = (await this.runtime.runPromise(l))[0];
+		if (!u) throw Error(`MssqlStore.insert: row not returned post-insert in '${t}'`);
+		let d = this.decodeWritten(t, u);
+		return await this.routeEvent({
+			table: t,
+			op: "insert",
+			old: null,
+			new: d
+		}, i, r, o), d;
+	}
+	async executeUpdate(t, n, r, i, o, s) {
+		let c = this.sql, l = e(c, this.nsT(t), (e) => c`UPDATE ${c(this.nsT(t))} SET ${c.update(S(r, t)).returning(c`INSERTED.* INTO ${e}`)} WHERE ${c.and(I(n).map(([e, t]) => c`${c(e)} = ${t}`))}`), u = i ? a.provideService(l, this.sql.transactionService, i) : l, d = (await this.runtime.runPromise(u))[0];
+		if (!d) return null;
+		let f = this.decodeWritten(t, d);
+		return await this.routeEvent({
+			table: t,
+			op: "update",
+			old: null,
+			new: f
+		}, o, i, s), f;
+	}
+	async executeInsertMany(t, n, r, i, o, s) {
+		if (n = V(t, n), n.length === 0) return [];
+		let c = this.sql, l = p(n, f("mssql")), u = s?.returning === "none", d = u && !G(t), m = (n) => {
+			let r = c.insert(n.map((e) => S(e, t)));
+			return d ? a.as(c`INSERT INTO ${c(this.nsT(t))} ${r}`, []) : e(c, this.nsT(t), (e) => c`INSERT INTO ${c(this.nsT(t))} ${r.returning(c`INSERTED.* INTO ${e}`)}`);
+		}, h;
+		if (l.length === 1) {
+			let e = m(l[0]), t = r ? a.provideService(e, this.sql.transactionService, r) : e;
+			h = await this.runtime.runPromise(t);
+		} else if (r) {
+			let e = [];
+			for (let t of l) e.push(...await this.runtime.runPromise(a.provideService(m(t), this.sql.transactionService, r)));
+			h = e;
+		} else h = await this.runtime.runPromise(c.withTransaction(a.map(a.forEach(l, m, { concurrency: 1 }), (e) => e.flat())));
+		if (d) return [];
+		let g = n.map((e) => e.id), _ = y(h, t, "mssql"), v = new Map(_.map((e) => [e.id, e])), b = g.map((e) => v.get(e)).filter((e) => e !== void 0), x = b.length === h.length ? b : _;
+		for (let e of x) await this.routeEvent({
+			table: t,
+			op: "insert",
+			old: null,
+			new: e
+		}, i, r, o);
+		return u ? [] : x;
+	}
+	async executePatchJson(t, n, r, i, o, s, c, l) {
+		let u = this.sql, d = S(E(n, r, l), t), f = u.csv([h(u, "mssql", r, i), ...Object.entries(d).map(([e, t]) => u`${u(e)} = ${t}`)]), p = e(u, this.nsT(t), (e) => u`UPDATE ${u(this.nsT(t))} SET ${f} OUTPUT INSERTED.* INTO ${e} WHERE ${u.and(I(n).map(([e, t]) => u`${u(e)} = ${t}`))}`), m = o ? a.provideService(p, this.sql.transactionService, o) : p, g = (await this.runtime.runPromise(m))[0];
+		if (!g) return null;
+		let _ = this.decodeWritten(t, g);
+		return await this.routeEvent({
+			table: t,
+			op: "update",
+			old: null,
+			new: _
+		}, s, o, c), _;
+	}
+	async executeDelete(t, n, r, i, o) {
+		let s = this.sql, c = e(s, this.nsT(t), (e) => s`DELETE FROM ${s(this.nsT(t))} OUTPUT DELETED.* INTO ${e} WHERE ${s.and(I(n).map(([e, t]) => s`${s(e)} = ${t}`))}`), l = r ? a.provideService(c, this.sql.transactionService, r) : c, u = (await this.runtime.runPromise(l))[0];
+		if (!u) return !1;
+		let d = this.decodeWritten(t, u);
+		return await this.routeEvent({
+			table: t,
+			op: "delete",
+			old: d,
+			new: null
+		}, i, r, o), !0;
+	}
+	async appendInTxn(e, t, n) {
+		let r = this.sql, i = r`INSERT INTO ${r(this.nsT(e))} ${r.insert(S(t, e))}`;
+		await this.runtime.runPromise(n ? a.provideService(i, this.sql.transactionService, n) : i);
+	}
+	async maxInTxn(e, t, n, r) {
+		let i = this.sql, o = Object.entries(n).map(([e, t]) => i`${i(e)} = ${t}`), s = i`SELECT MAX(${i(t)}) AS ${i("m")} FROM ${i(this.nsT(e))} WHERE ${i.and(o)}`, c = (await this.runtime.runPromise(r ? a.provideService(s, this.sql.transactionService, r) : s))[0]?.m;
+		return c == null ? null : Number(c);
+	}
+	async routeEvent(e, t, n = null, r) {
+		e = {
+			...d(r),
+			...e
+		}, P(e.table) && await z({
+			append: (e, t) => this.appendInTxn(e, t, n),
+			maxOf: (e, t, r) => this.maxInTxn(e, t, r, n)
+		}, {
+			table: e.table,
+			op: e.op,
+			next: e.new,
+			prev: e.old,
+			traceId: e.traceId,
+			subjectId: e.subjectId
+		}), T(e.table) && (t === null ? this.inlineEmit && this.emitter.emit("change", e) : t.push(e));
+	}
+	integrityQuery(e) {
+		return this.query(e);
+	}
+	query(e) {
+		return this.runWithEager(e, null);
+	}
+	raw(e, t) {
+		return this.rawOn(e, null);
+	}
+	rawOn(e, t) {
+		let n = _(e, this.sql), r = t ? a.provideService(n, this.sql.transactionService, t) : n;
+		return k("mssql", "raw", () => this.runtime.runPromise(r));
+	}
+	async runWithEager(e, t) {
+		if (!w(e)) return this.executeQuery(e, t);
+		let n = this.namespace === null ? m(e, this.sql, "mssql") : null;
+		if (n !== null) try {
+			let e = t ? a.provideService(n.fragment, this.sql.transactionService, t) : n.fragment, r = await k("mssql", "select", () => this.runtime.runPromise(e));
+			return n.decode(r);
+		} catch (t) {
+			if (t instanceof l) throw t;
+			this.reportEagerFallback({
+				dialect: "mssql",
+				table: e.table,
+				reason: "execute-failed",
+				error: t
+			});
+		}
+		else this.reportEagerFallback({
+			dialect: "mssql",
+			table: e.table,
+			reason: "not-compilable"
+		});
+		let r = await this.executeQuery(e, t);
+		return u(r, e.eager, e.sourceTable ?? F(e.table), (e) => this.executeQuery(e, t));
+	}
+	getInternalRunWithEager() {
+		return this.runWithEager.bind(this);
+	}
+	localWrite(e, t, n) {
+		let r = (e) => P(t) ? this.writeWithRecorders(n, e) : n(e, null, null);
+		return k("mssql", e, () => W(r));
+	}
+	async writeWithRecorders(e, t) {
+		let n = [], r = this.sql, i = await this.runtime.runPromise(r.withTransaction(a.flatMap(a.serviceOption(this.sql.transactionService), (r) => c.isNone(r) ? a.fail(/* @__PURE__ */ Error("MssqlStore.write: TransactionConnection missing.")) : a.tryPromise({
+			try: () => e(t, r.value, n),
+			catch: (e) => e
+		}))));
+		return x(n, (e) => this.emitChange(e)), i;
+	}
+	insert(e, t) {
+		return this.localWrite("insert", e, (n, r, i) => this.executeInsert(e, t, r, i, n));
+	}
+	insertMany(e, t, n) {
+		return this.localWrite("insert", e, (r, i, a) => this.executeInsertMany(e, t, i, a, r, n));
+	}
+	patchJson(e, t, n, r, i) {
+		return this.localWrite("update", e, (a, o, s) => this.executePatchJson(e, t, n, r, o, s, a, i));
+	}
+	update(e, t, n) {
+		return this.localWrite("update", e, (r, i, a) => this.executeUpdate(e, t, n, i, a, r));
+	}
+	delete(e, t) {
+		return this.localWrite("delete", e, (n, r, i) => this.executeDelete(e, t, r, i, n));
+	}
+	updateMany(e, t, n) {
+		return this.executeUpdateMany(e, t, n, null, null);
+	}
+	deleteMany(e, t) {
+		return this.executeDeleteMany(e, t, null, null);
+	}
+	async executeUpdateMany(t, n, r, i, o, s) {
+		let c = this.sql, l = g(r.where, c, this.namespace), u = c.update(S(n, t));
+		if (!G(t)) return this.countWritten(c`UPDATE ${c(this.nsT(t))} SET ${u} WHERE ${l}`, "update", i);
+		let d = e(c, this.nsT(t), (e) => c`UPDATE ${c(this.nsT(t))} SET ${u} OUTPUT INSERTED.* INTO ${e} WHERE ${l}`), f = i ? a.provideService(d, this.sql.transactionService, i) : d, p = await k("mssql", "update", () => this.runtime.runPromise(f));
+		for (let e of y(p, t, "mssql")) await this.routeEvent({
+			table: t,
+			op: "update",
+			old: null,
+			new: e
+		}, o, i, s);
+		return p.length;
+	}
+	async countWritten(e, t, n) {
+		let r = this.sql`${e}; SELECT @@ROWCOUNT AS n`, i = n ? a.provideService(r, this.sql.transactionService, n) : r, [o] = await k("mssql", t, () => this.runtime.runPromise(i));
+		return Number(o?.n ?? 0);
+	}
+	async executeDeleteMany(t, n, r, i, o) {
+		let s = this.sql, c = g(n.where, s, this.namespace);
+		if (!G(t)) return this.countWritten(s`DELETE FROM ${s(this.nsT(t))} WHERE ${c}`, "delete", r);
+		let l = e(s, this.nsT(t), (e) => s`DELETE FROM ${s(this.nsT(t))} OUTPUT DELETED.* INTO ${e} WHERE ${c}`), u = r ? a.provideService(l, this.sql.transactionService, r) : l, d = await k("mssql", "delete", () => this.runtime.runPromise(u));
+		for (let e of y(d, t, "mssql")) await this.routeEvent({
+			table: t,
+			op: "delete",
+			old: e,
+			new: null
+		}, i, r, o);
+		return d.length;
+	}
+	upsert(e, t, n) {
+		return this.localWrite("upsert", e, (r, i, a) => this.executeUpsert(e, t, n, i, a, r));
+	}
+	insertIgnore(e, t, n) {
+		return this.insertIgnoreWithOutcome(e, t, n).then((e) => e.row);
+	}
+	insertIgnoreWithOutcome(e, t, n) {
+		return this.localWrite("upsert", e, (r, i, a) => this.executeInsertIgnore(e, t, n, i, a, r));
+	}
+	async executeUpsert(e, n, r, i, a, o) {
+		if (U(r), n = B(e, n), typeof r.update != "function" && r.conflictColumns.length > 0) return this.mergeUpsert(e, n, {
+			conflictColumns: r.conflictColumns,
+			...r.update === void 0 ? {} : { update: r.update },
+			...r.updateValues === void 0 ? {} : { updateValues: r.updateValues }
+		}, i, a, o);
+		let s = await this.findByConflict(e, n, r.conflictColumns, i);
+		if (s) return await this.executeUpdate(e, Object.fromEntries(r.conflictColumns.map((e) => [e, s[e]])), H(n, s, r), i, a, o) ?? s;
+		try {
+			return await this.executeInsert(e, n, i, a, o);
+		} catch (s) {
+			if (!t(s)) throw s;
+			let c = await this.findByConflict(e, n, r.conflictColumns, i);
+			if (!c) throw s;
+			return await this.executeUpdate(e, Object.fromEntries(r.conflictColumns.map((e) => [e, c[e]])), H(n, c, r), i, a, o) ?? c;
+		}
+	}
+	async mergeUpsert(t, n, r, i, o, s) {
+		let c = this.sql, l = Object.keys(n), u = Array.isArray(r.update) ? r.update.filter((e) => l.includes(e)) : l.filter((e) => e !== "id" && !r.conflictColumns.includes(e)), d = S(n, t), f = l.map((e) => c`${d[e]}`), p = l.map((e) => c`${c(e)}`), m = r.conflictColumns.map((e) => c`tgt.${c(e)} = src.${c(e)}`), h = l.map((e) => c`${c(e)}`), g = l.map((e) => c`src.${c(e)}`), _ = U(r), v = S(_, t), y = [...u.filter((e) => !Object.hasOwn(_, e)).map((e) => c`tgt.${c(e)} = src.${c(e)}`), ...Object.entries(v).map(([e, t]) => c`tgt.${c(e)} = ${t}`)];
+		y.length === 0 && y.push(c`tgt.${c(r.conflictColumns[0])} = src.${c(r.conflictColumns[0])}`);
+		let b = e(c, this.nsT(t), (e) => c`
+      MERGE ${c(this.nsT(t))} WITH (HOLDLOCK) AS tgt
+      USING (VALUES (${c.csv(f)})) AS src (${c.csv(p)})
+      ON ${c.and(m)}
+      WHEN MATCHED THEN UPDATE SET ${c.csv(y)}
+      WHEN NOT MATCHED THEN INSERT (${c.csv(h)}) VALUES (${c.csv(g)})
+      OUTPUT $action AS ${c("__action")}, INSERTED.* INTO ${e};`, !0), x = i ? a.provideService(b, this.sql.transactionService, i) : b, C = (await this.runtime.runPromise(x))[0];
+		if (!C) throw Error(`MssqlStore.upsert: MERGE returned no row for '${t}'`);
+		let w = C.__action, { __action: T, ...E } = C, D = this.decodeWritten(t, E);
+		return await this.routeEvent({
+			table: t,
+			op: w === "INSERT" ? "insert" : "update",
+			old: null,
+			new: D
+		}, o, i, s), D;
+	}
+	async executeInsertIgnore(e, n, r, i, a, o) {
+		n = B(e, n);
+		let s = await this.findByConflict(e, n, r.conflictColumns, i);
+		if (s) return {
+			row: s,
+			outcome: "ignored"
+		};
+		try {
+			return {
+				row: await this.executeInsert(e, n, i, a, o),
+				outcome: "inserted"
+			};
+		} catch (a) {
+			if (!t(a)) throw a;
+			let o = await this.findByConflict(e, n, r.conflictColumns, i);
+			if (!o) throw a;
+			return {
+				row: o,
+				outcome: "ignored"
+			};
+		}
+	}
+	async findByConflict(e, t, n, r) {
+		if (n.length === 0) return;
+		let i = this.sql, o = n.map((e) => i`${i(e)} = ${t[e]}`), s = i`SELECT TOP 1 * FROM ${i(this.nsT(e))} WHERE ${i.and(o)}`, c = r ? a.provideService(s, this.sql.transactionService, r) : s, l = (await this.runtime.runPromise(c))[0];
+		return l ? this.decodeWritten(e, l) : void 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 && Y.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 r({
+			run: this.__mssqlReplicationFriend.runEffect,
+			tables: t,
+			startVersion: n,
+			onChange: (e) => this.injectExternalChange(e),
+			onVersion: (e) => {
+				this.cdcPendingVersion = e;
+			},
+			onError: (e) => Y.warn("cdc: consumer error", {}, e),
+			onResync: () => {
+				Y.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(i)}
+          WHERE ${t("id")} = ${e}`))[0]?.ctVersion;
+			return n ? (Y.info("cdc: resuming from persisted CT version", {
+				replicaId: e,
+				version: n
+			}), n) : null;
+		} catch (t) {
+			return Y.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(i, {
+					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, Y.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);
+	}
+	getInternalExecuteUpdateMany() {
+		return this.executeUpdateMany.bind(this);
+	}
+	getInternalExecuteDeleteMany() {
+		return this.executeDeleteMany.bind(this);
+	}
+	getInternalExecuteDelete() {
+		return this.executeDelete.bind(this);
+	}
+	getInternalExecuteUpsert() {
+		return this.executeUpsert.bind(this);
+	}
+	getInternalExecuteInsertIgnore() {
+		return this.executeInsertIgnore.bind(this);
+	}
+	async emptyTables(e) {
+		await this.emptyTablesOn(e, null);
+	}
+	async incomingForeignKeys(e) {
+		if (e.length === 0) return [];
+		let t = this.sql;
+		return (await this.runtime.runPromise(t`
+        SELECT child.name AS fromTable, col.name AS columnName, parent.name AS toTable
+        FROM sys.foreign_key_columns fkc
+        JOIN sys.tables child ON child.object_id = fkc.parent_object_id
+        JOIN sys.tables parent ON parent.object_id = fkc.referenced_object_id
+        JOIN sys.columns col ON col.object_id = fkc.parent_object_id AND col.column_id = fkc.parent_column_id
+        WHERE parent.name IN ${t.in(e)}
+          AND child.name NOT IN ${t.in(e)}`)).map((e) => ({
+			from: e.fromTable,
+			column: e.columnName,
+			to: e.toTable
+		}));
+	}
+	async emptyTablesOn(e, t) {
+		if (e.length === 0) return;
+		let n = this.sql, r = (e) => this.nsT(e), i = (e, t) => n.unsafe(`ALTER TABLE ${M(r(e), "mssql")} ${t ? "WITH CHECK CHECK" : "NOCHECK"} CONSTRAINT ALL`), o = a.acquireUseRelease(a.forEach(e, (e) => i(e, !1), { discard: !0 }), () => a.forEach(e, (e) => n`DELETE FROM ${n(r(e))}`, { discard: !0 }), () => a.orDie(a.ignore(a.forEach(e, (e) => i(e, !0), { discard: !0 })))), s = t === null ? n.withTransaction(o) : a.provideService(o, this.sql.transactionService, t);
+		await this.runtime.runPromise(s);
+	}
+	async transactional(e) {
+		this.inflightTxns++;
+		try {
+			return await R({
+				...this.txnSpec("MssqlStore.transactional"),
+				work: e,
+				makeView: (e, t) => new Q(this, e, t)
+			});
+		} finally {
+			this.inflightTxns--;
+		}
+	}
+	get transactionService() {
+		return this.sql.transactionService;
+	}
+	txnSpec(e) {
+		return {
+			label: e,
+			dialect: "mssql",
+			withTransaction: (e) => this.sql.withTransaction(e),
+			transactionService: this.sql.transactionService,
+			runPromiseExit: (e) => this.runtime.runPromiseExit(e),
+			isRetryable: n,
+			span: {
+				name: "store.transactional",
+				attributes: {
+					"db.system": "mssql",
+					"db.operation": "transaction"
+				}
+			}
+		};
+	}
+	onChange(e) {
+		return this.emitter.on("change", e), () => {
+			this.emitter.off("change", e);
+		};
+	}
+	get changeScope() {
+		return this.changeStrategy === "cdc" ? "fleet" : "local";
+	}
+	injectExternalChange(e) {
+		T(e.table) && this.emitter.emit("change", C(e));
+	}
+	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 && Y.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`);
+	}
+}, Q = class {
+	parent;
+	txn;
+	attr;
+	events = [];
+	aborts = O((e) => n(e));
+	committed = !1;
+	constructor(e, t, n = void 0) {
+		this.parent = e, this.txn = t, this.attr = n;
+	}
+	async savepoint(e) {
+		let t = this.events.length;
+		try {
+			return await L({
+				tracker: this.aborts,
+				name: `voltro_sp_${++this.savepointCounter}`,
+				spelling: "mssql",
+				exec: (e) => this.parent.run(a.provideService(J.pipe(a.flatMap((t) => t.unsafe(e))), this.parent.transactionService, this.txn))
+			}, e);
+		} catch (e) {
+			throw this.events.length = t, e;
+		}
+	}
+	savepointCounter = 0;
+	run(e) {
+		return this.aborts.track(() => this.parent.run(A(e, this.parent.transactionService, this.txn)));
+	}
+	abortedBy() {
+		return this.aborts.abortedBy();
+	}
+	raw(e, t) {
+		return this.aborts.track(() => this.parent.rawOn(e, this.txn));
+	}
+	integrityQuery(e) {
+		return this.query(e);
+	}
+	query(e) {
+		return this.aborts.track(() => this.parent.getInternalRunWithEager()(e, this.txn));
+	}
+	emptyTables(e) {
+		return this.aborts.track(() => this.parent.emptyTablesOn(e, this.txn));
+	}
+	insert(e, t) {
+		return this.aborts.track(() => this.parent.getInternalExecuteInsert()(e, t, this.txn, this.events, this.attr));
+	}
+	insertMany(e, t, n) {
+		return this.aborts.track(() => this.parent.getInternalExecuteInsertMany()(e, t, this.txn, this.events, this.attr, n));
+	}
+	patchJson(e, t, n, r, i) {
+		return this.aborts.track(() => this.parent.getInternalExecutePatchJson()(e, t, n, r, this.txn, this.events, this.attr, i));
+	}
+	update(e, t, n) {
+		return this.aborts.track(() => this.parent.getInternalExecuteUpdate()(e, t, n, this.txn, this.events, this.attr));
+	}
+	delete(e, t) {
+		return this.aborts.track(() => this.parent.getInternalExecuteDelete()(e, t, this.txn, this.events, this.attr));
+	}
+	updateMany(e, t, n) {
+		return this.aborts.track(() => this.parent.getInternalExecuteUpdateMany()(e, t, n, this.txn, this.events, this.attr));
+	}
+	deleteMany(e, t) {
+		return this.aborts.track(() => this.parent.getInternalExecuteDeleteMany()(e, t, this.txn, this.events, this.attr));
+	}
+	upsert(e, t, n) {
+		return this.aborts.track(() => this.parent.getInternalExecuteUpsert()(e, t, n, this.txn, this.events, this.attr));
+	}
+	insertIgnore(e, t, n) {
+		return this.insertIgnoreWithOutcome(e, t, n).then((e) => e.row);
+	}
+	insertIgnoreWithOutcome(e, t, n) {
+		return this.aborts.track(() => this.parent.getInternalExecuteInsertIgnore()(e, t, n, this.txn, this.events, this.attr));
+	}
+	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() {
+		this.committed || (this.committed = !0, x(this.events, (e) => this.parent.emitChange(e)), this.events.length = 0);
+	}
+};
+//#endregion
+export { Z as MssqlStore, X as makeMssqlStore };

package/dist/writeOutput.js

@@ -0,0 +1,18 @@
+import { mssqlRowResultProjection as e, readMssqlPhysicalColumns as t } from "./rowResultProjection.js";
+import { Effect as n } from "effect";
+//#region src/writeOutput.ts
+var r = (r, i, a, o = !1) => n.uninterruptible(n.gen(function* () {
+	let n = r.literal("[#voltro_write_output]"), s = yield* t(r, i), c = r.join(", ", !1)(s.map((e) => {
+		let t = r.literal(`[${e.name.replaceAll("]", "]]")}]`);
+		return e.system_type_id === 189 ? r`CONVERT(binary(8), ${t}) AS ${t}` : t;
+	})), l = e(r, s);
+	return yield* r`
+    SELECT TOP (0) ${o ? r.literal("CAST(NULL AS nvarchar(10)) AS [__action],") : r.literal("")} source.* INTO ${n}
+    FROM (SELECT ${c} FROM ${r(i)} UNION ALL SELECT ${c} FROM ${r(i)}) AS source;
+    ${a(n)};
+    SELECT ${o ? r.literal("[__action],") : r.literal("")}${l} FROM ${n};
+    DROP TABLE ${n};
+  `;
+}));
+//#endregion
+export { r as writeOutput };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/sql-mssql",
-  "version": "0.85.0",
+  "version": "0.87.0",
   "description": "SQL Server (mssql) dialect adapter for Voltro's cross-dialect DataStore (OUTPUT-clause returning, OFFSET/FETCH paging, inline reactivity).",
   "keywords": [
     "voltro",
@@ -34,8 +34,8 @@
   },
   "dependencies": {
     "@effect/sql-mssql": "4.0.1",
-    "@voltro/database": "0.85.0",
-    "@voltro/logger": "0.85.0",
+    "@voltro/database": "0.87.0",
+    "@voltro/logger": "0.87.0",
     "tedious": "20.3.3"
   },
   "peerDependencies": {