better-supabase 0.7.1 → 0.9.0

package/dist/outbox-Cq7pPYvl.d.ts

@@ -1,161 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { b as DbError, t as AsyncResult } from "./result-D7y2fT87.js";
-import { t as SqlClient } from "./executor-DbvExCFC.js";
-import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
-import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-CKtbFcRv.js";
-import { t as BlockProblemOptions } from "./problem-DD8LZFjc.js";
-import { r as EventSink, t as CloudEvent } from "./cloud-event-C1JCc1bH.js";
-//#region src/blocks/outbox/outbox.d.ts
-/** One row of the outbox, as `outbox_claim` and `outbox_history` return it. */
-interface OutboxEvent {
-  /** The cursor value: increases with every event. */
-  readonly position: number;
-  readonly id: string;
-  readonly type: string;
-  readonly payload: unknown;
-  /** The module or function that wrote it, e.g. `better-supabase/blocks/organizations`. */
-  readonly source: string | null;
-  readonly subject: string | null;
-  readonly tenant: string | null;
-  readonly key: string | null;
-  readonly actorId: string | null;
-  readonly createdAt: Temporal.Instant;
-}
-interface EmitOptions {
-  readonly subject?: string;
-  readonly tenant?: string;
-  /** With a key, emitting again (per tenant) returns the first event. */
-  readonly key?: string;
-  readonly source?: string;
-}
-interface OutboxOptions extends BlockTemporalOptions {
-  /** The schema of the `outbox` module. Defaults to `better_supabase`. */
-  readonly schema?: string;
-  /** CloudEvents `source` of the relayed events, e.g. `https://crm.example.com`. */
-  readonly source: string;
-  /** Prepended to each type with a dot when relaying, e.g. `com.example`. Defaults to `dev.better-supabase`. */
-  readonly typePrefix?: string;
-}
-interface RegisterOptions {
-  /** Type patterns such as `organization.*` or `invoice.paid`. Defaults to every event. */
-  readonly types?: readonly string[];
-  /** Start at the first kept event instead of after the latest one. */
-  readonly fromStart?: boolean;
-}
-interface RelayOptions {
-  /** Events per claim and per `sink.send`. Defaults to 100. */
-  readonly batch?: number;
-  /** How long a claim holds the consumer. Defaults to `1 minute`. */
-  readonly lease?: string;
-  /** Stops claiming after this many milliseconds. */
-  readonly budgetMs?: number;
-  /** Identifies this worker in the lease. Defaults to a random id. */
-  readonly owner?: string;
-  /**
-   * Failures in a row before the event that keeps failing goes to the dead
-   * letters and the cursor moves past it. Defaults to 10.
-   */
-  readonly maxAttempts?: number;
-  /** The longest wait between failed attempts. Defaults to `10 minutes`. */
-  readonly maxBackoff?: string;
-}
-interface RelayResult {
-  readonly delivered: number;
-  /**
-   * Set when the sink threw: the consumer backs off and retries the batch
-   * one event at a time.
-   */
-  readonly error?: DbError;
-  /** 1 when this run moved the failing event to the dead letters. */
-  readonly deadLettered?: number;
-}
-/** An event a consumer skipped after `maxAttempts` failures. */
-interface OutboxDeadLetter {
-  readonly consumer: string;
-  readonly event: OutboxEvent;
-  readonly attempts: number;
-  readonly error: string | null;
-  readonly deadAt: Temporal.Instant;
-}
-interface OutboxPurgeOptions {
-  /**
-   * A consumer that hasn't claimed for this long (a Postgres interval such
-   * as `30 days`) no longer holds events back. Defaults to waiting for
-   * every consumer.
-   */
-  readonly ignoreIdle?: string;
-}
-/**
- * Takes a batch of outbox rows, with the actor and tenant that CloudEvents
- * leave out. Throwing counts a failed attempt: the consumer backs off, then
- * retries one event at a time until the event that fails goes to the dead
- * letters.
- */
-type OutboxHandler = (events: readonly OutboxEvent[]) => unknown;
-interface OutboxRouteOptions extends Omit<RelayOptions, "owner">, BlockProblemOptions {
-  /** The bearer secret, such as `process.env.CRON_SECRET`. */
-  readonly secret: string | undefined;
-  /** Consumer name to the sink its events go to, or a handler that takes the rows. */
-  readonly consumers: Readonly<Record<string, EventSink | OutboxHandler>>;
-  readonly onError?: (error: DbError, consumer: string) => void;
-}
-interface OutboxRouteResult {
-  readonly consumers: Readonly<Record<string, RelayResult>>;
-  readonly budgetExhausted: boolean;
-}
-interface HistoryFilter extends CursorPageOptions<number> {
-  readonly subject?: string;
-  readonly type?: string;
-  /** Only events after this position. */
-  readonly cursor?: number;
-  readonly limit?: number;
-}
-interface Outbox {
-  /** Writes an event in the current transaction and returns its id. */
-  emit(type: string, payload?: unknown, options?: EmitOptions): AsyncResult<string>;
-  /** Creates the consumer, or changes its types. Returns its cursor position. */
-  register(consumer: string, options?: RegisterOptions): AsyncResult<number>;
-  /** Removes the consumer, so purges stop waiting for it. */
-  unregister(consumer: string): AsyncResult<boolean>;
-  /**
-   * Claims the consumer's next events, sends them to `sink` as CloudEvents and
-   * moves the cursor, until none are left or the budget runs out. A sink that
-   * throws leaves the batch for a later run with backoff, so delivery is at
-   * least once; an event that fails `maxAttempts` times goes to the dead
-   * letters.
-   */
-  relay(consumer: string, sink: EventSink, options?: RelayOptions): Promise<RelayResult>;
-  /**
-   * Like `relay`, but hands `handler` the outbox rows themselves, with
-   * `actorId`, `tenant` and `key`, for consumers inside the app (search
-   * indexing, notifications) that need the actor.
-   */
-  consume(consumer: string, handler: OutboxHandler, options?: RelayOptions): Promise<RelayResult>;
-  /** A `GET`/`POST` handler for a cron that relays every consumer at once, within one budget. */
-  relayRoute(options: OutboxRouteOptions): (request: Request) => Promise<Response>;
-  history(filter?: HistoryFilter): AsyncResult<readonly OutboxEvent[]>;
-  /** The consumer's dead letters, newest first (default 100, at most 1000). */
-  deadLetters(consumer: string, limit?: number): AsyncResult<readonly OutboxDeadLetter[]>;
-  /**
-   * Deletes up to `batch` events (default 10,000) older than `olderThan` that
-   * every consumer has passed, and dead letters older than `olderThan`. Call
-   * it again while it returns `batch`.
-   */
-  purge(olderThan?: string, batch?: number, options?: OutboxPurgeOptions): AsyncResult<number>;
-}
-/**
- * The CloudEvent for an outbox row: the row id as `id` (stable, so receivers
- * can deduplicate), the payload as `data`, the tenant as `partitionkey` and
- * the writing module as `producer`. The actor stays out of the context
- * attributes, which must not carry personal data.
- */
-declare function outboxCloudEvent(event: OutboxEvent, options: Pick<OutboxOptions, "source" | "typePrefix">): CloudEvent;
-/**
- * The outbox over a server connection (`SqlClient`), or over a
- * `BlockTransport` such as `rpcTransport(serviceClient, { schema: "api" })`
- * for apps that reach the database only through the Data API. Over a
- * transport, `emit` writes in its own transaction.
- */
-declare function createOutbox(source: SqlClient | BlockTransport, options: OutboxOptions): Outbox;
-//#endregion
-export { OutboxEvent as a, OutboxPurgeOptions as c, RegisterOptions as d, RelayOptions as f, outboxCloudEvent as h, OutboxDeadLetter as i, OutboxRouteOptions as l, createOutbox as m, HistoryFilter as n, OutboxHandler as o, RelayResult as p, Outbox as r, OutboxOptions as s, EmitOptions as t, OutboxRouteResult as u };

