@voltro/runtime 0.85.0 → 0.87.0

package/dist/dataStore.js

@@ -0,0 +1,712 @@
+import { memoryQueryJoins as e } from "./memoryQueryJoins.js";
+import { memoryOutputColumns as t, memoryRowKey as n, memorySetRows as r } from "./memorySetOperations.js";
+import { applyMemoryColumnDefaults as i } from "./memoryColumnDefaults.js";
+import { Effect as a } from "effect";
+import { applyJsonPatch as o, attachEagerLoads as s, attributionFields as c, collectSubqueries as l, compareDecimal as u, emitCommittedChanges as d, evaluatePredicate as f, externalChangeEvent as p, getTable as m, hasEagerLoads as h, isTableReactive as g, jsonPatchAssignments as _, preparePredicate as v, raiseChangeListenerCeiling as y, requireTable as b, rowKeyColumns as x, settleTransactionExit as S, stampGeneratedId as C, transactionRetrySchedule as w, upsertUpdatePatch as T, upsertUpdateValues as E } from "@voltro/database";
+import { EventEmitter as D } from "node:events";
+//#region src/dataStore.ts
+var O = (e, t, n, r = m(n)?.fields) => t.length === 0 ? e : [...e].sort((e, n) => {
+	for (let i of t) {
+		let t = e[i.column], a = n[i.column];
+		if (t === a || t instanceof Date && a instanceof Date && t.getTime() === a.getTime()) continue;
+		if (t == null) return i.direction === "asc" ? -1 : 1;
+		if (a == null) return i.direction === "asc" ? 1 : -1;
+		let o = r?.[i.column]?.type === "decimal" ? u(t, a) ?? 0 : t < a ? -1 : 1;
+		if (o !== 0) return i.direction === "asc" ? o : -o;
+	}
+	return 0;
+}), k = (e, t, n, r) => !e || f(e, t, n, r ? m(r)?.fields : void 0), A = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	if (!e) return n;
+	for (let r of l(e)) {
+		let e = t.get(r.descriptor.table) ?? /* @__PURE__ */ new Map(), i = A(r.descriptor.predicate, t), a = I(r.descriptor, e, t, i);
+		if (r.kind === "exists") n.set(r.descriptor, a.length);
+		else {
+			let e = r.descriptor.projection, t = /* @__PURE__ */ new Set();
+			if (e && e.length === 1) {
+				let n = e[0];
+				for (let e of a) t.add(e[n]);
+			} else for (let e of a) {
+				let n = Object.keys(e)[0];
+				n !== void 0 && t.add(e[n]);
+			}
+			n.set(r.descriptor, t);
+		}
+	}
+	return n;
+}, j = {
+	A: 4,
+	B: 2,
+	C: 1,
+	D: .5
+}, M = (e) => (typeof e == "string" ? e : e == null ? "" : JSON.stringify(e)).toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [], N = (e) => {
+	let t = {
+		children: /* @__PURE__ */ new Map(),
+		terms: []
+	};
+	for (let n = 0; n < e.length; n++) {
+		let r = t, i = e[n];
+		for (let e = 0; e < i.length; e++) {
+			let t = i[e], n = r.children.get(t);
+			n === void 0 && (n = {
+				children: /* @__PURE__ */ new Map(),
+				terms: []
+			}, r.children.set(t, n)), r = n;
+		}
+		r.terms.push(n);
+	}
+	return t;
+}, P = (e, t, n) => {
+	let r = Array(n).fill(0);
+	for (let n of t) {
+		let t = e;
+		for (let e = 0; e < n.length && (t = t.children.get(n[e]), t !== void 0); e++) for (let e of t.terms) r[e] = r[e] + 1;
+	}
+	return r;
+}, F = (e, t) => {
+	let n = M(t.query);
+	if (n.length === 0) return [];
+	let r = [], i;
+	for (let a of e) {
+		let e = 0, o = /* @__PURE__ */ new Set();
+		for (let r of t.columns) {
+			let s = M(a[r]), c = j[t.weights?.[r] ?? ""] ?? 1;
+			i === void 0 && n.length >= 16 && s.length >= 512 && (i = N(n));
+			let l = i === void 0 ? void 0 : P(i, s, n.length);
+			for (let t = 0; t < n.length; t++) {
+				let r = n[t], i = l?.[t];
+				if (i === void 0) {
+					i = 0;
+					for (let e of s) e.startsWith(r) && (i += 1);
+				}
+				i > 0 && (o.add(r), e += i * c);
+			}
+		}
+		o.size === n.length && r.push(t.rank === void 0 ? a : {
+			...a,
+			[t.rank.alias]: e
+		});
+	}
+	return r;
+}, I = (i, a, o = /* @__PURE__ */ new Map(), s = null) => {
+	for (let e of [i.take, i.skip]) if (e !== void 0 && (!Number.isSafeInteger(e) || e < 0)) throw Error("Query limit and offset must be non-negative safe integers");
+	if (i.setOp && i.setOp.queries.length >= 2) {
+		let e = r(i, (e) => I(e, o.get(e.table) ?? /* @__PURE__ */ new Map(), o)), n = O(e, i.order, i.table, t(i, e)), a = i.skip === void 0 ? n : n.slice(i.skip);
+		return i.take === void 0 ? a : a.slice(0, i.take);
+	}
+	let c = s ?? A(i.predicate, o), l = i.alias !== void 0 || (i.joins?.length ?? 0) > 0 || i.joinedProjection !== void 0 ? e(i, [...a.values()], o, (e) => A(e, o)) : void 0, u = i.predicate === void 0 ? void 0 : v(i.predicate, c, l?.columns ?? m(i.table)?.fields), d = l?.rows ?? [...a.values()], f = u === void 0 ? d : d.filter((e) => u(e) ?? !0);
+	if (i.aggregations && i.aggregations.length > 0) {
+		let e = L(f, i.aggregations, i.groupBy, i.table, l?.columns);
+		if (!i.having) return e;
+		let t = A(i.having, o);
+		return e.filter((e) => k(i.having, e, t));
+	}
+	let p = O(i.fullTextSearch === void 0 ? f : F(f, i.fullTextSearch), i.order.map((e) => ({
+		...e,
+		column: i.joinedProjection?.find((t) => t.outputKey === e.column)?.source ?? e.column
+	})), i.table, l?.columns), h = i.fullTextSearch?.rank, g = h?.order === !0 ? p.sort((e, t) => Number(t[h.alias] ?? 0) - Number(e[h.alias] ?? 0)) : p, _ = l?.project ?? (i.projection ? (e) => Object.fromEntries(i.projection.map((t) => [t, e[t]])) : (e) => e), y = g;
+	if (i.distinct) {
+		let e = t(i, g), r = Object.keys(e), a = /* @__PURE__ */ new Set();
+		y = g.filter((t) => {
+			let i = n(_(t), r, e);
+			return !a.has(i) && (a.add(i), !0);
+		});
+	}
+	let b = i.skip ? y.slice(i.skip) : y;
+	return (i.take === void 0 ? b : b.slice(0, i.take)).map(_);
+}, L = (e, t, n, r, i = m(r)?.fields) => {
+	let a = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		let e = {};
+		if (n) for (let r of n) e[r] = t[r];
+		let r = n ? n.map((e) => String(t[e] ?? "null")).join("\0") : "", i = a.get(r);
+		i || (i = {
+			keyVals: e,
+			rows: []
+		}, a.set(r, i)), i.rows.push(t);
+	}
+	a.size === 0 && !n && a.set("", {
+		keyVals: {},
+		rows: []
+	});
+	let o = [];
+	for (let e of a.values()) {
+		let n = { ...e.keyVals };
+		for (let r of t) n[r.alias] = B(r, e.rows, r.column === void 0 ? void 0 : i?.[r.column]?.type, r.column === void 0 ? void 0 : i?.[r.column]?.scale);
+		o.push(n);
+	}
+	return o;
+}, R = /^-?\d+$/, z = (e, t) => {
+	let n = !1;
+	for (let r of e) {
+		let e = r[t];
+		if (e != null) {
+			if (typeof e != "string" || !R.test(e)) return !1;
+			n = !0;
+		}
+	}
+	return n;
+}, B = (e, t, n, r) => {
+	if (n === void 0 && (e.op === "sum" || e.op === "avg") && e.column !== void 0 && z(t, e.column) && (n = "bigint"), n === "decimal" && (e.op === "sum" || e.op === "avg")) {
+		let n = t.map((t) => t[e.column]).filter((e) => e != null).map(String);
+		if (n.length === 0) return null;
+		if (e.op === "avg") return n.reduce((e, t) => e + Number(t), 0) / n.length;
+		let i = r ?? Math.max(0, ...n.map((e) => (e.split(".")[1] ?? "").length)), a = n.reduce((e, t) => {
+			let n = t.startsWith("-"), [r = "0", a = ""] = t.replace(/^[-+]/, "").split("."), o = BigInt((r || "0") + a.slice(0, i).padEnd(i, "0"));
+			return e + (n ? -o : o);
+		}, 0n), o = (a < 0n ? -a : a).toString().padStart(i + 1, "0");
+		return (a < 0n ? "-" : "") + (i === 0 ? o : `${o.slice(0, -i)}.${o.slice(-i)}`);
+	}
+	if (n === "bigint" && (e.op === "sum" || e.op === "avg")) {
+		let n = 0n, r = 0;
+		for (let i of t) {
+			let t = i[e.column];
+			t != null && (n += BigInt(t), r++);
+		}
+		return r === 0 ? null : e.op === "sum" ? String(n) : Number(n) / r;
+	}
+	switch (e.op) {
+		case "column": {
+			let n = t[0];
+			return n === void 0 ? null : n[e.column] ?? null;
+		}
+		case "count": return e.column === void 0 ? t.length : t.reduce((t, n) => t + +(n[e.column] !== null && n[e.column] !== void 0), 0);
+		case "count-distinct": {
+			let n = /* @__PURE__ */ new Set();
+			for (let r of t) {
+				let t = r[e.column];
+				t != null && n.add(t);
+			}
+			return n.size;
+		}
+		case "sum": {
+			let n = 0, r = !1;
+			for (let i of t) {
+				let t = i[e.column];
+				typeof t == "number" && (n += t, r = !0);
+			}
+			return r ? n : null;
+		}
+		case "avg": {
+			let n = 0, r = 0;
+			for (let i of t) {
+				let t = i[e.column];
+				typeof t == "number" && (n += t, r++);
+			}
+			return r > 0 ? n / r : null;
+		}
+		case "min":
+		case "max": {
+			let r = null;
+			for (let i of t) {
+				let t = i[e.column];
+				if (t == null) continue;
+				if (r === null) {
+					r = t;
+					continue;
+				}
+				if (n === "decimal" || n === "bigint") {
+					let n = u(t, r);
+					n !== null && (e.op === "min" && n < 0 || e.op === "max" && n > 0) && (r = t);
+					continue;
+				}
+				let a = t instanceof Date ? t.getTime() : t, o = r instanceof Date ? r.getTime() : r, s = e.op === "min";
+				(s && a < o || !s && a > o) && (r = t);
+			}
+			return r;
+		}
+		default: throw Error(`computeAggregates: unknown op '${e.op}'`);
+	}
+}, V = (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	for (let e of t.values()) for (let t of Object.keys(e)) n.add(t);
+	return {
+		table: e,
+		columns: [...n],
+		rowCount: t.size
+	};
+}, H = "\0", U = (e, t) => e === null ? t : `${e}${H}${t}`, W = class extends Error {
+	constructor() {
+		super("InMemoryDataStore.transactional: concurrent table change; transaction attempt was discarded."), this.name = "MemoryTransactionConflict";
+	}
+}, G = (e, t) => {
+	if (typeof t == "string" || typeof t == "number") return e.has(String(t)) ? String(t) : void 0;
+	let n = x(t);
+	for (let [t, r] of e) if (n.every(([e, t]) => r[e] === t)) return t;
+}, K = /* @__PURE__ */ new WeakSet(), q = class e {
+	#e;
+	#t;
+	#n;
+	#r(e, t = !0) {
+		t && this.#l(this.#c(e.table)), g(e.table) && this.#n.emit("change", {
+			...c(),
+			...e
+		});
+	}
+	#i(e, t = !1) {
+		if (t) for (let t of e) this.#l(this.#c(t.table));
+		let n = e.filter((e) => g(e.table)).map((e) => ({
+			...c(),
+			...e
+		}));
+		d(n, (e) => this.#n.emit("change", e));
+	}
+	#a;
+	#o;
+	static #s(t, n) {
+		let r = new e(void 0, n);
+		return r.#e = t.tables, r.#t = t.revisions, r.#n = t.emitter, r.#a = t.numericCounters, r;
+	}
+	constructor(e, t = null) {
+		if (this.#o = t, this.#e = /* @__PURE__ */ new Map(), this.#t = /* @__PURE__ */ new Map(), this.#n = new D(), y(this.#n), this.#a = /* @__PURE__ */ new Map(), e) for (let [n, r] of Object.entries(e)) {
+			let e = /* @__PURE__ */ new Map(), i = 0n;
+			for (let [t, n] of r.entries()) {
+				let r = n.id, a = r == null ? `__voltro_seed_${t}` : String(r);
+				if (e.set(a, n), r != null) try {
+					let e = BigInt(r);
+					e > i && (i = e);
+				} catch {}
+			}
+			let a = U(t, n);
+			this.#e.set(a, e), i > 0n && this.#a.set(a, i);
+		}
+	}
+	withNamespace(t) {
+		return t === this.#o ? this : e.#s({
+			tables: this.#e,
+			revisions: this.#t,
+			emitter: this.#n,
+			numericCounters: this.#a
+		}, t);
+	}
+	#c(e) {
+		return U(this.#o, e);
+	}
+	#l(e) {
+		this.#t.set(e, (this.#t.get(e) ?? 0n) + 1n);
+	}
+	#u(e = this.#e) {
+		let t = /* @__PURE__ */ new Map(), n = this.#o === null ? null : `${this.#o}${H}`;
+		for (let [r, i] of e) n === null ? r.includes(H) || t.set(r, i) : r.startsWith(n) && t.set(r.slice(n.length), i);
+		return t;
+	}
+	#d(e) {
+		let t = this.#c(e), n = this.#e.get(t);
+		return n || (n = /* @__PURE__ */ new Map(), this.#e.set(t, n)), K.has(n) && (n = new Map(n), this.#e.set(t, n)), n;
+	}
+	storedTables() {
+		return [...this.#u()].map(([e, t]) => V(e, t));
+	}
+	integrityQuery(e) {
+		return this.query(e);
+	}
+	async query(e) {
+		let t = I(e, this.#e.get(this.#c(e.table)) ?? /* @__PURE__ */ new Map(), this.#u());
+		return h(e) ? s(t, e.eager, b(e.table), (e) => this.query(e)) : t;
+	}
+	async insert(e, t) {
+		t = i(e, C(e, t));
+		let n = m(e), r = (n?.fields)?.id?.idScheme, a = t;
+		if (a.id === void 0 && (n === void 0 || r !== void 0)) {
+			let n = this.#f(e);
+			a = {
+				...t,
+				id: n
+			};
+		}
+		let o = a.id === void 0 ? `__voltro_row_${this.#f(e)}` : String(a.id);
+		return this.#d(e).set(o, a), this.#r({
+			table: e,
+			op: "insert",
+			old: null,
+			new: a
+		}), a;
+	}
+	async insertMany(e, t, n) {
+		let r = [];
+		for (let n of t) r.push(await this.insert(e, n));
+		return n?.returning === "none" ? [] : r;
+	}
+	async patchJson(e, t, n, r, i) {
+		let a = _(t, n, i), s = this.#e.get(this.#c(e));
+		if (!s) return null;
+		let c = G(s, t), l = c === void 0 ? void 0 : s.get(c);
+		if (!l || c === void 0) return null;
+		let u = {
+			...o(l, n, r),
+			...a
+		};
+		return this.#d(e).set(c, u), this.#r({
+			table: e,
+			op: "update",
+			old: l,
+			new: u
+		}), u;
+	}
+	#f(e) {
+		let t = this.#c(e), n = (this.#a.get(t) ?? 0n) + 1n;
+		if (n > BigInt(2 ** 53 - 1)) throw RangeError("Numeric id must be a safe integer; use a string id scheme for larger identities");
+		return this.#a.set(t, n), Number(n);
+	}
+	async update(e, t, n) {
+		let r = this.#e.get(this.#c(e));
+		if (!r) return null;
+		let i = G(r, t), a = i === void 0 ? void 0 : r.get(i);
+		if (!a || i === void 0) return null;
+		let o = {
+			...a,
+			...n
+		};
+		return this.#d(e).set(i, o), this.#r({
+			table: e,
+			op: "update",
+			old: a,
+			new: o
+		}), o;
+	}
+	async delete(e, t) {
+		let n = this.#e.get(this.#c(e));
+		if (!n) return !1;
+		let r = G(n, t), i = r === void 0 ? void 0 : n.get(r);
+		return !i || r === void 0 ? !1 : (this.#d(e).delete(r), this.#r({
+			table: e,
+			op: "delete",
+			old: i,
+			new: null
+		}), !0);
+	}
+	async updateMany(e, t, n) {
+		let r = this.#e.get(this.#c(e));
+		if (!r) return 0;
+		let i = A(n.where, this.#u()), a = v(n.where, i, m(e)?.fields), o = 0, s = [];
+		for (let [n, i] of r) {
+			if (!a(i)) continue;
+			let r = {
+				...i,
+				...t
+			};
+			this.#d(e).set(n, r), s.push({
+				table: e,
+				op: "update",
+				old: i,
+				new: r
+			}), o++;
+		}
+		return this.#i(s, !0), o;
+	}
+	async deleteMany(e, t) {
+		let n = this.#e.get(this.#c(e));
+		if (!n) return 0;
+		let r = A(t.where, this.#u()), i = v(t.where, r, m(e)?.fields), a = [];
+		for (let [e, t] of n) i(t) && a.push([e, t]);
+		for (let [t, n] of a) this.#d(e).delete(t);
+		return this.#i(a.map(([, t]) => ({
+			table: e,
+			op: "delete",
+			old: t,
+			new: null
+		})), !0), a.length;
+	}
+	async upsert(e, t, n) {
+		E(n);
+		let r = this.#p(e, t, n.conflictColumns);
+		if (r) {
+			let i = T(t, r, n), a = Object.fromEntries(n.conflictColumns.map((e) => [e, r[e]]));
+			return await this.update(e, a, i) ?? r;
+		}
+		return this.insert(e, t);
+	}
+	async insertIgnore(e, t, n) {
+		return (await this.insertIgnoreWithOutcome(e, t, n)).row;
+	}
+	async insertIgnoreWithOutcome(e, t, n) {
+		let r = this.#p(e, t, n.conflictColumns);
+		return r ? {
+			row: r,
+			outcome: "ignored"
+		} : {
+			row: await this.insert(e, t),
+			outcome: "inserted"
+		};
+	}
+	#p(e, t, n) {
+		let r = this.#e.get(this.#c(e));
+		if (r && n.length !== 0) outer: for (let e of r.values()) {
+			for (let r of n) {
+				let n = e[r], i = t[r];
+				if (n !== i && !(n instanceof Date && i instanceof Date && n.getTime() === i.getTime())) continue outer;
+			}
+			return e;
+		}
+	}
+	async transactional(e) {
+		let t = a.tryPromise({
+			try: async () => {
+				let t = new J(this.#m());
+				try {
+					let n = await e(t);
+					return t.commit(), n;
+				} catch (e) {
+					throw t.discard(), e;
+				}
+			},
+			catch: (e) => e
+		});
+		return S(await a.runPromiseExit(t.pipe(a.retry(w((e) => e instanceof W)))));
+	}
+	onChange(e) {
+		return this.#n.on("change", e), () => {
+			this.#n.off("change", e);
+		};
+	}
+	injectExternalChange(e) {
+		this.#r(p(e), !1);
+	}
+	#m() {
+		let e = new Map(this.#e);
+		for (let t of e.values()) K.add(t);
+		let t = new Map(this.#t), n = /* @__PURE__ */ new Set();
+		return {
+			readTable: (t) => {
+				let r = this.#c(t);
+				return n.add(r), e.get(r);
+			},
+			listTables: () => [...this.#u(e).keys()],
+			commitOverlay: (e, r) => {
+				let i = /* @__PURE__ */ new Set();
+				for (let t of e.keys()) i.add(this.#c(t));
+				for (let e of r.keys()) i.add(this.#c(e));
+				let a = new Set(n);
+				for (let e of i) a.add(e);
+				for (let e of a) if ((t.get(e) ?? 0n) !== (this.#t.get(e) ?? 0n)) throw new W();
+				for (let [e, t] of r) {
+					if (!this.#e.get(this.#c(e))) continue;
+					let n = this.#d(e);
+					for (let e of t) n.delete(e);
+				}
+				for (let [t, n] of e) {
+					let e = this.#d(t);
+					for (let [t, r] of n) e.set(t, r);
+				}
+				for (let e of i) this.#l(e);
+			},
+			emit: (e) => this.#i(e),
+			allocateNumericId: (e) => this.#f(e)
+		};
+	}
+}, J = class {
+	parent;
+	overlay = /* @__PURE__ */ new Map();
+	tombstones = /* @__PURE__ */ new Map();
+	events = [];
+	settled = !1;
+	constructor(e) {
+		this.parent = e;
+	}
+	assertActive() {
+		if (this.settled) throw Error("InMemoryDataStore.transactional: transaction view is settled.");
+	}
+	async savepoint(e) {
+		this.assertActive();
+		let t = /* @__PURE__ */ new Map();
+		this.overlay.forEach((e, n) => {
+			t.set(n, new Map(e));
+		});
+		let n = /* @__PURE__ */ new Map();
+		this.tombstones.forEach((e, t) => {
+			n.set(t, new Set(e));
+		});
+		let r = this.events.length;
+		try {
+			return await e();
+		} catch (e) {
+			this.overlay.clear();
+			for (let [e, n] of t) this.overlay.set(e, n);
+			this.tombstones.clear();
+			for (let [e, t] of n) this.tombstones.set(e, t);
+			throw this.events.length = r, e;
+		}
+	}
+	materialise(e) {
+		this.assertActive();
+		let t = /* @__PURE__ */ new Map(), n = this.parent.readTable(e), r = this.tombstones.get(e);
+		if (n) for (let [e, i] of n) r?.has(e) || t.set(e, i);
+		let i = this.overlay.get(e);
+		if (i) for (let [e, n] of i) t.set(e, n);
+		return t;
+	}
+	buildTablesView(e) {
+		let t = /* @__PURE__ */ new Set([e.table]), n = (e) => {
+			t.add(e.table);
+			for (let t of e.setOp?.queries ?? []) n(t);
+			for (let r of e.joins ?? []) {
+				t.add(r.table);
+				for (let e of l(r.on)) n(e.descriptor);
+			}
+			if (e.predicate) for (let t of l(e.predicate)) n(t.descriptor);
+		};
+		n(e);
+		let r = /* @__PURE__ */ new Map();
+		for (let e of t) r.set(e, this.materialise(e));
+		return r;
+	}
+	storedTables() {
+		return [.../* @__PURE__ */ new Set([...this.parent.listTables(), ...this.overlay.keys()])].map((e) => V(e, this.materialise(e)));
+	}
+	getOrCreateOverlay(e) {
+		this.assertActive();
+		let t = this.overlay.get(e);
+		return t || (t = /* @__PURE__ */ new Map(), this.overlay.set(e, t)), t;
+	}
+	integrityQuery(e) {
+		return this.query(e);
+	}
+	async query(e) {
+		let t = this.buildTablesView(e), n = I(e, this.materialise(e.table), t);
+		return h(e) ? s(n, e.eager, b(e.table), (e) => this.query(e)) : n;
+	}
+	async insert(e, t) {
+		t = i(e, C(e, t));
+		let n = m(e), r = (n?.fields)?.id?.idScheme, a = t;
+		a.id === void 0 && (n === void 0 || r !== void 0) && (a = {
+			...t,
+			id: this.parent.allocateNumericId(e)
+		});
+		let o = a.id === void 0 ? `__voltro_row_${this.parent.allocateNumericId(e)}` : String(a.id);
+		return this.getOrCreateOverlay(e).set(o, a), this.tombstones.get(e)?.delete(o), this.events.push({
+			table: e,
+			op: "insert",
+			old: null,
+			new: a
+		}), a;
+	}
+	async insertMany(e, t, n) {
+		let r = [];
+		for (let n of t) r.push(await this.insert(e, n));
+		return n?.returning === "none" ? [] : r;
+	}
+	async update(e, t, n) {
+		let r = this.materialise(e), i = G(r, t), a = i === void 0 ? void 0 : r.get(i);
+		if (!a || i === void 0) return null;
+		let o = {
+			...a,
+			...n
+		};
+		return this.getOrCreateOverlay(e).set(i, o), this.events.push({
+			table: e,
+			op: "update",
+			old: a,
+			new: o
+		}), o;
+	}
+	async patchJson(e, t, n, r, i) {
+		let a = _(t, n, i), s = this.materialise(e), c = G(s, t), l = c === void 0 ? void 0 : s.get(c);
+		if (!l || c === void 0) return null;
+		let u = {
+			...o(l, n, r),
+			...a
+		};
+		return this.getOrCreateOverlay(e).set(c, u), this.events.push({
+			table: e,
+			op: "update",
+			old: l,
+			new: u
+		}), u;
+	}
+	async delete(e, t) {
+		let n = this.materialise(e), r = G(n, t), i = r === void 0 ? void 0 : n.get(r);
+		if (!i || r === void 0) return !1;
+		this.overlay.get(e)?.delete(r);
+		let a = this.tombstones.get(e);
+		return a || (a = /* @__PURE__ */ new Set(), this.tombstones.set(e, a)), a.add(r), this.events.push({
+			table: e,
+			op: "delete",
+			old: i,
+			new: null
+		}), !0;
+	}
+	async updateMany(e, t, n) {
+		let r = this.materialise(e), i = A(n.where, this.buildTablesViewForPred(n.where)), a = v(n.where, i, m(e)?.fields), o = 0;
+		for (let [n, i] of r) {
+			if (!a(i)) continue;
+			let r = {
+				...i,
+				...t
+			};
+			this.getOrCreateOverlay(e).set(n, r), this.events.push({
+				table: e,
+				op: "update",
+				old: i,
+				new: r
+			}), o++;
+		}
+		return o;
+	}
+	async deleteMany(e, t) {
+		let n = this.materialise(e), r = A(t.where, this.buildTablesViewForPred(t.where)), i = v(t.where, r, m(e)?.fields), a = 0, o = this.tombstones.get(e);
+		for (let [t, r] of n) i(r) && (this.overlay.get(e)?.delete(t), o || (o = /* @__PURE__ */ new Set(), this.tombstones.set(e, o)), o.add(t), this.events.push({
+			table: e,
+			op: "delete",
+			old: r,
+			new: null
+		}), a++);
+		return a;
+	}
+	buildTablesViewForPred(e) {
+		let t = /* @__PURE__ */ new Set();
+		for (let n of l(e)) t.add(n.descriptor.table);
+		let n = /* @__PURE__ */ new Map();
+		for (let e of t) n.set(e, this.materialise(e));
+		return n;
+	}
+	async upsert(e, t, n) {
+		E(n);
+		let r = this.findByConflictColumns(e, t, n.conflictColumns);
+		if (r) {
+			let i = T(t, r, n), a = Object.fromEntries(n.conflictColumns.map((e) => [e, r[e]]));
+			return await this.update(e, a, i) ?? r;
+		}
+		return this.insert(e, t);
+	}
+	async insertIgnore(e, t, n) {
+		return (await this.insertIgnoreWithOutcome(e, t, n)).row;
+	}
+	async insertIgnoreWithOutcome(e, t, n) {
+		let r = this.findByConflictColumns(e, t, n.conflictColumns);
+		return r ? {
+			row: r,
+			outcome: "ignored"
+		} : {
+			row: await this.insert(e, t),
+			outcome: "inserted"
+		};
+	}
+	findByConflictColumns(e, t, n) {
+		if (n.length === 0) return;
+		let r = this.materialise(e);
+		outer: for (let e of r.values()) {
+			for (let r of n) {
+				let n = e[r], i = t[r];
+				if (n !== i && !(n instanceof Date && i instanceof Date && n.getTime() === i.getTime())) continue outer;
+			}
+			return e;
+		}
+	}
+	transactional(e) {
+		return Promise.reject(/* @__PURE__ */ Error("InMemoryDataStore.transactional: nested transactions are not supported. Mutations should execute a single top-level transaction."));
+	}
+	onChange(e) {
+		throw Error("InMemoryTransactionalView.onChange: subscribing from inside a transaction is not supported. Subscribe on the parent store outside `transactional()`.");
+	}
+	injectExternalChange(e) {
+		throw Error("InMemoryTransactionalView.injectExternalChange: injecting external changes from inside a transaction is not supported. Inject on the parent store outside `transactional()`.");
+	}
+	commit() {
+		this.settled || (this.parent.commitOverlay(this.overlay, this.tombstones), this.settled = !0, this.parent.emit(this.events));
+	}
+	discard() {
+		this.settled || (this.settled = !0, this.overlay.clear(), this.tombstones.clear(), this.events.length = 0);
+	}
+};
+//#endregion
+export { q as InMemoryDataStore };