better-supabase 0.0.0 → 0.2.0

package/dist/query-ChvDbsDE.js

@@ -0,0 +1,186 @@
+import { t as DbException } from "./errors-Bl3rkOzo.js";
+import { t as invalidationTargets } from "./tables-rZxRxNPW.js";
+import { t as invalidateTables } from "./invalidate-DbxuL2jL.js";
+//#region src/query/index.ts
+/** Query errors stay `DbException`s, even for an `sb` with `mapError()`. */
+const asException = (error) => new DbException(error);
+function isSkip(value) {
+	return typeof value === "symbol";
+}
+function withoutSignal(value) {
+	if (typeof value !== "object" || value === null) return value;
+	const { signal: _signal, ...rest } = value;
+	return rest;
+}
+function specQuery(runtime, spec, key) {
+	const stale = runtime.staleTime === void 0 ? {} : { staleTime: runtime.staleTime };
+	if (isSkip(spec)) return {
+		queryKey: key ?? ["bs", "$skip"],
+		queryFn: spec,
+		meta: { bsTables: [] },
+		...stale
+	};
+	return {
+		queryKey: key ?? [
+			"bs",
+			spec.table,
+			spec.method,
+			...spec.args
+		],
+		queryFn: ({ signal }) => runtime.db().$run(spec, { signal }).orThrow(asException),
+		meta: { bsTables: runtime.sb.tablesOf(spec) },
+		...stale
+	};
+}
+function tableQueries(runtime, table) {
+	const key = ["bs", table];
+	const specs = runtime.sb.spec[table];
+	const stale = runtime.staleTime === void 0 ? {} : { staleTime: runtime.staleTime };
+	const read = (method) => (args) => isSkip(args) ? specQuery(runtime, args, [
+		...key,
+		method,
+		"$skip"
+	]) : specQuery(runtime, specs[method](withoutSignal(args)));
+	const repo = () => {
+		const found = runtime.db()[table];
+		if (!found) throw new TypeError(`better-supabase: unknown table "${table}"`);
+		return found;
+	};
+	const call = (method, ...args) => {
+		const fn = repo()[method];
+		if (!fn) throw new TypeError(`better-supabase: ${table}.${method} is not available`);
+		return fn(...args);
+	};
+	const mutation = (op, run, tables) => ({
+		mutationKey: [...key, op],
+		mutationFn: (variables) => run(variables).orThrow(asException),
+		onSuccess: (_data, _variables, _result, context) => invalidateTables(context.client, tables)
+	});
+	return {
+		key,
+		findMany: read("findMany"),
+		findFirst: read("findFirst"),
+		findUnique: read("findUnique"),
+		count: read("count"),
+		aggregate: read("aggregate"),
+		exists: read("exists"),
+		paginate: read("paginate"),
+		findById: (id, args) => isSkip(id) ? specQuery(runtime, id, [
+			...key,
+			"findById",
+			"$skip"
+		]) : specQuery(runtime, specs["findById"](id, withoutSignal(args))),
+		infinite: (args) => {
+			const base = withoutSignal(args);
+			return {
+				queryKey: [
+					...key,
+					"infinite",
+					base
+				],
+				queryFn: ({ signal, pageParam }) => runtime.db().$run(specs["paginate"]({
+					...base,
+					after: pageParam
+				}), { signal }).orThrow(asException),
+				initialPageParam: null,
+				getNextPageParam: (last) => last.nextCursor ?? void 0,
+				meta: { bsTables: runtime.sb.tablesOf(specs["paginate"]({
+					...base,
+					after: null
+				})) },
+				...stale
+			};
+		},
+		infinitePages: (args) => {
+			const base = withoutSignal(args);
+			return {
+				queryKey: [
+					...key,
+					"infinitePages",
+					base
+				],
+				queryFn: ({ signal, pageParam }) => runtime.db().$run(specs["paginate"]({
+					...base,
+					page: pageParam
+				}), { signal }).orThrow(asException),
+				initialPageParam: base.page ?? 1,
+				getNextPageParam: (last) => last.page.hasMore ? last.page.number + 1 : void 0,
+				meta: { bsTables: runtime.sb.tablesOf(specs["paginate"](base)) },
+				...stale
+			};
+		},
+		create: (args) => mutation("create", (data) => call("create", data, args), [table]),
+		update: (args) => mutation("update", (variables) => call("update", variables.id, variables.patch, args), [table]),
+		upsert: (args) => mutation("upsert", (data) => call("upsert", data, args), [table]),
+		delete: (args) => mutation("delete", (id) => call("delete", id, args), invalidationTargets(runtime.sb.meta, table))
+	};
+}
+/**
+* TanStack Query option factories for every table, framework-neutral: pass
+* them to `useQuery` (React), `createQuery` (Svelte, Solid), `useQuery`
+* (Vue) or `injectQuery` (Angular). Payload types flow into the cache, errors
+* are `DbException`s, and mutations invalidate every query that read a
+* changed table.
+*
+* ```ts
+* const q = createQueries(sb, () => browser.db);
+* const { data } = useQuery(q.customers.findMany({ select: ['id', 'name'] }));
+* ```
+*/
+function createQueries(sb, db, options = {}) {
+	const runtime = {
+		sb,
+		db: typeof db === "function" ? db : () => db,
+		staleTime: options.staleTime
+	};
+	const stale = options.staleTime === void 0 ? {} : { staleTime: options.staleTime };
+	const queries = {
+		key: ["bs"],
+		$spec: (spec) => specQuery(runtime, spec),
+		$prefetch: (client, spec) => client.prefetchQuery(specQuery(runtime, spec)),
+		$rpc: (name, args, rpcOptions = {}) => ({
+			queryKey: [
+				"bs",
+				"$rpc",
+				name,
+				isSkip(args) ? "$skip" : args ?? {}
+			],
+			queryFn: isSkip(args) ? args : ({ signal }) => runtime.db().$rpc(name, args ?? {}, { signal }).orThrow(asException),
+			meta: { bsTables: rpcOptions.tables ?? [] },
+			...stale
+		}),
+		$rpcMutation: (name) => ({
+			mutationKey: [
+				"bs",
+				"$rpc",
+				name
+			],
+			mutationFn: (args) => runtime.db().$rpc(name, args ?? {}).orThrow(asException),
+			onSuccess: (_data, _variables, _result, context) => invalidateTables(context.client, (sb.options.rpc?.[name]?.invalidates ?? []).flatMap((table) => invalidationTargets(sb.meta, table)))
+		})
+	};
+	for (const table of Object.keys(sb.meta.tables)) {
+		let built;
+		Object.defineProperty(queries, table, {
+			enumerable: true,
+			get: () => {
+				built ??= tableQueries(runtime, table);
+				return built;
+			}
+		});
+	}
+	return queries;
+}
+/** Invalidates every query that read a table in the target. */
+function queryCache(client) {
+	return {
+		name: "tanstack-query",
+		invalidate: (target) => invalidateTables(client, target.tables)
+	};
+}
+/** Invalidates affected queries for every mutation and declared RPC `sb` performs in this runtime. */
+function invalidateOnMutation(sb, client) {
+	return sb.cache(queryCache(client));
+}
+//#endregion
+export { invalidateOnMutation as n, queryCache as r, createQueries as t };