package/dist/path-Cv__-OTj.d.ts

@@ -1,17 +0,0 @@
-//#region src/storage/path.d.ts
-declare const bucketOf: unique symbol;
-/**
- * An object path in bucket `B`, e.g. `org-1/cust-1/logo/3.webp`. Returned by
- * `bucket.path()` and `upload()`, and the type of columns listed in the
- * `storagePaths` config. Store paths, not URLs: signed URLs expire and public
- * URLs pin the project host.
- */
-type StoragePath<B extends string = string> = string & {
-  readonly [bucketOf]: B;
-};
-/** A plain string or a `StoragePath` of bucket `B`; paths of other buckets are rejected. */
-type PathIn<B extends string> = string & {
-  readonly [bucketOf]?: B;
-};
-//#endregion
-export { StoragePath as n, PathIn as t };

package/dist/plugin-FGY8UhYm.d.ts

@@ -1,151 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { w as ErrorMapper } from "./result-D7y2fT87.js";
-import { I as TableFlags, P as SchemaMeta, R as TableMeta, a as AnyModels } from "./types-6BdhkmZe.js";
-import { _ as MutationOp, g as MutationKind, h as MutationIntent, r as Executor, v as Operation } from "./executor-DvsBbNBS.js";
-//#region src/core/plugin.d.ts
-/** Who is making the request. */
-interface Actor {
-  readonly id: string;
-  readonly kind: "user" | "service" | "anon";
-  readonly role?: string;
-  readonly email?: string;
-  /** The admin acting as this user (the `act` claim's `sub`). */
-  readonly impersonator?: string;
-}
-/**
- * Per-connection context. Server adapters fill it from the verified JWT;
- * plugins read it (`tenant()` reads `tenant`, `actor()` reads `actor`).
- */
-interface RequestContext {
-  readonly actor?: Actor;
-  readonly tenant?: string;
-  readonly claims?: Readonly<Record<string, unknown>>;
-  readonly [key: string]: unknown;
-}
-/** Plugin-specific per-call options (`withDeleted`, `hard`, ...). */
-type CallOptions = Readonly<Record<string, unknown>>;
-interface HookArgs {
-  readonly table: TableMeta;
-  readonly schema: SchemaMeta;
-  readonly context: RequestContext;
-  readonly options: CallOptions;
-  readonly now: () => Temporal.Instant;
-  /** The caller's `signal`, when it passed one. Hooks that do I/O should honor it. */
-  readonly signal?: AbortSignal;
-}
-interface MutationEvent {
-  readonly table: TableMeta;
-  /** The statement that ran. */
-  readonly kind: MutationKind;
-  /** What the caller asked for; differs from `kind` when a plugin rewrote the mutation. */
-  readonly intent?: MutationIntent;
-  /** App-cased rows returned by the mutation. A copy: changing it never changes the result. */
-  readonly rows: readonly Readonly<Record<string, unknown>>[];
-  /**
-   * App-cased primary keys of the changed rows, when they are known: from
-   * the returned rows, or from a `where` on the primary key when nothing is
-   * returned (soft deletes, `returning: false`).
-   */
-  readonly keys?: readonly Readonly<Record<string, unknown>>[];
-  /** The tenant of the write: `context.tenant`, which `tenant()` fills from the claims. */
-  readonly tenant?: string;
-  readonly context: RequestContext;
-}
-/** Runtime handle passed to `Plugin.repository`. */
-interface RepositoryApi {
-  readonly table: TableMeta;
-  readonly base: Readonly<Record<string, (...args: never[]) => unknown>>;
-}
-/**
- * Type-level repository extension, applied per table. Implement it as an
- * interface that reads `this['M']` and `this['T']`:
- *
- * ```ts
- * interface RestoreExtension extends RepositoryExtension {
- *   readonly methods: HasFlag<this['M'], this['T'], 'softDelete'> extends true
- *     ? { restore(id: string): AsyncResult<unknown> }
- *     : unknown;
- * }
- * ```
- */
-interface RepositoryExtension {
-  readonly M: AnyModels;
-  readonly T: string;
-  readonly methods: unknown;
-  readonly findArgs: unknown;
-  readonly deleteArgs: unknown;
-}
-/**
- * Applies the extensions in `E` to table `T`. `E` is a tuple of extensions (as
- * built by `use()`) or a single extension. Each is applied on its own because
- * indexing an intersection of `this`-typed interfaces overflows TS < 7.
- */
-/** Default extension of plugins that add no repository types. */
-interface NoExtension extends RepositoryExtension {
-  readonly "~none": true;
-}
-type ApplyExtension<E, M extends AnyModels, T extends keyof M, K extends "methods" | "findArgs" | "deleteArgs"> = E extends readonly [infer Head, ...infer Rest] ? ApplyOne<Head, M, T, K> & ApplyExtension<Rest, M, T, K> : ApplyOne<E, M, T, K>;
-type ApplyOne<E, M extends AnyModels, T extends keyof M, K extends "methods" | "findArgs" | "deleteArgs"> = E extends RepositoryExtension ? (E & {
-  readonly M: M;
-  readonly T: T;
-})[K] : unknown;
-/** True when table `T` has the flag set by codegen. */
-type HasFlag<M, T, F extends string> = M extends AnyModels ? T extends keyof M ? M[T]["Flags"] extends { readonly [K in F]: unknown; } ? true : false : false : false;
-declare const PLUGIN_API_VERSION = 1;
-/**
- * Plugin API v1. Every hook is optional. Hooks run in `use()` order.
- */
-interface Plugin<Name extends string = string, Ext extends RepositoryExtension = NoExtension> {
-  readonly apiVersion: 1;
-  readonly name: Name;
-  /**
-   * Hook order: `first`, then `pre`, then unmarked plugins, then `post`;
-   * plugins at the same level keep `use()` order. `first` is for plugins
-   * that check the query as the caller wrote it, before a `pre` plugin
-   * rewrites it (`rules()`). Validation is `post` so it sees columns other
-   * plugins fill.
-   */
-  readonly enforce?: "first" | "pre" | "post";
-  /**
-   * The table flags whose tables this plugin's `transformQuery` filters
-   * (`tenant()` declares `['tenant']`). Read sets warn when they read such a
-   * table, because their generated SQL function runs without the plugin.
-   * `[]` means the plugin only inspects queries. A plugin with
-   * `transformQuery` that leaves this out is assumed to filter every table.
-   */
-  readonly scopes?: readonly (keyof TableFlags)[];
-  /**
-   * `context`: derive values from the connection's context once per
-   * `connect()` and `$with()`, so `db.$context` carries them (`tenant()`
-   * adds the tenant it resolved). Runs in hook order on the context the
-   * caller passed. A throw is logged and leaves the context unchanged.
-   */
-  readonly context?: (context: RequestContext, args: {
-    readonly schema: SchemaMeta;
-  }) => RequestContext;
-  /** `ir`: rewrite an operation before it runs (filters, defaults). */
-  readonly transformQuery?: (op: Operation, args: HookArgs) => Operation;
-  /** `mutation`: rewrite a mutation or reject it by throwing a `DbException`. */
-  readonly beforeMutation?: (op: MutationOp, args: HookArgs) => MutationOp | Promise<MutationOp>;
-  /** `mutation`: observe a finished mutation. Cannot change the result. */
-  readonly afterMutation?: (event: MutationEvent) => void | Promise<void>;
-  /** `execute`: wrap the executor for tracing, caching or retries. */
-  readonly wrapExecutor?: (executor: Executor) => Executor;
-  /** `errors`: map custom SQLSTATE or hint codes to `DbError`s. */
-  readonly mapError?: ErrorMapper;
-  /** `repository`: add methods to the repositories of matching tables. */
-  readonly repository?: (api: RepositoryApi) => Readonly<Record<string, (...args: never[]) => unknown>> | undefined;
-  /** Phantom carrying the repository extension type. */
-  readonly "~ext"?: Ext;
-}
-type AnyPlugin = Plugin<string, any>;
-/** The plugin's repository extension; `unknown` for plugins that add none. */
-type ExtensionOf<P> = P extends Plugin<string, infer E> ? E extends NoExtension ? unknown : E : never;
-/** `E` with extension `X` appended, as a tuple. */
-type WithExtension<E, X> = unknown extends X ? E : E extends readonly unknown[] ? readonly [...E, X] : unknown extends E ? readonly [X] : readonly [E, X];
-/** Identity helper that fixes `apiVersion` and infers the plugin types. */
-declare function definePlugin<const Name extends string, Ext extends RepositoryExtension = NoExtension>(plugin: Omit<Plugin<Name, Ext>, "apiVersion"> & {
-  readonly apiVersion?: 1;
-}): Plugin<Name, Ext>;
-//#endregion
-export { ExtensionOf as a, MutationEvent as c, Plugin as d, RepositoryApi as f, definePlugin as g, WithExtension as h, CallOptions as i, NoExtension as l, RequestContext as m, AnyPlugin as n, HasFlag as o, RepositoryExtension as p, ApplyExtension as r, HookArgs as s, Actor as t, PLUGIN_API_VERSION as u };

