better-supabase 0.4.0 → 0.5.1

package/dist/postgres/index.js

@@ -1,5 +1,5 @@
-import { n as quoteIdent, t as compileSql } from "../sql-B34HU2DI.js";
-import { n as postgresExecutor, t as fromPgError } from "../executor-CVt6dD0B.js";
+import { n as quoteIdent, t as compileSql } from "../sql-Coh6n4cC.js";
+import { n as postgresExecutor, t as fromPgError } from "../executor-XycESQPH.js";
 import { Pool } from "pg";
 //#region src/postgres/pool.ts
 const DEFAULT_TIMEOUTS = {
@@ -22,6 +22,10 @@ function openPool(options) {
 		idleTimeoutMillis: options.idleTimeout ?? 1e4
 	});
 }
+const RESERVED_SETTINGS = /* @__PURE__ */ new Set(["role", "request.jwt.claims"]);
+function checkSettings(settings = {}) {
+	for (const name of Object.keys(settings)) if (!name.includes(".") || RESERVED_SETTINGS.has(name)) throw new TypeError(`Session setting "${name}": use a custom setting with a dot, such as better_supabase.tenant`);
+}
 /**
 * A pooled Postgres connection for jobs, scripts and tests. Each query (or
 * transaction) runs in its own transaction; claims and role are
@@ -39,8 +43,8 @@ function createPostgres(options = {}) {
 	};
 	/** Opens the transaction, then sets the timeouts, claims and role in one round trip. */
 	async function begin(client, session) {
-		await client.query("begin");
-		const settings = [];
+		await client.query(session?.readOnly ? "begin read only" : "begin");
+		const settings = Object.entries(session?.settings ?? {});
 		const timeout = session?.role === "authenticated" ? timeouts.authenticated : session?.role === "anon" ? timeouts.anon : timeouts.admin;
 		if (timeout !== void 0) settings.push(["statement_timeout", String(Math.trunc(timeout))]);
 		if (options.idleInTransactionTimeout !== void 0) settings.push(["idle_in_transaction_session_timeout", String(Math.trunc(options.idleInTransactionTimeout))]);
@@ -73,19 +77,24 @@ function createPostgres(options = {}) {
 		queryRaw: (text, params) => transaction(session, (client) => client.queryRaw(text, params)),
 		transaction: (fn) => transaction(session, fn)
 	});
-	const sessionFor = (claims) => ({
-		claims,
-		role: roleOf(claims)
-	});
+	const sessionFor = (claims, sessionOptions = {}) => {
+		checkSettings(sessionOptions.settings);
+		return {
+			claims,
+			role: roleOf(claims),
+			...sessionOptions.settings ? { settings: sessionOptions.settings } : {},
+			...sessionOptions.readOnly ? { readOnly: true } : {}
+		};
+	};
 	return {
 		admin: clientFor(void 0),
 		anon: clientFor({
 			claims: { role: "anon" },
 			role: "anon"
 		}),
-		asUser: (claims) => clientFor(sessionFor(claims)),
-		executorFor: (claims) => postgresExecutor(clientFor(sessionFor(claims))),
-		transaction: (fn, txOptions) => transaction(txOptions?.claims ? sessionFor(txOptions.claims) : void 0, fn),
+		asUser: (claims, sessionOptions) => clientFor(sessionFor(claims, sessionOptions)),
+		executorFor: (claims, sessionOptions) => postgresExecutor(clientFor(sessionFor(claims, sessionOptions))),
+		transaction: (fn, txOptions) => transaction(txOptions?.claims ? sessionFor(txOptions.claims, txOptions) : void 0, fn),
 		end: () => pool.end(),
 		[Symbol.asyncDispose]: () => pool.end()
 	};

package/dist/{postgrest-Bc-0Xw62.d.ts → postgrest-CruYKAvV.d.ts}

