better-supabase 0.8.0 → 0.10.0

package/dist/index-R274XFlg.d.ts

@@ -1,138 +0,0 @@
-import { n as RouteGuardOptions } from "./refusal-CFI8-5nf.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 };

package/dist/index-_4R4b01v.d.ts

@@ -1,257 +0,0 @@
-import { b as DbError, f as Result, t as AsyncResult } from "./result-BchM1XZn.js";
-import { H as UploadOptions, J as TemplateValues, U as UrlOptions, V as UploadBody } from "./storage-api-CB7Zl1Ci.js";
-import { at as QuerySpec } from "./define-DmcfoNXB.js";
-import { t as AuthSnapshot } from "./bind-CQ5mPyX1.js";
-import { t as AuthSession } from "./view-TpXEUcVN.js";
-import { S as Topic, _ as RealtimeClient, f as PresenceMember, g as PresenceSubscription, p as PresenceOptions, r as LiveCountSeed, u as EventSchemas, w as TopicHandlers, x as SubscriptionStatus, y as SubscribeOptions } from "./index-BCHR4Ucl.js";
-import { a as BroadcastOptions, c as LiveCountHookOptions, m as UseActionOptions, n as ActionInputOf, o as ClaimsOf, p as ProfileOf, r as ActionResultOf, s as ClientLike, u as LiveQueryHookOptions } from "./field-errors-DIe9XYWL.js";
-import { SupabaseClient } from "@supabase/supabase-js";
-import { ReactNode, SubmitEvent } from "react";
-import { QueryClient } from "@tanstack/query-core";
-//#region src/react/hooks.d.ts
-interface BetterSupabaseProviderProps {
-  readonly client: ClientLike;
-  /** better-supabase queries are removed when the user signs out or changes. */
-  readonly queryClient?: QueryClient;
-  readonly children?: ReactNode;
-}
-/** Provides the better-supabase client to the hooks. */
-declare function BetterSupabaseProvider(props: BetterSupabaseProviderProps): ReactNode;
-/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
-declare function useAuth(): AuthSnapshot;
-declare function useSupabase(): SupabaseClient;
-interface BetterHooks<B extends ClientLike> {
-  /** Repositories bound to the current session. Re-renders when the user changes. */
-  readonly useDb: () => B["db"];
-  /** TanStack Query option factories: `useQuery(useQueries().customers.findMany())`. */
-  readonly useQueries: () => B["queries"];
-  readonly useSupabase: () => SupabaseClient;
-  readonly useAuth: () => AuthSnapshot;
-  /** `useSession()` typed by the client's `betterSupabase.claims(schema)` and `betterSupabase.userMetadata(schema)`. */
-  readonly useSession: () => AuthSession<ClaimsOf<B>, ProfileOf<B>>;
-}
-/**
- * Hooks typed for your schema.
- *
- * ```ts
- * export const { useDb, useQueries, useAuth } = createHooks<typeof bs>();
- * ```
- */
-declare function createHooks<B extends ClientLike>(): BetterHooks<B>;
-/**
- * Subscribes to a topic while mounted. Pass `null` values to pause. It
- * resubscribes when the topic or the signed-in user changes.
- *
- * ```ts
- * useBroadcast(customersTopic, organizationId ? { organizationId } : null, {}, { invalidate: ['customers'] });
- * ```
- */
-declare function useBroadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: TemplateValues<P> | null | undefined, handlers?: TopicHandlers<E>, options?: BroadcastOptions): SubscriptionStatus;
-/**
- * Keeps a query fresh: invalidates every cached query that read a table the
- * spec touches whenever one of them changes. Pass `null` to pause. It
- * resubscribes when the spec, tenant or user changes.
- *
- * ```ts
- * const spec = betterSupabase.spec.customers.findMany({ include: { notes: true } });
- * const { data } = useQuery(q.$spec(spec));
- * useLiveQuery(spec);
- * ```
- */
-declare function useLiveQuery(spec: QuerySpec | null | undefined, options?: LiveQueryHookOptions): SubscriptionStatus;
-interface LiveCount {
-  /** `undefined` until the first count arrives. */
-  readonly count: number | undefined;
-  readonly status: SubscriptionStatus;
-  /** The last failed refetch; the previous count stays. */
-  readonly error: DbError | undefined;
-}
-/**
- * A count that stays current: refetches only the `count` spec (a HEAD
- * request) after each debounced change to a table it reads, and after the
- * channel rejoins. Takes a spec or a `bs.liveCount()` seed; pass `null` to
- * pause. Doesn't need a `QueryClient`.
- *
- * ```tsx
- * const { count } = useLiveCount(seed); // seed = await bs.liveCount(spec)
- * ```
- */
-declare function useLiveCount(source: QuerySpec<string, "count", number> | LiveCountSeed | null | undefined, options?: LiveCountHookOptions): LiveCount;
-//#endregion
-//#region src/react/actions.d.ts
-interface ActionHandle<I, T> {
-  /** Runs the action in a transition; resolves with its result. */
-  run(input: I): Promise<ActionResultOf<T>>;
-  /** True while a run is in flight, including the router update it causes. */
-  readonly pending: boolean;
-  /** The inputs of the runs in flight, e.g. to dim one table row. */
-  readonly pendingInputs: readonly I[];
-  /** The input of the latest run in flight. */
-  readonly pendingInput: I | undefined;
-  /** The data of the last successful run. */
-  readonly data: T | undefined;
-  /** The error of the last run, until the next one starts. */
-  readonly error: DbError | undefined;
-  reset(): void;
-}
-/**
- * Calls a Server Action from an event handler: tracks pending inputs and the
- * last result, and calls `onSuccess` or `onError`.
- *
- * ```tsx
- * const remove = useAction(removeMember, { onError: (e) => toast.error(message(e)) });
- * <Button disabled={remove.pendingInputs.some((p) => p.userId === id)} onClick={() => remove.run({ userId: id })} />
- * ```
- */
-declare function useAction<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
-interface UseActionFormOptions<T> {
-  readonly onSuccess?: (data: T, form: HTMLFormElement) => void;
-  readonly onError?: (error: DbError, form: HTMLFormElement) => void;
-  /** Clear the fields after a successful run. Defaults to true. */
-  readonly resetOnSuccess?: boolean;
-}
-interface ActionForm<T> {
-  /** Spread on the `<form>`. */
-  readonly formProps: {
-    readonly onSubmit: (event: SubmitEvent<HTMLFormElement>) => void;
-  };
-  readonly pending: boolean;
-  readonly data: T | undefined;
-  readonly error: DbError | undefined;
-  /** The first message per top-level field of a `validation` error. */
-  readonly fieldErrors: Readonly<Partial<Record<string, string>>>;
-  reset(): void;
-}
-/**
- * A `<form>` that submits `FormData` to a Server Action. Fields keep what
- * the user typed when the action fails (a `<form action>` resets them) and
- * clear only on success.
- *
- * ```tsx
- * const form = useActionForm(createCustomer, { onSuccess: () => toast.success('Saved') });
- * <form {...form.formProps}>
- *   <Input name="name" aria-invalid={form.fieldErrors.name !== undefined} />
- * </form>
- * ```
- */
-declare function useActionForm<T>(action: (input: FormData) => Promise<ActionResultOf<T>>, options?: UseActionFormOptions<T>): ActionForm<T>;
-//#endregion
-//#region src/react/presence.d.ts
-interface PresenceHookOptions<I> {
-  /**
-   * The state this client shares while mounted. It is tracked after the
-   * join and tracked again when its JSON changes; `null` stays untracked.
-   */
-  readonly state?: I | null;
-  /** A supabase-js client for apps without `<BetterSupabaseProvider>`. */
-  readonly client?: SupabaseClient;
-}
-interface Presence<I, O> {
-  /** Everyone on the topic, this client included, from the last sync. */
-  readonly members: readonly PresenceMember<O>[];
-  readonly status: SubscriptionStatus;
-  /** Shares a state now; the `state` option tracks one for you. */
-  readonly track: (state: I) => Promise<DbError | undefined>;
-  readonly untrack: () => Promise<DbError | undefined>;
-}
-/** The parts of a `defineTopic(..., { presence })` topic the hook uses. */
-interface PresenceTopic<P extends string, I, O> {
-  topic(values: TemplateValues<P>): string;
-  match(topic: string): TemplateValues<P> | null;
-  subscribe(client: RealtimeClient, values: TemplateValues<P>, handlers: Readonly<Record<string, never>>, options?: SubscribeOptions & PresenceOptions<O>): PresenceSubscription<I, O>;
-}
-/**
- * Joins a presence topic while mounted and returns who is on it. Pass
- * `null` values to pause. It rejoins when the topic or the user changes.
- *
- * ```tsx
- * const { members } = usePresence(roomTopic, { roomId }, { state: { name } });
- * ```
- */
-declare function usePresence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: TemplateValues<P> | null | undefined, options?: PresenceHookOptions<I>): Presence<I, O>;
-//#endregion
-//#region src/react/search.d.ts
-interface DebouncedSearchOptions {
-  /** Defaults to 250 ms. */
-  readonly delayMs?: number;
-  /** Shorter terms count as no search. Defaults to 1. */
-  readonly minLength?: number;
-}
-interface DebouncedSearch {
-  /** What the input shows; updates on every keystroke. */
-  readonly value: string;
-  readonly setValue: (value: string) => void;
-  /** The trimmed value once typing pauses, or `undefined` below `minLength`. */
-  readonly term: string | undefined;
-  /** `term` with `%` and `_` escaped and wrapped in `%`, for `like` and `ilike`. */
-  readonly pattern: string | undefined;
-  /** `value` changed and `term` hasn't caught up yet. */
-  readonly pending: boolean;
-}
-/**
- * A search box's value, debounced. Pass `term` to `contains` (which
- * escapes it) or `pattern` to `ilike`; both are `undefined` while empty.
- *
- * ```tsx
- * const search = useDebouncedSearch();
- * useQuery(q.customers.findMany({ where: search.term ? { name: { contains: search.term } } : {} }));
- * ```
- */
-declare function useDebouncedSearch(initial?: string, options?: DebouncedSearchOptions): DebouncedSearch;
-//#endregion
-//#region src/react/storage.d.ts
-/** The part of a connected bucket `useSignedUrl` calls. */
-interface SignedUrlSource<T> {
-  signedUrl(target: T, options?: UrlOptions): AsyncResult<string>;
-}
-interface SignedUrl {
-  /** `undefined` until the first URL arrives, and while paused. */
-  readonly url: string | undefined;
-  readonly error: DbError | undefined;
-  readonly loading: boolean;
-}
-/**
- * A signed URL for an object, signed again before it expires. Pass `null`
- * as the target to pause. Connect the bucket with `cacheSignedUrls: true`
- * so components showing the same object share one URL.
- *
- * ```tsx
- * const { url } = useSignedUrl(avatars, user ? { userId: user.id } : null, { ttl: 'hour' });
- * ```
- */
-declare function useSignedUrl<T>(bucket: SignedUrlSource<T>, target: T | null | undefined, options?: UrlOptions): SignedUrl;
-/** The part of a connected bucket `useUpload` calls. */
-interface UploadTarget<T, R> {
-  upload(target: T, body: UploadBody, options?: UploadOptions): AsyncResult<R>;
-}
-type UploadStatus = "idle" | "uploading" | "done" | "error";
-interface Upload<T, R> {
-  readonly status: UploadStatus;
-  /** 0 to 1 while uploading; see `UploadOptions.onProgress` for when it is exact. */
-  readonly progress: number;
-  readonly data: R | undefined;
-  readonly error: DbError | undefined;
-  /** Starts an upload; a new one aborts the one in flight. */
-  readonly upload: (target: T, body: UploadBody, options?: Omit<UploadOptions, "signal" | "onProgress">) => Promise<Result<R>>;
-  /** Cancels the upload in flight. */
-  readonly abort: () => void;
-  /** Back to `idle`. */
-  readonly reset: () => void;
-}
-interface UseUploadOptions<R> {
-  readonly onSuccess?: (data: R) => void;
-  readonly onError?: (error: DbError) => void;
-}
-/**
- * Uploads to a connected bucket with progress, abort and status state.
- * Unmounting aborts the upload in flight.
- *
- * ```tsx
- * const avatar = useUpload(avatars, { onSuccess: ({ path }) => save(path) });
- * <input type="file" onChange={(e) => avatar.upload({ userId }, e.target.files[0], { upsert: true })} />
- * <progress value={avatar.progress} />
- * ```
- */
-declare function useUpload<T, R>(bucket: UploadTarget<T, R>, options?: UseUploadOptions<R>): Upload<T, R>;
-//#endregion
-export { useSupabase as A, BetterSupabaseProviderProps as C, useBroadcast as D, useAuth as E, useLiveCount as O, BetterSupabaseProvider as S, createHooks as T, ActionHandle as _, UploadTarget as a, useActionForm as b, useUpload as c, useDebouncedSearch as d, Presence as f, ActionForm as g, usePresence as h, UploadStatus as i, useLiveQuery as k, DebouncedSearch as l, PresenceTopic as m, SignedUrlSource as n, UseUploadOptions as o, PresenceHookOptions as p, Upload as r, useSignedUrl as s, SignedUrl as t, DebouncedSearchOptions as u, UseActionFormOptions as v, LiveCount as w, BetterHooks as x, useAction as y };