better-supabase 0.7.1 → 0.9.0

package/dist/server-Bh0EVSwU.d.ts

@@ -1,558 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { t as AsyncResult } from "./result-D7y2fT87.js";
-import { a as AnyModels, i as AnyFunctions } from "./types-6BdhkmZe.js";
-import { t as SqlClient } from "./executor-DbvExCFC.js";
-import { m as RequestContext } from "./plugin-FGY8UhYm.js";
-import { a as EventHub } from "./events-DWDhx77e.js";
-import { t as BetterSupabaseEnv } from "./index-CLg87OBW.js";
-import { a as CookieWrite } from "./session-ChiXDZdZ.js";
-import { a as ResolveAuthOptions, r as AuthState, t as AuthResolution } from "./resolve-ChTYeTEl.js";
-import { r as CredentialProvider } from "./provider-D-UEMvSD.js";
-import { B as DbStats, H as StatsRecorder, b as Db, t as BetterSupabase } from "./define-CJJkkr1-.js";
-import { r as EventSink } from "./cloud-event-C1JCc1bH.js";
-import { s as SqlClaims, t as BetterPostgres } from "./pool-CAu2nLrL.js";
-import { o as ImpersonationOptions } from "./mfa-Daak8ukG.js";
-import { n as Bucket } from "./bucket-Cl46E3jS.js";
-import { SupabaseClient } from "@supabase/supabase-js";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/auth/support.d.ts
-type SupportEndedBy = "admin" | "expired" | "revoked";
-/** A support session: a platform admin viewing the app as `targetUserId`. */
-interface SupportSession {
-  readonly id: string;
-  readonly adminId: string;
-  readonly targetUserId: string;
-  readonly reason: string;
-  /** Writes fail while it is true (`begin read only`). */
-  readonly readOnly: boolean;
-  readonly tenant?: string;
-  readonly startedAt: Temporal.Instant;
-  readonly expiresAt: Temporal.Instant;
-  readonly endedAt?: Temporal.Instant;
-  readonly endedBy?: SupportEndedBy;
-  /** App data, such as a ticket id. */
-  readonly metadata: Readonly<Record<string, unknown>>;
-}
-interface SupportStartInput {
-  readonly adminId: string;
-  /**
-   * The admin's verified claims. The SQL store runs `start_support_session`
-   * with them, so `is_platform()` checks the admin in the database too.
-   */
-  readonly adminClaims: Readonly<Record<string, unknown>>;
-  readonly targetUserId: string;
-  readonly reason: string;
-  readonly ttlSeconds: number;
-  readonly readOnly: boolean;
-  readonly tenant?: string;
-  readonly metadata: Readonly<Record<string, unknown>>;
-}
-/** A caller's verified claims, which the store runs a call with. */
-type SupportCallerClaims = Readonly<Record<string, unknown>>;
-interface SupportListFilter {
-  readonly adminId?: string;
-  readonly targetUserId?: string;
-  /** `true`: running sessions only; `false`: ended or expired ones only. */
-  readonly active?: boolean;
-  /** Defaults to 50. */
-  readonly limit?: number;
-}
-/**
- * Where support sessions live. `sqlSupportStore` uses the `support-sessions`
- * SQL module; implement this for another store and check it with
- * `testSupportSessionStore` from `better-supabase/testing`.
- */
-interface SupportSessionStore {
-  readonly apiVersion: 1;
-  readonly name: string;
-  /** Starts a session and ends the admin's previous one. Rejects when the store refuses. */
-  start(input: SupportStartInput): Promise<SupportSession>;
-  /**
-   * The admin's session while it is running; `undefined` once ended or
-   * expired. With the admin's `claims`, the store also checks that the admin
-   * may still start sessions.
-   */
-  get(sessionId: string, adminId: string, claims?: SupportCallerClaims): Promise<SupportSession | undefined>;
-  /**
-   * `false` when it was not running. With `claims`, it runs as that caller:
-   * the session's admin, or staff with the revoke permission.
-   */
-  end(sessionId: string, endedBy: SupportEndedBy, claims?: SupportCallerClaims): Promise<boolean>;
-  /** With `claims`, only what that caller may view. */
-  list(filter?: SupportListFilter, claims?: SupportCallerClaims): Promise<readonly SupportSession[]>;
-  /** The claims `targetUserId` would get, when the store can build them. */
-  claims?(targetUserId: string): Promise<Readonly<Record<string, unknown>>>;
-}
-interface SqlSupportStoreOptions {
-  /** `sql.modules.support-sessions.schema`. Defaults to `better_supabase`. */
-  readonly schema?: string;
-}
-/**
- * Support sessions in the `support-sessions` SQL module. `start` runs
- * as the admin, so the module's `is_platform()` gate applies; the reads run
- * on the admin connection.
- */
-declare function sqlSupportStore(postgres: Pick<BetterPostgres, "admin" | "asUser">, options?: SqlSupportStoreOptions): SupportSessionStore;
-/**
- * The claims a support session runs with: the target's, plus `act` naming
- * the admin, the reason and the session (the audit module records all three),
- * marked `kind: "support"` so `actorOf` never reads it as an OAuth client.
- * `role` falls back to `authenticated`; the admin's claims never leak in.
- */
-declare function supportClaims(session: Pick<SupportSession, "id" | "adminId" | "targetUserId" | "reason" | "readOnly">, target: Readonly<Record<string, unknown>>): Record<string, unknown>;
-//#endregion
-//#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(modules.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;
-  /**
-   * Direct Postgres with rights on `auth.users` (`postgres.admin`). When the
-   * Auth server reports a database error, the delete is replayed in a
-   * statement that is rolled back, and the database's own error (its
-   * SQLSTATE and hint, such as `ORGANIZATION_OWNER_REQUIRED`) is returned
-   * instead of Auth's generic one. `server.deleteAccount` passes its
-   * `postgres.admin`.
-   */
-  readonly sql?: SqlClient;
-}
-interface DeleteAccountResult {
-  readonly userId: string;
-  /** Removed objects per bucket id. */
-  readonly removed: Readonly<Record<string, number>>;
-}
-/**
- * Deletes the Auth user, then removes their Storage objects, then announces
- * the delete. Rows referencing `auth.users` follow their foreign keys. The
- * objects are listed first and removed only once the user is gone, so a
- * delete the database refuses leaves them in place.
- *
- * `server.deleteAccount` calls it with the server's service client. Apps on
- * the `@supabase/server` pipeline call it with theirs:
- * `deleteAccount(betterSupabase, ctx.supabaseAdmin, userId)`.
- */
-declare function deleteAccount<M extends AnyModels, D, F extends AnyFunctions, E, C>(betterSupabase: BetterSupabase<M, D, F, E, C>, service: SupabaseClient | (() => SupabaseClient), userId: string, options?: DeleteAccountOptions): AsyncResult<DeleteAccountResult>;
-//#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/request-ids.d.ts
-interface RequestIdOptions {
-  readonly requestHeader?: string;
-  readonly correlationHeader?: string;
-  readonly incoming?: boolean;
-  readonly generate?: boolean;
-}
-//#endregion
-//#region src/server/suspend-account.d.ts
-interface EndSessionsResult {
-  readonly userId: string;
-  readonly ended: number;
-}
-interface SuspendAccountOptions {
-  readonly suspended: boolean;
-  /** A Go duration for the ban, such as `"24h"`. Defaults to 100 years. */
-  readonly duration?: string;
-  /**
-   * Also end the sessions when suspending. Defaults to `false`: the sessions
-   * stay, so Auth answers refresh and `/user` with `user_banned` and the app
-   * can show why. Without the `sessions` SQL module, an access token keeps
-   * working against the Data API until it expires; set this to end the
-   * sessions at once instead.
-   */
-  readonly endSessions?: boolean;
-}
-interface SuspendAccountResult {
-  readonly userId: string;
-  readonly suspended: boolean;
-  /**
-   * The sessions deleted: `0` on a suspension (unless `endSessions` is set),
-   * and the user's remaining sessions when the ban is lifted.
-   */
-  readonly ended: number;
-}
-declare function endSessions(sql: SqlClient, userId: string): AsyncResult<EndSessionsResult>;
-interface LastSignIn {
-  readonly userId: string;
-  /** `null` for a user who never signed in. */
-  readonly lastSignInAt: Temporal.Instant | null;
-}
-/**
- * The last sign-in of each user, in one query (`better_supabase.last_sign_ins`
- * from the `sessions` module, which only the service role may call). Users
- * that don't exist are missing from the map.
- */
-declare function lastSignIns(sql: SqlClient, userIds: readonly string[]): AsyncResult<ReadonlyMap<string, LastSignIn>>;
-declare function suspendAccount(service: SupabaseClient | (() => SupabaseClient), sql: SqlClient, userId: string, options: SuspendAccountOptions): AsyncResult<SuspendAccountResult>;
-//#endregion
-//#region src/server/server.d.ts
-/**
- * PostgREST request settings for the caller's repositories and the shared
- * service and anon clients, the `db` options supabase-js takes.
- */
-interface ServerDbOptions {
-  /** Aborts each PostgREST request after this many milliseconds with a `timeout` error. */
-  readonly timeout?: number;
-  /**
-   * postgrest-js retries of idempotent requests (GET and HEAD) on network
-   * errors, 503 and 520. Defaults to postgrest-js's setting, which is on.
-   */
-  readonly retry?: boolean;
-  /**
-   * The longest query string one read sends. Defaults to the definition's
-   * `urlLengthLimit`, else 6000.
-   */
-  readonly urlLengthLimit?: number;
-}
-interface ServerOptions {
-  /**
-   * Defaults to the variables `getEnv` from `@supabase/middleware` reads:
-   * Workers bindings, then `process.env`, then `Deno.env`.
-   */
-  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>>;
-  readonly requestIds?: RequestIdOptions | false;
-  /**
-   * 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 (`sql.modules.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. Under `createNext`, Server Components and
-   * actions pass a request with the incoming headers and a placeholder URL,
-   * so read a header there, not the path.
-   */
-  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 claims `forContext()` adds for a user, the ones a custom access token
-   * hook would put in their token (roles, organization lists). Read them
-   * fresh: a job can run after the user lost access. `sub`, `role`, `act` and
-   * `tenant_id` come from the context and win.
-   */
-  readonly claimsFor?: (userId: string, context: RequestContext) => SqlClaims | PromiseLike<SqlClaims>;
-  /** PostgREST request settings: `timeout`, `retry` and `urlLengthLimit`. */
-  readonly db?: ServerDbOptions;
-  /**
-   * Resolves the `credential_ref`s third-party calls use, e.g.
-   * `vaultCredentials()` from `better-supabase/credentials`. It becomes
-   * `ctx.credentials`; pass `subjectFor(ctx)` as the subject.
-   */
-  readonly credentials?: CredentialProvider;
-  /**
-   * Where the server's audit trail goes, such as `audit.sink()` from
-   * `better-supabase/blocks/audit`. `suspendAccount`, `deleteAccount` and
-   * `endSessions` send `dev.better-supabase.account.*` CloudEvents, and
-   * `support.denied` events are forwarded. A failed send is logged and never
-   * fails the action.
-   */
-  readonly audit?: EventSink;
-}
-interface ForContextOptions {
-  /** Recorded as `act.reason` when the context carries an impersonator. Defaults to `"job"`. */
-  readonly reason?: string;
-}
-/** 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;
-  /**
-   * The cookies `apply` would set, for frameworks that write cookies through
-   * a cookie store instead of a response (`cookies().set`, `setResponseHeaders`).
-   * Read it after the handler ran: a write adds `bs-primary-until`.
-   */
-  cookies(): readonly CookieWrite[];
-  /**
-   * 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;
-  /** `options.credentials`, when the server has one. */
-  readonly credentials?: CredentialProvider;
-  readonly requestId?: string;
-  readonly correlationId?: string;
-}
-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;
-  readonly requestId?: string;
-  readonly correlationId?: string;
-}
-interface BetterServer<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> {
-  readonly env: BetterSupabaseEnv;
-  /** The definition's events; adapters pass `events.settled()` to `waitUntil`. */
-  readonly events: EventHub;
-  resolve(request: Request, options?: {
-    readonly refresh?: boolean;
-    readonly cookies?: boolean;
-    readonly checkSession?: 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: the Auth user, then their objects in `buckets`, then a
-   * `mutation` notice for `auth.users`. Needs the secret key. With
-   * `postgres`, a delete the database refuses returns its own error and
-   * hint. Access tokens already issued stay valid until they expire.
-   */
-  deleteAccount(userId: string, options?: DeleteAccountOptions): AsyncResult<DeleteAccountResult>;
-  endSessions(userId: string): AsyncResult<EndSessionsResult>;
-  /**
-   * Bans the user in Auth and keeps their sessions, so Auth answers with
-   * `user_banned` (`endSessions: true` deletes them too). Lifting the ban
-   * ends the sessions first, so the user signs in again.
-   */
-  suspendAccount(userId: string, options: SuspendAccountOptions): AsyncResult<SuspendAccountResult>;
-  /**
-   * Repositories running as a user, with RLS, over direct Postgres. With
-   * `impersonation`, the claims carry `act: { kind: "impersonation", sub, reason }`, which
-   * the `audit` and `actor` SQL modules record.
-   */
-  actingAs(userId: string, claims?: Omit<SqlClaims, "sub" | "act">, impersonation?: ImpersonationOptions): Db<M, F, E, undefined>;
-  /**
-   * Repositories for the user in a recorded context (`job.context`), with
-   * RLS, over direct Postgres: `actingAs` with the context's tenant and
-   * `ServerOptions.claimsFor`. Fails with `forbidden` when the actor is not a
-   * user; it never falls back to `admin()`.
-   */
-  forContext(context: RequestContext, options?: ForContextOptions): AsyncResult<Db<M, F, E, undefined>>;
-  /** Support sessions; every method fails without `ServerOptions.support`. */
-  readonly support: SupportApi;
-}
-type ServerKeys = keyof BetterServer<AnyModels, AnyFunctions, unknown>;
-/**
- * A framework adapter's server: `server` plus the adapter's own methods,
- * without reading the lazy `env` getter. `extra` can't replace a
- * `BetterServer` method.
- */
-declare function extendServer<R extends object>(server: object, extra: Omit<R, ServerKeys>): R;
-/**
- * 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
-export { supportSessions as A, SupportSession as B, ActiveSupport as C, SupportPolicy as D, SupportOptions as E, supportCookieValue as F, SupportStartInput as H, SqlSupportStoreOptions as I, SupportCallerClaims as L, SupportCookieOptions as M, clearSupportCookie as N, SupportSessions as O, supportCookie as P, SupportEndedBy as R, deleteAccount as S, SupportAuthorizeInput as T, sqlSupportStore as U, SupportSessionStore as V, supportClaims as W, RequestIdOptions as _, ServerDbOptions as a, DeleteAccountOptions as b, createServer as c, LastSignIn as d, SuspendAccountOptions as f, suspendAccount as g, lastSignIns as h, ServerContext as i, SUPPORT_COOKIE as j, SupportStartRequest as k, extendServer as l, endSessions as m, ContextOptions as n, ServerOptions as o, SuspendAccountResult as p, ForContextOptions as r, TENANT_HEADER as s, BetterServer as t, EndSessionsResult as u, PRIMARY_COOKIE as v, SupportApi as w, DeleteAccountResult as x, ReplicaState as y, SupportListFilter as z };

package/dist/session-ChiXDZdZ.d.ts

@@ -1,72 +0,0 @@
-import { CookieOptions } from "@supabase/ssr";
-//#region src/auth/session.d.ts
-/**
- * The session object auth-js persists (`sb-<ref>-auth-token`). A
- * `tokens-only` cookie has no `user`: auth-js keeps it in `auth.userStorage`.
- */
-interface StoredSession {
-  readonly access_token: string;
-  readonly refresh_token: string;
-  readonly expires_at?: number;
-  readonly expires_in?: number;
-  readonly token_type?: string;
-  readonly user?: unknown;
-  readonly [key: string]: unknown;
-}
-/**
- * `cookies.encode` in `@supabase/ssr`: `user-and-tokens` stores the user
- * object in the cookie, `tokens-only` stores the access and refresh tokens
- * alone. The server and the browser client must use the same value.
- */
-type SessionEncoding = "user-and-tokens" | "tokens-only";
-declare const DEFAULT_SESSION_ENCODING: SessionEncoding;
-interface WriteSessionOptions {
-  /** Defaults to `user-and-tokens`, the `@supabase/ssr` default. */
-  readonly encode?: SessionEncoding;
-}
-/** A cookie scope an earlier deploy wrote the session at. */
-interface CookieScope {
-  readonly domain?: string;
-  readonly path?: string;
-}
-interface CookieRecord {
-  readonly name: string;
-  readonly value: string;
-}
-interface CookieWrite {
-  readonly name: string;
-  readonly value: string;
-  readonly options: CookieOptions;
-}
-/** Headers that keep responses carrying session cookies out of shared caches. */
-declare const AUTH_CACHE_HEADERS: Readonly<Record<string, string>>;
-/** `sb-<first label of the hostname>-auth-token`, the supabase-js default. */
-declare function sessionCookieName(url: string): string;
-declare function parseCookies(header: string | null | undefined): CookieRecord[];
-declare function serializeCookie(write: CookieWrite): string;
-/**
- * Reads the session written by `@supabase/ssr` (plain or `base64-`, whole or
- * chunked, `user-and-tokens` or `tokens-only`). Mismatched chunks from a
- * partial write read as no session.
- */
-declare function readSession(cookies: readonly CookieRecord[], name: string): StoredSession | null;
-/** The encoding a stored session was written with: `tokens-only` without a `user`. */
-declare function sessionEncoding(session: StoredSession): SessionEncoding;
-/**
- * Cookie writes that store `session` (or clear it with `null`) exactly like
- * `@supabase/ssr` with the same `encode`, and expire chunks the new value no
- * longer uses.
- */
-declare function writeSession(existing: readonly CookieRecord[], name: string, session: StoredSession | null, options?: CookieOptions, { encode }?: WriteSessionOptions): CookieWrite[];
-/**
- * `Max-Age=0` writes for every chunk of the session cookie at each of
- * `scopes`, like `clearAuthCookiesAtScopes` from `@supabase/ssr`. Use it once
- * the cookie `domain` or `path` changed, for the scopes earlier deploys
- * wrote: browsers ignore writes for scopes the host doesn't own, but a scope
- * equal to the current one clears the live session.
- */
-declare function clearSessionAtScopes(existing: readonly CookieRecord[], name: string, scopes: readonly CookieScope[]): CookieWrite[];
-/** Applies cookie writes to a cookie list, as the next request would see it. */
-declare function applyCookieWrites(cookies: readonly CookieRecord[], writes: readonly CookieWrite[]): CookieRecord[];
-//#endregion
-export { writeSession as _, CookieWrite as a, StoredSession as c, clearSessionAtScopes as d, parseCookies as f, sessionEncoding as g, sessionCookieName as h, CookieScope as i, WriteSessionOptions as l, serializeCookie as m, CookieOptions as n, DEFAULT_SESSION_ENCODING as o, readSession as p, CookieRecord as r, SessionEncoding as s, AUTH_CACHE_HEADERS as t, applyCookieWrites as u };