better-supabase 0.13.0 → 0.15.0

package/dist/problem-Bf0cJ7tk.js

@@ -0,0 +1,162 @@
+import { n as dbError, u as statusOf } from "./errors-BVFgt8BZ.js";
+//#region src/core/problem.ts
+/** The `type` prefix of kinds that mean more than their HTTP status. */
+const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
+const PROBLEM_CONTENT_TYPE = "application/problem+json";
+/** RFC 9457 section 4.2.1: a problem that means only its HTTP status. */
+const PROBLEM_TYPE_BLANK = "about:blank";
+/**
+* Kinds that say nothing beyond their HTTP status. At their default status they
+* use `about:blank` with the status phrase as `title`.
+*/
+const GENERIC = {
+	invalid_request: "Bad Request",
+	unauthorized: "Unauthorized",
+	forbidden: "Forbidden",
+	not_found: "Not Found",
+	conflict: "Conflict",
+	rate_limited: "Too Many Requests",
+	unexpected: "Internal Server Error"
+};
+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",
+	invalid_value: "Stored value not representable",
+	raised: "Request rejected",
+	timeout: "Timed out",
+	serialization: "Concurrent update, retry",
+	network: "Database unreachable",
+	aborted: "Aborted",
+	invalid_request: "Bad Request",
+	validation: "Validation failed",
+	multiple_rows: "More than one row matched",
+	stale: "Row changed since it was read",
+	max_affected: "Too many rows affected",
+	rate_limited: "Too Many Requests",
+	quota_exceeded: "Quota exceeded",
+	unsupported: "Not supported by this executor",
+	unexpected: "Internal Server Error"
+};
+/**
+* The `type` and `title` of a problem: `about:blank` and the status phrase for
+* a generic kind at its default status, otherwise the kind's URI under
+* `PROBLEM_TYPE_BASE`.
+*/
+function problemType(kind, status = statusOf(kind)) {
+	const phrase = GENERIC[kind];
+	if (phrase !== void 0 && status === statusOf(kind)) return {
+		type: PROBLEM_TYPE_BLANK,
+		title: phrase
+	};
+	return {
+		type: `${PROBLEM_TYPE_BASE}${kind.replaceAll("_", "-")}`,
+		title: TITLES[kind]
+	};
+}
+/**
+* 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 = {
+		...problemType(error.kind, error.status),
+		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) 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) problem["required"] = error.required;
+	if ("scopes" in error) problem["scopes"] = error.scopes;
+	if ("permission" in error) problem["permission"] = error.permission;
+	if ("permissions" in error) problem["permissions"] = error.permissions;
+	if ("approval" in error) problem["approval"] = error.approval;
+	if ("retryAfter" in error) problem["retryAfter"] = error.retryAfter;
+	if ("meter" in error) problem["meter"] = error.meter;
+	if ("limit" in error) problem["limit"] = error.limit;
+	if ("maxAffected" in error) problem["maxAffected"] = error.maxAffected;
+	return problem;
+}
+/**
+* An `application/problem+json` response. A 401, and a 403 for a missing OAuth
+* scope, carry an RFC 6750 `WWW-Authenticate: Bearer` challenge.
+*/
+function problemResponse(error, options = {}) {
+	const headers = new Headers(options.headers);
+	headers.set("content-type", PROBLEM_CONTENT_TYPE);
+	const realm = (options.realm ?? "supabase").replaceAll("\"", "");
+	if (error.status === 401 && !headers.has("www-authenticate")) {
+		const params = error.code === "MISSING_CREDENTIALS" ? "" : ", error=\"invalid_token\"";
+		headers.set("www-authenticate", `Bearer realm="${realm}"${params}`);
+	}
+	if ("scopes" in error && error.code === "INSUFFICIENT_SCOPE" && !headers.has("www-authenticate")) {
+		const scope = error.scopes.join(" ").replaceAll("\"", "");
+		headers.set("www-authenticate", `Bearer realm="${realm}", error="insufficient_scope", scope="${scope}"`);
+	}
+	if ("retryAfter" in error && !headers.has("retry-after")) headers.set("retry-after", String(error.retryAfter));
+	const problem = toProblem(error, options);
+	const body = options.format ? options.format(problem, error) : problem;
+	return Response.json(body, {
+		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",
+		"scopes",
+		"permission",
+		"permissions",
+		"approval",
+		"retryAfter",
+		"meter",
+		"limit",
+		"maxAffected"
+	]) 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);
+}
+/** An empty `405` that lists the methods a route does accept. */
+function methodNotAllowed(allowed) {
+	return new Response(null, {
+		status: 405,
+		headers: { allow: allowed.join(", ") }
+	});
+}
+//#endregion
+export { methodNotAllowed as a, toProblem as c, isProblem as i, PROBLEM_TYPE_BASE as n, problemResponse as o, fromProblem as r, problemType as s, PROBLEM_CONTENT_TYPE as t };

