better-supabase 0.7.1 → 0.9.0

package/dist/index-Bepi-Hgg.d.ts

@@ -1,206 +0,0 @@
-import { n as DbException } from "./escape-like-ImTK0ps_.js";
-import { E as PrimaryKeyValue, H as Update, L as TableKey, V as UniqueWhere, a as AnyModels, i as AnyFunctions, x as Insert } from "./types-6BdhkmZe.js";
-import { C as DeleteExt, D as OffsetPage, F as UpdateArgs, I as UpsertArgs, Mt as Payload, N as Returned, Nt as ReadArgs, O as OffsetPageArgs, R as WriteArgs, S as DeleteArgs, St as FindOnlyArgs, b as Db, bt as FindFirstArgs, it as QuerySpec, k as OffsetRangeArgs, pt as AggregateResult, rt as InferResult, t as BetterSupabase, u as CacheAdapter, ut as AggregateArgs, v as CursorPage, vt as CountArgs, w as FindExt, xt as FindManyArgs, y as CursorPageArgs, zt as WhereInput } from "./define-CJJkkr1-.js";
-import { t as BetterQueryMeta } from "./invalidate-BBqhpxyB.js";
-import { DataTag, InfiniteData, QueryClient, SkipToken } from "@tanstack/query-core";
-//#region src/query/queries.d.ts
-type QueryKeyOf<T> = DataTag<readonly unknown[], T, DbException>;
-type QueryFnOf<T> = ((context: {
-  readonly signal: AbortSignal;
-}) => Promise<T>) | SkipToken;
-/** Options for `useQuery`, `createQuery`, `injectQuery`, `queryClient.fetchQuery` and `prefetchQuery`. */
-interface QueryOptionsOf<T> {
-  readonly queryKey: QueryKeyOf<T>;
-  readonly queryFn: QueryFnOf<T>;
-  readonly meta: BetterQueryMeta;
-  readonly staleTime?: number;
-}
-/** Options for infinite queries over cursor (`string | null`) or offset (`number`) pages. */
-interface InfiniteOptionsOf<P, Param> {
-  readonly queryKey: DataTag<readonly unknown[], InfiniteData<P>, DbException>;
-  readonly queryFn: (context: {
-    readonly signal: AbortSignal;
-    readonly pageParam: Param;
-  }) => Promise<P>;
-  readonly initialPageParam: Param;
-  readonly getNextPageParam: (last: P) => Param | undefined;
-  /** Set on numbered pages, so a window trimmed by `maxPages` can load backwards. */
-  readonly getPreviousPageParam?: (first: P) => Param | undefined;
-  readonly maxPages?: number;
-  readonly meta: BetterQueryMeta;
-  readonly staleTime?: number;
-}
-interface InfiniteExtras {
-  /**
-   * Pages kept in the cache; older ones are dropped as new ones load. Keeps
-   * long feeds from holding every page in memory and refetching them all.
-   */
-  readonly maxPages?: number;
-}
-/** Options for `useMutation`. Invalidates every query that read a changed table. */
-interface MutationOptionsOf<V, R> {
-  readonly mutationKey: readonly unknown[];
-  readonly mutationFn: (variables: V) => Promise<R>;
-  readonly onSuccess: (data: R, variables: V, onMutateResult: unknown, context: {
-    readonly client: QueryClient;
-  }) => Promise<void>;
-}
-interface TableQueries<M extends AnyModels, T extends TableKey<M>, E> {
-  /** Prefix of every key for this table's own queries. */
-  readonly key: readonly ["bs", T];
-  findMany<const A extends FindManyArgs<M, T> & FindExt<E, M, T>>(args?: A | SkipToken): QueryOptionsOf<Payload<M, T, A>[]>;
-  findFirst<const A extends FindFirstArgs<M, T> & FindExt<E, M, T>>(args?: A | SkipToken): QueryOptionsOf<Payload<M, T, A> | null>;
-  findOnly<const A extends FindOnlyArgs<M, T> & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<Payload<M, T, A> | null>;
-  findUnique<const A extends ReadArgs<M, T> & {
-    readonly where: UniqueWhere<M, T>;
-  } & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<Payload<M, T, A> | null>;
-  findById<const A extends ReadArgs<M, T> & FindExt<E, M, T>>(id: PrimaryKeyValue<M, T> | SkipToken, args?: A): QueryOptionsOf<Payload<M, T, A>>;
-  count(args?: (CountArgs<M, T> & FindExt<E, M, T>) | SkipToken): QueryOptionsOf<number>;
-  aggregate<const A extends AggregateArgs<M, T> & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<AggregateResult<M, T, A>>;
-  exists(args?: ({
-    readonly where?: WhereInput<M, T>;
-  } & FindExt<E, M, T>) | SkipToken): QueryOptionsOf<boolean>;
-  paginate<const A extends (OffsetPageArgs<M, T> | OffsetRangeArgs<M, T>) & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<OffsetPage<Payload<M, T, A>>>;
-  /** Cursor pages for `useInfiniteQuery`. */
-  infinite<const A extends Omit<CursorPageArgs<M, T>, "after"> & FindExt<E, M, T>>(args: A, options?: InfiniteExtras): InfiniteOptionsOf<CursorPage<Payload<M, T, A>>, string | null>;
-  /** Numbered pages for `useInfiniteQuery`, starting at `args.page` (default 1). */
-  infinitePages<const A extends OffsetPageArgs<M, T> & FindExt<E, M, T>>(args: A, options?: InfiniteExtras): InfiniteOptionsOf<OffsetPage<Payload<M, T, A>>, number>;
-  create<const A extends WriteArgs<M, T> = {}>(args?: A): MutationOptionsOf<Insert<M, T>, Returned<M, T, A>>;
-  update<const A extends UpdateArgs<M, T> = {}>(args?: A): MutationOptionsOf<{
-    readonly id: PrimaryKeyValue<M, T>;
-    readonly patch: Update<M, T>;
-  }, Returned<M, T, A>>;
-  upsert<const A extends UpsertArgs<M, T> = {}>(args?: A): MutationOptionsOf<Insert<M, T>, Returned<M, T, A>>;
-  delete(args?: DeleteArgs & DeleteExt<E, M, T>): MutationOptionsOf<PrimaryKeyValue<M, T>, void>;
-}
-type RpcArgsOf<F extends AnyFunctions, N extends keyof F> = F[N]["Args"];
-interface QueryHelpers<M extends AnyModels, F extends AnyFunctions> {
-  /** Prefix of every better-supabase key. */
-  readonly $key: readonly ["bs"];
-  /** Query options for a `QuerySpec`, for example one sent from a Server Component. */
-  $spec<S extends QuerySpec<TableKey<M>>>(spec: S | SkipToken): QueryOptionsOf<InferResult<S>>;
-  /** Fetches a spec into `queryClient` for server rendering and hydration. */
-  $prefetch(queryClient: QueryClient, spec: QuerySpec<TableKey<M>>): Promise<void>;
-  /** Query options for a database function. `tables` lists what it reads, for invalidation. */
-  $rpc<N extends Extract<keyof F, string>>(name: N, args?: RpcArgsOf<F, N> | SkipToken, options?: {
-    readonly tables?: readonly TableKey<M>[];
-  }): QueryOptionsOf<F[N]["Returns"]>;
-  /** Mutation options for a database function; invalidates what `betterSupabase.defineRpc` declared. */
-  $rpcMutation<N extends Extract<keyof F, string>>(name: N): MutationOptionsOf<RpcArgsOf<F, N>, F[N]["Returns"]>;
-}
-type BetterQueries<M extends AnyModels, E, F extends AnyFunctions = AnyFunctions> = { readonly [T in TableKey<M>]: TableQueries<M, T, E>; } & QueryHelpers<M, F>;
-interface QueriesOptions {
-  /**
-   * `staleTime` for every query option. Set it above zero when rendering on
-   * the server so hydrated data isn't refetched on mount.
-   */
-  readonly staleTime?: number;
-  /**
-   * Appended to every query key. Give each executor its own scope (`'local'`
-   * for PowerSync, for instance) when several share one QueryClient, so their
-   * results never land in the same cache entry. Invalidation by table still
-   * reaches every scope.
-   */
-  readonly scope?: string;
-}
-/**
- * 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'] }));
- * ```
- */
-declare function createQueries<M extends AnyModels, D, F extends AnyFunctions, E>(betterSupabase: BetterSupabase<M, D, F, E>, db: Db<M, F, E, unknown> | (() => Db<M, F, E, unknown>), options?: QueriesOptions): BetterQueries<M, E, F>;
-/** Invalidates every query that read a table in the target. */
-declare function queryCache(client: QueryClient): CacheAdapter;
-/** Invalidates affected queries for every mutation and declared RPC `betterSupabase` performs in this runtime. */
-declare function invalidateOnMutation<M extends AnyModels, D, F extends AnyFunctions, E>(betterSupabase: BetterSupabase<M, D, F, E>, client: QueryClient): () => void;
-//#endregion
-//#region src/query/user-change.d.ts
-/** The part of `createClient().auth` that `clearOnUserChange` reads. */
-interface UserChangeSource {
-  subscribe(listener: () => void): () => void;
-  current(): {
-    readonly status: string;
-    readonly user: {
-      readonly id: string;
-    } | null;
-    readonly claims?: Readonly<Record<string, unknown>> | null;
-  };
-}
-/**
- * Resets every `['bs', ...]` query when the caller changes: another user,
- * signing out, or new claims for the same user (an organization switch, a
- * role change). Mounted queries refetch, so no one sees the previous
- * identity's rows. Returns the function that stops listening.
- * `BetterSupabaseProvider` calls it for React; call it yourself with Vue,
- * Solid, Svelte or Angular Query.
- *
- * Queries that fetched while the session was still loading ran as anon, so
- * they are reset when a user arrives. Data already in the cache when loading
- * started (hydrated from the server) stays.
- *
- * ```ts
- * const stop = clearOnUserChange(queryClient, bs.auth);
- * ```
- */
-declare function clearOnUserChange(queryClient: Pick<QueryClient, "resetQueries" | "getQueryCache">, auth: UserChangeSource): () => void;
-//#endregion
-//#region src/query/optimistic.d.ts
-/** A query whose cached data an optimistic update rewrites: any `q.<table>.*()` option. */
-interface OptimisticTarget<T> {
-  readonly queryKey: QueryKeyOf<T>;
-}
-interface MutationContext {
-  readonly client: QueryClient;
-}
-/** What `onMutate` returns: the data each target held before the change. */
-interface OptimisticSnapshot {
-  readonly previous: readonly (readonly [queryKey: readonly unknown[], data: unknown])[];
-}
-/**
- * `onMutate`, `onError` and `onSettled` for `useMutation`: spread them next
- * to a mutation option, which keeps its `onSuccess` invalidation.
- */
-interface OptimisticHandlers<V> {
-  onMutate(variables: V, context: MutationContext): Promise<OptimisticSnapshot>;
-  onError(error: Error, variables: V, snapshot: OptimisticSnapshot | undefined, context: MutationContext): void;
-  onSettled(data: unknown, error: Error | null, variables: V, snapshot: OptimisticSnapshot | undefined, context: MutationContext): Promise<void>;
-}
-type Targets<T> = OptimisticTarget<T> | readonly OptimisticTarget<T>[];
-type Keyed<R> = Extract<keyof R, string>;
-/**
- * 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) });
- * ```
- */
-declare const optimistic: (<T, V>(targets: Targets<T>, apply: (current: T, variables: V) => T) => OptimisticHandlers<V>) & {
-  create<R, V>(targets: Targets<R[]>, toRow: (variables: V) => R, options?: {
-    readonly position?: "start" | "end";
-  }): OptimisticHandlers<V>;
-  update<R, K extends Keyed<R> = Keyed<R> & "id">(targets: Targets<R[]>, options?: {
-    readonly key?: K;
-  }): OptimisticHandlers<{
-    readonly id: R[K];
-    readonly patch: Partial<R>;
-  }>;
-  remove<R, K extends Keyed<R> = Keyed<R> & "id">(targets: Targets<R[]>, options?: {
-    readonly key?: K;
-  }): OptimisticHandlers<R[K]>;
-};
-//#endregion
-export { invalidateOnMutation as _, UserChangeSource as a, InfiniteExtras as c, QueriesOptions as d, QueryHelpers as f, createQueries as g, TableQueries as h, optimistic as i, InfiniteOptionsOf as l, QueryOptionsOf as m, OptimisticSnapshot as n, clearOnUserChange as o, QueryKeyOf as p, OptimisticTarget as r, BetterQueries as s, OptimisticHandlers as t, MutationOptionsOf as u, queryCache as v };

