better-supabase 0.12.0 → 0.13.0

package/dist/session-DObioXpX.d.ts

@@ -1,95 +0,0 @@
-import { a as AnyModels, i as AnyFunctions } from "./types-BrpW5ixT.js";
-import { n as AuthOutageEvent, o as EventHub } from "./events-P3raDX2E.js";
-import { f as CookieScope, h as SessionEncoding, r as AuthState, t as AuthResolution } from "./resolve-Ceft-18-.js";
-import { a as ServerContext, r as ContextOptions, v as ActiveSupport } from "./server-types-fLdep4gb.js";
-import { d as RefreshPolicy } from "./respond-BSL36dQp.js";
-import { SingleKeyEntry } from "@supabase/middleware";
-//#region src/server/entries/core.d.ts
-/**
- * What the entries need from a `createServer` server: its resolver, its
- * request-scoped context builder and the settings behind them. The server
- * registers it once; entries read it with `serverCore(server)`.
- */
-interface ServerCore<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> {
-  readonly events: EventHub;
-  /** How long reads stay on the primary after a write. */
-  readonly pinMs: number;
-  resolve(request: Request, options: {
-    readonly refresh?: boolean;
-    readonly cookies?: boolean;
-    readonly encode?: SessionEncoding;
-    readonly checkSession?: boolean;
-  }): Promise<AuthResolution<C, P>>;
-  /** The session cookie's name (`auth.cookie.name`, else `sb-<ref>-auth-token`). */
-  sessionCookie(): string;
-  /** `ServerOptions.tenant`, or `undefined` without one. */
-  tenant(request: Request, auth: AuthState<C, P>): string | undefined | PromiseLike<string | undefined>;
-  support(request: Request, auth: AuthState<C, P>): Promise<ActiveSupport | undefined>;
-  context(resolution: AuthResolution<C, P>, request: Request, options: ContextOptions, tenant: string | undefined): ServerContext<M, F, E, C, P, B>;
-}
-/** The core of a server built by `createServer` or one of the adapter factories. */
-declare function serverCore<M extends AnyModels, F extends AnyFunctions, E, C, P, B>(server: {
-  readonly events: EventHub;
-  context(request: Request): Promise<ServerContext<M, F, E, C, P, B>>;
-}): ServerCore<M, F, E, C, P, B>;
-//#endregion
-//#region src/server/entries/session.d.ts
-interface SessionEntryConfig {
-  /**
-   * Refresh an expired cookie session and send the new cookies on the
-   * response. Only where cookies can be written once per request (a proxy, a
-   * framework middleware); never in Server Components. `'navigation'`
-   * refreshes page loads, navigations and form posts (`shouldRefresh`), so
-   * parallel `fetch` calls never race on the refresh token. Defaults to false.
-   */
-  readonly refresh?: RefreshPolicy;
-  /**
-   * Ask the Auth server whether the session still exists, so a session
-   * ended elsewhere (sign-out on another device, an admin revoke) is anon
-   * here too. One Auth call per matching request: `true` checks every
-   * request, `'navigation'` full page loads (`shouldCheckSession`). Off by
-   * default, because a valid token otherwise never calls the Auth server.
-   */
-  readonly checkSession?: boolean | "navigation" | ((request: Request) => boolean);
-  /** Read the session cookie. Defaults to true; `false` resolves bearer tokens only. */
-  readonly cookies?: boolean;
-  /**
-   * Keeps the invocation alive for event sink sends the handler started:
-   * `EdgeRuntime.waitUntil`, the Workers `ctx.waitUntil` or Next's `after`.
-   */
-  readonly waitUntil?: (promise: Promise<unknown>) => void;
-  /**
-   * The shape refreshed sessions are written in, `cookies.encode` in
-   * `@supabase/ssr`. Use the browser client's value. Defaults to the
-   * server's `auth.cookie.encode`, then `user-and-tokens`.
-   */
-  readonly encode?: SessionEncoding;
-  /**
-   * Cookie scopes (`domain`, `path`) earlier deploys wrote the session at.
-   * Each response to a request that carries the session cookie expires it
-   * at these scopes, like `clearAuthCookiesAtScopes` in `@supabase/ssr`, so
-   * moving the cookie to a new domain or path is one config change. Never
-   * list the current scope: that clears the live session.
-   */
-  readonly cookieScopes?: readonly CookieScope[];
-  /**
-   * Called when a refresh failed because the Auth server was unreachable,
-   * timed out or answered 5xx or 429. When the access token couldn't be
-   * kept (`event.kept` is false), a returned `Response` answers the request
-   * instead of the handler, such as a 503 with `Retry-After`. A throw is
-   * logged and ignored.
-   */
-  readonly onAuthOutage?: AuthOutageHook;
-}
-/** `onAuthOutage` on the session entry and the Next.js proxy. */
-type AuthOutageHook = (event: AuthOutageEvent, request: Request) => Response | undefined | void | Promise<Response | undefined | void>;
-/**
- * Entry contributing `ctx.session`, the request's `AuthResolution`: a bearer
- * token first, the session cookie second. It is the only entry with a
- * response seam for cookies: on the way out it adds the refreshed session
- * cookies and the no-store headers, and hands pending event sends to
- * `waitUntil`.
- */
-declare function withSession<M extends AnyModels, F extends AnyFunctions, E, C, P, B>(core: ServerCore<M, F, E, C, P, B>, config?: SessionEntryConfig): SingleKeyEntry<"session", Record<never, never>, AuthResolution<C, P>>;
-//#endregion
-export { serverCore as a, ServerCore as i, SessionEntryConfig as n, withSession as r, AuthOutageHook as t };

