@voltro/sql-sqlite 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,187 @@
+import { ChangeEvent } from '@voltro/database';
+import { ChangeStrategy } from '@voltro/database';
+import { ConfigError } from 'effect';
+import { ConfigError as ConfigError_2 } from 'effect/ConfigError';
+import { ConnectionConfig } from '@voltro/database';
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { EventEmitter } from 'node:events';
+import { Layer } from 'effect';
+import { ManagedRuntime } from 'effect';
+import { Predicate } from '@voltro/database';
+import { QueryDescriptor } from '@voltro/database';
+import { QueryNamespace } from '@voltro/database';
+import { RawSqlFragment } from '@voltro/database/sql';
+import { RetryDecision } from '@voltro/database';
+import { Row } from '@voltro/database';
+import { SqlClient } from '@effect/sql';
+import { SqlClient as SqlClient_2 } from '@effect/sql/SqlClient';
+import { SqlDialect } from '@voltro/database';
+import { SqlError } from '@effect/sql';
+import { SqlError as SqlError_2 } from '@effect/sql/SqlError';
+import { SqliteClient } from '@effect/sql-sqlite-node';
+import { TransactionConnection } from '@effect/sql/SqlClient';
+
+/**
+ * Parse a `ConnectionConfig` into the sqlite-specific `SqliteConnection`
+ * shape. Sqlite is the simplest dialect — it only needs a filename.
+ *
+ * Resolution order:
+ *   1. `url` — accepted forms documented at file head
+ *   2. `database` — treated as the filename
+ *   3. Throw with a clear message
+ */
+export declare const connectionFromConfig: (config: ConnectionConfig) => SqliteConnection;
+
+export declare const makeSqliteSqlLayer: (options: SqliteConnection) => SqliteSqlLayer;
+
+export declare const makeSqliteSqlLayerFromConfig: (config: ConnectionConfig) => SqliteSqlLayer;
+
+export declare const makeSqliteStore: (options: SqliteStoreOptions) => Promise<SqliteStore>;
+
+export { SqliteClient }
+
+export declare interface SqliteConnection {
+    /** Absolute or `file:` path, or `:memory:` for ephemeral. */
+    readonly filename: string;
+    readonly readonly?: boolean;
+}
+
+export declare const sqliteDialect: SqlDialect;
+
+export declare const sqliteRetryFilter: (err: unknown) => RetryDecision;
+
+/**
+ * The connection layer this package produces: the driver's client layer plus
+ * the per-connection `PRAGMA foreign_keys = ON` tap (which adds `SqlError`
+ * to the error channel — matching the cross-dialect `sqlLayer` shape in
+ * `@voltro/database`).
+ */
+declare type SqliteSqlLayer = Layer.Layer<SqliteClient.SqliteClient | SqlClient_2, ConfigError_2 | SqlError_2>;
+
+export declare class SqliteStore implements DataStore {
+    private readonly sql;
+    private readonly runtime;
+    private readonly namespace;
+    private readonly isRetryable;
+    private readonly systemName;
+    private readonly wrapTransaction;
+    private readonly emitter;
+    private inflightTxns;
+    constructor(sql: SqlClient.SqlClient, runtime: ManagedRuntime.ManagedRuntime<SqlClient.SqlClient, never>, namespace?: QueryNamespace, sharedEmitter?: EventEmitter, isRetryable?: (e: unknown) => boolean, systemName?: string, wrapTransaction?: <A, E, R>(e: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>);
+    /**
+     * Bind a per-request tenant namespace, returning a view that qualifies
+     * every table reference to `<namespace>.<table>`. The view SHARES this
+     * store's connection + emitter (sqlite is single-process). The
+     * namespace's attached database must already exist — see
+     * `attachNamespace` / the migrator's namespace fan-out.
+     */
+    withNamespace(namespace: string | null): DataStore;
+    /** Qualify a table to this view's namespace (no-op when unset). */
+    private nsT;
+    /**
+     * Provision a tenant's namespace: `ATTACH DATABASE '<file>' AS
+     * <namespace>`. Idempotent enough for first-use lazy-create — sqlite
+     * errors if the alias is already attached, which the caller treats as
+     * "already provisioned". The file path defaults to `<namespace>.db`
+     * beside the main database.
+     */
+    attachNamespace(namespace: string, file?: string): Promise<void>;
+    private executeQuery;
+    private executeInsert;
+    private executeUpdate;
+    private executeInsertMany;
+    private executePatchJson;
+    private executeDelete;
+    private routeEvent;
+    private executeUpsert;
+    private executeInsertIgnore;
+    private findByConflict;
+    query(descriptor: QueryDescriptor): Promise<ReadonlyArray<Row>>;
+    raw<T extends object = Row>(fragment: RawSqlFragment, _opts?: {
+        dependsOn?: ReadonlyArray<string>;
+    }): Promise<ReadonlyArray<T>>;
+    private runWithEager;
+    getInternalRunWithEager(): (d: QueryDescriptor, txn: TxnContext | null) => Promise<ReadonlyArray<Row>>;
+    insert(table: string, row: Row): Promise<Row>;
+    insertMany(table: string, rows: ReadonlyArray<Row>): Promise<ReadonlyArray<Row>>;
+    patchJson(table: string, primaryKey: string, path: string, value: unknown): Promise<Row | null>;
+    update(table: string, primaryKey: string, patch: Readonly<Record<string, unknown>>): Promise<Row | null>;
+    delete(table: string, primaryKey: string): Promise<boolean>;
+    updateMany(table: string, patch: Readonly<Record<string, unknown>>, options: {
+        where: Predicate;
+    }): Promise<number>;
+    deleteMany(table: string, options: {
+        where: Predicate;
+    }): Promise<number>;
+    upsert(table: string, row: Row, options: {
+        conflictColumns: ReadonlyArray<string>;
+        update?: ReadonlyArray<string> | ((existing: Row) => Readonly<Record<string, unknown>>);
+    }): Promise<Row>;
+    insertIgnore(table: string, row: Row, options: {
+        conflictColumns: ReadonlyArray<string>;
+    }): Promise<Row>;
+    /* Excluded from this release type: emitChange */
+    /* Excluded from this release type: getInternalExecuteQuery */
+    /* Excluded from this release type: getInternalExecuteInsert */
+    /* Excluded from this release type: getInternalExecuteInsertMany */
+    /* Excluded from this release type: getInternalExecutePatchJson */
+    /* Excluded from this release type: getInternalExecuteUpdate */
+    /* Excluded from this release type: getInternalExecuteDelete */
+    /* Excluded from this release type: getInternalExecuteUpsert */
+    /* Excluded from this release type: getInternalExecuteInsertIgnore */
+    /**
+     * Run `work` inside a real transaction. Same architecture as the
+     * postgres impl: per-call view + captured TxnContext + events buffer;
+     * commit drains, throw discards. Each attempt builds a FRESH view, so a
+     * retried attempt cannot double-emit (events drain only on success).
+     *
+     * Retry uses the injected `isRetryable` predicate — sqlite's
+     * `SQLITE_BUSY` / `SQLITE_LOCKED`, or (Turso dialect) the MVCC
+     * `"Write-write conflict"` from `BEGIN CONCURRENT`. A conflict can
+     * surface from the COMMIT, which `@effect/sql` runs as `Effect.orDie`
+     * → it arrives as a DEFECT, not a typed failure, and `Effect.retry`
+     * does not retry defects. So we promote a retryable defect back to a
+     * typed failure before the schedule sees it (and re-die on a genuine
+     * defect, preserving crash semantics). Without this the Turso MVCC
+     * retry — the whole point of `BEGIN CONCURRENT` — would never fire.
+     */
+    transactional<T>(work: (tx: DataStore) => Promise<T>): Promise<T>;
+    onChange(listener: (event: ChangeEvent) => void): () => void;
+    /** Cross-instance reactivity seam — emit an externally-sourced event to
+     *  local subscribers without re-persisting. sqlite is single-process so
+     *  this is unused in practice, but the seam keeps the DataStore contract
+     *  uniform. See `DataStore.injectExternalChange`. */
+    injectExternalChange(event: ChangeEvent): void;
+    run<A, E>(effect: Effect.Effect<A, E, SqlClient.SqlClient>): Promise<A>;
+    close(gracePeriodMs?: number): Promise<void>;
+    /** Liveness probe — `SELECT 1`. Rejects if the pool can't answer. */
+    ping(): Promise<void>;
+}
+
+export declare interface SqliteStoreOptions {
+    readonly sqlLayer: Layer.Layer<SqlClient.SqlClient, ConfigError.ConfigError | SqlError.SqlError, never>;
+    readonly tracerLayer?: Layer.Layer<never, never, never>;
+    /** Accepted for cross-dialect symmetry; ignored (always in-process). */
+    readonly changeStrategy?: ChangeStrategy;
+    /**
+     * Predicate deciding whether a failed transaction is a transient
+     * contention error worth retrying. Defaults to sqlite's busy/locked
+     * codes. The Turso dialect injects its own (matches the
+     * `"Write-write conflict"` message its MVCC `BEGIN CONCURRENT` raises).
+     */
+    readonly isRetryable?: (e: unknown) => boolean;
+    /** `db.system` span attribute on `store.transactional`. Default `'sqlite'`. */
+    readonly systemName?: string;
+    /**
+     * Wraps each `transactional()` program before it runs. The Turso dialect uses
+     * it to set a fiber flag that upgrades `BEGIN` → `BEGIN CONCURRENT` for the
+     * store's DML (DDL paths keep plain BEGIN). Default: identity (sqlite).
+     */
+    readonly wrapTransaction?: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}
+
+declare type TxnContext = Context.Tag.Service<typeof TransactionConnection>;
+
+export { }

package/dist/index.js

@@ -0,0 +1,376 @@
+import { SqliteClient as e } from "@effect/sql-sqlite-node";
+import { Config as t, Context as n, Effect as r, Layer as i, ManagedRuntime as a, Option 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, qualifyTable as y, requireTable as b } from "@voltro/database";
+//#region src/sqlLayer.ts
+var x = (r) => e.layerConfig({
+	filename: t.succeed(r.filename),
+	...r.readonly === void 0 ? {} : { readonly: t.succeed(r.readonly) }
+}).pipe(i.tap((t) => n.get(t, e.SqliteClient)`PRAGMA foreign_keys = ON`)), S = (e) => {
+	if (e.url) {
+		if (e.url === ":memory:") return { filename: ":memory:" };
+		if (e.url.startsWith("file:")) return { filename: e.url.slice(5) };
+		throw Error(`@voltro/sql-sqlite: unsupported url '${e.url}'. Accepted: 'file:./path.sqlite', 'file:/abs/path.sqlite', ':memory:'.`);
+	}
+	if (e.database) return { filename: e.database };
+	throw Error("@voltro/sql-sqlite: no filename supplied. Set DB_URL=file:./db.sqlite or DB_DATABASE=path/to/db.sqlite.");
+}, C = (e) => x(S(e)), w = /* @__PURE__ */ new Set([
+	"SQLITE_BUSY",
+	"SQLITE_LOCKED",
+	"5",
+	"6"
+]), T = (e) => {
+	let t = e;
+	for (let e = 0; e < 5 && typeof t == "object" && t; e++) {
+		let e = t.code;
+		if (typeof e == "string") return e;
+		if (typeof e == "number") return String(e);
+		t = t.cause;
+	}
+}, E = (e) => {
+	let t = T(e);
+	return t !== void 0 && w.has(t);
+}, D = (e) => E(e) ? "retry" : "noRetry", O = l({ scope: "voltro:sqlite" }), k = async (e) => {
+	let t = e.tracerLayer ? i.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, n = a.make(t);
+	return new M(await n.runPromise(u), n, null, void 0, e.isRetryable ?? E, e.systemName ?? "sqlite", e.wrapTransaction);
+}, A = (e) => e, j = (e) => {
+	if (typeof e != "object" || !e) return e;
+	let t = {};
+	for (let [n, r] of Object.entries(e)) r instanceof Date ? t[n] = r.toISOString() : typeof r == "boolean" ? t[n] = +!!r : t[n] = r;
+	return t;
+}, M = class e {
+	sql;
+	runtime;
+	namespace;
+	isRetryable;
+	systemName;
+	wrapTransaction;
+	emitter;
+	inflightTxns = 0;
+	constructor(e, t, n = null, r, i = E, a = "sqlite", o = A) {
+		this.sql = e, this.runtime = t, this.namespace = n, this.isRetryable = i, this.systemName = a, this.wrapTransaction = o, this.emitter = r ?? new c();
+	}
+	withNamespace(t) {
+		return t === this.namespace ? this : new e(this.sql, this.runtime, t, this.emitter, this.isRetryable, this.systemName, this.wrapTransaction);
+	}
+	nsT(e) {
+		return y(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, t) {
+		let n = g(e, this.sql, this.namespace), i = t ? r.provideService(n, d, t) : n;
+		return _(await this.runtime.runPromise(i), e.table, "sqlite");
+	}
+	async executeInsert(e, t, n, i) {
+		let a = this.sql, o = a`INSERT INTO ${a(this.nsT(e))} ${a.insert(j(t))} RETURNING *`, s = n ? r.provideService(o, d, n) : o, c = (await this.runtime.runPromise(s))[0];
+		if (!c) throw Error(`SqliteStore.insert: no row returned for table '${e}'`);
+		return this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: c
+		}, i), c;
+	}
+	async executeUpdate(e, t, n, i, a) {
+		let o = this.sql, s = o`UPDATE ${o(this.nsT(e))} SET ${o.update(j(n))} WHERE ${o("id")} = ${t} RETURNING *`, c = i ? r.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, n, i) {
+		if (t.length === 0) return [];
+		let a = this.sql, o = t.map((e) => j(e)), s = a`INSERT INTO ${a(this.nsT(e))} ${a.insert(o)} RETURNING *`, c = n ? r.provideService(s, d, n) : s, l = await this.runtime.runPromise(c);
+		for (let t of l) this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: t
+		}, i);
+		return l;
+	}
+	async executePatchJson(e, t, n, i, a, o) {
+		let s = this.sql, c = n.split("."), l = c[0], u = c.slice(1), f = JSON.stringify(i ?? null), p = u.length === 0 ? s`${s(l)} = json_patch(COALESCE(${s(l)}, '{}'), json(${f}))` : s`${s(l)} = json_set(COALESCE(${s(l)}, '{}'), ${`$.${u.join(".")}`}, json(${f}))`, m = s`UPDATE ${s(this.nsT(e))} SET ${p} WHERE ${s("id")} = ${t} RETURNING *`, h = a ? r.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, n, i) {
+		let a = this.sql, o = a`DELETE FROM ${a(this.nsT(e))} WHERE ${a("id")} = ${t} RETURNING *`, s = n ? r.provideService(o, d, n) : 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.emitter.emit("change", e) : t.push(e);
+	}
+	async executeUpsert(e, t, n, i, a) {
+		if (typeof n.update == "function") {
+			let r = await this.findByConflict(e, t, n.conflictColumns, i);
+			return r ? await this.executeUpdate(e, r.id, n.update(r), i, a) ?? r : this.executeInsert(e, t, i, a);
+		}
+		let o = this.sql, s = n.conflictColumns.map((e) => o`${o(e)}`), c = Object.keys(t).filter((e) => t[e] !== void 0), l = n.update === void 0 ? c.filter((e) => e !== "id" && !n.conflictColumns.includes(e)) : n.update, u = l.length > 0 ? o.csv(l.map((e) => o`${o(e)} = excluded.${o(e)}`)) : o`${o(n.conflictColumns[0])} = excluded.${o(n.conflictColumns[0])}`, f = o`INSERT INTO ${o(this.nsT(e))} ${o.insert(j(t))} ON CONFLICT (${o.csv(s)}) DO UPDATE SET ${u} RETURNING *`, p = i ? r.provideService(f, d, i) : f, m = (await this.runtime.runPromise(p))[0];
+		if (!m) throw Error(`SqliteStore.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, n, i, a) {
+		let o = this.sql, s = n.conflictColumns.map((e) => o`${o(e)}`), c = o`INSERT INTO ${o(this.nsT(e))} ${o.insert(j(t))} ON CONFLICT (${o.csv(s)}) DO NOTHING RETURNING *`, l = i ? r.provideService(c, d, i) : c, u = (await this.runtime.runPromise(l))[0];
+		if (u) return this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: u
+		}, a), u;
+		let f = await this.findByConflict(e, t, n.conflictColumns, i);
+		if (!f) throw Error(`SqliteStore.insertIgnore: conflict fired but no existing row found in '${e}'`);
+		return f;
+	}
+	async findByConflict(e, t, n, i) {
+		if (n.length === 0) return;
+		let a = this.sql, o = n.map((e) => a`${a(e)} = ${t[e]}`), s = a`SELECT * FROM ${a(this.nsT(e))} WHERE ${a.and(o)} LIMIT 1`, c = i ? r.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 (!v(e)) return this.executeQuery(e, t);
+		let n = this.namespace === null ? p(e, this.sql, "sqlite") : null;
+		if (n !== null) try {
+			let e = t ? r.provideService(n.fragment, d, t) : n.fragment, i = await this.runtime.runPromise(e);
+			return n.decode(i);
+		} catch (e) {
+			O.warn("sqlite JSON-agg eager-load failed; falling back to walker", { err: e });
+		}
+		return f(await this.executeQuery(e, t), e.eager, e.sourceTable ?? b(e.table), (e) => this.executeQuery(e, t));
+	}
+	getInternalRunWithEager() {
+		return (e, t) => this.runWithEager(e, t);
+	}
+	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(j(t))} 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;
+	}
+	async deleteMany(e, t) {
+		let n = this.sql, r = m(t.where, n, this.namespace), i = n`DELETE FROM ${n(this.nsT(e))} WHERE ${r} RETURNING *`, 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);
+	}
+	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);
+	}
+	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, n = r.suspend(() => {
+			let n = ++t;
+			return this.sql.withTransaction(r.flatMap(r.serviceOption(d), (t) => {
+				if (o.isNone(t)) return r.fail(/* @__PURE__ */ Error("SqliteStore.transactional: TransactionConnection unexpectedly missing."));
+				let i = new N(this, t.value);
+				return r.tryPromise({
+					try: () => e(i).then((e) => ({
+						result: e,
+						view: i,
+						attempt: n
+					})),
+					catch: (e) => e
+				});
+			})).pipe(r.catchAllDefect((e) => this.isRetryable(e) ? r.fail(e) : r.die(e)));
+		}), i = s.exponential("10 millis").pipe(s.compose(s.recurs(3)), s.whileInput(this.isRetryable)), a = n.pipe(r.retry(i), r.withSpan("store.transactional", { attributes: {
+			"db.system": this.systemName,
+			"db.operation": "transaction"
+		} }));
+		try {
+			let e = await this.runtime.runPromise(this.wrapTransaction(a));
+			return e.view.commitEvents(), e.result;
+		} finally {
+			this.inflightTxns--;
+		}
+	}
+	onChange(e) {
+		return this.emitter.on("change", e), () => {
+			this.emitter.off("change", e);
+		};
+	}
+	injectExternalChange(e) {
+		this.emitter.emit("change", {
+			...e,
+			origin: "injected"
+		});
+	}
+	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 && O.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`);
+	}
+}, N = 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("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() {
+		if (!this.committed) {
+			this.committed = !0;
+			for (let e of this.events) this.parent.emitChange(e);
+			this.events.length = 0;
+		}
+	}
+}, P = {
+	id: "sqlite",
+	makeSqlLayer: (e) => C(e),
+	makeStore: (e) => k(e),
+	compileContains: (e, t, n) => n`${e} LIKE ${`%${t.replace(/[\\%_]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
+	retryFilter: D
+};
+//#endregion
+export { e as SqliteClient, S as connectionFromConfig, x as makeSqliteSqlLayer, C as makeSqliteSqlLayerFromConfig, k as makeSqliteStore, P as sqliteDialect, D as sqliteRetryFilter };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@voltro/sql-sqlite",
+  "version": "0.1.0",
+  "description": "SQLite dialect adapter for Voltro's cross-dialect DataStore (single-process; in-process change events).",
+  "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-sqlite-node": "^0.52.0",
+    "@voltro/database": "0.1.0",
+    "@voltro/logger": "0.1.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}