package/dist/problem-DNwN8iGz.d.ts

@@ -0,0 +1,79 @@
+import { D as ValidationIssue, b as DbError, x as DbErrorKind } from "./result-DZeA5KS6.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";
+  /** The OAuth scopes a `forbidden` answer needs. */
+  readonly scopes?: readonly string[];
+  /** The permission key an authorizer denied. */
+  readonly permission?: string;
+  /** The permission keys a `forbidden` caller lacks. */
+  readonly permissions?: readonly string[];
+  /** The pending approval of an `APPROVAL_REQUIRED` answer. */
+  readonly approval?: {
+    readonly id: string;
+  };
+  /** Seconds until a `rate_limited` or `quota_exceeded` caller may retry. */
+  readonly retryAfter?: number;
+  /** The meter a `quota_exceeded` answer ran out of, and its limit. */
+  readonly meter?: string;
+  readonly limit?: number;
+  /** The row limit a `max_affected` write exceeded. */
+  readonly maxAffected?: number;
+}
+/** The `type` prefix of kinds that mean more than their HTTP status. */
+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;
+}
+/**
+ * Rewrites the Problem Details a block answers with into the app's own error
+ * body, such as its `type` URIs and error codes. The status, `Retry-After` and
+ * `WWW-Authenticate` headers stay as they are.
+ */
+type ProblemFormat = (problem: ProblemDetails, error: DbError) => Readonly<Record<string, unknown>>;
+/** The `problem` option of the blocks that answer HTTP requests. */
+interface BlockProblemOptions {
+  /**
+   * The app's error body for the block's error responses. Defaults to RFC 9457
+   * Problem Details.
+   */
+  readonly problem?: ProblemFormat;
+}
+interface ProblemResponseOptions extends ProblemOptions {
+  readonly headers?: ConstructorParameters<typeof Headers>[0];
+  /** `realm` of the RFC 6750 challenge on 401. */
+  readonly realm?: string;
+  /** Rewrites the body; see `ProblemFormat`. */
+  readonly format?: ProblemFormat | undefined;
+}
+/** Converts a `DbError` to Problem Details. */
+declare function toProblem(error: DbError, options?: ProblemOptions): ProblemDetails;
+/**
+ * An `application/problem+json` response. A 401, and a 403 for a missing OAuth
+ * scope, carry 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 { ProblemFormat as a, fromProblem as c, toProblem as d, ProblemDetails as i, isProblem as l, PROBLEM_CONTENT_TYPE as n, ProblemOptions as o, PROBLEM_TYPE_BASE as r, ProblemResponseOptions as s, BlockProblemOptions as t, problemResponse as u };

package/dist/provider-B6g7rBZX.js

@@ -0,0 +1,57 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+//#region src/credentials/provider.ts
+/** `ref` bound to `tenant`'s namespace. */
+function tenantCredentialRef(tenant, ref) {
+	return {
+		...ref,
+		tenant
+	};
+}
+/**
+* Whether `ref` belongs to `tenant`: its `tenant` is exactly that tenant.
+* Without a tenant (an app-level row), only a ref without one belongs.
+*/
+function credentialRefInTenant(ref, tenant) {
+	const owner = ref.tenant;
+	return tenant === void 0 ? owner === void 0 : typeof owner === "string" && owner === tenant;
+}
+/** The error for a ref that names a credential outside the row's tenant. */
+function foreignCredentialRef(tenant) {
+	return dbError("forbidden", tenant === void 0 ? "An app-level credential_ref can't name a tenant's credential" : `The credential_ref names a credential outside tenant "${tenant}"`, { hint: "CREDENTIAL_REF_FOREIGN" });
+}
+/** Checks the provider's `apiVersion` before the server uses it. */
+function credentialProviderOf(provider) {
+	const version = provider.apiVersion;
+	if (version !== 1) throw new TypeError(`credentials "${provider.name}" targets credential provider API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release of the provider for API 1.`);
+	return provider;
+}
+/**
+* The subject for a request: the user behind a session or a user-bound API key,
+* the app for the service role, and `undefined` for anyone else.
+*/
+function subjectFor(context) {
+	const { auth } = context;
+	switch (auth.kind) {
+		case "user": {
+			const issuer = auth.claims.iss;
+			return typeof issuer === "string" && issuer.length > 0 ? {
+				type: "user",
+				id: auth.claims.sub,
+				issuer
+			} : {
+				type: "user",
+				id: auth.claims.sub
+			};
+		}
+		case "apiKey": return auth.userId === void 0 ? void 0 : {
+			type: "user",
+			id: auth.userId
+		};
+		case "service": return { type: "app" };
+		case "anon":
+		case "invalid": return;
+		default: return auth;
+	}
+}
+//#endregion
+export { tenantCredentialRef as a, subjectFor as i, credentialRefInTenant as n, foreignCredentialRef as r, credentialProviderOf as t };