package/dist/index-BkWT_uBO.d.ts

@@ -1,51 +0,0 @@
-import { a as AnyModels, i as AnyFunctions } from "./types-6BdhkmZe.js";
-import { l as PublicEnv } from "./index-CLg87OBW.js";
-import { s as SessionEncoding } from "./session-ChiXDZdZ.js";
-import { t as BetterSupabase } from "./define-CJJkkr1-.js";
-import { r as BetterClient } from "./bind-Bu_ZNa3W.js";
-import { SupabaseClient, SupabaseClientOptions } from "@supabase/supabase-js";
-//#region src/client/index.d.ts
-interface ClientOptions {
-  /** URL and publishable key. Not needed when `client` is given. */
-  readonly env?: PublicEnv;
-  /**
-   * Bring your own supabase-js client (custom storage). React Native apps
-   * use `better-supabase/client/native`, which doesn't load `@supabase/ssr`.
-   */
-  readonly client?: SupabaseClient;
-  /**
-   * `cookies` (default) shares the session with the server through
-   * `@supabase/ssr`; `local` keeps it in localStorage for SPAs without a server.
-   */
-  readonly storage?: "cookies" | "local";
-  readonly cookies?: {
-    /**
-     * `tokens-only` keeps the user object out of the cookie (it lives in
-     * `auth.userStorage`, localStorage by default), so cookies stay small.
-     * Use the same value as the server's `encode`. Defaults to
-     * `user-and-tokens`.
-     */
-    readonly encode?: SessionEncoding;
-  };
-  readonly auth?: {
-    /** Where auth-js keeps the user object with `cookies.encode: 'tokens-only'`. */
-    readonly userStorage?: UserStorage;
-  };
-  /**
-   * `staleTime` for every query option in `bs.queries`. Above zero, a
-   * remount or a window focus reuses cached rows instead of refetching.
-   */
-  readonly staleTime?: number;
-}
-type UserStorage = NonNullable<NonNullable<SupabaseClientOptions<"public">["auth"]>["userStorage"]>;
-/**
- * The browser side: a supabase-js client, repositories that follow the
- * session, TanStack Query options and an auth store for UI state.
- *
- * ```ts
- * export const bs = createClient(betterSupabase, { env: { url, publishableKey } });
- * ```
- */
-declare function createClient$1<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: ClientOptions): BetterClient<M, F, E, C, P>;
-//#endregion
-export { createClient$1 as n, ClientOptions as t };

