better-supabase 0.3.0 → 0.5.0

package/dist/{resource-D30rp0GN.js → resource-CRxxwkQq.js}

@@ -1,7 +1,7 @@
-import { n as dbError } from "./errors-Bl3rkOzo.js";
-import { i as ok, n as err } from "./result-DWXatkd6.js";
-import { t as validate } from "./standard-FUi3Z3-7.js";
-import { i as respond } from "./respond-C44EZAJo.js";
+import { n as dbError } from "./errors-DtwXa6b8.js";
+import { i as ok, n as err } from "./result-BKiliPY7.js";
+import { t as validate } from "./standard-D7r6dMUu.js";
+import { p as respond } from "./server-Csx2sRjg.js";
 //#region src/server/resource.ts
 const INTEGER = /* @__PURE__ */ new Set([
 	"int2",
@@ -9,7 +9,7 @@ const INTEGER = /* @__PURE__ */ new Set([
 	"int8"
 ]);
 function keyValue(table, raw) {
-	const invalid = err(dbError("invalid_request", `${JSON.stringify(raw)} is not a valid ${table.key} key`));
+	const invalid = err(dbError("invalid_input", `${JSON.stringify(raw)} is not a valid ${table.key} key`));
 	const column = table.columns[table.primaryKey[0]];
 	if (column && INTEGER.has(column.type)) {
 		const value = typeof raw === "string" ? Number(raw) : raw;
@@ -17,12 +17,26 @@ function keyValue(table, raw) {
 	}
 	return typeof raw === "string" && raw !== "" ? ok(raw) : invalid;
 }
+/**
+* A cross-site browser request that needed no CORS preflight: a form post
+* riding on the session cookie. Bearer requests and JSON bodies (which need a
+* preflight) pass, as do requests without an `Origin` (not a browser).
+*/
+function crossSiteSimpleRequest(request) {
+	if (request.method === "GET" || request.method === "HEAD") return false;
+	if (request.headers.has("authorization")) return false;
+	const origin = request.headers.get("origin");
+	if (!origin || origin === new URL(request.url).origin) return false;
+	if (request.headers.get("sec-fetch-site") === "same-origin") return false;
+	const type = request.headers.get("content-type") ?? "";
+	return !/^application\/(?:[\w.+-]+\+)?json\b/iu.test(type);
+}
 async function readBody(request) {
 	try {
 		const body = await request.json();
 		if (typeof body === "object" && body !== null && !Array.isArray(body)) return ok(body);
 	} catch {}
-	return err(dbError("invalid_request", "The request body must be a JSON object"));
+	return err(dbError("invalid_input", "The request body must be a JSON object"));
 }
 function pageArgs(query, max, pagination) {
 	const raw = (name) => {
@@ -66,7 +80,7 @@ function pageArgs(query, max, pagination) {
 	});
 }
 function asObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? ok(value) : err(dbError("invalid_request", "Expected an object of column values"));
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? ok(value) : err(dbError("invalid_input", "Expected an object of column values"));
 }
 async function settled(value) {
 	return await value;
@@ -82,8 +96,8 @@ function notAllowed(allowed) {
 * `createOpenApi`: `GET/POST /<table>` and `GET/PATCH/DELETE /<table>/{id}`.
 * Shared by the HTTP adapters and the MCP table tools.
 */
-function defineResource(sb, table, options = {}) {
-	const meta = sb.meta.tables[table];
+function defineResource(betterSupabase, table, options = {}) {
+	const meta = betterSupabase.meta.tables[table];
 	if (!meta) throw new TypeError(`Unknown table "${table}"`);
 	if (options.list && options.list.table !== table) throw new TypeError(`The list query is for "${options.list.table}", not "${table}"`);
 	const operations = options.operations ?? (meta.kind === "view" ? ["list", "get"] : [
@@ -155,6 +169,7 @@ function defineResource(sb, table, options = {}) {
 		...has("delete") ? ["DELETE"] : []
 	];
 	const route = async (request, db, id) => {
+		if (crossSiteSimpleRequest(request)) return err(dbError("forbidden", "Cross-site requests need Content-Type: application/json or a bearer token", { code: "CROSS_SITE_REQUEST" }));
 		if (id === void 0) {
 			if (request.method === "GET" && has("list")) return execute(db, "list", { query: new URL(request.url).searchParams });
 			if (request.method === "POST" && has("create")) {

package/dist/{resource-CwVgiI5q.d.ts → resource-D8iqWMr-.d.ts}

@@ -1,8 +1,8 @@
-import { N as TableKey, P as TableMeta, R as Update, g as Insert, n as AnyModels, t as AnyFunctions } from "./types-DONv9SHN.js";
-import { b as ValidationIssue, o as Result } from "./result-c2OYgCV2.js";
-import { t as BetterSupabase, xt as SelectArg } from "./define-DUbydmJa.js";
-import { r as RespondOptions } from "./respond-DAkPIdTH.js";
-import { i as ResourceOperation } from "./index-qriRM9cZ.js";
+import { F as TableMeta, P as TableKey, _ as Insert, n as AnyFunctions, r as AnyModels, z as Update } from "./types-Dnf_wRDz.js";
+import { u as Result, w as ValidationIssue } from "./executor-BunPOO-k.js";
+import { t as BetterSupabase, xt as SelectArg } from "./define-Bp_BZa5h.js";
+import { i as RespondOptions } from "./respond-D2OQl62-.js";
+import { i as ResourceOperation } from "./index-C7f8cOBM.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/server/resource.d.ts
 /** What a resource needs from `defineListQuery`. */
@@ -69,6 +69,6 @@ interface ResourceHandler {
  * `createOpenApi`: `GET/POST /<table>` and `GET/PATCH/DELETE /<table>/{id}`.
  * Shared by the HTTP adapters and the MCP table tools.
  */
-declare function defineResource<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>>(sb: BetterSupabase<M, D, F, E>, table: T, options?: ResourceRouteOptions<M, T>): ResourceHandler;
+declare function defineResource<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>>(betterSupabase: BetterSupabase<M, D, F, E>, table: T, options?: ResourceRouteOptions<M, T>): ResourceHandler;
 //#endregion
 export { ResourceRouteOptions as a, ResourcePagination as i, ResourceInput as n, defineResource as o, ResourceList as r, ResourceHandler as t };

package/dist/respond-D2OQl62-.d.ts

@@ -0,0 +1,371 @@
+import { n as AnyFunctions, r as AnyModels } from "./types-Dnf_wRDz.js";
+import { _ as DbError, a as AsyncResult } from "./executor-BunPOO-k.js";
+import { a as EventHub } from "./events-aIO7vsIk.js";
+import { I as StatsRecorder, P as DbStats, t as BetterSupabase, y as Db } from "./define-Bp_BZa5h.js";
+import { g as RequestContext } from "./plugin-o144f322.js";
+import { t as BetterSupabaseEnv } from "./index-CLg87OBW.js";
+import { s as SqlClaims, t as BetterPostgres } from "./pool-C9voM4Kw.js";
+import { a as ResolveAuthOptions, r as AuthState, t as AuthResolution } from "./resolve-C15TJq77.js";
+import { a as SupportSession, i as SupportListFilter, o as SupportSessionStore } from "./support-DT-OhSxD.js";
+import { o as ImpersonationOptions, t as Aal } from "./mfa-CusDgPaD.js";
+import { c as Bucket } from "./index-SaTsEfGP.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/auth/support-cookie.d.ts
+/** The cookie that carries the support session id. */
+declare const SUPPORT_COOKIE = "bs-support";
+interface SupportCookieOptions {
+  /** Defaults to `bs-support`. */
+  readonly name?: string;
+  /** Defaults to `/`. */
+  readonly path?: string;
+  /** Defaults to true; set false for plain-HTTP local development. */
+  readonly secure?: boolean;
+}
+/** `Set-Cookie` for a session: HttpOnly, SameSite=Lax, gone when the session expires. */
+declare function supportCookie(session: Pick<SupportSession, "id" | "expiresAt">, options?: SupportCookieOptions, now?: number): string;
+/** `Set-Cookie` that removes the support cookie. */
+declare function clearSupportCookie(options?: SupportCookieOptions): string;
+/** The support session id in a `Cookie` header, or `undefined`. */
+declare function supportCookieValue(cookieHeader: string | null, name?: string): string | undefined;
+//#endregion
+//#region src/server/support.d.ts
+type UserAuth = Extract<AuthState, {
+  kind: "user";
+}>;
+interface SupportPolicy {
+  /** Seconds a session lasts. Defaults to 1800 (30 minutes). */
+  readonly ttl?: number;
+  /** The longest `ttl` a start may ask for. Defaults to 14400 (4 hours). */
+  readonly maxTtl?: number;
+  /** Defaults to true. */
+  readonly requireReason?: boolean;
+  /**
+   * `always` (the default): every session is read-only. `default`: read-only
+   * unless the start passes `readOnly: false`.
+   */
+  readonly readOnly?: "always" | "default";
+}
+interface SupportAuthorizeInput {
+  readonly admin: UserAuth;
+  readonly targetUserId: string;
+  readonly reason: string;
+  readonly readOnly: boolean;
+  readonly tenant?: string;
+  readonly metadata: Readonly<Record<string, unknown>>;
+}
+interface SupportOptions {
+  readonly store: SupportSessionStore;
+  /**
+   * Whether `admin` may view the app as the target. A throw or rejection
+   * counts as a deny. Defaults to allowing, so the store decides: the SQL
+   * store checks `is_platform(kits.support-sessions.permissions.start)`.
+   */
+  readonly authorize?: (input: SupportAuthorizeInput) => boolean | Promise<boolean>;
+  /**
+   * The claims the target gets. Defaults to `store.claims` (the SQL store
+   * runs your custom access token hook), then `{ role: 'authenticated' }`.
+   */
+  readonly claims?: (targetUserId: string) => Readonly<Record<string, unknown>> | Promise<Readonly<Record<string, unknown>>>;
+  readonly policy?: SupportPolicy;
+  readonly cookie?: SupportCookieOptions;
+}
+interface SupportStartRequest {
+  readonly targetUserId: string;
+  readonly reason?: string;
+  /** Seconds; defaults to `policy.ttl`. */
+  readonly ttl?: number;
+  /** Honoured only with `policy.readOnly: 'default'`. */
+  readonly readOnly?: boolean;
+  readonly tenant?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** A running support session, as the request that carries its cookie sees it. */
+interface ActiveSupport {
+  readonly session: SupportSession;
+  /** The admin behind the session, from their own verified token. */
+  readonly admin: {
+    readonly id: string;
+    readonly email?: string;
+  };
+  /** The target's claims plus `act`, which repositories run with. */
+  readonly claims: Readonly<Record<string, unknown>>;
+}
+/** `bs.support`: start, stop and inspect support sessions. */
+interface SupportApi {
+  /**
+   * Starts a session for a signed-in admin and returns it with the
+   * `Set-Cookie` value that switches the admin's next requests to the target.
+   */
+  start(admin: AuthState, request: SupportStartRequest): AsyncResult<{
+    readonly session: SupportSession;
+    readonly cookie: string;
+  }>;
+  /** Ends the admin's own session and returns the `Set-Cookie` that clears the cookie. */
+  stop(admin: AuthState, sessionId: string): AsyncResult<{
+    readonly ended: boolean;
+    readonly cookie: string;
+  }>;
+  /**
+   * Ends a session as `caller`: the SQL store allows the session's admin and
+   * staff with the revoke permission.
+   */
+  revoke(caller: AuthState, sessionId: string): AsyncResult<boolean>;
+  /** The running session the request's cookie names for `auth`, if any. */
+  current(request: Request, auth: AuthState): Promise<ActiveSupport | undefined>;
+  /** The sessions `caller` may view (the SQL store checks the view permission). */
+  list(caller: AuthState, filter?: SupportListFilter): AsyncResult<readonly SupportSession[]>;
+  /** The support session id in a request's cookie. */
+  sessionIdOf(request: Request): string | undefined;
+  /** `Set-Cookie` that clears the support cookie. */
+  clearCookie(): string;
+}
+/** `ServerOptions.support`, from `supportSessions(options)`. */
+interface SupportSessions {
+  readonly options: SupportOptions;
+  /** Builds `bs.support`; `createServer` calls it once. */
+  readonly create: (events: EventHub, claimsSchema: StandardSchemaV1 | undefined) => SupportApi;
+}
+/**
+ * Support sessions for `createServer(betterSupabase, { support })`. Apps that
+ * never import it don't bundle the support code.
+ */
+declare function supportSessions(options: SupportOptions): SupportSessions;
+//#endregion
+//#region src/server/delete-account.d.ts
+interface DeleteAccountOptions {
+  /**
+   * Buckets to clear first. Objects whose `owner` placeholder (`{userId}`,
+   * or `owner.param` for `owner` buckets) is the user are removed; buckets
+   * without one are skipped.
+   */
+  readonly buckets?: readonly Bucket<string>[];
+  /**
+   * App keys of tables whose rows the database deletes or updates with the
+   * user (`on delete cascade` or `set null` to `auth.users`). They get a
+   * table-wide `mutation` notice, so caches drop their reads.
+   */
+  readonly cascades?: readonly string[];
+  readonly context?: RequestContext;
+  readonly signal?: AbortSignal;
+}
+interface DeleteAccountResult {
+  readonly userId: string;
+  /** Removed objects per bucket id. */
+  readonly removed: Readonly<Record<string, number>>;
+}
+//#endregion
+//#region src/server/replicas.d.ts
+/** Cookie holding the epoch ms until which reads stay on the primary. */
+declare const PRIMARY_COOKIE = "bs-primary-until";
+/** Where a request context sends its reads. */
+interface ReplicaState {
+  /** Reads go to the primary: this context wrote, or a recent request did. */
+  readonly pinned: boolean;
+  /** This context wrote through its repositories (or called `pin()`). */
+  readonly wrote: boolean;
+  /** Sends later reads to the primary, e.g. after a write through `$client` or `ctx.sql`. */
+  pin(): void;
+}
+//#endregion
+//#region src/server/server.d.ts
+interface ServerOptions {
+  /** Defaults to `loadEnv()`. */
+  readonly env?: BetterSupabaseEnv;
+  /** Enables `ctx.sql` and `actingAs()`. */
+  readonly postgres?: BetterPostgres;
+  readonly auth?: Omit<ResolveAuthOptions, "env">;
+  /**
+   * Fetch the JWKS when the server is created, so the first request verifies
+   * its token without waiting for it. Applies when neither `auth.jwks` nor
+   * `env.jwks` (`SUPABASE_JWKS`) holds the keys inline. Defaults to true, except under `NODE_ENV=test`.
+   */
+  readonly prefetchJwks?: boolean;
+  /**
+   * Extra headers on the caller's PostgREST requests, readable in Postgres as
+   * `current_setting('request.headers')` (channel, request id, client IP for audit).
+   */
+  readonly headers?: (request: Request) => Readonly<Record<string, string>>;
+  /**
+   * PostgREST URL for the caller's reads: a read replica or the `<ref>-all`
+   * load balancer. Defaults to `SUPABASE_READ_URL`; `false` reads from the
+   * primary.
+   */
+  readonly readUrl?: string | false;
+  /**
+   * `fetch` for the PostgREST and supabase-js clients, e.g. `tracedFetch()`
+   * from `better-supabase/otel`. Auth refreshes use `auth.fetch`.
+   */
+  readonly fetch?: typeof globalThis.fetch;
+  readonly replicas?: {
+    /** How long the next requests read from the primary after a write. Defaults to 5 s. */
+    readonly pinMs?: number;
+  };
+  /**
+   * The active tenant of a request when it doesn't come from a claim, e.g.
+   * from a URL slug (`kits.access.activeTenant: 'resolver'`). It becomes
+   * `context.tenant` for the `tenant()` plugin, the `better_supabase.tenant`
+   * setting over Postgres and the `x-bs-tenant` header over PostgREST, which
+   * `current_tenant_id()` reads only while the caller is a member. Async
+   * resolvers need `context(request)`; `contextFromResolution` takes
+   * `options.tenant` instead.
+   */
+  readonly tenant?: (request: Request, auth: AuthState) => string | undefined | PromiseLike<string | undefined>;
+  /**
+   * Support sessions ("view as user") from `supportSessions(options)`: a platform admin's requests that carry
+   * the support cookie run as the target user, read-only by default. Needs
+   * `postgres`, since the target's queries run over direct Postgres.
+   */
+  readonly support?: SupportSessions;
+}
+/** The header `current_tenant_id()` reads over the Data API. */
+declare const TENANT_HEADER = "x-bs-tenant";
+interface ServerContext<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> {
+  readonly auth: AuthState<C, P>;
+  readonly resolution: AuthResolution<C, P>;
+  /**
+   * supabase-js client scoped to the caller (RLS applies). Throws in a
+   * support session: Realtime, Storage and Auth would act as the admin.
+   */
+  readonly supabase: SupabaseClient;
+  /** Repositories over PostgREST as the caller. */
+  readonly db: Db<M, F, E, SupabaseClient>;
+  /** Repositories over direct Postgres as the caller, when `postgres` is configured. */
+  readonly sql: Db<M, F, E, undefined> | undefined;
+  /** Calls, waves, tables and time for `db` and `sql` together. */
+  stats(): DbStats;
+  /** Where `db` reads go, when a read URL is configured. */
+  readonly replica: ReplicaState | undefined;
+  /**
+   * `response` with this request's cookies: refreshed session cookies
+   * (`resolution.apply`) and, after a write, `bs-primary-until`.
+   */
+  apply(response: Response): Response;
+  /**
+   * Set while an admin views the app as another user: `auth`, `db` and
+   * `sql` are the target's, and `resolution` stays the admin's.
+   */
+  readonly support?: ActiveSupport;
+}
+interface ContextOptions {
+  readonly refresh?: boolean;
+  /** Read the session cookie. Defaults to true; `false` resolves bearer tokens only. */
+  readonly cookies?: boolean;
+  /** Epoch ms until which `db` reads from the primary (the `bs-primary-until` cookie). */
+  readonly pinnedUntil?: number;
+  /** Also records this context's calls into a request-wide recorder. */
+  readonly stats?: StatsRecorder;
+  /** The active tenant, instead of `ServerOptions.tenant`. */
+  readonly tenant?: string;
+  /**
+   * The request's support session, from `support.current()`. `context()`
+   * looks it up itself; `contextFromResolution` only uses this.
+   */
+  readonly support?: ActiveSupport;
+}
+interface BetterServer<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> {
+  readonly env: BetterSupabaseEnv;
+  resolve(request: Request, options?: {
+    readonly refresh?: boolean;
+    readonly cookies?: boolean;
+  }): Promise<AuthResolution<C, P>>;
+  /**
+   * Resolves auth and binds repositories to the caller. Refreshes an expired
+   * cookie session only with `refresh: true`; send `ctx.apply(response)`.
+   */
+  context(request: Request, options?: ContextOptions): Promise<ServerContext<M, F, E, C, P>>;
+  /**
+   * The context for a resolution from `resolve(request)`, so one resolution
+   * can back several contexts without verifying the token again.
+   */
+  contextFromResolution(resolution: AuthResolution<C, P>, request: Request, options?: Omit<ContextOptions, "refresh">): ServerContext<M, F, E, C, P>;
+  /** The context for an auth state resolved elsewhere (the proxy, a queue message). */
+  contextFor(auth: AuthState<C, P>, options?: ContextOptions): ServerContext<M, F, E, C, P>;
+  /** A stateless supabase-js client for an auth state, optionally with extra request headers. */
+  supabaseFor(auth: AuthState, headers?: Readonly<Record<string, string>>): SupabaseClient;
+  /** Repositories for an auth state (e.g. one resolved by the proxy). */
+  dbFor(auth: AuthState, context?: RequestContext): Db<M, F, E, SupabaseClient>;
+  /** Service-role repositories. Bypasses RLS; the actor is `service`. */
+  admin(context?: RequestContext): Db<M, F, E, SupabaseClient>;
+  /**
+   * Deletes a user: their objects in `buckets`, then the Auth user, then a
+   * `mutation` notice for `auth.users`. Needs the secret key. Access tokens
+   * already issued stay valid until they expire.
+   */
+  deleteAccount(userId: string, options?: DeleteAccountOptions): AsyncResult<DeleteAccountResult>;
+  /**
+   * Repositories running as a user, with RLS, over direct Postgres. With
+   * `impersonation`, the claims carry `act: { sub: actor, reason }`, which
+   * the `audit` and `actor` SQL kit modules record.
+   */
+  actingAs(userId: string, claims?: Omit<SqlClaims, "sub" | "act">, impersonation?: ImpersonationOptions): Db<M, F, E, undefined>;
+  /** Support sessions; every method fails without `ServerOptions.support`. */
+  readonly support: SupportApi;
+}
+/**
+ * Server-side entry point for APIs, jobs, MCP servers and framework
+ * adapters. Holds the secrets; `betterSupabase` stays isomorphic.
+ */
+declare function createServer<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: ServerOptions): BetterServer<M, F, E, C, P>;
+//#endregion
+//#region src/server/respond.d.ts
+type AuthKind = AuthState["kind"];
+/** An auth kind a guard lets through; `anonymous` admits `signInAnonymously()` users. */
+type AllowedCaller = Exclude<AuthKind, "invalid"> | "anonymous";
+interface GuardOptions {
+  /**
+   * Callers allowed through. Defaults to `['user']`, which refuses anonymous
+   * users (`is_anonymous`); add `'anonymous'` (or `'anon'`) to admit 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) 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.
+   */
+  readonly refresh?: boolean;
+}
+/** `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 { clearSupportCookie as A, SupportOptions as C, supportSessions as D, SupportStartRequest as E, supportCookieValue as M, SUPPORT_COOKIE as O, SupportAuthorizeInput as S, SupportSessions as T, ReplicaState as _, Settled as a, ActiveSupport as b, respond as c, ContextOptions as d, ServerContext as f, PRIMARY_COOKIE as g, createServer as h, RespondOptions as i, supportCookie as j, SupportCookieOptions as k, settle as l, TENANT_HEADER as m, GuardOptions as n, guard as o, ServerOptions as p, MiddlewareOptions as r, isResult as s, AuthKind as t, BetterServer as u, DeleteAccountOptions as v, SupportPolicy as w, SupportApi as x, DeleteAccountResult as y };

package/dist/{result-DWXatkd6.js → result-BKiliPY7.js}

@@ -1,4 +1,4 @@
-import { n as dbError, r as dbErrorOf, t as DbException } from "./errors-Bl3rkOzo.js";
+import { n as dbError, r as dbErrorOf, t as DbException } from "./errors-DtwXa6b8.js";
 //#region src/core/result.ts
 const throwMappers = /* @__PURE__ */ new WeakMap();
 function inherit(from, next) {
@@ -49,7 +49,7 @@ var AsyncResult = class AsyncResult {
 	/**
 	* 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.
+	* without it, the mapper from `betterSupabase.mapError()` applies when one is set.
 	*/
 	async orThrow(factory) {
 		const result = await this.#promise;

package/dist/server/index.d.ts

@@ -1,14 +1,16 @@
-import { n as AnyModels, t as AnyFunctions } from "../types-DONv9SHN.js";
-import { p as DbError } from "../result-c2OYgCV2.js";
-import { t as BetterSupabase, y as Db } from "../define-DUbydmJa.js";
-import { h as RequestContext } from "../plugin-DVRB8qNE.js";
-import { a as checkAal, c as impersonatorOf, i as amrOf, n as AmrEntry, o as ImpersonationOptions, r as aalOf, s as Impersonator, t as Aal } from "../mfa-x3V3vGh-.js";
-import { _ as readSession, a as ResolveAuthOptions, b as writeSession, c as clientIp, d as CookieOptions, f as CookieRecord, i as InvalidReason, l as resolveAuth, m as StoredSession, n as AuthResolver, o as ResolvedState, p as CookieWrite, r as AuthState, s as authContext, t as AuthResolution, u as AUTH_CACHE_HEADERS, y as sessionCookieName } from "../resolve-BRciX2jK.js";
-import { _ as DeleteAccountResult, a as guard, c as settle, d as ServerContext, f as ServerOptions, g as DeleteAccountOptions, h as ReplicaState, i as Settled, l as BetterServer, m as PRIMARY_COOKIE, n as GuardOptions, o as isResult, p as createServer, r as RespondOptions, s as respond, t as AuthKind, u as ContextOptions } from "../respond-DAkPIdTH.js";
-import { a as ResourceRouteOptions, i as ResourcePagination, n as ResourceInput, o as defineResource, r as ResourceList, t as ResourceHandler } from "../resource-CwVgiI5q.js";
-import { a as ProblemResponseOptions, c as problemResponse, i as ProblemOptions, l as toProblem, n as PROBLEM_TYPE_BASE, o as fromProblem, r as ProblemDetails, s as isProblem, t as PROBLEM_CONTENT_TYPE } from "../problem-Z2RTQjZD.js";
-import { a as SessionDelegation, i as SessionActor, n as toSession, r as ActClaim, t as AuthSession } from "../view-3Po_PVlr.js";
-import { n as RefreshOutcome, r as refreshSession } from "../index-kpgopLNv.js";
+import { n as AnyFunctions, r as AnyModels } from "../types-Dnf_wRDz.js";
+import { _ as DbError } from "../executor-BunPOO-k.js";
+import { t as BetterSupabase, y as Db } from "../define-Bp_BZa5h.js";
+import { g as RequestContext } from "../plugin-o144f322.js";
+import { _ as readSession, a as ResolveAuthOptions, b as writeSession, c as clientIp, d as CookieOptions, f as CookieRecord, i as InvalidReason, l as resolveAuth, m as StoredSession, n as AuthResolver, o as ResolvedState, p as CookieWrite, r as AuthState, s as authContext, t as AuthResolution, u as AUTH_CACHE_HEADERS, y as sessionCookieName } from "../resolve-C15TJq77.js";
+import { a as SupportSession, c as sqlSupportStore, i as SupportListFilter, l as supportClaims, n as SupportCallerClaims, o as SupportSessionStore, r as SupportEndedBy, s as SupportStartInput, t as SqlSupportStoreOptions } from "../support-DT-OhSxD.js";
+import { A as clearSupportCookie, C as SupportOptions, D as supportSessions, E as SupportStartRequest, M as supportCookieValue, O as SUPPORT_COOKIE, S as SupportAuthorizeInput, T as SupportSessions, _ as ReplicaState, a as Settled, b as ActiveSupport, c as respond, d as ContextOptions, f as ServerContext, g as PRIMARY_COOKIE, h as createServer, i as RespondOptions, j as supportCookie, k as SupportCookieOptions, l as settle, m as TENANT_HEADER, n as GuardOptions, o as guard, p as ServerOptions, r as MiddlewareOptions, s as isResult, t as AuthKind, u as BetterServer, v as DeleteAccountOptions, w as SupportPolicy, x as SupportApi, y as DeleteAccountResult } from "../respond-D2OQl62-.js";
+import { a as checkAal, c as impersonatorOf, i as amrOf, n as AmrEntry, o as ImpersonationOptions, r as aalOf, s as Impersonator, t as Aal } from "../mfa-CusDgPaD.js";
+import { a as ResourceRouteOptions, i as ResourcePagination, n as ResourceInput, o as defineResource, r as ResourceList, t as ResourceHandler } from "../resource-D8iqWMr-.js";
+import { a as ProblemResponseOptions, c as problemResponse, i as ProblemOptions, l as toProblem, n as PROBLEM_TYPE_BASE, o as fromProblem, r as ProblemDetails, s as isProblem, t as PROBLEM_CONTENT_TYPE } from "../problem-Blxe8S31.js";
+import { a as SessionDelegation, i as SessionActor, n as toSession, r as ActClaim, t as AuthSession } from "../view-BEf0diC5.js";
+import { n as supportOf, t as SupportView } from "../support-view-Da5peKFg.js";
+import { n as RefreshOutcome, r as refreshSession } from "../refresh-BTrQ_ZTp.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Middleware } from "@supabase/middleware";
 import { AuthMode, JWTClaims, UserClaims } from "@supabase/server";
@@ -27,17 +29,17 @@ export declare function contextFromSupabase(ctx: SupabaseAuthContext): RequestCo
  * `ctx.supabase` (the caller-scoped client from `withSupabase`).
  *
  * ```ts
- * pipeline([withSupabase({ auth: 'user' }), withBetterSupabase(sb)()], (req, ctx) => ...)
+ * pipeline([withSupabase({ auth: 'user' }), withBetterSupabase(betterSupabase)()], (req, ctx) => ...)
  * ```
  */
-export declare function withBetterSupabase<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>): Middleware<"db", void, SupabaseAuthContext & {
+export declare function withBetterSupabase<M extends AnyModels, D, F extends AnyFunctions, E>(betterSupabase: BetterSupabase<M, D, F, E>): Middleware<"db", void, SupabaseAuthContext & {
   readonly supabase: SupabaseClient;
 }, Db<M, F, E, SupabaseClient>>;
 /**
  * Entry contributing `ctx.sql`: repositories over `ctx.postgres` from
  * `withPostgresClient`, which runs each query as the caller with RLS.
  */
-export declare function withBetterPostgres<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>): Middleware<"sql", void, SupabaseAuthContext & {
+export declare function withBetterPostgres<M extends AnyModels, D, F extends AnyFunctions, E>(betterSupabase: BetterSupabase<M, D, F, E>): Middleware<"sql", void, SupabaseAuthContext & {
   readonly postgres: PostgresApi;
 }, Db<M, F, E, undefined>>;
 //#endregion
@@ -64,4 +66,4 @@ export declare function checkSession(sql: SessionLookup, auth: {
   readonly kind: string;
 }): Promise<DbError | undefined>;
 //#endregion
-export { AUTH_CACHE_HEADERS, type Aal, type ActClaim, type AmrEntry, type AuthKind, type AuthResolution, type AuthResolver, type AuthSession, type AuthState, type BetterServer, type ContextOptions, type CookieOptions, type CookieRecord, type CookieWrite, type DeleteAccountOptions, type DeleteAccountResult, type GuardOptions, type ImpersonationOptions, type Impersonator, type InvalidReason, PRIMARY_COOKIE, PROBLEM_CONTENT_TYPE, PROBLEM_TYPE_BASE, type ProblemDetails, type ProblemOptions, type ProblemResponseOptions, type RefreshOutcome, type ReplicaState, type ResolveAuthOptions, type ResolvedState, type ResourceHandler, type ResourceInput, type ResourceList, type ResourcePagination, type ResourceRouteOptions, type RespondOptions, type ServerContext, type ServerOptions, type SessionActor, type SessionDelegation, type SessionLookup, type Settled, type StoredSession, type SupabaseAuthContext, aalOf, amrOf, authContext, checkAal, clientIp, createServer, defineResource, fromProblem, guard, impersonatorOf, isProblem, isResult, problemResponse, readSession, refreshSession, resolveAuth, respond, sessionCookieName, settle, toProblem, toSession, writeSession };
+export { AUTH_CACHE_HEADERS, type Aal, type ActClaim, type ActiveSupport, type AmrEntry, type AuthKind, type AuthResolution, type AuthResolver, type AuthSession, type AuthState, type BetterServer, type ContextOptions, type CookieOptions, type CookieRecord, type CookieWrite, type DeleteAccountOptions, type DeleteAccountResult, type GuardOptions, type ImpersonationOptions, type Impersonator, type InvalidReason, type MiddlewareOptions, PRIMARY_COOKIE, PROBLEM_CONTENT_TYPE, PROBLEM_TYPE_BASE, type ProblemDetails, type ProblemOptions, type ProblemResponseOptions, type RefreshOutcome, type ReplicaState, type ResolveAuthOptions, type ResolvedState, type ResourceHandler, type ResourceInput, type ResourceList, type ResourcePagination, type ResourceRouteOptions, type RespondOptions, SUPPORT_COOKIE, type ServerContext, type ServerOptions, type SessionActor, type SessionDelegation, type SessionLookup, type Settled, type SqlSupportStoreOptions, type StoredSession, type SupabaseAuthContext, type SupportApi, type SupportAuthorizeInput, type SupportCallerClaims, type SupportCookieOptions, type SupportEndedBy, type SupportListFilter, type SupportOptions, type SupportPolicy, type SupportSession, type SupportSessionStore, type SupportSessions, type SupportStartInput, type SupportStartRequest, type SupportView, TENANT_HEADER, aalOf, amrOf, authContext, checkAal, clearSupportCookie, clientIp, createServer, defineResource, fromProblem, guard, impersonatorOf, isProblem, isResult, problemResponse, readSession, refreshSession, resolveAuth, respond, sessionCookieName, settle, sqlSupportStore, supportClaims, supportCookie, supportCookieValue, supportOf, supportSessions, toProblem, toSession, writeSession };

package/dist/server/index.js

@@ -1,10 +1,12 @@
-import { n as dbError } from "../errors-Bl3rkOzo.js";
-import { a as problemResponse, i as isProblem, n as PROBLEM_TYPE_BASE, o as toProblem, r as fromProblem, t as PROBLEM_CONTENT_TYPE } from "../problem-CGt1ADix.js";
-import { a as settle, i as respond, n as guard, o as createServer, r as isResult, u as PRIMARY_COOKIE } from "../respond-C44EZAJo.js";
-import { a as clientIp, f as sessionCookieName, i as authContext, m as refreshSession, n as amrOf, o as resolveAuth, p as writeSession, r as checkAal, s as AUTH_CACHE_HEADERS, t as aalOf, u as readSession, v as impersonatorOf } from "../mfa-BxoR1RkN.js";
-import { n as postgresExecutor } from "../executor-C57jx2pn.js";
-import { t as toSession } from "../view-wZ-9qIUz.js";
-import { t as defineResource } from "../resource-D30rp0GN.js";
+import { n as dbError } from "../errors-DtwXa6b8.js";
+import { a as problemResponse, i as isProblem, n as PROBLEM_TYPE_BASE, o as toProblem, r as fromProblem, t as PROBLEM_CONTENT_TYPE } from "../problem-BW1KhzSG.js";
+import { n as impersonatorOf, r as userContext } from "../impersonation-VfaGc4Q_.js";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
+import { c as supportCookie, d as guard, f as isResult, l as supportCookieValue, m as settle, n as createServer, o as SUPPORT_COOKIE, p as respond, s as clearSupportCookie, t as TENANT_HEADER, v as PRIMARY_COOKIE } from "../server-Csx2sRjg.js";
+import { _ as writeSession, a as checkAal, d as AUTH_CACHE_HEADERS, g as sessionCookieName, i as amrOf, m as readSession, n as toSession, o as authContext, r as aalOf, s as clientIp, u as resolveAuth, v as refreshSession } from "../view-Bq64ki8-.js";
+import { n as sqlSupportStore, r as supportClaims, t as supportSessions } from "../support-Dk6vdmEw.js";
+import { n as postgresExecutor } from "../executor-XycESQPH.js";
+import { t as defineResource } from "../resource-CRxxwkQq.js";
 import { defineMiddleware } from "@supabase/middleware";
 //#region src/server/middleware.ts
 /** Repository context from a `@supabase/server` context. */
@@ -12,15 +14,7 @@ function contextFromSupabase(ctx) {
 	switch (ctx.authMode) {
 		case "user":
 			if (!ctx.userClaims) break;
-			return {
-				actor: {
-					id: ctx.userClaims.id,
-					kind: "user",
-					...ctx.userClaims.role === void 0 ? {} : { role: ctx.userClaims.role },
-					...ctx.userClaims.email === void 0 ? {} : { email: ctx.userClaims.email }
-				},
-				claims: ctx.jwtClaims ?? {}
-			};
+			return userContext(ctx.userClaims, ctx.jwtClaims ?? {});
 		case "secret": return {
 			actor: {
 				id: "service",
@@ -50,23 +44,23 @@ function contextFromSupabase(ctx) {
 * `ctx.supabase` (the caller-scoped client from `withSupabase`).
 *
 * ```ts
-* pipeline([withSupabase({ auth: 'user' }), withBetterSupabase(sb)()], (req, ctx) => ...)
+* pipeline([withSupabase({ auth: 'user' }), withBetterSupabase(betterSupabase)()], (req, ctx) => ...)
 * ```
 */
-function withBetterSupabase(sb) {
+function withBetterSupabase(betterSupabase) {
 	return defineMiddleware({
 		key: "db",
-		run: (_config) => (_req, ctx) => Promise.resolve({ db: sb.connect(ctx.supabase, contextFromSupabase(ctx)) })
+		run: (_config) => (_req, ctx) => Promise.resolve({ db: betterSupabase.connect(ctx.supabase, contextFromSupabase(ctx)) })
 	});
 }
 /**
 * Entry contributing `ctx.sql`: repositories over `ctx.postgres` from
 * `withPostgresClient`, which runs each query as the caller with RLS.
 */
-function withBetterPostgres(sb) {
+function withBetterPostgres(betterSupabase) {
 	return defineMiddleware({
 		key: "sql",
-		run: (_config) => (_req, ctx) => Promise.resolve({ sql: sb.connect(postgresExecutor(ctx.postgres), contextFromSupabase(ctx)) })
+		run: (_config) => (_req, ctx) => Promise.resolve({ sql: betterSupabase.connect(postgresExecutor(ctx.postgres), contextFromSupabase(ctx)) })
 	});
 }
 //#endregion
@@ -94,4 +88,4 @@ async function checkSession(sql, auth) {
 	return row?.active === true ? void 0 : revoked;
 }
 //#endregion
-export { AUTH_CACHE_HEADERS, PRIMARY_COOKIE, PROBLEM_CONTENT_TYPE, PROBLEM_TYPE_BASE, aalOf, amrOf, authContext, checkAal, checkSession, clientIp, contextFromSupabase, createServer, defineResource, fromProblem, guard, impersonatorOf, isProblem, isResult, problemResponse, readSession, refreshSession, resolveAuth, respond, sessionCookieName, settle, toProblem, toSession, withBetterPostgres, withBetterSupabase, writeSession };
+export { AUTH_CACHE_HEADERS, PRIMARY_COOKIE, PROBLEM_CONTENT_TYPE, PROBLEM_TYPE_BASE, SUPPORT_COOKIE, TENANT_HEADER, aalOf, amrOf, authContext, checkAal, checkSession, clearSupportCookie, clientIp, contextFromSupabase, createServer, defineResource, fromProblem, guard, impersonatorOf, isProblem, isResult, problemResponse, readSession, refreshSession, resolveAuth, respond, sessionCookieName, settle, sqlSupportStore, supportClaims, supportCookie, supportCookieValue, supportOf, supportSessions, toProblem, toSession, withBetterPostgres, withBetterSupabase, writeSession };