better-supabase 0.5.0 → 0.6.0

package/dist/solid/index.js

@@ -0,0 +1,344 @@
+import { t as clearOnUserChange } from "../user-change-XzvgafU4.js";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
+import { t as fieldErrorsOf } from "../field-errors-VF1yb8yI.js";
+import { a as createActionRunner, c as liveKey, d as shownCount, f as startBroadcast, i as countSource, l as notJoined, m as startLiveQuery, n as assertInvalidateClient, o as joinPresence, p as startLiveCount, r as callerOf, s as keyed, t as NO_COUNT, u as plainCaller } from "../client-CI0Z2zWX.js";
+import { createComponent, createContext, createEffect, createMemo, createSignal, onCleanup, onMount, untrack, useContext } from "solid-js";
+//#region src/solid/index.ts
+function read(value) {
+	return typeof value === "function" ? value() : value;
+}
+const ClientContext = createContext();
+/** Provides the better-supabase client to the primitives. */
+function BetterSupabaseProvider(props) {
+	const { client, queryClient } = props;
+	const [auth, setAuth] = createSignal(client.auth.current());
+	onMount(() => {
+		setAuth(client.auth.current());
+		onCleanup(client.auth.subscribe(() => {
+			setAuth(client.auth.current());
+		}));
+		if (queryClient) onCleanup(clearOnUserChange(queryClient, client.auth));
+	});
+	const value = {
+		client,
+		queryClient,
+		auth,
+		session: props.session
+	};
+	return createComponent(ClientContext.Provider, {
+		value,
+		get children() {
+			return props.children;
+		}
+	});
+}
+function useContext$1() {
+	const context = useContext(ClientContext);
+	if (!context) throw new Error("better-supabase: wrap your app in <BetterSupabaseProvider client={bs}>");
+	return context;
+}
+/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
+function useAuth() {
+	return useContext$1().auth;
+}
+function useSupabase() {
+	return useContext$1().client.supabase;
+}
+/** The session passed to `<BetterSupabaseProvider session={...}>`, `undefined` while it loads. */
+function useSession() {
+	const { session } = useContext$1();
+	if (!session) throw new Error("better-supabase: useSession() needs <BetterSupabaseProvider session={...}>");
+	return session;
+}
+/** The support session the page renders in, or `undefined` for a normal session. */
+function useSupportSession() {
+	const session = useSession();
+	return () => {
+		const current = session();
+		return current ? supportOf(current) : void 0;
+	};
+}
+/**
+* Primitives typed for your schema.
+*
+* ```ts
+* export const { useDb, useQueries, useAuth } = createBindings<typeof bs>();
+* ```
+*/
+function createBindings() {
+	return {
+		useDb: () => useContext$1().client.db,
+		useQueries: () => useContext$1().client.queries,
+		useSupabase,
+		useAuth,
+		useSession
+	};
+}
+/** Restarts `start` when `key` changes; stops it with the owner. */
+function follow(key, start) {
+	const run = keyed();
+	createEffect(() => {
+		const next = key();
+		untrack(() => {
+			run.update(next, () => next === null ? void 0 : start(next));
+		});
+	});
+	onCleanup(run.stop);
+}
+function useCaller(context, client) {
+	if (context && client === void 0) return () => callerOf(context.auth());
+	const supabase = client ?? context?.client.supabase;
+	if (!supabase) throw new Error("better-supabase: no supabase client");
+	const store = plainCaller(supabase);
+	const [caller, setCaller] = createSignal(store.current());
+	onMount(() => {
+		onCleanup(store.subscribe(() => {
+			setCaller(store.current());
+		}));
+	});
+	return caller;
+}
+function supabaseFor(hook, context, client) {
+	const supabase = client ?? context?.client.supabase;
+	if (!supabase) throw new Error(`better-supabase: ${hook} needs <BetterSupabaseProvider client={bs}> or { client: supabase }`);
+	return supabase;
+}
+/**
+* Subscribes to a topic while the owner lives. A `null` value pauses. It
+* resubscribes when the topic values or the signed-in user change.
+*
+* ```ts
+* useBroadcast(customersTopic, () => ({ organizationId: org() }), {}, { invalidate: ['customers'] });
+* ```
+*/
+function useBroadcast(topic, values, handlers, options) {
+	const context = useContext(ClientContext);
+	const supabase = supabaseFor("useBroadcast", context, options?.client);
+	const queryClient = options?.queryClient ?? context?.queryClient;
+	assertInvalidateClient("useBroadcast", options, queryClient);
+	const caller = useCaller(context, options?.client);
+	const [status, setStatus] = createSignal("closed");
+	const name = createMemo(() => {
+		const current = read(values);
+		return current ? topic.topic(current) : null;
+	});
+	follow(createMemo(() => {
+		const current = name();
+		if (current === null || caller().status === "loading") return null;
+		return JSON.stringify([current, caller().userId]);
+	}), () => {
+		const current = name();
+		if (current === null) return;
+		return startBroadcast({
+			supabase,
+			topic,
+			name: current,
+			latest: () => ({
+				handlers,
+				options
+			}),
+			queryClient,
+			onStatus: (next) => {
+				setStatus(next);
+			}
+		});
+	});
+	return status;
+}
+/**
+* Keeps a query fresh: invalidates every cached query that read a table the
+* spec touches whenever one of them changes. A `null` spec pauses.
+*
+* ```ts
+* useLiveQuery(() => betterSupabase.spec.customers.findMany({ where: { orgId: org() } }));
+* ```
+*/
+function useLiveQuery(spec, options = {}) {
+	const { client, queryClient, auth } = useContext$1();
+	const [status, setStatus] = createSignal("closed");
+	let joined = null;
+	const current = createMemo(() => read(spec));
+	follow(createMemo(() => {
+		const value = current();
+		if (value && !queryClient) throw new Error("better-supabase: useLiveQuery needs <BetterSupabaseProvider queryClient={...}>");
+		return liveKey(client, value, auth(), options);
+	}), (key) => {
+		const value = current();
+		if (!value || !queryClient) return;
+		const resumed = joined === key;
+		joined = key;
+		return startLiveQuery({
+			client,
+			queryClient,
+			spec: value,
+			auth: auth(),
+			options,
+			resumed,
+			onStatus: (next) => {
+				setStatus(next);
+			}
+		});
+	});
+	return status;
+}
+/**
+* A count that stays current: refetches only the `count` spec after each
+* debounced change to a table it reads. Takes a spec or a `bs.liveCount()`
+* seed; `null` pauses. The returned object's fields are reactive.
+*
+* ```tsx
+* const unread = useLiveCount(() => betterSupabase.spec.messages.count({ where: { read: false } }));
+* <span>{unread.count}</span>
+* ```
+*/
+function useLiveCount(source, options = {}) {
+	const { client, auth } = useContext$1();
+	const [status, setStatus] = createSignal("closed");
+	const [state, setState] = createSignal(NO_COUNT);
+	let joined = null;
+	const parsed = createMemo(() => countSource(read(source), options));
+	const key = createMemo(() => liveKey(client, parsed().spec, auth(), options));
+	follow(key, (next) => {
+		const { spec, initial, seedAt } = parsed();
+		if (!spec) return;
+		const previous = joined?.key === next ? joined : null;
+		joined = {
+			key: next,
+			at: previous?.at ?? seedAt ?? 0
+		};
+		return startLiveCount({
+			client,
+			spec,
+			key: next,
+			auth: auth(),
+			options,
+			immediate: initial === void 0 && !previous,
+			since: previous ? previous.at : seedAt,
+			onState: (update) => {
+				const value = setState(update);
+				if (joined?.key === next) joined = {
+					key: next,
+					at: value.at
+				};
+			},
+			onStatus: (next) => {
+				setStatus(next);
+			}
+		});
+	});
+	const shown = createMemo(() => shownCount(state(), key(), parsed()));
+	return {
+		get count() {
+			return shown().count;
+		},
+		get status() {
+			return status();
+		},
+		get error() {
+			return shown().error;
+		}
+	};
+}
+const NO_MEMBERS = [];
+/**
+* Joins a presence topic while the owner lives and returns who is on it. A
+* `null` value pauses. The returned object's fields are reactive.
+*
+* ```ts
+* const room = usePresence(roomTopic, () => ({ roomId: id() }), { state: () => ({ name: name() }) });
+* ```
+*/
+function usePresence(topic, values, options = {}) {
+	const context = useContext(ClientContext);
+	const supabase = supabaseFor("usePresence", context, options.client);
+	const caller = useCaller(context, options.client);
+	const [members, setMembers] = createSignal(NO_MEMBERS);
+	const [status, setStatus] = createSignal("closed");
+	const [join, setJoin] = createSignal();
+	const name = createMemo(() => {
+		const current = read(values);
+		return current ? topic.topic(current) : null;
+	});
+	const state = createMemo(() => read(options.state), void 0, { equals: (a, b) => JSON.stringify(a) === JSON.stringify(b) });
+	follow(createMemo(() => {
+		const current = name();
+		if (current === null || caller().status === "loading") return null;
+		return JSON.stringify([current, caller().userId]);
+	}), () => {
+		const current = name();
+		if (current === null) return;
+		const joined = joinPresence(supabase, topic, current, {
+			onStatus: (next) => {
+				setStatus(next);
+			},
+			onPresence: (next) => {
+				setMembers(next);
+			}
+		});
+		if (!joined) return;
+		setJoin(() => joined);
+		return () => {
+			setJoin(void 0);
+			setMembers(NO_MEMBERS);
+			setStatus("closed");
+			joined.leave();
+		};
+	});
+	createEffect(() => {
+		const joined = join();
+		const value = state();
+		joined?.sync(value);
+	});
+	return {
+		get members() {
+			return members();
+		},
+		get status() {
+			return status();
+		},
+		track: (value) => join()?.track(value) ?? notJoined(),
+		untrack: () => join()?.untrack() ?? notJoined()
+	};
+}
+/**
+* Calls a server action (`action()` from SolidStart, or a `bs.action()`)
+* from an event handler: tracks pending inputs and the last result, and
+* calls `onSuccess` or `onError`. The returned object's fields are reactive.
+*
+* ```tsx
+* const remove = useAction(removeMember);
+* <button disabled={remove.pending} onClick={() => remove.run({ userId })} />
+* ```
+*/
+function useAction(action, options = {}) {
+	const call = action;
+	const runner = createActionRunner(() => ({
+		action: call,
+		options
+	}));
+	const [state, setState] = createSignal(runner.current());
+	onCleanup(runner.subscribe(() => {
+		setState(runner.current());
+	}));
+	return {
+		run: runner.run,
+		reset: runner.reset,
+		get pending() {
+			return state().pending;
+		},
+		get pendingInputs() {
+			return state().pendingInputs;
+		},
+		get pendingInput() {
+			return state().pendingInput;
+		},
+		get data() {
+			return state().data;
+		},
+		get error() {
+			return state().error;
+		}
+	};
+}
+//#endregion
+export { BetterSupabaseProvider, createBindings, fieldErrorsOf, useAction, useAuth, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession, useSupabase, useSupportSession };