package/dist/index-Bxih3l0u.d.ts

@@ -1,81 +0,0 @@
-import { P as SchemaMeta } from "./types-6BdhkmZe.js";
-import { m as OpenApiParameter } from "./list-query-BRt-zDF7.js";
-//#region src/openapi/index.d.ts
-type Json = Record<string, unknown>;
-type ResourceOperation = "list" | "get" | "create" | "update" | "delete";
-interface ResourceOptions {
-  /** Defaults to every operation for tables, `list` and `get` for views. */
-  readonly operations?: readonly ResourceOperation[];
-  /** Parameters for `list`, from `defineListQuery`. */
-  readonly list?: {
-    readonly openapi: readonly OpenApiParameter[];
-    readonly pagination?: "offset" | "cursor";
-  };
-  /** Paging of the default list, as in `defineResource`. Defaults to `offset`. */
-  readonly pagination?: "offset" | "cursor";
-  /** Largest page of the default list. Defaults to 200. */
-  readonly maxPageSize?: number;
-  /** Path of the collection. Defaults to `/<table>`. */
-  readonly path?: string;
-  readonly tag?: string;
-  readonly description?: string;
-}
-interface OpenApiOptions {
-  readonly info: {
-    readonly title: string;
-    readonly version: string;
-    readonly description?: string;
-  };
-  readonly servers?: readonly {
-    readonly url: string;
-    readonly description?: string;
-  }[];
-  /** Prefix for every path, e.g. `/api`. */
-  readonly basePath?: string;
-  /** Tables to publish, by app key. */
-  readonly resources: Readonly<Record<string, ResourceOptions | true>>;
-  /**
-   * Security schemes. `bearer` is a Supabase access token; `oauth2` uses the
-   * Supabase OAuth server and needs `supabaseUrl`. Defaults to `['bearer']`.
-   */
-  readonly security?: readonly ("bearer" | "oauth2")[];
-  readonly supabaseUrl?: string;
-  /** Tables with a JSON column typed in `better-supabase.config.ts`. */
-  readonly json?: Readonly<Record<string, unknown>>;
-}
-interface OpenApiDocument {
-  readonly openapi: string;
-  readonly info: OpenApiOptions["info"];
-  readonly jsonSchemaDialect: string;
-  readonly servers?: OpenApiOptions["servers"];
-  readonly tags: readonly {
-    readonly name: string;
-    readonly description?: string;
-  }[];
-  readonly paths: Readonly<Record<string, Json>>;
-  readonly components: {
-    readonly schemas: Readonly<Record<string, Json>>;
-    readonly responses: Readonly<Record<string, Json>>;
-    readonly securitySchemes: Readonly<Record<string, Json>>;
-  };
-  readonly security: readonly Readonly<Record<string, readonly string[]>>[];
-}
-/** JSON Schema for RFC 9457 Problem Details as better-supabase sends them. */
-declare const PROBLEM_SCHEMA: Json;
-/**
- * An OpenAPI 3.1 document for REST resources over your tables, with schemas
- * from the generated metadata, list-query parameters, Supabase security
- * schemes and Problem Details errors.
- *
- * ```ts
- * const doc = createOpenApi(betterSupabase, {
- *   info: { title: 'CRM API', version: '1.0.0' },
- *   resources: { customers: { list: customerList }, notes: { operations: ['list', 'get'] } },
- * });
- * ```
- */
-declare function createOpenApi(betterSupabase: {
-  readonly meta: SchemaMeta;
-}, options: OpenApiOptions): OpenApiDocument;
-//#endregion
-export { ResourceOptions as a, ResourceOperation as i, OpenApiOptions as n, createOpenApi as o, PROBLEM_SCHEMA as r, OpenApiDocument as t };