package/dist/react/index.d.ts

@@ -0,0 +1,7 @@
+import { s as Impersonator } from "../mfa-TVia554c.js";
+import { t as AuthSession } from "../view-D1s0wa0T.js";
+import { r as LiveCountSeed } from "../live-DJyZMD6w.js";
+import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-Dng-ctuT.js";
+import { n as SessionProviderProps, r as useSession, t as SessionProvider } from "../session-C3LxnQ0e.js";
+import { a as BrowserLike, c as LiveCountHookOptions, d as createHooks, f as useAuth, g as useSupabase, h as useLiveQuery, i as BroadcastOptions, l as LiveQueryHookOptions, m as useLiveCount, n as BetterSupabaseProvider, o as ClaimsOf, p as useBroadcast, r as BetterSupabaseProviderProps, s as LiveCount, t as BetterHooks, u as ProfileOf } from "../index-CBDufH1M.js";
+export { type AuthSession, BetterHooks, BetterSupabaseProvider, BetterSupabaseProviderProps, BroadcastOptions, BrowserLike, ClaimsOf, type EntitlementKey, type Impersonator, LiveCount, LiveCountHookOptions, type LiveCountSeed, LiveQueryHookOptions, type MembershipClaim, ProfileOf, SessionProvider, type SessionProviderProps, createHooks, hasEntitlement, useAuth, useBroadcast, useLiveCount, useLiveQuery, useSession, useSupabase };

