better-supabase 0.12.0 → 0.13.0

package/dist/query-DgPYlU82.js

@@ -0,0 +1,311 @@
+import { r as isPlainObject } from "./clone-CkG0-hlI.js";
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { t as invalidationTargets } from "./tables-Cb-3_VWc.js";
+import { r as invalidateTables } from "./user-change-CSR_prhd.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 ?? ["bs", "$skip"]),
+		queryFn: spec,
+		meta: { bsTables: [] },
+		...stale
+	};
+	return {
+		queryKey: scoped(runtime, key ?? [
+			"bs",
+			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 = ["bs", 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 `findById(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 `findById(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["findById"](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,
+		findMany: read("findMany"),
+		findFirst: read("findFirst"),
+		findOnly: read("findOnly"),
+		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, extras = {}) => {
+			const base = withoutSignal(args);
+			return {
+				queryKey: scoped(runtime, [
+					...key,
+					"infinite",
+					keyPart(base)
+				]),
+				queryFn: ({ signal, pageParam }) => runtime.db().$run(specs["paginate"]({
+					...base,
+					after: pageParam
+				}), { signal }).orThrow(asException),
+				initialPageParam: null,
+				getNextPageParam: (last) => last.nextCursor ?? void 0,
+				...maxPagesOf(extras),
+				meta: { bsTables: runtime.betterSupabase.tablesOf(specs["paginate"]({
+					...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["paginate"]({
+					...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["paginate"](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, () => bs.db);
+* const { data } = useQuery(
+*   q.customers.findMany({ 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: ["bs"],
+		$spec: (spec) => specQuery(runtime, spec),
+		$prefetch: (client, spec) => client.prefetchQuery(specQuery(runtime, spec)),
+		$rpc: (name, args, rpcOptions = {}) => ({
+			queryKey: scoped(runtime, [
+				"bs",
+				"$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: [
+				"bs",
+				"$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
+//#region src/query/optimistic.ts
+function listOf(targets) {
+	return "queryKey" in targets ? [targets] : targets;
+}
+/**
+* Rewrites the cached data of `targets` before the mutation runs, puts it back
+* when the mutation fails, and refetches the targets once it settles. `apply`
+* gets the cached data (skipped while nothing is cached) and the mutation's
+* variables.
+*/
+function rewrite(targets, apply) {
+	const list = listOf(targets);
+	return {
+		async onMutate(variables, { client }) {
+			await Promise.all(list.map((target) => client.cancelQueries({
+				queryKey: target.queryKey,
+				exact: true
+			})));
+			return { previous: list.map((target) => {
+				const data = client.getQueryData(target.queryKey);
+				if (data !== void 0) client.setQueryData(target.queryKey, apply(data, variables));
+				return [target.queryKey, data];
+			}) };
+		},
+		onError(_error, _variables, snapshot, { client }) {
+			for (const [queryKey, data] of snapshot?.previous ?? []) client.setQueryData(queryKey, data);
+		},
+		async onSettled(_data, _error, _variables, _snapshot, { client }) {
+			await Promise.all(list.map((target) => client.invalidateQueries({
+				queryKey: target.queryKey,
+				exact: true
+			})));
+		}
+	};
+}
+/**
+* Optimistic updates for list queries (`findMany`), keyed by a row column (`id`
+* by default):
+*
+* - `optimistic.create(list, (input) => row)` adds the row the input will make.
+* - `optimistic.update(list)` merges `{ id, patch }` into the matching row.
+* - `optimistic.remove(list)` drops the row whose key is the deleted id.
+* - `optimistic(target, apply)` rewrites any cached data.
+*
+* ```ts
+* const list = q.todos.findMany({ where: { done: false } });
+* useMutation({ ...q.todos.update(), ...optimistic.update(list) });
+* ```
+*/
+const optimistic = Object.assign(rewrite, {
+	create(targets, toRow, options = {}) {
+		return rewrite(targets, (rows, variables) => options.position === "start" ? [toRow(variables), ...rows] : [...rows, toRow(variables)]);
+	},
+	update(targets, options = {}) {
+		const key = options.key ?? "id";
+		return rewrite(targets, (rows, { id, patch }) => rows.map((row) => row[key] === id ? {
+			...row,
+			...patch
+		} : row));
+	},
+	remove(targets, options = {}) {
+		const key = options.key ?? "id";
+		return rewrite(targets, (rows, id) => rows.filter((row) => row[key] !== id));
+	}
+});
+//#endregion
+export { queryCache as i, createQueries as n, invalidateOnMutation as r, optimistic as t };

package/dist/rank-result-C6vsw27N.js

@@ -0,0 +1,18 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { a as ok, r as err } from "./result-DIT_qp4G.js";
+import { i as rankBetween } from "./rank-keys-DcPMt_Jk.js";
+//#region src/core/rank-result.ts
+/**
+* `rankBetween` as a result: an `invalid_request` error with the hint
+* `RANK_KEY_INVALID` instead of a `RangeError`.
+*/
+function rankBetweenResult(neighbors) {
+	try {
+		return ok(rankBetween(neighbors.previous ?? null, neighbors.next ?? null));
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		return err(dbError("invalid_request", message, { hint: "RANK_KEY_INVALID" }));
+	}
+}
+//#endregion
+export { rankBetweenResult as t };

package/dist/rank-result-DHflCNwo.d.ts

@@ -0,0 +1,14 @@
+import { f as Result } from "./result-mijqfoJN.js";
+//#region src/core/rank-result.d.ts
+/** Neighbour keys for a reorder; leave one out (or `null`) for an end. */
+interface RankNeighbors {
+  readonly previous?: string | null;
+  readonly next?: string | null;
+}
+/**
+ * `rankBetween` as a result: an `invalid_request` error with the hint
+ * `RANK_KEY_INVALID` instead of a `RangeError`.
+ */
+declare function rankBetweenResult(neighbors: RankNeighbors): Result<string>;
+//#endregion
+export { rankBetweenResult as n, RankNeighbors as t };

package/dist/rate-limit-B7N1ZGl6.d.ts

@@ -0,0 +1,50 @@
+import { f as Result } from "./result-mijqfoJN.js";
+import { a as ProblemFormat } from "./problem-D_DEBfMn.js";
+//#region src/server/rate-limit.d.ts
+/** A counted hit, as `createRateLimit().check` answers. */
+interface RateLimitVerdict {
+  readonly allowed: boolean;
+  readonly remaining: number;
+  /** Seconds until the window ends; 0 when allowed. */
+  readonly retryAfter: number;
+}
+/** A limit for one route instead of the scope's stored rule. */
+interface RouteRateLimitRule {
+  readonly max: number;
+  /** Seconds, or a Postgres interval such as `1 minute`. */
+  readonly period: number | string;
+}
+/**
+ * What `rateLimit()` counts hits with: `createRateLimit()` from
+ * `better-supabase/blocks/jobs`.
+ */
+interface RateLimiter {
+  check(scope: string, key: string, rule?: RouteRateLimitRule): PromiseLike<Result<RateLimitVerdict>>;
+}
+/** The options of the Hono and oRPC `rateLimit()` middleware. */
+interface RateLimitRouteOptions<I> {
+  readonly limiter: RateLimiter;
+  /** The scope the hits count against, and its rule from `set_rate_limit`. */
+  readonly scope: string;
+  /**
+   * Whose hits these are, such as an API key or a client IP; `undefined` skips
+   * the limit.
+   */
+  readonly key: (input: I) => string | undefined | PromiseLike<string | undefined>;
+  /**
+   * The route's limit instead of the scope's rule. With it, responses also
+   * carry `RateLimit-Policy`.
+   */
+  readonly rule?: RouteRateLimitRule;
+  /** The policy name in the headers. Default: `scope`. */
+  readonly policy?: string;
+  /**
+   * Let the request through when the limiter fails. Default: answer with its
+   * error.
+   */
+  readonly failOpen?: boolean;
+  /** The app's error body for the 429. */
+  readonly problem?: ProblemFormat;
+}
+//#endregion
+export { RouteRateLimitRule as i, RateLimitVerdict as n, RateLimiter as r, RateLimitRouteOptions as t };

package/dist/rate-limit-CXpPm4_l.js

@@ -0,0 +1,49 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { i as rateLimitPolicyHeader, n as periodSeconds, r as rateLimitHeader, t as isRateLimitPolicyName } from "./ratelimit-headers-kEcXyO3H.js";
+//#region src/server/rate-limit.ts
+/** Counts a hit for each request and builds the RateLimit fields or the refusal. */
+function rateLimitGate(options) {
+	const policy = options.policy ?? options.scope;
+	if (!isRateLimitPolicyName(policy)) throw new TypeError(`rateLimit(): "${policy}" can't name a RateLimit policy; pass a printable ASCII \`policy\``);
+	const window = options.rule === void 0 ? void 0 : periodSeconds(options.rule.period);
+	const policyHeader = options.rule === void 0 ? void 0 : rateLimitPolicyHeader([{
+		name: policy,
+		quota: options.rule.max,
+		...window === void 0 ? {} : { window }
+	}]);
+	const headersFor = (remaining, reset) => {
+		const headers = new Headers();
+		if (policyHeader !== void 0) headers.set("ratelimit-policy", policyHeader);
+		headers.set("ratelimit", rateLimitHeader([{
+			policy,
+			remaining,
+			...reset === void 0 ? {} : { reset }
+		}]));
+		return headers;
+	};
+	return async (input) => {
+		const key = await options.key(input);
+		if (key === void 0) return { kind: "skip" };
+		const checked = await options.limiter.check(options.scope, key, options.rule);
+		if (!checked.ok) return options.failOpen ? { kind: "skip" } : {
+			kind: "deny",
+			error: checked.error,
+			headers: new Headers()
+		};
+		const verdict = checked.data;
+		if (verdict.allowed) return {
+			kind: "allow",
+			headers: headersFor(Math.max(0, verdict.remaining))
+		};
+		const retryAfter = Math.max(1, Math.ceil(verdict.retryAfter));
+		const headers = headersFor(0, retryAfter);
+		headers.set("retry-after", String(retryAfter));
+		return {
+			kind: "deny",
+			error: dbError("rate_limited", `Too many requests. Retry after ${retryAfter} seconds.`, { retryAfter }),
+			headers
+		};
+	};
+}
+//#endregion
+export { rateLimitGate as t };