package/dist/index-CLg87OBW.d.ts

@@ -1,76 +0,0 @@
-import { StandardSchemaV1 } from "@standard-schema/spec";
-import { SupabaseEnv } from "@supabase/server";
-//#region src/env/index.d.ts
-/** Validated Supabase settings. Only `publicEnv()` of it is safe to ship to a browser. */
-interface BetterSupabaseEnv {
-  readonly url: string;
-  readonly publishableKey: string;
-  readonly secretKey?: string;
-  /** Named secret keys from `SUPABASE_SECRET_KEYS`, including `default` when `secretKey` is set. */
-  readonly secretKeys?: Readonly<Record<string, string>>;
-  /** `SUPABASE_JWKS_URL`, or `<url>/auth/v1/.well-known/jwks.json`. */
-  readonly jwksUrl: URL;
-  /** `SUPABASE_JWKS`: inline keys, used instead of fetching `jwksUrl`. */
-  readonly jwks?: InlineJwks;
-  /** Direct Postgres connection string (`SUPABASE_DB_URL` / `DATABASE_URL`). */
-  readonly dbUrl?: string;
-  /** Project ref for hosted projects (`<ref>.supabase.co`). */
-  readonly projectRef?: string;
-  /** `SUPABASE_READ_URL`: a read replica or the `<ref>-all` load balancer, for reads. */
-  readonly readUrl?: string;
-}
-/** A JSON Web Key Set, as `@supabase/server` verifies with it. */
-type InlineJwks = Exclude<SupabaseEnv["jwks"], URL | null>;
-interface PublicEnv {
-  readonly url: string;
-  readonly publishableKey: string;
-}
-type EnvSource = Readonly<Record<string, string | undefined>>;
-interface EnvIssue {
-  /** The variable names that were checked, first one preferred. */
-  readonly variables: readonly string[];
-  readonly message: string;
-}
-interface EnvOptions {
-  /** Settings that must be present. `url` and `publishableKey` always are. */
-  readonly require?: readonly ("secretKey" | "dbUrl")[];
-}
-type EnvResult = {
-  readonly ok: true;
-  readonly env: BetterSupabaseEnv;
-  readonly issues?: undefined;
-} | {
-  readonly ok: false;
-  readonly env?: undefined;
-  readonly issues: readonly EnvIssue[];
-};
-declare const ENV_VARIABLES: {
-  readonly url: readonly string[];
-  readonly publishableKey: readonly string[];
-  readonly secretKey: readonly string[];
-  readonly dbUrl: readonly string[];
-  readonly jwksUrl: readonly string[];
-  readonly jwks: readonly string[];
-  readonly readUrl: readonly string[];
-};
-declare class EnvValidationError extends Error {
-  override readonly name = "EnvValidationError";
-  readonly issues: readonly EnvIssue[];
-  constructor(issues: readonly EnvIssue[]);
-}
-/**
- * Reads and validates Supabase settings. Accepts the `SUPABASE_`,
- * `NEXT_PUBLIC_`, `VITE_`, `PUBLIC_`, `EXPO_PUBLIC_` and `NUXT_PUBLIC_`
- * spellings. Issues name variables, never values.
- */
-declare function parseEnv(source: EnvSource, options?: EnvOptions): EnvResult;
-/** Like `parseEnv`, but throws `EnvValidationError`. Reads `process.env` by default. */
-declare function loadEnv(source?: EnvSource, options?: EnvOptions): BetterSupabaseEnv;
-/** The env validator as a Standard Schema, for t3-env, framework config or any validator slot. */
-declare function envSchema(options?: EnvOptions): StandardSchemaV1<EnvSource, BetterSupabaseEnv>;
-/** The parts that are safe in client bundles. */
-declare function publicEnv(env: BetterSupabaseEnv): PublicEnv;
-/** Converts to `@supabase/server`'s `SupabaseEnv` (the `env` option of `withSupabase`). */
-declare function toServerEnv(env: BetterSupabaseEnv): SupabaseEnv;
-//#endregion
-export { EnvResult as a, InlineJwks as c, loadEnv as d, parseEnv as f, EnvOptions as i, PublicEnv as l, toServerEnv as m, ENV_VARIABLES as n, EnvSource as o, publicEnv as p, EnvIssue as r, EnvValidationError as s, BetterSupabaseEnv as t, envSchema as u };