package/dist/react/index.js

@@ -0,0 +1,5 @@
+"use client";
+import { n as useSession, t as SessionProvider } from "../session-CqEwzVup.js";
+import { t as hasEntitlement } from "../entitlements-CTEBm7IB.js";
+import { a as useLiveCount, i as useBroadcast, n as createHooks, o as useLiveQuery, r as useAuth, s as useSupabase, t as BetterSupabaseProvider } from "../react-C83BdBGt.js";
+export { BetterSupabaseProvider, SessionProvider, createHooks, hasEntitlement, useAuth, useBroadcast, useLiveCount, useLiveQuery, useSession, useSupabase };

package/dist/react/server.d.ts

@@ -0,0 +1,13 @@
+import { t as AuthSession } from "../view-D1s0wa0T.js";
+import { n as SessionProviderProps, t as SessionProvider } from "../session-C3LxnQ0e.js";
+import { a as BrowserLike, f as useAuth, g as useSupabase, h as useLiveQuery, i as BroadcastOptions, l as LiveQueryHookOptions, n as BetterSupabaseProvider, o as ClaimsOf, p as useBroadcast, r as BetterSupabaseProviderProps, t as BetterHooks, u as ProfileOf } from "../index-CBDufH1M.js";
+//#region src/react/server.d.ts
+/** The `react-server` build of `useSession`: await `next.session()` instead. */
+export declare const useSession: <C = unknown, P = unknown>() => AuthSession<C, P>;
+/**
+ * The `react-server` build of `createHooks`: importing a module that creates
+ * hooks is safe on the server, calling a hook there throws.
+ */
+export declare function createHooks<B extends BrowserLike>(): BetterHooks<B>;
+//#endregion
+export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type BrowserLike, type ClaimsOf, type LiveQueryHookOptions, type ProfileOf, SessionProvider, type SessionProviderProps, useAuth, useBroadcast, useLiveQuery, useSupabase };

package/dist/react/server.js

@@ -0,0 +1,25 @@
+import { i as useBroadcast, o as useLiveQuery, r as useAuth, s as useSupabase, t as BetterSupabaseProvider } from "../react-C83BdBGt.js";
+import { SessionProvider } from "./session.js";
+//#region src/react/server.ts
+function clientOnly(name) {
+	return () => {
+		throw new Error(`better-supabase: ${name}() runs in Client Components only. In Server Components use \`next.server()\` or \`db.$run(spec)\`.`);
+	};
+}
+/** The `react-server` build of `useSession`: await `next.session()` instead. */
+const useSession = clientOnly("useSession");
+/**
+* The `react-server` build of `createHooks`: importing a module that creates
+* hooks is safe on the server, calling a hook there throws.
+*/
+function createHooks() {
+	return {
+		useDb: clientOnly("useDb"),
+		useQueries: clientOnly("useQueries"),
+		useSupabase: clientOnly("useSupabase"),
+		useAuth: clientOnly("useAuth"),
+		useSession: clientOnly("useSession")
+	};
+}
+//#endregion
+export { BetterSupabaseProvider, SessionProvider, createHooks, useAuth, useBroadcast, useLiveQuery, useSession, useSupabase };

package/dist/react/session.d.ts

@@ -0,0 +1,2 @@
+import { n as SessionProviderProps, r as useSession, t as SessionProvider } from "../session-C3LxnQ0e.js";
+export { SessionProvider, SessionProviderProps, useSession };