package/dist/solid-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, 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 { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/solid-start/index.d.ts
+/** The part of a SolidStart `FetchEvent` the integration reads and writes. */
+export interface SolidFetchEvent {
+  readonly request: Request;
+  readonly response: {
+    readonly headers: Headers;
+  };
+  readonly locals: Record<string, unknown>;
+  /** The H3 event; Nitro's Cloudflare presets put the bindings on its context. */
+  readonly nativeEvent?: {
+    readonly context?: {
+      readonly cloudflare?: {
+        readonly env?: unknown;
+      } | undefined;
+    } | undefined;
+  } | undefined;
+}
+export interface SolidStartOptions extends FrameworkOptions {
+  /**
+   * `getRequestEvent` from `solid-js/web`, which `require` and `action`
+   * call inside `"use server"` functions.
+   */
+  readonly getRequestEvent: () => SolidFetchEvent | undefined;
+  /** The host's env object for `getEnv`; defaults to the Cloudflare bindings. */
+  readonly platformEnv?: (event: SolidFetchEvent) => unknown;
+}
+/** What `createMiddleware` from `@solidjs/start/middleware` takes. */
+export interface SolidStartMiddleware {
+  readonly onRequest: (event: SolidFetchEvent) => Promise<Response | undefined>;
+  readonly onBeforeResponse: (event: SolidFetchEvent) => void;
+}
+export interface BetterSolidStart<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
+  /**
+   * Verifies the caller, refreshes the session cookie on navigations and
+   * form posts, and puts `db`, `bs`, `auth`, `tenant` and `session` on
+   * `event.locals`.
+   *
+   * ```ts title="src/middleware.ts"
+   * export default createMiddleware(bs.middleware)
+   * ```
+   */
+  readonly middleware: SolidStartMiddleware;
+  /** The current request's `locals`, inside a `"use server"` function. */
+  readonly locals: () => FrameworkLocals<M, F, E, C, P>;
+  /**
+   * The caller inside a `"use server"` function (a `query`, an `action`,
+   * an API route), or a thrown refusal: a redirect to `signIn` or `mfa`
+   * when configured, else Problem Details.
+   *
+   * ```ts
+   * const notes = query(async () => {
+   *   "use server";
+   *   const { db } = await bs.require();
+   *   return db.notes.findMany().orThrow();
+   * }, "notes");
+   * ```
+   */
+  require<R extends boolean = false>(options?: BlockRequireOptions<C, P, R>): Promise<FrameworkLocals<M, F, E, C, P> & AuthorizedContext<C, P, R>>;
+  /**
+   * A server function returning an `ActionResult`, for `action()` from
+   * `@solidjs/router`: `FormData` or a plain object, validated by `input`.
+   */
+  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): (input: unknown) => Promise<ActionResult<Unwrapped<Awaited<T>>>>;
+}
+/** SolidStart integration: middleware, guards and server function actions. */
+export declare function createSolidStart<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options: SolidStartOptions): BetterSolidStart<M, F, E, C, P>;
+//#endregion
+export type { ActionResult, RefusalRedirects };

