better-supabase 0.5.0 → 0.6.0

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 };

package/dist/tee-CoEppCER.js

@@ -0,0 +1,101 @@
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-DzUbqgdW.js";
+//#region src/streams/tee.ts
+/**
+* Copies `source` into `store` under `id` while passing it through. Chunks
+* are written in batches, each at its own index, so a reader that counted
+* `n` chunks of the live stream resumes with `read(id, n)`.
+*/
+function teeToStore(store, id, source, options = {}) {
+	const [live, copy] = source.tee();
+	return {
+		stream: live,
+		persisted: AsyncResult.from(() => persist(store, id, copy, options))
+	};
+}
+/**
+* Stores `source` under `id` without a live copy, for a stream the caller
+* already sends elsewhere (the second branch of its own `tee()`). Settles
+* like `teeToStore`'s `persisted`.
+*/
+function writeToStore(store, id, source, options = {}) {
+	return AsyncResult.from(() => persist(store, id, source, options));
+}
+async function persist(store, id, copy, options) {
+	const { flushMs = 100, flushBytes = 4096, onCancel } = options;
+	const opened = await store.open(id, {
+		...options.owner === void 0 ? {} : { owner: options.owner },
+		...options.tenant === void 0 ? {} : { tenant: options.tenant },
+		...options.kind === void 0 ? {} : { kind: options.kind },
+		...options.ttl === void 0 ? {} : { ttl: options.ttl }
+	});
+	if (!opened.ok) {
+		copy.cancel().catch(() => void 0);
+		return opened;
+	}
+	let next = 0;
+	let buffer = [];
+	let bytes = 0;
+	let failure;
+	let cancelled = false;
+	let timer;
+	let writing = Promise.resolve();
+	const flush = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+		if (buffer.length === 0) return writing;
+		const batch = buffer;
+		const from = next;
+		buffer = [];
+		bytes = 0;
+		next += batch.length;
+		writing = writing.then(async () => {
+			if (failure) return;
+			const appended = await store.append(id, from, batch);
+			if (!appended.ok) {
+				failure = appended.error;
+				return;
+			}
+			if (appended.data.cancelled && !cancelled) {
+				cancelled = true;
+				onCancel?.();
+			}
+		});
+		return writing;
+	};
+	const reader = copy.getReader();
+	let sourceError;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer.push(value);
+			bytes += value.length;
+			if (bytes >= flushBytes) flush();
+			else timer ??= setTimeout(() => void flush(), flushMs);
+			if (failure) break;
+		}
+	} catch (cause) {
+		sourceError = cause;
+	} finally {
+		reader.releaseLock();
+	}
+	await flush();
+	if (failure) {
+		copy.cancel().catch(() => void 0);
+		return err(failure);
+	}
+	const closed = await store.close(id);
+	if (!closed.ok) return closed;
+	return sourceError === void 0 ? ok(next) : err(toDbError(sourceError));
+}
+/**
+* The rest of stream `id` from `fromIdx`, or `undefined` when there is
+* nothing to resume: no such stream, or a closed one the client has read to
+* the end. A route answers `undefined` with 204.
+*/
+function resumeFromStore(store, id, options = {}) {
+	const from = options.fromIdx ?? 0;
+	return store.status(id).map((status) => status === void 0 || status.closed && from >= status.next ? void 0 : store.read(id, from, options.signal === void 0 ? {} : { signal: options.signal }));
+}
+//#endregion
+export { teeToStore as n, writeToStore as r, resumeFromStore as t };

package/dist/{template-TxrGI5jR.js → template--jDkl3UP.js}

@@ -1,6 +1,7 @@
-import { n as dbError, t as DbException } from "./errors-DtwXa6b8.js";
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { n as dbError } from "./errors-B11Duf73.js";
 //#region src/core/template.ts
