better-supabase 0.5.0 → 0.6.0

package/dist/sign-in-Cb1mwv6X.js

@@ -0,0 +1,86 @@
+import { n as ClientContext } from "./hooks-1BTCJsiw.js";
+import { useContext, useMemo, useRef, useState } from "react";
+//#region src/react/sign-in.ts
+function useAuthApi(options, hook) {
+	const context = useContext(ClientContext);
+	const auth = options.client?.auth ?? context?.client.supabase.auth;
+	if (!auth) throw new Error(`better-supabase: ${hook} needs <BetterSupabaseProvider client={bs}> or { client: supabase }`);
+	return auth;
+}
+/** Runs auth calls with `pending` and `error` state; the latest call owns the state. */
+function usePending(options) {
+	const [state, setState] = useState({
+		pending: false,
+		error: void 0
+	});
+	const latest = useRef({
+		call: 0,
+		options
+	});
+	latest.current.options = options;
+	return {
+		state,
+		run: useMemo(() => async (call) => {
+			latest.current.call += 1;
+			const id = latest.current.call;
+			setState({
+				pending: true,
+				error: void 0
+			});
+			let error;
+			try {
+				({error} = await call());
+			} catch (cause) {
+				if (id === latest.current.call) setState({
+					pending: false,
+					error: void 0
+				});
+				throw cause;
+			}
+			if (id === latest.current.call) setState({
+				pending: false,
+				error: error ?? void 0
+			});
+			if (!error) latest.current.options.onSuccess?.();
+			return error ?? void 0;
+		}, [])
+	};
+}
+/**
+* Sign-in calls with `pending` and `error` state. The session lands in the
+* client's auth store, so `useAuth()` updates on its own.
+*
+* ```tsx
+* const signIn = useSignIn({ onSuccess: () => router.push('/') });
+* <button disabled={signIn.pending} onClick={() => signIn.password({ email, password })} />
+* ```
+*/
+function useSignIn(options = {}) {
+	const auth = useAuthApi(options, "useSignIn");
+	const { state, run } = usePending(options);
+	const calls = useMemo(() => ({
+		password: (credentials) => run(() => auth.signInWithPassword({ ...credentials })),
+		otp: (credentials) => run(() => auth.signInWithOtp(credentials)),
+		verifyOtp: (params) => run(() => auth.verifyOtp(params)),
+		oauth: (provider, oauthOptions) => run(() => auth.signInWithOAuth(oauthOptions ? {
+			provider,
+			options: oauthOptions
+		} : { provider }))
+	}), [auth, run]);
+	return {
+		...state,
+		...calls
+	};
+}
+/** `auth.signOut()` with `pending` and `error` state. The provider clears cached queries. */
+function useSignOut(options = {}) {
+	const auth = useAuthApi(options, "useSignOut");
+	const { state, run } = usePending(options);
+	const signOut = useMemo(() => (signOutOptions) => run(() => auth.signOut(signOutOptions ? { ...signOutOptions } : void 0)), [auth, run]);
+	return {
+		...state,
+		signOut
+	};
+}
+//#endregion
+export { useSignIn as n, useSignOut as r, usePending as t };

package/dist/{signers-Cc6r98SW.d.ts → signers-4y62_VIi.d.ts}

@@ -1,7 +1,11 @@
 /// <reference lib="esnext.temporal" />
-import { t as KitTransport } from "./kit-transport-B82k1djG.js";
-//#region src/webhooks/url-policy.d.ts
-/** Decides whether a webhook may be sent to `url`. Rejecting counts as `false`. */
+import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
+//#region src/blocks/webhooks/url-policy.d.ts
+/**
+ * Decides whether a webhook may be sent to `url`. Throwing means the check
+ * itself failed (a DNS lookup error): deliveries retry it, and `safeFetch`
+ * throws `UrlCheckError`.
+ */
 type AllowUrl = (url: URL) => boolean | Promise<boolean>;
 /** The addresses a host name resolves to. */
 type ResolveHost = (hostname: string) => Promise<readonly string[]>;
@@ -33,7 +37,7 @@ declare function isPublicAddress(address: string): boolean;
  */
 declare function publicUrl(options?: PublicUrlOptions): AllowUrl;
 //#endregion