package/dist/pool-CAu2nLrL.d.ts

@@ -1,89 +0,0 @@
-import { r as Executor } from "./executor-DvsBbNBS.js";
-import { t as SqlClient } from "./executor-DbvExCFC.js";
-//#region src/postgres/pool.d.ts
-/** The part of a `pg` pool client `createPostgres` uses. */
-interface PgPoolClient {
-  query(text: string, values?: unknown[]): Promise<{
-    rows: unknown[];
-  }>;
-  release(): void;
-}
-/** The part of a `pg.Pool` `createPostgres` uses. */
-interface PgPool {
-  connect(): Promise<PgPoolClient>;
-  end(): Promise<void>;
-}
-/** Statement timeouts in milliseconds by the role a transaction runs as. */
-interface PostgresTimeouts {
-  /** The connection-string role (`admin` and `transaction` without claims). Unset by default. */
-  readonly admin?: number;
-  /** Defaults to 8000, Supabase's setting for the role. */
-  readonly authenticated?: number;
-  /** Defaults to 3000, Supabase's setting for the role. */
-  readonly anon?: number;
-}
-interface PostgresOptions {
-  /** Defaults to `$SUPABASE_DB_URL`, then `$DATABASE_URL`. */
-  readonly connectionString?: string;
-  /** An existing pool to run on instead of opening one. `end()` ends it. */
-  readonly pool?: PgPool;
-  readonly max?: number;
-  /**
-   * Statement timeout in milliseconds, applied per transaction: one value
-   * for every role, or one per role. `set role` doesn't apply the role's own
-   * `statement_timeout`, so `authenticated` and `anon` get Supabase's 8 s
-   * and 3 s unless you set them.
-   */
-  readonly statementTimeout?: number | PostgresTimeouts;
-  /** Ends a session that stays idle inside a transaction this long, in milliseconds. */
-  readonly idleInTransactionTimeout?: number;
-  /** How long `connect` waits for a connection, in milliseconds. Defaults to 10000. */
-  readonly connectionTimeout?: number;
-  /** How long an unused connection stays open, in milliseconds. Defaults to 10000. */
-  readonly idleTimeout?: number;
-}
-/** JWT claims to run as. `role` must be `authenticated` or `anon`. */
-interface SqlClaims {
-  readonly sub?: string;
-  readonly role?: string;
-  readonly [claim: string]: unknown;
-}
-/** What every transaction of a user session sets besides the claims and role. */
-interface SessionOptions {
-  /**
-   * Transaction-local settings, e.g. `{ 'better_supabase.tenant': id }`.
-   * Names need a dot (custom settings); `role` and `request.jwt.claims` are
-   * set from the claims.
-   */
-  readonly settings?: Readonly<Record<string, string>>;
-  /** Runs every transaction with `begin read only`: writes fail with 25006. */
-  readonly readOnly?: boolean;
-}
-interface BetterPostgres {
-  /** Connects as the connection-string role. On Supabase that bypasses RLS. */
-  readonly admin: SqlClient;
-  /** Runs every query as the given user, with RLS, like PostgREST does. */
-  asUser(claims: SqlClaims, options?: SessionOptions): SqlClient;
-  /** Runs every query as `anon`. */
-  readonly anon: SqlClient;
-  /**
-   * Repositories' executor as the given user (`postgresExecutor(asUser(claims))`).
-   * `createServer` calls it for `ctx.sql`, so only apps that pass `postgres`
-   * bundle the SQL compiler.
-   */
-  executorFor(claims: SqlClaims, options?: SessionOptions): Executor;
-  /** Runs `fn` in one transaction. Pass claims to run it as a user. */
-  transaction<T>(fn: (client: SqlClient) => Promise<T>, options?: {
-    readonly claims?: SqlClaims;
-  } & SessionOptions): Promise<T>;
-  end(): Promise<void>;
-  [Symbol.asyncDispose](): Promise<void>;
-}
-/**
- * A pooled Postgres connection for jobs, scripts and tests. Each query (or
- * transaction) runs in its own transaction; claims and role are
- * transaction-local, so nothing leaks back into the pool.
- */
-declare function createPostgres(options?: PostgresOptions): BetterPostgres;
-//#endregion
-export { PostgresTimeouts as a, createPostgres as c, PostgresOptions as i, PgPool as n, SessionOptions as o, PgPoolClient as r, SqlClaims as s, BetterPostgres as t };