package/dist/react/session.js

@@ -0,0 +1,3 @@
+"use client";
+import { n as useSession, t as SessionProvider } from "../session-CqEwzVup.js";
+export { SessionProvider, useSession };

package/dist/react-C83BdBGt.js

@@ -0,0 +1,242 @@
+import { i as tenantClaimPaths, n as claimAt, r as claimsOf } from "./claims-CoTobNC-.js";
+import { t as invalidateTables } from "./invalidate-DbxuL2jL.js";
+import { n as liveQuery, t as liveCount } from "./live-D8rV1Ldw.js";
+import { n as useSession } from "./session-CqEwzVup.js";
+import { createContext, createElement, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+//#region src/react/index.ts
+const BrowserContext = createContext(null);
+const LOADING = {
+	status: "loading",
+	user: null,
+	claims: null
+};
+/** Provides the browser client to the hooks. */
+function BetterSupabaseProvider(props) {
+	const { browser, queryClient } = props;
+	const user = useRef(void 0);
+	useEffect(() => browser.auth.subscribe(() => {
+		const snapshot = browser.auth.current();
+		if (snapshot.status === "loading") return;
+		const id = snapshot.user?.id ?? null;
+		if (user.current !== void 0 && user.current !== id) queryClient?.removeQueries({ queryKey: ["bs"] });
+		user.current = id;
+	}), [browser, queryClient]);
+	const value = useMemo(() => ({
+		browser,
+		queryClient
+	}), [browser, queryClient]);
+	return createElement(BrowserContext.Provider, { value }, props.children);
+}
+function useBrowserContext() {
+	const value = useContext(BrowserContext);
+	if (!value) throw new Error("better-supabase: wrap your app in <BetterSupabaseProvider browser={browser}>");
+	return value;
+}
+function useBrowser() {
+	return useBrowserContext().browser;
+}
+/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
+function useAuth() {
+	const browser = useBrowser();
+	return useSyncExternalStore(browser.auth.subscribe, browser.auth.current, () => LOADING);
+}
+function useSupabase() {
+	return useBrowser().supabase;
+}
+/**
+* Hooks typed for your schema.
+*
+* ```ts
+* export const { useDb, useQueries, useAuth } = createHooks<typeof browser>();
+* ```
+*/
+function createHooks() {
+	return {
+		useDb() {
+			const browser = useBrowser();
+			useAuth();
+			return browser.db;
+		},
+		useQueries() {
+			const browser = useBrowser();
+			useAuth();
+			return browser.queries;
+		},
+		useSupabase,
+		useAuth,
+		useSession
+	};
+}
+/**
+* Subscribes to a topic while mounted. Pass `null` values to pause. It
+* resubscribes when the topic or the signed-in user changes.
+*
+* ```ts
+* useBroadcast(customersTopic, orgId ? { orgId } : null, {}, { invalidate: ['customers'] });
+* ```
+*/
+function useBroadcast(topic, values, handlers, options) {
+	const { browser, queryClient } = useBrowserContext();
+	const auth = useAuth();
+	const [status, setStatus] = useState("closed");
+	const latest = useRef({
+		handlers,
+		options
+	});
+	latest.current = {
+		handlers,
+		options
+	};
+	const name = values ? topic.topic(values) : null;
+	const userId = auth.user?.id ?? null;
+	if (options?.invalidate && !queryClient) throw new Error("better-supabase: useBroadcast({ invalidate }) needs <BetterSupabaseProvider queryClient={...}>");
+	useEffect(() => {
+		if (!name || auth.status === "loading") return void 0;
+		const matched = topic.match(name);
+		if (!matched) return void 0;
+		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(browser.supabase, matched, { "*": forward }, {
+			...latest.current.options?.self === void 0 ? {} : { self: latest.current.options.self },
+			onStatus: setStatus,
+			onInvalid: (message, issues) => latest.current.options?.onInvalid?.(message, issues)
+		});
+		return () => {
+			subscription.unsubscribe();
+			setStatus("closed");
+		};
+	}, [
+		browser,
+		topic,
+		name,
+		userId,
+		auth.status,
+		queryClient
+	]);
+	return status;
+}
+function claimedTenant(auth, meta) {
+	if (auth.status !== "signed-in") return void 0;
+	for (const path of tenantClaimPaths(claimsOf(meta).tenant)) {
+		const value = claimAt(auth.claims, path);
+		if (value !== void 0) return value;
+	}
+}
+/**
+* Keeps a query fresh: invalidates every cached query that read a table the
+* spec touches whenever one of them changes. Pass `null` to pause. It
+* resubscribes when the spec, tenant or user changes.
+*
+* ```ts
+* const spec = sb.spec.customers.findMany({ include: { notes: true } });
+* const { data } = useQuery(q.$spec(spec));
+* useLiveQuery(spec);
+* ```
+*/
+function useLiveQuery(spec, options = {}) {
+	const { browser, queryClient } = useBrowserContext();
+	const auth = useAuth();
+	const [status, setStatus] = useState("closed");
+	if (spec && !queryClient) throw new Error("better-supabase: useLiveQuery needs <BetterSupabaseProvider queryClient={...}>");
+	const key = spec ? JSON.stringify(spec) : null;
+	const tenant = options.tenant ?? claimedTenant(auth, browser.sb.meta);
+	const userId = auth.user?.id ?? null;
+	const debounceMs = options.debounceMs;
+	useEffect(() => {
+		if (!key || !queryClient || auth.status === "loading") return void 0;
+		const live = liveQuery(browser.sb, browser.supabase, JSON.parse(key), {
+			onChange: (tables) => void invalidateTables(queryClient, tables),
+			onStatus: setStatus,
+			...tenant === void 0 ? {} : { tenant },
+			...debounceMs === void 0 ? {} : { debounceMs }
+		});
+		return () => {
+			live.unsubscribe();
+		};
+	}, [
+		browser,
+		queryClient,
+		key,
+		tenant,
+		userId,
+		auth.status,
+		debounceMs
+	]);
+	return status;
+}
+/**
+* A count that stays current: refetches only the `count` spec (a HEAD
+* request) after each debounced change to a table it reads, and after the
+* channel rejoins. Takes a spec or a `next.liveCount()` seed; pass `null` to
+* pause. Doesn't need a `QueryClient`.
+*
+* ```tsx
+* const { count } = useLiveCount(seed); // seed = await next.liveCount(spec)
+* ```
+*/
+function useLiveCount(source, options = {}) {
+	const { browser } = useBrowserContext();
+	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,
+		error: void 0
+	});
+	const [status, setStatus] = useState("closed");
+	const key = spec ? JSON.stringify(spec) : null;
+	const tenant = options.tenant ?? claimedTenant(auth, browser.sb.meta);
+	const userId = auth.user?.id ?? null;
+	const debounceMs = options.debounceMs;
+	const hasInitial = initial !== void 0;
+	useEffect(() => {
+		if (!key || auth.status === "loading") return void 0;
+		const live = liveCount(browser.sb, browser.supabase, browser.db, JSON.parse(key), {
+			immediate: !hasInitial,
+			onCount: (count) => setState({
+				key,
+				count,
+				error: void 0
+			}),
+			onError: (error) => setState((previous) => ({
+				key,
+				count: previous.key === key ? previous.count : void 0,
+				error
+			})),
+			onStatus: setStatus,
+			...tenant === void 0 ? {} : { tenant },
+			...debounceMs === void 0 ? {} : { debounceMs }
+		});
+		return () => {
+			live.unsubscribe();
+		};
+	}, [
+		browser,
+		key,
+		tenant,
+		userId,
+		auth.status,
+		debounceMs,
+		hasInitial
+	]);
+	const fresh = state.key === key;
+	return {
+		count: fresh && state.count !== void 0 ? state.count : initial,
+		status,
+		error: fresh ? state.error : void 0
+	};
+}
+//#endregion
+export { useLiveCount as a, useBroadcast as i, createHooks as n, useLiveQuery as o, useAuth as r, useSupabase as s, BetterSupabaseProvider as t };