-//#region src/webhooks/http.d.ts
+//#region src/blocks/webhooks/http.d.ts
 interface WebhookRequest {
   readonly url: string;
   readonly headers: Readonly<Record<string, string>>;
@@ -76,7 +80,7 @@ interface FetchTransportOptions {
 /** Sends webhooks with `fetch`, following redirects only to allowed URLs. */
 declare function fetchTransport(options?: FetchTransportOptions): WebhookTransport;
 //#endregion
-//#region src/webhooks/secrets.d.ts
+//#region src/blocks/webhooks/secrets.d.ts
 interface RotateSecretOptions {
   /** How long older secrets keep signing, e.g. `'24 hours'` (the default). */
   readonly overlap?: string;
@@ -85,7 +89,7 @@ interface RotateSecretOptions {
 }
 /**
  * Where endpoint signing secrets live. `sqlSecretStore` (Vault or a
- * column, set in `kits.webhooks-out.options.secretStorage`) is the default;
+ * column, set in `sql.modules.webhooks-out.options.secretStorage`) is the default;
  * implement it for a KMS or a secrets manager.
  */
 interface WebhookSecretStore {
@@ -95,12 +99,12 @@ interface WebhookSecretStore {
   /** Creates a new secret and returns it once. */
   rotate?(endpointId: string, options?: RotateSecretOptions): Promise<string>;
 }
-/** The kit's `webhook_secrets` and `rotate_webhook_secret` functions. */
-declare function sqlSecretStore(transport: KitTransport, options?: {
+/** The module's `webhook_secrets` and `rotate_webhook_secret` functions. */
+declare function sqlSecretStore(transport: BlockTransport, options?: {
   readonly schema?: string;
 }): WebhookSecretStore;
 //#endregion
-//#region src/webhooks/signers.d.ts
+//#region src/blocks/webhooks/signers.d.ts
 interface WebhookSignInput {
   /** The delivery id, the same on every retry so receivers can deduplicate. */
   readonly id: string;

package/dist/simplify-DDO0j0LI.js

@@ -0,0 +1,83 @@
+//#region src/ir/simplify.ts
+/**
+* Folds constant conditions. `true` means "no filter", `false` means "matches
+* nothing", so executors can skip the request entirely.
+*/
+function simplify(condition) {
+	if (condition === void 0) return true;
+	switch (condition.kind) {
+		case "and": {
+			const items = [];
+			for (const item of condition.items) {
+				const simple = simplify(item);
+				if (simple === false) return false;
+				if (simple !== true) items.push(simple);
+			}
+			if (items.length === 0) return true;
+			return items.length === 1 && items[0] ? items[0] : {
+				kind: "and",
+				items
+			};
+		}
+		case "or": {
+			const items = [];
+			for (const item of condition.items) {
+				const simple = simplify(item);
+				if (simple === true) return true;
+				if (simple !== false) items.push(simple);
+			}
+			if (items.length === 0) return false;
+			return items.length === 1 && items[0] ? items[0] : {
+				kind: "or",
+				items
+			};
+		}
+		case "not": {
+			const inner = simplify(condition.item);
+			if (typeof inner === "boolean") return !inner;
+			if (inner.kind === "not") return inner.item;
+			return {
+				kind: "not",
+				item: inner
+			};
+		}
+		case "relation": {
+			const where = simplify(condition.where);
+			if (where === true) {
+				if (condition.quantifier === "every") return true;
+				return {
+					...condition,
+					where: void 0
+				};
+			}
+			if (where === false) {
+				if (condition.quantifier === "some") return false;
+				if (condition.quantifier === "none") return true;
+				return {
+					...condition,
+					quantifier: "none",
+					where: void 0
+				};
+			}
+			return {
+				...condition,
+				where
+			};
+		}
+		case "column":
+			if (condition.op === "in" && Array.isArray(condition.value) && condition.value.length === 0) return false;
+			return condition;
+		default: return condition;
+	}
+}
+/** Returns the condition, or `undefined` when it folds to `true`. */
+function simplifyOrFalse(condition) {
+	const simple = simplify(condition);
+	if (simple === false) return { never: true };
+	return {
+		never: false,
+		condition: simple === true ? void 0 : simple
+	};
+}
+//#endregion
+export { simplifyOrFalse as n, simplify as t };

package/dist/solid/index.d.ts

@@ -0,0 +1,131 @@
+import { b as DbError } from "../result-D7y2fT87.js";
+import { it as QuerySpec } from "../define-CJJkkr1-.js";
+import { n as TemplateValues } from "../template-CwO38Do8.js";
+import { t as AuthSnapshot } from "../bind-Bu_ZNa3W.js";
+import { t as AuthSession } from "../view-DbxLNu8L.js";
+import { S as Topic, f as PresenceMember, u as EventSchemas, w as TopicHandlers, x as SubscriptionStatus } from "../index-DunNRdnT.js";
+import { t as SupportView } from "../support-view-33Oi07TT.js";
+import { a as BroadcastOptions, c as LiveCountSource, d as PresenceTopic, f as UseActionOptions, i as ActionState, l as LiveQueryHookOptions, n as ActionInputOf, o as ClientLike, r as ActionResultOf, s as LiveCountHookOptions, t as fieldErrorsOf, u as PresenceHookOptions } from "../field-errors-BFOa7WhB.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Accessor, JSX } from "solid-js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/solid/index.d.ts
+/** A value, or an accessor Solid tracks. */
+export type MaybeAccessor<T> = T | Accessor<T>;
+export interface BetterSupabaseProviderProps {
+  readonly client: ClientLike;
+  /** better-supabase queries are reset when the user signs out or changes. */
+  readonly queryClient?: QueryClient;
+  /** A server-verified session (`createAsync(() => getSession())`) for `useSession()`. */
+  readonly session?: Accessor<AuthSession | undefined>;
+  readonly children?: JSX.Element;
+}
+/** Provides the better-supabase client to the primitives. */
+export declare function BetterSupabaseProvider(props: BetterSupabaseProviderProps): JSX.Element;
+/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
+export declare function useAuth(): Accessor<AuthSnapshot>;
+export declare function useSupabase(): SupabaseClient;
+/** The session passed to `<BetterSupabaseProvider session={...}>`, `undefined` while it loads. */
+export declare function useSession<C = unknown, P = unknown>(): Accessor<AuthSession<C, P> | undefined>;
+/** The support session the page renders in, or `undefined` for a normal session. */
+export declare function useSupportSession(): Accessor<SupportView | undefined>;
+/** The claims type of a client's `betterSupabase.claims(schema)`, `unknown` without one. */
+export type ClaimsOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly claimsSchema: StandardSchemaV1<unknown, infer C> | undefined;
+} ? C : unknown;
+/** The profile type of a client's `betterSupabase.userMetadata(schema)`, `unknown` without one. */
+export type ProfileOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly userMetadataSchema: StandardSchemaV1<unknown, infer P> | undefined;
+} ? P : unknown;
+export interface BetterPrimitives<B extends ClientLike> {
+  /** Repositories bound to the current session. */
+  readonly useDb: () => B["db"];
+  /** TanStack Query option factories: `useQuery(() => useQueries().customers.findMany())`. */
+  readonly useQueries: () => B["queries"];
+  readonly useSupabase: () => SupabaseClient;
+  readonly useAuth: () => Accessor<AuthSnapshot>;
+  readonly useSession: () => Accessor<AuthSession<ClaimsOf<B>, ProfileOf<B>> | undefined>;
+}
+/**
+ * Primitives typed for your schema.
+ *
+ * ```ts
+ * export const { useDb, useQueries, useAuth } = createBindings<typeof bs>();
+ * ```
+ */
+export declare function createBindings<B extends ClientLike>(): BetterPrimitives<B>;
+/**
+ * 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'] });
+ * ```
+ */
+export declare function useBroadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: MaybeAccessor<TemplateValues<P> | null | undefined>, handlers?: TopicHandlers<E>, options?: BroadcastOptions): Accessor<SubscriptionStatus>;
+/**
+ * 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() } }));
+ * ```
+ */
+export declare function useLiveQuery(spec: MaybeAccessor<QuerySpec | null | undefined>, options?: LiveQueryHookOptions): Accessor<SubscriptionStatus>;
+export interface LiveCount {
+  /** `undefined` until the first count arrives. */
+  readonly count: number | undefined;
+  readonly status: SubscriptionStatus;
+  /** The last failed refetch; the previous count stays. */
+  readonly error: DbError | undefined;
+}
+/**
+ * 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>
+ * ```
+ */
+export declare function useLiveCount(source: MaybeAccessor<LiveCountSource>, options?: LiveCountHookOptions): LiveCount;
+export interface Presence<I, O> {
+  /** Everyone on the topic, this client included, from the last sync. */
+  readonly members: readonly PresenceMember<O>[];
+  readonly status: SubscriptionStatus;
+  /** Shares a state now; the `state` option tracks one for you. */
+  readonly track: (state: I) => Promise<DbError | undefined>;
+  readonly untrack: () => Promise<DbError | undefined>;
+}
+export interface SolidPresenceOptions<I> extends Omit<PresenceHookOptions<I>, "state"> {
+  readonly state?: MaybeAccessor<I | null | undefined>;
+}
+/**
+ * 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() }) });
+ * ```
+ */
+export declare function usePresence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: MaybeAccessor<TemplateValues<P> | null | undefined>, options?: SolidPresenceOptions<I>): Presence<I, O>;
+export interface ActionHandle<I, T> extends ActionState<I, T> {
+  /** Runs the action; resolves with its result. */
+  readonly run: (input: I) => Promise<ActionResultOf<T>>;
+  readonly reset: () => void;
+}
+/**
+ * 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 })} />
+ * ```
+ */
+export declare function useAction<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
+//#endregion
+export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BroadcastOptions, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type SupportView, type UseActionOptions, fieldErrorsOf };