package/dist/postgrest-BLVdEnfe.d.ts

@@ -1,53 +0,0 @@
-import { v as Operation } from "./executor-DvsBbNBS.js";
-//#region src/compile/postgrest.d.ts
-/**
- * A compiled PostgREST request, expressed as calls on the public
- * postgrest-js builder so it works with any supabase-js client.
- */
-interface PostgrestPlan {
-  /** `select` parameter, or `undefined` for mutations without returning. */
-  readonly select: string | undefined;
-  readonly filters: readonly PlanFilter[];
-  readonly orders: readonly PlanOrder[];
-  readonly limits: readonly PlanLimit[];
-  readonly range: {
-    readonly from: number;
-    readonly to: number;
-  } | undefined;
-  /** The condition can never match; skip the request. */
-  readonly never: boolean;
-  /** `Prefer: max-affected` on an update or delete (PostgREST 13 and later). */
-  readonly maxAffected?: number;
-}
-interface PostgrestCompileOptions {
-  /**
-   * The PostgREST version the request goes to, from `postgrestVersion` in
-   * the config. `maxAffected` needs 13 or later; older versions fail with
-   * `invalid_request` before any request. Defaults to `"13"`.
-   */
-  readonly postgrestVersion?: string;
-}
-type PlanFilter = {
-  readonly kind: "filter";
-  readonly path: string;
-  readonly operator: string;
-  readonly value: string;
-} | {
-  readonly kind: "or";
-  readonly expression: string;
-  readonly referencedTable: string | undefined;
-};
-interface PlanOrder {
-  readonly column: string;
-  readonly ascending: boolean;
-  readonly nullsFirst: boolean | undefined;
-  readonly referencedTable: string | undefined;
-}
-interface PlanLimit {
-  readonly count: number;
-  readonly referencedTable: string | undefined;
-}
-/** Compiles an operation into a PostgREST plan. */
-declare function compilePostgrest(op: Operation, options?: PostgrestCompileOptions): PostgrestPlan;
-//#endregion
-export { PostgrestPlan as a, PostgrestCompileOptions as i, PlanLimit as n, compilePostgrest as o, PlanOrder as r, PlanFilter as t };

