better-supabase 0.3.0 → 0.4.0

package/dist/{live-QE3UPbGm.d.ts → live-BHakSWWo.d.ts}

@@ -1,6 +1,6 @@
 import { A as SchemaMeta, N as TableKey, O as Row, n as AnyModels, t as AnyFunctions, x as PermdockTopicPolicy } from "./types-DONv9SHN.js";
-import { b as ValidationIssue, o as Result, p as DbError, t as AsyncResult } from "./result-c2OYgCV2.js";
-import { Z as QuerySpec, t as BetterSupabase } from "./define-DUbydmJa.js";
+import { b as ValidationIssue, o as Result, p as DbError, t as AsyncResult } from "./result-CqEsbgYs.js";
+import { Z as QuerySpec, t as BetterSupabase } from "./define-CRS2MRV3.js";
 import { t as PermdockCatalog } from "./permdock-sql-DImJULY-.js";
 import { n as TemplateValues, t as TemplateParams } from "./template-mbvlysOo.js";
 import { RealtimeChannel, SupabaseClient } from "@supabase/supabase-js";
@@ -78,7 +78,7 @@ interface Subscription extends Disposable, AsyncDisposable {
   readonly ready: Promise<void>;
   unsubscribe(): Promise<void>;
 }
-type RealtimeClient = Pick<SupabaseClient, "channel" | "removeChannel" | "realtime">;
+type RealtimeClient = Pick<SupabaseClient, "channel" | "getChannels" | "removeChannel" | "realtime">;
 interface TriggerOptions<M extends AnyModels, T extends keyof M, P extends string> {
   /** Column that fills each placeholder. */
   readonly values: { readonly [K in TemplateParams<P>]: Extract<keyof Row<M, T>, string>; };
@@ -106,7 +106,7 @@ interface Topic<P extends string, E extends EventSchemas> {
   /** `realtime.messages` policies for this topic. Idempotent. */
   sql(): string;
   /** A trigger that broadcasts row changes (`realtime.broadcast_changes`) to this topic. */
-  triggerSql<M extends AnyModels, D, F extends AnyFunctions, X, T extends TableKey<M>>(sb: BetterSupabase<M, D, F, X>, table: T, options: TriggerOptions<M, T, P>): string;
+  triggerSql<M extends AnyModels, D, F extends AnyFunctions, X, T extends TableKey<M>>(betterSupabase: BetterSupabase<M, D, F, X>, table: T, options: TriggerOptions<M, T, P>): string;
   subscribe(client: RealtimeClient, values: TemplateValues<P>, handlers: TopicHandlers<E>, options?: SubscribeOptions): Subscription;
   /** Sends over HTTP, without joining the channel. */
   send<K extends TopicEvent<E>>(client: RealtimeClient, values: TemplateValues<P>, event: K, payload: TopicPayload<E, K>): AsyncResult<void>;
@@ -127,10 +127,10 @@ declare function defineTopic<const P extends string, const E extends EventSchema
  * Reads a `realtime.broadcast_changes` message as an app-cased row change.
  * Returns `null` for messages about other tables.
  */
-declare function rowChange<M extends AnyModels, D, F extends AnyFunctions, X, T extends TableKey<M>>(sb: BetterSupabase<M, D, F, X>, table: T, message: TopicMessage): RowChange<Row<M, T>> | null;
+declare function rowChange<M extends AnyModels, D, F extends AnyFunctions, X, T extends TableKey<M>>(betterSupabase: BetterSupabase<M, D, F, X>, table: T, message: TopicMessage): RowChange<Row<M, T>> | null;
 //#endregion
 //#region src/realtime/live.d.ts
-/** What `liveQuery` needs from `sb`: metadata and the tables a spec reads. */
+/** What `liveQuery` needs from `betterSupabase`: metadata and the tables a spec reads. */
 interface LiveSource {
   readonly meta: SchemaMeta;
   tablesOf(spec: QuerySpec): string[];
@@ -154,7 +154,7 @@ interface LiveSubscription extends Disposable, AsyncDisposable {
 }
 /**
  * A count from the server plus the spec to keep it live on the client:
- * `next.liveCount(spec)` makes one, `useLiveCount(seed)` reads it. `count`
+ * `bs.liveCount(spec)` makes one, `useLiveCount(seed)` reads it. `count`
  * is `null` when the server read failed; the client then fetches it.
  */
 interface LiveCountSeed<T extends string = string> {
@@ -170,11 +170,11 @@ declare function liveTopic(meta: SchemaMeta, table: string, tenant?: string): st
  * table, so any number of them can run at once.
  *
  * ```ts
- * using live = liveQuery(sb, supabase, spec, { onChange: () => refetch() });
+ * using live = liveQuery(betterSupabase, supabase, spec, { onChange: () => refetch() });
  * ```
  */
-declare function liveQuery(sb: LiveSource, client: RealtimeClient, spec: QuerySpec | readonly string[], options: LiveQueryOptions): LiveSubscription;
-/** What `liveCount` runs the spec with: a `db` from `sb.connect()` or `createBrowser()`. */
+declare function liveQuery(betterSupabase: LiveSource, client: RealtimeClient, spec: QuerySpec | readonly string[], options: LiveQueryOptions): LiveSubscription;
+/** What `liveCount` runs the spec with: a `db` from `betterSupabase.connect()` or `createClient()`. */
 interface CountRunner {
   $run(spec: QuerySpec): PromiseLike<Result<unknown>>;
 }
@@ -191,11 +191,11 @@ interface LiveCountOptions extends Omit<LiveQueryOptions, "onChange"> {
  * Responses that arrive out of order are dropped.
  *
  * ```ts
- * using live = liveCount(sb, supabase, db, sb.spec.notes.count(), {
+ * using live = liveCount(betterSupabase, supabase, db, betterSupabase.spec.notes.count(), {
  *   onCount: (count) => render(count),
  * });
  * ```
  */
-declare function liveCount(sb: LiveSource, client: RealtimeClient, db: CountRunner, spec: QuerySpec<string, "count", number>, options: LiveCountOptions): LiveSubscription;
+declare function liveCount(betterSupabase: LiveSource, client: RealtimeClient, db: CountRunner, spec: QuerySpec<string, "count", number>, options: LiveCountOptions): LiveSubscription;
 //#endregion
 export { defineTopic as C, TriggerOptions as S, TopicEvent as _, LiveSource as a, TopicOptions as b, liveQuery as c, RealtimeClient as d, RowChange as f, Topic as g, SubscriptionStatus as h, LiveQueryOptions as i, liveTopic as l, Subscription as m, LiveCountOptions as n, LiveSubscription as o, SubscribeOptions as p, LiveCountSeed as r, liveCount as s, CountRunner as t, EventSchemas as u, TopicHandlers as v, rowChange as w, TopicPayload as x, TopicMessage as y };

package/dist/{live-D8rV1Ldw.js → live-CdJBOc4f.js}

@@ -64,6 +64,10 @@ function join(client, topic, listener) {
 			left = true;
 			current.listeners.delete(listener);
 			if (current.listeners.size > 0) return;
+			await new Promise((resolve) => {
+				setTimeout(resolve, 0);
+			});
+			if (current.listeners.size > 0 || byTopic.get(topic) !== current) return;
 			byTopic.delete(topic);
 			await client.removeChannel(current.channel);
 		}
@@ -76,13 +80,13 @@ function join(client, topic, listener) {
 * table, so any number of them can run at once.
 *
 * ```ts
-* using live = liveQuery(sb, supabase, spec, { onChange: () => refetch() });
+* using live = liveQuery(betterSupabase, supabase, spec, { onChange: () => refetch() });
 * ```
 */
-function liveQuery(sb, client, spec, options) {
-	const touched = Array.isArray(spec) ? spec : sb.tablesOf(spec);
-	const tables = touched.filter((table) => sb.meta.realtime?.[table]);
-	const unwatched = touched.filter((table) => !sb.meta.realtime?.[table]);
+function liveQuery(betterSupabase, client, spec, options) {
+	const touched = Array.isArray(spec) ? spec : betterSupabase.tablesOf(spec);
+	const tables = touched.filter((table) => betterSupabase.meta.realtime?.[table]);
+	const unwatched = touched.filter((table) => !betterSupabase.meta.realtime?.[table]);
 	const debounceMs = options.debounceMs ?? 100;
 	const changed = /* @__PURE__ */ new Set();
 	let timer;
@@ -94,7 +98,7 @@ function liveQuery(sb, client, spec, options) {
 		changed.clear();
 		options.onChange(batch);
 	};
-	const memberships = tables.map((table) => join(client, liveTopic(sb.meta, table, options.tenant), () => {
+	const memberships = tables.map((table) => join(client, liveTopic(betterSupabase.meta, table, options.tenant), () => {
 		changed.add(table);
 		if (timer !== void 0) clearTimeout(timer);
 		timer = setTimeout(flush, debounceMs);
@@ -130,12 +134,12 @@ function liveQuery(sb, client, spec, options) {
 * Responses that arrive out of order are dropped.
 *
 * ```ts
-* using live = liveCount(sb, supabase, db, sb.spec.notes.count(), {
+* using live = liveCount(betterSupabase, supabase, db, betterSupabase.spec.notes.count(), {
 *   onCount: (count) => render(count),
 * });
 * ```
 */
-function liveCount(sb, client, db, spec, options) {
+function liveCount(betterSupabase, client, db, spec, options) {
 	let latest = 0;
 	let closed = false;
 	const refetch = () => {
@@ -146,7 +150,7 @@ function liveCount(sb, client, db, spec, options) {
 			else options.onError?.(result.error);
 		});
 	};
-	const live = liveQuery(sb, client, spec, {
+	const live = liveQuery(betterSupabase, client, spec, {
 		onChange: refetch,
 		...options.tenant === void 0 ? {} : { tenant: options.tenant },
 		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs },

package/dist/lookup-BaP5bI27.js

@@ -0,0 +1,18 @@
+//#region src/schema/lookup.ts
+const lookups = /* @__PURE__ */ new WeakMap();
+/** The cached lookup for a table; metadata is immutable after `defineSchema`. */
+function lookupOf(table) {
+	let lookup = lookups.get(table);
+	if (!lookup) {
+		const entries = Object.entries(table.columns);
+		lookup = {
+			entries,
+			byDb: new Map(entries.map((entry) => [entry[1].db, entry])),
+			keys: [table.primaryKey, ...Object.values(table.uniqueKeys)]
+		};
+		lookups.set(table, lookup);
+	}
+	return lookup;
+}
+//#endregion
+export { lookupOf as t };

package/dist/mcp/index.d.ts

@@ -1,7 +1,7 @@
 import { N as TableKey, n as AnyModels, t as AnyFunctions } from "../types-DONv9SHN.js";
-import { t as BetterSupabase } from "../define-DUbydmJa.js";
-import { d as ServerContext, f as ServerOptions, l as BetterServer, n as GuardOptions } from "../respond-DAkPIdTH.js";
-import { a as ResourceRouteOptions } from "../resource-CwVgiI5q.js";
+import { t as BetterSupabase } from "../define-CRS2MRV3.js";
+import { f as ServerContext, n as GuardOptions, p as ServerOptions, u as BetterServer } from "../respond-DgIbdrt8.js";
+import { a as ResourceRouteOptions } from "../resource-BJcaIfxi.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/mcp/mcp.d.ts
 export declare const MCP_PROTOCOL_VERSION: string;
@@ -23,17 +23,17 @@ interface ToolInfo {
   readonly outputSchema?: Json;
   readonly annotations?: ToolAnnotations;
 }
-interface ToolContext<M extends AnyModels, F extends AnyFunctions, E> extends ServerContext<M, F, E> {
+interface ToolContext<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends ServerContext<M, F, E, C, P> {
   readonly request: Request;
   readonly signal: AbortSignal;
 }
-interface McpTool<M extends AnyModels, F extends AnyFunctions, E> {
+interface McpTool<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> {
   readonly info: ToolInfo;
   /** Validates arguments; its output is what `run` receives. */
   readonly input?: StandardSchemaV1;
   /** Opaque data for the `authorize` and `visible` hooks. Never sent to clients. */
   readonly meta?: unknown;
-  run(args: never, ctx: ToolContext<M, F, E>): unknown;
+  run(args: never, ctx: ToolContext<M, F, E, C, P>): unknown;
 }
 /** What the `authorize` and `visible` hooks see of a tool. */
 interface ToolRef {
@@ -50,7 +50,7 @@ type ToolDecision = {
   /** OAuth scopes the call needs, sent in an `insufficient_scope` challenge. */
   readonly scopes?: readonly string[];
 };
-interface ToolDefinition<M extends AnyModels, F extends AnyFunctions, E, I> {
+interface ToolDefinition<M extends AnyModels, F extends AnyFunctions, E, I, C = unknown, P = unknown> {
   readonly name: string;
   readonly title?: string;
   readonly description: string;
@@ -64,10 +64,10 @@ interface ToolDefinition<M extends AnyModels, F extends AnyFunctions, E, I> {
   readonly annotations?: ToolAnnotations;
   /** Opaque data for the `authorize` and `visible` hooks. Never sent to clients. */
   readonly meta?: unknown;
-  run(args: I, ctx: ToolContext<M, F, E>): unknown;
+  run(args: I, ctx: ToolContext<M, F, E, C, P>): unknown;
 }
 type ToolResources<M extends AnyModels> = { readonly [T in TableKey<M>]?: ResourceRouteOptions<M, T> | true; };
-interface McpOptions<M extends AnyModels, F extends AnyFunctions, E> extends ServerOptions, GuardOptions {
+interface McpOptions<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends ServerOptions, GuardOptions {
   readonly name: string;
   readonly version: string;
   readonly title?: string;
@@ -75,7 +75,7 @@ interface McpOptions<M extends AnyModels, F extends AnyFunctions, E> extends Ser
   readonly instructions?: string;
   /** Tables exposed as tools: `<table>_list`, `_get`, `_create`, `_update`, `_delete`. */
   readonly resources?: ToolResources<M>;
-  readonly tools?: readonly McpTool<M, F, E>[];
+  readonly tools?: readonly McpTool<M, F, E, C, P>[];
   /**
    * Canonical URL of this MCP server (RFC 9728 `resource`). Defaults to the
    * request URL without query.
@@ -108,25 +108,25 @@ interface McpOptions<M extends AnyModels, F extends AnyFunctions, E> extends Ser
    * validate in the repository). A refusal is a tool error; a refusal with
    * `scopes` is a 403 `insufficient_scope` challenge naming them.
    */
-  readonly authorize?: (ctx: ToolContext<M, F, E>, tool: ToolRef, args: unknown) => ToolDecision | Promise<ToolDecision>;
+  readonly authorize?: (ctx: ToolContext<M, F, E, C, P>, tool: ToolRef, args: unknown) => ToolDecision | Promise<ToolDecision>;
   /**
    * Whether the caller sees a tool in `tools/list`. A hidden tool is called
    * like an unknown one. Lists are cached per token (`cacheScope: 'private'`).
    */
-  readonly visible?: (ctx: ToolContext<M, F, E>, tool: ToolRef) => boolean | Promise<boolean>;
+  readonly visible?: (ctx: ToolContext<M, F, E, C, P>, tool: ToolRef) => boolean | Promise<boolean>;
 }
-interface BetterMcp<M extends AnyModels, F extends AnyFunctions, E> extends BetterServer<M, F, E> {
+interface BetterMcp<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
   /** Everything in one handler: the MCP endpoint and `/.well-known/oauth-protected-resource`. */
   readonly fetch: (request: Request) => Promise<Response>;
   /** The Streamable HTTP endpoint (POST JSON-RPC). */
-  readonly handler: (request: Request) => Promise<Response>;
+  readonly endpoint: (request: Request) => Promise<Response>;
   /** RFC 9728 protected resource metadata. */
   metadata(request: Request): Response;
   readonly tools: readonly ToolInfo[];
   /** Adds a tool typed against this app's repositories. */
-  tool<I = Record<string, unknown>>(definition: ToolDefinition<M, F, E, I>): this;
+  tool<I = Record<string, unknown>>(definition: ToolDefinition<M, F, E, I, C, P>): this;
   /** Calls a tool directly, e.g. from tests or another transport. */
-  call(name: string, args: unknown, ctx: ToolContext<M, F, E>): Promise<ToolResult>;
+  call(name: string, args: unknown, ctx: ToolContext<M, F, E, C, P>): Promise<ToolResult>;
 }
 interface ToolResult {
   readonly content: readonly {
@@ -137,13 +137,13 @@ interface ToolResult {
   readonly isError?: boolean;
 }
 /** A custom tool. Pass it in `createMcp({ tools: [...] })`. */
-export declare function defineTool<M extends AnyModels, F extends AnyFunctions, E, I = Record<string, unknown>>(definition: ToolDefinition<M, F, E, I>): McpTool<M, F, E>;
+export declare function defineTool<M extends AnyModels, F extends AnyFunctions, E, I = Record<string, unknown>, C = unknown, P = unknown>(definition: ToolDefinition<M, F, E, I, C, P>): McpTool<M, F, E, C, P>;
 /**
  * An MCP server (Streamable HTTP, stateless) whose tools run as the caller:
  * the Bearer token from the MCP client is verified and every query goes
  * through RLS. Answers 401 with RFC 9728 metadata so clients can sign in with
  * Supabase Auth's OAuth server.
  */
-export declare function createMcp<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>, options: McpOptions<M, F, E>): BetterMcp<M, F, E>;
+export declare function createMcp<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options: McpOptions<M, F, E, C, P>): BetterMcp<M, F, E, C, P>;
 //#endregion
 export type { BetterMcp, GuardOptions, McpOptions, McpTool, ResourceRouteOptions, ToolAnnotations, ToolContext, ToolDecision, ToolDefinition, ToolInfo, ToolRef, ToolResources, ToolResult };

package/dist/mcp/index.js

@@ -1,11 +1,11 @@
-import { n as dbError } from "../errors-Bl3rkOzo.js";
-import { t as base64ToText } from "../base64-CQeB1eSf.js";
-import { t as validate } from "../standard-FUi3Z3-7.js";
-import { o as toProblem } from "../problem-CGt1ADix.js";
+import { n as dbError } from "../errors-L0xK41y_.js";
+import { t as base64ToText } from "../base64-D2gsioCY.js";
+import { t as validate } from "../standard-BRyBGTtp.js";
+import { o as toProblem } from "../problem-BihjPR0t.js";
 import { t as SPEC_PINS } from "../spec-pins-C3oc-Tdp.js";
-import { t as buildJsonSchema } from "../json-schema--aOXAGfU.js";
-import { a as settle, c as withExtra, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-C44EZAJo.js";
-import { t as defineResource } from "../resource-D30rp0GN.js";
+import { t as buildJsonSchema } from "../json-schema-DP6V7cbr.js";
+import { a as guard, c as settle, i as defaultExpose, n as extendServer, r as withExtra, t as createServer } from "../server-BA75B0mT.js";
+import { t as defineResource } from "../resource-My_y-Syh.js";
 import { fromSupabaseUrl, unauthorizedResponse } from "@supabase/server/oauth-protected-resource";
 //#region src/mcp/mcp.ts
 const MCP_PROTOCOL_VERSION = SPEC_PINS.mcp;
@@ -231,17 +231,19 @@ function canonical(request) {
 * through RLS. Answers 401 with RFC 9728 metadata so clients can sign in with
 * Supabase Auth's OAuth server.
 */
-function createMcp(sb, options) {
-	const server = createServer(sb, options);
+function createMcp(betterSupabase, options) {
+	const server = createServer(betterSupabase, options);
 	const expose = options.exposeErrors ?? defaultExpose();
 	const defs = buildJsonSchema({
-		meta: sb.meta,
+		meta: betterSupabase.meta,
 		config: { json: options.json ?? {} }
 	})["$defs"];
 	const registry = /* @__PURE__ */ new Map();
+	let allTools;
 	const register = (entry) => {
 		if (registry.has(entry.info.name)) throw new TypeError(`Duplicate MCP tool "${entry.info.name}"`);
 		registry.set(entry.info.name, entry);
+		allTools = void 0;
 	};
 	const failure = (error) => textResult(toProblem(error, { expose }), true);
 	const refused = async (tool, args, ctx) => {
@@ -256,7 +258,7 @@ function createMcp(sb, options) {
 	const isVisible = async (tool, ctx) => !options.visible || options.visible(ctx, tool);
 	for (const [table, raw] of Object.entries(options.resources ?? {})) {
 		if (!raw) continue;
-		const resource = defineResource(sb, table, raw === true ? {} : raw);
+		const resource = defineResource(betterSupabase, table, raw === true ? {} : raw);
 		for (const { info, operation } of tableTools(resource, defs)) {
 			const ref = {
 				info,
@@ -302,8 +304,11 @@ function createMcp(sb, options) {
 		});
 	};
 	for (const tool of options.tools ?? []) addTool(tool);
-	const listTools = () => [...registry.values()].map((entry) => entry.info);
-	const visibleTools = async (ctx) => {
+	const listTools = () => allTools ??= [...registry.values()].map((entry) => entry.info);
+	/** Without a `visible` hook every caller sees the same list, built once. */
+	const visibleTools = async (context) => {
+		if (!options.visible) return listTools();
+		const ctx = context();
 		const entries = [...registry.values()];
 		const shown = await Promise.all(entries.map((entry) => isVisible(entry, ctx)));
 		return entries.filter((_, index) => shown[index]).map((e) => e.info);
@@ -376,7 +381,7 @@ function createMcp(sb, options) {
 			if (sent === null || headerName(sent) !== name) return mismatch(`Mcp-Name must be ${name}`);
 		}
 	};
-	const handler = async (request) => {
+	const endpoint = async (request) => {
 		const origin = request.headers.get("origin");
 		if (origin && options.allowedOrigins && !options.allowedOrigins.includes(origin)) return rpcError(null, INVALID_REQUEST, "Origin not allowed", 403);
 		if (options.allowedHosts && !hostAllowed(request, options.allowedHosts)) return rpcError(null, INVALID_REQUEST, "Host not allowed", 403);
@@ -437,7 +442,7 @@ function createMcp(sb, options) {
 			}
 			case "ping": return modern ? notFound() : reply({});
 			case "tools/list": return reply({
-				tools: await visibleTools(toolContext()),
+				tools: await visibleTools(toolContext),
 				...modern ? {
 					ttlMs: LIST_TTL_MS,
 					cacheScope: "private"
@@ -465,14 +470,14 @@ function createMcp(sb, options) {
 	}, { headers: { "access-control-allow-origin": "*" } });
 	const mcp = extendServer(server, {
 		get tools() {
-			return listTools();
+			return [...listTools()];
 		},
 		tool(definition) {
 			addTool(defineTool(definition));
 			return mcp;
 		},
 		call,
-		handler,
+		endpoint,
 		metadata,
 		fetch(request) {
 			const { pathname } = new URL(request.url);
@@ -483,7 +488,7 @@ function createMcp(sb, options) {
 					"access-control-allow-methods": "GET"
 				}
 			}) : metadata(request));
-			return handler(request);
+			return endpoint(request);
 		}
 	});
 	return mcp;

package/dist/{mfa-x3V3vGh-.d.ts → mfa-C7MNQ1Ob.d.ts}

@@ -1,4 +1,4 @@
-import { p as DbError } from "./result-c2OYgCV2.js";
+import { p as DbError } from "./result-CqEsbgYs.js";
 //#region src/auth/impersonation.d.ts
 /** The admin acting as the user, from the RFC 8693 `act` claim. */
 interface Impersonator {