package/dist/solid-start/index.js

@@ -0,0 +1,58 @@
+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 { i as localsOf, r as frameworkEntry } from "../framework-CONDyPYx.js";
+import { r as refusalResponse } from "../refusal-CeJWxmkH.js";
+import { t as beforeRoute } from "../before-route-CnR0C0Jr.js";
+//#region src/solid-start/index.ts
+/** SolidStart integration: middleware, guards and server function actions. */
+function createSolidStart(betterSupabase, options) {
+	const server = createServer(betterSupabase, options);
+	const expose = options.exposeErrors ?? defaultExpose();
+	const run = beforeRoute([frameworkEntry(server, options, expose)]);
+	const eventOf = () => {
+		const event = options.getRequestEvent();
+		if (event === void 0 || !("bs" in event.locals)) throw new TypeError("better-supabase: no request context; add createMiddleware(bs.middleware) in src/middleware.ts and call this inside a \"use server\" function");
+		return event;
+	};
+	const scopeOf = (event) => {
+		return event.locals;
+	};
+	return extendServer(server, {
+		middleware: {
+			onRequest: async (event) => {
+				const env = options.platformEnv ? options.platformEnv(event) : event.nativeEvent?.context?.cloudflare?.env;
+				const outcome = await run(event.request, env);
+				if (!outcome.reached) return outcome.response;
+				for (const cookie of outcome.headers.getSetCookie()) event.response.headers.append("set-cookie", cookie);
+				for (const [name, value] of outcome.headers) if (name !== "set-cookie") event.response.headers.set(name, value);
+				Object.assign(event.locals, localsOf(outcome.contributions));
+			},
+			onBeforeResponse: () => {
+				flushEvents(server, options.waitUntil);
+			}
+		},
+		locals: () => scopeOf(eventOf()),
+		require: async (requireOptions = {}) => {
+			const event = eventOf();
+			const scope = scopeOf(event);
+			const caller = await requireCaller(scope.bs.auth, requireOptions, scope.tenant);
+			if ("kind" in caller) throw refusalResponse(caller, event.request, options, expose);
+			return {
+				...scope,
+				...caller
+			};
+		},
+		action(actionOptions, fn) {
+			return async (input) => {
+				const scope = scopeOf(eventOf());
+				return await runAction(scope.bs.auth, actionOptions, input, scope.tenant, (parsed, caller) => fn(parsed, {
+					...scope,
+					...caller
+				}));
+			};
+		}
+	});
+}
+//#endregion
+export { createSolidStart };

