better-supabase 0.5.0 → 0.6.0

package/dist/stripe-D04h-QBT.d.ts

@@ -0,0 +1,136 @@
+//#region src/blocks/stripe.d.ts
+/**
+ * The part of the Stripe SDK (`stripe`, an optional peer) the billing and
+ * usage blocks call, typed structurally so the blocks never import it.
+ */
+interface StripeClient {
+  readonly customers: {
+    create(params: {
+      readonly email?: string;
+      readonly name?: string;
+      readonly metadata?: Readonly<Record<string, string>>;
+    }, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.updateCustomer`. */
+    update?(id: string, params: Readonly<Record<string, unknown>>): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.taxIds`. */
+    listTaxIds?(id: string, params?: {
+      readonly limit?: number;
+    }): Promise<{
+      readonly data: readonly StripeTaxId[];
+    }>;
+    /** Used by `billing.addTaxId`. */
+    createTaxId?(id: string, params: {
+      readonly type: string;
+      readonly value: string;
+    }): Promise<StripeTaxId>;
+    /** Used by `billing.removeTaxId`. */
+    deleteTaxId?(id: string, taxId: string): Promise<{
+      readonly id: string;
+      readonly deleted?: boolean;
+    }>;
+  };
+  readonly checkout: {
+    readonly sessions: {
+      create(params: Readonly<Record<string, unknown>>, options?: {
+        readonly idempotencyKey?: string;
+      }): Promise<{
+        readonly id: string;
+        readonly url: string | null;
+      }>;
+    };
+  };
+  readonly billingPortal: {
+    readonly sessions: {
+      create(params: {
+        readonly customer: string;
+        readonly return_url?: string;
+      }): Promise<{
+        readonly id: string;
+        readonly url: string;
+      }>;
+    };
+  };
+  readonly subscriptionItems: {
+    update(id: string, params: {
+      readonly quantity: number;
+      readonly proration_behavior?: string;
+    }, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+      readonly quantity?: number | null;
+    }>;
+  };
+  readonly subscriptions: {
+    cancel(id: string): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.changePlan` and `billing.cancelAtPeriodEnd`. */
+    update?(id: string, params: Readonly<Record<string, unknown>>, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+    }>;
+  };
+  /** Used by `billing.voidInvoice` and `billing.markInvoiceUncollectible`. */
+  readonly invoices?: {
+    voidInvoice(id: string): Promise<{
+      readonly id: string;
+      readonly status?: string | null;
+    }>;
+    markUncollectible(id: string): Promise<{
+      readonly id: string;
+      readonly status?: string | null;
+    }>;
+  };
+  readonly billing: {
+    readonly meterEvents: {
+      create(params: {
+        readonly event_name: string;
+        readonly payload: Readonly<Record<string, string>>;
+        readonly identifier?: string;
+        readonly timestamp?: number;
+      }, options?: {
+        readonly idempotencyKey?: string;
+      }): Promise<unknown>;
+    };
+  };
+  readonly webhooks: {
+    constructEventAsync(payload: string, header: string, secret: string): Promise<{
+      readonly id: string;
+      readonly type: string;
+      readonly data: {
+        readonly object: unknown;
+      };
+    }>;
+  };
+}
+/** A customer tax id as Stripe returns it (`eu_vat`, `DE123456789`). */
+interface StripeTaxId {
+  readonly id: string;
+  readonly type: string;
+  readonly value: string;
+  readonly country?: string | null;
+  readonly verification?: {
+    readonly status?: string | null;
+  } | null;
+  readonly created?: number | null;
+}
+/**
+ * A Stripe client, the secret key to create one from the `stripe` package,
+ * or a function that returns a client. The function runs on every Stripe
+ * call, so it can create the client lazily, pick a per-request or per-tenant
+ * client (Stripe Connect), or read a rotated key; cache inside it when needed.
+ */
+type StripeSource = StripeClient | {
+  readonly secretKey: string;
+  readonly apiVersion?: string;
+} | (() => StripeClient | Promise<StripeClient>);
+//#endregion
+export { StripeSource as n, StripeTaxId as r, StripeClient as t };

package/dist/{support-Dk6vdmEw.js → support-BivNqSpK.js}

@@ -1,11 +1,11 @@
-import { c as mapDbError, n as dbError } from "./errors-DtwXa6b8.js";
-import { t as temporal } from "./temporal-required-CAt4Dc9Z.js";
-import { i as ok, n as err, o as toDbError, t as AsyncResult } from "./result-BKiliPY7.js";
-import { t as validate } from "./standard-D7r6dMUu.js";
-import { c as supportCookie, l as supportCookieValue, s as clearSupportCookie } from "./server-Csx2sRjg.js";
-import { r as sqlIdent } from "./template-TxrGI5jR.js";
-import { n as emitKitEvent } from "./kit-events-CTFDfSwb.js";
-import { t as fromPgError } from "./executor-XycESQPH.js";
+import { c as mapDbError, n as dbError } from "./errors-B11Duf73.js";
+import { t as temporal } from "./temporal-required-BVvW7SYJ.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-DzUbqgdW.js";
+import { n as validate } from "./standard-BK0cqJ7y.js";
+import { t as fromPgError } from "./executor-De1Of3m3.js";
+import { d as clearSupportCookie, f as supportCookie, m as supportCookieValue } from "./adapter-Bc1o3zyy.js";
+import { r as sqlIdent } from "./template--jDkl3UP.js";
+import { i as emitBlockEvent } from "./block-events-CrT8r7Fe.js";
 //#region src/auth/support.ts
 /** A session from the jsonb the `support-sessions` functions return. */
 function supportSessionFromRow(row) {
@@ -25,7 +25,7 @@ function supportSessionFromRow(row) {
 	};
 }
 /**
-* Support sessions in the `support-sessions` SQL kit module. `start` runs
+* Support sessions in the `support-sessions` SQL module. `start` runs
 * as the admin, so the module's `is_platform()` gate applies; the reads run
 * on the admin connection.
 */
@@ -76,7 +76,8 @@ function sqlSupportStore(postgres, options = {}) {
 }
 /**
 * The claims a support session runs with: the target's, plus `act` naming
-* the admin, the reason and the session (the audit module records all three).
+* the admin, the reason and the session (the audit module records all three),
+* marked `kind: "support"` so `actorOf` never reads it as an OAuth client.
 * `role` falls back to `authenticated`; the admin's claims never leak in.
 */
 function supportClaims(session, target) {
@@ -86,6 +87,7 @@ function supportClaims(session, target) {
 		sub: session.targetUserId,
 		role: typeof role === "string" && role !== "" ? role : "authenticated",
 		act: {
+			kind: "support",
 			sub: session.adminId,
 			reason: session.reason,
 			session_id: session.id,
@@ -95,6 +97,9 @@ function supportClaims(session, target) {
 }
 //#endregion
 //#region src/server/support.ts
+/** How long a support target's claims are reused; a role change applies within it. */
+const CLAIMS_TTL_MS = 6e4;
+const CLAIMS_CACHE_SIZE = 1e3;
 const denied = (message, code) => dbError("forbidden", message, { code });
 const invalid = (message, code) => dbError("invalid_request", message, { code });
 function storeError(cause) {
@@ -117,7 +122,7 @@ function createSupport(options, events, claimsSchema) {
 	const maxTtl = policy.maxTtl ?? 14400;
 	const cookieName = options.cookie?.name;
 	const emit = (type, data) => {
-		emitKitEvent(events, type, data, {
+		emitBlockEvent(events, type, data, {
 			actorId: data.adminId,
 			...data.sessionId ? { subject: `support_sessions/${data.sessionId}` } : {}
 		});
@@ -127,6 +132,24 @@ function createSupport(options, events, claimsSchema) {
 		if (store.claims) return store.claims(targetUserId);
 		return { role: "authenticated" };
 	};
+	/** Target claims per support session; the session itself is loaded every time, so revoking stays immediate. */
+	const claimsCache = /* @__PURE__ */ new Map();
+	const cachedTargetClaims = async (session) => {
+		const now = Date.now();
+		const cached = claimsCache.get(session.id);
+		if (cached && cached.until > now) return cached.claims;
+		const claims = await targetClaims(options.store, session.targetUserId);
+		claimsCache.delete(session.id);
+		if (claimsCache.size >= CLAIMS_CACHE_SIZE) {
+			const oldest = claimsCache.keys().next();
+			if (!oldest.done) claimsCache.delete(oldest.value);
+		}
+		claimsCache.set(session.id, {
+			claims,
+			until: Math.min(session.expiresAt.epochMilliseconds, now + CLAIMS_TTL_MS)
+		});
+		return claims;
+	};
 	const checkPolicy = (admin, request, reason, seconds) => {
 		if (admin.claims["act"] !== void 0) return denied("An impersonated session cannot start a support session", "SUPPORT_NESTED");
 		if (request.targetUserId === admin.user.id) return invalid("An admin cannot start a support session as themselves", "SUPPORT_SELF");
@@ -248,7 +271,7 @@ function createSupport(options, events, claimsSchema) {
 					...session,
 					readOnly: true
 				};
-				claims = supportClaims(session, await targetClaims(options.store, session.targetUserId));
+				claims = supportClaims(session, await cachedTargetClaims(session));
 			} catch (cause) {
 				events.logger.warn("Could not load the support session", { cause });
 				return;

package/dist/{support-view-Da5peKFg.d.ts → support-view-33Oi07TT.d.ts}

@@ -1,4 +1,4 @@
-import { t as AuthSession } from "./view-BEf0diC5.js";
+import { t as AuthSession } from "./view-DbxLNu8L.js";
 //#region src/auth/support-view.d.ts
 /** A running support session as the target's view shows it, for a banner. */
 interface SupportView {

package/dist/svelte/index.d.ts

@@ -0,0 +1,114 @@
+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 { 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 { StandardSchemaV1 } from "@standard-schema/spec";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/svelte/index.d.ts
+/** A value read through `.current`, reactive in templates, `$derived` and `$effect`. */
+export interface Current<T> {
+  readonly current: T;
+}
+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;
+}
+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 SveltePresenceOptions<I> extends Omit<PresenceHookOptions<I>, "state"> {
+  readonly state?: () => I | null | undefined;
+}
+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;
+}
+/** 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;
+/**
+ * The client bound to Svelte. Inputs are getters (`() => spec`), so the
+ * subscriptions follow `$state` and `$props`. A subscription starts when a
+ * template, `$derived` or `$effect` reads one of its fields and stops when
+ * nothing reads it any more.
+ */
+export interface BetterSvelte<B extends ClientLike = ClientLike> {
+  readonly client: B;
+  readonly queryClient: QueryClient | undefined;
+  /** Repositories bound to the current session. */
+  readonly db: B["db"];
+  /** TanStack Query option factories: `createQuery(() => bs.queries.customers.findMany())`. */
+  readonly queries: B["queries"];
+  readonly supabase: SupabaseClient;
+  /** The session state for UI: `loading`, `signed-out` or `signed-in`. */
+  readonly auth: Current<AuthSnapshot>;
+  broadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: () => TemplateValues<P> | null | undefined, handlers?: TopicHandlers<E>, options?: BroadcastOptions): Current<SubscriptionStatus>;
+  liveQuery(spec: () => QuerySpec | null | undefined, options?: LiveQueryHookOptions): Current<SubscriptionStatus>;
+  liveCount(source: () => LiveCountSource, options?: LiveCountHookOptions): LiveCount;
+  presence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: () => TemplateValues<P> | null | undefined, options?: SveltePresenceOptions<I>): Presence<I, O>;
+  action<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
+}
+export interface BetterSvelteOptions {
+  /** better-supabase queries are reset when the user signs out or changes. */
+  readonly queryClient?: QueryClient;
+}
+/** Binds a client to Svelte without a component context, e.g. in tests or a module. */
+export declare function createBetterSvelte<B extends ClientLike>(client: B, options?: BetterSvelteOptions): BetterSvelte<B>;
+/**
+ * Binds the client for the components below, in the root layout. With a
+ * `queryClient`, better-supabase queries are reset when the caller changes.
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   setBetterSupabase(bs, { queryClient });
+ * <\/script>
+ * ```
+ */
+export declare function setBetterSupabase<B extends ClientLike>(client: B, options?: BetterSvelteOptions): BetterSvelte<B>;
+/** The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof bs>()`. */
+export declare function getBetterSupabase<B extends ClientLike = ClientLike>(): BetterSvelte<B>;
+/** The session state for UI. Call during component setup. */
+export declare function useAuth(): Current<AuthSnapshot>;
+/** Subscribes to a topic while read. Call during component setup. */
+export declare function useBroadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: () => TemplateValues<P> | null | undefined, handlers?: TopicHandlers<E>, options?: BroadcastOptions): Current<SubscriptionStatus>;
+/**
+ * Keeps a query fresh while read. Call during component setup.
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   const live = useLiveQuery(() => betterSupabase.spec.customers.findMany());
+ * <\/script>
+ * <span data-status={live.current}></span>
+ * ```
+ */
+export declare function useLiveQuery(spec: () => QuerySpec | null | undefined, options?: LiveQueryHookOptions): Current<SubscriptionStatus>;
+/** A count that stays current while read. Call during component setup. */
+export declare function useLiveCount(source: () => LiveCountSource, options?: LiveCountHookOptions): LiveCount;
+/** Joins a presence topic while read. Call during component setup. */
+export declare function usePresence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: () => TemplateValues<P> | null | undefined, options?: SveltePresenceOptions<I>): Presence<I, O>;
+/** Tracks the runs of a server action or form action. */
+export declare function useAction<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
+/** Shares a server-verified session (from `+layout.ts` data) with the components below. */
+export declare function setSession(session: () => AuthSession): void;
+/** The session from the nearest `setSession()`, typed with `useSession<Claims, Profile>()`. */
+export declare function useSession<C = unknown, P = unknown>(): Current<AuthSession<C, P>>;
+//#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 UseActionOptions, fieldErrorsOf };