better-supabase 0.8.0 → 0.10.0

package/dist/respond-Cw-zanCm.d.ts

@@ -1,93 +0,0 @@
-import { b as DbError } from "./result-BchM1XZn.js";
-import { r as AuthState } from "./resolve-MxXVWyhd.js";
-import { t as Aal } from "./mfa-SZc9YYyb.js";
-//#region src/server/refresh.d.ts
-/** A router or browser prefetch, by its request headers. */
-declare function isPrefetch(request: Request): boolean;
-/**
- * Whether a request should refresh an expired session cookie: page loads,
- * client navigations (`rsc`, `x-sveltekit-*`, `_data` loaders), form posts
- * and Server Actions. Prefetches, assets and `fetch` calls from scripts
- * read the session as it is, so a burst of parallel requests never races
- * on the single-use refresh token.
- */
-declare function shouldRefresh(request: Request): boolean;
-/**
- * Whether a request should ask the Auth server if the session still exists
- * (`checkSession`): full page loads, and `paths` you list for client
- * navigations. Never prefetches or mutations.
- */
-declare function shouldCheckSession(request: Request, paths?: readonly string[]): boolean;
-/** When a session entry refreshes: always, never, on navigations, or a predicate. */
-type RefreshPolicy = boolean | "navigation" | ((request: Request) => boolean);
-/** `policy` for one request. */
-declare function refreshFor(policy: RefreshPolicy | undefined, request: Request): boolean | undefined;
-//#endregion
-//#region src/server/respond.d.ts
-type AuthKind = AuthState["kind"];
-/**
- * An auth kind a guard lets through. `anonymous` admits users signed in with
- * `signInAnonymously()` (`is_anonymous`); `anon` admits callers without a
- * session only.
- */
-type AllowedCaller = Exclude<AuthKind, "invalid"> | "anonymous";
-interface GuardOptions {
-  /**
-   * Callers allowed through. Defaults to `['user']`, which refuses anonymous
-   * sign-ins. Only `'anonymous'` admits them: `['anonymous']` alone admits
-   * anonymous sign-ins and refuses other users, and `'anon'` (no session)
-   * never admits them.
-   */
-  readonly allow?: readonly AllowedCaller[];
-  /**
-   * Assurance level user sessions need. `aal2` answers 403 with
-   * `required: 'aal2'` until the user verifies a second factor.
-   */
-  readonly aal?: Aal;
-  /**
-   * OAuth scopes a delegated token (an OAuth client or an `act` chain) or an
-   * API key needs. A missing one answers 403 with `error="insufficient_scope"`.
-   * The user's own session is not limited by scopes.
-   */
-  readonly scopes?: readonly string[];
-}
-/** Guard options for middleware and fetch handlers that resolve the caller themselves. */
-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.
-   * `'navigation'` refreshes page loads and form posts only (`shouldRefresh`).
-   */
-  readonly refresh?: RefreshPolicy;
-}
-/** `undefined` when `auth` may pass; otherwise the 401/403 error to send. */
-declare function guard(auth: AuthState, allow?: GuardOptions["allow"], aal?: Aal, scopes?: readonly string[]): DbError | undefined;
-declare function isResult(value: unknown): value is {
-  ok: boolean;
-  data: unknown;
-  error: unknown;
-};
-type Settled = {
-  readonly ok: true;
-  readonly data: unknown;
-} | {
-  readonly ok: false;
-  readonly error: DbError;
-};
-/**
- * Settles a handler's return value: `Result`s and `AsyncResult`s unwrap,
- * thrown `DbException`s (or errors whose `cause` is a `DbError`) become
- * errors, anything else is data. Other thrown
- * errors propagate.
- */
-declare function settle(run: () => unknown): Promise<Settled>;
-interface RespondOptions {
-  readonly instance?: string;
-  readonly expose?: boolean;
-  /** Status for data responses. Defaults to 200 (204 without data). */
-  readonly status?: number;
-}
-/** A handler's value as a response: `Response` as is, data as JSON, errors as Problem Details. */
-declare function respond(run: () => unknown, options?: RespondOptions): Promise<Response>;
-//#endregion
-export { RespondOptions as a, isResult as c, RefreshPolicy as d, isPrefetch as f, shouldRefresh as h, MiddlewareOptions as i, respond as l, shouldCheckSession as m, AuthKind as n, Settled as o, refreshFor as p, GuardOptions as r, guard as s, AllowedCaller as t, settle as u };