@@ -1,4 +1,4 @@
-import { g as Operation } from "./executor-B5IoUxLE.js";
+import { U as Operation } from "./executor-BunPOO-k.js";
 //#region src/compile/postgrest.d.ts
 /**
  * A compiled PostgREST request, expressed as calls on the public

package/dist/{problem-BihjPR0t.js → problem-BW1KhzSG.js}

@@ -1,4 +1,4 @@
-import { n as dbError } from "./errors-L0xK41y_.js";
+import { n as dbError } from "./errors-DtwXa6b8.js";
 //#region src/core/problem.ts
 const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
 const PROBLEM_CONTENT_TYPE = "application/problem+json";
@@ -12,6 +12,7 @@ const TITLES = {
 	not_null: "Required value missing",
 	exclusion: "Exclusion constraint violated",
 	invalid_input: "Invalid input",
+	invalid_value: "Stored value not representable",
 	raised: "Request rejected",
 	timeout: "Timed out",
 	serialization: "Concurrent update, retry",

package/dist/{problem-U8UEKccv.d.ts → problem-Blxe8S31.d.ts}

@@ -1,4 +1,4 @@
-import { b as ValidationIssue, m as DbErrorKind, p as DbError } from "./result-CqEsbgYs.js";
+import { _ as DbError, v as DbErrorKind, w as ValidationIssue } from "./executor-BunPOO-k.js";
 //#region src/core/problem.d.ts
 /** RFC 9457 Problem Details, with the `DbError` fields as extension members. */
 interface ProblemDetails {

package/dist/query/index.d.ts

@@ -1,2 +1,2 @@
-import { a as QueryHelpers, c as TableQueries, d as queryCache, f as BetterQueryMeta, i as QueriesOptions, l as createQueries, n as InfiniteOptionsOf, o as QueryKeyOf, p as invalidateTables, r as MutationOptionsOf, s as QueryOptionsOf, t as BetterQueries, u as invalidateOnMutation } from "../index-DFmOpBGC.js";
-export { type BetterQueries, type BetterQueryMeta, type InfiniteOptionsOf, type MutationOptionsOf, type QueriesOptions, type QueryHelpers, type QueryKeyOf, type QueryOptionsOf, type TableQueries, createQueries, invalidateOnMutation, invalidateTables, queryCache };
+import { a as MutationOptionsOf, c as QueryKeyOf, d as createQueries, f as invalidateOnMutation, h as invalidateTables, i as InfiniteOptionsOf, l as QueryOptionsOf, m as BetterQueryMeta, n as clearOnUserChange, o as QueriesOptions, p as queryCache, r as BetterQueries, s as QueryHelpers, t as UserChangeSource, u as TableQueries } from "../index-DgILJRXj.js";
+export { type BetterQueries, type BetterQueryMeta, type InfiniteOptionsOf, type MutationOptionsOf, type QueriesOptions, type QueryHelpers, type QueryKeyOf, type QueryOptionsOf, type TableQueries, type UserChangeSource, clearOnUserChange, createQueries, invalidateOnMutation, invalidateTables, queryCache };

package/dist/query/index.js

@@ -1,3 +1,3 @@
-import { t as invalidateTables } from "../invalidate-CgxmRamI.js";
-import { n as invalidateOnMutation, r as queryCache, t as createQueries } from "../query-BMMSWbI7.js";
-export { createQueries, invalidateOnMutation, invalidateTables, queryCache };
+import { n as invalidateTables, t as clearOnUserChange } from "../user-change-CHFEUro1.js";
+import { n as invalidateOnMutation, r as queryCache, t as createQueries } from "../query-CCbo44lG.js";
+export { clearOnUserChange, createQueries, invalidateOnMutation, invalidateTables, queryCache };

package/dist/{query-BMMSWbI7.js → query-CCbo44lG.js}

@@ -1,6 +1,6 @@
-import { t as DbException } from "./errors-L0xK41y_.js";
+import { t as DbException } from "./errors-DtwXa6b8.js";
 import { t as invalidationTargets } from "./tables-Cb-3_VWc.js";
-import { t as invalidateTables } from "./invalidate-CgxmRamI.js";
+import { n as invalidateTables } from "./user-change-CHFEUro1.js";
 //#region src/query/queries.ts
 /** Query errors stay `DbException`s, even for an `betterSupabase` with `mapError()`. */
 const asException = (error) => new DbException(error);

package/dist/queue-BYUCjr59.d.ts

@@ -0,0 +1,252 @@
+/// <reference lib="esnext.temporal" />
+import { _ as DbError, a as AsyncResult } from "./executor-BunPOO-k.js";
+import { g as RequestContext, t as Actor } from "./plugin-o144f322.js";
+import { t as SqlClient } from "./executor-Cghdstwu.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/jobs/queue.d.ts
+type QueueSchemas = Readonly<Record<string, StandardSchemaV1>>;
+type PayloadIn<Q extends QueueSchemas, N extends keyof Q> = StandardSchemaV1.InferInput<Q[N]>;
+type PayloadOut<Q extends QueueSchemas, N extends keyof Q> = StandardSchemaV1.InferOutput<Q[N]>;
+/** The actor and tenant of the request that enqueued a job. */
+interface JobContext {
+  readonly actor?: Actor;
+  readonly tenant?: string;
+}
+interface Job<P = unknown> {
+  /** The pgmq message id. */
+  readonly id: number;
+  readonly queue: string;
+  readonly payload: P;
+  /** 1 on the first run (pgmq's `read_ct`). */
+  readonly attempts: number;
+  readonly maxAttempts: number;
+  readonly enqueuedAt: Temporal.Instant;
+  /** End of the lease: the job becomes claimable again after this. */
+  readonly visibleUntil: Temporal.Instant;
+  readonly lastError: string | null;
+  /**
+   * The actor and tenant recorded at enqueue, ready for `db.$with(job.context)`.
+   * Without a recorded tenant, `tenant()` applies its `onMissing` unless the
+   * worker runs with `allTenants: true`.
+   */
+  readonly context: RequestContext;
+}
+interface EnqueueOptions {
+  /** Run no earlier than this. */
+  readonly runAt?: Temporal.Instant;
+  /** Seconds to wait before running. */
+  readonly delay?: number;
+  /** Defaults to 5. After this many failed attempts the job is archived as dead. */
+  readonly maxAttempts?: number;
+  /**
+   * While a job with this key is waiting or running, enqueueing again returns
+   * its id. SQL connections only.
+   */
+  readonly dedupeKey?: string;
+  /**
+   * The request context whose actor and tenant the job records, next to the
+   * payload. The tenant is `context.tenant`, the one `tenant()` resolved, or
+   * the `tenant_id` claim (then `app_metadata.tenant_id`).
+   */
+  readonly context?: RequestContext;
+}
+interface ScheduleOptions {
+  /** The actor and tenant every scheduled run records, as in `enqueue`. */
+  readonly context?: RequestContext;
+  /**
+   * The IANA time zone the cron fields are read in. Defaults to `UTC`.
+   * Other zones need `kits.jobs.options.scheduler: "drain"`.
+   */
+  readonly timeZone?: string;
+}
+interface RunSchedulesOptions {
+  /** Seconds a claimed schedule stays leased. Defaults to 60. */
+  readonly lease?: number;
+  /** Defaults to 100. */
+  readonly batch?: number;
+}
+interface DrainOptions extends Omit<WorkOptions, "pollInterval" | "maxPollInterval" | "signal"> {
+  /** Stop claiming after this many ms; claimed jobs still finish. */
+  readonly budgetMs?: number;
+}
+interface DrainRouteOptions<Q extends QueueSchemas> extends Omit<DrainOptions, "onError"> {
+  /**
+   * The bearer token callers send (`Authorization: Bearer <secret>`), such
+   * as Vercel's `CRON_SECRET`. Required.
+   */
+  readonly secret: string | undefined;
+  /** The queues to drain, in order, with their handlers. */
+  readonly handlers: { readonly [N in Extract<keyof Q, string>]?: JobHandler<PayloadOut<Q, N>>; };
+  /** Total time in ms for schedules and queues. Defaults to 50000. */
+  readonly budgetMs?: number;
+  /** Enqueue due schedules first (the drain scheduler). Defaults to true. */
+  readonly schedules?: boolean;
+  readonly onError?: (error: DbError, job?: Job) => void;
+}
+interface DrainRouteResult {
+  /** Schedules whose run was enqueued. */
+  readonly schedules: number;
+  readonly queues: Readonly<Record<string, DrainResult>>;
+  /** True when the budget ran out before every queue was empty. */
+  readonly budgetExhausted: boolean;
+}
+interface ClaimOptions {
+  /** Defaults to 1. */
+  readonly batch?: number;
+  /** Seconds a claimed job stays invisible to other workers. Defaults to 300. */
+  readonly lease?: number;
+}
+interface FailOptions {
+  /** Retry after this many seconds instead of the exponential backoff. SQL connections only. */
+  readonly retryIn?: number;
+}
+type JobHandler<P> = (payload: P, job: Job<P>, signal: AbortSignal) => unknown;
+interface WorkOptions extends ClaimOptions {
+  /** Jobs handled at once. Defaults to 1. */
+  readonly concurrency?: number;
+  /**
+   * First wait between polls when the queue is empty, in ms. Defaults to
+   * 1000. Each empty poll doubles the wait up to `maxPollInterval`; a claimed
+   * job resets it.
+   */
+  readonly pollInterval?: number;
+  /** Longest wait between empty polls, in ms. Defaults to 30000. */
+  readonly maxPollInterval?: number;
+  /** Stops the loop; running jobs finish first. */
+  readonly signal?: AbortSignal;
+  readonly onError?: (error: DbError, job: Job) => void;
+  /**
+   * Run jobs that recorded no tenant with a context that `tenant()` and
+   * tenant buckets don't scope. Off by default, so such jobs get the
+   * `onMissing` of `tenant()`.
+   */
+  readonly allTenants?: boolean;
+}
+interface DrainResult {
+  readonly succeeded: number;
+  readonly failed: number;
+}
+interface Jobs<Q extends QueueSchemas> {
+  /** Validates the payload with the queue's schema, then enqueues it. Returns the job id. */
+  enqueue<N extends Extract<keyof Q, string>>(queue: N, payload: PayloadIn<Q, N>, options?: EnqueueOptions): AsyncResult<number>;
+  claim<N extends Extract<keyof Q, string>>(queue: N, options?: ClaimOptions): AsyncResult<Job<PayloadOut<Q, N>>[]>;
+  /** Archives the job. `false` when the lease was lost (another worker claimed it since). */
+  complete(job: Job): AsyncResult<boolean>;
+  /** Returns the new state: `queued` (will retry), `dead` (archived), or `null` when the lease was lost. */
+  fail(job: Job, error: unknown, options?: FailOptions): AsyncResult<"queued" | "dead" | null>;
+  /** Pushes the lease out by `lease` seconds. `false` when it was lost or the transport can't. */
+  extend(job: Job, lease: number): AsyncResult<boolean>;
+  /**
+   * Enqueues a dead letter again with its payload and attempts, and removes
+   * it from the archive. Returns the new id, or `null` when `id` is not a
+   * dead letter of `queue`. SQL connections only.
+   */
+  replay(queue: Extract<keyof Q, string>, id: number): AsyncResult<number | null>;
+  /**
+   * Enqueues `payload` on a cron schedule (`'0 3 * * *'`, `'@daily'`,
+   * `'30 seconds'`), with pg_cron or the drain scheduler
+   * (`kits.jobs.options.scheduler`). Re-scheduling a name replaces it. SQL
+   * connections only.
+   */
+  schedule<N extends Extract<keyof Q, string>>(name: string, cron: string, queue: N, payload: PayloadIn<Q, N>, options?: ScheduleOptions): AsyncResult<void>;
+  unschedule(name: string): AsyncResult<boolean>;
+  /**
+   * Enqueues one run of every due schedule (the drain scheduler) and moves
+   * it to its next time. Returns how many ran. Missed runs collapse into one.
+   */
+  runSchedules(options?: RunSchedulesOptions): AsyncResult<number>;
+  /** Processes ready jobs until the queue is empty or the budget is spent. For cron and edge invocations. */
+  drain<N extends Extract<keyof Q, string>>(queue: N, handler: JobHandler<PayloadOut<Q, N>>, options?: DrainOptions): Promise<DrainResult>;
+  /**
+   * A route handler for a cron caller such as Vercel Cron: checks the bearer
+   * secret, runs due schedules, then drains each queue in `handlers` within
+   * the budget, and answers with a `DrainRouteResult`.
+   */
+  drainRoute(options: DrainRouteOptions<Q>): (request: Request) => Promise<Response>;
+  /** Polls and processes jobs until `signal` aborts. */
+  work<N extends Extract<keyof Q, string>>(queue: N, handler: JobHandler<PayloadOut<Q, N>>, options?: WorkOptions): Promise<DrainResult>;
+}
+/** The body of a queued message, on pgmq and the table backend alike. */
+interface QueueMessageBody {
+  readonly payload?: unknown;
+  readonly max_attempts?: number;
+  readonly last_error?: string;
+}
+/** A claimed message, as `better_supabase.claim_jobs` returns it. */
+interface QueueMessageRow {
+  readonly id: string | number;
+  /** 1 on the first claim; a lease token for complete, fail and extend. */
+  readonly attempts: number;
+  readonly enqueued_at: Date | string;
+  readonly visible_until: Date | string;
+  readonly message: QueueMessageBody | null;
+}
+/** A schedule whose run is due, claimed by `runSchedules`. */
+interface DueSchedule {
+  readonly name: string;
+  readonly cron: string;
+  readonly timeZone: string;
+  readonly queue: string;
+  /** The payload as stored, with its recorded context. */
+  readonly payload: unknown;
+  readonly nextRun: Temporal.Instant;
+}
+/** A Supabase client, or anything with `.schema(name).rpc(fn, args)`. */
+interface QueueRpcClient {
+  schema(name: string): {
+    rpc(fn: string, args: Readonly<Record<string, unknown>>): PromiseLike<{
+      data: unknown;
+      error: unknown;
+    }>;
+  };
+}
+/**
+ * Where `createJobs` stores jobs. `sqlQueueBackend` (the `jobs` SQL kit
+ * module, on pgmq or its table backend) and `pgmqPublicBackend` ship with
+ * the package; `testQueueBackend` from `better-supabase/testing` checks
+ * another one.
+ */
+interface QueueBackend {
+  readonly apiVersion: 1;
+  readonly name: string;
+  /** Whether `extend` works, so long-running batches keep their lease. */
+  readonly leases: boolean;
+  send(queue: string, payload: unknown, delay: number, maxAttempts: number, dedupeKey: string | undefined): Promise<number>;
+  read(queue: string, lease: number, batch: number): Promise<readonly QueueMessageRow[]>;
+  /** `false` when the lease was lost. */
+  complete(job: Job): Promise<boolean>;
+  fail(job: Job, error: string, retryIn: number | undefined): Promise<"queued" | "dead" | null>;
+  extend(job: Job, lease: number): Promise<boolean>;
+  /** Re-enqueues a dead letter; `null` when it isn't one. Absent when the backend can't. */
+  replay?(queue: string, id: number): Promise<number | null>;
+  schedule(name: string, cron: string, queue: string, payload: unknown, timeZone: string, nextRun: Temporal.Instant): Promise<void>;
+  unschedule(name: string): Promise<boolean>;
+  /** Leases due schedules (the drain scheduler); absent or empty with pg_cron. */
+  dueSchedules?(lease: number, batch: number): Promise<readonly DueSchedule[]>;
+  /** Moves a schedule from `ran` to `next`; `false` when it changed since the claim. */
+  advanceSchedule?(name: string, ran: Temporal.Instant, next: Temporal.Instant): Promise<boolean>;
+}
+/**
+ * The `jobs` SQL kit module over a service SQL connection. The same
+ * functions back both `kits.jobs.options.backend` values (pgmq and table)
+ * and both schedulers.
+ */
+declare function sqlQueueBackend(sql: SqlClient): QueueBackend;
+/**
+ * Supabase's `pgmq_public` RPCs (Integrations, Queues, "Expose Queues via
+ * PostgREST"). No lease check on complete, no retry delay, no deduplication
+ * and no schedules: a failed job reappears when its lease ends.
+ */
+declare function pgmqPublicBackend(client: QueueRpcClient): QueueBackend;
+/**
+ * Typed jobs on Supabase Queues (pgmq), over the `jobs` SQL kit module.
+ *
+ * Pass a service SQL connection (`postgres.admin`, `ctx.sql`) for the full
+ * feature set, a service-role Supabase client to go through the
+ * `pgmq_public` RPCs where no direct connection exists (edge functions), or
+ * any `QueueBackend`. Queue names are lowercase letters, digits and
+ * underscores.
+ */
+declare function createJobs<const Q extends QueueSchemas>(source: SqlClient | QueueRpcClient | QueueBackend, queues: Q): Jobs<Q>;
+//#endregion
+export { sqlQueueBackend as C, pgmqPublicBackend as S, QueueSchemas as _, DrainRouteResult as a, WorkOptions as b, FailOptions as c, JobHandler as d, Jobs as f, QueueRpcClient as g, QueueMessageRow as h, DrainRouteOptions as i, Job as l, QueueMessageBody as m, DrainOptions as n, DueSchedule as o, QueueBackend as p, DrainResult as r, EnqueueOptions as s, ClaimOptions as t, JobContext as u, RunSchedulesOptions as v, createJobs as x, ScheduleOptions as y };

package/dist/react/index.d.ts

@@ -1,7 +1,8 @@
-import { s as Impersonator } from "../mfa-C7MNQ1Ob.js";
-import { t as AuthSession } from "../view-B64o81wp.js";
-import { r as LiveCountSeed } from "../live-BHakSWWo.js";
-import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-Dm-FHpNH.js";
-import { a as ClaimsOf, 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 ClientLike, p as useBroadcast, r as BetterSupabaseProviderProps, s as LiveCount, t as BetterHooks, u as ProfileOf } from "../index-BBdvo-5d.js";
-import { SessionProvider, SessionProviderProps, useSession } from "./session.js";
-export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type ClaimsOf, type ClientLike, type EntitlementKey, type Impersonator, type LiveCount, type LiveCountHookOptions, type LiveCountSeed, type LiveQueryHookOptions, type MembershipClaim, type ProfileOf, SessionProvider, type SessionProviderProps, createHooks, hasEntitlement, useAuth, useBroadcast, useLiveCount, useLiveQuery, useSession, useSupabase };
+import { n as Impersonator } from "../impersonation-BmePsuxz.js";
+import { t as AuthSession } from "../view-CbgObAeb.js";
+import { r as LiveCountSeed } from "../live-D9W2M5aO.js";
+import { n as supportOf, t as SupportView } from "../support-view-B8SlToQX.js";
+import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-BiJZ4t49.js";
+import { _ as useBroadcast, a as BetterHooks, b as useSupabase, c as BroadcastOptions, d as LiveCount, f as LiveCountHookOptions, g as useAuth, h as createHooks, i as useNotifications, l as ClaimsOf, m as ProfileOf, n as NotificationsState, o as BetterSupabaseProvider, p as LiveQueryHookOptions, r as UseNotificationsOptions, s as BetterSupabaseProviderProps, t as NotificationSource, u as ClientLike, v as useLiveCount, y as useLiveQuery } from "../index-Dp2VDwog.js";
+import { SessionProvider, SessionProviderProps, useSession, useSupportSession } from "./session.js";
+export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type ClaimsOf, type ClientLike, type EntitlementKey, type Impersonator, type LiveCount, type LiveCountHookOptions, type LiveCountSeed, type LiveQueryHookOptions, type MembershipClaim, type NotificationSource, type NotificationsState, type ProfileOf, SessionProvider, type SessionProviderProps, type SupportView, type UseNotificationsOptions, createHooks, hasEntitlement, supportOf, useAuth, useBroadcast, useLiveCount, useLiveQuery, useNotifications, useSession, useSupabase, useSupportSession };

