better-supabase 0.14.0 → 0.15.0

package/dist/executor-o9HkOJ0m.js

@@ -1,869 +0,0 @@
-import { t as DbException } from "./db-exception-Lngc1W49.js";
-import { c as mapDbError, n as dbError } from "./errors-03ysrOt4.js";
-import { n as invalidRequest } from "./build-g9wTbQdp.js";
-import { t as lookupOf } from "./lookup-BaP5bI27.js";
-import { a as ok, r as err, s as toDbError } from "./result-B3m7xtRY.js";
-import { n as simplifyOrFalse } from "./simplify-DDO0j0LI.js";
-import { n as isQuerySpec } from "./spec-CoWHDoud.js";
-import { n as whereClause, t as integer } from "./shared-eVrl39dX.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
-//#region src/powersync/executor.ts
-/**
-* Runs repository operations on PowerSync's 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 PowerSync'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.
-*
-* ```ts
-* const db = betterSupabase.connect(
-*   powersyncExecutor(powersync, {
-*     fallback: postgrestExecutor(supabase),
-*   }),
-* );
-* ```
-*/
-function powersyncExecutor(db, options = {}) {
-	return sqliteExecutor(db, options, "powersync");
-}
-//#endregion
-export { sqliteCompiler as a, quoteSqliteIdent as c, checkSqlite as i, sqliteValue as l, fromSqliteError as n, compileSqlite as o, postgrestTimestamp as r, likeToGlob as s, powersyncExecutor as t };