package/dist/respond-volM3ByS.js

@@ -1,91 +0,0 @@
-import { n as dbError, o as isDbError, r as dbErrorOf } from "./errors-2M6CKMP4.js";
-import { s as toDbError } from "./result-DEqHCMKP.js";
-import { o as problemResponse } from "./problem-CJvFeGu7.js";
-import { a as actorOf, o as delegationOf } from "./impersonation-DcqaTBHx.js";
-import { a as checkAal, t as isAnonymousUser } from "./view-D5ryq3gz.js";
-import { n as jsonResponse } from "./json-CEnpTHlZ.js";
-//#region src/server/respond.ts
-/**
-* The scopes a delegated user token lacks. Empty for the user's own session,
-* which a support or impersonated session counts as: only an `oauth-client`
-* actor is limited to what the user delegated.
-*/
-function missingScopes(auth, required) {
-	if (required.length === 0) return [];
-	const outcome = actorOf(auth.claims);
-	if (!outcome.ok || outcome.actor?.kind !== "oauth-client") return [];
-	const granted = new Set(delegationOf(auth.claims)?.scopes);
-	return required.filter((scope) => !granted.has(scope));
-}
-/** An API key's `*` scope grants every scope. */
-function missingKeyScopes(granted, required) {
-	if (granted.includes("*")) return [];
-	return required.filter((scope) => !granted.includes(scope));
-}
-/** `undefined` when `auth` may pass; otherwise the 401/403 error to send. */
-function guard(auth, allow = ["user"], aal = "aal1", scopes = []) {
-	if (auth.kind === "invalid") return auth.error;
-	const anonymous = auth.kind === "user" && isAnonymousUser(auth.claims);
-	if (anonymous ? allow.includes("anonymous") : allow.includes(auth.kind)) {
-		const denied = checkAal(auth, aal);
-		if (denied) return denied;
-		if (auth.kind !== "user" && auth.kind !== "apiKey") return void 0;
-		const missing = auth.kind === "apiKey" ? missingKeyScopes(auth.scopes, scopes) : missingScopes(auth, scopes);
-		return missing.length > 0 ? dbError("forbidden", `The token lacks the scope ${missing.join(" ")}`, {
-			code: "INSUFFICIENT_SCOPE",
-			scopes
-		}) : void 0;
-	}
-	if (anonymous) return dbError("forbidden", "Sign up to continue", { code: "ANONYMOUS_USER" });
-	return auth.kind === "anon" ? dbError("unauthorized", "Sign in to continue", { code: "MISSING_CREDENTIALS" }) : dbError("forbidden", `A ${auth.kind} caller is not allowed here`);
-}
-function isResult(value) {
-	return typeof value === "object" && value !== null && "ok" in value && "data" in value && "error" in value;
-}
-/**
-* Settles a handler's return value: `Result`s and `AsyncResult`s unwrap,
-* thrown `DbException`s (or errors whose `cause` is a `DbError`) become
-* errors, anything else is data. Other thrown
-* errors propagate.
-*/
-async function settle(run) {
-	try {
-		const value = await run();
-		if (!isResult(value)) return {
-			ok: true,
-			data: value
-		};
-		if (value.ok) return {
-			ok: true,
-			data: value.data
-		};
-		return {
-			ok: false,
-			error: isDbError(value.error) ? value.error : toDbError(value.error)
-		};
-	} catch (cause) {
-		const thrown = dbErrorOf(cause);
-		if (thrown) return {
-			ok: false,
-			error: thrown
-		};
-		throw cause;
-	}
-}
-/** A handler's value as a response: `Response` as is, data as JSON, errors as Problem Details. */
-async function respond(run, options = {}) {
-	const settled = await settle(run);
-	if (!settled.ok) return problemResponse(settled.error, options);
-	if (settled.data instanceof Response) return settled.data;
-	if (settled.data === void 0) return new Response(null, { status: 204 });
-	return jsonResponse(settled.data, { status: options.status ?? 200 });
-}
-/** Prefetching the JWKS would add a network call to every test that builds a server. */
-function defaultPrefetchJwks() {
-	return typeof process === "undefined" || process.env["NODE_ENV"] !== "test";
-}
-function defaultExpose() {
-	return typeof process !== "undefined" && process.env["NODE_ENV"] === "development";
-}
-//#endregion
-export { respond as a, isResult as i, defaultPrefetchJwks as n, settle as o, guard as r, defaultExpose as t };