package/dist/react/index.js

@@ -1,5 +1,6 @@
 "use client";
-import { SessionProvider, useSession } from "./session.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-CQHMaESR.js";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
+import { SessionProvider, useSession, useSupportSession } from "./session.js";
+import { a as useBroadcast, c as useSupabase, i as useAuth, n as BetterSupabaseProvider, o as useLiveCount, r as createHooks, s as useLiveQuery, t as useNotifications } from "../react-C_s7kiNz.js";
 import { t as hasEntitlement } from "../entitlements-CTEBm7IB.js";
-export { BetterSupabaseProvider, SessionProvider, createHooks, hasEntitlement, useAuth, useBroadcast, useLiveCount, useLiveQuery, useSession, useSupabase };
+export { BetterSupabaseProvider, SessionProvider, createHooks, hasEntitlement, supportOf, useAuth, useBroadcast, useLiveCount, useLiveQuery, useNotifications, useSession, useSupabase, useSupportSession };

package/dist/react/server.d.ts

@@ -1,13 +1,24 @@
-import { t as AuthSession } from "../view-B64o81wp.js";
-import { a as ClaimsOf, f as useAuth, g as useSupabase, h as useLiveQuery, i as BroadcastOptions, l as LiveQueryHookOptions, n as BetterSupabaseProvider, o as ClientLike, p as useBroadcast, r as BetterSupabaseProviderProps, t as BetterHooks, u as ProfileOf } from "../index-BBdvo-5d.js";
+import { Z as QuerySpec } from "../define-Bp_BZa5h.js";
+import { n as Impersonator } from "../impersonation-BmePsuxz.js";
+import { t as AuthSession } from "../view-CbgObAeb.js";
+import { r as LiveCountSeed } from "../live-D9W2M5aO.js";
+import { n as supportOf, t as SupportView } from "../support-view-B8SlToQX.js";
+import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-BiJZ4t49.js";
+import { _ as useBroadcast, a as BetterHooks, b as useSupabase, c as BroadcastOptions, d as LiveCount, f as LiveCountHookOptions, g as useAuth, l as ClaimsOf, m as ProfileOf, n as NotificationsState, o as BetterSupabaseProvider, p as LiveQueryHookOptions, r as UseNotificationsOptions, s as BetterSupabaseProviderProps, t as NotificationSource, u as ClientLike, y as useLiveQuery } from "../index-Dp2VDwog.js";
 import { SessionProvider, SessionProviderProps } from "./session.js";
 //#region src/react/server.d.ts
 /** The `react-server` build of `useSession`: await `bs.session()` instead. */
 export declare const useSession: <C = unknown, P = unknown>() => AuthSession<C, P>;
