@voltro/sql-sqlite 0.84.0 → 0.86.0

package/dist/store.js

@@ -0,0 +1,480 @@
+import { isRetryableSqliteFailure as e } from "./retry.js";
+import { Effect as t, Layer as n, ManagedRuntime as r, Option as i } from "effect";
+import { EagerCardinalityError as a, attachEagerLoads as o, attributionFields as s, bulkInsertLimitsFor as c, chunkRowsForInsert as l, coercePredicateForSqlite as u, compileEagerJson as d, compileJsonPatch as f, compilePredicate as p, compileRawFragment as m, compileRowProjection as h, compileSelect as g, decodeRowsFromSchema as _, emitCommittedChanges as v, encodeRowForSchema as y, externalChangeEvent as b, hasEagerLoads as x, isTableReactive as S, jsonPatchAssignments as C, makeEagerFallbackReporter as w, makeTransactionAbortTracker as T, observeDbOp as E, onTransaction as D, qualifyTable as O, quoteIdent as k, raiseChangeListenerCeiling as A, recordsTable as j, requireTable as M, rowKeyColumns as N, runSavepoint as P, runStoreTransaction as F, runWriteRecorders as I, stampGeneratedId as L, stampGeneratedIds as R, upsertUpdatePatch as z, upsertUpdateValues as B, withCapturedAttribution as V } from "@voltro/database";
+import { EventEmitter as H } from "node:events";
+import { createLogger as U } from "@voltro/logger";
+import { SqlClient as W } from "effect/sql/SqlClient";
+//#region src/store.ts
+var G = U({ scope: "voltro:sqlite" }), K = async (t) => {
+	let i = t.tracerLayer ? n.mergeAll(t.sqlLayer, t.tracerLayer) : t.sqlLayer, a = r.make(i);
+	return new Z(await a.runPromise(W), a, null, void 0, t.isRetryable ?? e, t.systemName ?? "sqlite", t.wrapTransaction, t.fullText ?? "fts5");
+}, q = (e) => e, J = (e) => u(e), Y = (e) => e.predicate === void 0 || e.predicate === null ? e : {
+	...e,
+	predicate: J(e.predicate)
+}, X = (e, t) => {
+	let n = y(e, t, [
+		"json",
+		"array",
+		"decimal"
+	]), r = {};
+	for (let [e, t] of Object.entries(n)) r[e] = t instanceof Date ? t.toISOString() : typeof t == "boolean" ? +!!t : t;
+	return r;
+}, Z = class n {
+	sql;
+	runtime;
+	namespace;
+	isRetryable;
+	systemName;
+	wrapTransaction;
+	fullText;
+	emitter;
+	inflightTxns = 0;
+	reportEagerFallback;
+	constructor(t, n, r = null, i, a = e, o = "sqlite", s = q, c = "fts5") {
+		this.sql = t, this.runtime = n, this.namespace = r, this.isRetryable = a, this.systemName = o, this.wrapTransaction = s, this.fullText = c, this.emitter = i ?? new H(), A(this.emitter), this.reportEagerFallback = w(G);
+	}
+	withNamespace(e) {
+		return e === this.namespace ? this : new n(this.sql, this.runtime, e, this.emitter, this.isRetryable, this.systemName, this.wrapTransaction, this.fullText);
+	}
+	withFullTextMode(e) {
+		return this.fullText === "like" && e.fullTextSearch !== void 0 ? {
+			...e,
+			fullTextSearch: {
+				...e.fullTextSearch,
+				fallback: "like"
+			}
+		} : e;
+	}
+	nsT(e) {
+		return O(this.namespace, e);
+	}
+	async attachNamespace(e, t) {
+		let n = this.sql, r = t ?? `${e}.db`;
+		await this.runtime.runPromise(n`ATTACH DATABASE ${r} AS ${n(e)}`);
+	}
+	async executeQuery(e, n, r) {
+		let i = g(Y(this.withFullTextMode(e)), this.sql, this.namespace), a = n ? t.provideService(i, this.sql.transactionService, n) : i, o = await E(this.systemName, "select", () => this.runtime.runPromise(a));
+		return _(o, e.table, "sqlite", e);
+	}
+	keyWhere(e, t) {
+		let n = this.sql, r = X(Object.fromEntries(N(t)), e);
+		return n.and(Object.entries(r).map(([e, t]) => n`${n(e)} = ${t}`));
+	}
+	async executeInsert(e, n, r, i, a) {
+		n = L(e, n);
+		let o = this.sql, s = o`INSERT INTO ${o(this.nsT(e))} ${o.insert(X(n, e))} RETURNING ${h(e, o)}`, c = r ? t.provideService(s, this.sql.transactionService, r) : s, l = await this.runtime.runPromise(c), u = _(l, e, "sqlite")[0];
+		if (!u) throw Error(`SqliteStore.insert: no row returned for table '${e}'`);
+		return await this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: u
+		}, i, r, a), u;
+	}
+	async executeUpdate(e, n, r, i, a, o) {
+		let s = this.sql, c = s`UPDATE ${s(this.nsT(e))} SET ${s.update(X(r, e))} WHERE ${this.keyWhere(e, n)} RETURNING ${h(e, s)}`, l = i ? t.provideService(c, this.sql.transactionService, i) : c, u = await this.runtime.runPromise(l), d = _(u, e, "sqlite")[0];
+		return d ? (await this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: d
+		}, a, i, o), d) : null;
+	}
+	async executeInsertMany(e, n, r, i, a) {
+		if (n = R(e, n), n.length === 0) return [];
+		let o = this.sql, s = n.map((t) => X(t, e)), u = l(s, c("sqlite")), d = (t) => o`INSERT INTO ${o(this.nsT(e))} ${o.insert(t)} RETURNING ${h(e, o)}`, f;
+		if (u.length === 1) {
+			let e = d(u[0]), n = r ? t.provideService(e, this.sql.transactionService, r) : e;
+			f = await this.runtime.runPromise(n);
+		} else if (r) {
+			let e = [];
+			for (let n of u) e.push(...await this.runtime.runPromise(t.provideService(d(n), this.sql.transactionService, r)));
+			f = e;
+		} else f = await this.runtime.runPromise(o.withTransaction(t.map(t.forEach(u, d, { concurrency: 1 }), (e) => e.flat())));
+		let p = _(f, e, "sqlite");
+		for (let t of p) await this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: t
+		}, i, r, a);
+		return p;
+	}
+	async executePatchJson(e, n, r, i, a, o, s, c) {
+		let l = this.sql, u = X(C(n, r, c), e), d = l.csv([f(l, "sqlite", r, i, l`${l(this.nsT(e))}.${l(r.split(".")[0])}`), ...Object.entries(u).map(([e, t]) => l`${l(e)} = ${t}`)]), p = l`UPDATE ${l(this.nsT(e))} SET ${d} WHERE ${this.keyWhere(e, n)} RETURNING ${h(e, l)}`, m = a ? t.provideService(p, this.sql.transactionService, a) : p, g = await this.runtime.runPromise(m), v = _(g, e, "sqlite")[0];
+		return v ? (await this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: v
+		}, o, a, s), v) : null;
+	}
+	async executeDelete(e, n, r, i, a) {
+		let o = this.sql, s = o`DELETE FROM ${o(this.nsT(e))} WHERE ${this.keyWhere(e, n)} RETURNING ${h(e, o)}`, c = r ? t.provideService(s, this.sql.transactionService, r) : s, l = await this.runtime.runPromise(c), u = _(l, e, "sqlite")[0];
+		return u ? (await this.routeEvent({
+			table: e,
+			op: "delete",
+			old: u,
+			new: null
+		}, i, r, a), !0) : !1;
+	}
+	async appendInTxn(e, n, r) {
+		let i = this.sql, a = i`INSERT INTO ${i(this.nsT(e))} ${i.insert(X(n, e))}`;
+		await this.runtime.runPromise(r ? t.provideService(a, this.sql.transactionService, r) : a);
+	}
+	async maxInTxn(e, n, r, i) {
+		let a = this.sql, o = Object.entries(r).map(([e, t]) => a`${a(e)} = ${t}`), s = a`SELECT MAX(${a(n)}) AS ${a("m")} FROM ${a(this.nsT(e))} WHERE ${a.and(o)}`, c = (await this.runtime.runPromise(i ? t.provideService(s, this.sql.transactionService, i) : s))[0]?.m;
+		return c == null ? null : Number(c);
+	}
+	async routeEvent(e, t, n = null, r) {
+		e = {
+			...s(r),
+			...e
+		}, j(e.table) && await I({
+			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
+		}), S(e.table) && (t === null ? this.emitter.emit("change", e) : t.push(e));
+	}
+	async executeUpsert(e, n, r, i, a, o) {
+		let s = B(r);
+		if (n = L(e, n), typeof r.update == "function") {
+			let t = await this.findByConflict(e, n, r.conflictColumns, i);
+			if (t) {
+				let s = Object.fromEntries(r.conflictColumns.map((e) => [e, t[e]]));
+				return await this.executeUpdate(e, s, z(n, t, r), i, a, o) ?? t;
+			}
+			return this.executeInsert(e, n, i, a, o);
+		}
+		let c = this.sql, l = r.conflictColumns.map((e) => c`${c(e)}`), u = Object.keys(n).filter((e) => n[e] !== void 0), d = r.update === void 0 ? u.filter((e) => e !== "id" && !r.conflictColumns.includes(e)) : r.update, f = X(s, e), p = [...d.filter((e) => !Object.hasOwn(s, e)).map((e) => c`${c(e)} = excluded.${c(e)}`), ...Object.entries(f).map(([e, t]) => c`${c(e)} = ${t}`)], m = p.length > 0 ? c.csv(p) : c`${c(r.conflictColumns[0])} = excluded.${c(r.conflictColumns[0])}`, g = c`INSERT INTO ${c(this.nsT(e))} ${c.insert(X(n, e))} ON CONFLICT (${c.csv(l)}) DO UPDATE SET ${m} RETURNING ${h(e, c)}`, v = i ? t.provideService(g, this.sql.transactionService, i) : g, y = await this.runtime.runPromise(v), b = _(y, e, "sqlite")[0];
+		if (!b) throw Error(`SqliteStore.upsert: no row returned for table '${e}'`);
+		let x = n.id !== void 0 && n.id === b.id ? "insert" : "update";
+		return await this.routeEvent({
+			table: e,
+			op: x,
+			old: null,
+			new: b
+		}, a, i, o), b;
+	}
+	async executeInsertIgnore(e, n, r, i, a, o) {
+		n = L(e, n);
+		let s = this.sql, c = r.conflictColumns.map((e) => s`${s(e)}`), l = s`INSERT INTO ${s(this.nsT(e))} ${s.insert(X(n, e))} ON CONFLICT (${s.csv(c)}) DO NOTHING RETURNING ${h(e, s)}`, u = i ? t.provideService(l, this.sql.transactionService, i) : l, d = await this.runtime.runPromise(u), f = _(d, e, "sqlite")[0];
+		if (f) return await this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: f
+		}, a, i, o), {
+			row: f,
+			outcome: "inserted"
+		};
+		let p = await this.findByConflict(e, n, r.conflictColumns, i);
+		if (!p) throw Error(`SqliteStore.insertIgnore: conflict fired but no existing row found in '${e}'`);
+		return {
+			row: p,
+			outcome: "ignored"
+		};
+	}
+	async findByConflict(e, n, r, i) {
+		if (r.length === 0) return;
+		let a = this.sql, o = X(Object.fromEntries(r.map((e) => [e, n[e]])), e), s = r.map((e) => a`${a(e)} = ${o[e]}`), c = a`SELECT ${h(e, a)} FROM ${a(this.nsT(e))} WHERE ${a.and(s)} LIMIT 1`, l = i ? t.provideService(c, this.sql.transactionService, i) : c, u = await this.runtime.runPromise(l);
+		return _(u, e, "sqlite")[0];
+	}
+	query(e) {
+		return this.runWithEager(e, null);
+	}
+	raw(e, t) {
+		return this.rawOn(e, null);
+	}
+	rawOn(e, n) {
+		let r = m(e, this.sql), i = n ? t.provideService(r, this.sql.transactionService, n) : r;
+		return E(this.systemName, "raw", () => this.runtime.runPromise(i));
+	}
+	async runWithEager(e, n) {
+		if (!x(e)) return this.executeQuery(e, n);
+		let r = this.namespace === null ? d(e, this.sql, "sqlite") : null;
+		if (r !== null) try {
+			let e = n ? t.provideService(r.fragment, this.sql.transactionService, n) : r.fragment, i = await E(this.systemName, "select", () => this.runtime.runPromise(e));
+			return r.decode(i);
+		} catch (t) {
+			if (t instanceof a) throw t;
+			this.reportEagerFallback({
+				dialect: this.systemName,
+				table: e.table,
+				reason: "execute-failed",
+				error: t
+			});
+		}
+		else this.reportEagerFallback({
+			dialect: this.systemName,
+			table: e.table,
+			reason: "not-compilable"
+		});
+		let i = await this.executeQuery(e, n);
+		return o(i, e.eager, e.sourceTable ?? M(e.table), (e) => this.executeQuery(e, n));
+	}
+	getInternalRunWithEager() {
+		return (e, t) => this.runWithEager(e, t);
+	}
+	localWrite(e, t, n) {
+		let r = (e) => j(t) ? this.writeWithRecorders(n, e) : n(e, null, null);
+		return E(this.systemName, e, () => V(r));
+	}
+	async writeWithRecorders(e, n) {
+		let r = [], a = this.sql, o = await this.runtime.runPromise(a.withTransaction(t.flatMap(t.serviceOption(this.sql.transactionService), (a) => i.isNone(a) ? t.fail(/* @__PURE__ */ Error("SqliteStore.write: TransactionConnection missing.")) : t.tryPromise({
+			try: () => e(n, a.value, r),
+			catch: (e) => e
+		}))));
+		return v(r, (e) => this.emitChange(e)), o;
+	}
+	insert(e, t) {
+		return this.localWrite("insert", e, (n, r, i) => this.executeInsert(e, t, r, i, n));
+	}
+	insertMany(e, t) {
+		return this.localWrite("insert", e, (n, r, i) => this.executeInsertMany(e, t, r, i, 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(e, n, r, i, a, o) {
+		let s = this.sql, c = p(J(r.where), s, this.namespace, e), l = s`UPDATE ${s(this.nsT(e))} SET ${s.update(X(n, e))} WHERE ${c} RETURNING ${h(e, s)}`, u = i ? t.provideService(l, this.sql.transactionService, i) : l, d = await E(this.systemName, "update", () => this.runtime.runPromise(u));
+		for (let t of _(d, e, "sqlite")) await this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: t
+		}, a, i, o);
+		return d.length;
+	}
+	async executeDeleteMany(e, n, r, i, a) {
+		let o = this.sql, s = p(J(n.where), o, this.namespace, e), c = o`DELETE FROM ${o(this.nsT(e))} WHERE ${s} RETURNING ${h(e, o)}`, l = r ? t.provideService(c, this.sql.transactionService, r) : c, u = await E(this.systemName, "delete", () => this.runtime.runPromise(l));
+		for (let t of _(u, e, "sqlite")) await this.routeEvent({
+			table: e,
+			op: "delete",
+			old: t,
+			new: null
+		}, i, r, a);
+		return u.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));
+	}
+	emitChange(e) {
+		this.emitter.emit("change", e);
+	}
+	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, n = new Set(e), r = await this.runtime.runPromise(t`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`), i = [];
+		for (let e of r) {
+			if (n.has(e.name)) continue;
+			let r = await this.runtime.runPromise(t`${t.unsafe(`PRAGMA foreign_key_list(${k(e.name, "sqlite")})`)}`).catch(() => []);
+			for (let t of r) n.has(t.table) && i.push({
+				from: e.name,
+				column: t.from,
+				to: t.table
+			});
+		}
+		return i;
+	}
+	async emptyTablesOn(e, n) {
+		if (e.length === 0) return;
+		let r = this.sql, i = (e) => this.nsT(e), a = t.acquireUseRelease(r.unsafe("PRAGMA defer_foreign_keys = ON"), () => t.forEach(e, (e) => r`DELETE FROM ${r(i(e))}`, { discard: !0 }), () => t.orDie(t.ignore(r.unsafe("PRAGMA defer_foreign_keys = OFF")))), o = n === null ? r.withTransaction(a) : t.provideService(a, this.sql.transactionService, n);
+		await this.runtime.runPromise(o);
+	}
+	transactionEndingFailure(e) {
+		return this.isRetryable(e);
+	}
+	async transactional(e) {
+		this.inflightTxns++;
+		try {
+			return await F({
+				...this.txnSpec("SqliteStore.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: this.systemName === "turso" ? "turso" : "sqlite",
+			withTransaction: (e) => this.sql.withTransaction(e),
+			transactionService: this.sql.transactionService,
+			runPromiseExit: (e) => this.runtime.runPromiseExit(e),
+			isRetryable: this.isRetryable,
+			wrapProgram: (e) => this.wrapTransaction(e),
+			span: {
+				name: "store.transactional",
+				attributes: {
+					"db.system": this.systemName,
+					"db.operation": "transaction"
+				}
+			}
+		};
+	}
+	onChange(e) {
+		return this.emitter.on("change", e), () => {
+			this.emitter.off("change", e);
+		};
+	}
+	injectExternalChange(e) {
+		S(e.table) && this.emitter.emit("change", b(e));
+	}
+	run(e) {
+		return this.runtime.runPromise(e);
+	}
+	async close(e = 5e3) {
+		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 && G.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 = T((e) => this.parent.transactionEndingFailure(e));
+	committed = !1;
+	constructor(e, t, n = void 0) {
+		this.parent = e, this.txn = t, this.attr = n;
+	}
+	savepoint(e) {
+		return P({
+			tracker: this.aborts,
+			name: `voltro_sp_${++this.savepointCounter}`,
+			spelling: "standard",
+			exec: (e) => this.parent.run(t.provideService(W.pipe(t.flatMap((t) => t.unsafe(e))), this.parent.transactionService, this.txn))
+		}, e);
+	}
+	savepointCounter = 0;
+	run(e) {
+		return this.aborts.track(() => this.parent.run(D(e, this.parent.transactionService, this.txn)));
+	}
+	abortedBy() {
+		return this.aborts.abortedBy();
+	}
+	raw(e, t) {
+		return this.aborts.track(() => this.parent.rawOn(e, this.txn));
+	}
+	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) {
+		return this.aborts.track(() => this.parent.getInternalExecuteInsertMany()(e, t, this.txn, this.events, this.attr));
+	}
+	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("SqliteStore.transactional: nested transactions are not supported. Mutations should execute a single top-level transaction."));
+	}
+	onChange(e) {
+		throw Error("SqliteTransactionalView.onChange: subscribing from inside a transaction is not supported.");
+	}
+	injectExternalChange(e) {
+		throw Error("SqliteTransactionalView.injectExternalChange: injecting external changes from inside a transaction is not supported.");
+	}
+	commitEvents() {
+		this.committed || (this.committed = !0, v(this.events, (e) => this.parent.emitChange(e)), this.events.length = 0);
+	}
+};
+//#endregion
+export { Z as SqliteStore, K as makeSqliteStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/sql-sqlite",
-  "version": "0.84.0",
+  "version": "0.86.0",
   "description": "SQLite dialect adapter for Voltro's cross-dialect DataStore (single-process; in-process change events).",
   "keywords": [
     "voltro",
@@ -33,13 +33,12 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@effect/sql": "^0.52.1",
-    "@effect/sql-sqlite-node": "^0.53.0",
-    "@voltro/database": "0.84.0",
-    "@voltro/logger": "0.84.0"
+    "@effect/sql-sqlite-node": "4.0.1",
+    "@voltro/database": "0.86.0",
+    "@voltro/logger": "0.86.0"
   },
   "peerDependencies": {
-    "effect": "^3.22.2"
+    "effect": "4.0.1"
   },
   "publishConfig": {
     "access": "public"