better-supabase 0.0.0 → 0.1.0

package/dist/plugins/timestamps/index.js

@@ -0,0 +1,37 @@
+import { n as definePlugin } from "../../plugin-BqR6wKMB.js";
+import { i as insertsOnly, l as withDefault, t as dbName } from "../../shared-_6-uPL7E.js";
+//#region src/plugins/timestamps/index.ts
+/**
+* Stamps the columns generated as `Flags.timestamps`: `createdAt` on insert,
+* `updatedAt` on insert and update. Values the caller passes win. Pair it with
+* the `updated-at` SQL kit trigger to cover writes that bypass the app.
+*/
+function timestamps() {
+	return definePlugin({
+		name: "timestamps",
+		beforeMutation(op, { table, now }) {
+			const flags = table.flags.timestamps;
+			if (!flags) return op;
+			const created = dbName(table, flags.createdAt);
+			const updated = dbName(table, flags.updatedAt);
+			const stamp = now().toISOString();
+			switch (op.kind) {
+				case "insert": {
+					const stampCreated = insertsOnly(op);
+					return {
+						...op,
+						rows: op.rows.map((row) => withDefault(stampCreated ? withDefault(row, created, stamp) : row, updated, stamp))
+					};
+				}
+				case "update": return {
+					...op,
+					set: withDefault(op.set, updated, stamp)
+				};
+				case "delete": return op;
+				default: return op;
+			}
+		}
+	});
+}
+//#endregion
+export { timestamps };

package/dist/plugins/validation/index.d.ts

@@ -0,0 +1,24 @@
+import { f as Plugin } from "../../plugin-HvGqCurB.js";
+import { t as StandardSchemaV1 } from "../../standard-CyhRzctb.js";
+//#region src/plugins/validation/index.d.ts
+export interface TableValidators {
+  /** Validates inserts and upserts, with app-cased keys. */
+  readonly insert?: StandardSchemaV1;
+  /** Validates update patches, with app-cased keys. */
+  readonly update?: StandardSchemaV1;
+}
+export interface ValidationOptions {
+  /**
+   * Validators per table key. The `validators` export of a generated
+   * `zod()` or `valibot()` module fits as is.
+   */
+  readonly schemas: Readonly<Record<string, TableValidators>>;
+}
+/**
+ * Validates writes with Standard Schema validators (zod, valibot, arktype,
+ * ...). Runs after other plugins (`enforce: 'post'`), so it sees the tenant,
+ * timestamp and actor columns they fill. Failures become `validation` errors
+ * (422) with issue paths; bulk writes prefix the row index.
+ */
+export declare function validation(options: ValidationOptions): Plugin<"validation">;
+//#endregion

package/dist/plugins/validation/index.js

@@ -0,0 +1,59 @@
+import { n as dbError, t as DbException } from "../../errors-Bl3rkOzo.js";
+import { n as definePlugin } from "../../plugin-BqR6wKMB.js";
+import { t as validate } from "../../standard-FUi3Z3-7.js";
+import { c as toDb, s as toApp } from "../../shared-_6-uPL7E.js";
+//#region src/plugins/validation/index.ts
+async function check(schema, table, row, label, index) {
+	const result = await validate(schema, toApp(table, row), label);
+	if (result.ok) {
+		const output = result.data;
+		return typeof output === "object" && output !== null ? toDb(table, output) : { ...row };
+	}
+	const error = result.error;
+	if (index === void 0 || error.kind !== "validation") throw new DbException(error);
+	const issues = error.issues.map((issue) => ({
+		message: issue.message,
+		path: [index, ...issue.path ?? []]
+	}));
+	throw new DbException(dbError("validation", error.message, { issues }));
+}
+/**
+* Validates writes with Standard Schema validators (zod, valibot, arktype,
+* ...). Runs after other plugins (`enforce: 'post'`), so it sees the tenant,
+* timestamp and actor columns they fill. Failures become `validation` errors
+* (422) with issue paths; bulk writes prefix the row index.
+*/
+function validation(options) {
+	return definePlugin({
+		name: "validation",
+		enforce: "post",
+		async beforeMutation(op, { table }) {
+			const validators = options.schemas[table.key];
+			if (!validators) return op;
+			switch (op.kind) {
+				case "insert": {
+					const schema = validators.insert;
+					if (!schema) return op;
+					const many = op.rows.length > 1;
+					const rows = await Promise.all(op.rows.map((row, index) => check(schema, table, row, `${table.key} insert`, many ? index : void 0)));
+					return {
+						...op,
+						rows
+					};
+				}
+				case "update": {
+					const schema = validators.update;
+					if (!schema) return op;
+					return {
+						...op,
+						set: await check(schema, table, op.set, `${table.key} update`, void 0)
+					};
+				}
+				case "delete": return op;
+				default: return op;
+			}
+		}
+	});
+}
+//#endregion
+export { validation };

