better-supabase 0.13.0 → 0.15.0

package/dist/support-CWVTM2AB.js

@@ -1,534 +0,0 @@
-import { c as mapDbError, n as dbError } from "./errors-D7u24ZJH.js";
-import { t as temporal } from "./temporal-required-Dt4mcPsi.js";
-import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-DIT_qp4G.js";
-import { n as validate } from "./standard-l10kE0yS.js";
-import { o as problemResponse } from "./problem-D0KDiYPk.js";
-import { i as sqlIdent } from "./template-DXsGm_R0.js";
-import { t as fromPgError } from "./pg-error-B5QLDcbG.js";
-import { d as clearSupportCookie, f as supportCookie, m as supportCookieValue } from "./adapter-D8dW6p2A.js";
-import { a as emitBlockEvent } from "./block-events-BURaqwyp.js";
-import { t as cronRoute } from "./cron-route-BbVtwXZz.js";
-import { t as boundedTtlCache } from "./ttl-cache-Bhr9swjT.js";
-//#region src/auth/support.ts
-/** A request from the jsonb the `support-sessions` request functions return. */
-function supportRequestFromRow(row, namespace) {
-	const Instant = (namespace ?? temporal()).Instant;
-	return {
-		id: row.id,
-		adminId: row.admin_id,
-		targetUserId: row.target_user_id,
-		reason: row.reason,
-		readOnly: row.read_only,
-		...row.tenant === null ? {} : { tenant: String(row.tenant) },
-		metadata: row.metadata ?? {},
-		requestedAt: Instant.from(row.requested_at),
-		expiresAt: Instant.from(row.expires_at),
-		...row.approved_by === null ? {} : { approvedBy: row.approved_by },
-		...row.approved_at === null ? {} : { approvedAt: Instant.from(row.approved_at) },
-		...row.session_id === null ? {} : { sessionId: row.session_id }
-	};
-}
-/**
-* A session from the jsonb the `support-sessions` functions return, with
-* `namespace` (else the provided or global Temporal) for its time values.
-*/
-function supportSessionFromRow(row, namespace) {
-	const Instant = (namespace ?? temporal()).Instant;
-	const instant = (value) => Instant.from(value);
-	return {
-		id: row.id,
-		adminId: row.admin_id,
-		targetUserId: row.target_user_id,
-		reason: row.reason,
-		readOnly: row.read_only ?? true,
-		...row.tenant === null ? {} : { tenant: String(row.tenant) },
-		startedAt: instant(row.started_at),
-		expiresAt: instant(row.expires_at),
-		...row.ended_at === null ? {} : { endedAt: instant(row.ended_at) },
-		...row.ended_by === null ? {} : { endedBy: row.ended_by },
-		metadata: row.metadata ?? {}
-	};
-}
-/**
-* 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.
-*/
-function sqlSupportStore(postgres, options = {}) {
-	const fn = (name) => `${sqlIdent(options.schema ?? "better_supabase")}.${sqlIdent(name)}`;
-	const as = (claims) => claims ? postgres.asUser(claims) : postgres.admin;
-	const one = async (client, text, params) => {
-		const [row] = await client.queryRaw(text, params);
-		return row?.session ?? null;
-	};
-	return {
-		apiVersion: 1,
-		name: "sql",
-		async start(input) {
-			const row = await one(postgres.asUser(input.adminClaims), `select ${fn("start_support_session")}($1, $2, $3::interval, $4, $5, $6, $7) as session`, [
-				input.targetUserId,
-				input.reason,
-				`${String(input.ttlSeconds)} seconds`,
-				input.readOnly,
-				JSON.stringify(input.metadata),
-				input.tenant ?? null,
-				input.adminId
-			]);
-			if (!row) throw new Error("start_support_session returned no session");
-			return supportSessionFromRow(row, options.temporal);
-		},
-		async get(sessionId, adminId, claims) {
-			const row = await one(as(claims), `select ${fn("active_support_session")}($1, $2) as session`, [sessionId, adminId]);
-			return row ? supportSessionFromRow(row, options.temporal) : void 0;
-		},
-		async end(sessionId, endedBy, claims) {
-			const [row] = await as(claims).queryRaw(`select ${fn("end_support_session")}($1, $2) as ended`, [sessionId, endedBy]);
-			return row?.ended === true;
-		},
-		async list(filter = {}, claims) {
-			return (await as(claims).queryRaw(`select session from ${fn("list_support_sessions")}($1, $2, $3, $4) as session`, [
-				filter.adminId ?? null,
-				filter.targetUserId ?? null,
-				filter.active ?? null,
-				filter.limit ?? 50
-			])).map((row) => supportSessionFromRow(row.session, options.temporal));
-		},
-		async expire() {
-			return (await postgres.admin.queryRaw(`select session from ${fn("expire_support_sessions")}() as session`)).map((row) => supportSessionFromRow(row.session, options.temporal));
-		},
-		withTemporal: (namespace) => options.temporal === void 0 ? sqlSupportStore(postgres, {
-			...options,
-			temporal: namespace
-		}) : sqlSupportStore(postgres, options),
-		async claims(targetUserId) {
-			const [row] = await postgres.admin.queryRaw(`select ${fn("support_target_claims")}($1) as claims`, [targetUserId]);
-			return row?.claims ?? {};
-		},
-		async request(input) {
-			const row = await oneRequest(input.approvedBy !== void 0 ? postgres.admin : postgres.asUser(input.adminClaims), `select ${fn("request_support_session")}($1, $2, $3, $4, $5, $6, $7) as request`, [
-				input.targetUserId,
-				input.reason,
-				input.readOnly,
-				JSON.stringify(input.metadata),
-				input.tenant ?? null,
-				input.adminId,
-				input.approvedBy ?? null
-			]);
-			if (!row) throw new Error("request_support_session returned no request");
-			return supportRequestFromRow(row, options.temporal);
-		},
-		async getRequest(requestId) {
-			const row = await oneRequest(postgres.admin, `select ${fn("support_request")}($1) as request`, [requestId]);
-			return row ? supportRequestFromRow(row, options.temporal) : void 0;
-		},
-		async approve(requestId, approver) {
-			const row = await oneRequest(as(approver.claims), `select ${fn("approve_support_request")}($1, $2) as request`, [requestId, approver.id]);
-			if (!row) throw new Error("approve_support_request returned no request");
-			return supportRequestFromRow(row, options.temporal);
-		},
-		async approvedRequest(query) {
-			const row = await oneRequest(postgres.admin, `select ${fn("approved_support_request")}($1, $2, $3, $4) as request`, [
-				query.targetUserId,
-				query.tenant ?? null,
-				query.readOnly,
-				query.adminId
-			]);
-			return row ? supportRequestFromRow(row, options.temporal) : void 0;
-		}
-	};
-}
-async function oneRequest(client, text, params) {
-	const [row] = await client.queryRaw(text, params);
-	return row?.request ?? null;
-}
-/**
-* 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),
-* 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) {
-	const role = target["role"];
-	return {
-		...target,
-		sub: session.targetUserId,
-		role: typeof role === "string" && role !== "" ? role : "authenticated",
-		act: {
-			kind: "support",
-			sub: session.adminId,
-			reason: session.reason,
-			session_id: session.id,
-			read_only: session.readOnly
-		}
-	};
-}
-//#endregion
-//#region src/server/support.ts
-/**
-* The `kind` an `approverOf` hook sees for a support request; the SQL
-* `isApprover` sees the same.
-*/
-const SUPPORT_SESSION_APPROVAL = "support-session";
-/**
-* 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) {
-	const raw = fromPgError(cause);
-	return raw ? mapDbError(raw) : toDbError(cause);
-}
-/**
-* Support sessions for `createServer(betterSupabase, { support })`. Apps that
-* never import it don't bundle the support code.
-*/
-function supportSessions(options) {
-	return {
-		options,
-		create: (events, claimsSchema, temporal, authorization) => createSupport(options, events, claimsSchema, temporal, authorization)
-	};
-}
-const forbidden = () => denied("Not allowed to start a support session", "SUPPORT_FORBIDDEN");
-const selfApproval = () => denied("An admin cannot approve their own support session", "SUPPORT_SELF_APPROVAL");
-function createSupport(options, events, claimsSchema, temporal, authorization) {
-	const store = temporal !== void 0 && options.store.withTemporal ? options.store.withTemporal(temporal) : options.store;
-	const policy = options.policy ?? {};
-	const ttl = policy.ttl ?? 1800;
-	const maxTtl = policy.maxTtl ?? 14400;
-	const cookieName = options.cookie?.name;
-	const emit = (type, data) => {
-		emitBlockEvent(events, type, data, {
-			actorId: data.adminId,
-			...data.sessionId ? { subject: `support_sessions/${data.sessionId}` } : {}
-		});
-	};
-	const targetClaims = async (store, targetUserId) => {
-		if (options.claims) return options.claims(targetUserId);
-		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 = boundedTtlCache({ max: CLAIMS_CACHE_SIZE });
-	const cachedTargetClaims = async (session) => {
-		const cached = claimsCache.get(session.id);
-		if (cached) return cached;
-		const claims = await targetClaims(store, session.targetUserId);
-		claimsCache.set(session.id, claims, Math.min(session.expiresAt.epochMilliseconds, Date.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");
-		if ((policy.requireReason ?? true) && reason === "") return invalid("A reason is required", "SUPPORT_REASON_REQUIRED");
-		if (!Number.isFinite(seconds) || seconds <= 0 || seconds > maxTtl) return invalid(`ttl must be between 1 and ${String(maxTtl)} seconds`, "SUPPORT_TTL");
-	};
-	const approval = policy.approval ?? "distinct";
-	const authorize = options.authorize ?? authorization?.support?.authorize;
-	/** The decision for a start; a missing hook and a throw refuse it. */
-	const decide = async (input) => {
-		if (authorize === void 0) return false;
-		if (authorize === "store") return true;
-		try {
-			return await authorize(input);
-		} catch {
-			return false;
-		}
-	};
-	const mayApprove = async (approver, request) => {
-		const approverOf = authorization?.approverOf;
-		if (approverOf === void 0) return true;
-		try {
-			return await approverOf({
-				userId: approver.user.id,
-				claims: approver.claims
-			}, {
-				kind: SUPPORT_SESSION_APPROVAL,
-				subject: request.id,
-				requester: request.adminId,
-				...request.tenant === void 0 ? {} : { tenant: request.tenant }
-			});
-		} catch {
-			return false;
-		}
-	};
-	/**
-	* The approved request a start uses: recorded now for an `{ approvedBy }`
-	* decision, else looked up.
-	*/
-	const approvedRequest = async (admin, request, reason, readOnly, approvedBy) => {
-		const tenant = request.tenant === void 0 ? {} : { tenant: request.tenant };
-		if (approvedBy !== void 0) return store.request?.({
-			adminId: admin.user.id,
-			adminClaims: admin.claims,
-			targetUserId: request.targetUserId,
-			reason,
-			readOnly,
-			...tenant,
-			metadata: request.metadata ?? {},
-			approvedBy
-		});
-		return store.approvedRequest?.({
-			adminId: admin.user.id,
-			targetUserId: request.targetUserId,
-			readOnly,
-			...tenant
-		});
-	};
-	const noApprovals = () => dbError("unsupported", `The "${store.name}" support session store does not record approvals; set policy.approval to "none" or use a store that does`, { code: "SUPPORT_APPROVAL_UNSUPPORTED" });
-	const expire = () => AsyncResult.from(async () => {
-		if (!store.expire) return err(dbError("unsupported", `The "${store.name}" support session store has no expire()`, { code: "SUPPORT_EXPIRE_UNSUPPORTED" }));
-		let expired;
-		try {
-			expired = await store.expire();
-		} catch (cause) {
-			return err(storeError(cause));
-		}
-		for (const session of expired) emit("support.ended", {
-			sessionId: session.id,
-			adminId: session.adminId,
-			targetUserId: session.targetUserId,
-			reason: session.reason,
-			endedBy: "expired",
-			...session.tenant === void 0 ? {} : { organizationId: session.tenant }
-		});
-		return ok(expired);
-	});
-	const sessionIdOf = (request) => {
-		if (options.sessionId) try {
-			const id = options.sessionId(request);
-			return id === "" ? void 0 : id;
-		} catch (cause) {
-			events.logger.warn("support.sessionId threw", { cause });
-			return;
-		}
-		return supportCookieValue(request.headers.get("cookie"), cookieName);
-	};
-	const resolve = async (id, auth) => {
-		if (auth.kind !== "user") return;
-		if (auth.claims["act"] !== void 0) return;
-		if (!id) return;
-		let session;
-		let claims;
-		try {
-			session = await store.get(id, auth.user.id, auth.claims);
-			if (!session || session.expiresAt.epochMilliseconds <= Date.now()) return;
-			if (policy.readOnly !== "default" && !session.readOnly) session = {
-				...session,
-				readOnly: true
-			};
-			claims = supportClaims(session, await cachedTargetClaims(session));
-		} catch (cause) {
-			events.logger.warn("Could not load the support session", { cause });
-			return;
-		}
-		if (claimsSchema) {
-			const checked = await validate(claimsSchema, claims, "claims");
-			if (!checked.ok) {
-				events.logger.warn("The support target's claims fail the claims schema", { sessionId: session.id });
-				return;
-			}
-			if (typeof checked.data === "object" && checked.data !== null) claims = {
-				...claims,
-				...checked.data
-			};
-		}
-		return {
-			session,
-			admin: {
-				id: auth.user.id,
-				...auth.user.email ? { email: auth.user.email } : {}
-			},
-			claims
-		};
-	};
-	return {
-		expire,
-		expireRoute: (routeOptions) => cronRoute({
-			name: "expire",
-			secret: routeOptions.secret,
-			problem: routeOptions.problem
-		}, async (_request, instance) => {
-			const result = await expire();
-			return result.ok ? Response.json({ expired: result.data.length }) : problemResponse(result.error, {
-				instance,
-				format: routeOptions.problem
-			});
-		}),
-		start(admin, request) {
-			return AsyncResult.from(async () => {
-				if (admin.kind !== "user") return err(dbError("unauthorized", "Sign in to start a support session"));
-				const reason = request.reason?.trim() ?? "";
-				const seconds = request.ttl ?? ttl;
-				const readOnly = policy.readOnly === "default" ? request.readOnly ?? true : true;
-				const deny = (error, denial) => {
-					emit("support.denied", {
-						adminId: admin.user.id,
-						targetUserId: request.targetUserId,
-						...reason ? { reason } : {},
-						denial
-					});
-					return err(error);
-				};
-				const violation = checkPolicy(admin, request, reason, seconds);
-				if (violation) return deny(violation, "policy");
-				const tenant = request.tenant === void 0 ? {} : { tenant: request.tenant };
-				const input = {
-					admin,
-					targetUserId: request.targetUserId,
-					reason,
-					readOnly,
-					...tenant,
-					metadata: request.metadata ?? {}
-				};
-				const decision = await decide(input);
-				if (decision === false) return deny(forbidden(), "authorize");
-				const approvedBy = typeof decision === "object" ? decision.approvedBy : void 0;
-				if (approvedBy === admin.user.id) return deny(selfApproval(), "authorize");
-				let requestId;
-				if (approval === "distinct") {
-					let approved;
-					try {
-						approved = await approvedRequest(admin, request, reason, readOnly, approvedBy);
-					} catch (cause) {
-						const error = storeError(cause);
-						return deny(error, error.code === "42501" ? "permission" : "store");
-					}
-					if (approved === void 0 || approved.approvedBy === admin.user.id) return deny(denied("A second admin must approve this support session", "SUPPORT_APPROVAL_REQUIRED"), "policy");
-					requestId = approved.id;
-				}
-				let session;
-				try {
-					session = await store.start({
-						adminId: admin.user.id,
-						adminClaims: admin.claims,
-						targetUserId: request.targetUserId,
-						reason,
-						ttlSeconds: seconds,
-						readOnly,
-						...tenant,
-						metadata: request.metadata ?? {},
-						...requestId === void 0 ? {} : { requestId }
-					});
-				} catch (cause) {
-					const error = storeError(cause);
-					return deny(error, error.code === "42501" ? "permission" : "store");
-				}
-				emit("support.started", {
-					sessionId: session.id,
-					adminId: session.adminId,
-					targetUserId: session.targetUserId,
-					reason: session.reason,
-					readOnly: session.readOnly,
-					expiresAt: session.expiresAt
-				});
-				return ok({
-					session,
-					cookie: supportCookie(session, options.cookie)
-				});
-			});
-		},
-		request(admin, request) {
-			return AsyncResult.from(async () => {
-				if (admin.kind !== "user") return err(dbError("unauthorized", "Sign in to ask for a support session"));
-				const reason = request.reason?.trim() ?? "";
-				const violation = checkPolicy(admin, request, reason, request.ttl ?? ttl);
-				if (violation) return err(violation);
-				if (!store.request) return err(noApprovals());
-				try {
-					return ok(await store.request({
-						adminId: admin.user.id,
-						adminClaims: admin.claims,
-						targetUserId: request.targetUserId,
-						reason,
-						readOnly: policy.readOnly === "default" ? request.readOnly ?? true : true,
-						...request.tenant === void 0 ? {} : { tenant: request.tenant },
-						metadata: request.metadata ?? {}
-					}));
-				} catch (cause) {
-					return err(storeError(cause));
-				}
-			});
-		},
-		approve(approver, requestId) {
-			return AsyncResult.from(async () => {
-				if (approver.kind !== "user") return err(dbError("unauthorized", "Sign in to approve a support session"));
-				if (approver.claims["act"] !== void 0) return err(denied("An impersonated session cannot approve a support session", "SUPPORT_NESTED"));
-				if (!store.approve || !store.getRequest) return err(noApprovals());
-				try {
-					const found = await store.getRequest(requestId);
-					if (!found) return err(dbError("not_found", "No such support request", { code: "SUPPORT_REQUEST_MISSING" }));
-					if (found.adminId === approver.user.id) return err(selfApproval());
-					if (authorization?.approverOf === void 0) return ok(await store.approve(requestId, {
-						id: approver.user.id,
-						claims: approver.claims
-					}));
-					if (!await mayApprove(approver, found)) return err(denied("Not allowed to approve this support session", "SUPPORT_FORBIDDEN"));
-					return ok(await store.approve(requestId, { id: approver.user.id }));
-				} catch (cause) {
-					return err(storeError(cause));
-				}
-			});
-		},
-		stop(admin, sessionId) {
-			return AsyncResult.from(async () => {
-				const cookie = clearSupportCookie(options.cookie);
-				if (admin.kind !== "user") return err(dbError("unauthorized", "Sign in to stop a support session"));
-				try {
-					const session = await store.get(sessionId, admin.user.id, admin.claims);
-					if (!session) return ok({
-						ended: false,
-						cookie
-					});
-					const ended = await store.end(sessionId, "admin", admin.claims);
-					if (ended) emit("support.ended", {
-						sessionId,
-						adminId: session.adminId,
-						targetUserId: session.targetUserId,
-						endedBy: "admin"
-					});
-					return ok({
-						ended,
-						cookie
-					});
-				} catch (cause) {
-					return err(storeError(cause));
-				}
-			});
-		},
-		revoke(caller, sessionId) {
-			return AsyncResult.from(async () => {
-				if (caller.kind !== "user") return err(dbError("unauthorized", "Sign in to revoke a support session"));
-				try {
-					return ok(await store.end(sessionId, "revoked", caller.claims));
-				} catch (cause) {
-					return err(storeError(cause));
-				}
-			});
-		},
-		async current(request, auth) {
-			const id = sessionIdOf(request);
-			return id ? resolve(id, auth) : void 0;
-		},
-		resolve,
-		list(caller, filter) {
-			return AsyncResult.from(async () => {
-				if (caller.kind !== "user") return err(dbError("unauthorized", "Sign in to list support sessions"));
-				try {
-					return ok(await store.list(filter, caller.claims));
-				} catch (cause) {
-					return err(storeError(cause));
-				}
-			});
-		},
-		sessionIdOf,
-		clearCookie: () => clearSupportCookie(options.cookie)
-	};
-}
-//#endregion
-export { sqlSupportStore as n, supportClaims as r, supportSessions as t };

package/dist/support-view-BOJJSZKv.d.ts

@@ -1,17 +0,0 @@
-import { t as AuthSession } from "./view-CKzCp8FW.js";
-//#region src/auth/support-view.d.ts
-/** A running support session as the target's view shows it, for a banner. */
-interface SupportView {
-  readonly sessionId: string;
-  /** The admin viewing the app. */
-  readonly adminId: string;
-  readonly targetUserId: string;
-  readonly reason?: string;
-  readonly readOnly: boolean;
-  /** Seconds since epoch. */
-  readonly expiresAt: number | null;
-}
-/** The support session behind `session`, or `undefined` outside one. */
-declare function supportOf(session: AuthSession): SupportView | undefined;
-//#endregion
-export { supportOf as n, SupportView as t };

package/dist/svelte-controller-BmRhHvFz.js

@@ -1,50 +0,0 @@
-import { t as CLIENT } from "./context-C-bHOtoD.js";
-import { n as withEnv, t as blockEnv } from "./block-env-YfPmSNa1.js";
-import { getContext, onDestroy, onMount } from "svelte";
-import { readable } from "svelte/store";
-//#region src/blocks/svelte-controller.ts
-function contextClient() {
-	const bound = getContext(CLIENT);
-	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bs) in a parent component");
-	return bound.client;
-}
-/**
-* Makes a controller once, during component setup. The store follows it from
-* mount (never during server rendering) while it has subscribers, and the
-* controller is disposed with the component.
-*/
-function useBlockController(create, options, usesEnv = true) {
-	const controller = create(withEnv(options, usesEnv ? () => blockEnv(contextClient()) : void 0));
-	let mounted = false;
-	let pending;
-	const store = readable(controller.getSnapshot(), (set) => {
-		let stop;
-		const start = () => {
-			stop = controller.subscribe(() => {
-				set(controller.getSnapshot());
-			});
-			set(controller.getSnapshot());
-		};
-		if (mounted) start();
-		else pending = start;
-		return () => {
-			pending = void 0;
-			stop?.();
-		};
-	});
-	onMount(() => {
-		mounted = true;
-		pending?.();
-		pending = void 0;
-	});
-	onDestroy(() => {
-		controller.dispose();
-	});
-	return {
-		subscribe: store.subscribe,
-		actions: controller.actions,
-		controller
-	};
-}
-//#endregion
-export { useBlockController as t };

package/dist/svelte-controller-DXO7gsmS.d.ts

@@ -1,13 +0,0 @@
-import { n as Controller } from "./controller-lWRcKqCl.js";
-import { Readable } from "svelte/store";
-//#region src/blocks/svelte-controller.d.ts
-/**
- * A block controller in a Svelte component: a readable store of its state, with
- * its actions.
- */
-interface SvelteController<S, A> extends Readable<S> {
-  readonly actions: A;
-  readonly controller: Controller<S, A>;
-}
-//#endregion
-export { SvelteController as t };