-const PLACEHOLDER = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+const PLACEHOLDER = /\{(\.\.\.)?([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function parseSegment(segment) {
 	const parts = [];
 	let last = 0;
@@ -10,8 +11,8 @@ function parseSegment(segment) {
 			text: segment.slice(last, match.index)
 		});
 		parts.push({
-			kind: "param",
-			name: match[1]
+			kind: match[1] ? "rest" : "param",
+			name: match[2]
 		});
 		last = match.index + match[0].length;
 	}
@@ -22,14 +23,20 @@ function parseSegment(segment) {
 	return parts;
 }
 const escapeRegex = (text) => text.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
-function parseTemplate(source, separator, validate) {
+function parseTemplate(source, separator, validate, options = {}) {
 	const segments = source.split(separator).map(parseSegment);
 	const params = [];
-	for (const segment of segments) {
+	let rest;
+	for (const [position, segment] of segments.entries()) {
 		if (segment.length === 0) throw new TypeError(`Template "${source}" has an empty segment`);
-		for (let index = 1; index < segment.length; index++) if (segment[index].kind === "param" && segment[index - 1].kind === "param") throw new TypeError(`Template "${source}" has adjacent placeholders`);
+		for (let index = 1; index < segment.length; index++) if (segment[index].kind !== "literal" && segment[index - 1].kind !== "literal") throw new TypeError(`Template "${source}" has adjacent placeholders`);
 		for (const part of segment) {
-			if (part.kind !== "param") continue;
+			if (part.kind === "literal") continue;
+			if (part.kind === "rest") {
+				if (!options.rest) throw new TypeError(`Template "${source}" uses {...${part.name}}, which is not supported here`);
+				if (segment.length !== 1 || position !== segments.length - 1) throw new TypeError(`Template "${source}": {...${part.name}} must be the whole last segment`);
+				rest = part.name;
+			}
 			if (params.includes(part.name)) throw new TypeError(`Template "${source}" repeats {${part.name}}`);
 			params.push(part.name);
 		}
@@ -37,12 +44,25 @@ function parseTemplate(source, separator, validate) {
 	if (/[{}]/.test(segments.flat().map((part) => part.kind === "literal" ? part.text : "").join(""))) throw new TypeError(`Template "${source}" has an unbalanced brace`);
 	const sep = escapeRegex(separator);
 	const valueClass = `[^${separator === "/" ? "/" : sep}]+`;
-	const regexFor = (named) => segments.map((segment) => segment.map((part) => part.kind === "literal" ? escapeRegex(part.text) : named ? `(?<${part.name}>${valueClass})` : valueClass).join("")).join(sep);
+	const restClass = `${valueClass}(?:${sep}${valueClass})*`;
+	const regexFor = (withNames) => segments.map((segment) => segment.map((part) => {
+		if (part.kind === "literal") return escapeRegex(part.text);
+		const pattern = part.kind === "rest" ? restClass : valueClass;
+		return withNames ? `(?<${part.name}>${pattern})` : pattern;
+	}).join("")).join(sep);
 	const matcher = new RegExp(`^${regexFor(true)}$`);
+	const valueProblem = (name, value) => value === "" ? "is empty" : value.includes(separator) ? `contains "${separator}"` : validate(name, value);
+	const restProblem = (name, value) => {
+		if (value === "") return "is empty";
+		for (const part of value.split(separator)) {
+			const problem = part === "" ? "has an empty segment" : validate(name, part);
+			if (problem) return problem;
+		}
+	};
 	const render = (name, raw) => {
 		if (raw === void 0 || typeof raw !== "string" && typeof raw !== "number") throw new DbException(dbError("invalid_input", `Missing value for {${name}}`));
 		const value = String(raw);
-		const problem = value === "" ? "is empty" : value.includes(separator) ? `contains "${separator}"` : validate(name, value);
+		const problem = rest === name ? restProblem(name, value) : valueProblem(name, value);
 		if (problem) throw new DbException(dbError("invalid_input", `Value for {${name}} ${problem}`));
 		return value;
 	};
@@ -59,7 +79,7 @@ function parseTemplate(source, separator, validate) {
 			const out = {};
 			for (const name of params) {
 				const part = found.groups[name];
-				if (validate(name, part)) return null;
+				if (rest === name ? restProblem(name, part) : validate(name, part)) return null;
 				out[name] = part;
 			}
 			return out;
@@ -67,7 +87,7 @@ function parseTemplate(source, separator, validate) {
 		prefix(values, maxSegments = segments.length) {
 			const out = [];
 			for (const segment of segments.slice(0, maxSegments)) {
-				if (segment.some((part) => part.kind === "param" && values[part.name] === void 0)) break;
+				if (segment.some((part) => part.kind !== "literal" && values[part.name] === void 0)) break;
 				out.push(renderSegment(segment, values));
 			}
 			return out.join(separator);
@@ -76,7 +96,8 @@ function parseTemplate(source, separator, validate) {
 			const index = segments.findIndex((segment) => segment.length === 1 && segment[0].kind === "param" && segment[0].name === name);
 			return index === -1 ? void 0 : index + 1;
 		},
-		sqlPattern: `^${regexFor(false)}$`
+		sqlPattern: `^${regexFor(false)}$`,
+		rest
 	};
 }
 function sqlString(value) {

package/dist/template-CwO38Do8.d.ts

@@ -0,0 +1,6 @@
+//#region src/core/template.d.ts
+/** Placeholder names in a `{name}` template; a rest placeholder `{...name}` is `name`. */
+type TemplateParams<P extends string> = P extends `${string}{${infer K}}${infer R}` ? (K extends `...${infer N}` ? N : K) | TemplateParams<R> : never;
+type TemplateValues<P extends string> = { readonly [K in TemplateParams<P>]: string | number; };
+//#endregion
+export { TemplateValues as n, TemplateParams as t };

package/dist/temporal-BJGitm-h.js

@@ -0,0 +1,79 @@
+const TEMPORAL_MISSING = `Temporal is not available in this runtime. Pass it to defineSupabase(schema, { temporal }) (import { Temporal } from "temporal-polyfill"), or import "temporal-polyfill/global" once at startup.`;
+let provided;
+/**
+* Uses `namespace` wherever better-supabase needs Temporal, without touching
+* `globalThis`. `defineSupabase(schema, { temporal })` calls it; call it
+* yourself when you use a standalone helper (webhook verification, jobs)
+* without a definition. `undefined` goes back to the global.
+*/
+function provideTemporal(namespace) {
+	provided = namespace;
+}
+/** The namespace `provideTemporal` set, without the global fallback. */
+function providedTemporal() {
+	return provided;
+}
+/** The provided `Temporal`, else the runtime's, or `undefined` when neither exists. */
+function optionalTemporal() {
+	if (provided !== void 0) return provided;
+	return globalThis.Temporal;
+}
+/**
+* The current instant, the default `now` everywhere. Without Temporal it
+* throws a `TypeError` that names the injection option and the polyfill.
+*/
+function nowInstant() {
+	const namespace = optionalTemporal();
+	if (namespace === void 0) throw new TypeError(TEMPORAL_MISSING);
+	return namespace.Now.instant();
+}
+const ISO_TAGS = /* @__PURE__ */ new Set([
+	"Temporal.Instant",
+	"Temporal.PlainDateTime",
+	"Temporal.PlainDate",
+	"Temporal.PlainTime"
+]);
+function tagOf(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	if (!(Symbol.toStringTag in value)) return void 0;
+	return value[Symbol.toStringTag];
+}
+/**
+* The text Postgres reads back for a Temporal value: ISO 8601, with a
+* `ZonedDateTime` sent as its instant because Postgres rejects the
+* `[Region/City]` annotation. `undefined` for anything else.
+*
+* Values are recognized by `Symbol.toStringTag`, not `instanceof`, so values
+* from another realm or a second copy of the polyfill still encode.
+*/
+function temporalText(value) {
+	const tag = tagOf(value);
+	if (tag === void 0) return void 0;
+	if (ISO_TAGS.has(tag)) return String(value);
+	return tag === "Temporal.ZonedDateTime" && typeof value === "object" && value !== null && isZoned(value) ? String(value.toInstant()) : void 0;
+}
+function isZoned(value) {
+	return "toInstant" in value && typeof value.toInstant === "function";
+}
+/** A `Temporal.Instant` from any copy of Temporal, checked by `Symbol.toStringTag`. */
+function isInstant(value) {
+	return tagOf(value) === "Temporal.Instant";
+}
+/** A `Temporal.PlainDateTime` from any copy of Temporal. */
+function isPlainDateTime(value) {
+	return tagOf(value) === "Temporal.PlainDateTime";
+}
+/** A `Temporal.PlainDate` from any copy of Temporal. */
+function isPlainDate(value) {
+	return tagOf(value) === "Temporal.PlainDate";
+}
+/** A `Temporal.PlainTime` from any copy of Temporal. */
+function isPlainTime(value) {
+	return tagOf(value) === "Temporal.PlainTime";
+}
+/** A `Temporal.ZonedDateTime` from any copy of Temporal. */
+function isZonedDateTime(value) {
+	return tagOf(value) === "Temporal.ZonedDateTime";
+}
+//#endregion
+export { isPlainTime as a, optionalTemporal as c, temporalText as d, isPlainDateTime as i, provideTemporal as l, isInstant as n, isZonedDateTime as o, isPlainDate as r, nowInstant as s, TEMPORAL_MISSING as t, providedTemporal as u };

package/dist/{temporal-required-CAt4Dc9Z.js → temporal-required-BVvW7SYJ.js}

@@ -1,5 +1,6 @@
-import { n as dbError, t as DbException } from "./errors-DtwXa6b8.js";
-import { r as optionalTemporal, t as TEMPORAL_MISSING } from "./temporal-CVlIV2DZ.js";
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { n as dbError } from "./errors-B11Duf73.js";
+import { c as optionalTemporal, t as TEMPORAL_MISSING } from "./temporal-BJGitm-h.js";
 //#region src/core/temporal-required.ts
 /** The error for a runtime without Temporal, naming the polyfill to load. */
 function temporalMissing() {

package/dist/tenant-I1TEZ_BX.js

@@ -0,0 +1,27 @@
+import { a as tenantClaimPaths, n as claimAt } from "./claims-PqzCxaTD.js";
+//#region src/auth/tenant.ts
+/**
+* The active tenant of a user session: the `claim` claim (`tenant_id` by
+* default, as `config.claims.tenant`) at the top level of the token, then in
+* `app_metadata`. `undefined` for every other session. Takes a server
+* session or the client's `useAuth()` snapshot.
+*
+* ```ts
+* const organizationId = tenantOf(await bs.session());
+* const organizationId = tenantOf(useAuth());
+* ```
+*/
+function tenantOf(session, claim) {
+	const claims = claimsOf(session);
+	if (claims === void 0) return void 0;
+	for (const path of tenantClaimPaths(claim)) {
+		const value = claimAt(claims, path);
+		if (value !== void 0) return value;
+	}
+}
+function claimsOf(session) {
+	if ("kind" in session) return session.kind === "user" ? session.claims : void 0;
+	return session.status === "signed-in" ? session.claims : void 0;
+}
+//#endregion
+export { tenantOf as t };

package/dist/tenant-icPeuUBN.d.ts

@@ -0,0 +1,17 @@
+import { t as AuthSnapshot } from "./bind-Bu_ZNa3W.js";
+import { t as AuthSession } from "./view-DbxLNu8L.js";
+//#region src/auth/tenant.d.ts
+/**
+ * The active tenant of a user session: the `claim` claim (`tenant_id` by
+ * default, as `config.claims.tenant`) at the top level of the token, then in
+ * `app_metadata`. `undefined` for every other session. Takes a server
+ * session or the client's `useAuth()` snapshot.
+ *
+ * ```ts
+ * const organizationId = tenantOf(await bs.session());
+ * const organizationId = tenantOf(useAuth());
+ * ```
+ */
+declare function tenantOf<C, P>(session: AuthSession<C, P> | AuthSnapshot, claim?: string): string | undefined;
+//#endregion
+export { tenantOf as t };