better-supabase 0.5.0 → 0.6.0

package/dist/executor-Bq28caBo.js

@@ -0,0 +1,718 @@
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { c as mapDbError, n as dbError } from "./errors-B11Duf73.js";
+import { n as invalidRequest } from "./build-BXIzE6Xv.js";
+import { t as lookupOf } from "./lookup-BaP5bI27.js";
+import { a as ok, r as err, s as toDbError } from "./result-DzUbqgdW.js";
+import { n as simplifyOrFalse } from "./simplify-DDO0j0LI.js";
+//#region src/compile/sqlite.ts
+/**
+* The operation needs something the SQLite dialect can't express: an
+* include (embedding), full-text search, 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) {
+		if (selection.includes.length > 0) {
+			const include = selection.includes[0];
+			unsupported(include.count === void 0 && include.aggregate === void 0 ? `the include "${include.alias}" (embedding a related table)` : `the related ${include.count === void 0 ? "aggregate" : "count"} "${include.alias}"`, table);
+		}
+		const items = [];
+		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);
+			items.push(`${entry.cast === "text" && decode !== "timestamptz" ? `cast(${column} as text)` : column} as ${quoteSqliteIdent(entry.alias)}`);
+			columns.push({
+				alias: entry.alias,
+				decode
+			});
+		}
+		if (selection.aggregate) {
+			if (selection.aggregate.count) {
+				items.push(`count(*) as "_count"`);
+				columns.push({
+					alias: "_count",
+					decode: "raw"
+				});
+			}
+			for (const measure of selection.aggregate.measures) {
+				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";
+				const expression = timestamp ? `${measure.fn}(${this.column(alias, measure.column)})` : measure.cast === "text" ? `cast(${inner} as text)` : inner;
+				items.push(`${expression} as ${quoteSqliteIdent(measure.key)}`);
+				columns.push({
+					alias: measure.key,
+					decode: timestamp && meta?.type === "timestamptz" ? "timestamptz" : "raw"
+				});
+			}
+		}
+		if (items.length === 0) items.push("1 as \"_\"");
+		return {
+			list: items.join(", "),
+			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 integer(value) {
+	if (!Number.isInteger(value) || value < 0) invalidRequest(`Expected a non-negative integer, got ${value}`);
+	return value;
+}
+function whereClause(parts) {
+	const present = parts.filter((part) => part !== void 0);
+	return present.length > 0 ? ` where ${present.join(" and ")}` : "";
+}
+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(compiler, op) {
+	const simple = simplifyOrFalse(op.where);
+	if (simple.never) return { kind: "never" };
+	const alias = compiler.alias();
+	const { list, columns } = compiler.selection(op.selection, op.table, alias);
+	const filter = whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0]);
+	const from = `${compiler.table(op.table)} as ${alias}`;
+	const filterParams = [...compiler.params];
+	const count = op.count || op.head ? {
+		text: `select count(*) as count from ${from}${filter}`,
+		params: filterParams
+	} : void 0;
+	if (op.head) return {
+		kind: "select",
+		rows: void 0,
+		count,
+		columns: []
+	};
+	return {
+		kind: "select",
+		rows: {
+			text: `select ${list} from ${from}${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 void 0;
+	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)
+};
+/**
+* Compiles every operation a list definition runs (the page, its count and
+* the facet counts) for SQLite, without a database. Returns the first
+* `unsupported` or `invalid_request` error, so a test or a dev build fails
+* before a native screen does.
+*
+* ```ts
+* expect(await checkSqlite(betterSupabase, customerList)).toEqual({ ok: true, data: undefined });
+* ```
+*/
+async function checkSqlite(betterSupabase, list, options = {}) {
+	let failure;
+	const probe = {
+		name: "sqlite-check",
+		execute(op) {
+			try {
+				compileSqlite(op, options);
+			} catch (cause) {
+				failure ??= toDbError(cause);
+				return Promise.resolve(err(failure));
+			}
+			return Promise.resolve(ok({
+				rows: [],
+				count: 0
+			}));
+		}
+	};
+	const facets = {};
+	for (const facet of list.facets) facets[facet.key] = [facet.values?.[0] ?? "x"];
+	const query = {
+		...list.defaults,
+		q: "x",
+		facets
+	};
+	const db = betterSupabase.connect(probe);
+	await list.run(db, query);
+	return failure ? err(failure) : ok(void 0);
+}
+//#endregion
+//#region src/powersync/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 void 0;
+	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":
+			if (typeof value !== "string") return value;
+			try {
+				return JSON.parse(value);
+			} catch {
+				return value;
+			}
+		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 decode(rows, columns) {
+	return rows.map((row) => {
+		const out = {};
+		for (const column of columns) out[column.alias] = decodeValue(column, row[column.alias]);
+		return out;
+	});
+}
+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) {
+		return err(toDbError(cause));
+	}
+	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 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) returns a
+* `DbError` of kind `unsupported` without running anything.
+* `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));
+* ```
+*/
+function powersyncExecutor(db, options = {}) {
+	return {
+		name: "powersync",
+		execute: (op, context) => executeOn(db, op, context, options)
+	};
+}
+//#endregion
+export { sqliteCompiler as a, quoteSqliteIdent as c, checkSqlite as i, sqliteValue as l, postgrestTimestamp as n, compileSqlite as o, powersyncExecutor as r, likeToGlob as s, fromSqliteError as t };