better-supabase 0.5.1 → 0.6.0

package/dist/sveltekit/index.d.ts

@@ -0,0 +1,116 @@
+import { a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
+import { t as BetterSupabase } from "../define-CJJkkr1-.js";
+import { t as BetterServer } from "../server-CeVeeXwz.js";
+import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-B5tid-q5.js";
+import { t as RefusalRedirects } from "../refusal-D1rgbzNq.js";
+import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-DuVb4Xa8.js";
+import { t as Validated } from "../shared-DDSjEGDR.js";
+import { i as tagFor } from "../tags-Cx-LnIQP.js";
+import { AnyEntry, Contributions } from "@supabase/middleware";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/bridges/sveltekit.d.ts
+/** The part of SvelteKit's `RequestEvent` the bridge reads and writes. */
+interface SvelteKitEvent<Locals extends object> {
+  readonly request: Request;
+  readonly locals: Locals;
+  readonly platform?: {
+    readonly env?: unknown;
+  } | undefined;
+}
+/** SvelteKit's `Handle`, typed structurally so the package does not import `@sveltejs/kit`. */
+type SvelteKitHandle<Locals extends object> = (input: {
+  readonly event: SvelteKitEvent<Locals>;
+  readonly resolve: (event: SvelteKitEvent<Locals>) => Response | Promise<Response>;
+}) => Promise<Response>;
+/**
+ * Runs an entry array as a SvelteKit `handle` hook. Every contributed key
+ * lands on `event.locals`, so loads, actions and endpoints read
+ * `locals.db`; `event.platform.env` (Cloudflare) seeds `getEnv`. Declare
+ * the keys in `App.Locals` with `BetterSupabaseContributions`.
+ *
+ * ```ts title="src/hooks.server.ts"
+ * export const handle = toSvelteKit([withBetterSupabase(server)])
+ * ```
+ *
+ * Compose it with other hooks through SvelteKit's `sequence`.
+ */
+export declare function toSvelteKit<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>): SvelteKitHandle<Partial<Contributions<Entries>>>;
+//#endregion
+//#region src/sveltekit/create.d.ts
+/** SvelteKit's `fail()` result, typed structurally. */
+interface SvelteKitFailure<T> {
+  readonly status: number;
+  readonly data: T;
+}
+/**
+ * `error`, `redirect` and `fail` from `@sveltejs/kit`. Pass them so refused
+ * callers get SvelteKit's own errors and redirects, and failed form actions
+ * a `fail()` with the status.
+ */
+interface SvelteKitHelpers {
+  error(status: number, body: {
+    readonly message: string;
+  }): never;
+  redirect(status: 303, location: string): never;
+  fail(status: number, data: Record<string, unknown>): SvelteKitFailure<unknown>;
+}
+interface SvelteKitOptions extends FrameworkOptions {
+  /** `{ error, redirect, fail }` from `@sveltejs/kit`. */
+  readonly kit?: SvelteKitHelpers;
+}
+/** The part of a SvelteKit `RequestEvent` the guards read. */
+interface SvelteKitRequestEvent<Locals extends object = object> {
+  readonly request: Request;
+  readonly locals: Locals;
+}
+/** A load's `depends`, typed structurally. */
+interface SvelteKitDepends {
+  depends(...deps: `${string}:${string}`[]): void;
+}
+/** What `handleError` returns: SvelteKit's `App.Error` with a code. */
+interface SvelteKitAppError {
+  readonly message: string;
+  readonly code?: string;
+}
+interface BetterSvelteKit<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
+  /** The keys on `event.locals`, for `App.Locals`. Type only: `undefined` at runtime. */
+  readonly Locals: FrameworkLocals<M, F, E, C, P>;
+  /**
+   * The `handle` hook: verifies the caller, refreshes the session cookie on
+   * navigations and form posts, and puts `db`, `bs`, `auth`, `tenant` and
+   * the serializable `session` on `event.locals`.
+   */
+  readonly handle: SvelteKitHandle<Partial<FrameworkLocals<M, F, E, C, P>>>;
+  /**
+   * The caller in a `load` or endpoint, or a refusal: a redirect to
+   * `signIn` or `mfa` when configured, else SvelteKit's `error()`.
+   *
+   * ```ts
+   * export const load = async (event) => {
+   *   const { db, tenant } = await bs.require(event, { requireTenant: true });
+   *   return { customers: await db.customers.findMany().orThrow() };
+   * };
+   * ```
+   */
+  require<R extends boolean = false>(event: SvelteKitRequestEvent, options?: BlockRequireOptions<C, P, R>): Promise<FrameworkLocals<M, F, E, C, P> & AuthorizedContext<C, P, R>>;
+  /**
+   * A form action returning an `ActionResult`: validates the form with
+   * `input`, runs the guard and `authorize`, and on failure answers with
+   * `fail(status, result)` when `kit` is set, so `form.error` is a `DbError`.
+   */
+  action<S extends StandardSchemaV1 | undefined, T, R extends boolean = false>(options: BlockActionOptions<S, C, P, R>, fn: (input: ActionParsed<S>, ctx: FrameworkLocals<M, F, E, C, P> & AuthorizedContext<C, P, R>, event: SvelteKitRequestEvent) => T): (event: SvelteKitRequestEvent) => Promise<ActionResult<Unwrapped<Awaited<T>>> | SvelteKitFailure<ActionResult<never>>>;
+  /**
+   * `handleError` for `hooks.server.ts`: `DbError`s keep their message and
+   * kind as `code`; other errors become a generic message unless
+   * `exposeErrors` is on.
+   */
+  handleError(input: {
+    readonly error: unknown;
+  }): SvelteKitAppError;
+  /** Registers `bs:<table>` dependencies, so `invalidate(tagFor(table))` reruns the load. */
+  depends(load: SvelteKitDepends, ...tables: readonly string[]): void;
+}
+/** SvelteKit integration: a `handle` hook, guarded loads and form actions. */
+export declare function createSvelteKit<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: SvelteKitOptions): BetterSvelteKit<M, F, E, C, P>;
+//#endregion
+export { type ActionResult, type AuthorizeOptions, type AuthorizedContext, type BetterSvelteKit, type BlockActionOptions, type BlockRequireOptions, type FrameworkLocals, type FrameworkOptions, type RefusalRedirects, type SvelteKitAppError, type SvelteKitDepends, type SvelteKitEvent, type SvelteKitFailure, type SvelteKitHandle, type SvelteKitHelpers, type SvelteKitOptions, type SvelteKitRequestEvent, tagFor };

