better-supabase 0.2.0 → 0.4.0

package/dist/{define-BXMYD9AY.js → define-Bh0AqTik.js}

@@ -1,13 +1,16 @@
-import { n as dbError, t as DbException } from "./errors-Bl3rkOzo.js";
-import { a as invalidRequest, c as needsDecoding, o as decodeRows, r as IrBuilder, s as encodeValue } from "./simplify-bwJpLnaS.js";
-import { i as or, t as and } from "./types-6cYK9pbJ.js";
-import { i as ok, n as err, o as toDbError, s as withErrorMapper, t as AsyncResult } from "./result-DWXatkd6.js";
-import { t as invalidationTargets } from "./tables-rZxRxNPW.js";
+import { n as dbError, t as DbException } from "./errors-L0xK41y_.js";
+import { a as invalidRequest, c as needsDecoding, o as decodeRows, r as builderFor, s as encodeValue } from "./simplify-Cqvfr9dj.js";
+import { t as lookupOf } from "./lookup-BaP5bI27.js";
+import { n as nowInstant } from "./temporal-BwshQk0W.js";
+import { i as or, n as column, r as not, t as and } from "./types-6cYK9pbJ.js";
+import { i as ok, n as err, o as toDbError, s as withErrorMapper, t as AsyncResult } from "./result-Bj6yt33D.js";
+import { t as invalidationTargets } from "./tables-Cb-3_VWc.js";
 import { t as consoleLogger } from "./logger-glM28NVN.js";
 import { r as orderPlugins } from "./plugin-BqR6wKMB.js";