package/dist/index-CaxrMD1A.d.ts

@@ -1 +0,0 @@
-export {}

package/dist/index-CdZKQF98.d.ts

@@ -1,138 +0,0 @@
-import { n as RouteGuardOptions } from "./refusal-DhSU2Vvr.js";
-import { t as Validated } from "./shared-DDSjEGDR.js";
-import { AnyEntry, Contributions } from "@supabase/middleware";
-import { IncomingMessage, ServerResponse } from "node:http";
-//#region src/node/http.d.ts
-interface WebRequestOptions {
-  /**
-   * Read the protocol and host from `x-forwarded-proto` and
-   * `x-forwarded-host`. Turn it on behind a proxy you control. Defaults to false.
-   */
-  readonly trustProxy?: boolean;
-  /** Stream the request body into the `Request`. Defaults to true. */
-  readonly body?: boolean;
-}
-/**
- * A Node `IncomingMessage` as a Web `Request`. Express, Fastify and Koa
- * pass theirs (`req`, `request.raw`, `ctx.req`). With `body: false` the
- * stream stays unread, for middleware that runs before a body parser.
- */
-declare function toWebRequest(req: IncomingMessage, options?: WebRequestOptions): Request;
-/** Writes a Web `Response` to a Node `ServerResponse`, streaming the body. */
-declare function sendWebResponse(res: ServerResponse, response: Response): Promise<void>;
-//#endregion
-//#region src/node/index.d.ts
-interface ToNodeOptions<Req = IncomingMessage> extends Omit<WebRequestOptions, "body"> {
-  /** The host's env object for `getEnv`; defaults to `process.env` through `getEnv`. */
-  readonly env?: (req: Req) => unknown;
-}
-/**
- * A `node:http` request listener running the entries around `handler`.
- * Response-phase entries see the handler's response, so refreshed cookies
- * and `withDbStats` totals reach the client.
- *
- * ```ts
- * createServer(toNodeHandler([withBetterSupabase(server)], (request, { db }) => db.notes.findMany()))
- * ```
- */
-declare function toNodeHandler<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, handler: (request: Request, contributions: Contributions<Entries>) => unknown, options?: ToNodeOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-/** The part of an Express response the middleware writes. */
-interface ExpressResponse extends ServerResponse {
-  /** Express's per-request locals; the contributions land here. */
-  locals: Record<string, unknown>;
-}
-/** Express (or Connect) middleware, typed structurally. */
-type ExpressMiddleware = (req: IncomingMessage, res: ExpressResponse, next: (error?: unknown) => void) => void;
-/** An Express error handler, typed structurally. */
-type ExpressErrorHandler = (error: unknown, req: IncomingMessage, res: ExpressResponse, next: (error?: unknown) => void) => void;
-/**
- * Express middleware that puts every contribution on `res.locals`
- * (`res.locals.db`, `res.locals.bs`). Mount it before the routes.
- *
- * ```ts
- * app.use(toExpress([withBetterSupabase(server)]))
- * app.get('/notes', async (req, res) => res.json(await res.locals.db.notes.findMany().orThrow()))
- * ```
- */
-declare function toExpress<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, options?: ToNodeOptions): ExpressMiddleware;
-/**
- * Express route middleware that refuses callers outside `options`:
- * Problem Details, or a redirect to `signIn` or `mfa`. Runs after `toExpress`.
- *
- * ```ts
- * app.get('/admin', guard({ roles: ['admin'] }), handler)
- * ```
- */
-declare function guard(options?: RouteGuardOptions): ExpressMiddleware;
-/**
- * An Express error handler that answers thrown `DbException`s (from
- * `.orThrow()`) with Problem Details and passes every other error on.
- * Register it after the routes.
- */
-declare function problemErrorHandler(options?: {
-  readonly expose?: boolean;
-}): ExpressErrorHandler;
-/** The part of a Fastify request the hook reads and writes. */
-interface FastifyRequestLike {
-  readonly raw: IncomingMessage;
-  /** The contributions land here: `request.locals.db`. */
-  locals?: Record<string, unknown>;
-}
-/** The part of a Fastify reply the hook writes. */
-interface FastifyReplyLike {
-  readonly raw: ServerResponse;
-  readonly sent: boolean;
-  code(status: number): FastifyReplyLike;
-  header(name: string, value: string | readonly string[]): FastifyReplyLike;
-  getHeader(name: string): number | string | string[] | undefined;
-  send(payload?: unknown): FastifyReplyLike;
-}
-/** A Fastify `onRequest` or `preHandler` hook, typed structurally. */
-type FastifyHook = (request: FastifyRequestLike, reply: FastifyReplyLike) => Promise<void>;
-/**
- * A Fastify `onRequest` hook that puts every contribution on
- * `request.locals`. Declare `locals` with `app.decorateRequest('locals', null)`.
- *
- * ```ts
- * app.decorateRequest('locals', null)
- * app.addHook('onRequest', toFastify([withBetterSupabase(server)]))
- * app.get('/notes', (request) => request.locals.db.notes.findMany().orThrow())
- * ```
- */
-declare function toFastify<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, options?: ToNodeOptions<FastifyRequestLike>): FastifyHook;
-/**
- * A Fastify `preHandler` hook that refuses callers outside `options`. Runs
- * after `toFastify`.
- */
-declare function fastifyGuard(options?: RouteGuardOptions): FastifyHook;
-/** The part of a Koa context the middleware reads and writes. */
-interface KoaContextLike {
-  readonly req: IncomingMessage;
-  readonly res: ServerResponse;
-  /** Koa's per-request state; the contributions land here. */
-  state: Record<string, unknown>;
-  status: number;
-  body: unknown;
-  set(name: string, value: string | readonly string[]): void;
-  get response(): {
-    get(name: string): string | string[] | undefined;
-  };
-}
-/** Koa middleware, typed structurally. */
-type KoaMiddleware = (ctx: KoaContextLike, next: () => Promise<unknown>) => Promise<void>;
-/**
- * Koa middleware that puts every contribution on `ctx.state`, then awaits
- * the rest of the chain. Thrown `DbException`s become Problem Details.
- *
- * ```ts
- * app.use(toKoa([withBetterSupabase(server)]))
- * app.use(async (ctx) => { ctx.body = await ctx.state.db.notes.findMany().orThrow() })
- * ```
- */
-declare function toKoa<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, options?: ToNodeOptions<KoaContextLike> & {
-  readonly expose?: boolean;
-}): KoaMiddleware;
-/** Koa middleware that refuses callers outside `options`. Runs after `toKoa`. */
-declare function koaGuard(options?: RouteGuardOptions): KoaMiddleware;
-//#endregion
-export { toNodeHandler as _, FastifyReplyLike as a, toWebRequest as b, KoaMiddleware as c, guard as d, koaGuard as f, toKoa as g, toFastify as h, FastifyHook as i, ToNodeOptions as l, toExpress as m, ExpressMiddleware as n, FastifyRequestLike as o, problemErrorHandler as p, ExpressResponse as r, KoaContextLike as s, ExpressErrorHandler as t, fastifyGuard as u, WebRequestOptions as v, sendWebResponse as y };