package/dist/sveltekit/index.js

@@ -0,0 +1,106 @@
+import { t as DbException } from "../db-exception-CnWcYPxL.js";
+import { r as dbErrorOf } from "../errors-B11Duf73.js";
+import { o as toProblem } from "../problem-BreOl8b8.js";
+import { c as extendServer, n as flushEvents, s as createServer } from "../adapter-Bc1o3zyy.js";
+import { t as defaultExpose } from "../respond-BUgsXNgk.js";
+import { r as tagFor } from "../tags-B99_U9Pp.js";
+import { i as requireCaller, o as runAction } from "../kit-Fm-Fv7q5.js";
+import { n as bufferInPlace, t as around } from "../shared-CBxosKK3.js";
+import { a as platformWaitUntil, i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-CONDyPYx.js";
+import { i as refusalTarget } from "../refusal-CeJWxmkH.js";
+//#region src/bridges/sveltekit.ts
+/**
+* Runs an entry array as a SvelteKit `handle` hook. Every contributed key
+* lands on `event.locals`, so loads, actions and endpoints read
+* `locals.db`; `event.platform.env` (Cloudflare) seeds `getEnv`. Declare
+* the keys in `App.Locals` with `BetterSupabaseContributions`.
+*
+* ```ts title="src/hooks.server.ts"
+* export const handle = toSvelteKit([withBetterSupabase(server)])
+* ```
+*
+* Compose it with other hooks through SvelteKit's `sequence`.
+*/
+function toSvelteKit(entries) {
+	const run = around(entries);
+	return ({ event, resolve }) => {
+		bufferInPlace(event.request);
+		return run(event.request, event.platform?.env, async (contributions) => {
+			Object.assign(event.locals, contributions);
+			return resolve(event);
+		});
+	};
+}
+//#endregion
+//#region src/sveltekit/create.ts
+/** SvelteKit integration: a `handle` hook, guarded loads and form actions. */
+function createSvelteKit(betterSupabase, options = {}) {
+	const server = createServer(betterSupabase, options);
+	const expose = options.exposeErrors ?? defaultExpose();
+	const run = around([frameworkEntry(server, options, expose)]);
+	const localsFrom = (event) => {
+		const locals = event.locals;
+		if (!locals.bs) throw new TypeError("better-supabase: no context on event.locals; export handle = bs.handle from hooks.server.ts");
+		return locals;
+	};
+	const refuse = (error, request) => {
+		const target = refusalTarget(error, request, options);
+		if (options.kit) {
+			if (target) options.kit.redirect(303, target.pathname + target.search);
+			options.kit.error(error.status, { message: toProblem(error, { expose }).detail ?? error.message });
+		}
+		throw new DbException(error);
+	};
+	const handle = ({ event, resolve }) => {
+		bufferInPlace(event.request);
+		const platform = event.platform;
+		const env = event.platform?.env;
+		return run(event.request, env, async (contributions) => {
+			Object.assign(event.locals, localsOf(contributions));
+			const response = await resolve(event);
+			flushEvents(server, options.waitUntil ?? platformWaitUntil(platform));
+			return response;
+		});
+	};
+	return extendServer(server, {
+		Locals: void 0,
+		handle,
+		require: async (event, requireOptions = {}) => {
+			const locals = localsFrom(event);
+			const caller = await requireCaller(locals.bs.auth, requireOptions, locals.tenant);
+			if ("kind" in caller) return refuse(caller, event.request);
+			return {
+				...locals,
+				...caller
+			};
+		},
+		action(actionOptions, fn) {
+			return async (event) => {
+				const locals = localsFrom(event);
+				const input = await actionInput(event.request);
+				const result = await runAction(locals.bs.auth, actionOptions, input, locals.tenant, (parsed, caller) => fn(parsed, {
+					...locals,
+					...caller
+				}, event));
+				if (!result.ok && options.kit) return options.kit.fail(result.error.status, result);
+				return result;
+			};
+		},
+		handleError({ error }) {
+			const found = dbErrorOf(error);
+			if (found) {
+				const problem = toProblem(found, { expose });
+				return {
+					message: problem.detail ?? problem.title,
+					code: found.kind
+				};
+			}
+			return { message: expose && error instanceof Error ? error.message : "Internal Error" };
+		},
+		depends(load, ...tables) {
+			for (const table of tables) load.depends(`bs:${table}`);
+		}
+	});
+}
+//#endregion
+export { createSvelteKit, tagFor, toSvelteKit };

package/dist/tags-B99_U9Pp.js

@@ -0,0 +1,39 @@
+//#region src/core/tags.ts
+/**
+* `bs:<table>`, `bs:<table>:<id>`, or `bs:<table>@<tenant>` for a read
+* scoped to one tenant. Mutations invalidate the table tag, the tag of their
+* tenant (`bs:<table>@*` without one) and the tags of the changed rows.
+*/
+function tagFor(table, id, options = {}) {
+	if (id !== void 0) return `bs:${table}:${String(id)}`;
+	return options.tenant === void 0 ? `bs:${table}` : `bs:${table}@${options.tenant}`;
+}
+/**
+* The tags a mutation invalidates: `bs:<table>` for every table in the
+* target, the tenant's `bs:<table>@<tenant>` (every tenant's `bs:<table>@*`
+* when the mutation has no tenant) and `bs:<table>:<id>` per changed row.
+*/
+function cacheTagsOf(target) {
+	const tenant = { tenant: target.tenant ?? "*" };
+	const tags = [];
+	for (const table of target.tables) tags.push(tagFor(table), tagFor(table, void 0, tenant));
+	for (const id of target.ids) tags.push(tagFor(target.table, id));
+	return tags;
+}
+/**
+* A `CacheAdapter` for any tag-based cache: it hands `invalidate` the tags
+* from `cacheTagsOf`, e.g. a CDN purge by tag, SvelteKit's `invalidate`, or
+* a Redis set of keys per tag. Tag your reads with `tagFor`.
+*
+* ```ts
+* betterSupabase.cache(tagCache((tags) => purgeCdn(tags), 'cdn'))
+* ```
+*/
+function tagCache(invalidate, name = "tags") {
+	return {
+		name,
+		invalidate: (target) => invalidate(cacheTagsOf(target))
+	};
+}
+//#endregion
+export { tagCache as n, tagFor as r, cacheTagsOf as t };

package/dist/tags-Cx-LnIQP.d.ts

@@ -0,0 +1,30 @@
+import { d as CacheTarget, u as CacheAdapter } from "./define-CJJkkr1-.js";
+//#region src/core/tags.d.ts
+interface TagOptions {
+  /** The tenant the read is scoped to; `"*"` is every tenant's reads. */
+  readonly tenant?: string;
+}
+/**
+ * `bs:<table>`, `bs:<table>:<id>`, or `bs:<table>@<tenant>` for a read
+ * scoped to one tenant. Mutations invalidate the table tag, the tag of their
+ * tenant (`bs:<table>@*` without one) and the tags of the changed rows.
+ */
+declare function tagFor(table: string, id?: string | number, options?: TagOptions): string;
+/**
+ * The tags a mutation invalidates: `bs:<table>` for every table in the
+ * target, the tenant's `bs:<table>@<tenant>` (every tenant's `bs:<table>@*`
+ * when the mutation has no tenant) and `bs:<table>:<id>` per changed row.
+ */
+declare function cacheTagsOf(target: CacheTarget): string[];
+/**
+ * A `CacheAdapter` for any tag-based cache: it hands `invalidate` the tags
+ * from `cacheTagsOf`, e.g. a CDN purge by tag, SvelteKit's `invalidate`, or
+ * a Redis set of keys per tag. Tag your reads with `tagFor`.
+ *
+ * ```ts
+ * betterSupabase.cache(tagCache((tags) => purgeCdn(tags), 'cdn'))
+ * ```
+ */
+declare function tagCache(invalidate: (tags: readonly string[]) => void | Promise<void>, name?: string): CacheAdapter;
+//#endregion
+export { tagFor as i, cacheTagsOf as n, tagCache as r, TagOptions as t };

package/dist/tanstack-db/index.d.ts

@@ -0,0 +1,71 @@
+import { L as TableKey, a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
+import { b as Db, t as BetterSupabase } from "../define-CJJkkr1-.js";
+import { t as BetterQueryMeta } from "../invalidate-BBqhpxyB.js";
+import { QueryClient, SkipToken } from "@tanstack/query-core";
+//#region src/tanstack-db/collection.d.ts
+/** The query a collection loads: `queries.<table>.findMany(args)` from `better-supabase/query`. */
+interface CollectionQuery<Row> {
+  readonly queryKey: readonly unknown[];
+  readonly queryFn: ((context: {
+    readonly signal: AbortSignal;
+  }) => Promise<Row[]>) | SkipToken;
+  readonly meta?: BetterQueryMeta;
+}
+/** The fields of a TanStack DB pending mutation the handlers read. */
+interface PendingMutationLike<Row> {
+  readonly original: unknown;
+  readonly modified: Row;
+  readonly changes: Partial<Row>;
+}
+/** The handler argument TanStack DB passes to `onInsert`, `onUpdate` and `onDelete`. */
+interface MutationParamsLike<Row> {
+  readonly transaction: {
+    readonly mutations: readonly PendingMutationLike<Row>[];
+  };
+}
+type CollectionMutationHandler<Row> = (params: MutationParamsLike<Row>) => Promise<void>;
+interface CollectionOptions<Row> {
+  readonly query: CollectionQuery<Row>;
+  readonly queryClient: QueryClient;
+  /** The collection id. Defaults to the table key. */
+  readonly id?: string;
+}
+/**
+ * Options for `queryCollectionOptions()` from `@tanstack/query-db-collection`.
+ * Typed by shape, so better-supabase doesn't depend on TanStack DB.
+ */
+interface CollectionConfig<Row> {
+  readonly id: string;
+  readonly queryKey: readonly unknown[];
+  readonly queryFn: (context: {
+    readonly signal: AbortSignal;
+  }) => Promise<Row[]>;
+  readonly meta?: BetterQueryMeta;
+  readonly queryClient: QueryClient;
+  readonly getKey: (row: Row) => string | number;
+  readonly onInsert: CollectionMutationHandler<Row>;
+  readonly onUpdate: CollectionMutationHandler<Row>;
+  readonly onDelete: CollectionMutationHandler<Row>;
+}
+/**
+ * A TanStack DB query collection for one table: it loads the rows with
+ * `query`, keys them by the table's primary key, and sends inserts, updates
+ * and deletes through the table's repository, so RLS, hooks, events and
+ * plugins apply. After a write the collection refetches its query; with
+ * `invalidateOnMutation(betterSupabase, queryClient)`, every other query
+ * that read the table refetches too.
+ *
+ * ```ts
+ * const customers = createCollection(
+ *   queryCollectionOptions(
+ *     collectionOptions(betterSupabase, db, "customers", {
+ *       query: queries.customers.findMany({ where: { status: "active" } }),
+ *       queryClient,
+ *     }),
+ *   ),
+ * );
+ * ```
+ */
+export declare function collectionOptions<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>, Row extends object>(betterSupabase: BetterSupabase<M, D, F, E>, db: Db<M, F, E, unknown> | (() => Db<M, F, E, unknown>), table: T, options: CollectionOptions<Row>): CollectionConfig<Row>;
+//#endregion
+export type { CollectionConfig, CollectionMutationHandler, CollectionOptions, CollectionQuery, MutationParamsLike, PendingMutationLike };

package/dist/tanstack-db/index.js

@@ -0,0 +1,72 @@
+import { t as DbException } from "../db-exception-CnWcYPxL.js";
+//#region src/tanstack-db/collection.ts
+function field(row, name) {
+	if (typeof row !== "object" || row === null || !(name in row)) return void 0;
+	return Object.getOwnPropertyDescriptor(row, name)?.value;
+}
+/**
+* A TanStack DB query collection for one table: it loads the rows with
+* `query`, keys them by the table's primary key, and sends inserts, updates
+* and deletes through the table's repository, so RLS, hooks, events and
+* plugins apply. After a write the collection refetches its query; with
+* `invalidateOnMutation(betterSupabase, queryClient)`, every other query
+* that read the table refetches too.
+*
+* ```ts
+* const customers = createCollection(
+*   queryCollectionOptions(
+*     collectionOptions(betterSupabase, db, "customers", {
+*       query: queries.customers.findMany({ where: { status: "active" } }),
+*       queryClient,
+*     }),
+*   ),
+* );
+* ```
+*/
+function collectionOptions(betterSupabase, db, table, options) {
+	const { query, queryClient } = options;
+	const queryFn = query.queryFn;
+	if (typeof queryFn !== "function") throw new TypeError(`better-supabase: the "${table}" collection needs a query that runs, not skipToken`);
+	const primaryKey = betterSupabase.meta.tables[table]?.primaryKey ?? [];
+	const [single] = primaryKey;
+	if (single === void 0) throw new TypeError(`better-supabase: the "${table}" collection needs a table with a primary key`);
+	const composite = primaryKey.length > 1;
+	const idOf = (row) => composite ? Object.fromEntries(primaryKey.map((name) => [name, field(row, name)])) : field(row, single);
+	const write = (method) => {
+		const fn = (typeof db === "function" ? db() : db)[table]?.[method];
+		if (!fn) throw new TypeError(`better-supabase: ${table}.${method} is not available`);
+		return fn;
+	};
+	const orThrow = async (result) => {
+		const settled = await result;
+		if (!settled.ok) throw new DbException(settled.error);
+	};
+	return {
+		id: options.id ?? table,
+		queryKey: query.queryKey,
+		queryFn,
+		...query.meta ? { meta: query.meta } : {},
+		queryClient,
+		getKey: (row) => {
+			if (!composite) {
+				const id = field(row, single);
+				return typeof id === "number" ? id : String(id);
+			}
+			return JSON.stringify(primaryKey.map((name) => field(row, name)));
+		},
+		onInsert: async ({ transaction }) => {
+			const create = write("create");
+			for (const mutation of transaction.mutations) await orThrow(create(mutation.modified, { returning: false }));
+		},
+		onUpdate: async ({ transaction }) => {
+			const update = write("update");
+			for (const mutation of transaction.mutations) await orThrow(update(idOf(mutation.original), mutation.changes, { returning: false }));
+		},
+		onDelete: async ({ transaction }) => {
+			const remove = write("delete");
+			for (const mutation of transaction.mutations) await orThrow(remove(idOf(mutation.original)));
+		}
+	};
+}
+//#endregion
+export { collectionOptions };

package/dist/tanstack-start/index.d.ts

@@ -0,0 +1,75 @@
+import { a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
+import { t as BetterSupabase } from "../define-CJJkkr1-.js";
+import { t as BetterServer } from "../server-CeVeeXwz.js";
+import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-B5tid-q5.js";
+import { t as RefusalRedirects } from "../refusal-D1rgbzNq.js";
+import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-DuVb4Xa8.js";
+import { t as Validated } from "../shared-DDSjEGDR.js";
+import { AnyEntry, Contributions } from "@supabase/middleware";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/bridges/tanstack-start.d.ts
+/** The arguments TanStack Start passes to a `.server()` callback. */
+interface TanStackStartServerArgs<Context, Result> {
+  readonly request: Request;
+  readonly next: (options: {
+    readonly context: Context;
+  }) => Promise<Result>;
+}
+interface ToTanStackStartOptions {
+  /** The host's env object for `getEnv`, read per request. */
+  readonly env?: (request: Request) => unknown;
+}
+/**
+ * Runs an entry array as the `.server()` callback of a TanStack Start
+ * middleware. Every contributed key lands on `context`. On request
+ * middleware the response passes back through the entries, so refreshed
+ * session cookies reach it; on server function middleware the context still
+ * flows, and a short circuit (a 401 from the guard) is thrown as a
+ * `Response`, which TanStack Start sends.
+ *
+ * ```ts title="src/start.ts"
+ * const supabase = createMiddleware().server(toTanStackStart([withBetterSupabase(server)]))
+ * export const startInstance = createStart(() => ({ requestMiddleware: [supabase] }))
+ * ```
+ */
+export declare function toTanStackStart<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, options?: ToTanStackStartOptions): <Result extends object>(args: TanStackStartServerArgs<Contributions<Entries>, Result>) => Promise<Result>;
+//#endregion
+//#region src/tanstack-start/create.d.ts
+interface TanStackStartOptions extends FrameworkOptions {
+  /** The host's env object for `getEnv`, read per request. */
+  readonly platformEnv?: (request: Request) => unknown;
+}
+/** What a server function handler receives. */
+interface TanStackStartHandlerArgs<Data, Context> {
+  readonly data: Data;
+  readonly context: Context;
+}
+interface BetterTanStackStart<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
+  /**
+   * The `.server()` callback of a request middleware: verifies the caller,
+   * refreshes the session cookie on navigations and form posts, and puts
+   * `db`, `bs`, `auth`, `tenant` and the serializable `session` on `context`.
+   *
+   * ```ts title="src/start.ts"
+   * const supabase = createMiddleware().server(bs.middleware)
+   * export const startInstance = createStart(() => ({ requestMiddleware: [supabase] }))
+   * ```
+   */
+  readonly middleware: <Result extends object>(args: TanStackStartServerArgs<FrameworkLocals<M, F, E, C, P>, Result>) => Promise<Result>;
+  /**
+   * The caller in a server function or route handler, or a thrown
+   * refusal: a redirect to `signIn` or `mfa` when configured, else a
+   * Problem Details response, which TanStack Start sends.
+   */
+  require<R extends boolean = false>(context: FrameworkLocals<M, F, E, C, P>, options?: BlockRequireOptions<C, P, R>): Promise<FrameworkLocals<M, F, E, C, P> & AuthorizedContext<C, P, R>>;
+  /**
+   * A `createServerFn().handler()` returning an `ActionResult`, for
+   * `useAction`. Pass the same schema to `.inputValidator()` to type `data`
+   * on the client; `input` validates it again on the server.
+   */
+  action<S extends StandardSchemaV1 | undefined, T, R extends boolean = false>(options: BlockActionOptions<S, C, P, R>, fn: (input: ActionParsed<S>, ctx: FrameworkLocals<M, F, E, C, P> & AuthorizedContext<C, P, R>) => T): <Data>(args: TanStackStartHandlerArgs<Data, FrameworkLocals<M, F, E, C, P>>) => Promise<ActionResult<Unwrapped<Awaited<T>>>>;
+}
+/** TanStack Start integration: request middleware, guards and server function actions. */
+export declare function createTanStackStart<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: TanStackStartOptions): BetterTanStackStart<M, F, E, C, P>;
+//#endregion
+export type { ActionResult, AuthorizeOptions, AuthorizedContext, BetterTanStackStart, BlockActionOptions, BlockRequireOptions, FrameworkLocals, FrameworkOptions, RefusalRedirects, TanStackStartHandlerArgs, TanStackStartOptions, TanStackStartServerArgs, ToTanStackStartOptions };