package/dist/settings-BiHDFglz.js

@@ -1,90 +0,0 @@
-import { n as dbError } from "./errors-BV1SKTVs.js";
-import { r as err, t as AsyncResult } from "./result-DIeYscA3.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { n as validate } from "./standard-B1BigegP.js";
-import { n as applyTemporal, o as blockCall } from "./block-helpers-DkVZNDrj.js";
-import { r as withBlockHooks } from "./block-hooks-C22vuIUd.js";
-//#region src/blocks/settings/settings.ts
-/**
-* Declares the app's settings with a Standard Schema per key. Values are
-* validated before they are written, and stored values that no longer match
-* their schema read as the default. Pass the result to `createSettings`.
-*/
-function defineSettings(spec) {
-	return { schemas: {
-		user: spec.user ?? {},
-		organization: spec.organization ?? {},
-		platform: spec.platform ?? {}
-	} };
-}
-/** The settings block: typed `get`, `set` and `reset` over the settings module's functions. */
-function createSettings(options) {
-	applyTemporal(options);
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const { user, organization, platform } = (options.settings ?? defineSettings({})).schemas;
-	function getUser(key) {
-		return reader(user, call, "get_user_settings", {}, key);
-	}
-	function getOrganization(organizationId, key) {
-		return reader(organization, call, "get_organization_settings", { tenant: organizationId }, key);
-	}
-	function getPlatform(key) {
-		return reader(platform, call, "get_platform_settings", {}, key);
-	}
-	return withBlockHooks({
-		getUser,
-		setUser: (key, value) => writer(user, call, "set_user_setting", {}, key, value),
-		resetUser: (key) => remover(user, call, "reset_user_setting", {}, key),
-		getOrganization,
-		setOrganization: (organizationId, key, value) => writer(organization, call, "set_organization_setting", { tenant: organizationId }, key, value),
-		resetOrganization: (organizationId, key) => remover(organization, call, "reset_organization_setting", { tenant: organizationId }, key),
-		getPlatform,
-		setPlatform: (key, value) => writer(platform, call, "set_platform_setting", {}, key, value),
-		resetPlatform: (key) => remover(platform, call, "reset_platform_setting", {}, key)
-	}, options.hooks, {
-		block: "settings",
-		...options.logger ? { logger: options.logger } : {}
-	});
-}
-/** Stored values merged over the defaults; unknown keys are dropped. */
-async function merged(entries, stored) {
-	const values = isRecord(stored) ? stored : {};
-	const out = {};
-	for (const [key, entry] of Object.entries(entries)) out[key] = await readValue(entry, values[key]);
-	return out;
-}
-async function readValue(entry, stored) {
-	if (stored === void 0) return entry.default;
-	const parsed = await validate(entry.schema, stored);
-	return parsed.ok ? parsed.data : entry.default;
-}
-function unknownSetting(key) {
-	return AsyncResult.from(() => Promise.resolve(err(dbError("invalid_input", `Unknown setting "${key}"`))));
-}
-/** Reads every key, or one key, through `fn`. */
-function reader(entries, call, fn, args, key) {
-	if (key !== void 0 && !(key in entries)) return unknownSetting(key);
-	return call(fn, args, async (stored) => {
-		const values = await merged(entries, stored);
-		return key === void 0 ? values : values[key];
-	});
-}
-/** Validates `value` with the key's schema, then writes the output through `fn`. */
-function writer(entries, call, fn, args, key, value) {
-	const entry = entries[key];
-	if (!entry) return unknownSetting(key);
-	return AsyncResult.from(() => validate(entry.schema, value, `setting "${key}"`)).andThen((output) => call(fn, {
-		...args,
-		key,
-		value: { value: output ?? null }
-	}, () => output));
-}
-function remover(entries, call, fn, args, key) {
-	if (!(key in entries)) return unknownSetting(key);
-	return call(fn, {
-		...args,
-		key
-	}, (removed) => removed === true);
-}
-//#endregion
-export { defineSettings as n, createSettings as t };