-import { a as postgrestExecutor, n as StatsRecorder, r as recordStats } from "./stats-C5W-rBfR.js";
-import { d as isQuerySpec, f as specTables, n as checkParams, o as isReadSet, r as containsPlaceholder, t as bindParams, u as createSpecs } from "./read-set-4lI3W_gZ.js";
-import { t as validate } from "./standard-FUi3Z3-7.js";
+import { a as postgrestExecutor, n as StatsRecorder, r as recordStats } from "./stats-C_YxA2r1.js";
+import { d as isQuerySpec, f as specTables, n as checkParams, o as isReadSet, r as containsPlaceholder, t as bindParams, u as createSpecs } from "./read-set-FWK8qQ58.js";
+import { a as toBase64Url, t as base64ToText } from "./base64-D2gsioCY.js";
+import { t as validate } from "./standard-BRyBGTtp.js";
 //#region src/core/batch.ts
 /**
 * Holds operations until each of `readers` has either submitted one or
@@ -93,12 +96,18 @@ function memoryCache() {
 }
 //#endregion
 //#region src/core/events.ts
+/** More handlers than this for one event usually means a missing unsubscribe. */
+const HANDLER_WARNING = 50;
+function isDevelopment() {
+	return typeof process !== "undefined" && process.env["NODE_ENV"] !== "production";
+}
 /**
 * Observers only: a handler that throws is reported to the logger and never
 * changes a result.
 */
 var EventHub = class {
 	#handlers = /* @__PURE__ */ new Map();
+	#warned = /* @__PURE__ */ new Set();
 	logger;
 	constructor(logger = consoleLogger) {
 		this.logger = logger;
@@ -110,6 +119,10 @@ var EventHub = class {
 			this.#handlers.set(name, set);
 		}
 		set.add(handler);
+		if (set.size > HANDLER_WARNING && !this.#warned.has(name) && isDevelopment()) {
+			this.#warned.add(name);
+			this.logger.warn(`${set.size} "${name}" handlers are registered; call the function on() returns to remove one you no longer need`);
+		}
 		return () => {
 			set.delete(handler);
 		};
@@ -129,27 +142,13 @@ var EventHub = class {
 };
 //#endregion
 //#region src/core/cursor.ts
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-function toBase64Url(bytes) {
-	let binary = "";
-	for (const byte of bytes) binary += String.fromCharCode(byte);
-	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function fromBase64Url(text) {
-	const base64 = text.replace(/-/g, "+").replace(/_/g, "/");
-	const binary = atob(base64 + "=".repeat((4 - base64.length % 4) % 4));
-	const bytes = new Uint8Array(binary.length);
-	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
-	return bytes;
-}
 /** Opaque, URL-safe keyset cursor. */
 function encodeCursor(values) {
-	return toBase64Url(encoder.encode(JSON.stringify(values)));
+	return toBase64Url(JSON.stringify(values));
 }
 function decodeCursor(cursor) {
 	try {
-		const parsed = JSON.parse(decoder.decode(fromBase64Url(cursor)));
+		const parsed = JSON.parse(base64ToText(cursor));
 		return Array.isArray(parsed) ? parsed : void 0;
 	} catch {
 		return;
@@ -182,11 +181,28 @@ const KNOWN_KEYS = /* @__PURE__ */ new Set([
 	"_min",
 	"_max"
 ]);
+const NO_OPTIONS = Object.freeze({});
 function optionsOf(args) {
-	if (!args) return {};
-	const options = {};
-	for (const [key, value] of Object.entries(args)) if (!KNOWN_KEYS.has(key)) options[key] = value;
-	return options;
+	if (!args) return NO_OPTIONS;
+	let options;
+	for (const key in args) if (!KNOWN_KEYS.has(key) && Object.hasOwn(args, key)) (options ??= {})[key] = args[key];
+	return options ?? NO_OPTIONS;
+}
+const hooksByPlugins = /* @__PURE__ */ new WeakMap();
+function hooksOf(plugins) {
+	let hooks = hooksByPlugins.get(plugins);
+	if (!hooks) {
+		hooks = {
+			transformQuery: plugins.filter((plugin) => plugin.transformQuery),
+			beforeMutation: plugins.filter((plugin) => plugin.beforeMutation),
+			afterMutation: plugins.filter((plugin) => plugin.afterMutation)
+		};
+		hooksByPlugins.set(plugins, hooks);
+	}
+	return hooks;
+}
+function isThenable(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
 function signalOf(args) {
 	const signal = args?.["signal"];
@@ -199,8 +215,10 @@ function mutationKind(op) {
 /** Runs operations through plugins, the executor and the event hub. */
 var OperationRunner = class {
 	runtime;
+	#hooks;
 	constructor(runtime) {
 		this.runtime = runtime;
+		this.#hooks = hooksOf(runtime.plugins);
 	}
 	hookArgs(table, options) {
 		return {
@@ -213,30 +231,43 @@ var OperationRunner = class {
 	}
 	async run(op, options, signal) {
 		const { runtime } = this;
-		const hook = this.hookArgs(op.table, options);
+		const hooks = this.#hooks;
 		let current = op;
-		try {
-			for (const plugin of runtime.plugins) if (plugin.transformQuery) current = plugin.transformQuery(current, hook);
-			if (current.kind !== "select") {
-				let mutation = current;
-				for (const plugin of runtime.plugins) if (plugin.beforeMutation) mutation = await plugin.beforeMutation(mutation, hook);
-				current = mutation;
+		if (hooks.transformQuery.length > 0 || hooks.beforeMutation.length > 0) {
+			const hook = this.hookArgs(op.table, options);
+			try {
+				for (const plugin of hooks.transformQuery) current = plugin.transformQuery(current, hook);
+				if (current.kind !== "select") {
+					let mutation = current;
+					for (const plugin of hooks.beforeMutation) {
+						const next = plugin.beforeMutation(mutation, hook);
+						mutation = isThenable(next) ? await next : next;
+					}
+					current = mutation;
+				}
+			} catch (cause) {
+				if (cause instanceof DbException) return this.fail(op.table, cause.error);
+				throw cause;
 			}
-		} catch (cause) {
-			if (cause instanceof DbException) return this.fail(op.table, cause.error);
-			throw cause;
 		}
-		const started = performance.now();
+		const timed = runtime.events.has("query");
+		const started = timed ? performance.now() : 0;
 		const context = signal ? {
 			signal,
 			errorMappers: runtime.errorMappers
 		} : { errorMappers: runtime.errorMappers };
 		const executed = await runtime.executor.execute(current, context);
 		const selection = current.kind === "select" ? current.selection : current.returning;
-		const result = executed.ok && selection && needsDecoding(selection) ? ok({
-			...executed.data,
-			rows: decodeRows(selection, executed.data.rows)
-		}) : executed;
+		let result = executed;
+		if (executed.ok && selection && needsDecoding(selection)) try {
+			result = ok({
+				...executed.data,
+				rows: decodeRows(selection, executed.data.rows, true)
+			});
+		} catch (cause) {
+			if (cause instanceof DbException) return this.fail(op.table, cause.error);
+			throw cause;
+		}
 		const rows = result.ok ? result.data.rows.length : 0;
 		const truncated = current.kind === "select" && current.limit === void 0 && current.single === void 0 && !current.head && rows >= runtime.maxRows;
 		if (truncated && !runtime.truncatedTables.has(op.table.key)) {
@@ -246,7 +277,7 @@ var OperationRunner = class {
 				maxRows: runtime.maxRows
 			});
 		}
-		if (runtime.events.has("query")) runtime.events.emit("query", {
+		if (timed) runtime.events.emit("query", {
 			table: op.table.key,
 			operation: current.kind,
 			ok: result.ok,
@@ -260,21 +291,22 @@ var OperationRunner = class {
 	}
 	async afterMutation(op, data) {
 		const { runtime } = this;
+		const plugins = this.#hooks.afterMutation;
+		const listening = runtime.events.has("mutation");
+		if (plugins.length === 0 && !listening) return;
 		const event = {
 			table: op.table,
 			kind: mutationKind(op),
 			rows: data.rows,
 			context: runtime.context
 		};
-		for (const plugin of runtime.plugins) {
-			if (!plugin.afterMutation) continue;
-			try {
-				await plugin.afterMutation(event);
-			} catch (cause) {
-				runtime.events.logger.error(`plugin "${plugin.name}" afterMutation threw`, { cause });
-			}
+		for (const plugin of plugins) try {
+			const pending = plugin.afterMutation(event);
+			if (isThenable(pending)) await pending;
+		} catch (cause) {
+			runtime.events.logger.error(`plugin "${plugin.name}" afterMutation threw`, { cause });
 		}
-		runtime.events.emit("mutation", {
+		if (listening) runtime.events.emit("mutation", {
 			table: op.table.key,
 			kind: event.kind,
 			rows: event.rows,
@@ -286,7 +318,7 @@ var OperationRunner = class {
 			...error,
 			table: table.key
 		};
-		this.runtime.events.emit("error", {
+		if (this.runtime.events.has("error")) this.runtime.events.emit("error", {
 			table: table.key,
 			error: withTable
 		});
@@ -312,19 +344,22 @@ function createRepository(runner, table) {
 	});
 	const returning = (args) => args?.["returning"] === false ? void 0 : selection(args);
 	const run = (op, args) => runner.run(op, optionsOf(args), signalOf(args));
+	let primaryOrder;
+	/** `primaryKey` holds app names; order terms take database names. */
+	const defaultOrder = () => primaryOrder ??= table.primaryKey.map((name) => ({
+		column: builder.column(table, name),
+		direction: "asc"
+	}));
 	const notFound = () => runner.fail(table, dbError("not_found", `No ${table.key} row matched`));
 	const base = {
-		$table: table.key,
+		$tableName: table.key,
 		$meta: table,
 		findMany(args) {
 			return AsyncResult.from(async () => {
 				const op = selectOp(args);
 				const ordered = op.orderBy.length > 0 || table.primaryKey.length === 0 ? op : {
 					...op,
-					orderBy: table.primaryKey.map((column) => ({
-						column,
-						direction: "asc"
-					}))
+					orderBy: defaultOrder()
 				};
 				const result = await run(ordered, args);
 				return result.ok ? ok(result.data.rows) : result;
@@ -515,10 +550,11 @@ function createRepository(runner, table) {
 		}
 	};
 	function insertOp(rows, args, conflict) {
+		const built = rows.map((row) => builder.row(table, row));
 		return {
 			kind: "insert",
 			table,
-			rows: rows.map((row) => builder.row(table, row)),
+			rows: conflict && built.length > 1 ? byKey(built, conflict) : built,
 			returning: returning(args),
 			onConflict: conflict ? {
 				columns: conflict,
@@ -572,7 +608,8 @@ function createRepository(runner, table) {
 		if (typeof args["after"] === "string") {
 			const values = decodeCursor(args["after"]);
 			if (!values || values.length !== orderBy.length) return runner.fail(table, dbError("invalid_request", "Invalid cursor"));
-			after = keysetCondition(orderBy, values);
+			const { byDb } = lookupOf(table);
+			after = keysetCondition(orderBy, values, (name) => byDb.get(name)?.[1].nullable ?? true);
 		}
 		const op = selectOp(args, {
 			selection: withSort,
@@ -586,7 +623,8 @@ function createRepository(runner, table) {
 		const rows = result.data.rows.slice(0, size);
 		const hasMore = result.data.rows.length > size;
 		const last = rows.at(-1);
-		const nextCursor = hasMore && last ? encodeCursor(orderBy.map((term) => encodeValue(last[aliasOf(withSort, term.column)]))) : null;
+		const aliases = new Map(withSort.columns.map((entry) => [entry.column, entry.alias]));
+		const nextCursor = hasMore && last ? encodeCursor(orderBy.map((term) => encodeValue(last[aliases.get(term.column) ?? term.column]))) : null;
 		return ok({
 			items: added.length > 0 ? rows.map((row) => strip(row, added)) : rows,
 			nextCursor,
@@ -606,14 +644,17 @@ function createRepository(runner, table) {
 	}
 	function ensureColumns(base, orderBy) {
 		const columns = [...base.columns];
+		const selected = new Set(columns.map((entry) => entry.column));
+		const { byDb } = lookupOf(table);
 		const added = [];
 		for (const term of orderBy) {
-			if (columns.some((entry) => entry.column === term.column)) continue;
-			const alias = Object.entries(table.columns).find(([, meta]) => meta.db === term.column)?.[0] ?? term.column;
+			if (selected.has(term.column)) continue;
+			const alias = byDb.get(term.column)?.[0] ?? term.column;
 			columns.push({
 				alias,
 				column: term.column
 			});
+			selected.add(term.column);
 			added.push(alias);
 		}
 		return {
@@ -626,32 +667,60 @@ function createRepository(runner, table) {
 	}
 	return base;
 }
-function aliasOf(selection, column) {
-	return selection.columns.find((entry) => entry.column === column)?.alias ?? column;
-}
 function strip(row, keys) {
-	const copy = { ...row };
-	for (const key of keys) delete copy[key];
+	const copy = {};
+	for (const key in row) if (!keys.includes(key) && Object.hasOwn(row, key)) copy[key] = row[key];
 	return copy;
 }
-/** `(a, b) > (x, y)` for mixed directions, as an OR of ANDs. */
-function keysetCondition(orderBy, values) {
-	const branches = orderBy.map((term, index) => {
-		const equal = orderBy.slice(0, index).map((prev, prevIndex) => ({
-			kind: "column",
-			column: prev.column,
-			op: "eq",
-			value: values[prevIndex]
-		}));
-		const step = {
-			kind: "column",
-			column: term.column,
-			op: term.direction === "asc" ? "gt" : "lt",
-			value: values[index]
-		};
-		return and(...equal, step) ?? step;
+/**
+* Rows in conflict-key order, so concurrent upserts lock the same rows in
+* the same order instead of deadlocking.
+*/
+function byKey(rows, columns) {
+	const compare = (left, right) => {
+		if (left === right) return 0;
+		if (left === null || left === void 0) return 1;
+		if (right === null || right === void 0) return -1;
+		if (typeof left === "number" && typeof right === "number") return left - right;
+		if (typeof left === "bigint" && typeof right === "bigint") return left < right ? -1 : 1;
+		const a = String(left);
+		const b = String(right);
+		return a < b ? -1 : a > b ? 1 : 0;
+	};
+	const keyed = rows.map((row) => ({
+		row,
+		key: columns.map((column) => {
+			const value = row[column];
+			return typeof value === "object" && value !== null ? String(value) : value;
+		})
+	}));
+	keyed.sort((left, right) => {
+		for (let index = 0; index < columns.length; index++) {
+			const order = compare(left.key[index], right.key[index]);
+			if (order !== 0) return order;
+		}
+		return 0;
+	});
+	return keyed.map((entry) => entry.row);
+}
+/**
+* The rows after the cursor `values` in `orderBy` order, as an OR of ANDs:
+* `a > x or (a = x and b > y)`. The SQL compiler sends that shape as the row
+* comparison `(a, b) > (x, y)`. Nulls sort where Postgres puts them: last
+* for `asc`, first for `desc`, unless the term says otherwise.
+*/
+function keysetCondition(orderBy, values, nullable) {
+	const isNull = (name) => column(name, "is", null);
+	const branches = orderBy.flatMap((term, index) => {
+		const value = values[index];
+		const nullsFirst = (term.nulls ?? (term.direction === "desc" ? "first" : "last")) === "first";
+		const after = column(term.column, term.direction === "asc" ? "gt" : "lt", value);
+		const step = value === null ? nullsFirst ? not(isNull(term.column)) : void 0 : nullsFirst || !nullable(term.column) ? after : or(after, isNull(term.column));
+		if (!step) return [];
+		const equal = orderBy.slice(0, index).map((prev, prevIndex) => values[prevIndex] === null ? isNull(prev.column) : column(prev.column, "eq", values[prevIndex]));
+		return [and(...equal, step) ?? step];
 	});
-	return or(...branches);
+	return branches.length > 0 ? or(...branches) : column(orderBy[0]?.column ?? "", "in", []);
 }
 //#endregion
 //#region src/core/search.ts
@@ -698,7 +767,7 @@ var BetterSupabase = class BetterSupabase {
 	* A token that fails it resolves to `{ kind: 'invalid', reason: 'claims' }`.
 	*
 	* ```ts
-	* const sb = defineSupabase(schema).claims(z.object({ tenant_id: z.uuid() }));
+	* const betterSupabase = defineSupabase(schema).claims(z.object({ tenant_id: z.uuid() }));
 	* ```
 	*/
 	claims(schema) {
@@ -716,7 +785,7 @@ var BetterSupabase = class BetterSupabase {
 	* the verified claims, never from `profile`.
 	*
 	* ```ts
-	* const sb = defineSupabase(schema).userMetadata(z.object({ display_name: z.string() }));
+	* const betterSupabase = defineSupabase(schema).userMetadata(z.object({ display_name: z.string() }));
 	* ```
 	*/
 	userMetadata(schema) {
@@ -731,7 +800,7 @@ var BetterSupabase = class BetterSupabase {
 	* Results themselves keep their `DbError`.
 	*
 	* ```ts
-	* const sb = defineSupabase(schema).mapError((error) => new AppError(error));
+	* const betterSupabase = defineSupabase(schema).mapError((error) => new AppError(error));
 	* ```
 	*/
 	mapError(mapper) {
@@ -742,9 +811,14 @@ var BetterSupabase = class BetterSupabase {
 	}
 	#specs;
 	#truncatedTables = /* @__PURE__ */ new Set();
+	/** A hub without listeners, for decoding read-set results. */
+	#decodeEvents;
+	/** One getter per table, shared by every db this instance connects. */
+	#tables;
+	#errorMappers = /* @__PURE__ */ new WeakMap();
 	/**
 	* Builds serializable `QuerySpec`s with the same arguments and result types
-	* as the repository: `sb.spec.customers.findMany({ select: ['id'] })`.
+	* as the repository: `betterSupabase.spec.customers.findMany({ select: ['id'] })`.
 	*/
 	get spec() {
 		this.#specs ??= createSpecs(this.meta);
@@ -765,7 +839,7 @@ var BetterSupabase = class BetterSupabase {
 	* invalidate them after it succeeds.
 	*
 	* ```ts
-	* sb.defineRpc('archive_customer', { invalidates: ['customers', 'notes'] });
+	* betterSupabase.defineRpc('archive_customer', { invalidates: ['customers', 'notes'] });
 	* ```
 	*/
 	defineRpc(name, options) {
@@ -796,7 +870,9 @@ var BetterSupabase = class BetterSupabase {
 		const invalidate = (target) => {
 			try {
 				const pending = adapter.invalidate(target);
-				if (pending) pending.catch((cause) => report(cause, target.table));
+				if (pending) pending.catch((cause) => {
+					report(cause, target.table);
+				});
 			} catch (cause) {
 				report(cause, target.table);
 			}
@@ -822,20 +898,26 @@ var BetterSupabase = class BetterSupabase {
 		let executor = base;
 		for (const plugin of plugins) if (plugin.wrapExecutor) executor = plugin.wrapExecutor(executor);
 		executor = recordStats(executor, recorder);
-		const errorMappers = [...this.options.errors ?? [], ...plugins.flatMap((plugin) => plugin.mapError ? [plugin.mapError] : [])];
+		const errorMappers = this.#errorMappersFor(plugins);
 		const runner = new OperationRunner({
 			meta: this.meta,
-			builder: new IrBuilder(this.meta),
+			builder: builderFor(this.meta),
 			executor,
 			plugins,
 			context,
 			events,
 			errorMappers,
-			now: this.options.now ?? (() => /* @__PURE__ */ new Date()),
+			now: this.options.now ?? nowInstant,
 			maxRows: this.options.maxRows ?? 1e3,
 			truncatedTables: this.#truncatedTables
 		});
-		const db = {
+		const db = Object.create(this.#tablePrototype());
+		dbStates.set(db, {
+			runner,
+			plugins,
+			repositories: /* @__PURE__ */ new Map()
+		});
+		Object.assign(db, {
 			$client: client,
 			$executor: executor,
 			$context: context,
@@ -903,10 +985,10 @@ var BetterSupabase = class BetterSupabase {
 					hint: `Add "${table.schema}.${table.name}" to vectorSearch in better-supabase.config.ts and run \`better-supabase sql sync\`.`
 				}) : result;
 			})
-		};
+		});
 		const many = (specs, signal, usePlugins) => AsyncResult.from(async () => {
 			const invalid = specs.findIndex((spec) => !isQuerySpec(spec));
-			if (invalid !== -1) return err(dbError("invalid_request", `db.$many() entry ${invalid} is not a QuerySpec from sb.spec`));
+			if (invalid !== -1) return err(dbError("invalid_request", `db.$many() entry ${invalid} is not a QuerySpec from betterSupabase.spec`));
 			const active = usePlugins ? plugins : [];
 			const batch = base.batch?.bind(base);
 			const batching = batch && specs.length > 1 ? batchingExecutor({
@@ -954,21 +1036,6 @@ var BetterSupabase = class BetterSupabase {
 			"$many",
 			"$search"
 		]) db[name] = mapThrows(db[name], throwAs);
-		for (const [key, table] of Object.entries(this.meta.tables)) {
-			let repository;
-			Object.defineProperty(db, key, {
-				enumerable: true,
-				get: () => {
-					if (!repository) {
-						repository = this.#repository(runner, key, table, plugins);
-						if (throwAs) {
-							for (const [name, method] of Object.entries(repository)) if (typeof method === "function" && name !== "extend") repository[name] = mapThrows(method, throwAs);
-						}
-					}
-					return repository;
-				}
-			});
-		}
 		return db;
 	}
 	/**
@@ -985,22 +1052,55 @@ var BetterSupabase = class BetterSupabase {
 			const rows = entry.rows ?? [];
 			const result = await runSpec(this.#db(client, {
 				name: "read-set",
-				execute: async (op) => {
+				execute: (op) => {
 					if (op.kind === "select" && op.single) {
-						if (rows.length > 1) return err(dbError("multiple_rows", `Expected one ${op.table.key} row`));
-						if (rows.length === 0 && op.single === "one") return err(dbError("not_found", `No ${op.table.key} row matched`));
+						if (rows.length > 1) return Promise.resolve(err(dbError("multiple_rows", `Expected one ${op.table.key} row`)));
+						if (rows.length === 0 && op.single === "one") return Promise.resolve(err(dbError("not_found", `No ${op.table.key} row matched`)));
 					}
-					return ok({
+					return Promise.resolve(ok({
 						rows,
 						count: entry.count ?? null
-					});
+					}));
 				}
-			}, context, [], new StatsRecorder(), new EventHub(this.events.logger)), spec, void 0);
+			}, context, [], new StatsRecorder(), this.#decodeEvents ??= new EventHub(this.events.logger)), spec, void 0);
 			if (!result.ok) return result;
 			out[key] = result.data;
 		}
 		return ok(out);
 	}
+	#errorMappersFor(plugins) {
+		let mappers = this.#errorMappers.get(plugins);
+		if (!mappers) {
+			mappers = [...this.options.errors ?? [], ...plugins.flatMap((plugin) => plugin.mapError ? [plugin.mapError] : [])];
+			this.#errorMappers.set(plugins, mappers);
+		}
+		return mappers;
+	}
+	#tablePrototype() {
+		if (this.#tables) return this.#tables;
+		const tables = {};
+		const throwAs = this.options.throwAs;
+		const build = (state, key) => {
+			let repository = state.repositories.get(key);
+			if (repository) return repository;
+			const table = this.meta.tables[key];
+			repository = this.#repository(state.runner, key, table, state.plugins);
+			if (throwAs) {
+				for (const [name, method] of Object.entries(repository)) if (typeof method === "function" && name !== "extend") repository[name] = mapThrows(method, throwAs);
+			}
+			state.repositories.set(key, repository);
+			return repository;
+		};
+		for (const key of Object.keys(this.meta.tables)) Object.defineProperty(tables, key, {
+			enumerable: true,
+			get() {
+				const state = dbStates.get(this);
+				return state ? build(state, key) : void 0;
+			}
+		});
+		this.#tables = tables;
+		return tables;
+	}
 	#repository(runner, key, table, plugins) {
 		const repository = createRepository(runner, table);
 		for (const plugin of plugins) {
@@ -1021,6 +1121,7 @@ var BetterSupabase = class BetterSupabase {
 		return repository;
 	}
 };
+const dbStates = /* @__PURE__ */ new WeakMap();
 function mapThrows(method, throwAs) {
 	return function(...args) {
 		const value = method.apply(this, args);
@@ -1028,7 +1129,7 @@ function mapThrows(method, throwAs) {
 	};
 }
 function runSpec(db, spec, signal) {
-	if (!isQuerySpec(spec)) return AsyncResult.err(dbError("invalid_request", "db.$run() expects a QuerySpec from sb.spec"));
+	if (!isQuerySpec(spec)) return AsyncResult.err(dbError("invalid_request", "db.$run() expects a QuerySpec from betterSupabase.spec"));
 	const method = db[spec.table]?.[spec.method];
 	if (!method) return AsyncResult.err(dbError("invalid_request", `Unknown table "${spec.table}" in QuerySpec`));
 	if (containsPlaceholder(spec.args)) return AsyncResult.err(dbError("invalid_request", "This spec comes from a read set and still holds placeholders; run it with db.$many(readSet, params)"));
@@ -1061,7 +1162,7 @@ function rpc(executor, errorMappers, name, rest) {
 * Creates the data-layer definition from the generated `schema`.
 *
 * ```ts
-* export const sb = defineSupabase(schema).use(timestamps()).use(softDelete());
+* export const betterSupabase = defineSupabase(schema).use(timestamps()).use(softDelete());
 * ```
 */
 function defineSupabase(schema, options) {