package/dist/problem-BreOl8b8.js

@@ -1,115 +0,0 @@
-import { n as dbError } from "./errors-B11Duf73.js";
-//#region src/core/problem.ts
-const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
-const PROBLEM_CONTENT_TYPE = "application/problem+json";
-const TITLES = {
-	not_found: "Not found",
-	unauthorized: "Unauthorized",
-	forbidden: "Forbidden",
-	conflict: "Conflict",
-	foreign_key: "Referenced row missing or still referenced",
-	check: "Check constraint violated",
-	not_null: "Required value missing",
-	exclusion: "Exclusion constraint violated",
-	invalid_input: "Invalid input",
-	invalid_value: "Stored value not representable",
-	raised: "Request rejected",
-	timeout: "Timed out",
-	serialization: "Concurrent update, retry",
-	network: "Database unreachable",
-	aborted: "Aborted",
-	invalid_request: "Invalid request",
-	validation: "Validation failed",
-	multiple_rows: "More than one row matched",
-	stale: "Row changed since it was read",
-	max_affected: "Too many rows affected",
-	rate_limited: "Too many requests",
-	quota_exceeded: "Quota exceeded",
-	unsupported: "Not supported by this executor",
-	unexpected: "Unexpected error"
-};
-/** Kinds whose message may contain internals (SQL, hostnames), hidden unless `expose` is set. */
-const INTERNAL = /* @__PURE__ */ new Set([
-	"unexpected",
-	"network",
-	"invalid_request"
-]);
-/** Converts a `DbError` to Problem Details. */
-function toProblem(error, options = {}) {
-	const problem = {
-		type: `${PROBLEM_TYPE_BASE}${error.kind.replaceAll("_", "-")}`,
-		title: TITLES[error.kind],
-		status: error.status,
-		kind: error.kind
-	};
-	if (!INTERNAL.has(error.kind) || options.expose) problem["detail"] = error.message;
-	if (options.instance) problem["instance"] = options.instance;
-	if (error.code) problem["code"] = error.code;
-	if (error.hint) problem["hint"] = error.hint;
-	if ("constraint" in error && error.constraint) problem["constraint"] = error.constraint;
-	if ("columns" in error) problem["columns"] = error.columns;
-	if ("column" in error && error.column) problem["column"] = error.column;
-	if ("issues" in error) problem["issues"] = error.issues;
-	if ("required" in error) problem["required"] = error.required;
-	if ("scopes" in error) problem["scopes"] = error.scopes;
-	if ("retryAfter" in error) problem["retryAfter"] = error.retryAfter;
-	if ("meter" in error) problem["meter"] = error.meter;
-	if ("limit" in error) problem["limit"] = error.limit;
-	if ("maxAffected" in error) problem["maxAffected"] = error.maxAffected;
-	return problem;
-}
-/**
-* An `application/problem+json` response. A 401, and a 403 for a missing
-* OAuth scope, carry an RFC 6750 `WWW-Authenticate: Bearer` challenge.
-*/
-function problemResponse(error, options = {}) {
-	const headers = new Headers(options.headers);
-	headers.set("content-type", PROBLEM_CONTENT_TYPE);
-	const realm = (options.realm ?? "supabase").replaceAll("\"", "");
-	if (error.status === 401 && !headers.has("www-authenticate")) {
-		const params = error.code === "MISSING_CREDENTIALS" ? "" : ", error=\"invalid_token\"";
-		headers.set("www-authenticate", `Bearer realm="${realm}"${params}`);
-	}
-	if ("scopes" in error && error.code === "INSUFFICIENT_SCOPE" && !headers.has("www-authenticate")) {
-		const scope = error.scopes.join(" ").replaceAll("\"", "");
-		headers.set("www-authenticate", `Bearer realm="${realm}", error="insufficient_scope", scope="${scope}"`);
-	}
-	if ("retryAfter" in error && !headers.has("retry-after")) headers.set("retry-after", String(error.retryAfter));
-	const problem = toProblem(error, options);
-	const body = options.format ? options.format(problem, error) : problem;
-	return new Response(JSON.stringify(body), {
-		status: error.status,
-		headers
-	});
-}
-function isProblem(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const problem = value;
-	return typeof problem["type"] === "string" && typeof problem["status"] === "number" && typeof problem["title"] === "string";
-}
-function isKind(value) {
-	return typeof value === "string" && value in TITLES;
-}
-/** Turns a Problem Details body back into a `DbError` (client side). */
-function fromProblem(problem) {
-	const kind = isKind(problem.kind) ? problem.kind : "unexpected";
-	const extra = { status: problem.status };
-	for (const key of [
-		"code",
-		"hint",
-		"constraint",
-		"columns",
-		"column",
-		"required",
-		"scopes",
-		"retryAfter",
-		"meter",
-		"limit",
-		"maxAffected"
-	]) if (problem[key] !== void 0) extra[key] = problem[key];
-	extra["issues"] = problem.issues ?? [];
-	if (kind !== "validation") delete extra["issues"];
-	return dbError(kind, problem.detail ?? problem.title, extra);
-}
-//#endregion
-export { problemResponse as a, isProblem as i, PROBLEM_TYPE_BASE as n, toProblem as o, fromProblem as r, PROBLEM_CONTENT_TYPE as t };