+/** The `react-server` build of `useSupportSession`: use `supportOf(await bs.session())` instead. */
+export declare const useSupportSession: () => SupportView | undefined;
+/** The `react-server` build of `useLiveCount`: render the `bs.liveCount()` seed instead. */
+export declare const useLiveCount: (source: QuerySpec<string, "count", number> | LiveCountSeed | null | undefined, options?: LiveCountHookOptions) => LiveCount;
+/** The `react-server` build of `useNotifications`: call `notifications.list()` instead. */
+export declare const useNotifications: <T>(options: UseNotificationsOptions<T>) => NotificationsState<T>;
 /**
  * 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 ClientLike>(): BetterHooks<B>;
 //#endregion
-export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type ClaimsOf, type ClientLike, type LiveQueryHookOptions, type ProfileOf, SessionProvider, type SessionProviderProps, useAuth, useBroadcast, useLiveQuery, useSupabase };
+export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type ClaimsOf, type ClientLike, type EntitlementKey, type Impersonator, type LiveCount, type LiveCountHookOptions, type LiveCountSeed, type LiveQueryHookOptions, type MembershipClaim, type NotificationSource, type NotificationsState, type ProfileOf, SessionProvider, type SessionProviderProps, type SupportView, type UseNotificationsOptions, hasEntitlement, supportOf, useAuth, useBroadcast, useLiveQuery, useSupabase };

package/dist/react/server.js

@@ -1,4 +1,6 @@
-import { i as useBroadcast, o as useLiveQuery, r as useAuth, s as useSupabase, t as BetterSupabaseProvider } from "../react-CQHMaESR.js";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
+import { a as useBroadcast, c as useSupabase, i as useAuth, n as BetterSupabaseProvider, s as useLiveQuery } from "../react-C_s7kiNz.js";
+import { t as hasEntitlement } from "../entitlements-CTEBm7IB.js";
 import { SessionProvider } from "./session.js";
 //#region src/react/server.ts
 function clientOnly(name) {
@@ -8,6 +10,12 @@ function clientOnly(name) {
 }
 /** The `react-server` build of `useSession`: await `bs.session()` instead. */
 const useSession = clientOnly("useSession");
