better-supabase 0.3.0 → 0.5.0

package/dist/next/index.js

@@ -1,17 +1,18 @@
-import { n as dbError } from "../errors-Bl3rkOzo.js";
-import { n as StatsRecorder, t as EMPTY_STATS } from "../stats-D78UQ8Yu.js";
-import { o as isReadSet } from "../read-set-D0qBcboM.js";
-import { t as validate } from "../standard-FUi3Z3-7.js";
-import { a as problemResponse } from "../problem-CGt1ADix.js";
+import { n as dbError } from "../errors-DtwXa6b8.js";
+import { n as StatsRecorder, t as EMPTY_STATS } from "../stats-Bqob3WqT.js";
+import { o as isReadSet } from "../read-set-DQFt1N_Y.js";
+import { t as validate } from "../standard-D7r6dMUu.js";
+import { a as problemResponse } from "../problem-BW1KhzSG.js";
 import { t as isList } from "../guards-BnzDvFrz.js";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
 import { t as hasEntitlement } from "../entitlements-CTEBm7IB.js";
-import { a as settle, c as withExtra, d as primaryCookie, i as respond, n as guard, o as createServer, s as extendServer, t as defaultExpose, u as PRIMARY_COOKIE } from "../respond-C44EZAJo.js";
-import { r as checkAal } from "../mfa-BxoR1RkN.js";
-import { t as toSession } from "../view-wZ-9qIUz.js";
+import { a as withExtra, b as withPrimaryPin, d as guard, m as settle, n as createServer, p as respond, r as extendServer, u as defaultExpose, v as PRIMARY_COOKIE, y as primaryCookieOptions } from "../server-Csx2sRjg.js";
+import { a as checkAal, n as toSession } from "../view-Bq64ki8-.js";
+import { t as supportSessions } from "../support-Dk6vdmEw.js";
 import { cache } from "react";
 import { cacheLife, cacheTag, revalidateTag, updateTag } from "next/cache.js";
 import { cookies, headers } from "next/headers.js";
-import { NextResponse } from "next/server.js";
+import { NextResponse, after } from "next/server.js";
 //#region src/next/collector.ts
 /** Forwarded by the proxy so every scope of one render shares an id. */
 const REQUEST_ID_HEADER = "x-bs-request-id";
@@ -143,8 +144,12 @@ function serverTimingValue(metrics) {
 }
 //#endregion
 //#region src/next/create.ts
-/** Response header with the URL of the request's totals on `next.debugRoute()`. */
+/** Response header with the URL of the request's totals on `bs.debugRoute()`. */
 const STATS_URL_HEADER = "x-bs-stats";
+/** The tag `bs.cached()` adds to entries rendered in a support session. */
+function supportTag(sessionId) {
+	return `bs:support:${sessionId}`;
+}
 /**
 * `cacheLife` `stale` seconds for a view of `session`: `max`, but never past
 * the token's expiry, and at least `min`.
@@ -156,7 +161,7 @@ function sessionStale(session, options = {}, now = Date.now()) {
 	const remaining = session.expiresAt - Math.floor(now / 1e3);
 	return Math.min(max, Math.max(min, remaining));
 }
-/** The tag `next.cached()` puts on a user's entries. */
+/** The tag `bs.cached()` puts on a user's entries. */
 function sessionTag(userId) {
 	return `bs:session:${userId}`;
 }
