better-supabase 0.12.0 → 0.14.0

package/dist/stats-qCEV5M3B.js

@@ -0,0 +1,1147 @@
+import { c as mapDbError, d as withMaxAffected, n as dbError } from "./errors-03ysrOt4.js";
+import { n as invalidRequest } from "./build-g9wTbQdp.js";
+import { t as lookupOf } from "./lookup-BaP5bI27.js";
+import { d as temporalText } from "./temporal-DLZlWbOi.js";
+import { t as dateText } from "./wire-Bizdxvp-.js";
+import { a as ok, r as err, s as toDbError } from "./result-B3m7xtRY.js";
+import { n as simplifyOrFalse } from "./simplify-DDO0j0LI.js";
+//#region src/compile/postgrest.ts
+/** `false` only for a version string whose major is known to be below 13. */
+function supportsMaxAffected(version) {
+	if (version === void 0) return true;
+	const major = /^v?(\d+)/i.exec(version)?.[1];
+	return major === void 0 || Number(major) >= 13;
+}
+function scalar(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	const temporalValue = temporalText(value);
+	if (temporalValue !== void 0) return temporalValue;
+	if (value instanceof Date) return dateText(value);
+	if (typeof value === "bigint") return String(value);
+	if (value === null) return "null";
+	return JSON.stringify(value);
+}
+/** Double-quotes a value for PostgREST lists and logic trees. */
+function quote(value) {
+	return `"${scalar(value).replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+/**
+* Values PostgREST reads the same with or without quotes in an `in` list:
+* uuids, numbers, ISO dates and times, enum values, slugs and emails. `null`
+* stays quoted, so it keeps meaning the string.
+*/
+const BARE = /^[\w.:+@-]+$/;
+/** An `in` list element; quoted only when it needs to be, as supabase-js does. */
+function listItem(value) {
+	const text = scalar(value);
+	return BARE.test(text) && text.toLowerCase() !== "null" ? text : quote(text);
+}
+const BRACES = /[{}]/;
+function list(values, open, close) {
+	return `${open}${values.map(quote).join(",")}${close}`;
+}
+/** The filter target: the column, or `column->a->>b` for a json path. */
+function target(condition) {
+	const { column, path } = condition;
+	if (!path || path.length === 0) return column;
+	const last = path.length - 1;
+	return `${column}${path.map((key, index) => `${index === last ? "->>" : "->"}${key}`).join("")}`;
+}
+const REGEX_SPECIAL = /[\\^$.|?*+()[\]{}]/;
+/**
+* A LIKE pattern as an anchored POSIX regex. PostgREST reads every `*` in a
+* like value as `%`, so a pattern with a literal `*` goes as `match`.
+*/
+function likeToRegex(pattern) {
+	let regex = "^";
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern.charAt(index);
+		if (char === "\\" && index + 1 < pattern.length) {
+			index += 1;
+			const next = pattern.charAt(index);
+			regex += REGEX_SPECIAL.test(next) ? `\\${next}` : next;
+		} else if (char === "%") regex += ".*";
+		else if (char === "_") regex += ".";
+		else regex += REGEX_SPECIAL.test(char) ? `\\${char}` : char;
+	}
+	return `${regex}$`;
+}
+function isBoolLike(value) {
+	return value === null || typeof value === "boolean";
+}
+function operatorAndValue(condition, inLogic) {
+	const { op, value } = condition;
+	const plain = (text) => inLogic ? quote(text) : scalar(text);
+	switch (op) {
+		case "eq":
+		case "neq":
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte":
+		case "match":
+		case "imatch": return {
+			operator: op,
+			value: plain(value)
+		};
+		case "like":
+		case "ilike": {
+			const text = scalar(value);
+			if (!text.includes("*")) return {
+				operator: op,
+				value: plain(text)
+			};
+			return {
+				operator: op === "like" ? "match" : "imatch",
+				value: plain(likeToRegex(text))
+			};
+		}
+		case "in":
+			if (!Array.isArray(value)) invalidRequest("\"in\" needs an array");
+			return {
+				operator: "in",
+				value: `(${value.map(listItem).join(",")})`
+			};
+		case "is":
+			if (!isBoolLike(value)) invalidRequest("\"is\" needs null, true or false");
+			return {
+				operator: "is",
+				value: String(value)
+			};
+		case "contains":
+		case "containedBy":
+		case "overlaps": {
+			const operator = op === "contains" ? "cs" : op === "containedBy" ? "cd" : "ov";
+			if (Array.isArray(value) && !condition.json) {
+				const literal = list(value, "{", "}");
+				return {
+					operator,
+					value: inLogic && BRACES.test(literal.slice(1, -1)) ? quote(literal) : literal
+				};
+			}
+			const json = JSON.stringify(value);
+			return {
+				operator,
+				value: inLogic ? quote(json) : json
+			};
+		}
+		case "fts": return {
+			operator: condition.config ? `wfts(${condition.config})` : "wfts",
+			value: plain(value)
+		};
+		default: return op;
+	}
+}
+var PostgrestCompiler = class {
+	filters = [];
+	orders = [];
+	limits = [];
+	#counter = 0;
+	nextAlias() {
+		this.#counter += 1;
+		return `_bs${this.#counter}`;
+	}
+	/** Compiles a condition at `path` where top-level items are ANDed. */
+	andContext(condition, path, embeds) {
+		switch (condition.kind) {
+			case "and":
+				for (const item of condition.items) this.andContext(item, path, embeds);
+				return;
+			case "column": {
+				const { operator, value } = operatorAndValue(condition, false);
+				this.filters.push({
+					kind: "filter",
+					path: path ? `${path}.${target(condition)}` : target(condition),
+					operator,
+					value
+				});
+				return;
+			}
+			case "not": {
+				const inner = condition.item;
+				if (inner.kind === "column") {
+					const { operator, value } = operatorAndValue(inner, false);
+					this.filters.push({
+						kind: "filter",
+						path: path ? `${path}.${target(inner)}` : target(inner),
+						operator: `not.${operator}`,
+						value
+					});
+					return;
+				}
+				if (inner.kind === "relation") {
+					this.relationAnd(negateRelation(inner), path, embeds);
+					return;
+				}
+				if (inner.kind === "not") {
+					this.andContext(inner.item, path, embeds);
+					return;
+				}
+				this.filters.push({
+					kind: "or",
+					expression: this.logic(condition, embeds),
+					referencedTable: path
+				});
+				return;
+			}
+			case "or":
+				this.filters.push({
+					kind: "or",
+					expression: this.logic(condition, embeds).replace(/^or\(/, "").replace(/\)$/, ""),
+					referencedTable: path
+				});
+				return;
+			case "relation":
+				this.relationAnd(condition, path, embeds);
+				return;
+			default: return condition;
+		}
+	}
+	relationAnd(condition, path, embeds) {
+		if (condition.quantifier === "every" && !condition.where) return;
+		const alias = this.nextAlias();
+		const aliasPath = path ? `${path}.${alias}` : alias;
+		const node = filterEmbed(alias, condition, condition.quantifier === "some");
+		this.withPath(node.children, aliasPath);
+		embeds.push(node);
+		const where = condition.quantifier === "every" && condition.where ? {
+			kind: "not",
+			item: condition.where
+		} : condition.where;
+		if (where) this.andContext(where, aliasPath, node.children);
+		if (condition.quantifier !== "some") this.filters.push({
+			kind: "filter",
+			path: aliasPath,
+			operator: "is",
+			value: "null"
+		});
+	}
+	/** Compiles a condition into a PostgREST logic-tree term. */
+	logic(condition, embeds) {
+		switch (condition.kind) {
+			case "and":
+			case "or": return `${condition.kind}(${condition.items.map((item) => this.logic(item, embeds)).join(",")})`;
+			case "not": {
+				const inner = condition.item;
+				if (inner.kind === "column") {
+					const { operator, value } = operatorAndValue(inner, true);
+					return `${target(inner)}.not.${operator}.${value}`;
+				}
+				if (inner.kind === "relation") return this.logic(negateRelation(inner), embeds);
+				if (inner.kind === "not") return this.logic(inner.item, embeds);
+				return `not.${this.logic(inner, embeds)}`;
+			}
+			case "column": {
+				const { operator, value } = operatorAndValue(condition, true);
+				return `${target(condition)}.${operator}.${value}`;
+			}
+			case "relation": {
+				if (condition.quantifier === "every" && !condition.where) invalidRequest("every({}) must be simplified before compiling");
+				const alias = this.nextAlias();
+				const node = filterEmbed(alias, condition, false);
+				const nodePath = this.pathOf(alias, embeds);
+				this.withPath(node.children, nodePath);
+				embeds.push(node);
+				const where = condition.quantifier === "every" && condition.where ? {
+					kind: "not",
+					item: condition.where
+				} : condition.where;
+				if (where) this.andContext(where, nodePath, node.children);
+				return condition.quantifier === "some" ? `${alias}.not.is.null` : `${alias}.is.null`;
+			}
+			default: return condition;
+		}
+	}
+	#paths;
+	withPath(embeds, path) {
+		(this.#paths ??= /* @__PURE__ */ new WeakMap()).set(embeds, path);
+		return embeds;
+	}
+	pathOf(alias, embeds) {
+		const parent = this.#paths?.get(embeds);
+		return parent ? `${parent}.${alias}` : alias;
+	}
+	include(include, path, embeds) {
+		const aliasPath = path ? `${path}.${include.alias}` : include.alias;
+		const node = {
+			alias: include.alias,
+			target: include.target,
+			relation: include.relation,
+			inner: include.required,
+			columns: include.selection.columns,
+			children: this.withPath([], aliasPath),
+			...include.count === void 0 ? {} : { count: true },
+			...include.selection.aggregate ? { measures: include.selection.aggregate.measures } : {}
+		};
+		embeds.push(node);
+		for (const child of include.selection.includes) this.include(child, aliasPath, node.children);
+		const where = simplifyOrFalse(include.where);
+		if (where.never) {
+			const [first] = include.target.primaryKey;
+			const column = first ? include.target.columns[first]?.db : void 0;
+			if (!column) invalidRequest(`Cannot filter "${include.alias}" to nothing`);
+			this.filters.push({
+				kind: "filter",
+				path: `${aliasPath}.${column}`,
+				operator: "is",
+				value: "null"
+			}, {
+				kind: "filter",
+				path: `${aliasPath}.${column}`,
+				operator: "not.is",
+				value: "null"
+			});
+		} else if (where.condition) this.andContext(where.condition, aliasPath, node.children);
+		for (const term of include.orderBy) this.order(term, aliasPath);
+		if (include.limit !== void 0) this.limits.push({
+			count: include.limit,
+			referencedTable: aliasPath
+		});
+	}
+	/**
+	* Sorts the root rows by a column of a to-one embed, `order=alias(column)`.
+	* Reuses the include of that relation, or adds an empty embed for it.
+	*/
+	relationOrder(term, embeds) {
+		const { relation } = term;
+		if (!relation) return;
+		let alias = embeds.find((node) => node.relation.foreignKey === relation.relation.foreignKey && node.target === relation.target && node.count === void 0 && node.measures === void 0 && node.alias === relation.name)?.alias;
+		if (alias === void 0) {
+			alias = this.nextAlias();
+			embeds.push({
+				alias,
+				target: relation.target,
+				relation: relation.relation,
+				inner: false,
+				columns: [],
+				children: []
+			});
+		}
+		this.order({
+			...term,
+			column: `${alias}(${term.column})`
+		}, void 0);
+	}
+	order(term, referencedTable) {
+		this.orders.push({
+			column: term.column,
+			ascending: term.direction === "asc",
+			nullsFirst: term.nulls === void 0 ? void 0 : term.nulls === "first",
+			referencedTable
+		});
+	}
+};
+function negateRelation(condition) {
+	switch (condition.quantifier) {
+		case "some": return {
+			...condition,
+			quantifier: "none"
+		};
+		case "none": return {
+			...condition,
+			quantifier: "some"
+		};
+		case "every": return {
+			...condition,
+			quantifier: "some",
+			where: condition.where ? {
+				kind: "not",
+				item: condition.where
+			} : void 0
+		};
+		default: return condition.quantifier;
+	}
+}
+function filterEmbed(alias, condition, inner) {
+	return {
+		alias,
+		target: condition.target,
+		relation: condition.relation,
+		inner,
+		columns: [],
+		children: []
+	};
+}
+const columnTexts = /* @__PURE__ */ new WeakMap();
+/** The rendered column list, cached per (shared, immutable) column array. */
+function columnText(columns) {
+	let text = columnTexts.get(columns);
+	if (text === void 0) {
+		text = columns.map(({ alias, column, cast }) => {
+			const source = cast ? `${column}::${cast}` : column;
+			return alias === column ? source : `${alias}:${source}`;
+		}).join(",");
+		columnTexts.set(columns, text);
+	}
+	return text;
+}
+function columnList(columns) {
+	return columns.length > 0 ? [columnText(columns)] : [];
+}
+/** `key:column.sum()::text`, PostgREST's aggregate syntax (PostgREST 12+). */
+function measureList(measures) {
+	return measures.map(({ key, column, fn, cast }) => `${key}:${column}.${fn}()${cast ? `::${cast}` : ""}`);
+}
+function aggregateList(aggregate) {
+	return [...aggregate.count ? ["_count:count()"] : [], ...measureList(aggregate.measures)];
+}
+function renderEmbeds(embeds) {
+	return embeds.map((node) => {
+		const hint = `${node.target.name}!${node.relation.foreignKey}${node.inner ? "!inner" : ""}`;
+		if (node.count) return `${node.alias}:${hint}(count)`;
+		if (node.measures) return `${node.alias}:${hint}(${measureList(node.measures).join(",")})`;
+		const inside = [...columnList(node.columns), ...renderEmbeds(node.children)];
+		return `${node.alias}:${hint}(${inside.join(",")})`;
+	});
+}
+function renderSelect(selection, embeds) {
+	if (!selection.aggregate && embeds.length === 0) return selection.columns.length > 0 ? columnText(selection.columns) : "*";
+	const parts = [
+		...columnList(selection.columns),
+		...selection.aggregate ? aggregateList(selection.aggregate) : [],
+		...renderEmbeds(embeds)
+	];
+	return parts.length > 0 ? parts.join(",") : "*";
+}
+/**
+* PostgREST orders by columns only. `order=count` still sorts groups by their
+* row count: Postgres reads `customers.count` as `count(customers)` when the
+* table has no `count` column. Measures have no such spelling.
+*/
+function aggregateOrder(compiler, term, table) {
+	if (term.aggregate !== "count") invalidRequest(`PostgREST can't sort "${table.key}" by _${term.aggregate}; sort by _count or a groupBy column, or use the postgres adapter`, table.key);
+	if (Object.values(table.columns).some((column) => column.db === "count")) invalidRequest(`PostgREST can't sort "${table.key}" by _count because the table has a column named "count"; sort by a groupBy column or use the postgres adapter`, table.key);
+	compiler.order({
+		...term,
+		column: "count"
+	}, void 0);
+}
+function applyWhere(compiler, condition, embeds) {
+	const where = simplifyOrFalse(condition);
+	if (where.never) return false;
+	if (where.condition) compiler.andContext(where.condition, void 0, embeds);
+	return true;
+}
+/** Compiles an operation into a PostgREST plan. */
+function compilePostgrest(op, options = {}) {
+	const maxAffected = op.kind === "update" || op.kind === "delete" ? op.maxAffected : void 0;
+	if (maxAffected !== void 0) {
+		if (!Number.isInteger(maxAffected) || maxAffected < 0) invalidRequest(`"maxAffected" must be a non-negative integer, got ${maxAffected}`, op.table.key);
+		if (!supportsMaxAffected(options.postgrestVersion)) invalidRequest(`"maxAffected" needs PostgREST 13 or later; postgrestVersion is "${options.postgrestVersion}"`, op.table.key);
+	}
+	const compiler = new PostgrestCompiler();
+	const embeds = compiler.withPath([], void 0);
+	const selection = op.kind === "select" ? op.selection : op.kind === "insert" ? op.returning : op.returning;
+	if (selection) for (const include of selection.includes) compiler.include(include, void 0, embeds);
+	let matches = true;
+	if (op.kind === "select" || op.kind === "update" || op.kind === "delete") {
+		const before = embeds.length;
+		matches = applyWhere(compiler, op.where, embeds);
+		if (op.kind !== "select" && embeds.length > before) invalidRequest(`Relation filters are not supported in ${op.kind} on PostgREST; filter by key instead`, op.table.key);
+	}
+	let range;
+	if (op.kind === "select") {
+		for (const term of op.orderBy) if (term.relation) compiler.relationOrder(term, embeds);
+		else if (term.aggregate) aggregateOrder(compiler, term, op.table);
+		else compiler.order(term, void 0);
+		if (op.offset !== void 0) {
+			const from = op.offset;
+			range = {
+				from,
+				to: op.limit === void 0 ? Number.MAX_SAFE_INTEGER : from + op.limit - 1
+			};
+		} else if (op.limit !== void 0) compiler.limits.push({
+			count: op.limit,
+			referencedTable: void 0
+		});
+	}
+	return {
+		select: selection ? renderSelect(selection, embeds) : void 0,
+		filters: compiler.filters,
+		orders: compiler.orders,
+		limits: compiler.limits,
+		range,
+		never: !matches,
+		...maxAffected === void 0 ? {} : { maxAffected }
+	};
+}
+//#endregion
+//#region src/core/in-chunks.ts
+/** The length of the query string supabase-js sends for `plan`. */
+function queryLength(plan) {
+	let length = plan.select === void 0 ? 0 : 8 + encoded(plan.select);
+	for (const filter of plan.filters) length += filter.kind === "filter" ? encoded(filter.path) + 2 + encoded(`${filter.operator}.${filter.value}`) : 4 + encoded(`(${filter.expression})`) + (filter.referencedTable ? encoded(filter.referencedTable) + 1 : 0);
+	for (const order of plan.orders) length += 24 + encoded(order.column);
+	return length;
+}
+function encoded(text) {
+	return encodeURIComponent(text).length;
+}
+function topLevel(where) {
+	if (!where) return [];
+	return where.kind === "and" ? where.items : [where];
+}
+function isInList(condition) {
+	return condition.kind === "column" && condition.op === "in" && condition.path === void 0 && Array.isArray(condition.value);
+}
+/**
+* Column types whose order JavaScript reproduces without the database's
+* collation.
+*/
+const SORTABLE = /* @__PURE__ */ new Set([
+	"int2",
+	"int4",
+	"int8",
+	"float4",
+	"float8",
+	"numeric",
+	"uuid",
+	"date",
+	"timestamp",
+	"timestamptz",
+	"bool"
+]);
+const TIME = /* @__PURE__ */ new Set([
+	"date",
+	"timestamp",
+	"timestamptz"
+]);
+const NUMERIC = /* @__PURE__ */ new Set([
+	"int2",
+	"int4",
+	"float4",
+	"float8",
+	"numeric"
+]);
+const INTEGER = /^-?\d+$/;
+function sortKind(type) {
+	if (type === "int8") return "bigint";
+	if (NUMERIC.has(type)) return "number";
+	return TIME.has(type) ? "time" : "text";
+}
+/** The `invalid_request` for a request whose URL is over the limit. */
+function tooLong(op, length, max, why) {
+	return dbError("invalid_request", `The request for "${op.table.key}" is ${length} characters, over the ${max} the URL takes, and ${why}`, {
+		table: op.table.key,
+		hint: "Split the in list or paginate, pass a shorter list to a search function, or raise `urlLengthLimit` when every proxy in front of PostgREST accepts longer URLs."
+	});
+}
+/**
+* Splits a read whose query string is over `max` into reads that each fit,
+* along its longest top-level `in` list. Only reads without a limit, offset,
+* count or single row qualify, since chunks can't share those; their rows are
+* disjoint, and an order is re-applied in memory on columns that sort the same
+* in JavaScript.
+*/
+function chunkRead(op, plan, max) {
+	const length = queryLength(plan);
+	if (op.limit !== void 0 || op.offset !== void 0 || op.count !== void 0 || op.head || op.single !== void 0 || op.source !== void 0) return tooLong(op, length, max, "a read with a limit, offset, count or single row can't be split");
+	const items = topLevel(op.where);
+	let longest;
+	for (const condition of items) {
+		if (!isInList(condition)) continue;
+		const seen = /* @__PURE__ */ new Set();
+		const values = [];
+		const texts = [];
+		const sizes = [];
+		let total = 0;
+		let largest = 0;
+		for (const value of condition.value) {
+			const text = listItem(value);
+			if (seen.has(text)) continue;
+			seen.add(text);
+			const size = encoded(text) + 3;
+			values.push(value);
+			texts.push(text);
+			sizes.push(size);
+			total += size;
+			if (size > largest) largest = size;
+		}
+		if (!longest || total > longest.total) longest = {
+			condition,
+			values,
+			texts,
+			sizes,
+			total,
+			largest
+		};
+	}
+	if (!longest) return tooLong(op, length, max, "it has no top-level in list to split");
+	const listLength = encoded(`(${longest.condition.value.map(listItem).join(",")})`);
+	const { byDb } = lookupOf(op.table);
+	const hidden = [];
+	const aliases = new Map(op.selection.columns.map((c) => [c.column, c.alias]));
+	for (const term of op.orderBy) {
+		if (term.relation || aliases.has(term.column)) continue;
+		const alias = `_bs_order${hidden.length}`;
+		const exact = byDb.get(term.column)?.[1].type === "int8";
+		hidden.push({
+			alias,
+			column: term.column,
+			...exact ? { cast: "text" } : {}
+		});
+		aliases.set(term.column, alias);
+	}
+	const hiddenText = (column) => `${column.alias}:${column.column}${column.cast ? `::${column.cast}` : ""}`;
+	const extra = hidden.reduce((sum, column) => sum + encoded(`,${hiddenText(column)}`), 0);
+	const budget = max - (length - listLength) - extra - encoded("()");
+	if (budget < longest.largest) return tooLong(op, length, max, "the rest of the request leaves no room for its in list");
+	let sort;
+	if (op.orderBy.length > 0) {
+		const keys = [];
+		for (const term of op.orderBy) {
+			const type = byDb.get(term.column)?.[1].type ?? "";
+			const alias = aliases.get(term.column);
+			if (term.relation || alias === void 0 || !SORTABLE.has(type) && !term.implicit) return tooLong(op, length, max, `its order on "${term.column}" can't be re-applied after splitting it; order by number, uuid, date or time columns`);
+			const desc = term.direction === "desc";
+			keys.push({
+				alias,
+				desc,
+				nullsFirst: (term.nulls ?? (desc ? "first" : "last")) === "first",
+				kind: sortKind(type)
+			});
+		}
+		sort = (rows) => {
+			const decorated = rows.map((row) => ({
+				row,
+				values: keys.map((key) => sortValue(row[key.alias], key.kind))
+			}));
+			decorated.sort((left, right) => {
+				for (const [index, key] of keys.entries()) {
+					const a = left.values[index];
+					const b = right.values[index];
+					if (a === b) continue;
+					if (a === void 0) return key.nullsFirst ? -1 : 1;
+					if (b === void 0) return key.nullsFirst ? 1 : -1;
+					const order = a < b ? -1 : a > b ? 1 : 0;
+					if (order !== 0) return key.desc ? -order : order;
+				}
+				return 0;
+			});
+			return decorated.map(({ row }) => {
+				for (const column of hidden) delete row[column.alias];
+				return row;
+			});
+		};
+	}
+	const chunks = [];
+	let current = {
+		values: [],
+		texts: []
+	};
+	let used = 0;
+	const list = longest;
+	for (const [index, value] of list.values.entries()) {
+		const size = list.sizes[index] ?? 0;
+		if (current.values.length > 0 && used + size > budget) {
+			chunks.push(current);
+			current = {
+				values: [],
+				texts: []
+			};
+			used = 0;
+		}
+		current.values.push(value);
+		current.texts.push(list.texts[index] ?? "");
+		used += size;
+	}
+	if (current.values.length > 0) chunks.push(current);
+	const full = `(${list.condition.value.map(listItem).join(",")})`;
+	const at = plan.filters.findIndex((filter) => filter.kind === "filter" && filter.operator === "in" && filter.path === list.condition.column && filter.value === full);
+	const select = plan.select === void 0 || hidden.length === 0 ? plan.select : `${plan.select},${hidden.map(hiddenText).join(",")}`;
+	const plans = at === -1 ? void 0 : chunks.map((chunk) => ({
+		...plan,
+		select,
+		filters: plan.filters.map((filter, index) => index === at && filter.kind === "filter" ? {
+			...filter,
+			value: `(${chunk.texts.join(",")})`
+		} : filter)
+	}));
+	return {
+		ops: chunks.map(({ values }) => {
+			const where = items.map((item) => item === list.condition ? {
+				...list.condition,
+				value: values
+			} : item);
+			return {
+				...op,
+				...hidden.length > 0 && { selection: {
+					...op.selection,
+					columns: [...op.selection.columns, ...hidden]
+				} },
+				where: where.length === 1 ? where[0] : {
+					kind: "and",
+					items: where
+				}
+			};
+		}),
+		plans,
+		sort
+	};
+}
+/**
+* A comparable value, or `undefined` for SQL null. Times compare by instant,
+* which text can't do across offsets, with the microseconds `Date.parse` drops
+* appended.
+*/
+function sortValue(value, kind) {
+	if (value === null || value === void 0) return;
+	if (kind === "number") return Number(value);
+	if (kind === "bigint") {
+		if (typeof value === "bigint") return value;
+		if (typeof value === "number" && Number.isInteger(value)) return BigInt(value);
+		if (typeof value === "string" && INTEGER.test(value)) return BigInt(value);
+		return Number(value);
+	}
+	const text = String(value);
+	if (kind === "text") return text;
+	const instant = Date.parse(text);
+	if (Number.isNaN(instant)) return text;
+	const micros = (/\.(\d+)/.exec(text)?.[1] ?? "").slice(3, 6).padEnd(3, "0");
+	return `${String(instant + 864e13).padStart(17, "0")}${micros}`;
+}
+//#endregion
+//#region src/core/timeout.ts
+const NO_DEADLINE = (signal) => ({
+	signal,
+	timedOut: () => false,
+	clear: () => {}
+});
+/**
+* Either signal aborting aborts the result. Uses `AbortSignal.any` where the
+* runtime has it; Hermes and older runtimes get the same behaviour by hand.
+*/
+function anySignal(signals) {
+	if (typeof AbortSignal.any === "function") return {
+		signal: AbortSignal.any([...signals]),
+		detach: () => {}
+	};
+	const controller = new AbortController();
+	const abort = () => {
+		controller.abort();
+	};
+	for (const signal of signals) if (signal.aborted) {
+		abort();
+		return {
+			signal: controller.signal,
+			detach: () => {}
+		};
+	}
+	for (const signal of signals) signal.addEventListener("abort", abort);
+	return {
+		signal: controller.signal,
+		detach: () => {
+			for (const signal of signals) signal.removeEventListener("abort", abort);
+		}
+	};
+}
+/** `true` for a timeout the executors and the repository accept. */
+function isTimeout(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+/**
+* `signal` combined with a `timeoutMs` timer. Without a timeout it returns the
+* signal unchanged, so calls without one allocate nothing.
+*/
+function deadline(signal, timeoutMs) {
+	if (timeoutMs === void 0) return NO_DEADLINE(signal);
+	const timer = new AbortController();
+	const handle = setTimeout(() => {
+		timer.abort();
+	}, timeoutMs);
+	const combined = signal ? anySignal([signal, timer.signal]) : {
+		signal: timer.signal,
+		detach: () => {}
+	};
+	return {
+		signal: combined.signal,
+		timedOut: () => timer.signal.aborted && !(signal?.aborted ?? false),
+		clear: () => {
+			clearTimeout(handle);
+			combined.detach();
+		}
+	};
+}
+const NO_TUNING = Object.freeze({});
+/** `invalid_request` text for a bad `timeout` or `retry`, else `undefined`. */
+function invalidTuning(tuning) {
+	if (tuning.timeout !== void 0 && !isTimeout(tuning.timeout)) return `"timeout" must be a positive number of milliseconds, got ${String(tuning.timeout)}`;
+	if (tuning.retry !== void 0 && typeof tuning.retry !== "boolean") return `"retry" must be a boolean, got ${String(tuning.retry)}`;
+}
+/** `timeout` and `retry` from a call's arguments, or why they are invalid. */
+function tuningOf(args) {
+	const timeout = args?.["timeout"];
+	const retry = args?.["retry"];
+	if (timeout === void 0 && retry === void 0) return NO_TUNING;
+	const invalid = invalidTuning({
+		timeout,
+		retry
+	});
+	if (invalid) return { invalid };
+	return {
+		...isTimeout(timeout) ? { timeout } : {},
+		...typeof retry === "boolean" ? { retry } : {}
+	};
+}
+//#endregion
+//#region src/core/postgrest-executor.ts
+function scope(client, schema) {
+	const loose = client;
+	if (schema === "public" || !loose.schema) return loose;
+	let schemas = scopedClients.get(client);
+	if (!schemas) {
+		schemas = /* @__PURE__ */ new Map();
+		scopedClients.set(client, schemas);
+	}
+	let scoped = schemas.get(schema);
+	if (!scoped) {
+		scoped = loose.schema(schema);
+		schemas.set(schema, scoped);
+	}
+	return scoped;
+}
+/**
+* `schema()` builds a new client on every call; one per client and schema is
+* enough.
+*/
+const scopedClients = /* @__PURE__ */ new WeakMap();
+function fromTable(client, schema, table) {
+	return scope(client, schema).from(table);
+}
+/**
+* A POST to the function: arguments such as query vectors are too long for a
+* URL.
+*/
+function fromFunction(client, source, options) {
+	const scoped = scope(client, source.schema);
+	if (!scoped.rpc) throw new TypeError(`better-supabase: the client has no rpc(), needed to read from ${source.name}`);
+	return scoped.rpc(source.name, source.args, options);
+}
+function applyFilters(builder, plan) {
+	let query = builder;
+	for (const filter of plan.filters) query = filter.kind === "filter" ? query.filter(filter.path, filter.operator, filter.value) : query.or(filter.expression, filter.referencedTable ? { referencedTable: filter.referencedTable } : {});
+	return query;
+}
+function applyOrderAndLimits(builder, plan) {
+	let query = builder;
+	for (const order of plan.orders) {
+		const options = { ascending: order.ascending };
+		if (order.nullsFirst !== void 0) options.nullsFirst = order.nullsFirst;
+		if (order.referencedTable) options.referencedTable = order.referencedTable;
+		query = query.order(order.column, options);
+	}
+	for (const limit of plan.limits) query = query.limit(limit.count, limit.referencedTable ? { referencedTable: limit.referencedTable } : {});
+	if (plan.range) query = query.range(plan.range.from, plan.range.to);
+	return query;
+}
+/**
+* A mutation without `returning` reports its row count, `exact` unless the op
+* says otherwise.
+*/
+function countOf(op, plan) {
+	return plan.select === void 0 ? { count: op.count ?? "exact" } : {};
+}
+function bounded(query, op, plan) {
+	if (plan.maxAffected === void 0) return query;
+	if (!query.maxAffected) invalidRequest("\"maxAffected\" needs @supabase/postgrest-js 2 or later", op.table.key);
+	return query.maxAffected(plan.maxAffected);
+}
+function build(client, op, plan) {
+	const base = fromTable(client, op.table.schema, op.table.name);
+	switch (op.kind) {
+		case "select": {
+			const options = {};
+			if (op.count) options.count = op.count;
+			if (op.head) options.head = true;
+			let query = applyOrderAndLimits(applyFilters(op.source ? fromFunction(client, op.source, options).select(plan.select) : base.select(plan.select, options), plan), plan);
+			if (op.single === "one") query = query.single();
+			if (op.single === "maybe") query = query.maybeSingle();
+			return query;
+		}
+		case "insert": {
+			const rows = op.rows.length === 1 ? op.rows[0] : op.rows;
+			const count = countOf(op, plan);
+			let query = op.onConflict ? base.upsert(rows, {
+				onConflict: op.onConflict.columns.join(","),
+				ignoreDuplicates: op.onConflict.action === "ignore",
+				defaultToNull: op.defaultToNull,
+				...count
+			}) : base.insert(rows, {
+				defaultToNull: op.defaultToNull,
+				...count
+			});
+			if (plan.select !== void 0) query = query.select(plan.select);
+			return query;
+		}
+		case "update": {
+			let query = applyFilters(base.update(op.set, countOf(op, plan)), plan);
+			if (plan.select !== void 0) query = query.select(plan.select);
+			return bounded(query, op, plan);
+		}
+		case "delete": {
+			let query = applyFilters(base.delete(countOf(op, plan)), plan);
+			if (plan.select !== void 0) query = query.select(plan.select);
+			return bounded(query, op, plan);
+		}
+		default: return op;
+	}
+}
+function rowsOf(data) {
+	if (data === null || data === void 0) return [];
+	if (Array.isArray(data)) return data;
+	return [data];
+}
+const ONLY_ROWS = /there are only (\d+) rows/;
+/**
+* PostgREST answers a counted read whose offset is past the last row with 416
+* (`PGRST103`); the SQL executor returns no rows and the total.
+*/
+function pastLastRow(op, error) {
+	if (op.kind !== "select" || !op.count || error.code !== "PGRST103") return;
+	const match = ONLY_ROWS.exec(error.details ?? "");
+	return match ? Number(match[1]) : void 0;
+}
+const aborted = () => dbError("aborted", "The request was aborted");
+function tune(builder, signal, retry) {
+	let query = builder;
+	if (signal) query = query.abortSignal(signal);
+	if (retry !== void 0 && query.retry) query = query.retry(retry);
+	return query;
+}
+const timedOut = (ms) => dbError("timeout", `The request timed out after ${ms} ms`);
+const DEFAULT_URL_LENGTH_LIMIT = 6e3;
+/**
+* `urlLengthLimit` on a bare `PostgrestClient`, or on supabase-js's `rest`
+* client.
+*/
+function clientUrlLengthLimit(client) {
+	const loose = client;
+	const limit = loose.urlLengthLimit ?? loose.rest?.urlLengthLimit;
+	return typeof limit === "number" && limit > 0 ? limit : void 0;
+}
+/**
+* The query-string budget for one read: the option, else the lower of 6000 and
+* the client's limit.
+*/
+function resolveUrlLengthLimit(client, options) {
+	const explicit = options.urlLengthLimit;
+	if (explicit !== void 0) return explicit;
+	const fromClient = clientUrlLengthLimit(client);
+	return fromClient === void 0 ? DEFAULT_URL_LENGTH_LIMIT : Math.min(fromClient, DEFAULT_URL_LENGTH_LIMIT);
+}
+/** Chunks of a split read in flight at once. */
+const CHUNK_CONCURRENCY = 4;
+/** Executes IR operations through a supabase-js client. */
+function postgrestExecutor(client, options = {}) {
+	const urlLengthLimit = resolveUrlLengthLimit(client, options);
+	const compileOptions = options.postgrestVersion === void 0 ? {} : { postgrestVersion: options.postgrestVersion };
+	const timeout = isTimeout(options.timeout) ? options.timeout : void 0;
+	const execute = async (op, context) => {
+		let plan;
+		try {
+			plan = compilePostgrest(op, compileOptions);
+		} catch (cause) {
+			return err(toDbError(cause));
+		}
+		if (plan.never) return ok({
+			rows: [],
+			count: 0
+		});
+		if (context.signal?.aborted) return err(aborted());
+		const length = queryLength(plan);
+		if (op.kind !== "select" && length > urlLengthLimit) return err(tooLong(op, length, urlLengthLimit, "a write can't be split into several requests"));
+		if (op.kind === "select" && length > urlLengthLimit) {
+			const chunked = chunkRead(op, plan, urlLengthLimit);
+			if (!("ops" in chunked)) return err(chunked);
+			const results = [];
+			let next = 0;
+			const lane = async () => {
+				while (next < chunked.ops.length) {
+					const index = next;
+					next += 1;
+					const chunk = chunked.ops[index];
+					const chunkPlan = chunked.plans?.[index];
+					const result = await (chunkPlan ? run(chunk, chunkPlan, context) : send(chunk, context));
+					results[index] = result;
+					if (!result.ok) next = chunked.ops.length;
+				}
+			};
+			await Promise.all(Array.from({ length: Math.min(CHUNK_CONCURRENCY, chunked.ops.length) }, lane));
+			const rows = [];
+			for (const result of results) {
+				if (!result.ok) return result;
+				for (const row of result.data.rows) rows.push(row);
+			}
+			return ok({
+				rows: chunked.sort ? chunked.sort(rows) : rows,
+				count: null
+			});
+		}
+		return run(op, plan, context);
+	};
+	const send = (op, context) => {
+		let plan;
+		try {
+			plan = compilePostgrest(op, compileOptions);
+		} catch (cause) {
+			return Promise.resolve(err(toDbError(cause)));
+		}
+		return plan.never ? Promise.resolve(ok({
+			rows: [],
+			count: 0
+		})) : run(op, plan, context);
+	};
+	const run = async (op, plan, context) => {
+		let query;
+		try {
+			query = build(client, op, plan);
+		} catch (cause) {
+			return err(toDbError(cause));
+		}
+		const limit = deadline(context.signal, timeout);
+		try {
+			query = tune(query, limit.signal, context.retry ?? options.retry);
+			const response = await query;
+			if (response.error) {
+				if (limit.timedOut() && timeout !== void 0) return err(timedOut(timeout));
+				if (limit.signal?.aborted) return err(aborted());
+				const total = pastLastRow(op, response.error);
+				if (total !== void 0) return ok({
+					rows: [],
+					count: total
+				});
+				return err(withMaxAffected(mapDbError(response.error, context.errorMappers), plan.maxAffected));
+			}
+			return ok({
+				rows: rowsOf(response.data),
+				count: response.count ?? null
+			});
+		} finally {
+			limit.clear();
+		}
+	};
+	return {
+		name: "postgrest",
+		functionSources: true,
+		execute,
+		async rpc(name, args, context) {
+			if (options.rpcUnavailable !== void 0) return err(dbError("unsupported", options.rpcUnavailable, {
+				code: "RPC_UNAVAILABLE",
+				details: `rpc("${name}")`
+			}));
+			const scoped = scope(client, context.schema);
+			if (!scoped.rpc) return err(toDbError(/* @__PURE__ */ new Error("The client does not support rpc()")));
+			if (context.signal?.aborted) return err(aborted());
+			const called = context.get ? scoped.rpc(name, queryArgs(args), { get: true }) : scoped.rpc(name, args);
+			const built = context.select ? called.select(context.select.map(({ column, cast }) => cast ? `${column}::${cast}` : column).join(",")) : called;
+			const limit = deadline(context.signal, timeout);
+			try {
+				const response = await tune(built, limit.signal, context.retry ?? options.retry);
+				if (response.error) {
+					if (limit.timedOut() && timeout !== void 0) return err(timedOut(timeout));
+					if (limit.signal?.aborted) return err(aborted());
+					return err(mapDbError(response.error, context.errorMappers));
+				}
+				return ok(response.data);
+			} finally {
+				limit.clear();
+			}
+		}
+	};
+}
+/**
+* GET arguments travel in the query string, where supabase-js would print an
+* object as `[object Object]`; json and jsonb parameters take it as JSON.
+*/
+function queryArgs(args) {
+	return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, typeof value === "object" && value !== null && !Array.isArray(value) ? JSON.stringify(value) : value]));
+}
+/** The compiled plan for an operation; useful for debugging and tests. */
+function explainPostgrest(op, options) {
+	return compilePostgrest(op, options);
+}
+//#endregion
+//#region src/core/stats.ts
+const EMPTY_STATS = {
+	calls: 0,
+	waves: 0,
+	tables: [],
+	ms: 0
+};
+/**
+* Counts calls and waves. A recorder with a `parent` also reports to it, so a
+* request-wide recorder sees every scope's calls.
+*/
+var StatsRecorder = class {
+	#parent;
+	#now;
+	#tables = /* @__PURE__ */ new Set();
+	#calls = 0;
+	#waves = 0;
+	#inFlight = 0;
+	#first;
+	#last;
+	constructor(parent, now = () => performance.now()) {
+		this.#parent = parent;
+		this.#now = now;
+	}
+	/** Records a call to `table`; the returned function ends it. */
+	begin(table) {
+		const end = this.#parent?.begin(table);
+		const started = this.#now();
+		if (this.#inFlight === 0) this.#waves += 1;
+		this.#inFlight += 1;
+		this.#calls += 1;
+		this.#tables.add(table);
+		this.#first ??= started;
+		let ended = false;
+		return () => {
+			if (ended) return;
+			ended = true;
+			this.#inFlight -= 1;
+			this.#last = Math.max(this.#last ?? 0, this.#now());
+			end?.();
+		};
+	}
+	/** The totals so far. */
+	snapshot() {
+		return {
+			calls: this.#calls,
+			waves: this.#waves,
+			tables: [...this.#tables],
+			ms: this.#first === void 0 || this.#last === void 0 ? 0 : Math.round((this.#last - this.#first) * 100) / 100
+		};
+	}
+};
+/** Wraps an executor so every call is recorded. */
+function recordStats(executor, recorder) {
+	const wrapped = {
+		name: executor.name,
+		async execute(op, context) {
+			const end = recorder.begin(op.table.key);
+			try {
+				return await executor.execute(op, context);
+			} finally {
+				end();
+			}
+		}
+	};
+	if (executor.rpc) {
+		const rpc = executor.rpc.bind(executor);
+		return {
+			...wrapped,
+			async rpc(name, args, context) {
+				const end = recorder.begin(`${name}()`);
+				try {
+					return await rpc(name, args, context);
+				} finally {
+					end();
+				}
+			}
+		};
+	}
+	return wrapped;
+}
+//#endregion
+export { postgrestExecutor as a, invalidTuning as c, explainPostgrest as i, tuningOf as l, StatsRecorder as n, NO_TUNING as o, recordStats as r, deadline as s, EMPTY_STATS as t, compilePostgrest as u };