+/** The `react-server` build of `useSupportSession`: use `supportOf(await bs.session())` instead. */
+const useSupportSession = clientOnly("useSupportSession");
+/** The `react-server` build of `useLiveCount`: render the `bs.liveCount()` seed instead. */
+const useLiveCount = clientOnly("useLiveCount");
+/** The `react-server` build of `useNotifications`: call `notifications.list()` instead. */
+const useNotifications = clientOnly("useNotifications");
 /**
 * The `react-server` build of `createHooks`: importing a module that creates
 * hooks is safe on the server, calling a hook there throws.
@@ -22,4 +30,4 @@ function createHooks() {
 	};
 }
 //#endregion
-export { BetterSupabaseProvider, SessionProvider, createHooks, useAuth, useBroadcast, useLiveQuery, useSession, useSupabase };
+export { BetterSupabaseProvider, SessionProvider, createHooks, hasEntitlement, supportOf, useAuth, useBroadcast, useLiveCount, useLiveQuery, useNotifications, useSession, useSupabase, useSupportSession };

package/dist/react/session.d.ts

@@ -1,4 +1,5 @@
-import { t as AuthSession } from "../view-B64o81wp.js";
+import { t as AuthSession } from "../view-CbgObAeb.js";
+import { t as SupportView } from "../support-view-B8SlToQX.js";
 import { ReactNode } from "react";
 //#region src/react/session.d.ts
 export interface SessionProviderProps {
@@ -18,4 +19,9 @@ export declare function SessionProvider(props: SessionProviderProps): ReactNode;
  * `betterSupabase.userMetadata(schema)`); `createHooks().useSession` infers both.
  */
 export declare function useSession<C = unknown, P = unknown>(): AuthSession<C, P>;