package/dist/provider-CqwEOLCA.d.ts

@@ -0,0 +1,112 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { r as AuthState } from "./resolve-CXX6DHv3.js";
+//#region src/credentials/provider.d.ts
+/**
+ * Names a credential without holding it. Tables store this as a `credential_ref
+ * jsonb` column; `provider` picks the `CredentialProvider` and the other keys
+ * are that provider's.
+ */
+type CredentialRef = {
+  readonly provider: string;
+  /**
+   * The tenant that owns the credential. A provider resolves, sets and revokes
+   * a ref with `tenant` only inside that tenant's namespace, so a tenant admin
+   * who picks a ref can never name another tenant's or the app's secret.
+   */
+  readonly tenant?: string;
+} & Readonly<Record<string, unknown>>;
+/** `ref` bound to `tenant`'s namespace. */
+declare function tenantCredentialRef<R extends CredentialRef>(tenant: string, ref: R): R & {
+  readonly tenant: string;
+};
+/**
+ * Whether `ref` belongs to `tenant`: its `tenant` is exactly that tenant.
+ * Without a tenant (an app-level row), only a ref without one belongs.
+ */
+declare function credentialRefInTenant(ref: CredentialRef, tenant: string | undefined): boolean;
+/** The error for a ref that names a credential outside the row's tenant. */
+declare function foreignCredentialRef(tenant: string | undefined): DbError;
+/** Whose credential to use: the app's own, or one a user connected. */
+type CredentialSubject = {
+  readonly type: "app";
+} | {
+  readonly type: "user";
+  readonly id: string;
+  readonly issuer?: string;
+};
+interface GetTokenOptions {
+  readonly subject: CredentialSubject;
+  readonly scopes?: readonly string[];
+  readonly installationId?: string;
+  readonly signal?: AbortSignal;
+}
+interface CredentialToken {
+  readonly token: string;
+  /** Unset when the provider doesn't know when the token expires. */
+  readonly expiresAt?: Temporal.Instant;
+  /** Headers that authenticate a request with this token. */
+  readonly headers: Readonly<Record<string, string>>;
+}
+interface CredentialCapabilities {
+  /** The ref holds one credential per user subject. */
+  readonly userSubjects: boolean;
+  /** `startAuthorization` can send the user to connect the account. */
+  readonly authorization: boolean;
+  readonly revoke: boolean;
+  /** `verifyInbound` can check requests the third party sends. */
+  readonly inbound: boolean;
+}
+interface StartAuthorizationOptions {
+  readonly subject: CredentialSubject;
+  readonly redirectUri: string;
+  readonly scopes?: readonly string[];
+  readonly state?: string;
+}
+interface CompleteAuthorizationOptions {
+  readonly subject: CredentialSubject;
+  /** The callback request, or its URL, that carries the code and state. */
+  readonly callback: Request | URL | string;
+}
+/**
+ * Resolves `CredentialRef`s to tokens. Versioned: a breaking change to this
+ * contract ships a new `apiVersion`. Errors are `DbError`s: `invalid_input` for
+ * a ref the provider doesn't handle, `not_found` when no credential is stored,
+ * `forbidden` when the subject may not use it.
+ */
+interface CredentialProvider {
+  readonly apiVersion: 1;
+  readonly name: string;
+  getToken(ref: CredentialRef, options: GetTokenOptions): AsyncResult<CredentialToken>;
+  capabilities(ref: CredentialRef): CredentialCapabilities;
+  /** The URL to send the user to; only when `capabilities(ref).authorization`. */
+  startAuthorization?(ref: CredentialRef, options: StartAuthorizationOptions): AsyncResult<{
+    readonly url: string;
+  }>;
+  completeAuthorization?(ref: CredentialRef, options: CompleteAuthorizationOptions): AsyncResult<void>;
+  /** Forgets the stored credential; `false` when there was none. */
+  revoke(ref: CredentialRef, options: {
+    readonly subject: CredentialSubject;
+  }): AsyncResult<boolean>;
+  /** Checks a request the third party sent (a webhook) against the ref's secret. */
+  verifyInbound?(request: Request, ref: CredentialRef): AsyncResult<boolean>;
+  /**
+   * Stores or replaces the credential a ref names, for `subject` when the ref
+   * is per user. Optional: a provider without it can't take a secret from the
+   * app (an OAuth-only provider, say).
+   */
+  set?(ref: CredentialRef, value: string, options?: SetCredentialOptions): AsyncResult<void>;
+}
+interface SetCredentialOptions {
+  readonly subject?: CredentialSubject;
+  readonly description?: string;
+}
+/**
+ * The subject for a request: the user behind a session or a user-bound API key,
+ * the app for the service role, and `undefined` for anyone else.
+ */
+declare function subjectFor(context: {
+  readonly auth: AuthState;
+}): CredentialSubject | undefined;
+//#endregion
+export { CredentialSubject as a, SetCredentialOptions as c, foreignCredentialRef as d, subjectFor as f, CredentialRef as i, StartAuthorizationOptions as l, CredentialCapabilities as n, CredentialToken as o, tenantCredentialRef as p, CredentialProvider as r, GetTokenOptions as s, CompleteAuthorizationOptions as t, credentialRefInTenant as u };