@@ -202,7 +207,7 @@ function formDataObject(form) {
 * combine it with your sign-in redirect.
 *
 * ```ts
-* next.proxy(request, {
+* bs.proxy(request, {
 *   protect: requireAal('aal2', { redirect: '/mfa', match: (path) => path.startsWith('/settings') }),
 * });
 * ```
@@ -235,20 +240,20 @@ function shouldRefresh(request) {
 * actions and cache tags, on top of `createServer`.
 *
 * ```ts
-* export const next = createNext(sb);
+* export const bs = createNext(betterSupabase);
 * ```
 */
-function createNext(sb, options = {}) {
-	const base = createServer(sb, options);
+function createNext(betterSupabase, options = {}) {
+	const base = createServer(betterSupabase, options);
 	const pinMs = options.replicas?.pinMs ?? 5e3;
 	const expose = options.exposeErrors ?? defaultExpose();
-	if (options.cacheTags !== false) sb.cache(nextCache());
+	if (options.cacheTags !== false) betterSupabase.cache(nextCache());
 	const debug = options.debug;
 	const statsHeader = debug?.header ?? "x-bs-db-calls";
 	const statsRoute = debug?.route ?? "/api/bs-stats";
 	const development = process.env["NODE_ENV"] === "development";
 	const collector = debug?.enabled ? sharedCollector({
-		logger: sb.events.logger,
+		logger: betterSupabase.events.logger,
 		warn: development,
 		...debug.budget ? { budget: debug.budget } : {}
 	}) : void 0;
@@ -256,35 +261,66 @@ function createNext(sb, options = {}) {
 		const id = collector && request.headers.get("x-bs-request-id");
 		return id ? { stats: collector.recorderFor(id) } : {};
 	};
+	/** Keeps the function alive for event sink sends the handler started. */
+	const flushAfter = () => {
+		const { events } = betterSupabase;
+		if (!events.pending) return;
+		try {
+			after(() => events.settled());
+		} catch (cause) {
+			events.logger.warn("after() is unavailable; event sends may be cut off", { cause });
+		}
+	};
 	const incomingRequest = async () => new Request("http://next.local/", { headers: new Headers(await headers()) });
-	const server = cache(async () => {
+	/** One token verification per render scope backs `context()`, `session()` and `cached()`. */
+	const incoming = cache(async () => {
 		const request = await incomingRequest();
-		return base.context(request, statsFor(request));
+		return {
+			request,
+			resolution: await base.resolve(request, { refresh: false })
+		};
 	});
-	const session = cache(async () => {
-		const resolution = await base.resolve(await incomingRequest(), { refresh: false });
-		return toSession(resolution.auth);
+	const current = cache(async () => {
+		const { request, resolution } = await incoming();
+		const [tenant, support] = await Promise.all([options.tenant?.(request, resolution.auth), base.support.current(request, resolution.auth)]);
+		return base.contextFromResolution(resolution, request, {
+			...statsFor(request),
+			...tenant === void 0 ? {} : { tenant },
+			...support ? { support } : {}
+		});
 	});
-	const serverFor = async (view, { token }) => {
+	const context = (request, contextOptions) => request ? base.context(request, contextOptions) : current();
+	/** In a support session, the target's view: `impersonator` names the admin. */
+	const session = cache(async () => toSession(options.support ? (await current()).auth : (await incoming()).resolution.auth));
+	const supportCookieName = options.support?.options.cookie?.name ?? "bs-support";
+	const supportCookieOptions = {
+		httpOnly: true,
+		sameSite: "lax",
+		path: options.support?.options.cookie?.path ?? "/",
+		secure: options.support?.options.cookie?.secure ?? true
+	};
+	const contextForSession = async (view, { token }) => {
 		const request = new Request("http://next.local/", { headers: token ? { authorization: `Bearer ${token}` } : {} });
 		const ctx = await base.context(request);
-		if (ctx.auth.kind === "user" ? view.kind === "user" && view.user.id === ctx.auth.user.id : view.kind !== "user") return ctx;
+		if (ctx.auth.kind === "user" ? view.kind === "user" && view.user.id === ctx.auth.user.id : view.kind === ctx.auth.kind) return ctx;
 		return base.contextFor({
 			kind: "invalid",
 			reason: "token",
-			error: dbError("unauthorized", "The token does not belong to the session passed to serverFor()")
+			error: dbError("unauthorized", "The token does not belong to the session passed to contextForSession()")
 		});
 	};
-	const withAccounts = withExtra(base, { deleteAccount: ((userId, deleteOptions) => base.deleteAccount(userId, deleteOptions).map((result) => {
-		invalidate(sessionTag(userId));
-		return result;
-	})) });
+	const withAccounts = withExtra(base, {
+		context,
+		deleteAccount: ((userId, deleteOptions) => base.deleteAccount(userId, deleteOptions).map((result) => {
+			invalidate(sessionTag(userId));
+			return result;
+		}))
+	});
 	return extendServer(withAccounts, {
-		server,
 		session,
-		serverFor,
+		contextForSession,
 		async cached(cachedOptions = {}) {
-			const [view, ctx] = await Promise.all([session(), server()]);
+			const [view, ctx] = await Promise.all([session(), current()]);
 			const life = cachedOptions.life;
 			const stale = sessionStale(view, life);
 			cacheLife({
@@ -292,7 +328,11 @@ function createNext(sb, options = {}) {
 				...life?.revalidate === void 0 ? {} : { revalidate: life.revalidate },
 				...life?.expire === void 0 ? {} : { expire: life.expire }
 			});
-			const tags = [...view.kind === "user" ? [sessionTag(view.user.id)] : [], ...cachedOptions.tags ?? []];
+			const tags = [
+				...view.kind === "user" ? [sessionTag(view.user.id)] : [],
+				...ctx.support ? [supportTag(ctx.support.session.id)] : [],
+				...cachedOptions.tags ?? []
+			];
 			if (tags.length > 0) cacheTag(...tags);
 			return withExtra(ctx, { session: view });
 		},
@@ -301,7 +341,7 @@ function createNext(sb, options = {}) {
 			for (const tag of invalidateOptions.tags ?? []) invalidate(tag);
 		},
 		async liveCount(spec, db) {
-			const result = await (db ?? (await server()).db).$run(spec);
+			const result = await (db ?? (await current()).db).$run(spec);
 			return {
 				spec,
 				count: result.ok && typeof result.data === "number" ? result.data : null
@@ -349,13 +389,21 @@ function createNext(sb, options = {}) {
 					expose
 				});
 				const params = await segment.params;
-				const response = await respond(() => handler(request, withExtra(ctx, { params })), {
-					instance,
-					expose
-				});
-				if (ctx.replica?.wrote) try {
-					response.headers.append("set-cookie", primaryCookie(pinMs));
-				} catch {}
+				let response;
+				try {
+					response = await respond(() => handler(request, withExtra(ctx, { params })), {
+						instance,
+						expose
+					});
+				} catch (cause) {
+					rethrowNextControlFlow(cause);
+					response = problemResponse(dbError("unexpected", expose && cause instanceof Error ? cause.message : "Internal server error"), {
+						instance,
+						expose
+					});
+				}
+				response = withPrimaryPin(response, ctx.replica, pinMs);
+				flushAfter();
 				if (collector) try {
 					response.headers.set(statsHeader, formatStats(ctx.stats()));
 				} catch {}
@@ -378,7 +426,7 @@ function createNext(sb, options = {}) {
 		},
 		action(actionOptions, fn) {
 			return async (input) => {
-				const ctx = await server();
+				const ctx = await current();
 				const denied = guard(ctx.auth, actionOptions.allow, actionOptions.aal, actionOptions.scopes);
 				if (denied) return {
 					ok: false,
@@ -396,12 +444,8 @@ function createNext(sb, options = {}) {
 					parsed = checked.data;
 				}
 				const settled = await settle(() => fn(parsed, ctx));
-				if (ctx.replica?.wrote) (await cookies()).set(PRIMARY_COOKIE, String(Date.now() + pinMs), {
-					path: "/",
-					maxAge: Math.max(1, Math.ceil(pinMs / 1e3)),
-					httpOnly: true,
-					sameSite: "lax"
-				});
+				flushAfter();
+				if (ctx.replica?.wrote) (await cookies()).set(PRIMARY_COOKIE, String(Date.now() + pinMs), primaryCookieOptions(pinMs));
 				return settled.ok ? {
 					ok: true,
 					data: settled.data,
@@ -413,6 +457,59 @@ function createNext(sb, options = {}) {
 				};
 			};
 		},
+		async startSupport(request) {
+			const { resolution } = await incoming();
+			const started = await base.support.start(resolution.auth, request);
+			flushAfter();
+			if (!started.ok) return {
+				ok: false,
+				data: null,
+				error: started.error
+			};
+			const { session: support } = started.data;
+			(await cookies()).set(supportCookieName, support.id, {
+				...supportCookieOptions,
+				maxAge: Math.max(0, Math.floor((support.expiresAt.epochMilliseconds - Date.now()) / 1e3))
+			});
+			if (resolution.auth.kind === "user") invalidate(sessionTag(resolution.auth.user.id));
+			return {
+				ok: true,
+				data: {
+					sessionId: support.id,
+					targetUserId: support.targetUserId,
+					readOnly: support.readOnly,
+					expiresAt: support.expiresAt.toString()
+				},
+				error: null
+			};
+		},
+		async stopSupport() {
+			const { request, resolution } = await incoming();
+			const jar = await cookies();
+			const id = base.support.sessionIdOf(request);
+			jar.delete({
+				name: supportCookieName,
+				path: supportCookieOptions.path
+			});
+			if (!id) return {
+				ok: true,
+				data: { ended: false },
+				error: null
+			};
+			const stopped = await base.support.stop(resolution.auth, id);
+			flushAfter();
+			invalidate(supportTag(id));
+			if (resolution.auth.kind === "user") invalidate(sessionTag(resolution.auth.user.id));
+			return stopped.ok ? {
+				ok: true,
+				data: { ended: stopped.data.ended },
+				error: null
+			} : {
+				ok: false,
+				data: null,
+				error: stopped.error
+			};
+		},
 		cacheTag(table, id) {
 			cacheTag(tagFor(table), ...id === void 0 ? [] : [tagFor(table, id)]);
 		},
@@ -420,7 +517,7 @@ function createNext(sb, options = {}) {
 			const specs = isReadSet(target) ? Object.values(target.specs) : isList(target) ? target : [target];
 			const tags = /* @__PURE__ */ new Set();
 			for (const spec of specs) {
-				for (const table of sb.tablesOf(spec)) tags.add(tagFor(table));
+				for (const table of betterSupabase.tablesOf(spec)) tags.add(tagFor(table));
 				const [id] = spec.args;
 				if (spec.method === "findById" && (typeof id === "string" || typeof id === "number")) tags.add(tagFor(spec.table, id));
 			}
@@ -428,5 +525,25 @@ function createNext(sb, options = {}) {
 		}
 	});
 }
+const NEXT_DIGESTS = /* @__PURE__ */ new Set([
+	"NEXT_REDIRECT",
+	"NEXT_HTTP_ERROR_FALLBACK",
+	"DYNAMIC_SERVER_USAGE",
+	"BAILOUT_TO_CLIENT_SIDE_RENDERING",
+	"HANGING_PROMISE_REJECTION",
+	"NEXT_PRERENDER_INTERRUPTED"
+]);
+const REACT_POSTPONE = Symbol.for("react.postpone");
+/**
+* `unstable_rethrow` without `next/navigation`: that entry loads the client
+* router context, which Turbopack can't resolve inside route handlers. The
+* digests are the ones Next 16 checks.
+*/
+function rethrowNextControlFlow(error) {
+	if (typeof error !== "object" || error === null) return;
+	const digest = "digest" in error ? error.digest : void 0;
+	if (typeof digest === "string" && NEXT_DIGESTS.has(digest.split(";", 1)[0] ?? "") || "$$typeof" in error && error.$$typeof === REACT_POSTPONE || error instanceof Error && error.message.includes("needs to bail out of prerendering")) throw error;
+	if ("cause" in error) rethrowNextControlFlow(error.cause);
+}
 //#endregion
-export { REQUEST_ID_HEADER, STATS_URL_HEADER, createNext, hasEntitlement, nextCache, requireAal, sessionStale, sessionTag, shouldRefresh, tagFor, toSession };
+export { REQUEST_ID_HEADER, STATS_URL_HEADER, createNext, hasEntitlement, nextCache, requireAal, sessionStale, sessionTag, shouldRefresh, supportOf, supportSessions, supportTag, tagFor, toSession };

package/dist/notifications/index.d.ts

@@ -0,0 +1,162 @@
+/// <reference lib="esnext.temporal" />
+import { S as ErrorMapper, a as AsyncResult } from "../executor-BunPOO-k.js";
+import { a as EventHub } from "../events-aIO7vsIk.js";
+import { g as RequestContext } from "../plugin-o144f322.js";
+import { i as sqlTransport, n as RpcClient, r as rpcTransport, t as KitTransport } from "../kit-transport-B82k1djG.js";
+import { a as NotificationSubject, i as NotificationItem, n as NotificationMessage, o as RenderedText, r as NotificationSendResult, t as NotificationChannel } from "../channel-FQW-CnGR.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/notifications/notifications.d.ts
+/** Notification type to the Standard Schema of its `data`. */
+type NotificationTypes = Readonly<Record<string, StandardSchemaV1>>;
+type TypeName<K extends NotificationTypes> = keyof K & string;
+interface SendInput<D = unknown> {
+  /** Who gets it. Watchers of `subject` and the `notification_audience` hook add more. */
+  readonly recipients?: readonly string[];
+  /** The organization; required when an authenticated user sends. */
+  readonly tenant?: string;
+  readonly subject?: NotificationSubject;
+  readonly summary?: string;
+  readonly actionPath?: string;
+  /** One of `kits.notifications.options.priorities`. Defaults to `normal`. */
+  readonly priority?: string;
+  readonly data: D;
+  /** With a key, sending again (per tenant) returns the first notification. */
+  readonly key?: string;
+  /** Defaults to `kits.notifications.options.channels`. */
+  readonly channels?: readonly string[];
+  /** Also notify the user who caused it. Defaults to `false`. */
+  readonly includeActor?: boolean;
+  /**
+   * `participating` (default) reaches subject watchers at both levels;
+   * `all` is routine activity that only `all` watchers get.
+   */
+  readonly activity?: "participating" | "all";
+  /** Create it already resolved, e.g. for a record of a finished approval. */
+  readonly resolved?: boolean;
+  /** The actor, when the service sends on a user's behalf. */
+  readonly actorId?: string;
+}
+interface ListOptions<K extends string = string> {
+  readonly tenant?: string;
+  readonly status?: "all" | "unread" | "read" | "unresolved";
+  readonly types?: readonly K[];
+  /**
+   * Page: only notifications older than this. Pass the last item of the
+   * previous page; a bare instant skips items created at that same instant.
+   */
+  readonly before?: Temporal.Instant | Pick<NotificationItem, "createdAt" | "id">;
+  /** Up to 200. Defaults to 50. */
+  readonly limit?: number;
+  /** Passed to `render`. */
+  readonly locale?: string;
+}
+interface NotificationCounts {
+  readonly unread: number;
+  /** Unresolved notifications of the `actionable` types. */
+  readonly actionable: number;
+}
+type SubscriptionLevel = "participating" | "all" | "ignore";
+interface DeliverOptions {
+  /** Channel names to work on. Defaults to every channel in `channels`. */
+  readonly channels?: readonly string[];
+  /** Deliveries per claim. Defaults to 50. */
+  readonly batch?: number;
+  /** How long a claimed delivery waits before another worker retries it. */
+  readonly lease?: string;
+  /**
+   * Tries before a delivery is `failed`. Defaults to 5. Retries wait a random
+   * time up to 30 seconds, doubling per attempt to an hour.
+   */
+  readonly maxAttempts?: number;
+  readonly budgetMs?: number;
+}
+interface DeliverResult {
+  readonly sent: number;
+  readonly skipped: number;
+  /** Deliveries that threw; retried later unless they ran out of attempts. */
+  readonly failed: number;
+}
+interface Rendered<K extends string = string, D = unknown> extends NotificationItem<K, D> {
+  /** What `render` returned. Absent without a `render` option. */
+  readonly text?: RenderedText;
+}
+interface NotificationsOptions<K extends NotificationTypes> {
+  /** `sqlTransport(postgres.asUser(claims))`, or over `postgres.admin` for the service. */
+  readonly transport: KitTransport;
+  /** Each type's `data` schema: `send` validates against it. */
+  readonly types: K;
+  /** `kits.notifications.schema`. Defaults to `better_supabase`. */
+  readonly schema?: string;
+  /** Turns a notification into text at read time, in the reader's locale. */
+  readonly render?: (item: NotificationItem, context: {
+    readonly locale?: string;
+  }) => RenderedText;
+  /** Types that wait for an action; `counts().actionable` counts them. */
+  readonly actionable?: readonly TypeName<K>[];
+  /** Senders for the non-`in_app` channels, used by `deliver()`. */
+  readonly channels?: readonly NotificationChannel[];
+  /** Runs after a notification is stored, e.g. to call Next's `updateTag`. */
+  readonly onSent?: (sent: {
+    readonly id: string;
+    readonly type: string;
+    readonly tenant: string | null;
+    readonly recipients: readonly string[];
+  }) => void | Promise<void>;
+  /** `betterSupabase.events`, for `notification.*` kit events. */
+  readonly events?: EventHub;
+  readonly actorId?: string;
+  readonly context?: RequestContext;
+  readonly errorMappers?: readonly ErrorMapper[];
+}
+/**
+ * The `notifications` SQL kit module as typed calls. `send` validates the
+ * data against its type's schema; the database checks the send permission,
+ * leaves out the actor and non-members and applies subscriptions and
+ * preferences.
+ */
+interface Notifications<K extends NotificationTypes> {
+  /** The notification id, or `null` when nobody was left to notify. */
+  send<N extends TypeName<K>>(type: N, input: SendInput<StandardSchemaV1.InferInput<K[N]>>): AsyncResult<string | null>;
+  list(options?: ListOptions<TypeName<K>>): AsyncResult<readonly Rendered<TypeName<K>>[]>;
+  counts(options?: {
+    readonly tenant?: string;
+  }): AsyncResult<NotificationCounts>;
+  /** Marks the given notifications, or all of them, read. */
+  markRead(options?: {
+    readonly ids?: readonly string[];
+    readonly tenant?: string;
+  }): AsyncResult<number>;
+  dismiss(ids: readonly string[]): AsyncResult<number>;
+  /** Resolves every recipient's notification of a type about a subject. */
+  resolve(input: {
+    readonly type: TypeName<K>;
+    readonly subject: NotificationSubject;
+    readonly tenant?: string;
+  }): AsyncResult<number>;
+  /** Sets the user's level for a subject; `null` removes it. */
+  subscribe(input: {
+    readonly subject: NotificationSubject;
+    readonly level: SubscriptionLevel | null;
+    readonly tenant?: string;
+    /** Another member; only the service can set it. */
+    readonly userId?: string;
+  }): AsyncResult<void>;
+  /** Turns a type (`*` for all) on or off on a channel; `null` removes it. */
+  setPreference(input: {
+    readonly type: TypeName<K> | "*";
+    readonly channel: string;
+    readonly enabled: boolean | null;
+    /** One organization, or everywhere when omitted. */
+    readonly tenant?: string;
+  }): AsyncResult<void>;
+  /** Sends pending deliveries through `channels`. Run it from a cron or a job. */
+  deliver(options?: DeliverOptions): Promise<DeliverResult>;
+  /**
+   * Deletes up to `batch` (10,000) notifications older than `olderThan`
+   * (`90 days`) with their recipients and deliveries. Service only.
+   */
+  purge(olderThan?: string, batch?: number): AsyncResult<number>;
+}
+export declare function createNotifications<const K extends NotificationTypes>(options: NotificationsOptions<K>): Notifications<K>;
+//#endregion
+export { type DeliverOptions, type DeliverResult, type KitTransport, type ListOptions, type NotificationChannel, type NotificationCounts, type NotificationItem, type NotificationMessage, type NotificationSendResult, type NotificationSubject, type NotificationTypes, type Notifications, type NotificationsOptions, type Rendered, type RenderedText, type RpcClient, type SendInput, type SubscriptionLevel, rpcTransport, sqlTransport };