+/**
+ * The support session the page renders in, for a "Viewing as" banner, or
+ * `undefined` for a normal session. Needs `<SessionProvider>` like `useSession`.
+ */
+export declare function useSupportSession(): SupportView | undefined;
 //#endregion

package/dist/react/session.js

@@ -1,4 +1,5 @@
 "use client";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
 import { createContext, createElement, use, useContext } from "react";
 //#region src/react/session.ts
 const SessionContext = createContext(null);
@@ -17,5 +18,12 @@ function useSession() {
 	if (!promise) throw new Error("better-supabase: useSession() needs <SessionProvider sessionPromise={...}>");
 	return use(promise);
 }
+/**
+* The support session the page renders in, for a "Viewing as" banner, or
+* `undefined` for a normal session. Needs `<SessionProvider>` like `useSession`.
+*/
+function useSupportSession() {
+	return supportOf(useSession());
+}
 //#endregion
-export { SessionProvider, useSession };
+export { SessionProvider, useSession, useSupportSession };

package/dist/{react-CQHMaESR.js → react-C_s7kiNz.js}

@@ -1,8 +1,9 @@
 import { i as tenantClaimPaths, n as claimAt, r as claimsOf } from "./claims-BAf6c7is.js";
-import { t as invalidateTables } from "./invalidate-CgxmRamI.js";
+import { n as invalidateTables, t as clearOnUserChange } from "./user-change-CHFEUro1.js";
 import { n as liveQuery, t as liveCount } from "./live-CdJBOc4f.js";
 import { useSession } from "./react/session.js";
