better-supabase 0.3.0 → 0.5.0

package/dist/result-c2OYgCV2.d.ts

@@ -1,203 +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`).
-   */
-  forbidden: {
-    required?: "aal1" | "aal2";
-    scopes?: readonly 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>;
-  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>;
-  /** `retryAfter`: seconds until the window resets (the `Retry-After` header). */
-  rate_limited: {
-    retryAfter?: number;
-  };
-  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;
-};
-/** Thrown by `.orThrow()`. Carries the plain `DbError` as `error`. */
-declare class DbException extends Error {
-  override readonly name = "DbException";
-  readonly error: DbError;
-  constructor(error: DbError);
-  get kind(): DbErrorKind;
-}
-/** 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 `sb.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 `sb.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;
-}
-/**
- * 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 `sb.mapError(fn)`, through `fn` (typed `unknown`).
- * The value is a real `Ok`/`Err`: cast it (`as Result<T, E>`) for its
- * methods in types; the cast itself is not checked against `T`.
- *
- * ```ts
- * import { Result } from 'better-result';
- * const customer = toBetterResult(await db.customers.findById(id), Result, toAppError);
- * ```
- */
-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>>;
-/**
- * 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 { isConflict as C, statusOf as D, mapDbError as E, isCheck as S, isForeignKey as T, DbException as _, Ok as a, ValidationIssue as b, err as c, toBetterResult as d, toDbError as f, DbErrorOf as g, DbErrorKinds as h, Err as i, fromBetterResult as l, DbErrorKind as m, BetterResultApi as n, Result as o, DbError as p, BetterResultValue as r, ThrowMapper as s, AsyncResult as t, ok as u, ErrorMapper as v, isDbError as w, dbError as x, RawDbError as y };

package/dist/view-wZ-9qIUz.js

@@ -1,45 +0,0 @@
-import { g as delegationOf, h as actorOf, n as amrOf, t as aalOf, v as impersonatorOf } from "./mfa-BxoR1RkN.js";
-//#region src/auth/view.ts
-/** Drops the token from an `AuthState`, leaving only serializable fields. */
-function toSession(auth) {
-	switch (auth.kind) {
-		case "user": {
-			const impersonator = impersonatorOf(auth.claims);
-			const outcome = actorOf(auth.claims);
-			const actor = outcome.ok ? outcome.actor : void 0;
-			const scopes = actor ? delegationOf(auth.claims)?.scopes : void 0;
-			const delegation = actor && (scopes || actor.chain) ? {
-				scopes: scopes ?? [],
-				...actor.chain ? { chain: actor.chain } : {}
-			} : void 0;
-			return {
-				kind: "user",
-				user: auth.user,
-				claims: auth.claims,
-				expiresAt: auth.expiresAt,
-				...auth.profile === void 0 ? {} : { profile: auth.profile },
-				aal: aalOf(auth.claims),
-				amr: amrOf(auth.claims),
-				...impersonator ? { impersonator } : {},
-				...actor ? { actor } : {},
-				...delegation ? { delegation } : {}
-			};
-		}
-		case "service": return {
-			kind: "service",
-			keyName: auth.keyName
-		};
-		case "anon": return {
-			kind: "anon",
-			reason: auth.reason
-		};
-		case "invalid": return {
-			kind: "invalid",
-			reason: auth.reason,
-			error: auth.error
-		};
-		default: return auth;
-	}
-}
-//#endregion
-export { toSession as t };