better-supabase 0.11.0 → 0.13.0

package/dist/result-BREt7qOh.d.ts

@@ -1,312 +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. `permissions`: the keys the caller lacks, such as
-   * the ones a workflow's steps need (`WORKFLOW_PUBLISHER_FORBIDDEN`).
-   * `approval`: the pending approval when the answer is `APPROVAL_REQUIRED`.
-   */
-  forbidden: {
-    required?: "aal1" | "aal2";
-    scopes?: readonly string[];
-    permission?: string;
-    permissions?: readonly 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>;
-  /**
-   * The database or a service could not be reached. `retryAfter`: seconds
-   * until a retry can succeed, when known (a paused connection pool).
-   */
-  network: {
-    retryAfter?: number;
-  };
-  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;
-};
-/** Handlers for `matchDbError`: one per error kind, plus `codes` for SQLSTATE codes. */
-type DbErrorMatchers = { readonly [K in DbErrorKind]?: (error: DbErrorOf<K>) => unknown; } & {
-  /**
-   * Handlers by SQLSTATE or PostgREST code (`23505`, `PGRST116`). They run
-   * before the handler for the error's kind.
-   */
-  readonly codes?: Readonly<Record<string, (error: DbError) => unknown>>;
-};
-/**
- * Builds the factory `.orThrow()` takes from handlers per error kind and per
- * SQLSTATE code. A handler that returns `undefined`, and an error no handler
- * matches, throw a `DbException`.
- */
-declare function matchDbError(matchers: DbErrorMatchers): (error: DbError) => unknown;
-/** 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;
-  /** Milliseconds until a retry can succeed, from `@supabase/server`'s pool errors. */
-  readonly retryAfterMs?: number;
-}
-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 { isConflict as A, DbErrorMatchers as C, ValidationIssue as D, RawDbError as E, statusOf as F, isForeignKey as M, mapDbError as N, dbError as O, matchDbError as P, DbErrorKinds as S, ErrorMapper 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, isDbError as j, isCheck 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, DbErrorOf as w, DbErrorKind as x, toDbError as y };

package/dist/result-DIeYscA3.js

@@ -1,134 +0,0 @@
-import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { c as mapDbError, n as dbError, o as isDbError, r as dbErrorOf } from "./errors-BV1SKTVs.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 isRawDbError(value) {
-	if (typeof value !== "object" || value === null || value instanceof Error && value.name !== "PostgrestError") return false;
-	return "code" in value && typeof value.code === "string" && (!("message" in value) || value.message === void 0 || typeof value.message === "string");
-}
-function toDbError(cause) {
-	if (cause instanceof DbException) return cause.error;
-	if (isDbError(cause)) return cause;
-	if (isRawDbError(cause)) return mapDbError(cause);
-	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 };