package/dist/problem-DD8LZFjc.d.ts

@@ -1,67 +0,0 @@
-import { E as ValidationIssue, b as DbError, x as DbErrorKind } from "./result-D7y2fT87.js";
-//#region src/core/problem.d.ts
-/** RFC 9457 Problem Details, with the `DbError` fields as extension members. */
-interface ProblemDetails {
-  readonly type: string;
-  readonly title: string;
-  readonly status: number;
-  readonly detail?: string;
-  readonly instance?: string;
-  /** The `DbError` kind. */
-  readonly kind: DbErrorKind;
-  readonly code?: string;
-  readonly hint?: string;
-  readonly constraint?: string;
-  readonly columns?: readonly string[];
-  readonly column?: string;
-  readonly issues?: readonly ValidationIssue[];
-  /** The assurance level a `forbidden` answer needs (`aal2`). */
-  readonly required?: "aal1" | "aal2";
-  /** The OAuth scopes a `forbidden` answer needs. */
-  readonly scopes?: readonly string[];
-  /** Seconds until a `rate_limited` or `quota_exceeded` caller may retry. */
-  readonly retryAfter?: number;
-  /** The meter a `quota_exceeded` answer ran out of, and its limit. */
-  readonly meter?: string;
-  readonly limit?: number;
-  /** The row limit a `max_affected` write exceeded. */
-  readonly maxAffected?: number;
-}
-declare const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
-declare const PROBLEM_CONTENT_TYPE = "application/problem+json";
-interface ProblemOptions {
-  /** URI reference for this occurrence, e.g. the request path. */
-  readonly instance?: string;
-  /** Include messages of internal errors. Defaults to false. */
-  readonly expose?: boolean;
-}
-/**
- * Rewrites the Problem Details a block answers with into the app's own error
- * body, such as its `type` URIs and error codes. The status, `Retry-After`
- * and `WWW-Authenticate` headers stay as they are.
- */
-type ProblemFormat = (problem: ProblemDetails, error: DbError) => Readonly<Record<string, unknown>>;
-/** The `problem` option of the blocks that answer HTTP requests. */
-interface BlockProblemOptions {
-  /** The app's error body for the block's error responses. Defaults to RFC 9457 Problem Details. */
-  readonly problem?: ProblemFormat;
-}
-interface ProblemResponseOptions extends ProblemOptions {
-  readonly headers?: ConstructorParameters<typeof Headers>[0];
-  /** `realm` of the RFC 6750 challenge on 401. */
-  readonly realm?: string;
-  /** Rewrites the body; see `ProblemFormat`. */
-  readonly format?: ProblemFormat | undefined;
-}
-/** Converts a `DbError` to Problem Details. */
-declare function toProblem(error: DbError, options?: ProblemOptions): ProblemDetails;
-/**
- * An `application/problem+json` response. A 401, and a 403 for a missing
- * OAuth scope, carry an RFC 6750 `WWW-Authenticate: Bearer` challenge.
- */
-declare function problemResponse(error: DbError, options?: ProblemResponseOptions): Response;
-declare function isProblem(value: unknown): value is ProblemDetails;
-/** Turns a Problem Details body back into a `DbError` (client side). */
-declare function fromProblem(problem: ProblemDetails): DbError;
-//#endregion
-export { ProblemFormat as a, fromProblem as c, toProblem as d, ProblemDetails as i, isProblem as l, PROBLEM_CONTENT_TYPE as n, ProblemOptions as o, PROBLEM_TYPE_BASE as r, ProblemResponseOptions as s, BlockProblemOptions as t, problemResponse as u };