package/dist/tanstack-start/index.js

@@ -0,0 +1,95 @@
+import { c as extendServer, n as flushEvents, s as createServer } from "../adapter-Bc1o3zyy.js";
+import { t as defaultExpose } from "../respond-BUgsXNgk.js";
+import { i as requireCaller, o as runAction } from "../kit-Fm-Fv7q5.js";
+import { n as bufferInPlace, t as around } from "../shared-CBxosKK3.js";
+import { i as localsOf, r as frameworkEntry } from "../framework-CONDyPYx.js";
+import { r as refusalResponse } from "../refusal-CeJWxmkH.js";
+//#region src/bridges/tanstack-start.ts
+/** The `response` of a request middleware's `next()` result; server function results have none. */
+function responseOf(result) {
+	return "response" in result && result.response instanceof Response ? result.response : void 0;
+}
+/**
+* Runs an entry array as the `.server()` callback of a TanStack Start
+* middleware. Every contributed key lands on `context`. On request
+* middleware the response passes back through the entries, so refreshed
+* session cookies reach it; on server function middleware the context still
+* flows, and a short circuit (a 401 from the guard) is thrown as a
+* `Response`, which TanStack Start sends.
+*
+* ```ts title="src/start.ts"
+* const supabase = createMiddleware().server(toTanStackStart([withBetterSupabase(server)]))
+* export const startInstance = createStart(() => ({ requestMiddleware: [supabase] }))
+* ```
+*/
+function toTanStackStart(entries, options = {}) {
+	return tanStackStartServer(around(entries), options.env, (contributions) => contributions);
+}
+/** The `.server()` callback over a folded pipeline, with the context `toContext` builds. */
+function tanStackStartServer(run, env, toContext) {
+	return async ({ request, next }) => {
+		bufferInPlace(request);
+		const downstream = {};
+		const response = await run(request, env?.(request), async (contributions) => {
+			const result = await next({ context: toContext(contributions, request) });
+			downstream.result = result;
+			return responseOf(result) ?? new Response(null, { status: 204 });
+		});
+		const { result } = downstream;
+		if (result === void 0) throw response;
+		if (responseOf(result) === void 0) return result;
+		return {
+			...result,
+			response
+		};
+	};
+}
+//#endregion
+//#region src/tanstack-start/create.ts
+/** TanStack Start integration: request middleware, guards and server function actions. */
+function createTanStackStart(betterSupabase, options = {}) {
+	const server = createServer(betterSupabase, options);
+	const expose = options.exposeErrors ?? defaultExpose();
+	const requests = /* @__PURE__ */ new WeakMap();
+	const served = tanStackStartServer(around([frameworkEntry(server, options, expose)]), options.platformEnv, (contributions, request) => {
+		const locals = localsOf(contributions);
+		requests.set(locals, request);
+		return locals;
+	});
+	const scopeOf = (context) => {
+		if (typeof context !== "object" || !("bs" in context)) throw new TypeError("better-supabase: no context; add bs.middleware to the request middleware in src/start.ts");
+		return context;
+	};
+	return extendServer(server, {
+		async middleware(args) {
+			try {
+				return await served(args);
+			} finally {
+				flushEvents(server, options.waitUntil);
+			}
+		},
+		require: async (context, requireOptions = {}) => {
+			const scope = scopeOf(context);
+			const caller = await requireCaller(scope.bs.auth, requireOptions, scope.tenant);
+			if ("kind" in caller) {
+				const request = requests.get(scope) ?? new Request("http://localhost/");
+				throw refusalResponse(caller, request, options, expose);
+			}
+			return {
+				...scope,
+				...caller
+			};
+		},
+		action(actionOptions, fn) {
+			return async ({ data, context }) => {
+				const scope = scopeOf(context);
+				return await runAction(scope.bs.auth, actionOptions, data, scope.tenant, (parsed, caller) => fn(parsed, {
+					...scope,
+					...caller
+				}));
+			};
+		}
+	});
+}
+//#endregion
+export { createTanStackStart, toTanStackStart };