better-supabase 0.14.0 → 0.15.1

package/dist/executor-BQ7dYw4E.js

@@ -0,0 +1,843 @@
+import { t as DbException } from "./db-exception-Lngc1W49.js";
+import { c as mapDbError, n as dbError } from "./errors-BVFgt8BZ.js";
+import { n as invalidRequest } from "./build-BFC8nFiL.js";
+import { t as lookupOf } from "./lookup-BaP5bI27.js";
+import { a as ok, r as err, s as toDbError } from "./result-ntFBW2p2.js";
+import { n as simplifyOrFalse } from "./simplify-DDO0j0LI.js";
+import { n as isQuerySpec } from "./spec-DTWkHzYZ.js";
+import { n as whereClause, t as integer } from "./shared-C47zAh2A.js";
+//#region src/compile/sqlite.ts
+/**
+* The operation needs something the SQLite dialect can't express: full-text
+* search, a regular expression, a function source. Thrown while compiling,
+* before anything runs; executors return it as a `DbError` of kind
+* `unsupported`, with the feature in `details`.
+*/
+function unsupported(feature, table) {
+	throw new DbException(dbError("unsupported", `SQLite can't run ${feature} on "${table.key}"; run this query on the server (PostgREST) instead`, {
+		table: table.key,
+		details: feature
+	}));
+}
+function quoteSqliteIdent(name) {
+	return `"${name.replaceAll("\"", "\"\"")}"`;
+}
+const TIMESTAMPS = /* @__PURE__ */ new Set(["timestamptz", "timestamp"]);
+const TEXT = /* @__PURE__ */ new Set([
+	"text",
+	"varchar",
+	"bpchar",
+	"citext",
+	"name"
+]);
+const KEYS_PER_STATEMENT = 500;
+function columnMeta(table, db) {
+	return lookupOf(table).byDb.get(db)?.[1];
+}
+function decodeOf(meta, cast) {
+	if (!meta) return "raw";
+	if (meta.type === "timestamptz") return "timestamptz";
+	if (cast === "text") return "raw";
+	if (meta.json || meta.array) return "json";
+	if (meta.type === "bool") return "boolean";
+	return "raw";
+}
+/** A JavaScript value as a SQLite parameter. */
+function sqliteValue(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (typeof value === "number" || typeof value === "string") return value;
+	if (typeof value === "bigint") return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value;
+	return JSON.stringify(value);
+}
+/**
+* A LIKE pattern (backslash escapes) as a GLOB pattern, which SQLite matches
+* case-sensitively, like Postgres `like`.
+*/
+function likeToGlob(pattern) {
+	let out = "";
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		if (char === "\\" && index + 1 < pattern.length) {
+			index += 1;
+			out += globLiteral(pattern[index]);
+		} else if (char === "%") out += "*";
+		else if (char === "_") out += "?";
+		else out += globLiteral(char);
+	}
+	return out;
+}
+function globLiteral(char) {
+	return char === "*" || char === "?" || char === "[" ? `[${char}]` : char;
+}
+var SqliteCompiler = class {
+	params = [];
+	#tableName;
+	#aliases = 0;
+	constructor(tableName) {
+		this.#tableName = tableName;
+	}
+	alias() {
+		const alias = `t${this.#aliases}`;
+		this.#aliases += 1;
+		return alias;
+	}
+	table(table) {
+		return quoteSqliteIdent(this.#tableName(table));
+	}
+	param(value) {
+		this.params.push(sqliteValue(value));
+		return "?";
+	}
+	column(alias, name) {
+		return `${alias}.${quoteSqliteIdent(name)}`;
+	}
+	/**
+	* A column as compared and sorted: timestamps by their instant, not their
+	* text.
+	*/
+	comparable(table, alias, name) {
+		const column = this.column(alias, name);
+		return TIMESTAMPS.has(columnMeta(table, name)?.type ?? "") ? `julianday(${column})` : column;
+	}
+	comparableParam(table, name, value) {
+		const param = this.param(value);
+		return TIMESTAMPS.has(columnMeta(table, name)?.type ?? "") ? `julianday(${param})` : param;
+	}
+	condition(condition, table, alias) {
+		switch (condition.kind) {
+			case "and":
+			case "or": {
+				if (condition.items.length === 0) return condition.kind === "and" ? "1" : "0";
+				const joiner = condition.kind === "and" ? " and " : " or ";
+				return `(${condition.items.map((item) => this.condition(item, table, alias)).join(joiner)})`;
+			}
+			case "not": return `not ${this.condition(condition.item, table, alias)}`;
+			case "column": return this.columnCondition(condition, table, alias);
+			case "relation": {
+				const target = this.alias();
+				const join = this.join(condition, table, alias, target);
+				const where = condition.quantifier === "every" && condition.where ? `not ${this.condition(condition.where, condition.target, target)}` : condition.where ? this.condition(condition.where, condition.target, target) : void 0;
+				const body = `select 1 from ${this.table(condition.target)} as ${target} where ${join}${where ? ` and ${where}` : ""}`;
+				return condition.quantifier === "some" ? `exists (${body})` : `not exists (${body})`;
+			}
+			default: return condition;
+		}
+	}
+	join(condition, source, sourceAlias, targetAlias) {
+		const { relation, target } = condition;
+		if (relation.columns.length !== relation.references.length) invalidRequest(`Relation to "${target.key}" has mismatched columns`);
+		return relation.columns.map((column, index) => {
+			const reference = relation.references[index];
+			return `${this.column(targetAlias, dbName(target, reference))} = ${this.column(sourceAlias, dbName(source, column))}`;
+		}).join(" and ");
+	}
+	columnCondition(condition, table, alias) {
+		const name = condition.column;
+		if (condition.path) unsupported("a json path filter", table);
+		const column = this.comparable(table, alias, name);
+		const raw = this.column(alias, name);
+		const { value } = condition;
+		const operand = () => this.comparableParam(table, name, value);
+		switch (condition.op) {
+			case "eq": return `${column} = ${operand()}`;
+			case "neq": return `${column} <> ${operand()}`;
+			case "gt": return `${column} > ${operand()}`;
+			case "gte": return `${column} >= ${operand()}`;
+			case "lt": return `${column} < ${operand()}`;
+			case "lte": return `${column} <= ${operand()}`;
+			case "like": return `${raw} glob ${this.param(likeToGlob(String(value)))}`;
+			case "ilike": return `${raw} like ${this.param(value)} escape '\\'`;
+			case "in":
+				if (!Array.isArray(value)) invalidRequest("\"in\" needs an array");
+				if (value.length === 0) return "0";
+				return `${column} in (${value.map((item) => this.comparableParam(table, name, item)).join(", ")})`;
+			case "is":
+				if (value === null) return `${raw} is null`;
+				if (value === true) return `${raw} is 1`;
+				if (value === false) return `${raw} is 0`;
+				return invalidRequest("\"is\" needs null, true or false");
+			case "contains":
+			case "containedBy":
+			case "overlaps": return this.jsonCondition(condition.op, table, raw, value);
+			case "fts": return unsupported("full-text search", table);
+			case "match":
+			case "imatch": return unsupported("a regular expression filter", table);
+			default: return condition.op;
+		}
+	}
+	/** Arrays and jsonb sync to SQLite as JSON text; `json_each` reads them. */
+	jsonCondition(op, table, column, value) {
+		if (Array.isArray(value)) {
+			const distinct = [...new Set(value.map(sqliteValue))];
+			if (distinct.some((item) => item === null)) unsupported(`"${op}" with null elements`, table);
+			const list = distinct.map((item) => this.param(item)).join(", ");
+			switch (op) {
+				case "contains": return distinct.length === 0 ? `${column} is not null` : `(select count(distinct value) from json_each(${column}) where value in (${list})) = ${distinct.length}`;
+				case "overlaps": return distinct.length === 0 ? "0" : `exists (select 1 from json_each(${column}) where value in (${list}))`;
+				case "containedBy": return `(${column} is not null and not exists (select 1 from json_each(${column})${distinct.length === 0 ? "" : ` where value not in (${list})`}))`;
+				default: return op;
+			}
+		}
+		if (op !== "contains" || typeof value !== "object" || value === null) return unsupported(`"${op}" on a JSON object`, table);
+		const parts = [];
+		for (const [key, item] of Object.entries(value)) {
+			if (key.includes("\"") || typeof item === "object" && item !== null) unsupported("\"contains\" with a nested JSON value", table);
+			parts.push(item === null ? `json_type(${column}, ${this.param(`$."${key}"`)}) = 'null'` : `json_extract(${column}, ${this.param(`$."${key}"`)}) = ${this.param(item)}`);
+		}
+		return parts.length === 0 ? `${column} is not null` : `(${parts.join(" and ")})`;
+	}
+	/**
+	* A column as sorted. Postgres sorts text by the database collation, which
+	* ignores case at the first level, and enum types by their declared order.
+	*/
+	sortable(table, alias, name) {
+		const meta = columnMeta(table, name);
+		const column = this.column(alias, name);
+		if (meta?.enum && !TEXT.has(meta.type)) return `case ${column} ${meta.enum.map((value, index) => `when ${this.param(value)} then ${index}`).join(" ")} end`;
+		if (meta && TEXT.has(meta.type) && !meta.array && !meta.json) return `${column} collate nocase`;
+		return this.comparable(table, alias, name);
+	}
+	/**
+	* Postgres sorts nulls last ascending and first descending; SQLite does the
+	* opposite.
+	*/
+	orderBy(terms, table, alias) {
+		return terms.map((term) => {
+			if (term.relation) unsupported(`a sort by the relation "${term.relation.name}"`, table);
+			const nulls = term.nulls ?? (term.direction === "asc" ? "last" : "first");
+			return `${term.aggregate === "count" ? "count(*)" : term.aggregate ? `${term.aggregate}(${this.sortable(table, alias, term.column)})` : this.sortable(table, alias, term.column)} ${term.direction} nulls ${nulls}`;
+		}).join(", ");
+	}
+	selection(selection, table, alias) {
+		const { entries, columns } = this.entries(selection, table, alias, false);
+		const items = entries.map(([key, expression]) => `${expression} as ${quoteSqliteIdent(key)}`);
+		if (items.length === 0) items.push("1 as \"_\"");
+		return {
+			list: items.join(", "),
+			columns
+		};
+	}
+	/**
+	* `exists` filters for the includes with `required: true` (PostgREST
+	* `!inner`), which drop rows without a match.
+	*/
+	required(selection, table, alias) {
+		return selection.includes.filter((include) => include.required).map((include) => {
+			const target = this.alias();
+			return `exists (select 1 from ${this.table(include.target)} as ${target} where ${this.includeFilter(include, table, alias, target)})`;
+		});
+	}
+	/**
+	* The selected values as `[key, expression]` pairs, in the order their
+	* parameters bind. `nested` reads an include inside a JSON object, where an
+	* embedded value has to stay JSON instead of text.
+	*/
+	entries(selection, table, alias, nested) {
+		const entries = [];
+		const columns = [];
+		for (const entry of selection.columns) {
+			const meta = columnMeta(table, entry.column);
+			const column = this.column(alias, entry.column);
+			const decode = decodeOf(meta, entry.cast);
+			entries.push([entry.alias, entry.cast === "text" && decode !== "timestamptz" ? `cast(${column} as text)` : column]);
+			columns.push({
+				alias: entry.alias,
+				decode
+			});
+		}
+		if (selection.aggregate) {
+			if (selection.aggregate.count) {
+				entries.push(["_count", "count(*)"]);
+				columns.push({
+					alias: "_count",
+					decode: "raw"
+				});
+			}
+			for (const measure of selection.aggregate.measures) {
+				const { expression, column } = this.measure(measure, table, alias);
+				entries.push([measure.key, expression]);
+				columns.push(column);
+			}
+		}
+		for (const include of selection.includes) {
+			const { expression, column } = this.include(include, table, alias);
+			entries.push([include.alias, nested && column.decode === "json" ? `json(${expression})` : expression]);
+			columns.push(column);
+		}
+		return {
+			entries,
+			columns
+		};
+	}
+	measure(measure, table, alias) {
+		const meta = columnMeta(table, measure.column);
+		const inner = `${measure.fn}(${this.comparable(table, alias, measure.column)})`;
+		const timestamp = TIMESTAMPS.has(meta?.type ?? "") && measure.fn !== "avg";
+		return {
+			expression: timestamp ? `${measure.fn}(${this.column(alias, measure.column)})` : measure.cast === "text" ? `cast(${inner} as text)` : inner,
+			column: {
+				alias: measure.key,
+				decode: timestamp && meta?.type === "timestamptz" ? "timestamptz" : "raw"
+			}
+		};
+	}
+	/** `json_object('a', t1."a", ...)` for one row of a selection. */
+	jsonObject(selection, table, alias) {
+		const { entries, columns } = this.entries(selection, table, alias, true);
+		return {
+			text: `json_object(${entries.map(([key, expression]) => `'${key.replaceAll("'", "''")}', ${expression}`).join(", ")})`,
+			columns
+		};
+	}
+	/**
+	* The join to the parent row, the include's `where` and its own required
+	* includes.
+	*/
+	includeFilter(include, table, alias, target) {
+		const filters = [this.join(include, table, alias, target)];
+		const simple = simplifyOrFalse(include.where);
+		if (simple.never) filters.push("0");
+		else if (simple.condition) filters.push(this.condition(simple.condition, include.target, target));
+		filters.push(...this.required(include.selection, include.target, target));
+		return filters.join(" and ");
+	}
+	/**
+	* A correlated subquery for an include: the related rows as a JSON array
+	* (`json_group_array`), the one related row as a JSON object, a related
+	* `count(*)`, or the related measures as a JSON object.
+	*/
+	include(include, table, alias) {
+		const target = this.alias();
+		const from = `${this.table(include.target)} as ${target}`;
+		if (include.count !== void 0) return {
+			expression: `(select count(*) from ${from} where ${this.includeFilter(include, table, alias, target)})`,
+			column: {
+				alias: include.alias,
+				decode: "raw"
+			}
+		};
+		const row = this.jsonObject(include.selection, include.target, target);
+		const filter = this.includeFilter(include, table, alias, target);
+		if (include.aggregate !== void 0) return {
+			expression: `(select ${row.text} from ${from} where ${filter})`,
+			column: {
+				alias: include.alias,
+				decode: "json",
+				nested: {
+					many: false,
+					columns: row.columns
+				}
+			}
+		};
+		if (include.relation.kind === "one") return {
+			expression: `(select ${row.text} from ${from} where ${filter} limit 1)`,
+			column: {
+				alias: include.alias,
+				decode: "json",
+				nested: {
+					many: false,
+					columns: row.columns
+				}
+			}
+		};
+		const order = include.orderBy.length > 0 ? ` order by ${this.orderBy(include.orderBy, include.target, target)}` : "";
+		const limit = include.limit === void 0 ? "" : ` limit ${integer(include.limit)}`;
+		return {
+			expression: `(select json_group_array(json(j)) from (select ${row.text} as j from ${from} where ${filter}${order}${limit}))`,
+			column: {
+				alias: include.alias,
+				decode: "json",
+				nested: {
+					many: true,
+					columns: row.columns
+				}
+			}
+		};
+	}
+};
+function dbName(table, app) {
+	const meta = table.columns[app];
+	if (!meta) invalidRequest(`Unknown column "${app}" on "${table.key}"`, table.key);
+	return meta.db;
+}
+function keyColumns(table) {
+	if (table.primaryKey.length === 0) unsupported("a write to a table without a primary key", table);
+	return table.primaryKey.map((app) => dbName(table, app));
+}
+/** `where (a, b) in (values (?, ?), ...)` for a page of keys. */
+function byKeys(compiler, table, alias, keys) {
+	const columns = keyColumns(table);
+	if (keys.length === 0) return "0";
+	if (columns.length === 1) return `${compiler.column(alias, columns[0])} in (${keys.map((key) => compiler.param(key[0])).join(", ")})`;
+	return `${`(${columns.map((column) => compiler.column(alias, column)).join(", ")})`} in (values ${keys.map((key) => `(${key.map((value) => compiler.param(value)).join(", ")})`).join(", ")})`;
+}
+/**
+* Compiles IR operations for SQLite (PowerSync's local database). Reads become
+* one statement; writes become steps the executor runs in a write transaction.
+* Throws a `DbException` with kind `unsupported` for what SQLite can't express,
+* before anything runs.
+*/
+function compileSqlite(op, options = {}) {
+	const tableName = options.tableName ?? ((table) => table.name);
+	const make = () => new SqliteCompiler(tableName);
+	if (op.kind === "select" && op.source) unsupported(`the function source "${op.source.name}"`, op.table);
+	switch (op.kind) {
+		case "select": return selectPlan(make, op);
+		case "insert": return insertPlan(make, op);
+		case "update":
+		case "delete": return keyedPlan(make, op);
+		default: return op;
+	}
+}
+function selectPlan(make, op) {
+	const simple = simplifyOrFalse(op.where);
+	if (simple.never) return { kind: "never" };
+	const filterOf = (compiler, alias) => whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0, ...compiler.required(op.selection, op.table, alias)]);
+	let count;
+	if (op.count || op.head) {
+		const compiler = make();
+		const alias = compiler.alias();
+		const filter = filterOf(compiler, alias);
+		count = {
+			text: `select count(*) as count from ${compiler.table(op.table)} as ${alias}${filter}`,
+			params: compiler.params
+		};
+	}
+	if (op.head) return {
+		kind: "select",
+		rows: void 0,
+		count,
+		columns: []
+	};
+	const compiler = make();
+	const alias = compiler.alias();
+	const { list, columns } = compiler.selection(op.selection, op.table, alias);
+	const filter = filterOf(compiler, alias);
+	return {
+		kind: "select",
+		rows: {
+			text: `select ${list} from ${`${compiler.table(op.table)} as ${alias}`}${filter}${op.selection.aggregate && op.selection.columns.length > 0 ? ` group by ${op.selection.columns.map((entry) => compiler.column(alias, entry.column)).join(", ")}` : ""}${op.orderBy.length > 0 ? ` order by ${compiler.orderBy(op.orderBy, op.table, alias)}` : ""}${op.limit === void 0 ? op.offset === void 0 ? "" : " limit -1" : ` limit ${integer(op.limit)}`}${op.offset === void 0 ? "" : ` offset ${integer(op.offset)}`}`,
+			params: compiler.params
+		},
+		count,
+		columns
+	};
+}
+function returning(make, op) {
+	if (!op.returning) return;
+	const columns = make().selection(op.returning, op.table, "t0").columns;
+	const selection = op.returning;
+	return {
+		columns,
+		read: (keys) => {
+			const compiler = make();
+			const alias = compiler.alias();
+			const { list } = compiler.selection(selection, op.table, alias);
+			return {
+				text: `select ${list} from ${compiler.table(op.table)} as ${alias} where ${byKeys(compiler, op.table, alias, keys)}`,
+				params: compiler.params
+			};
+		}
+	};
+}
+function insertPlan(make, op) {
+	if (op.rows.length === 0) return { kind: "never" };
+	const keys = keyColumns(op.table);
+	const columns = /* @__PURE__ */ new Set();
+	for (const row of op.rows) for (const key of Object.keys(row)) columns.add(key);
+	const ordered = [...columns];
+	const conflict = op.onConflict;
+	const tenant = op.table.flags.tenant;
+	const tenantColumn = tenant === void 0 ? void 0 : op.table.columns[tenant]?.db;
+	return {
+		kind: "insert",
+		rows: op.rows.map((row) => {
+			const missing = keys.filter((key) => row[key] === void 0);
+			if (missing.length > 0) invalidRequest(`Insert into "${op.table.key}" needs ${missing.join(", ")}: SQLite has no column defaults for keys`, op.table.key);
+			const own = ordered.filter((column) => column in row || op.defaultToNull);
+			const insertCompiler = make();
+			const values = own.map((column) => insertCompiler.param(row[column] ?? null));
+			const insert = {
+				text: own.length === 0 ? `insert into ${insertCompiler.table(op.table)} default values` : `insert into ${insertCompiler.table(op.table)} (${own.map(quoteSqliteIdent).join(", ")}) values (${values.join(", ")})`,
+				params: insertCompiler.params
+			};
+			let existing;
+			let update;
+			if (conflict) {
+				const find = make();
+				const alias = find.alias();
+				const match = conflict.columns.map((column) => `${find.column(alias, column)} = ${find.param(row[column] ?? null)}`).join(" and ");
+				existing = {
+					text: `select ${keys.map((key) => find.column(alias, key)).join(", ")}${tenantColumn ? `, ${find.column(alias, tenantColumn)} as "_tenant"` : ""} from ${find.table(op.table)} as ${alias} where ${match} limit 1`,
+					params: find.params
+				};
+				const sets = own.filter((column) => !conflict.columns.includes(column) && !keys.includes(column));
+				if (conflict.action === "update" && sets.length > 0) update = (key) => {
+					const compiler = make();
+					const alias = compiler.alias();
+					const set = sets.map((column) => `${quoteSqliteIdent(column)} = ${compiler.param(row[column] ?? null)}`).join(", ");
+					const where = byKeys(compiler, op.table, alias, [key]);
+					return {
+						text: `update ${compiler.table(op.table)} as ${alias} set ${set} where ${where}`,
+						params: compiler.params
+					};
+				};
+			}
+			return {
+				key: keys.map((key) => sqliteValue(row[key])),
+				tenant: tenantColumn === void 0 ? void 0 : sqliteValue(row[tenantColumn]),
+				insert,
+				existing,
+				update
+			};
+		}),
+		conflict: conflict?.action,
+		returning: returning(make, op)
+	};
+}
+function keyedPlan(make, op) {
+	const simple = simplifyOrFalse(op.where);
+	if (simple.never) return { kind: "never" };
+	const { maxAffected } = op;
+	if (maxAffected !== void 0 && (!Number.isInteger(maxAffected) || maxAffected < 0)) invalidRequest(`"maxAffected" must be a non-negative integer, got ${maxAffected}`, op.table.key);
+	const keys = keyColumns(op.table);
+	const compiler = make();
+	const alias = compiler.alias();
+	const where = simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0;
+	const select = {
+		text: `select ${keys.map((key) => compiler.column(alias, key)).join(", ")} from ${compiler.table(op.table)} as ${alias}${whereClause([where])}`,
+		params: compiler.params
+	};
+	let set = [];
+	if (op.kind === "update") {
+		set = Object.entries(op.set);
+		if (set.length === 0) invalidRequest(`Update on "${op.table.key}" sets no columns`);
+	}
+	return {
+		kind: op.kind,
+		keys: select,
+		apply: (rows) => {
+			const own = make();
+			const ownAlias = own.alias();
+			const assignments = set.map(([column, value]) => `${quoteSqliteIdent(column)} = ${own.param(value)}`).join(", ");
+			const target = byKeys(own, op.table, ownAlias, rows);
+			return {
+				text: op.kind === "update" ? `update ${own.table(op.table)} as ${ownAlias} set ${assignments} where ${target}` : `delete from ${own.table(op.table)} as ${ownAlias} where ${target}`,
+				params: own.params
+			};
+		},
+		returning: returning(make, op),
+		...maxAffected === void 0 ? {} : { maxAffected }
+	};
+}
+/** Splits keys into pages that stay under SQLite's parameter limit. */
+function keyPages(keys) {
+	const pages = [];
+	for (let start = 0; start < keys.length; start += KEYS_PER_STATEMENT) pages.push(keys.slice(start, start + KEYS_PER_STATEMENT));
+	return pages;
+}
+//#endregion
+//#region src/powersync/compiler.ts
+const sqliteCompiler = {
+	target: "sqlite",
+	compile: (op) => compileSqlite(op)
+};
+async function checkSqlite(betterSupabase, list, options = {}) {
+	const failures = /* @__PURE__ */ new Map();
+	const db = betterSupabase.connect({
+		name: "sqlite-check",
+		execute(op) {
+			try {
+				compileSqlite(op, options);
+			} catch (cause) {
+				const failure = toDbError(cause);
+				if (!failures.has(failure.message)) failures.set(failure.message, failure);
+				return Promise.resolve(err(failure));
+			}
+			return Promise.resolve(ok({
+				rows: [],
+				count: 0
+			}));
+		}
+	});
+	if (isQuerySpec(list)) await db.$run(list);
+	else await runList(db, list, options.all === true);
+	const found = [...failures.values()];
+	if (options.all) return found;
+	const [first] = found;
+	return first ? err(first) : ok(void 0);
+}
+async function runList(db, list, all) {
+	const facets = {};
+	for (const facet of list.facets) facets[facet.key] = [facet.values?.[0] ?? "x"];
+	const query = {
+		...list.defaults,
+		q: "x",
+		facets
+	};
+	await list.run(db, query);
+	if (all) await list.run(db, list.defaults);
+}
+//#endregion
+//#region src/sqlite/executor.ts
+const UNIQUE = /(?:UNIQUE|PRIMARY KEY) constraint failed: (.+)$/m;
+const NOT_NULL = /NOT NULL constraint failed: (?:[^.\s]+\.)?(\S+)/;
+const CHECK = /CHECK constraint failed: ?(\S+)?/;
+const unqualified = (column) => column.trim().replace(/^[^.]+\./, "");
+/**
+* A SQLite constraint error in the shape `mapDbError` reads from Postgres: its
+* SQLSTATE, and the columns in Postgres's `Key (...)` detail format.
+*/
+function fromSqliteError(cause) {
+	if (!(cause instanceof Error)) return;
+	const message = cause.message;
+	const unique = UNIQUE.exec(message);
+	if (unique?.[1]) return {
+		code: "23505",
+		message,
+		details: `Key (${unique[1].split(",").map(unqualified).join(", ")})=(...) already exists.`
+	};
+	if (message.includes("FOREIGN KEY constraint failed")) return {
+		code: "23503",
+		message
+	};
+	const notNull = NOT_NULL.exec(message);
+	if (notNull?.[1]) return {
+		code: "23502",
+		message,
+		column: notNull[1]
+	};
+	const check = CHECK.exec(message);
+	if (check) return {
+		code: "23514",
+		message,
+		...check[1] ? { constraint: check[1] } : {}
+	};
+}
+const TIMESTAMP = /^(\d{4,}-\d{2}-\d{2})[Tt ](\d{2}:\d{2}:\d{2})(?:\.(\d+))?(Z|z|[+-]\d{2}(?::?\d{2})?)?$/;
+/**
+* Timestamp text as PostgREST sends it (`2026-01-02T10:00:00.5+00:00`), from
+* whatever the sync wrote (`2026-01-02 10:00:00.500000Z`).
+*/
+function postgrestTimestamp(value) {
+	const match = TIMESTAMP.exec(value);
+	if (!match) return value;
+	const [, date, time, fraction, zone] = match;
+	const trimmed = fraction?.replace(/0+$/, "");
+	let offset = "+00:00";
+	if (zone && zone !== "Z" && zone !== "z") {
+		const digits = zone.replace(":", "");
+		offset = `${digits.slice(0, 3)}:${digits.slice(3, 5) || "00"}`;
+	}
+	return `${date}T${time}${trimmed ? `.${trimmed}` : ""}${offset}`;
+}
+function decodeValue(column, value) {
+	if (value === null || value === void 0) return null;
+	switch (column.decode) {
+		case "boolean": return value === 1 || value === true || value === "1" || value === "true";
+		case "json": {
+			let parsed = value;
+			if (typeof value === "string") try {
+				parsed = JSON.parse(value);
+			} catch {
+				return value;
+			}
+			return column.nested ? decodeNested(column.nested, parsed) : parsed;
+		}
+		case "timestamptz": return typeof value === "string" ? postgrestTimestamp(value) : value;
+		case "raw":
+			if (typeof value !== "bigint") return value;
+			return value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER ? Number(value) : value.toString();
+		default: return column.decode;
+	}
+}
+function decodeRow(row, columns) {
+	const out = {};
+	for (const column of columns) out[column.alias] = decodeValue(column, row[column.alias]);
+	return out;
+}
+function isRow(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** An include's JSON: an array of rows, or one row or `null`. */
+function decodeNested(nested, value) {
+	if (nested.many) return Array.isArray(value) ? value.map((item) => isRow(item) ? decodeRow(item, nested.columns) : item) : [];
+	return isRow(value) ? decodeRow(value, nested.columns) : null;
+}
+function decode(rows, columns) {
+	return rows.map((row) => decodeRow(row, columns));
+}
+async function all(context, query) {
+	return context.getAll(query.text, [...query.params]);
+}
+function keyValue(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") return value;
+	return String(value);
+}
+async function keysOf(context, query) {
+	return (await all(context, query)).map((row) => Object.values(row).map(keyValue));
+}
+async function readBack(context, plan, keys) {
+	if (!plan.returning) return [];
+	const rows = [];
+	for (const page of keyPages(keys)) rows.push(...await all(context, plan.returning.read(page)));
+	return decode(rows, plan.returning.columns);
+}
+async function runInsert(tx, plan) {
+	const written = [];
+	for (const row of plan.rows) {
+		const [found] = row.existing ? await all(tx, row.existing) : [];
+		if (found) {
+			const { _tenant: tenant, ...key } = found;
+			const otherTenant = row.tenant !== void 0 && tenant !== row.tenant;
+			if (plan.conflict === "ignore" || otherTenant || !row.update) continue;
+			const existingKey = Object.values(key).map(keyValue);
+			const statement = row.update(existingKey);
+			await tx.execute(statement.text, [...statement.params]);
+			written.push(existingKey);
+			continue;
+		}
+		await tx.execute(row.insert.text, [...row.insert.params]);
+		written.push(row.key);
+	}
+	return {
+		rows: await readBack(tx, plan, written),
+		count: written.length
+	};
+}
+/**
+* Thrown inside the write transaction so it rolls back; mapped to
+* `max_affected`.
+*/
+var MaxAffected = class extends Error {
+	error;
+	constructor(affected, maxAffected) {
+		const message = `The write affects ${affected} rows, more than maxAffected (${maxAffected}) allows`;
+		super(message);
+		this.error = dbError("max_affected", message, { maxAffected });
+	}
+};
+async function runKeyed(tx, plan) {
+	const keys = await keysOf(tx, plan.keys);
+	if (keys.length === 0) return {
+		rows: [],
+		count: 0
+	};
+	if (plan.maxAffected !== void 0 && keys.length > plan.maxAffected) throw new MaxAffected(keys.length, plan.maxAffected);
+	const before = plan.kind === "delete" ? await readBack(tx, plan, keys) : void 0;
+	for (const page of keyPages(keys)) {
+		const statement = plan.apply(page);
+		await tx.execute(statement.text, [...statement.params]);
+	}
+	return {
+		rows: before ?? await readBack(tx, plan, keys),
+		count: keys.length
+	};
+}
+async function runSelect(context, plan) {
+	const [rows, counted] = await Promise.all([plan.rows ? all(context, plan.rows) : [], plan.count ? all(context, plan.count) : void 0]);
+	return {
+		rows: decode(rows, plan.columns),
+		count: counted ? Number(counted[0]?.["count"] ?? 0) : null
+	};
+}
+async function run(db, plan) {
+	switch (plan.kind) {
+		case "select": return plan.rows && plan.count && db.readTransaction ? db.readTransaction((tx) => runSelect(tx, plan)) : runSelect(db, plan);
+		case "insert": return db.writeTransaction((tx) => runInsert(tx, plan));
+		case "update":
+		case "delete": return db.writeTransaction((tx) => runKeyed(tx, plan));
+		default: return plan;
+	}
+}
+/** Hermes has no `crypto` unless the app installs a polyfill. */
+function randomId() {
+	const { crypto } = globalThis;
+	return crypto?.randomUUID?.();
+}
+/** Inserts with a missing single-column key get one, as PowerSync needs. */
+async function withIds(db, op, newId) {
+	const [key, ...rest] = op.table.primaryKey;
+	if (key === void 0 || rest.length > 0) return op;
+	const column = op.table.columns[key];
+	if (!column || column.type !== "uuid" && column.type !== "text") return op;
+	if (op.rows.every((row) => row[column.db] !== void 0)) return op;
+	const next = async () => {
+		if (newId) return newId(op.table);
+		const random = randomId();
+		if (random !== void 0) return random;
+		const [row] = await db.getAll("select uuid() as id");
+		if (!row) throw new TypeError("select uuid() returned no row");
+		return row.id;
+	};
+	const rows = [];
+	for (const row of op.rows) rows.push(row[column.db] === void 0 ? {
+		...row,
+		[column.db]: await next()
+	} : row);
+	return {
+		...op,
+		rows
+	};
+}
+async function executeOn(db, op, context, options) {
+	const aborted = () => context.signal?.aborted === true;
+	if (aborted()) return err(dbError("aborted", "The request was aborted"));
+	let plan;
+	try {
+		plan = compileSqlite(op.kind === "insert" ? await withIds(db, op, options.newId) : op, options);
+	} catch (cause) {
+		const error = toDbError(cause);
+		const { fallback } = options;
+		if (fallback && op.kind === "select" && error.kind === "unsupported") return fallback.execute(op, context);
+		return err(error);
+	}
+	if (plan.kind === "never") return ok({
+		rows: [],
+		count: 0
+	});
+	if (aborted()) return err(dbError("aborted", "The request was aborted"));
+	let result;
+	try {
+		result = await run(db, plan);
+	} catch (cause) {
+		return err(mapped(cause, context.errorMappers));
+	}
+	if (op.kind === "select" && op.single) {
+		if (result.rows.length > 1) return err(dbError("multiple_rows", `Expected one ${op.table.key} row`));
+		if (result.rows.length === 0 && op.single === "one") return err(dbError("not_found", `No ${op.table.key} row matched`));
+	}
+	return ok(result);
+}
+function mapped(cause, mappers) {
+	if (cause instanceof MaxAffected) return cause.error;
+	const raw = fromSqliteError(cause);
+	return raw ? mapDbError(raw, mappers) : toDbError(cause);
+}
+/**
+* Runs repository operations on a local SQLite database, so the same
+* repositories and list definitions work offline on native. Reads return rows
+* in the PostgREST shape (booleans, parsed JSON, ISO timestamps); writes go
+* through the database's upload queue. What SQLite can't express (includes,
+* full-text search, function sources) and `db.$rpc` return a `DbError` of kind
+* `unsupported` without running anything, or run on `options.fallback` when you
+* pass one. `maxAffected` is checked against the selected keys before any
+* write; a call's `timeout` and `signal` are checked before the statements
+* start, and `retry` does nothing here. A `bigint` beyond
+* `Number.MAX_SAFE_INTEGER` comes back as its decimal string instead of a
+* rounded number.
+*/
+function sqliteExecutor(db, options = {}, name = "sqlite") {
+	const { fallback } = options;
+	const rpc = fallback?.rpc?.bind(fallback);
+	return {
+		name,
+		...fallback?.functionSources ? { functionSources: true } : {},
+		execute: (op, context) => executeOn(db, op, context, options),
+		...rpc ? { rpc } : {}
+	};
+}
+//#endregion
+export { sqliteCompiler as a, quoteSqliteIdent as c, checkSqlite as i, sqliteValue as l, postgrestTimestamp as n, compileSqlite as o, sqliteExecutor as r, likeToGlob as s, fromSqliteError as t };