better-supabase 0.3.0 → 0.4.0

package/dist/{define-DUbydmJa.d.ts → define-CRS2MRV3.d.ts}

@@ -1,11 +1,11 @@
 /// <reference lib="esnext.temporal" />
 import { A as SchemaMeta, C as PrimaryKeyValue, D as Relations, E as RelationTypes, I as UniqueKeyName, L as UniqueWhere, N as TableKey, O as Row, P as TableMeta, R as Update, g as Insert, j as Simplify, k as Schema, n as AnyModels, t as AnyFunctions } from "./types-DONv9SHN.js";
-import { g as Operation, l as CountMode, r as Executor } from "./executor-DynmIWhq.js";
-import { p as DbError, s as ThrowMapper, t as AsyncResult, v as ErrorMapper } from "./result-c2OYgCV2.js";
-import { a as EventHub, f as Logger, i as EventHandler, o as EventName, s as MutationNotice, u as RpcNotice } from "./events-Do8jXh4D.js";
-import { a as ExtensionOf, g as WithExtension, h as RequestContext, n as AnyPlugin, r as ApplyExtension } from "./plugin-DVRB8qNE.js";
-import { t as StandardSchemaV1 } from "./standard-eudBiRk1.js";
-import { i as PostgrestPlan } from "./postgrest-DmBlevh-.js";
+import { g as Operation, l as CountMode, r as Executor } from "./executor-B5IoUxLE.js";
+import { p as DbError, s as ThrowMapper, t as AsyncResult, v as ErrorMapper } from "./result-CqEsbgYs.js";
+import { a as EventHub, f as Logger, i as EventHandler, o as EventName, s as MutationNotice, u as RpcNotice } from "./events-B21UOhvP.js";
+import { a as ExtensionOf, g as WithExtension, h as RequestContext, n as AnyPlugin, r as ApplyExtension } from "./plugin-bNhvJwRh.js";
+import { t as StandardSchemaV1 } from "./standard-BsaCYQJc.js";
+import { i as PostgrestPlan } from "./postgrest-Bc-0Xw62.js";
 //#region src/ir/args.d.ts
 interface BaseOps<V> {
   readonly eq?: V;
@@ -178,13 +178,17 @@ type AggregateResult<M extends AnyModels, T extends keyof M, A> = A extends {
   readonly groupBy: readonly unknown[];
 } ? AggregateRow<M, T, A>[] : AggregateRow<M, T, A>;
 /** The row type returned for read arguments `A` on table `T`. */
-type Payload<M extends AnyModels, T extends keyof M, A> = Simplify<SelectPart<M, T, A> & IncludePart<M, T, A>>;
+type Payload<M extends AnyModels, T extends keyof M, A> = A extends {
+  readonly include: unknown;
+} ? Simplify<SelectPart<M, T, A> & IncludePart<M, T, A>> : A extends {
+  readonly select: readonly unknown[];
+} ? Simplify<SelectPart<M, T, A>> : Row<M, T>;
 //#endregion
 //#region src/core/spec.d.ts
 type ReadMethod = "findMany" | "findFirst" | "findUnique" | "findById" | "count" | "aggregate" | "exists" | "paginate";
 declare const resultType: unique symbol;
 /**
- * A read, described as plain JSON: build it with `sb.spec`, run it with
+ * A read, described as plain JSON: build it with `betterSupabase.spec`, run it with
  * `db.$run(spec)`, send it from a Server Component to the client, or hand it
  * to `/query` and `/next`. Args never carry a `signal`.
  */
@@ -269,7 +273,7 @@ interface ReadSetOptions<P extends ReadSetParamTypes> {
  *
  * ```ts
  * export const appChrome = defineReadSet(
- *   sb,
+ *   betterSupabase,
  *   'app_chrome',
  *   { params: { userId: 'uuid' } },
  *   (s, p) => ({
@@ -282,7 +286,7 @@ interface ReadSetOptions<P extends ReadSetParamTypes> {
  * `p` holds placeholders, not values: pass them straight into `where` (or
  * `in`), where the function reads them from its `p jsonb` argument.
  */
-declare function defineReadSet<M extends AnyModels, D, F extends AnyFunctions, E, const N extends string, const P extends ReadSetParamTypes, const S extends Readonly<Record<string, QuerySpec>>>(sb: BetterSupabase<M, D, F, E>, name: N, options: ReadSetOptions<P>, build: (specs: Specs<M, E>, params: ReadSetParams<P>) => S): ReadSet<N, P, S>;
+declare function defineReadSet<M extends AnyModels, D, F extends AnyFunctions, E, const N extends string, const P extends ReadSetParamTypes, const S extends Readonly<Record<string, QuerySpec>>>(betterSupabase: BetterSupabase<M, D, F, E>, name: N, options: ReadSetOptions<P>, build: (specs: Specs<M, E>, params: ReadSetParams<P>) => S): ReadSet<N, P, S>;
 declare function isReadSet(value: unknown): value is ReadSet;
 /** App keys of every table the set reads. */
 declare function readSetTables(set: ReadSet, meta?: SchemaMeta): string[];
@@ -385,7 +389,7 @@ type PageOf<M extends AnyModels, T extends keyof M, A> = A extends {
   readonly after: unknown;
 } ? CursorPage<Payload<M, T, A>> : OffsetPage<Payload<M, T, A>>;
 interface Repository<M extends AnyModels, T extends TableKey<M>, E = unknown> {
-  readonly $table: T;
+  readonly $tableName: T;
   readonly $meta: TableMeta;
   findMany<const A extends FindManyArgs<M, T> & FindExt<E, M, T>>(args?: A): AsyncResult<Payload<M, T, A>[]>;
   findFirst<const A extends FindFirstArgs<M, T> & FindExt<E, M, T>>(args?: A): AsyncResult<Payload<M, T, A> | null>;
@@ -471,7 +475,7 @@ interface DbHelpers<M extends AnyModels, F extends AnyFunctions, E, C> {
   $table<T extends TableKey<M>>(name: T): RepositoryOf<M, T, E>;
   /** Calls, waves, tables and time for everything run through this `db`. */
   $stats(): DbStats;
-  /** Runs a `QuerySpec` built with `sb.spec`. */
+  /** Runs a `QuerySpec` built with `betterSupabase.spec`. */
   $run<S extends QuerySpec<TableKey<M>>>(spec: S, options?: {
     readonly signal?: AbortSignal;
   }): AsyncResult<InferResult<S>>;
@@ -516,7 +520,7 @@ interface CacheTarget {
 /**
  * Invalidates cached reads after a mutation. First-party adapters:
  * `nextCache()` (Next.js cache tags) and `queryCache(client)` (TanStack
- * Query). Attach one with `sb.cache(adapter)`; prove custom ones with
+ * Query). Attach one with `betterSupabase.cache(adapter)`; prove custom ones with
  * `testCacheAdapter`.
  */
 interface CacheAdapter {
@@ -550,20 +554,20 @@ declare function postgrestExecutor(client: PostgrestClientLike): Executor;
 declare function explainPostgrest(op: Operation): PostgrestPlan;
 //#endregion
 //#region src/core/define.d.ts
-interface DefineSupabaseOptions {
+interface SupabaseOptions {
   /** Clock used by plugins (timestamps, soft delete). */
   readonly now?: () => Temporal.Instant;
   /** Extra error mappers, run before plugin mappers. */
   readonly errors?: readonly ErrorMapper[];
   /** Receives errors from event handlers, hooks and cache adapters. Defaults to `console`. */
   readonly logger?: Logger;
-  /** RPCs that change tables, keyed by function name. Prefer `sb.defineRpc()`. */
+  /** RPCs that change tables, keyed by function name. Prefer `betterSupabase.defineRpc()`. */
   readonly rpc?: Readonly<Record<string, RpcDefinition>>;
-  /** Builds the error `.orThrow()` throws. Prefer `sb.mapError()`. */
+  /** Builds the error `.orThrow()` throws. Prefer `betterSupabase.mapError()`. */
   readonly throwAs?: ThrowMapper;
-  /** Validates verified JWT claims on the server. Prefer `sb.claims()`, which also types them. */
+  /** Validates verified JWT claims on the server. Prefer `betterSupabase.claims()`, which also types them. */
   readonly claims?: StandardSchemaV1;
-  /** Parses `user_metadata` into `session.profile`. Prefer `sb.userMetadata()`, which also types it. */
+  /** Parses `user_metadata` into `session.profile`. Prefer `betterSupabase.userMetadata()`, which also types it. */
   readonly userMetadata?: StandardSchemaV1;
   /**
    * PostgREST's `db-max-rows`: the most rows one read returns. An unbounded
@@ -594,8 +598,8 @@ declare class BetterSupabase<M extends AnyModels = AnyModels, D = unknown, F ext
   readonly schema: Schema<M, D, F>;
   readonly plugins: readonly AnyPlugin[];
   readonly events: EventHub;
-  readonly options: DefineSupabaseOptions;
-  constructor(schema: Schema<M, D, F>, plugins?: readonly AnyPlugin[], options?: DefineSupabaseOptions, events?: EventHub);
+  readonly options: SupabaseOptions;
+  constructor(schema: Schema<M, D, F>, plugins?: readonly AnyPlugin[], options?: SupabaseOptions, events?: EventHub);
   get meta(): SchemaMeta;
   /** The schema set by `claims()`; its output types `session.claims`. */
   get claimsSchema(): StandardSchemaV1<unknown, C> | undefined;
@@ -607,7 +611,7 @@ declare class BetterSupabase<M extends AnyModels = AnyModels, D = unknown, F ext
    * 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<S extends StandardSchemaV1>(schema: S): BetterSupabase<M, D, F, E, StandardSchemaV1.InferOutput<S>, P>;
@@ -620,7 +624,7 @@ declare class BetterSupabase<M extends AnyModels = AnyModels, D = unknown, F ext
    * 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<S extends StandardSchemaV1>(schema: S): BetterSupabase<M, D, F, E, C, StandardSchemaV1.InferOutput<S>>;
@@ -630,13 +634,13 @@ declare class BetterSupabase<M extends AnyModels = AnyModels, D = unknown, F ext
    * 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: (error: DbError) => unknown): BetterSupabase<M, D, F, E, C, P>;
   /**
    * 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(): Specs<M, E>;
   /** App keys of every table a spec reads; mutations of any of them make it stale. */
@@ -648,7 +652,7 @@ declare class BetterSupabase<M extends AnyModels = AnyModels, D = unknown, F ext
    * invalidate them after it succeeds.
    *
    * ```ts
-   * sb.defineRpc('archive_customer', { invalidates: ['customers', 'notes'] });
+   * betterSupabase.defineRpc('archive_customer', { invalidates: ['customers', 'notes'] });
    * ```
    */
   defineRpc(name: Extract<keyof F, string>, options: {
@@ -672,9 +676,9 @@ declare class BetterSupabase<M extends AnyModels = AnyModels, D = unknown, F ext
  * 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());
  * ```
  */
-declare function defineSupabase<M extends AnyModels, D, F extends AnyFunctions>(schema: Schema<M, D, F>, options?: DefineSupabaseOptions): BetterSupabase<M, D, F>;
+declare function defineSupabase<M extends AnyModels, D, F extends AnyFunctions>(schema: Schema<M, D, F>, options?: SupabaseOptions): BetterSupabase<M, D, F>;
 //#endregion
-export { Specs as $, RpcOptions as A, ReadSet as B, FindExt as C, WhereInput as Ct, Repository as D, PageOf as E, EMPTY_STATS as F, ReadSetParams as G, ReadSetParamType as H, StatsRecorder as I, isReadSet as J, ReadSetResult as K, recordStats as L, UpsertArgs as M, WriteArgs as N, RepositoryOf as O, DbStats as P, ReadMethod as Q, SearchArgs as R, DeleteExt as S, SortDirection as St, OffsetPageArgs as T, ReadSetParamTypes as U, ReadSetOptions as V, ReadSetParamValue as W, InferResult as X, readSetTables as Y, QuerySpec as Z, CursorPage as _, OrderByInput as _t, defineSupabase as a, AggregateRow as at, DbHelpers as b, RelationMeasureArg as bt, postgrestExecutor as c, FieldFilter as ct, MemoryCache as d, IncludeArg as dt, TableSpecs as et, cacheTargetOf as f, IncludeArgs as ft, ConflictTarget as g, OrderByArg as gt, rpcCacheTargets as h, NumericMeasureArg as ht, RpcDefinition as i, AggregateResult as it, UpdateArgs as j, Returned as k, CacheAdapter as l, FindFirstArgs as lt, rowKey as m, MeasureKey as mt, ConnectOptions as n, specTables as nt, PostgrestClientLike as o, CountArg as ot, memoryCache as p, MeasureArg as pt, defineReadSet as q, DefineSupabaseOptions as r, AggregateArgs as rt, explainPostgrest as s, CountArgs as st, BetterSupabase as t, isQuerySpec as tt, CacheTarget as u, FindManyArgs as ut, CursorPageArgs as v, Payload as vt, OffsetPage as w, DeleteArgs as x, SelectArg as xt, Db as y, ReadArgs as yt, InferReadSetParams as z };
+export { Specs as $, RpcOptions as A, ReadSet as B, FindExt as C, WhereInput as Ct, Repository as D, PageOf as E, EMPTY_STATS as F, ReadSetParams as G, ReadSetParamType as H, StatsRecorder as I, isReadSet as J, ReadSetResult as K, recordStats as L, UpsertArgs as M, WriteArgs as N, RepositoryOf as O, DbStats as P, ReadMethod as Q, SearchArgs as R, DeleteExt as S, SortDirection as St, OffsetPageArgs as T, ReadSetParamTypes as U, ReadSetOptions as V, ReadSetParamValue as W, InferResult as X, readSetTables as Y, QuerySpec as Z, CursorPage as _, OrderByInput as _t, defineSupabase as a, AggregateRow as at, DbHelpers as b, RelationMeasureArg as bt, postgrestExecutor as c, FieldFilter as ct, MemoryCache as d, IncludeArg as dt, TableSpecs as et, cacheTargetOf as f, IncludeArgs as ft, ConflictTarget as g, OrderByArg as gt, rpcCacheTargets as h, NumericMeasureArg as ht, SupabaseOptions as i, AggregateResult as it, UpdateArgs as j, Returned as k, CacheAdapter as l, FindFirstArgs as lt, rowKey as m, MeasureKey as mt, ConnectOptions as n, specTables as nt, PostgrestClientLike as o, CountArg as ot, memoryCache as p, MeasureArg as pt, defineReadSet as q, RpcDefinition as r, AggregateArgs as rt, explainPostgrest as s, CountArgs as st, BetterSupabase as t, isQuerySpec as tt, CacheTarget as u, FindManyArgs as ut, CursorPageArgs as v, Payload as vt, OffsetPage as w, DeleteArgs as x, SelectArg as xt, Db as y, ReadArgs as yt, InferReadSetParams as z };

package/dist/edge/index.d.ts

@@ -1,7 +1,7 @@
 import { N as TableKey, n as AnyModels, t as AnyFunctions } from "../types-DONv9SHN.js";
-import { t as BetterSupabase } from "../define-DUbydmJa.js";
-import { d as ServerContext, f as ServerOptions, l as BetterServer, n as GuardOptions } from "../respond-DAkPIdTH.js";
-import { a as ResourceRouteOptions } from "../resource-CwVgiI5q.js";
+import { t as BetterSupabase } from "../define-CRS2MRV3.js";
+import { f as ServerContext, n as GuardOptions, p as ServerOptions, r as MiddlewareOptions, u as BetterServer } from "../respond-DgIbdrt8.js";
+import { a as ResourceRouteOptions } from "../resource-BJcaIfxi.js";
 //#region src/edge/index.d.ts
 export interface CorsOptions {
   /** Allowed origins, or `*`. Defaults to `*`. */
@@ -17,27 +17,23 @@ export interface EdgeOptions extends ServerOptions {
   /** Include error details in problem responses. Defaults to `NODE_ENV === 'development'`. */
   readonly exposeErrors?: boolean;
 }
-export interface HandlerOptions extends GuardOptions {
-  /** Refresh an expired cookie session and send the new cookies. */
-  readonly refresh?: boolean;
-}
 export type EdgeHandler = (request: Request) => Promise<Response>;
 export type ResourceMap<M extends AnyModels> = { readonly [T in TableKey<M>]?: ResourceRouteOptions<M, T> | true; };
-export interface ResourcesOptions extends HandlerOptions {
+export interface ResourcesOptions extends MiddlewareOptions {
   /** Path before the resources, e.g. `/api` (Supabase: `/<function-name>`). */
   readonly basePath?: string;
 }
-export interface BetterEdge<M extends AnyModels, F extends AnyFunctions, E> extends BetterServer<M, F, E> {
+export interface BetterEdge<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
   /**
    * A fetch handler (`Deno.serve`, Workers `fetch`) running as the caller.
    * `Result`s become JSON or Problem Details; `undefined` becomes 204.
    */
-  handler(fn: (request: Request, ctx: ServerContext<M, F, E>) => unknown, options?: HandlerOptions): EdgeHandler;
+  handler(fn: (request: Request, ctx: ServerContext<M, F, E, C, P>) => unknown, options?: MiddlewareOptions): EdgeHandler;
   /** REST resources matching `createOpenApi`, e.g. `Deno.serve(bs.resources({ customers: true }))`. */
   resources(map: ResourceMap<M>, options?: ResourcesOptions): EdgeHandler;
 }
 export declare const SUPABASE_CORS_HEADERS: readonly string[];
 /** Fetch-handler integration for Supabase Edge Functions, Deno, Bun and Workers. */
-export declare function createEdge<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>, options?: EdgeOptions): BetterEdge<M, F, E>;
+export declare function createEdge<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: EdgeOptions): BetterEdge<M, F, E, C, P>;
 //#endregion
-export type { GuardOptions, ResourceRouteOptions };
+export type { GuardOptions, MiddlewareOptions, ResourceRouteOptions };

package/dist/edge/index.js

@@ -1,7 +1,7 @@
-import { n as dbError } from "../errors-Bl3rkOzo.js";
-import { a as problemResponse } from "../problem-CGt1ADix.js";
-import { i as respond, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-C44EZAJo.js";
-import { t as defineResource } from "../resource-D30rp0GN.js";
+import { n as dbError } from "../errors-L0xK41y_.js";
+import { a as problemResponse } from "../problem-BihjPR0t.js";
+import { a as guard, i as defaultExpose, n as extendServer, s as respond, t as createServer } from "../server-BA75B0mT.js";
+import { t as defineResource } from "../resource-My_y-Syh.js";
 //#region src/edge/index.ts
 const SUPABASE_CORS_HEADERS = [
 	"authorization",
@@ -9,15 +9,11 @@ const SUPABASE_CORS_HEADERS = [
 	"apikey",
 	"content-type"
 ];
-function corsHeaders(request, cors) {
-	const origin = request.headers.get("origin");
+/** The CORS headers for a request's origin; the fixed ones are joined once. */
+function corsFor(cors) {
 	const allowed = cors.origin ?? "*";
-	let value;
-	if (allowed === "*") value = "*";
-	else if (origin && (typeof allowed === "string" ? [allowed] : allowed).includes(origin)) value = origin;
-	if (!value) return void 0;
-	return {
-		"access-control-allow-origin": value,
+	const origins = new Set(typeof allowed === "string" ? [allowed] : allowed);
+	const fixed = {
 		"access-control-allow-headers": (cors.headers ?? SUPABASE_CORS_HEADERS).join(", "),
 		"access-control-allow-methods": (cors.methods ?? [
 			"GET",
@@ -26,8 +22,21 @@ function corsHeaders(request, cors) {
 			"DELETE",
 			"OPTIONS"
 		]).join(", "),
-		...cors.maxAge === void 0 ? {} : { "access-control-max-age": String(cors.maxAge) },
-		...value === "*" ? {} : { vary: "origin" }
+		...cors.maxAge === void 0 ? {} : { "access-control-max-age": String(cors.maxAge) }
+	};
+	const any = {
+		"access-control-allow-origin": "*",
+		...fixed
+	};
+	return (request) => {
+		if (allowed === "*") return any;
+		const origin = request.headers.get("origin");
+		if (!origin || !origins.has(origin)) return;
+		return {
+			"access-control-allow-origin": origin,
+			...fixed,
+			vary: "origin"
+		};
 	};
 }
 function withHeaders(response, headers) {
@@ -41,17 +50,20 @@ function withHeaders(response, headers) {
 	return target;
 }
 /** Fetch-handler integration for Supabase Edge Functions, Deno, Bun and Workers. */
-function createEdge(sb, options = {}) {
-	const server = createServer(sb, options);
+function createEdge(betterSupabase, options = {}) {
+	const server = createServer(betterSupabase, options);
 	const expose = options.exposeErrors ?? defaultExpose();
 	const cors = options.cors === true ? {} : options.cors === false ? void 0 : options.cors;
-	const serve = (run, handlerOptions) => {
+	const corsHeaders = cors ? corsFor(cors) : void 0;
+	const serve = (run, handlerOptions, early) => {
 		return async (request) => {
-			const extra = cors ? corsHeaders(request, cors) : void 0;
+			const extra = corsHeaders?.(request);
 			if (cors && request.method === "OPTIONS") return new Response(null, {
 				status: 204,
 				headers: extra ?? {}
 			});
+			const answered = early?.(request);
+			if (answered) return extra ? withHeaders(answered, extra) : answered;
 			const ctx = await server.context(request, { refresh: handlerOptions.refresh ?? false });
 			const instance = new URL(request.url).pathname;
 			const denied = guard(ctx.auth, handlerOptions.allow, handlerOptions.aal, handlerOptions.scopes);
@@ -83,19 +95,33 @@ function createEdge(sb, options = {}) {
 			const handlers = /* @__PURE__ */ new Map();
 			for (const [table, resource] of Object.entries(map)) {
 				if (!resource) continue;
-				handlers.set(table, defineResource(sb, table, resource === true ? {} : resource));
+				handlers.set(table, defineResource(betterSupabase, table, resource === true ? {} : resource));
 			}
-			return serve(async (request, ctx) => {
+			const routes = /* @__PURE__ */ new WeakMap();
+			const notFound = (request) => {
 				const { pathname } = new URL(request.url);
-				const instance = pathname;
 				const [table, id, extra] = (pathname.startsWith(`${base}/`) ? pathname.slice(base.length + 1) : void 0)?.split("/") ?? [];
 				const handler = table ? handlers.get(table) : void 0;
-				if (!handler || extra !== void 0 || id !== void 0 && !handler.keyParam) return problemResponse(dbError("not_found", `No route for ${pathname}`), { instance });
-				return handler.handle(request, ctx.db, id === void 0 || id === "" ? void 0 : decodeURIComponent(id), {
+				if (!handler || extra !== void 0 || id !== void 0 && !handler.keyParam) return problemResponse(dbError("not_found", `No route for ${pathname}`), { instance: pathname });
+				let key;
+				try {
+					key = id === void 0 || id === "" ? void 0 : decodeURIComponent(id);
+				} catch {
+					return problemResponse(dbError("invalid_request", `Malformed id in ${pathname}`), { instance: pathname });
+				}
+				routes.set(request, {
+					handler,
+					id: key,
+					instance: pathname
+				});
+			};
+			return serve((request, ctx) => {
+				const { handler, id, instance } = routes.get(request);
+				return handler.handle(request, ctx.db, id, {
 					instance,
 					expose
 				});
-			}, resourcesOptions);
+			}, resourcesOptions, notFound);
 		}
 	});
 }

package/dist/{entitlements-DvJXoI02.d.ts → entitlements-Dm-FHpNH.d.ts}

@@ -1,4 +1,4 @@
-import { t as AuthSession } from "./view-3Po_PVlr.js";
+import { t as AuthSession } from "./view-B64o81wp.js";
 //#region src/auth/entitlements.d.ts
 /**
  * One entry of the `memberships` claim, in PermDock's shape. PermDock strips
@@ -25,7 +25,7 @@ interface MembershipClaim {
 }
 /**
  * Entitlement keys of the `features` claim: the literal union when
- * `sb.claims(schema)` declares one (`z.enum([...])`), otherwise `string`.
+ * `betterSupabase.claims(schema)` declares one (`z.enum([...])`), otherwise `string`.
  */
 type EntitlementKey<C> = C extends {
   readonly features?: infer F;

package/dist/{errors-Bl3rkOzo.js → errors-L0xK41y_.js}

@@ -41,7 +41,7 @@ function isDbError(value) {
 }
 /**
 * The `DbError` in a `DbError`, a `DbException`, or an error whose `cause`
-* is a `DbError` (what `sb.mapError()` mappers should set).
+* is a `DbError` (what `betterSupabase.mapError()` mappers should set).
 */
 function dbErrorOf(value) {
 	if (value instanceof DbException) return value.error;

package/dist/events/index.d.ts

@@ -1,2 +1,2 @@
-import { a as HttpMode, c as RowEventData, d as httpSink, f as isCloudEvent, i as ForwardOptions, l as forwardMutations, m as toHttp, n as CloudEventOptions, o as HttpSinkOptions, p as toCloudEvents, r as EventSink, s as ROW_EVENT_TYPES, t as CloudEvent, u as fromHttp } from "../index-GV77NpRP.js";
+import { a as HttpMode, c as RowEventData, d as httpSink, f as isCloudEvent, i as ForwardOptions, l as forwardMutations, m as toHttp, n as CloudEventOptions, o as HttpSinkOptions, p as toCloudEvents, r as EventSink, s as ROW_EVENT_TYPES, t as CloudEvent, u as fromHttp } from "../index-D5IfUIDh.js";
 export { CloudEvent, CloudEventOptions, EventSink, ForwardOptions, HttpMode, HttpSinkOptions, ROW_EVENT_TYPES, RowEventData, forwardMutations, fromHttp, httpSink, isCloudEvent, toCloudEvents, toHttp };

package/dist/events/index.js

@@ -44,17 +44,17 @@ function toCloudEvents(notice, options) {
 * Sends a CloudEvent for every mutation to `sink`. Returns a function that
 * stops forwarding. Use an outbox (SQL kit) when events must not be lost.
 */
-function forwardMutations(sb, sink, options) {
-	return sb.events.on("mutation", (notice) => {
+function forwardMutations(betterSupabase, sink, options) {
+	return betterSupabase.events.on("mutation", (notice) => {
 		if (options.filter && !options.filter(notice)) return;
 		const events = toCloudEvents(notice, {
 			...options,
-			meta: sb.meta
+			meta: betterSupabase.meta
 		});
 		if (events.length === 0) return;
 		const report = (error) => {
 			(options.onError ?? ((cause) => {
-				sb.events.logger.error("event sink failed", { cause });
+				betterSupabase.events.logger.error("event sink failed", { cause });
 			}))(error, events);
 		};
 		try {

package/dist/{events-Do8jXh4D.d.ts → events-B21UOhvP.d.ts}

@@ -1,6 +1,6 @@
-import { g as Operation } from "./executor-DynmIWhq.js";
-import { p as DbError } from "./result-c2OYgCV2.js";
-import { h as RequestContext, l as MutationKind } from "./plugin-DVRB8qNE.js";
+import { g as Operation } from "./executor-B5IoUxLE.js";
+import { p as DbError } from "./result-CqEsbgYs.js";
+import { h as RequestContext, l as MutationKind } from "./plugin-bNhvJwRh.js";
 //#region src/core/logger.d.ts
 type LogFields = Readonly<Record<string, unknown>>;
 /**
@@ -37,7 +37,7 @@ interface MutationNotice {
   readonly rows: readonly Readonly<Record<string, unknown>>[];
   readonly context: RequestContext;
 }
-/** A successful RPC registered with `sb.defineRpc(name, { invalidates })`. */
+/** A successful RPC registered with `betterSupabase.defineRpc(name, { invalidates })`. */
 interface RpcNotice {
   readonly name: string;
   /** App keys of the tables the function changes. */

package/dist/{executor-DynmIWhq.d.ts → executor-B5IoUxLE.d.ts}

@@ -1,5 +1,5 @@
 import { P as TableMeta, T as RelationMeta, c as Codec } from "./types-DONv9SHN.js";
-import { o as Result, v as ErrorMapper } from "./result-c2OYgCV2.js";
+import { o as Result, v as ErrorMapper } from "./result-CqEsbgYs.js";
 //#region src/ir/types.d.ts
 /**
  * The query IR. Every repository call becomes one of these operations; the

package/dist/{executor-C57jx2pn.js → executor-CVt6dD0B.js}

@@ -1,6 +1,6 @@
-import { c as mapDbError, n as dbError } from "./errors-Bl3rkOzo.js";
-import { i as ok, n as err, o as toDbError } from "./result-DWXatkd6.js";
-import { t as compileSql } from "./sql-BIgk12ew.js";
+import { c as mapDbError, n as dbError } from "./errors-L0xK41y_.js";
+import { i as ok, n as err, o as toDbError } from "./result-Bj6yt33D.js";
+import { t as compileSql } from "./sql-B34HU2DI.js";
 //#region src/postgres/executor.ts
 function isPgError(value) {
 	return typeof value === "object" && value !== null && typeof value.code === "string";

package/dist/{executor-B26lgbHD.d.ts → executor-CZ7ImRiD.d.ts}

@@ -1,5 +1,5 @@
-import { r as Executor } from "./executor-DynmIWhq.js";
-import { y as RawDbError } from "./result-c2OYgCV2.js";
+import { r as Executor } from "./executor-B5IoUxLE.js";
+import { y as RawDbError } from "./result-CqEsbgYs.js";
 //#region src/postgres/executor.d.ts
 /**
  * Anything that runs parameterized SQL: `ctx.postgres` from

package/dist/hono/index.d.ts

@@ -1,45 +1,38 @@
 import { N as TableKey, n as AnyModels, t as AnyFunctions } from "../types-DONv9SHN.js";
-import { t as BetterSupabase } from "../define-DUbydmJa.js";
-import { r as AuthState } from "../resolve-BRciX2jK.js";
-import { d as ServerContext, f as ServerOptions, l as BetterServer, n as GuardOptions } from "../respond-DAkPIdTH.js";
-import { a as ResourceRouteOptions } from "../resource-CwVgiI5q.js";
+import { t as BetterSupabase } from "../define-CRS2MRV3.js";
+import { r as AuthState } from "../resolve-BAqQcwMW.js";
+import { f as ServerContext, n as GuardOptions, p as ServerOptions, r as MiddlewareOptions, u as BetterServer } from "../respond-DgIbdrt8.js";
+import { a as ResourceRouteOptions } from "../resource-BJcaIfxi.js";
 import { Context, ErrorHandler, Hono, MiddlewareHandler } from "hono";
 //#region src/hono/index.d.ts
 /** Hono `Env` with the request's better-supabase context in `c.var`. */
-export interface BetterEnv<M extends AnyModels, F extends AnyFunctions, E> {
+export interface HonoEnv<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> {
   Variables: {
-    readonly bs: ServerContext<M, F, E>;
-    readonly db: ServerContext<M, F, E>["db"];
-    readonly auth: AuthState;
+    readonly bs: ServerContext<M, F, E, C, P>;
+    readonly db: ServerContext<M, F, E, C, P>["db"];
+    readonly auth: AuthState<C, P>;
   };
 }
 export interface HonoOptions extends ServerOptions {
   /** Include error details in problem responses. Defaults to `NODE_ENV === 'development'`. */
   readonly exposeErrors?: boolean;
 }
-export interface MiddlewareOptions extends GuardOptions {
-  /**
-   * Refresh an expired cookie session and send the new cookies. Only for
-   * routes browsers call with cookies; bearer tokens never refresh.
-   */
-  readonly refresh?: boolean;
-}
-export interface BetterHono<M extends AnyModels, F extends AnyFunctions, E> extends BetterServer<M, F, E> {
+export interface BetterHono<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
   /** Resolves the caller, enforces `allow` and sets `c.var.bs`, `c.var.db`, `c.var.auth`. */
-  middleware(options?: MiddlewareOptions): MiddlewareHandler<BetterEnv<M, F, E>>;
+  middleware(options?: MiddlewareOptions): MiddlewareHandler<HonoEnv<M, F, E, C, P>>;
   /** Wraps a handler: `Result`s become JSON or Problem Details, `undefined` becomes 204. */
-  handle(handler: (c: Context<BetterEnv<M, F, E>>, ctx: ServerContext<M, F, E>) => unknown, options?: {
+  handler(fn: (c: Context<HonoEnv<M, F, E, C, P>>, ctx: ServerContext<M, F, E, C, P>) => unknown, options?: {
     readonly status?: number;
-  }): (c: Context<BetterEnv<M, F, E>>) => Promise<Response>;
+  }): (c: Context<HonoEnv<M, F, E, C, P>>) => Promise<Response>;
   /** `app.onError(bs.onError)`: `DbException`s (and errors caused by a `DbError`) become Problem Details, others a 500. */
-  readonly onError: ErrorHandler<BetterEnv<M, F, E>>;
+  readonly onError: ErrorHandler<HonoEnv<M, F, E, C, P>>;
   /**
    * REST routes for a table matching `createOpenApi`. Mount with
    * `app.route('/customers', bs.resource('customers'))` behind `middleware()`.
    */
-  resource<T extends TableKey<M>>(table: T, options?: ResourceRouteOptions<M, T>): Hono<BetterEnv<M, F, E>>;
+  resource<T extends TableKey<M>>(table: T, options?: ResourceRouteOptions<M, T>): Hono<HonoEnv<M, F, E, C, P>>;
 }
 /** Hono integration: a server plus middleware, handlers and REST resources. */
-export declare function createHono<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>, options?: HonoOptions): BetterHono<M, F, E>;
+export declare function createHono<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: HonoOptions): BetterHono<M, F, E, C, P>;
 //#endregion
-export type { GuardOptions, ResourceRouteOptions };
+export type { GuardOptions, MiddlewareOptions, ResourceRouteOptions };

package/dist/hono/index.js

@@ -1,7 +1,7 @@
-import { n as dbError, r as dbErrorOf } from "../errors-Bl3rkOzo.js";
-import { a as problemResponse } from "../problem-CGt1ADix.js";
-import { i as respond, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-C44EZAJo.js";
-import { t as defineResource } from "../resource-D30rp0GN.js";
+import { n as dbError, r as dbErrorOf } from "../errors-L0xK41y_.js";
+import { a as problemResponse } from "../problem-BihjPR0t.js";
+import { a as guard, i as defaultExpose, n as extendServer, s as respond, t as createServer } from "../server-BA75B0mT.js";
+import { t as defineResource } from "../resource-My_y-Syh.js";
 import { Hono } from "hono";
 //#region src/hono/index.ts
 function contextOf(c) {
@@ -10,8 +10,8 @@ function contextOf(c) {
 	return ctx;
 }
 /** Hono integration: a server plus middleware, handlers and REST resources. */
-function createHono(sb, options = {}) {
-	const server = createServer(sb, options);
+function createHono(betterSupabase, options = {}) {
+	const server = createServer(betterSupabase, options);
 	const expose = options.exposeErrors ?? defaultExpose();
 	const onError = (cause, c) => {
 		const instance = new URL(c.req.url).pathname;
@@ -43,18 +43,18 @@ function createHono(sb, options = {}) {
 				c.res = ctx.resolution.apply(c.res);
 			};
 		},
-		handle(handler, handleOptions = {}) {
+		handler(fn, handlerOptions = {}) {
 			return (c) => {
 				const ctx = contextOf(c);
-				return respond(() => handler(c, ctx), {
+				return respond(() => fn(c, ctx), {
 					instance: new URL(c.req.url).pathname,
 					expose,
-					...handleOptions
+					...handlerOptions
 				});
 			};
 		},
 		resource(table, resourceOptions) {
-			const resource = defineResource(sb, table, resourceOptions);
+			const resource = defineResource(betterSupabase, table, resourceOptions);
 			const app = new Hono();
 			const serve = (item) => (c) => resource.handle(c.req.raw, contextOf(c).db, item ? c.req.param("id") : void 0, {
 				instance: new URL(c.req.url).pathname,

package/dist/{index-CTTMS6_1.d.ts → index-528Ugmyp.d.ts}

@@ -1,6 +1,6 @@
 /// <reference lib="esnext.temporal" />
 import { b as PermdockBucketPolicy, i as BucketPolicyName } from "./types-DONv9SHN.js";
-import { p as DbError, t as AsyncResult } from "./result-c2OYgCV2.js";
+import { p as DbError, t as AsyncResult } from "./result-CqEsbgYs.js";
 import { n as StoragePath, t as PathIn } from "./path-Cv__-OTj.js";
 import { t as PermdockCatalog } from "./permdock-sql-DImJULY-.js";
 import { n as TemplateValues, t as TemplateParams } from "./template-mbvlysOo.js";
@@ -202,7 +202,16 @@ interface Bucket<P extends string, Id extends string = string> {
   /** A `[storage.buckets.<id>]` section for `supabase/config.toml`. */
   toml(): string;
   drift(actual: ActualBucket | undefined): readonly BucketDrift[];
-  connect(client: StorageClient): BucketClient<P, Id>;
+  connect(client: StorageClient, options?: BucketConnectOptions): BucketClient<P, Id>;
+}
+interface BucketConnectOptions {
+  /**
+   * Reuse a signed URL for the same path, `ttl`, `transform` and `download`
+   * until shortly before it expires (a tenth of the `ttl`, at most a minute).
+   * The cache belongs to this connection; connect once per request so URLs
+   * never cross users.
+   */
+  readonly cacheSignedUrls?: boolean;
 }
 declare function parseSize(value: string | number): number;
 /** Maps a Storage error (`StorageApiError`, fetch failures) to a `DbError`. */
@@ -224,4 +233,4 @@ declare function fromStorageError(raw: unknown, table?: string): DbError;
  */
 declare function defineBucket<const P extends string, const Id extends string = string>(config: BucketConfig<P, Id>): Bucket<P, Id>;
 //#endregion
-export { parseSize as C, fromStorageError as S, TtlPreset as _, BucketDrift as a, UrlOptions as b, ReplaceOptions as c, StorageClient as d, StoredObject as f, TransformOptions as g, TTL as h, BucketConfig as i, ReplaceResult as l, SweepResult as m, Bucket as n, BucketPolicy as o, SweepOptions as p, BucketClient as r, ObjectTarget as s, ActualBucket as t, Reservation as u, UploadBody as v, defineBucket as x, UploadOptions as y };
+export { fromStorageError as C, defineBucket as S, TransformOptions as _, BucketConnectOptions as a, UploadOptions as b, ObjectTarget as c, Reservation as d, StorageClient as f, TTL as g, SweepResult as h, BucketConfig as i, ReplaceOptions as l, SweepOptions as m, Bucket as n, BucketDrift as o, StoredObject as p, BucketClient as r, BucketPolicy as s, ActualBucket as t, ReplaceResult as u, TtlPreset as v, parseSize as w, UrlOptions as x, UploadBody as y };

package/dist/{index-CADlNHK-.d.ts → index-BAy4tsAP.d.ts}

@@ -1,7 +1,7 @@
 import { N as TableKey, O as Row, n as AnyModels, t as AnyFunctions } from "./types-DONv9SHN.js";
-import { l as CountMode } from "./executor-DynmIWhq.js";
-import { b as ValidationIssue, t as AsyncResult } from "./result-c2OYgCV2.js";
-import { C as FindExt, Ct as WhereInput, O as RepositoryOf, T as OffsetPageArgs, _ as CursorPage, dt as IncludeArg, gt as OrderByArg, t as BetterSupabase, v as CursorPageArgs, vt as Payload, w as OffsetPage, xt as SelectArg } from "./define-DUbydmJa.js";
+import { l as CountMode } from "./executor-B5IoUxLE.js";
+import { b as ValidationIssue, t as AsyncResult } from "./result-CqEsbgYs.js";
+import { C as FindExt, Ct as WhereInput, O as RepositoryOf, T as OffsetPageArgs, _ as CursorPage, dt as IncludeArg, gt as OrderByArg, t as BetterSupabase, v as CursorPageArgs, vt as Payload, w as OffsetPage, xt as SelectArg } from "./define-CRS2MRV3.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/list/list-query.d.ts
 /** Facet value meaning "not set": filters with `is null`. */
@@ -144,7 +144,7 @@ type ListParsers<S extends string, F extends string> = {
  * OpenAPI parameters and a JSON Schema derived from the same definition.
  *
  * ```ts
- * export const customerList = defineListQuery(sb, 'customers', {
+ * export const customerList = defineListQuery(betterSupabase, 'customers', {
  *   search: ['name', 'kvk'],
  *   facets: { status: 'status' },
  *   sorts: { name: { name: 'asc' }, newest: [{ createdAt: 'desc' }, { id: 'asc' }] },
@@ -152,6 +152,6 @@ type ListParsers<S extends string, F extends string> = {
  * });
  * ```
  */
-declare function defineListQuery<M extends AnyModels, D, Fn extends AnyFunctions, E, T extends TableKey<M>, const S extends string, const F extends string = never, const C extends boolean = false, const P extends ListPagination = "offset">(sb: BetterSupabase<M, D, Fn, E>, table: T, config: ListQueryConfig<M, T, S, F, C, P>): ListDefinition<M, T, E, S, F, C, P>;
+declare function defineListQuery<M extends AnyModels, D, Fn extends AnyFunctions, E, T extends TableKey<M>, const S extends string, const F extends string = never, const C extends boolean = false, const P extends ListPagination = "offset">(betterSupabase: BetterSupabase<M, D, Fn, E>, table: T, config: ListQueryConfig<M, T, S, F, C, P>): ListDefinition<M, T, E, S, F, C, P>;
 //#endregion
 export { ListPage as a, ListParsers as c, ListQueryInput as d, ListSearchParams as f, defineListQuery as g, UNSET as h, ListExtra as i, ListQuery as l, ParserSpec as m, FacetInfo as n, ListPagination as o, OpenApiParameter as p, ListDefinition as r, ListParseResult as s, FacetCounts as t, ListQueryConfig as u };