package/dist/{spec-pins-C3oc-Tdp.js → spec-pins--j6mTok4.js}

@@ -14,7 +14,14 @@ const SPEC_PINS = {
 	postgrestAggregates: "12",
 	serverTiming: "WD-20260407",
 	stripeSyncEngine: "0.48.5",
-	pgvector: "0.8"
+	pgvector: "0.8",
+	ocsf: "1.9.0",
+	openfeature: "0.9.0",
+	scim: "2.0",
+	supabaseSdkCapabilities: "1.14.0",
+	aiMessage: "1",
+	aiSdkUiMessageStream: "v1",
+	anthropicMemoryTool: "20250818"
 };
 //#endregion
 export { SPEC_PINS as t };

package/dist/{spec-pins-CqorWDnO.d.ts → spec-pins-C89s6DyW.d.ts}

@@ -15,6 +15,13 @@ declare const SPEC_PINS: {
   readonly serverTiming: "WD-20260407";
   readonly stripeSyncEngine: "0.48.5";
   readonly pgvector: "0.8";
+  readonly ocsf: "1.9.0";
+  readonly openfeature: "0.9.0";
+  readonly scim: "2.0";
+  readonly supabaseSdkCapabilities: "1.14.0";
+  readonly aiMessage: "1";
+  readonly aiSdkUiMessageStream: "v1";
+  readonly anthropicMemoryTool: "20250818";
 };
 //#endregion
 export { SPEC_PINS as t };