better-supabase 0.8.0 → 0.10.0

package/dist/index-Cckxs8IE.d.ts

@@ -0,0 +1,206 @@
+import { n as DbException } from "./escape-like-AUEPn-C5.js";
+import { E as PrimaryKeyValue, U as UniqueWhere, W as Update, a as AnyModels, i as AnyFunctions, x as Insert, z as TableKey } from "./types-BO8lVTun.js";
+import { B as UpsertArgs, Bt as WhereInput, Ct as FindOnlyArgs, D as OffsetRangeArgs, E as OffsetPageArgs, H as WriteArgs, I as Returned, Nt as Payload, Pt as ReadArgs, St as FindManyArgs, T as OffsetPage, _ as Db, at as QuerySpec, b as DeleteExt, dt as AggregateArgs, g as CursorPageArgs, h as CursorPage, it as InferResult, mt as AggregateResult, s as CacheAdapter, t as BetterSupabase, x as FindExt, xt as FindFirstArgs, y as DeleteArgs, yt as CountArgs, z as UpdateArgs } from "./define-DXTC706J.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-Ck4oK5vV.d.ts

@@ -0,0 +1,258 @@
+import { b as DbError, f as Result, t as AsyncResult } from "./result-Cj3yWhjH.js";
+import { H as UploadOptions, J as TemplateValues, U as UrlOptions, V as UploadBody } from "./storage-api-B4Ib2Zpo.js";
+import { at as QuerySpec } from "./define-DXTC706J.js";
+import { c as RealtimeClient, d as SubscribeOptions, g as TopicHandlers, i as PresenceOptions, m as Topic, p as SubscriptionStatus, r as PresenceMember, s as PresenceSubscription, t as EventSchemas } from "./topic-Dgs-eSYQ.js";
+import { t as AuthSnapshot } from "./bind-DkaP_0iS.js";
+import { t as AuthSession } from "./view-SuASaomx.js";
+import { r as LiveCountSeed } from "./index-DcijDfh1.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-nFnYWvB0.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 };

package/dist/index-Co0YsJTk.d.ts

@@ -0,0 +1,58 @@
+import { c as SpecDiagnostic, r as DocumentFormat } from "./format-CNwSjXUU.js";
+import { r as ResourceDescription } from "./resource-DxcgtHq6.js";
+import { C as ApiSource, _ as OpenApiDocuments, b as OpenApiVersion, l as AnyOpenApiDocument, n as DefineApiOptions, x as RenderedOpenApi } from "./api-XJcQON_7.js";
+//#region src/openapi/format.d.ts
+/**
+ * OpenAPI as a `DocumentFormat`. 3.1 is the default; 3.0 is legacy (schemas
+ * lowered to the 3.0 Schema Object); 3.2 has native `$self`, nested tags,
+ * `itemSchema`, `oauth2MetadataUrl` and `query`; `3.3-preview` follows the
+ * v3.3-dev branch at `SPEC_PINS.openapi33Preview`, with Path Item
+ * `security` and the Security Profiles proposal. Below 3.2, the 3.2 fields
+ * travel as the registered `x-oai-*` extensions where one exists, and as
+ * the model's prefixed extensions otherwise.
+ */
+declare const openapiFormat: DocumentFormat<"openapi", OpenApiVersion, AnyOpenApiDocument, OpenApiDocuments>;
+//#endregion
+//#region src/openapi/schema30.d.ts
+type Json = Record<string, unknown>;
+/**
+ * Rewrites a JSON Schema 2020-12 schema into the OpenAPI 3.0 Schema Object:
+ * `null` in `type` or in an `anyOf`/`oneOf` becomes `nullable`, a type list
+ * becomes `anyOf`, `const` becomes a one-value `enum`, `examples` becomes
+ * `example`, numeric `exclusiveMinimum`/`exclusiveMaximum` become the
+ * boolean form, `contentEncoding: base64` becomes `format: byte`, and a
+ * `$ref` with siblings is wrapped in `allOf`. Keywords 3.0 does not have
+ * are left out. The input is not changed.
+ */
+declare function toOpenApi30Schema(schema: Readonly<Json>): Json;
+//#endregion
+//#region src/openapi/index.d.ts
+/** How one table is published; see `defineApi`'s `resources`. */
+type ResourceOptions<Ref = string> = ResourceDescription<Ref>;
+interface OpenApiOptions<V extends OpenApiVersion = "3.1", Ref = string> extends DefineApiOptions<Ref> {
+  /** Defaults to 3.1. `3.3-preview` follows a draft. */
+  readonly version?: V;
+  /** Last change to the document before overlays; see `RenderOptions.transform`. */
+  readonly transform?: (rendered: Extract<RenderedOpenApi, {
+    readonly version: V;
+  }>) => OpenApiDocuments[OpenApiVersion] | undefined;
+  readonly overlays?: readonly unknown[];
+  /** Hears every warning and info finding. Errors throw. */
+  readonly onDiagnostic?: (diagnostic: SpecDiagnostic) => void;
+}
+/**
+ * An OpenAPI document for REST resources over your tables, with schemas
+ * from the generated metadata, list-query parameters, Supabase security
+ * schemes and Problem Details errors. Throws when building or checking the
+ * document finds an error; use `defineApi` to read every finding instead.
+ *
+ * ```ts
+ * const doc = createOpenApi(betterSupabase, {
+ *   info: { title: "CRM API", version: "1.0.0" },
+ *   resources: { customers: { list: customerList }, notes: { operations: ["list", "get"] } },
+ * });
+ * ```
+ */
+declare function createOpenApi<V extends OpenApiVersion = "3.1", Ref = string>(betterSupabase: ApiSource, options: OpenApiOptions<V, Ref>): OpenApiDocuments[V];
+//#endregion
+export { openapiFormat as a, toOpenApi30Schema as i, ResourceOptions as n, createOpenApi as r, OpenApiOptions as t };

package/dist/index-CxmVzT-3.d.ts

@@ -0,0 +1,86 @@
+import { SupabaseEnv } from "@supabase/server";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#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;
+  /**
+   * Postgres connection string: `SUPABASE_DB_URL`, `DATABASE_URL`, then
+   * the Vercel integration's `POSTGRES_URL` (pooled) and
+   * `POSTGRES_URL_NON_POOLING`.
+   */
+  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;
+  /**
+   * `SUPABASE_JWT_SECRET`: the shared HS256 secret Supabase Lite signs user
+   * tokens with (`auth.jwt_secret`). Server-only; read with `backend: "lite"`.
+   */
+  readonly jwtSecret?: 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[];
+  readonly jwtSecret: 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 };