-import { createContext, createElement, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { REALTIME_SUBSCRIBE_STATES } from "@supabase/supabase-js";
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 //#region src/react/hooks.ts
 const ClientContext = createContext(null);
 const LOADING = {
@@ -13,14 +14,7 @@ const LOADING = {
 /** Provides the better-supabase client to the hooks. */
 function BetterSupabaseProvider(props) {
 	const { client, queryClient } = props;
-	const user = useRef(void 0);
-	useEffect(() => client.auth.subscribe(() => {
-		const snapshot = client.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;
-	}), [client, queryClient]);
+	useEffect(() => queryClient ? clearOnUserChange(queryClient, client.auth) : void 0, [client, queryClient]);
 	const value = useMemo(() => ({
 		client,
 		queryClient
@@ -243,4 +237,102 @@ function useLiveCount(source, options = {}) {
 	};
 }
 //#endregion
-export { useLiveCount as a, useBroadcast as i, createHooks as n, useLiveQuery as o, useAuth as r, useSupabase as s, BetterSupabaseProvider as t };
+//#region src/react/notifications.ts
+const unread = (items) => items.filter((item) => typeof item === "object" && item !== null && "readAt" in item && item.readAt === null).length;
+/** Joins a private topic and returns the function that leaves it. */
+function watchTopic(supabase, topic, watch) {
+	let closed = false;
+	let joined = false;
+	const channel = supabase.channel(topic, { config: { private: true } });
+	channel.on("broadcast", { event: "*" }, (message) => {
+		watch.onMessage(message.event, message["payload"]);
+	});
+	(async () => {
+		watch.onStatus("joining");
+		await supabase.realtime.setAuth();
+		if (closed) return;
+		channel.subscribe((state) => {
+			switch (state) {
+				case REALTIME_SUBSCRIBE_STATES.SUBSCRIBED:
+					if (joined) watch.onRejoin();
+					joined = true;
+					watch.onStatus("subscribed");
+					return;
+				case REALTIME_SUBSCRIBE_STATES.CLOSED:
+					watch.onStatus("closed");
+					return;
+				case REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR:
+				case REALTIME_SUBSCRIBE_STATES.TIMED_OUT:
+					watch.onStatus("error");
+					return;
+				default: throw new Error(`Unknown realtime status ${String(state)}`);
+			}
+		});
+	})();
+	return () => {
+		closed = true;
+		supabase.removeChannel(channel);
+		watch.onStatus("closed");
+	};
+}
+/**
+* The signed-in user's notifications, kept current: loads them, then loads
+* again after each broadcast on `topic` and after the channel rejoins.
+*
+* ```tsx
+* const { items, count } = useNotifications({
+*   topic: `org:${orgId}:notifications:${userId}`,
+*   load: () => listNotifications(orgId),
+* });
+* ```
+*/
+function useNotifications(options) {
+	const supabase = useSupabase();
+	const auth = useAuth();
+	const [items, setItems] = useState(void 0);
+	const [error, setError] = useState(void 0);
+	const [status, setStatus] = useState("closed");
+	const latest = useRef(options);
+	latest.current = options;
+	const userId = auth.user?.id ?? null;
+	const refresh = useCallback(async () => {
+		const current = latest.current;
+		try {
+			const merged = (await Promise.all([current.load, ...current.sources ?? []].map((source) => source()))).flat();
+			setItems(current.sort ? [...merged].sort(current.sort) : merged);
+			setError(void 0);
+		} catch (cause) {
+			setError(cause);
+		}
+	}, []);
+	const topic = options.topic;
+	useEffect(() => {
+		if (auth.status !== "signed-in") return;
+		refresh();
+		if (!topic) return;
+		return watchTopic(supabase, topic, {
+			onMessage: (event, payload) => {
+				latest.current.onMessage?.(event, payload);
+				refresh();
+			},
+			onRejoin: () => void refresh(),
+			onStatus: setStatus
+		});
+	}, [
+		supabase,
+		topic,
+		userId,
+		auth.status,
+		refresh
+	]);
+	const list = items ?? [];
+	return {
+		items,
+		count: (options.count ?? unread)(list),
+		status,
+		error,
+		refresh
+	};
+}
+//#endregion
+export { useBroadcast as a, useSupabase as c, useAuth as i, BetterSupabaseProvider as n, useLiveCount as o, createHooks as r, useLiveQuery as s, useNotifications as t };