package/dist/push-token-D3Vcf0Pf.d.ts

@@ -0,0 +1,24 @@
+import { s as PushTokenPort } from "./ports-sx226JUL.js";
+//#region src/client/native/push-token.d.ts
+/** The part of `expo-notifications` the push token port uses. */
+interface ExpoNotificationsLike {
+  getPermissionsAsync(): Promise<{
+    readonly status: string;
+  }>;
+  requestPermissionsAsync(): Promise<{
+    readonly status: string;
+  }>;
+  getExpoPushTokenAsync(options?: {
+    readonly projectId?: string;
+  }): Promise<{
+    readonly data: string;
+  }>;
+}
+interface ExpoPushTokenOptions {
+  /** `Constants.easConfig?.projectId`; Expo needs it outside Expo Go. */
+  readonly projectId?: string | undefined;
+}
+/** The push token port over `expo-notifications`: the Expo push token. */
+declare function expoPushToken(notifications: ExpoNotificationsLike, options?: ExpoPushTokenOptions): PushTokenPort;
+//#endregion
+export { ExpoPushTokenOptions as n, expoPushToken as r, ExpoNotificationsLike as t };

package/dist/queries-BWYYS9um.js

@@ -0,0 +1,239 @@
+import { r as isPlainObject } from "./clone-CkG0-hlI.js";
+import { t as DbException } from "./db-exception-Lngc1W49.js";
+import { t as invalidationTargets } from "./tables-Cb-3_VWc.js";
+import { r as invalidateTables } from "./user-change-DgWC6RRC.js";
+//#region src/query/queries.ts
+/**
+* Query errors stay `DbException`s, even for an `betterSupabase` with
+* `mapError()`.
+*/
+const asException = (error) => new DbException(error);
+/**
+* A query key part TanStack Query can hash: `JSON.stringify` throws on a
+* `bigint`, so each becomes `{ $bigint: "<digits>" }`, which no string or
+* number argument can collide with. Values without one are returned as is.
+*/
+function keyPart(value) {
+	if (typeof value === "bigint") return { $bigint: value.toString() };
+	if (Array.isArray(value)) {
+		const items = value.map(keyPart);
+		return items.some((item, index) => item !== value[index]) ? items : value;
+	}
+	if (isPlainObject(value)) {
+		let copy;
+		for (const [key, item] of Object.entries(value)) {
+			const part = keyPart(item);
+			if (part !== item) copy ??= { ...value };
+			if (copy) copy[key] = part;
+		}
+		return copy ?? value;
+	}
+	return value;
+}
+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 scoped(runtime, key) {
+	return runtime.scope === void 0 ? key : [...key, { scope: runtime.scope }];
+}
+function specQuery(runtime, spec, key) {
+	const stale = runtime.staleTime === void 0 ? {} : { staleTime: runtime.staleTime };
+	if (isSkip(spec)) return {
+		queryKey: scoped(runtime, key ?? ["bsb", "$skip"]),
+		queryFn: spec,
+		meta: { bsTables: [] },
+		...stale
+	};
+	return {
+		queryKey: scoped(runtime, key ?? [
+			"bsb",
+			spec.table,
+			spec.method,
+			...spec.args.map(keyPart)
+		]),
+		queryFn: ({ signal }) => runtime.db().$run(spec, { signal }).orThrow(asException),
+		meta: { bsTables: runtime.betterSupabase.tablesOf(spec) },
+		...stale
+	};
+}
+function maxPagesOf(extras) {
+	return extras.maxPages === void 0 ? {} : { maxPages: extras.maxPages };
+}
+function tableQueries(runtime, table) {
+	const key = ["bsb", table];
+	const specs = runtime.betterSupabase.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 [primaryKey, ...composite] = runtime.betterSupabase.meta.tables[table]?.primaryKey ?? [];
+	/**
+	* The `get(id)` entry for a full row a write returned, so a detail view
+	* opened next renders without a request. Only writes without read args return
+	* the shape `get(id)` caches.
+	*/
+	const seed = (client, row, args) => {
+		if (primaryKey === void 0 || composite.length > 0) return;
+		if (args && Object.keys(args).some((name) => name !== "override")) return;
+		if (!isPlainObject(row)) return;
+		const id = row[primaryKey];
+		if (id === void 0 || id === null) return;
+		client.setQueryData(specQuery(runtime, specs["get"](id, void 0)).queryKey, row);
+	};
+	const mutation = (op, run, tables, seedArgs) => ({
+		mutationKey: [...key, op],
+		mutationFn: (variables) => run(variables).orThrow(asException),
+		onSuccess: (data, _variables, _result, context) => {
+			if (seedArgs) seed(context.client, data, seedArgs.args);
+			return invalidateTables(context.client, tables);
+		}
+	});
+	return {
+		key,
+		list: read("list"),
+		page: read("page"),
+		count: read("count"),
+		aggregate: read("aggregate"),
+		get: (id, args) => isSkip(id) ? specQuery(runtime, id, [
+			...key,
+			"get",
+			"$skip"
+		]) : specQuery(runtime, specs["get"](id, withoutSignal(args))),
+		infinite: (args, extras = {}) => {
+			const base = withoutSignal(args);
+			return {
+				queryKey: scoped(runtime, [
+					...key,
+					"infinite",
+					keyPart(base)
+				]),
+				queryFn: ({ signal, pageParam }) => runtime.db().$run(specs["page"]({
+					...base,
+					after: pageParam
+				}), { signal }).orThrow(asException),
+				initialPageParam: null,
+				getNextPageParam: (last) => last.nextCursor ?? void 0,
+				...maxPagesOf(extras),
+				meta: { bsTables: runtime.betterSupabase.tablesOf(specs["page"]({
+					...base,
+					after: null
+				})) },
+				...stale
+			};
+		},
+		infinitePages: (args, extras = {}) => {
+			const base = withoutSignal(args);
+			return {
+				queryKey: scoped(runtime, [
+					...key,
+					"infinitePages",
+					keyPart(base)
+				]),
+				queryFn: ({ signal, pageParam }) => runtime.db().$run(specs["page"]({
+					...base,
+					page: pageParam
+				}), { signal }).orThrow(asException),
+				initialPageParam: base.page ?? 1,
+				getNextPageParam: (last) => last.page.hasMore ? last.page.number + 1 : void 0,
+				getPreviousPageParam: (first) => first.page.number > 1 ? first.page.number - 1 : void 0,
+				...maxPagesOf(extras),
+				meta: { bsTables: runtime.betterSupabase.tablesOf(specs["page"](base)) },
+				...stale
+			};
+		},
+		create: (args) => mutation("create", (data) => call("create", data, args), [table], { args }),
+		update: (args) => mutation("update", (variables) => call("update", variables.id, variables.patch, args), [table], { args }),
+		upsert: (args) => mutation("upsert", (data) => call("upsert", data, args), [table], { args }),
+		delete: (args) => mutation("delete", (id) => call("delete", id, args), invalidationTargets(runtime.betterSupabase.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(betterSupabase, () => bsb.db);
+* const { data } = useQuery(q.customers.list({ select: ["id", "name"] }));
+* ```
+*/
+function createQueries(betterSupabase, db, options = {}) {
+	const runtime = {
+		betterSupabase,
+		db: typeof db === "function" ? db : () => db,
+		staleTime: options.staleTime,
+		scope: options.scope
+	};
+	const stale = options.staleTime === void 0 ? {} : { staleTime: options.staleTime };
+	const queries = {
+		$key: ["bsb"],
+		$spec: (spec) => specQuery(runtime, spec),
+		$prefetch: (client, spec) => client.prefetchQuery(specQuery(runtime, spec)),
+		$rpc: (name, args, rpcOptions = {}) => ({
+			queryKey: scoped(runtime, [
+				"bsb",
+				"$rpc",
+				name,
+				isSkip(args) ? "$skip" : keyPart(args ?? {})
+			]),
+			queryFn: isSkip(args) ? args : ({ signal }) => runtime.db().$rpc(name, args ?? {}, { signal }).orThrow(asException),
+			meta: { bsTables: rpcOptions.tables ?? [] },
+			...stale
+		}),
+		$rpcMutation: (name) => ({
+			mutationKey: [
+				"bsb",
+				"$rpc",
+				name
+			],
+			mutationFn: (args) => runtime.db().$rpc(name, args ?? {}).orThrow(asException),
+			onSuccess: (_data, _variables, _result, context) => invalidateTables(context.client, (betterSupabase.options.rpc?.[name]?.invalidates ?? []).flatMap((table) => invalidationTargets(betterSupabase.meta, table)))
+		})
+	};
+	for (const table of Object.keys(betterSupabase.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
+* `betterSupabase` performs in this runtime.
+*/
+function invalidateOnMutation(betterSupabase, client) {
+	return betterSupabase.cache(queryCache(client));
+}
+//#endregion
+export { queryCache as i, invalidateOnMutation as n, keyPart as r, createQueries as t };