better-supabase 0.7.1 → 0.8.0

package/dist/{hooks-1BTCJsiw.js → hooks-Bhza9Hnr.js}

@@ -1,6 +1,5 @@
-import { r as invalidateTables, t as clearOnUserChange } from "./user-change-XzvgafU4.js";
-import { n as sessionUserId, r as specKey, t as claimedTenant } from "./keys-4MnkWTTh.js";
-import { n as liveQuery, t as liveCount } from "./live-CTAZQkwl.js";
+import { t as clearOnUserChange } from "./user-change-XzvgafU4.js";
+import { c as liveKey, d as shownCount, f as startBroadcast, g as specKey, h as sessionUserId, i as countSource, m as startLiveQuery, p as startLiveCount, t as NO_COUNT } from "./client-wxeTQFtB.js";
 import { useSession } from "./react/session.js";
 import { createContext, createElement, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 //#region src/react/hooks.ts
@@ -89,29 +88,14 @@ function useBroadcast(topic, values, handlers, options) {
 	if (options?.invalidate && !queryClient) throw new Error("better-supabase: useBroadcast({ invalidate }) needs <BetterSupabaseProvider queryClient={...}> or { queryClient }");
 	useEffect(() => {
 		if (!name || auth.status === "loading") return;
-		const matched = topic.match(name);
-		if (!matched) return;
-		const forward = (payload, message) => {
-			const current = latest.current;
-			const table = current.handlers;
-			(table?.[message.event] ?? table?.["*"])?.(payload, message);
-			const invalidate = current.options?.invalidate;
-			if (!invalidate || !queryClient) return;
-			if (typeof invalidate !== "function") {
-				invalidateTables(queryClient, invalidate);
-				return;
-			}
-			for (const queryKey of invalidate(message)) queryClient.invalidateQueries({ queryKey });
-		};
-		const subscription = topic.subscribe(supabase, matched, { "*": forward }, {
-			...self === void 0 ? {} : { self },
-			onStatus: setStatus,
-			onInvalid: (message, issues) => latest.current.options?.onInvalid?.(message, issues)
+		return startBroadcast({
+			supabase,
+			topic,
+			name,
+			latest: () => latest.current,
+			queryClient,
+			onStatus: setStatus
 		});
-		return () => {
-			subscription.unsubscribe();
-			setStatus("closed");
-		};
 	}, [
 		supabase,
 		topic,
@@ -187,32 +171,33 @@ function useLiveQuery(spec, options = {}) {
 	if (spec && !queryClient) throw new Error("better-supabase: useLiveQuery needs <BetterSupabaseProvider queryClient={...}>");
 	const held = useHeldSpec(spec);
 	const joined = useRef(null);
-	const tenant = options.tenant ?? claimedTenant(auth, client.betterSupabase.meta);
-	const userId = auth.user?.id ?? null;
-	const debounceMs = options.debounceMs;
+	const key = liveKey(client, held.spec, auth, options);
+	const latest = useRef({
+		auth,
+		options
+	});
+	latest.current = {
+		auth,
+		options
+	};
 	useEffect(() => {
-		if (!held.spec || !queryClient || auth.status === "loading") return;
+		if (key === null || !held.spec || !queryClient) return;
 		const resumed = joined.current === held.key;
 		joined.current = held.key;
-		const live = liveQuery(client.betterSupabase, client.supabase, held.spec, {
-			onChange: (tables) => void invalidateTables(queryClient, tables),
-			onStatus: setStatus,
-			...tenant === void 0 ? {} : { tenant },
-			...userId === null ? {} : { user: userId },
-			...debounceMs === void 0 ? {} : { debounceMs }
+		return startLiveQuery({
+			client,
+			queryClient,
+			spec: held.spec,
+			auth: latest.current.auth,
+			options: latest.current.options,
+			resumed,
+			onStatus: setStatus
 		});
-		if (resumed) live.ready.then(() => void invalidateTables(queryClient, live.tables), () => void 0);
-		return () => {
-			live.unsubscribe();
-		};
 	}, [
 		client,
 		queryClient,
 		held,
-		tenant,
-		userId,
-		auth.status,
-		debounceMs
+		key
 	]);
 	return status;
 }
@@ -229,80 +214,63 @@ function useLiveQuery(spec, options = {}) {
 function useLiveCount(source, options = {}) {
 	const { client } = useClientContext();
 	const auth = useAuth();
-	const seed = source && "spec" in source ? source : void 0;
-	const spec = seed ? seed.spec : source;
-	const initial = seed?.count ?? options.initial;
-	const [state, setState] = useState({
-		key: null,
-		count: void 0,
-		at: 0,
-		error: void 0
-	});
+	const parsed = countSource(source, options);
+	const [state, setState] = useState(NO_COUNT);
+	const stateRef = useRef(NO_COUNT);
 	const [status, setStatus] = useState("closed");
-	const held = useHeldSpec(spec);
+	const held = useHeldSpec(parsed.spec);
 	const joined = useRef(null);
-	const tenant = options.tenant ?? claimedTenant(auth, client.betterSupabase.meta);
-	const userId = auth.user?.id ?? null;
-	const debounceMs = options.debounceMs;
-	const hasInitial = initial !== void 0;
-	const seedAt = seed?.at;
+	const key = liveKey(client, held.spec, auth, options);
+	const latest = useRef({
+		auth,
+		options
+	});
+	latest.current = {
+		auth,
+		options
+	};
+	const hasInitial = parsed.initial !== void 0;
+	const { seedAt } = parsed;
 	useEffect(() => {
-		if (!held.spec || auth.status === "loading") return;
-		const key = held.key;
-		const previous = joined.current?.key === key ? joined.current : null;
+		if (key === null || !held.spec || held.key === null) return;
+		const specKey = held.key;
+		const previous = joined.current?.key === specKey ? joined.current : null;
 		joined.current = {
-			key,
+			key: specKey,
 			at: previous?.at ?? seedAt ?? 0
 		};
-		const since = previous ? previous.at : seedAt;
-		const live = liveCount(client.betterSupabase, client.supabase, client.db, held.spec, {
+		return startLiveCount({
+			client,
+			spec: held.spec,
+			key: specKey,
+			auth: latest.current.auth,
+			options: latest.current.options,
 			immediate: !hasInitial && !previous,
-			...since === void 0 ? {} : { since },
-			onCount: (count) => {
-				const at = Date.now();
-				if (joined.current?.key === key) joined.current = {
-					key,
-					at
+			since: previous ? previous.at : seedAt,
+			onState: (update) => {
+				const next = update(stateRef.current);
+				stateRef.current = next;
+				if (next.error === void 0 && joined.current?.key === specKey) joined.current = {
+					key: specKey,
+					at: next.at
 				};
-				setState({
-					key,
-					count,
-					at,
-					error: void 0
-				});
+				setState(next);
 			},
-			onError: (error) => {
-				setState((last) => ({
-					key,
-					count: last.key === key ? last.count : void 0,
-					at: last.key === key ? last.at : 0,
-					error
-				}));
-			},
-			onStatus: setStatus,
-			...tenant === void 0 ? {} : { tenant },
-			...userId === null ? {} : { user: userId },
-			...debounceMs === void 0 ? {} : { debounceMs }
+			onStatus: setStatus
 		});
-		return () => {
-			live.unsubscribe();
-		};
 	}, [
 		client,
-		held,
-		tenant,
-		userId,
-		auth.status,
-		debounceMs,
+		held.spec,
+		held.key,
+		key,
 		hasInitial,
 		seedAt
 	]);
-	const fresh = state.key === held.key;
-	const seedNewer = seedAt !== void 0 && seed?.count !== null && seedAt > state.at;
+	const shown = shownCount(state, held.key, parsed);
 	return {
-		count: fresh && state.count !== void 0 && !seedNewer ? state.count : initial,
+		count: shown.count,
 		status,
-		error: fresh ? state.error : void 0
+		error: shown.error
 	};
 }
 //#endregion

package/dist/http-sbmBe5d2.js

@@ -0,0 +1,25 @@
+import { n as dbError } from "./errors-2M6CKMP4.js";
+import { o as problemResponse } from "./problem-CJvFeGu7.js";
+import { UI_MESSAGE_STREAM_HEADERS } from "ai";
+//#region src/ai-sdk/http.ts
+/** A 400 problem response for a malformed chat request. */
+function badRequest(message) {
+	return problemResponse(dbError("invalid_request", message, { code: "AI_CHAT_BAD_REQUEST" }));
+}
+/** The JSON body of a request, or `undefined` when it is not JSON. */
+async function readJson(request) {
+	try {
+		return await request.json();
+	} catch {
+		return;
+	}
+}
+/** A UI message stream as a response, with extra headers such as the workflow run id. */
+function sse(stream, headers = {}) {
+	return new Response(stream.pipeThrough(new TextEncoderStream()), { headers: {
+		...UI_MESSAGE_STREAM_HEADERS,
+		...headers
+	} });
+}
+//#endregion
+export { readJson as n, sse as r, badRequest as t };

package/dist/{inbox-i7E1ppo6.d.ts → inbox-Cd1KCEBL.d.ts}

@@ -1,7 +1,7 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult, w as ErrorMapper } from "./result-D7y2fT87.js";
-import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
-import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-CKtbFcRv.js";
+import { t as AsyncResult, w as ErrorMapper } from "./result-BchM1XZn.js";
+import { t as BlockTransport } from "./block-transport-inD4fFq-.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-C0Xj8War.js";
 //#region src/blocks/inbox/types.d.ts
 /** The channels an inbox can sit on. */
 type InboxChannel = "in_app" | "email" | "slack" | "teams" | "discord" | "telegram" | "whatsapp" | "messenger" | "instagram" | "sms" | "github" | "linear" | "other";

package/dist/index-B72Rvv_j.d.ts

@@ -0,0 +1,89 @@
+import { t as AsyncResult } from "./result-BchM1XZn.js";
+import { a as AnyModels, i as AnyFunctions } from "./types-CoE5Zwy4.js";
+import { l as PublicEnv } from "./index-BUK7jUzR.js";
+import { s as SessionEncoding } from "./session-ChiXDZdZ.js";
+import { t as BetterSupabase } from "./define-DmcfoNXB.js";
+import { r as BetterClient } from "./bind-CQ5mPyX1.js";
+import { t as FunctionContract } from "./function-contract-BcZenXMO.js";
+import { FunctionInvokeOptions, SupabaseClient, SupabaseClientOptions } from "@supabase/supabase-js";
+//#region src/client/functions.d.ts
+/** `supabase.functions.invoke` options, without the body: `invoke` sends the input. */
+type InvokeOptions = Omit<FunctionInvokeOptions, "body">;
+/** Edge Function contracts by function name. */
+type FunctionContracts = Readonly<Record<string, FunctionContract>>;
+/** Anything with supabase-js's `functions` client, e.g. a `SupabaseClient`. */
+interface FunctionsHost {
+  readonly functions: {
+    invoke(name: string, options?: FunctionInvokeOptions): Promise<{
+      data: unknown;
+      error: unknown;
+      response?: Response;
+    }>;
+  };
+}
+interface TypedFunctions<Contracts extends FunctionContracts> {
+  /**
+   * Calls the function with `input` as the JSON body. Problem Details from
+   * the function come back as their `DbError`; a network or relay failure is
+   * a `network` error.
+   */
+  invoke<N extends keyof Contracts & string>(name: N, ...[input, options]: undefined extends Contracts[N]["input"] ? [input?: Contracts[N]["input"], options?: InvokeOptions] : [input: Contracts[N]["input"], options?: InvokeOptions]): AsyncResult<Contracts[N]["output"]>;
+}
+/**
+ * Typed Edge Function calls over supabase-js's `functions` client. The
+ * contracts come from the functions' own code, imported as types:
+ *
+ * ```ts
+ * import type { SendInvite } from "../supabase/functions/send-invite/index.ts";
+ *
+ * const fns = functions<{ "send-invite": SendInvite }>(supabase);
+ * const invite = await fns.invoke("send-invite", { email }).orThrow();
+ * ```
+ */
+declare function functions<Contracts extends FunctionContracts>(host: FunctionsHost): TypedFunctions<Contracts>;
+//#endregion
+//#region src/client/index.d.ts
+interface ClientOptions {
+  /** URL and publishable key. Not needed when `client` is given. */
+  readonly env?: PublicEnv;
+  /**
+   * Bring your own supabase-js client (custom storage). React Native apps
+   * use `better-supabase/client/native`, which doesn't load `@supabase/ssr`.
+   */
+  readonly client?: SupabaseClient;
+  /**
+   * `cookies` (default) shares the session with the server through
+   * `@supabase/ssr`; `local` keeps it in localStorage for SPAs without a server.
+   */
+  readonly storage?: "cookies" | "local";
+  readonly cookies?: {
+    /**
+     * `tokens-only` keeps the user object out of the cookie (it lives in
+     * `auth.userStorage`, localStorage by default), so cookies stay small.
+     * Use the same value as the server's `encode`. Defaults to
+     * `user-and-tokens`.
+     */
+    readonly encode?: SessionEncoding;
+  };
+  readonly auth?: {
+    /** Where auth-js keeps the user object with `cookies.encode: 'tokens-only'`. */
+    readonly userStorage?: UserStorage;
+  };
+  /**
+   * `staleTime` for every query option in `bs.queries`. Above zero, a
+   * remount or a window focus reuses cached rows instead of refetching.
+   */
+  readonly staleTime?: number;
+}
+type UserStorage = NonNullable<NonNullable<SupabaseClientOptions<"public">["auth"]>["userStorage"]>;
+/**
+ * The browser side: a supabase-js client, repositories that follow the
+ * session, TanStack Query options and an auth store for UI state.
+ *
+ * ```ts
+ * export const bs = createClient(betterSupabase, { env: { url, publishableKey } });
+ * ```
+ */
+declare function createClient$1<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: ClientOptions): BetterClient<M, F, E, C, P>;
+//#endregion
+export { InvokeOptions as a, FunctionsHost as i, createClient$1 as n, TypedFunctions as o, FunctionContracts as r, functions as s, ClientOptions as t };

package/dist/{index-DunNRdnT.d.ts → index-BCHR4Ucl.d.ts}

@@ -1,7 +1,7 @@
-import { E as ValidationIssue, b as DbError, f as Result, t as AsyncResult } from "./result-D7y2fT87.js";
-import { L as TableKey, M as Row, P as SchemaMeta, a as AnyModels, i as AnyFunctions, r as AccessTopicPolicy } from "./types-6BdhkmZe.js";
-import { it as QuerySpec, t as BetterSupabase } from "./define-CJJkkr1-.js";
-import { n as TemplateValues, t as TemplateParams } from "./template-CwO38Do8.js";
+import { E as ValidationIssue, b as DbError, f as Result, t as AsyncResult } from "./result-BchM1XZn.js";
+import { L as TableKey, M as Row, P as SchemaMeta, a as AnyModels, i as AnyFunctions, r as AccessTopicPolicy } from "./types-CoE5Zwy4.js";
+import { J as TemplateValues, q as TemplateParams } from "./storage-api-CB7Zl1Ci.js";
+import { at as QuerySpec, t as BetterSupabase } from "./define-DmcfoNXB.js";
 import { t as AuthorizationFunctions } from "./authorization-BFCqamMs.js";
 import { RealtimeChannel, SupabaseClient } from "@supabase/supabase-js";
 import { StandardSchemaV1 } from "@standard-schema/spec";

package/dist/{index-CLg87OBW.d.ts → index-BUK7jUzR.d.ts}

@@ -18,6 +18,11 @@ interface BetterSupabaseEnv {
   readonly projectRef?: string;
   /** `SUPABASE_READ_URL`: a read replica or the `<ref>-all` load balancer, for reads. */
   readonly readUrl?: string;
+  /**
+   * `SUPABASE_JWT_SECRET`: the shared HS256 secret Supabase Lite signs user
+   * tokens with (`auth.jwt_secret`). Server-only; read with `backend: "lite"`.
+   */
+  readonly jwtSecret?: string;
 }
 /** A JSON Web Key Set, as `@supabase/server` verifies with it. */
 type InlineJwks = Exclude<SupabaseEnv["jwks"], URL | null>;
@@ -52,6 +57,7 @@ declare const ENV_VARIABLES: {
   readonly jwksUrl: readonly string[];
   readonly jwks: readonly string[];
   readonly readUrl: readonly string[];
+  readonly jwtSecret: readonly string[];
 };
 declare class EnvValidationError extends Error {
   override readonly name = "EnvValidationError";