package/dist/result-BchM1XZn.d.ts

@@ -1,288 +0,0 @@
-//#region src/core/errors.d.ts
-/**
- * Extra fields carried by each error kind. Plugins can add kinds through the
- * `errors` extension point; apps that want the new kinds in the union can add
- * them to this interface.
- */
-interface DbErrorKinds {
-  not_found: Record<never, never>;
-  unauthorized: Record<never, never>;
-  /**
-   * `required`: the assurance level the route needs, when a second factor is
-   * missing. `scopes`: the OAuth scopes the route needs, when a delegated
-   * token lacks one (`INSUFFICIENT_SCOPE`). `permission`: the key an
-   * `Authorizer` denied. `approval`: the pending approval when the answer is
-   * `APPROVAL_REQUIRED`.
-   */
-  forbidden: {
-    required?: "aal1" | "aal2";
-    scopes?: readonly string[];
-    permission?: string;
-    approval?: {
-      readonly id: string;
-    };
-  };
-  conflict: {
-    constraint?: string;
-    columns?: readonly string[];
-  };
-  foreign_key: {
-    constraint?: string;
-    columns?: readonly string[];
-  };
-  check: {
-    constraint?: string;
-  };
-  not_null: {
-    column?: string;
-  };
-  exclusion: {
-    constraint?: string;
-  };
-  invalid_input: Record<never, never>;
-  /** A stored value the app type can't hold, e.g. `infinity` for a Temporal timestamp. */
-  invalid_value: {
-    column?: string;
-  };
-  raised: Record<never, never>;
-  timeout: Record<never, never>;
-  serialization: Record<never, never>;
-  network: Record<never, never>;
-  aborted: Record<never, never>;
-  invalid_request: Record<never, never>;
-  validation: {
-    issues: readonly ValidationIssue[];
-  };
-  multiple_rows: Record<never, never>;
-  stale: Record<never, never>;
-  /**
-   * An `updateMany` or `deleteMany` matched more rows than its `maxAffected`
-   * allows; nothing was written. `maxAffected`: the limit, when known.
-   */
-  max_affected: {
-    maxAffected?: number;
-  };
-  /** `retryAfter`: seconds until the window resets (the `Retry-After` header). */
-  rate_limited: {
-    retryAfter?: number;
-  };
-  /**
-   * A usage quota is used up (`consume_quota`, SQLSTATE `BSQ29`). `meter`:
-   * what was metered, `limit`: the quota, `retryAfter`: seconds until the
-   * period resets.
-   */
-  quota_exceeded: {
-    meter?: string;
-    limit?: number;
-    retryAfter?: number;
-  };
-  /** The executor or its dialect can't run this operation (an include on SQLite, say). */
-  unsupported: Record<never, never>;
-  unexpected: Record<never, never>;
-}
-type DbErrorKind = keyof DbErrorKinds;
-interface ValidationIssue {
-  readonly message: string;
-  readonly path?: readonly PropertyKey[];
-}
-interface DbErrorBase<K extends DbErrorKind> {
-  readonly kind: K;
-  readonly message: string;
-  /** SQLSTATE or PostgREST code (`23505`, `PGRST116`), when known. */
-  readonly code?: string;
-  /** Suggested HTTP status, used by the RFC 9457 mapping. */
-  readonly status: number;
-  readonly details?: string;
-  /** Postgres `HINT`. `raised` errors use it as an app-level error code. */
-  readonly hint?: string;
-  /** App-cased table key the operation ran against. */
-  readonly table?: string;
-}
-/**
- * A database error as plain, serializable data. Safe to send across server
- * action and RPC boundaries.
- */
-type DbError = { [K in DbErrorKind]: DbErrorBase<K> & DbErrorKinds[K]; }[DbErrorKind];
-type DbErrorOf<K extends DbErrorKind> = Extract<DbError, {
-  kind: K;
-}>;
-declare function statusOf(kind: DbErrorKind): number;
-type ExtraOf<K extends DbErrorKind> = Record<never, never> extends DbErrorKinds[K] ? [extra?: DbErrorKinds[K] & Partial<Omit<DbErrorBase<K>, "kind">>] : [extra: DbErrorKinds[K] & Partial<Omit<DbErrorBase<K>, "kind">>];
-/** Creates a `DbError` with the default status for its kind. */
-declare function dbError<K extends DbErrorKind>(kind: K, message: string, ...[extra]: ExtraOf<K>): DbErrorOf<K>;
-declare function isDbError(value: unknown): value is DbError;
-/**
- * A unique violation, optionally for one constraint. Accepts a `DbError` or a
- * `DbException`. Pass the generated `UniqueConstraint` type to check names:
- * `isConflict<UniqueConstraint>(error, 'customers_organization_id_kvk_key')`.
- */
-declare const isConflict: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"conflict"> & {
-  readonly constraint: C;
-};
-/** A CHECK violation, optionally for one constraint (`CheckConstraint`). */
-declare const isCheck: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"check"> & {
-  readonly constraint: C;
-};
-/** A foreign key violation, optionally for one constraint (`ForeignKeyConstraint`). */
-declare const isForeignKey: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"foreign_key"> & {
-  readonly constraint: C;
-};
-/** Raw error shape shared by PostgREST responses and `pg` errors. */
-interface RawDbError {
-  readonly message?: string;
-  readonly code?: string;
-  readonly details?: string | null;
-  readonly hint?: string | null;
-  readonly constraint?: string;
-  readonly column?: string;
-  readonly table?: string;
-  readonly name?: string;
-}
-type ErrorMapper = (raw: RawDbError, fallback: DbError) => DbError | undefined;
-/**
- * Maps a PostgREST or Postgres error to a `DbError`. Custom mappers run
- * first; the first one that returns an error wins.
- */
-declare function mapDbError(raw: RawDbError, mappers?: readonly ErrorMapper[]): DbError;
-//#endregion
-//#region src/core/result.d.ts
-/** Turns a `DbError` into the error `.orThrow()` throws; set with `betterSupabase.mapError()`. */
-type ThrowMapper = (error: DbError) => unknown;
-type Ok<T> = {
-  readonly ok: true;
-  readonly data: T;
-  readonly error: null;
-};
-type Err<E = DbError> = {
-  readonly ok: false;
-  readonly data: null;
-  readonly error: E;
-};
-type Result<T, E = DbError> = Ok<T> | Err<E>;
-declare function ok<T>(data: T): Ok<T>;
-declare function err<E = DbError>(error: E): Err<E>;
-/**
- * A lazy-free `PromiseLike<Result<T>>` with helpers. `await` gives the
- * `Result`; `.orThrow()` gives the data or throws a `DbException`.
- */
-declare class AsyncResult<T> implements PromiseLike<Result<T>> {
-  #private;
-  constructor(promise: Promise<Result<T>>);
-  static from<T>(run: () => Promise<Result<T>>): AsyncResult<T>;
-  static ok<T>(data: T): AsyncResult<T>;
-  static err<T = never>(error: DbError): AsyncResult<T>;
-  then<R1 = Result<T>, R2 = never>(onfulfilled?: ((value: Result<T>) => R1 | PromiseLike<R1>) | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
-  /**
-   * Resolves with the data, or rejects with a `DbException`. Pass `factory`
-   * to throw your own error instead, e.g. an HTTP error for your framework;
-   * without it, the mapper from `betterSupabase.mapError()` applies when one is set.
-   */
-  orThrow(factory?: (error: DbError) => unknown): Promise<T>;
-  /** Resolves with the data, or `fallback` when the result is an error. */
-  unwrapOr<F>(fallback: F): Promise<T | F>;
-  map<U>(fn: (data: T) => U): AsyncResult<U>;
-  mapError(fn: (error: DbError) => DbError): AsyncResult<T>;
-  andThen<U>(fn: (data: T) => PromiseLike<Result<U>>): AsyncResult<U>;
-}
-/** What `toBetterResult` returns: the `status`/`value`/`error` fields every better-result value has. */
-type BetterResultValue<T, E> = {
-  readonly status: "ok";
-  readonly value: T;
-} | {
-  readonly status: "error";
-  readonly error: E;
-};
-/** The part of better-result's `Result` namespace `toBetterResult` calls. */
-interface BetterResultApi<T, E> {
-  ok(value: NoInfer<T>): unknown;
-  err(error: NoInfer<E>): unknown;
-}
-/** The value type of a better-result `Result` type. */
-type BetterResultOk<R> = R extends {
-  readonly status: "ok";
-  readonly value: infer T;
-} ? T : never;
-/** The error type of a better-result `Result` type. */
-type BetterResultErr<R> = R extends {
-  readonly status: "error";
-  readonly error: infer E;
-} ? E : never;
-/**
- * Builds a better-result value with the `Result` namespace you pass, so
- * better-result stays your dependency. Errors go through `mapError`, or, for a
- * result from a `db` of `betterSupabase.mapError(fn)`, through `fn` (typed `unknown`).
- *
- * The value is typed as better-result's `Result<T, E>` when the call has one
- * as its expected type (an annotation or a function's return type) or as its
- * type argument. That type is checked against the row type and `mapError`.
- * Without one, it is a `BetterResultValue<T, E>`.
- *
- * ```ts
- * import { Result } from 'better-result';
- * const customer: Result<Customer, AppError> = toBetterResult(
- *   await db.customers.findById(id),
- *   Result,
- *   toAppError,
- * );
- * ```
- */
-declare function toBetterResult<R extends BetterResultValue<unknown, unknown> = never>(result: Result<BetterResultOk<R>>, api: BetterResultApi<BetterResultOk<R>, BetterResultErr<R>>, mapError: (error: DbError) => BetterResultErr<R>): R;
-declare function toBetterResult<R extends BetterResultValue<unknown, unknown> = never>(result: Result<BetterResultOk<R>> & (DbError extends BetterResultErr<R> ? unknown : never), api: BetterResultApi<BetterResultOk<R>, DbError>): R;
-declare function toBetterResult<R extends BetterResultValue<unknown, unknown> = never>(result: AsyncResult<BetterResultOk<R>>, api: BetterResultApi<BetterResultOk<R>, BetterResultErr<R>>, mapError: (error: DbError) => BetterResultErr<R>): Promise<R>;
-declare function toBetterResult<R extends BetterResultValue<unknown, unknown> = never>(result: AsyncResult<BetterResultOk<R>> & (unknown extends BetterResultErr<R> ? unknown : never), api: BetterResultApi<BetterResultOk<R>, unknown>): Promise<R>;
-declare function toBetterResult<T, E>(result: Result<T>, api: BetterResultApi<T, E>, mapError: (error: DbError) => E): BetterResultValue<T, E>;
-declare function toBetterResult<T>(result: Result<T>, api: BetterResultApi<T, DbError>): BetterResultValue<T, DbError>;
-declare function toBetterResult<T, E>(result: AsyncResult<T>, api: BetterResultApi<T, E>, mapError: (error: DbError) => E): Promise<BetterResultValue<T, E>>;
-declare function toBetterResult<T>(result: AsyncResult<T>, api: BetterResultApi<T, unknown>): Promise<BetterResultValue<T, unknown>>;
-/**
- * An error class for one `DbError` kind. better-result's
- * `class NotFound extends TaggedError("NotFound")<{ message: string; error: DbError }> {}`
- * fits, as does any class whose constructor takes `{ message, error }`.
- */
-type DbErrorClass<K extends DbErrorKind = DbErrorKind> = new (props: {
-  readonly message: string;
-  readonly error: DbErrorOf<K>;
-}) => unknown;
-/** Error classes by `DbError` kind; kinds left out use the fallback class. */
-type DbErrorClasses = { readonly [K in DbErrorKind]?: DbErrorClass<K>; };
-/** The error a `DbError` of kind `K` becomes. */
-type MappedDbError<M extends DbErrorClasses, F extends DbErrorClass, K extends DbErrorKind = DbErrorKind> = K extends keyof M ? M[K] extends (abstract new (...args: never[]) => infer I) ? I : F extends (abstract new (...args: never[]) => infer I) ? I : never : F extends (abstract new (...args: never[]) => infer I) ? I : never;
-/**
- * Converts results with a fixed `Result` namespace and error mapping. Like
- * `toBetterResult`, the value is typed as better-result's `Result<T, E>`
- * when the call has one as its expected type, and `E` must accept every
- * error the mapping returns.
- */
-interface BetterResultErrors<M extends DbErrorClasses, F extends DbErrorClass> {
-  <R extends BetterResultValue<unknown, unknown> = never>(result: Result<BetterResultOk<R>> & (MappedDbError<M, F> extends BetterResultErr<R> ? unknown : never)): R;
-  <R extends BetterResultValue<unknown, unknown> = never>(result: AsyncResult<BetterResultOk<R>> & (MappedDbError<M, F> extends BetterResultErr<R> ? unknown : never)): Promise<R>;
-  <T>(result: Result<T>): BetterResultValue<T, MappedDbError<M, F>>;
-  <T>(result: AsyncResult<T>): Promise<BetterResultValue<T, MappedDbError<M, F>>>;
-  /** The error instance for one `DbError`, typed by its kind. */
-  map<E extends DbError>(error: E): MappedDbError<M, F, E["kind"]>;
-}
-/**
- * A typed mapping from `DbError` kinds to error classes, usually
- * better-result `TaggedError` classes, bound to better-result's `Result`
- * namespace. Kinds without a class use `fallback`. Each instance gets the
- * error's `message` and the `DbError` itself as `error`.
- *
- * ```ts
- * import { Result, TaggedError } from 'better-result';
- * class NotFound extends TaggedError('NotFound')<{ message: string; error: DbError }> {}
- * class DbFailure extends TaggedError('DbFailure')<{ message: string; error: DbError }> {}
- * const toResult = defineBetterResultErrors(Result, { not_found: NotFound }, DbFailure);
- * const customer: Result<Customer, NotFound | DbFailure> = await toResult(db.customers.findById(id));
- * ```
- */
-declare function defineBetterResultErrors<const M extends DbErrorClasses, F extends DbErrorClass>(api: BetterResultApi<unknown, unknown>, classes: M, fallback: F): BetterResultErrors<M, F>;
-/**
- * Converts a better-result value back into a `Result`, by its `status`
- * field, so it works across better-result versions. A `DbError`, or an
- * error whose `cause` is one, is kept; others go through `mapError`
- * (default `toDbError`).
- */
-declare function fromBetterResult<T>(result: BetterResultValue<T, unknown>, mapError?: (error: unknown) => DbError): Result<T>;
-declare function toDbError(cause: unknown): DbError;
-//#endregion
-export { isDbError as A, DbErrorOf as C, dbError as D, ValidationIssue as E, mapDbError as M, statusOf as N, isCheck as O, DbErrorKinds as S, RawDbError as T, ok as _, BetterResultOk as a, DbError as b, DbErrorClasses as c, Ok as d, Result as f, fromBetterResult as g, err as h, BetterResultErrors as i, isForeignKey as j, isConflict as k, Err as l, defineBetterResultErrors as m, BetterResultApi as n, BetterResultValue as o, ThrowMapper as p, BetterResultErr as r, DbErrorClass as s, AsyncResult as t, MappedDbError as u, toBetterResult as v, ErrorMapper as w, DbErrorKind as x, toDbError as y };

package/dist/result-DEqHCMKP.js

@@ -1,128 +0,0 @@
-import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { n as dbError, r as dbErrorOf } from "./errors-2M6CKMP4.js";
-//#region src/core/result.ts
-const throwMappers = /* @__PURE__ */ new WeakMap();
-function inherit(from, next) {
-	const mapper = throwMappers.get(from);
-	if (mapper) throwMappers.set(next, mapper);
-	return next;
-}
-/** Marks `result` so its `.orThrow()` throws `mapper(error)`; returns it. */
-function withErrorMapper(result, mapper) {
-	throwMappers.set(result, mapper);
-	return result;
-}
-function ok(data) {
-	return {
-		ok: true,
-		data,
-		error: null
-	};
-}
-function err(error) {
-	return {
-		ok: false,
-		data: null,
-		error
-	};
-}
-/**
-* A lazy-free `PromiseLike<Result<T>>` with helpers. `await` gives the
-* `Result`; `.orThrow()` gives the data or throws a `DbException`.
-*/
-var AsyncResult = class AsyncResult {
-	#promise;
-	constructor(promise) {
-		this.#promise = promise.catch((cause) => err(toDbError(cause)));
-	}
-	static from(run) {
-		return new AsyncResult(Promise.resolve().then(run));
-	}
-	static ok(data) {
-		return new AsyncResult(Promise.resolve(ok(data)));
-	}
-	static err(error) {
-		return new AsyncResult(Promise.resolve(err(error)));
-	}
-	then(onfulfilled, onrejected) {
-		return this.#promise.then(onfulfilled, onrejected);
-	}
-	/**
-	* Resolves with the data, or rejects with a `DbException`. Pass `factory`
-	* to throw your own error instead, e.g. an HTTP error for your framework;
-	* without it, the mapper from `betterSupabase.mapError()` applies when one is set.
-	*/
-	async orThrow(factory) {
-		const result = await this.#promise;
-		if (result.ok) return result.data;
-		const mapper = factory ?? throwMappers.get(this);
-		throw mapper ? mapper(result.error) : new DbException(result.error);
-	}
-	/** Resolves with the data, or `fallback` when the result is an error. */
-	async unwrapOr(fallback) {
-		const result = await this.#promise;
-		return result.ok ? result.data : fallback;
-	}
-	map(fn) {
-		return inherit(this, new AsyncResult(this.#promise.then((result) => result.ok ? ok(fn(result.data)) : result)));
-	}
-	mapError(fn) {
-		return inherit(this, new AsyncResult(this.#promise.then((result) => result.ok ? result : err(fn(result.error)))));
-	}
-	andThen(fn) {
-		return inherit(this, new AsyncResult(this.#promise.then((result) => result.ok ? fn(result.data) : result)));
-	}
-};
-function toBetterResult(result, api, mapError) {
-	const build = (settled, mapper) => settled.ok ? api.ok(settled.data) : api.err(mapper ? mapper(settled.error) : settled.error);
-	if (result instanceof AsyncResult) {
-		const mapper = mapError ?? throwMappers.get(result);
-		return result.then((settled) => build(settled, mapper));
-	}
-	return build(result, mapError);
-}
-/**
-* A typed mapping from `DbError` kinds to error classes, usually
-* better-result `TaggedError` classes, bound to better-result's `Result`
-* namespace. Kinds without a class use `fallback`. Each instance gets the
-* error's `message` and the `DbError` itself as `error`.
-*
-* ```ts
-* import { Result, TaggedError } from 'better-result';
-* class NotFound extends TaggedError('NotFound')<{ message: string; error: DbError }> {}
-* class DbFailure extends TaggedError('DbFailure')<{ message: string; error: DbError }> {}
-* const toResult = defineBetterResultErrors(Result, { not_found: NotFound }, DbFailure);
-* const customer: Result<Customer, NotFound | DbFailure> = await toResult(db.customers.findById(id));
-* ```
-*/
-function defineBetterResultErrors(api, classes, fallback) {
-	const map = (error) => {
-		return new (classes[error.kind] ?? fallback)({
-			message: error.message,
-			error
-		});
-	};
-	const convert = (result) => result instanceof AsyncResult ? toBetterResult(result, api, map) : toBetterResult(result, api, map);
-	return Object.assign(convert, { map });
-}
-/**
-* Converts a better-result value back into a `Result`, by its `status`
-* field, so it works across better-result versions. A `DbError`, or an
-* error whose `cause` is one, is kept; others go through `mapError`
-* (default `toDbError`).
-*/
-function fromBetterResult(result, mapError = toDbError) {
-	switch (result.status) {
-		case "ok": return ok(result.value);
-		case "error": return err(dbErrorOf(result.error) ?? mapError(result.error));
-		default: throw new TypeError(`better-supabase: fromBetterResult() expects a better-result value, got ${String(result)}`);
-	}
-}
-function toDbError(cause) {
-	if (cause instanceof DbException) return cause.error;
-	if (cause instanceof Error && cause.name === "AbortError") return dbError("aborted", cause.message || "The operation was aborted");
-	const message = cause instanceof Error ? cause.message : String(cause);
-	return dbError("unexpected", message);
-}
-//#endregion
-export { ok as a, withErrorMapper as c, fromBetterResult as i, defineBetterResultErrors as n, toBetterResult as o, err as r, toDbError as s, AsyncResult as t };