package/dist/shared-BmMcMoW9.js

@@ -1,89 +0,0 @@
-import { pipeline, seedContext } from "@supabase/middleware";
-//#region src/bridges/shared.ts
-/** The string keys of a pipeline context: every contribution, without the seed's symbols. */
-function contributionsOf(ctx) {
-	const contributions = {};
-	for (const [key, value] of Object.entries(ctx)) contributions[key] = value;
-	return contributions;
-}
-/**
-* The Cloudflare bindings Nitro 3 (H3 2, SolidStart 2) puts on the request
-* itself, at `request.runtime.cloudflare.env`.
-*/
-function nitroCloudflareEnv(request) {
-	if (!("runtime" in request) || !isRecord(request.runtime)) return;
-	const { cloudflare } = request.runtime;
-	if (!isRecord(cloudflare)) return;
-	const { env } = cloudflare;
-	return env;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-/** The per-request value a bridge seeds under `key`. */
-function handoffOf(ctx, key) {
-	return ctx[key];
-}
-/**
-* Makes the body of `request` readable more than once, in place: the first
-* reader drains the stream into a cache and later readers are served from
-* it, so an entry and the route both see the body. For frameworks that hand
-* the route the same `Request` the middleware saw (TanStack Start,
-* SvelteKit, React Router), where `bufferRequest`'s wrapped copy can't go.
-*/
-function bufferInPlace(request) {
-	if (!request.body || request.bodyUsed) return;
-	const readOnce = request.arrayBuffer.bind(request);
-	let buffer;
-	const arrayBuffer = () => buffer ??= readOnce();
-	const text = async () => new TextDecoder().decode(await arrayBuffer());
-	const readers = {
-		arrayBuffer,
-		text,
-		json: async () => JSON.parse(await text()),
-		bytes: async () => new Uint8Array(await arrayBuffer()),
-		blob: async () => new Blob([await arrayBuffer()]),
-		formData: async () => new Response(await arrayBuffer(), { headers: request.headers }).formData(),
-		clone: () => request
-	};
-	for (const [name, value] of Object.entries(readers)) Object.defineProperty(request, name, {
-		value,
-		configurable: true
-	});
-}
-const DOWNSTREAM = Symbol("bridge.downstream");
-/**
-* The shared shape of the upstream bridges: the pipeline folds once, each
-* request seeds the framework's `next` under a symbol, and the terminal
-* hands it the contributions, so response-phase entries see the
-* framework's response. `platform` is the host's env object, if any, which
-* `getEnv` reads first.
-*/
-function around(entries) {
-	const run = pipeline(entries, (_request, ctx) => handoffOf(ctx, DOWNSTREAM)(contributionsOf(ctx)));
-	return (request, platform, downstream) => run(request, {
-		...seedContext(platform),
-		[DOWNSTREAM]: downstream
-	});
-}
-/**
-* A framework handler's value as a `Response`: responses as is, `undefined`
-* as 204, other values as JSON. `init` carries the status and headers the
-* handler set on the framework's response object.
-*/
-function toResponse(value, init = {}) {
-	if (value instanceof Response) return value;
-	const options = {
-		...init.status === void 0 ? {} : { status: init.status },
-		...init.statusText === void 0 ? {} : { statusText: init.statusText },
-		...init.headers === void 0 ? {} : { headers: init.headers }
-	};
-	if (value === void 0 || value === null) return new Response(null, {
-		status: 204,
-		...options
-	});
-	if (typeof value === "string") return new Response(value, options);
-	return Response.json(value, options);
-}
-//#endregion
-export { toResponse as a, nitroCloudflareEnv as i, bufferInPlace as n, handoffOf as r, around as t };

package/dist/shared-C9zvURqC.js

@@ -1,14 +0,0 @@
-import { n as invalidRequest } from "./build-C-D_vn0U.js";
-//#region src/compile/shared.ts
-/** A row-count or offset value that is safe to inline into SQL text. */
-function integer(value) {
-	if (!Number.isInteger(value) || value < 0) invalidRequest(`Expected a non-negative integer, got ${value}`);
-	return value;
-}
-/** The ` where a and b` clause for the parts that are present, or an empty string. */
-function whereClause(parts) {
-	const present = parts.filter((part) => part !== void 0);
-	return present.length > 0 ? ` where ${present.join(" and ")}` : "";
-}
-//#endregion
-export { whereClause as n, integer as t };

package/dist/shared-D5Djh43x.js

@@ -1,60 +0,0 @@
-import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { n as dbError } from "./errors-BV1SKTVs.js";
-//#region src/plugins/shared.ts
-/** Database column name for an app column, or `undefined` if it is unknown. */
-function dbName(table, app) {
-	return app === void 0 ? void 0 : table.columns[app]?.db;
-}
-function isNull(column) {
-	return {
-		kind: "column",
-		column,
-		op: "is",
-		value: null
-	};
-}
-function isNotNull(column) {
-	return {
-		kind: "not",
-		item: isNull(column)
-	};
-}
-function equals(column, value) {
-	return {
-		kind: "column",
-		column,
-		op: "eq",
-		value
-	};
-}
-/** Sets `column` on a row unless the caller already provided it. */
-function withDefault(row, column, value) {
-	if (column === void 0 || column in row) return row;
-	return {
-		...row,
-		[column]: value
-	};
-}
-/**
-* Refuses caller-supplied values for columns a plugin fills (timestamps,
-* actor, soft delete) unless the call passes `{ override: true }`. Returns
-* whether the caller may keep its own values.
-*/
-function guardManaged(op, columns, plugin, options) {
-	if (options["override"] === true) return true;
-	const rows = op.kind === "insert" ? op.rows : op.kind === "update" ? [op.set] : [];
-	for (const column of columns) {
-		if (column === void 0) continue;
-		if (rows.some((row) => column in row)) throw new DbException(dbError("invalid_request", `"${column}" on ${op.table.key} is filled by ${plugin}(); pass { override: true } to set it yourself`, { table: op.table.key }));
-	}
-	return false;
-}
-/** Upserts that may update existing rows must not overwrite "created" columns. */
-function insertsOnly(op) {
-	return !op.onConflict || op.onConflict.action === "ignore";
-}
-function forbidden(message) {
-	throw new DbException(dbError("forbidden", message));
-}
-//#endregion
-export { insertsOnly as a, withDefault as c, guardManaged as i, equals as n, isNotNull as o, forbidden as r, isNull as s, dbName as t };

package/dist/shared-DDSjEGDR.d.ts

@@ -1,11 +0,0 @@
-import { AnyEntry, ValidateEntries } from "@supabase/middleware";
-//#region src/bridges/shared.d.ts
-/**
- * `unknown` when the entries compose, so a parameter typed
- * `Entries & Validated<Entries>` stays `Entries`. Otherwise the engine's
- * error string, and the intersection fails the call with the
- * `middleware-conflict` or `middleware-prereq` message.
- */
-type Validated<Entries extends readonly AnyEntry[]> = [ValidateEntries<Entries>] extends [true] ? unknown : ValidateEntries<Entries>;
-//#endregion
-export { Validated as t };

package/dist/sign-in-BCV5S2WZ.d.ts

@@ -1,49 +0,0 @@
-import { t as AuthFailure } from "./auth-link-BjFPqwLz.js";
-import { Provider, SignInWithOAuthCredentials, SignInWithPasswordlessCredentials, SupabaseClient, VerifyOtpParams } from "@supabase/supabase-js";
-//#region src/react/sign-in.d.ts
-type AuthApi = Pick<SupabaseClient["auth"], "signInWithPassword" | "signInWithOtp" | "verifyOtp" | "signInWithOAuth" | "signOut">;
-interface AuthHookOptions {
-  /** A supabase-js client for apps without `<BetterSupabaseProvider>`. */
-  readonly client?: {
-    readonly auth: AuthApi;
-  };
-  /** Called after a call succeeds, e.g. to navigate. */
-  readonly onSuccess?: () => void;
-}
-interface PendingState {
-  /** A call is in flight. */
-  readonly pending: boolean;
-  /** The last call's error; cleared when the next call starts. */
-  readonly error: AuthFailure | undefined;
-}
-interface SignIn extends PendingState {
-  readonly password: (credentials: {
-    readonly email: string;
-    readonly password: string;
-  }) => Promise<AuthFailure | undefined>;
-  /** Sends a magic link or a one-time code to an email or a phone. */
-  readonly otp: (credentials: SignInWithPasswordlessCredentials) => Promise<AuthFailure | undefined>;
-  /** Checks the code `otp` sent. */
-  readonly verifyOtp: (params: VerifyOtpParams) => Promise<AuthFailure | undefined>;
-  /** Starts the OAuth redirect. In a browser the page navigates away. */
-  readonly oauth: (provider: Provider, options?: SignInWithOAuthCredentials["options"]) => Promise<AuthFailure | undefined>;
-}
-interface SignOut extends PendingState {
-  readonly signOut: (options?: {
-    readonly scope?: "global" | "local" | "others";
-  }) => Promise<AuthFailure | undefined>;
-}
-/**
- * Sign-in calls with `pending` and `error` state. The session lands in the
- * client's auth store, so `useAuth()` updates on its own.
- *
- * ```tsx
- * const signIn = useSignIn({ onSuccess: () => router.push('/') });
- * <button disabled={signIn.pending} onClick={() => signIn.password({ email, password })} />
- * ```
- */
-declare function useSignIn(options?: AuthHookOptions): SignIn;
-/** `auth.signOut()` with `pending` and `error` state. The provider clears cached queries. */
-declare function useSignOut(options?: AuthHookOptions): SignOut;
-//#endregion
-export { useSignIn as a, SignOut as i, PendingState as n, useSignOut as o, SignIn as r, AuthHookOptions as t };