better-supabase 0.4.0 → 0.5.0

package/dist/next/index.js

@@ -1,17 +1,18 @@
-import { n as dbError } from "../errors-L0xK41y_.js";
-import { n as StatsRecorder, t as EMPTY_STATS } from "../stats-C_YxA2r1.js";
-import { o as isReadSet } from "../read-set-FWK8qQ58.js";
-import { t as validate } from "../standard-BRyBGTtp.js";
-import { a as problemResponse } from "../problem-BihjPR0t.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 guard, c as settle, d as primaryCookie, i as defaultExpose, n as extendServer, r as withExtra, s as respond, t as createServer, u as PRIMARY_COOKIE } from "../server-BA75B0mT.js";
-import { r as checkAal } from "../mfa-byfjruR9.js";
-import { t as toSession } from "../view-BrJI2LKp.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";
@@ -145,6 +146,10 @@ function serverTimingValue(metrics) {
 //#region src/next/create.ts
 /** 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`.
@@ -256,6 +261,16 @@ function createNext(betterSupabase, 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()) });
 	/** One token verification per render scope backs `context()`, `session()` and `cached()`. */
 	const incoming = cache(async () => {
@@ -267,14 +282,27 @@ function createNext(betterSupabase, options = {}) {
 	});
 	const current = cache(async () => {
 		const { request, resolution } = await incoming();
-		return base.contextFromResolution(resolution, request, statsFor(request));
+		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 context = (request, contextOptions) => request ? base.context(request, contextOptions) : current();
-	const session = cache(async () => toSession((await incoming()).resolution.auth));
+	/** 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",
@@ -300,7 +328,11 @@ function createNext(betterSupabase, 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 });
 		},
@@ -357,13 +389,21 @@ function createNext(betterSupabase, 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 {}
@@ -404,12 +444,8 @@ function createNext(betterSupabase, 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,
@@ -421,6 +457,59 @@ function createNext(betterSupabase, 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)]);
 		},
@@ -436,5 +525,25 @@ function createNext(betterSupabase, 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 };

package/dist/notifications/index.js

@@ -0,0 +1,264 @@
+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 { n as emitKitEvent } from "../kit-events-CTFDfSwb.js";
+import { n as rpcTransport, r as sqlTransport, t as rawError } from "../kit-transport-DJlHQUBU.js";
+//#region src/notifications/notifications.ts
+const DEFAULT_SCHEMA = "better_supabase";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const textOf = (value) => value === null || value === void 0 ? null : String(value);
+const instantOf = (value) => typeof value === "string" ? temporal().Instant.from(value) : null;
+function toItem(row) {
+	const type = textOf(row["subject_type"]);
+	const id = textOf(row["subject_id"]);
+	const label = textOf(row["subject_label"]);
+	return {
+		id: String(row["id"]),
+		eventId: String(row["event_id"]),
+		type: String(row["type"]),
+		data: row["data"] ?? {},
+		tenant: textOf(row["tenant"]),
+		actorId: textOf(row["actor_id"]),
+		subject: type === null || id === null ? null : {
+			type,
+			id,
+			...label === null ? {} : { label }
+		},
+		summary: textOf(row["summary"]),
+		actionPath: textOf(row["action_path"]),
+		priority: textOf(row["priority"]),
+		createdAt: instantOf(row["created_at"]) ?? temporal().Now.instant(),
+		readAt: instantOf(row["read_at"]),
+		resolvedAt: instantOf(row["resolved_at"])
+	};
+}
+function cursorOf(before) {
+	if (before === void 0) return {
+		before: null,
+		before_id: null
+	};
+	if ("epochNanoseconds" in before) return {
+		before: before.toString(),
+		before_id: null
+	};
+	return {
+		before: before.createdAt.toString(),
+		before_id: before.id
+	};
+}
+const errorText = (cause) => cause instanceof Error ? cause.message : String(cause);
+function createNotifications(options) {
+	const { transport } = options;
+	const schema = options.schema ?? DEFAULT_SCHEMA;
+	const mappers = options.errorMappers ?? [];
+	const call = async (fn, args) => transport.call(schema, fn, args);
+	function run(fn, args, then) {
+		return AsyncResult.from(async () => {
+			let value;
+			try {
+				value = await call(fn, args);
+			} catch (cause) {
+				const raw = rawError(cause);
+				return err(raw ? mapDbError(raw, mappers) : toDbError(cause));
+			}
+			return ok(await then(value));
+		});
+	}
+	function emit(type, data, tenant) {
+		if (!options.events) return;
+		emitKitEvent(options.events, type, data, {
+			subject: `notifications/${data.notificationId}`,
+			...tenant ? { tenant } : {},
+			...options.actorId ? { actorId: options.actorId } : {},
+			...options.context ? { context: options.context } : {}
+		});
+	}
+	const render = (item, locale) => {
+		if (!options.render) return item;
+		return {
+			...item,
+			text: options.render(item, locale === void 0 ? {} : { locale })
+		};
+	};
+	async function deliverOne(channel, row, maxAttempts) {
+		const notification = isRecord(row["notification"]) ? toItem(row["notification"]) : void 0;
+		if (!notification) throw new TypeError("claim returned no notification");
+		const attempts = Number(row["attempts"] ?? 1);
+		const message = {
+			deliveryId: String(row["delivery_id"]),
+			channel: channel.name,
+			attempts,
+			userId: String(row["user_id"]),
+			email: textOf(row["email"]),
+			notification,
+			...options.render ? { text: options.render(notification, {}) } : {}
+		};
+		try {
+			const result = await channel.send(message);
+			const status = result?.status ?? "sent";
+			await call("complete_notification_delivery", {
+				delivery: message.deliveryId,
+				status,
+				provider: result?.provider ?? null,
+				provider_message_id: result?.providerMessageId ?? null
+			});
+			if (status === "sent") emit("notification.delivered", {
+				notificationId: notification.eventId,
+				type: notification.type,
+				channel: channel.name
+			}, notification.tenant);
+			return status;
+		} catch (cause) {
+			const error = errorText(cause);
+			await call("complete_notification_delivery", {
+				delivery: message.deliveryId,
+				status: "pending",
+				error,
+				max_attempts: maxAttempts
+			});
+			emit("notification.failed", {
+				notificationId: notification.eventId,
+				type: notification.type,
+				channel: channel.name,
+				error
+			}, notification.tenant);
+			return "failed";
+		}
+	}
+	return {
+		send(type, input) {
+			return AsyncResult.from(async () => {
+				const schemaOf = Object.hasOwn(options.types, type) ? options.types[type] : void 0;
+				if (schemaOf === void 0) return err(dbError("validation", `Unknown notification type "${type}"`, {
+					issues: [{
+						path: ["type"],
+						message: `Unknown type "${type}"`
+					}],
+					hint: "NOTIFICATION_TYPE_UNKNOWN"
+				}));
+				const data = await validate(schemaOf, input.data, `${type} data`);
+				if (!data.ok) return err(data.error);
+				const sent = await run("notify", { notification: {
+					type,
+					data: data.data,
+					recipients: input.recipients ?? [],
+					tenant: input.tenant,
+					subject_type: input.subject?.type,
+					subject_id: input.subject?.id,
+					subject_label: input.subject?.label,
+					summary: input.summary,
+					action_path: input.actionPath,
+					priority: input.priority,
+					key: input.key,
+					channels: input.channels,
+					include_actor: input.includeActor,
+					activity: input.activity,
+					resolved: input.resolved,
+					actor: input.actorId
+				} }, (value) => value === null ? null : String(value));
+				if (!sent.ok || sent.data === null) return sent;
+				const recipients = input.recipients ?? [];
+				emit("notification.created", {
+					notificationId: sent.data,
+					type,
+					recipientIds: recipients
+				}, input.tenant ?? null);
+				if (options.onSent) try {
+					await options.onSent({
+						id: sent.data,
+						type,
+						tenant: input.tenant ?? null,
+						recipients
+					});
+				} catch (cause) {
+					return err(toDbError(cause));
+				}
+				return sent;
+			});
+		},
+		list(listOptions = {}) {
+			return run("list_notifications", {
+				tenant: listOptions.tenant ?? null,
+				status: listOptions.status ?? "all",
+				types: listOptions.types ?? null,
+				...cursorOf(listOptions.before),
+				max_items: listOptions.limit ?? 50
+			}, (value) => (Array.isArray(value) ? value : []).filter(isRecord).map((row) => render(toItem(row), listOptions.locale)));
+		},
+		counts(countOptions = {}) {
+			return run("notification_counts", {
+				tenant: countOptions.tenant ?? null,
+				actionable: options.actionable ?? []
+			}, (value) => ({
+				unread: Number(isRecord(value) ? value["unread"] ?? 0 : 0),
+				actionable: Number(isRecord(value) ? value["actionable"] ?? 0 : 0)
+			}));
+		},
+		markRead(readOptions = {}) {
+			return run("mark_notifications_read", {
+				ids: readOptions.ids ?? null,
+				tenant: readOptions.tenant ?? null
+			}, Number);
+		},
+		dismiss(ids) {
+			return run("dismiss_notifications", { ids }, Number);
+		},
+		resolve(input) {
+			return run("resolve_notifications", {
+				type: input.type,
+				subject_type: input.subject.type,
+				subject_id: input.subject.id,
+				tenant: input.tenant ?? null
+			}, Number);
+		},
+		subscribe(input) {
+			return run("set_notification_subscription", {
+				subject_type: input.subject.type,
+				subject_id: input.subject.id,
+				level: input.level,
+				tenant: input.tenant ?? null,
+				member: input.userId ?? null
+			}, () => void 0);
+		},
+		setPreference(input) {
+			return run("set_notification_preference", {
+				type: input.type,
+				channel: input.channel,
+				enabled: input.enabled,
+				tenant: input.tenant ?? null
+			}, () => void 0);
+		},
+		async deliver(deliverOptions = {}) {
+			const wanted = deliverOptions.channels;
+			const channels = (options.channels ?? []).filter((channel) => !wanted || wanted.includes(channel.name));
+			const deadline = deliverOptions.budgetMs === void 0 ? Number.POSITIVE_INFINITY : Date.now() + deliverOptions.budgetMs;
+			const batch = deliverOptions.batch ?? 50;
+			const counts = {
+				sent: 0,
+				skipped: 0,
+				failed: 0
+			};
+			for (const channel of channels) while (Date.now() < deadline) {
+				const claimed = await call("claim_notification_deliveries", {
+					channel: channel.name,
+					max_items: batch,
+					lease: deliverOptions.lease ?? "5 minutes",
+					max_attempts: deliverOptions.maxAttempts ?? 5
+				});
+				const rows = (Array.isArray(claimed) ? claimed : []).filter(isRecord);
+				for (const row of rows) counts[await deliverOne(channel, row, deliverOptions.maxAttempts ?? 5)] += 1;
+				if (rows.length < batch) break;
+			}
+			return counts;
+		},
+		purge(olderThan, batch) {
+			return run("purge_notifications", {
+				older_than: olderThan ?? null,
+				batch: batch ?? null
+			}, Number);
+		}
+	};
+}
+//#endregion
+export { createNotifications, rpcTransport, sqlTransport };

package/dist/openapi/index.d.ts

@@ -1,2 +1,2 @@
-import { a as ResourceOptions, i as ResourceOperation, n as OpenApiOptions, o as createOpenApi, r as PROBLEM_SCHEMA, t as OpenApiDocument } from "../index-BhHEC04r.js";
+import { a as ResourceOptions, i as ResourceOperation, n as OpenApiOptions, o as createOpenApi, r as PROBLEM_SCHEMA, t as OpenApiDocument } from "../index-C7f8cOBM.js";
 export { OpenApiDocument, OpenApiOptions, PROBLEM_SCHEMA, ResourceOperation, ResourceOptions, createOpenApi };

package/dist/openapi/index.js

@@ -1,6 +1,6 @@
-import { n as PROBLEM_TYPE_BASE, t as PROBLEM_CONTENT_TYPE } from "../problem-BihjPR0t.js";
+import { n as PROBLEM_TYPE_BASE, t as PROBLEM_CONTENT_TYPE } from "../problem-BW1KhzSG.js";
 import { t as SPEC_PINS } from "../spec-pins-C3oc-Tdp.js";
-import { t as buildJsonSchema } from "../json-schema-DP6V7cbr.js";
+import { t as buildJsonSchema } from "../json-schema-m1fiwKgN.js";
 //#region src/openapi/index.ts
 /** JSON Schema for RFC 9457 Problem Details as better-supabase sends them. */
 const PROBLEM_SCHEMA = {