package/dist/pool-BFeqzwQS.d.ts

@@ -0,0 +1,37 @@
+import { t as SqlClient } from "./executor-Bje4suQF.js";
+//#region src/postgres/pool.d.ts
+interface PostgresOptions {
+  /** Defaults to `$SUPABASE_DB_URL`, then `$DATABASE_URL`. */
+  readonly connectionString?: string;
+  readonly max?: number;
+  /** Statement timeout in milliseconds, applied per transaction. */
+  readonly statementTimeout?: number;
+}
+/** JWT claims to run as. `role` must be `authenticated` or `anon`. */
+interface SqlClaims {
+  readonly sub?: string;
+  readonly role?: string;
+  readonly [claim: string]: unknown;
+}
+interface Postgres {
+  /** Connects as the connection-string role. On Supabase that bypasses RLS. */
+  readonly admin: SqlClient;
+  /** Runs every query as the given user, with RLS, like PostgREST does. */
+  asUser(claims: SqlClaims): SqlClient;
+  /** Runs every query as `anon`. */
+  readonly anon: SqlClient;
+  /** Runs `fn` in one transaction. Pass claims to run it as a user. */
+  transaction<T>(fn: (client: SqlClient) => Promise<T>, options?: {
+    readonly claims?: SqlClaims;
+  }): Promise<T>;
+  end(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * A pooled Postgres connection for jobs, scripts and tests. Each query (or
+ * transaction) runs in its own transaction; claims and role are
+ * transaction-local, so nothing leaks back into the pool.
+ */
+declare function createPostgres(options?: PostgresOptions): Postgres;
+//#endregion
+export { createPostgres as i, PostgresOptions as n, SqlClaims as r, Postgres as t };

package/dist/postgres/index.d.ts

@@ -0,0 +1,28 @@
+import { g as Operation } from "../executor-Bazhgsgq.js";
+import { n as fromPgError, r as postgresExecutor, t as SqlClient } from "../executor-Bje4suQF.js";
+import { i as createPostgres, n as PostgresOptions, r as SqlClaims, t as Postgres } from "../pool-BFeqzwQS.js";
+import { t as Compiler } from "../compiler-DL18ukPe.js";
+//#region src/compile/sql.d.ts
+interface SqlQuery {
+  readonly text: string;
+  readonly params: readonly unknown[];
+}
+/**
+ * The SQL for one operation. `rows` returns a `row` json column per result
+ * row; `count` returns one `count` column. Either may be absent: a HEAD read
+ * only counts, a filter that can never match runs nothing.
+ */
+interface SqlPlan {
+  readonly rows: SqlQuery | undefined;
+  readonly count: SqlQuery | undefined;
+  /** No row can match; the executor returns an empty result without a query. */
+  readonly never: boolean;
+}
+export declare function quoteIdent(name: string): string;
+/** Compiles an operation to parameterized SQL. Rows come back as json. */
+export declare function compileSql(op: Operation): SqlPlan;
+//#endregion
+//#region src/postgres/compiler.d.ts
+export declare const sqlCompiler: Compiler<SqlPlan>;
+//#endregion
+export { type Postgres, type PostgresOptions, type SqlClaims, type SqlClient, type SqlPlan, type SqlQuery, createPostgres, fromPgError, postgresExecutor };

package/dist/postgres/index.js

@@ -0,0 +1,79 @@
+import { n as quoteIdent, t as compileSql } from "../sql-M8l3fnS0.js";
+import { n as postgresExecutor, t as fromPgError } from "../executor-Ceq60hPM.js";
+import { Pool } from "pg";
+//#region src/postgres/pool.ts
+const ROLES = /* @__PURE__ */ new Set(["authenticated", "anon"]);
+function roleOf(claims) {
+	const role = claims.role ?? (claims.sub ? "authenticated" : "anon");
+	if (!ROLES.has(role)) throw new TypeError(`Cannot run as role "${role}": only "authenticated" and "anon" are assumed. Use postgres.admin for service work.`);
+	return role;
+}
+/**
+* A pooled Postgres connection for jobs, scripts and tests. Each query (or
+* transaction) runs in its own transaction; claims and role are
+* transaction-local, so nothing leaks back into the pool.
+*/
+function createPostgres(options = {}) {
+	const connectionString = options.connectionString ?? process.env["SUPABASE_DB_URL"] ?? process.env["DATABASE_URL"];
+	if (!connectionString) throw new TypeError("createPostgres needs a connectionString, $SUPABASE_DB_URL or $DATABASE_URL");
+	const pool = new Pool({
+		connectionString,
+		max: options.max ?? 10
+	});
+	async function begin(client, session) {
+		await client.query("begin");
+		if (options.statementTimeout !== void 0) await client.query(`set local statement_timeout = ${Math.trunc(options.statementTimeout)}`);
+		if (session) {
+			await client.query("select set_config('request.jwt.claims', $1, true)", [JSON.stringify({
+				...session.claims,
+				role: session.role
+			})]);
+			await client.query(`set local role ${session.role}`);
+		}
+	}
+	async function transaction(session, fn) {
+		const client = await pool.connect();
+		try {
+			await begin(client, session);
+			const scoped = {
+				queryRaw: async (text, params) => (await client.query(text, params)).rows,
+				transaction: (inner) => inner(scoped)
+			};
+			const result = await fn(scoped);
+			await client.query("commit");
+			return result;
+		} catch (cause) {
+			await client.query("rollback").catch(() => void 0);
+			throw cause;
+		} finally {
+			client.release();
+		}
+	}
+	const clientFor = (session) => ({
+		queryRaw: (text, params) => transaction(session, (client) => client.queryRaw(text, params)),
+		transaction: (fn) => transaction(session, fn)
+	});
+	const sessionFor = (claims) => ({
+		claims,
+		role: roleOf(claims)
+	});
+	return {
+		admin: clientFor(void 0),
+		anon: clientFor({
+			claims: { role: "anon" },
+			role: "anon"
+		}),
+		asUser: (claims) => clientFor(sessionFor(claims)),
+		transaction: (fn, txOptions) => transaction(txOptions?.claims ? sessionFor(txOptions.claims) : void 0, fn),
+		end: () => pool.end(),
+		[Symbol.asyncDispose]: () => pool.end()
+	};
+}
+//#endregion
+//#region src/postgres/compiler.ts
+const sqlCompiler = {
+	target: "sql",
+	compile: compileSql
+};
+//#endregion
+export { compileSql, createPostgres, fromPgError, postgresExecutor, quoteIdent, sqlCompiler };

package/dist/postgrest-Dm-vhY6R.d.ts

@@ -0,0 +1,43 @@
+import { g as Operation } from "./executor-Bazhgsgq.js";
+//#region src/compile/postgrest.d.ts
+/**
+ * A compiled PostgREST request, expressed as calls on the public
+ * postgrest-js builder so it works with any supabase-js client.
+ */
+interface PostgrestPlan {
+  /** `select` parameter, or `undefined` for mutations without returning. */
+  readonly select: string | undefined;
+  readonly filters: readonly PlanFilter[];
+  readonly orders: readonly PlanOrder[];
+  readonly limits: readonly PlanLimit[];
+  readonly range: {
+    readonly from: number;
+    readonly to: number;
+  } | undefined;
+  /** The condition can never match; skip the request. */
+  readonly never: boolean;
+}
+type PlanFilter = {
+  readonly kind: "filter";
+  readonly path: string;
+  readonly operator: string;
+  readonly value: string;
+} | {
+  readonly kind: "or";
+  readonly expression: string;
+  readonly referencedTable: string | undefined;
+};
+interface PlanOrder {
+  readonly column: string;
+  readonly ascending: boolean;
+  readonly nullsFirst: boolean | undefined;
+  readonly referencedTable: string | undefined;
+}
+interface PlanLimit {
+  readonly count: number;
+  readonly referencedTable: string | undefined;
+}
+/** Compiles an operation into a PostgREST plan. */
+declare function compilePostgrest(op: Operation): PostgrestPlan;
+//#endregion
+export { compilePostgrest as a, PostgrestPlan as i, PlanLimit as n, PlanOrder as r, PlanFilter as t };

package/dist/problem-DPu6Fh-t.js

@@ -0,0 +1,97 @@
+import { n as dbError } from "./errors-Bl3rkOzo.js";
+//#region src/core/problem.ts
+const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
+const PROBLEM_CONTENT_TYPE = "application/problem+json";
+const TITLES = {
+	not_found: "Not found",
+	unauthorized: "Unauthorized",
+	forbidden: "Forbidden",
+	conflict: "Conflict",
+	foreign_key: "Referenced row missing or still referenced",
+	check: "Check constraint violated",
+	not_null: "Required value missing",
+	exclusion: "Exclusion constraint violated",
+	invalid_input: "Invalid input",
+	raised: "Request rejected",
+	timeout: "Timed out",
+	serialization: "Concurrent update, retry",
+	network: "Database unreachable",
+	aborted: "Aborted",
+	invalid_request: "Invalid request",
+	validation: "Validation failed",
+	multiple_rows: "More than one row matched",
+	stale: "Row changed since it was read",
+	rate_limited: "Too many requests",
+	unexpected: "Unexpected error"
+};
+/** Kinds whose message may contain internals (SQL, hostnames), hidden unless `expose` is set. */
+const INTERNAL = /* @__PURE__ */ new Set([
+	"unexpected",
+	"network",
+	"invalid_request"
+]);
+/** Converts a `DbError` to Problem Details. */
+function toProblem(error, options = {}) {
+	const problem = {
+		type: `${PROBLEM_TYPE_BASE}${error.kind.replace(/_/g, "-")}`,
+		title: TITLES[error.kind],
+		status: error.status,
+		kind: error.kind
+	};
+	if (!INTERNAL.has(error.kind) || options.expose) problem["detail"] = error.message;
+	if (options.instance) problem["instance"] = options.instance;
+	if (error.code) problem["code"] = error.code;
+	if (error.hint) problem["hint"] = error.hint;
+	if ("constraint" in error && error.constraint) problem["constraint"] = error.constraint;
+	if ("columns" in error && error.columns) problem["columns"] = error.columns;
+	if ("column" in error && error.column) problem["column"] = error.column;
+	if ("issues" in error) problem["issues"] = error.issues;
+	if ("required" in error && error.required) problem["required"] = error.required;
+	if ("retryAfter" in error && error.retryAfter !== void 0) problem["retryAfter"] = error.retryAfter;
+	return problem;
+}
+/**
+* An `application/problem+json` response. A 401 carries an RFC 6750
+* `WWW-Authenticate: Bearer` challenge.
+*/
+function problemResponse(error, options = {}) {
+	const headers = new Headers(options.headers);
+	headers.set("content-type", PROBLEM_CONTENT_TYPE);
+	if (error.status === 401 && !headers.has("www-authenticate")) {
+		const realm = (options.realm ?? "supabase").replace(/"/g, "");
+		const params = error.code === "MISSING_CREDENTIALS" ? "" : ", error=\"invalid_token\"";
+		headers.set("www-authenticate", `Bearer realm="${realm}"${params}`);
+	}
+	if ("retryAfter" in error && error.retryAfter !== void 0 && !headers.has("retry-after")) headers.set("retry-after", String(error.retryAfter));
+	return new Response(JSON.stringify(toProblem(error, options)), {
+		status: error.status,
+		headers
+	});
+}
+function isProblem(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const problem = value;
+	return typeof problem["type"] === "string" && typeof problem["status"] === "number" && typeof problem["title"] === "string";
+}
+function isKind(value) {
+	return typeof value === "string" && value in TITLES;
+}
+/** Turns a Problem Details body back into a `DbError` (client side). */
+function fromProblem(problem) {
+	const kind = isKind(problem.kind) ? problem.kind : "unexpected";
+	const extra = { status: problem.status };
+	for (const key of [
+		"code",
+		"hint",
+		"constraint",
+		"columns",
+		"column",
+		"required",
+		"retryAfter"
+	]) if (problem[key] !== void 0) extra[key] = problem[key];
+	extra["issues"] = problem.issues ?? [];
+	if (kind !== "validation") delete extra["issues"];
+	return dbError(kind, problem.detail ?? problem.title, extra);
+}
+//#endregion
+export { problemResponse as a, isProblem as i, PROBLEM_TYPE_BASE as n, toProblem as o, fromProblem as r, PROBLEM_CONTENT_TYPE as t };

package/dist/problem-DlgB0lYl.d.ts

@@ -0,0 +1,47 @@
+import { b as ValidationIssue, m as DbErrorKind, p as DbError } from "./result-CTkCZ6JA.js";
+//#region src/core/problem.d.ts
+/** RFC 9457 Problem Details, with the `DbError` fields as extension members. */
+interface ProblemDetails {
+  readonly type: string;
+  readonly title: string;
+  readonly status: number;
+  readonly detail?: string;
+  readonly instance?: string;
+  /** The `DbError` kind. */
+  readonly kind: DbErrorKind;
+  readonly code?: string;
+  readonly hint?: string;
+  readonly constraint?: string;
+  readonly columns?: readonly string[];
+  readonly column?: string;
+  readonly issues?: readonly ValidationIssue[];
+  /** The assurance level a `forbidden` answer needs (`aal2`). */
+  readonly required?: "aal1" | "aal2";
+  /** Seconds until a `rate_limited` caller may retry. */
+  readonly retryAfter?: number;
+}
+declare const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
+declare const PROBLEM_CONTENT_TYPE = "application/problem+json";
+interface ProblemOptions {
+  /** URI reference for this occurrence, e.g. the request path. */
+  readonly instance?: string;
+  /** Include messages of internal errors. Defaults to false. */
+  readonly expose?: boolean;
+}
+interface ProblemResponseOptions extends ProblemOptions {
+  readonly headers?: HeadersInit;
+  /** `realm` of the RFC 6750 challenge on 401. */
+  readonly realm?: string;
+}
+/** Converts a `DbError` to Problem Details. */
+declare function toProblem(error: DbError, options?: ProblemOptions): ProblemDetails;
+/**
+ * An `application/problem+json` response. A 401 carries an RFC 6750
+ * `WWW-Authenticate: Bearer` challenge.
+ */
+declare function problemResponse(error: DbError, options?: ProblemResponseOptions): Response;
+declare function isProblem(value: unknown): value is ProblemDetails;
+/** Turns a Problem Details body back into a `DbError` (client side). */
+declare function fromProblem(problem: ProblemDetails): DbError;
+//#endregion
+export { ProblemResponseOptions as a, problemResponse as c, ProblemOptions as i, toProblem as l, PROBLEM_TYPE_BASE as n, fromProblem as o, ProblemDetails as r, isProblem as s, PROBLEM_CONTENT_TYPE as t };

package/dist/query/index.d.ts

@@ -0,0 +1,2 @@
+import { a as QueryHelpers, c as TableQueries, d as queryCache, f as BetterQueryMeta, i as Queries, l as createQueries, n as InfiniteOptionsOf, o as QueryKeyOf, p as invalidateTables, r as MutationOptionsOf, s as QueryOptionsOf, t as CreateQueriesOptions, u as invalidateOnMutation } from "../index-Dup-nSe9.js";
+export { type BetterQueryMeta, CreateQueriesOptions, InfiniteOptionsOf, MutationOptionsOf, Queries, QueryHelpers, QueryKeyOf, QueryOptionsOf, TableQueries, createQueries, invalidateOnMutation, invalidateTables, queryCache };

package/dist/query/index.js

@@ -0,0 +1,3 @@
+import { t as invalidateTables } from "../invalidate-DbxuL2jL.js";
+import { n as invalidateOnMutation, r as queryCache, t as createQueries } from "../query-ChvDbsDE.js";
+export { createQueries, invalidateOnMutation, invalidateTables, queryCache };

package/dist/query-ChvDbsDE.js

@@ -0,0 +1,186 @@
+import { t as DbException } from "./errors-Bl3rkOzo.js";
+import { t as invalidationTargets } from "./tables-rZxRxNPW.js";
+import { t as invalidateTables } from "./invalidate-DbxuL2jL.js";
+//#region src/query/index.ts
+/** Query errors stay `DbException`s, even for an `sb` with `mapError()`. */
+const asException = (error) => new DbException(error);
+function isSkip(value) {
+	return typeof value === "symbol";
+}
+function withoutSignal(value) {
+	if (typeof value !== "object" || value === null) return value;
+	const { signal: _signal, ...rest } = value;
+	return rest;
+}
+function specQuery(runtime, spec, key) {
+	const stale = runtime.staleTime === void 0 ? {} : { staleTime: runtime.staleTime };
+	if (isSkip(spec)) return {
+		queryKey: key ?? ["bs", "$skip"],
+		queryFn: spec,
+		meta: { bsTables: [] },
+		...stale
+	};
+	return {
+		queryKey: key ?? [
+			"bs",
+			spec.table,
+			spec.method,
+			...spec.args
+		],
+		queryFn: ({ signal }) => runtime.db().$run(spec, { signal }).orThrow(asException),
+		meta: { bsTables: runtime.sb.tablesOf(spec) },
+		...stale
+	};
+}
+function tableQueries(runtime, table) {
+	const key = ["bs", table];
+	const specs = runtime.sb.spec[table];
+	const stale = runtime.staleTime === void 0 ? {} : { staleTime: runtime.staleTime };
+	const read = (method) => (args) => isSkip(args) ? specQuery(runtime, args, [
+		...key,
+		method,
+		"$skip"
+	]) : specQuery(runtime, specs[method](withoutSignal(args)));
+	const repo = () => {
+		const found = runtime.db()[table];
+		if (!found) throw new TypeError(`better-supabase: unknown table "${table}"`);
+		return found;
+	};
+	const call = (method, ...args) => {
+		const fn = repo()[method];
+		if (!fn) throw new TypeError(`better-supabase: ${table}.${method} is not available`);
+		return fn(...args);
+	};
+	const mutation = (op, run, tables) => ({
+		mutationKey: [...key, op],
+		mutationFn: (variables) => run(variables).orThrow(asException),
+		onSuccess: (_data, _variables, _result, context) => invalidateTables(context.client, tables)
+	});
+	return {
+		key,
+		findMany: read("findMany"),
+		findFirst: read("findFirst"),
+		findUnique: read("findUnique"),
+		count: read("count"),
+		aggregate: read("aggregate"),
+		exists: read("exists"),
+		paginate: read("paginate"),
+		findById: (id, args) => isSkip(id) ? specQuery(runtime, id, [
+			...key,
+			"findById",
+			"$skip"
+		]) : specQuery(runtime, specs["findById"](id, withoutSignal(args))),
+		infinite: (args) => {
+			const base = withoutSignal(args);
+			return {
+				queryKey: [
+					...key,
+					"infinite",
+					base
+				],
+				queryFn: ({ signal, pageParam }) => runtime.db().$run(specs["paginate"]({
+					...base,
+					after: pageParam
+				}), { signal }).orThrow(asException),
+				initialPageParam: null,
+				getNextPageParam: (last) => last.nextCursor ?? void 0,
+				meta: { bsTables: runtime.sb.tablesOf(specs["paginate"]({
+					...base,
+					after: null
+				})) },
+				...stale
+			};
+		},
+		infinitePages: (args) => {
+			const base = withoutSignal(args);
+			return {
+				queryKey: [
+					...key,
+					"infinitePages",
+					base
+				],
+				queryFn: ({ signal, pageParam }) => runtime.db().$run(specs["paginate"]({
+					...base,
+					page: pageParam
+				}), { signal }).orThrow(asException),
+				initialPageParam: base.page ?? 1,
+				getNextPageParam: (last) => last.page.hasMore ? last.page.number + 1 : void 0,
+				meta: { bsTables: runtime.sb.tablesOf(specs["paginate"](base)) },
+				...stale
+			};
+		},
+		create: (args) => mutation("create", (data) => call("create", data, args), [table]),
+		update: (args) => mutation("update", (variables) => call("update", variables.id, variables.patch, args), [table]),
+		upsert: (args) => mutation("upsert", (data) => call("upsert", data, args), [table]),
+		delete: (args) => mutation("delete", (id) => call("delete", id, args), invalidationTargets(runtime.sb.meta, table))
+	};
+}
+/**
+* TanStack Query option factories for every table, framework-neutral: pass
+* them to `useQuery` (React), `createQuery` (Svelte, Solid), `useQuery`
+* (Vue) or `injectQuery` (Angular). Payload types flow into the cache, errors
+* are `DbException`s, and mutations invalidate every query that read a
+* changed table.
+*
+* ```ts
+* const q = createQueries(sb, () => browser.db);
+* const { data } = useQuery(q.customers.findMany({ select: ['id', 'name'] }));
+* ```
+*/
+function createQueries(sb, db, options = {}) {
+	const runtime = {
+		sb,
+		db: typeof db === "function" ? db : () => db,
+		staleTime: options.staleTime
+	};
+	const stale = options.staleTime === void 0 ? {} : { staleTime: options.staleTime };
+	const queries = {
+		key: ["bs"],
+		$spec: (spec) => specQuery(runtime, spec),
+		$prefetch: (client, spec) => client.prefetchQuery(specQuery(runtime, spec)),
+		$rpc: (name, args, rpcOptions = {}) => ({
+			queryKey: [
+				"bs",
+				"$rpc",
+				name,
+				isSkip(args) ? "$skip" : args ?? {}
+			],
+			queryFn: isSkip(args) ? args : ({ signal }) => runtime.db().$rpc(name, args ?? {}, { signal }).orThrow(asException),
+			meta: { bsTables: rpcOptions.tables ?? [] },
+			...stale
+		}),
+		$rpcMutation: (name) => ({
+			mutationKey: [
+				"bs",
+				"$rpc",
+				name
+			],
+			mutationFn: (args) => runtime.db().$rpc(name, args ?? {}).orThrow(asException),
+			onSuccess: (_data, _variables, _result, context) => invalidateTables(context.client, (sb.options.rpc?.[name]?.invalidates ?? []).flatMap((table) => invalidationTargets(sb.meta, table)))
+		})
+	};
+	for (const table of Object.keys(sb.meta.tables)) {
+		let built;
+		Object.defineProperty(queries, table, {
+			enumerable: true,
+			get: () => {
+				built ??= tableQueries(runtime, table);
+				return built;
+			}
+		});
+	}
+	return queries;
+}
+/** Invalidates every query that read a table in the target. */
+function queryCache(client) {
+	return {
+		name: "tanstack-query",
+		invalidate: (target) => invalidateTables(client, target.tables)
+	};
+}
+/** Invalidates affected queries for every mutation and declared RPC `sb` performs in this runtime. */
+function invalidateOnMutation(sb, client) {
+	return sb.cache(queryCache(client));
+}
+//#endregion
+export { invalidateOnMutation as n, queryCache as r, createQueries as t };

package/dist/react/index.d.ts

@@ -0,0 +1,7 @@
+import { s as Impersonator } from "../mfa-TVia554c.js";
+import { t as AuthSession } from "../view-B0ltUmTi.js";
+import { r as LiveCountSeed } from "../live-6b9i72Ux.js";
+import { n as hasEntitlement, t as EntitlementKey } from "../entitlements-BBg61DQZ.js";
+import { n as SessionProviderProps, r as useSession, t as SessionProvider } from "../session-C3osL21k.js";
+import { a as BrowserLike, c as LiveCountHookOptions, d as useAuth, f as useBroadcast, h as useSupabase, i as BroadcastOptions, l as LiveQueryHookOptions, m as useLiveQuery, n as BetterSupabaseProvider, o as ClaimsOf, p as useLiveCount, r as BetterSupabaseProviderProps, s as LiveCount, t as BetterHooks, u as createHooks } from "../index-Hf8PP9sP.js";
+export { type AuthSession, BetterHooks, BetterSupabaseProvider, BetterSupabaseProviderProps, BroadcastOptions, BrowserLike, ClaimsOf, type EntitlementKey, type Impersonator, LiveCount, LiveCountHookOptions, type LiveCountSeed, LiveQueryHookOptions, SessionProvider, type SessionProviderProps, createHooks, hasEntitlement, useAuth, useBroadcast, useLiveCount, useLiveQuery, useSession, useSupabase };

package/dist/react/index.js

@@ -0,0 +1,5 @@
+"use client";
+import { n as useSession, t as SessionProvider } from "../session-CD-3orO_.js";
+import { t as hasEntitlement } from "../entitlements-BC_khwRy.js";
+import { a as useLiveCount, i as useBroadcast, n as createHooks, o as useLiveQuery, r as useAuth, s as useSupabase, t as BetterSupabaseProvider } from "../react-CrOvrnIP.js";
+export { BetterSupabaseProvider, SessionProvider, createHooks, hasEntitlement, useAuth, useBroadcast, useLiveCount, useLiveQuery, useSession, useSupabase };