better-supabase 0.13.0 → 0.15.0

package/dist/blocks/mfa/index.d.ts

@@ -1,7 +1,149 @@
-import { r as Block } from "../../define-block-MyM4lH42.js";
-import { a as MfaControllerOptions, c as MfaSnapshot, d as StepUpController, f as StepUpControllerOptions, g as needsStepUp, h as createStepUpController, i as MfaController, l as RawMfaFactor, m as createMfaController, n as MfaApi, o as MfaEnrollment, p as StepUpSnapshot, r as MfaAssurance, s as MfaFactor, t as MfaActions, u as StepUpActions } from "../../client-i_u1e0Kf.js";
+import { b as DbError, f as Result } from "../../result-DZeA5KS6.js";
+import { t as Aal } from "../../mfa-oIOYTpvc.js";
+import { r as Block } from "../../define-block-BVcLQ3DF.js";
+import { n as Controller, t as AuthPort } from "../../controller-BrP0gn47.js";
+import { t as AuthReply } from "../../auth-reply-Dj124sbX.js";
+//#region src/blocks/mfa/client.d.ts
+/** A factor as `auth.mfa.listFactors()` returns it. */
+interface RawMfaFactor {
+  readonly id: string;
+  readonly friendly_name?: string;
+  readonly factor_type: string;
+  readonly status: string;
+}
+/** The part of `supabase.auth.mfa` the MFA controllers call. */
+interface MfaApi {
+  listFactors(): PromiseLike<AuthReply<{
+    readonly all: readonly RawMfaFactor[];
+  }>>;
+  enroll(params: {
+    factorType: "totp";
+    friendlyName?: string;
+    issuer?: string;
+  }): PromiseLike<AuthReply<{
+    readonly id: string;
+    readonly totp: {
+      readonly qr_code: string;
+      readonly secret: string;
+      readonly uri: string;
+    };
+  }>>;
+  challengeAndVerify(params: {
+    factorId: string;
+    code: string;
+  }): PromiseLike<AuthReply<unknown>>;
+  unenroll(params: {
+    factorId: string;
+  }): PromiseLike<AuthReply<unknown>>;
+  getAuthenticatorAssuranceLevel(): PromiseLike<AuthReply<{
+    readonly currentLevel: string | null;
+    readonly nextLevel: string | null;
+  }>>;
+}
+interface MfaFactor {
+  readonly id: string;
+  readonly name: string | undefined;
+  /** `totp`, `phone` or `webauthn`. */
+  readonly type: string;
+  /** False for an enrolment the user hasn't confirmed with a code yet. */
+  readonly verified: boolean;
+}
+/** A TOTP factor waiting for its first code. */
+interface MfaEnrollment {
+  readonly factorId: string;
+  /** An SVG data URL of the QR code for authenticator apps. */
+  readonly qrCode: string;
+  /** The secret, for typing into an authenticator by hand. */
+  readonly secret: string;
+  readonly uri: string;
+}
+interface MfaAssurance {
+  /** The session's level; `undefined` until the first load. */
+  readonly level: Aal | undefined;
+  /**
+   * `aal2` when the user has a verified factor, so a challenge can raise the
+   * session.
+   */
+  readonly nextLevel: Aal | undefined;
+}
+/** Whether `error` is the `INSUFFICIENT_AAL` refusal that asks for a step-up. */
+export declare function needsStepUp(error: DbError | undefined): boolean;
+interface MfaControllerOptions {
+  /** `supabase.auth.mfa` of the browser client. */
+  readonly mfa: MfaApi;
+  readonly auth: AuthPort;
+  /** The issuer authenticator apps show; default: the Auth Site URL's host. */
+  readonly issuer?: string;
+}
+interface MfaSnapshot extends MfaAssurance {
+  /** Every factor, verified or not; `undefined` until the first load. */
+  readonly factors: readonly MfaFactor[] | undefined;
+  /** The TOTP factor `enroll` made, until `verify` or `cancel`. */
+  readonly enrollment: MfaEnrollment | undefined;
+  /** Whether an enrol, verify or unenrol call is in flight. */
+  readonly pending: boolean;
+  readonly error: DbError | undefined;
+}
+interface MfaActions {
+  /** Enrols a TOTP factor and keeps its QR code in `enrollment`. */
+  readonly enroll: (input?: {
+    readonly name?: string;
+  }) => Promise<Result<MfaEnrollment>>;
+  /**
+   * Confirms `enrollment` with a code from the app; the session is `aal2` after
+   * it.
+   */
+  readonly verify: (code: string) => Promise<Result<MfaAssurance>>;
+  /** Removes the unconfirmed factor of `enrollment`. */
+  readonly cancel: () => Promise<void>;
+  /** Removes a factor; removing a verified one needs an `aal2` session. */
+  readonly unenroll: (factorId: string) => Promise<Result<boolean>>;
+  /** Forgets `error`. */
+  readonly dismiss: () => void;
+  readonly refresh: () => Promise<void>;
+}
+type MfaController = Controller<MfaSnapshot, MfaActions>;
+/**
+ * A user's MFA factors for a security settings page: `enroll` shows a QR code,
+ * `verify` confirms it with the first code, and `unenroll` removes a factor.
+ * The assurance level is read again after each change.
+ */
+export declare function createMfaController(options: MfaControllerOptions): MfaController;
+interface StepUpControllerOptions {
+  /** `supabase.auth.mfa` of the browser client. */
+  readonly mfa: MfaApi;
+  readonly auth: AuthPort;
+}
+interface StepUpSnapshot extends MfaAssurance {
+  /**
+   * The verified factors a code can come from; `undefined` until the first
+   * load.
+   */
+  readonly factors: readonly MfaFactor[] | undefined;
+  /** Whether the session is `aal2`. */
+  readonly satisfied: boolean;
+  readonly verifying: boolean;
+  readonly error: DbError | undefined;
+}
+interface StepUpActions {
+  /**
+   * Challenges a verified factor (the first one by default) with `code`, then
+   * reads the session's level again.
+   */
+  readonly verify: (code: string, factorId?: string) => Promise<Result<MfaAssurance>>;
+  readonly dismiss: () => void;
+  readonly refresh: () => Promise<void>;
+}
+type StepUpController = Controller<StepUpSnapshot, StepUpActions>;
+/**
+ * Raises the session to `aal2` before a call that `checkAal` guards: show it
+ * when an error passes `needsStepUp`, then retry the call once `satisfied` is
+ * true.
+ */
+export declare function createStepUpController(options: StepUpControllerOptions): StepUpController;
+//#endregion
 //#region src/blocks/mfa/manifest.d.ts
 /** The `mfa` block's manifest (ADR 0029). */
 export declare const mfaBlock: Block<"mfa">;
 //#endregion
-export { type MfaActions, type MfaApi, type MfaAssurance, type MfaController, type MfaControllerOptions, type MfaEnrollment, type MfaFactor, type MfaSnapshot, type RawMfaFactor, type StepUpActions, type StepUpController, type StepUpControllerOptions, type StepUpSnapshot, createMfaController, createStepUpController, needsStepUp };
+export type { MfaActions, MfaApi, MfaAssurance, MfaController, MfaControllerOptions, MfaEnrollment, MfaFactor, MfaSnapshot, RawMfaFactor, StepUpActions, StepUpController, StepUpControllerOptions, StepUpSnapshot };

package/dist/blocks/mfa/index.js

@@ -1,5 +1,214 @@
-import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
-import { n as createStepUpController, r as needsStepUp, t as createMfaController } from "../../client-BAYh7P2h.js";
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { a as ok, r as err } from "../../result-ntFBW2p2.js";
+import { n as whileSignedIn, t as defineController } from "../../controller-BEliOBOv.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as authResult } from "../../auth-reply-tlXB2FQ9.js";
+//#region src/blocks/mfa/client.ts
+const toAal = (level) => level === "aal2" ? "aal2" : level === "aal1" ? "aal1" : void 0;
+const toFactor = (raw) => ({
+	id: raw.id,
+	name: raw.friendly_name === "" ? void 0 : raw.friendly_name,
+	type: raw.factor_type,
+	verified: raw.status === "verified"
+});
+async function readAssurance(mfa) {
+	const result = await authResult(() => mfa.getAuthenticatorAssuranceLevel());
+	return result.ok ? ok({
+		level: toAal(result.data.currentLevel),
+		nextLevel: toAal(result.data.nextLevel)
+	}) : result;
+}
+async function readFactors(mfa) {
+	const result = await authResult(() => mfa.listFactors());
+	return result.ok ? ok(result.data.all.map(toFactor)) : result;
+}
+/** Whether `error` is the `INSUFFICIENT_AAL` refusal that asks for a step-up. */
+function needsStepUp(error) {
+	return error?.kind === "forbidden" && error.code === "INSUFFICIENT_AAL";
+}
+/**
+* A user's MFA factors for a security settings page: `enroll` shows a QR code,
+* `verify` confirms it with the first code, and `unenroll` removes a factor.
+* The assurance level is read again after each change.
+*/
+function createMfaController(options) {
+	const { mfa } = options;
+	return defineController({
+		factors: void 0,
+		level: void 0,
+		nextLevel: void 0,
+		enrollment: void 0,
+		pending: false,
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const refresh = async () => {
+			ticket += 1;
+			const request = ticket;
+			const [factors, assurance] = await Promise.all([readFactors(mfa), readAssurance(mfa)]);
+			if (request !== ticket) return;
+			if (!factors.ok) {
+				state.set({ error: factors.error });
+				return;
+			}
+			if (!assurance.ok) {
+				state.set({ error: assurance.error });
+				return;
+			}
+			state.set({
+				factors: factors.data,
+				...assurance.data
+			});
+		};
+		const settle = async (result) => {
+			state.set(result.ok ? { pending: false } : {
+				pending: false,
+				error: result.error
+			});
+			if (result.ok) await refresh();
+			return result;
+		};
+		return {
+			actions: {
+				refresh,
+				dismiss: () => {
+					state.set({ error: void 0 });
+				},
+				enroll: async (input) => {
+					state.set({
+						pending: true,
+						error: void 0
+					});
+					const result = await authResult(() => mfa.enroll({
+						factorType: "totp",
+						...input?.name === void 0 ? {} : { friendlyName: input.name },
+						...options.issuer === void 0 ? {} : { issuer: options.issuer }
+					}));
+					const enrolled = result.ok ? ok({
+						factorId: result.data.id,
+						qrCode: result.data.totp.qr_code,
+						secret: result.data.totp.secret,
+						uri: result.data.totp.uri
+					}) : result;
+					if (enrolled.ok) state.set({ enrollment: enrolled.data });
+					return settle(enrolled);
+				},
+				verify: async (code) => {
+					const enrollment = state.get().enrollment;
+					if (enrollment === void 0) return err(dbError("invalid_input", "Enrol a factor before verifying it"));
+					state.set({
+						pending: true,
+						error: void 0
+					});
+					const verified = await authResult(() => mfa.challengeAndVerify({
+						factorId: enrollment.factorId,
+						code
+					}));
+					if (!verified.ok) return settle(err(verified.error));
+					state.set({ enrollment: void 0 });
+					return settle(await readAssurance(mfa));
+				},
+				cancel: async () => {
+					const enrollment = state.get().enrollment;
+					if (enrollment === void 0) return;
+					state.set({
+						enrollment: void 0,
+						pending: true
+					});
+					await settle(await authResult(() => mfa.unenroll({ factorId: enrollment.factorId })));
+				},
+				unenroll: async (factorId) => {
+					state.set({
+						pending: true,
+						error: void 0
+					});
+					const result = await authResult(() => mfa.unenroll({ factorId }));
+					return settle(result.ok ? ok(true) : result);
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+/**
+* Raises the session to `aal2` before a call that `checkAal` guards: show it
+* when an error passes `needsStepUp`, then retry the call once `satisfied` is
+* true.
+*/
+function createStepUpController(options) {
+	const { mfa } = options;
+	return defineController({
+		factors: void 0,
+		level: void 0,
+		nextLevel: void 0,
+		satisfied: false,
+		verifying: false,
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const assured = (assurance) => ({
+			...assurance,
+			satisfied: assurance.level === "aal2"
+		});
+		const refresh = async () => {
+			ticket += 1;
+			const request = ticket;
+			const [factors, assurance] = await Promise.all([readFactors(mfa), readAssurance(mfa)]);
+			if (request !== ticket) return;
+			if (!factors.ok) {
+				state.set({ error: factors.error });
+				return;
+			}
+			if (!assurance.ok) {
+				state.set({ error: assurance.error });
+				return;
+			}
+			state.set({
+				factors: factors.data.filter((factor) => factor.verified),
+				...assured(assurance.data)
+			});
+		};
+		return {
+			actions: {
+				refresh,
+				dismiss: () => {
+					state.set({ error: void 0 });
+				},
+				verify: async (code, factorId) => {
+					const id = factorId ?? state.get().factors?.[0]?.id;
+					if (id === void 0) {
+						const missing = dbError("invalid_input", "No verified factor to challenge");
+						state.set({ error: missing });
+						return err(missing);
+					}
+					state.set({
+						verifying: true,
+						error: void 0
+					});
+					const verified = await authResult(() => mfa.challengeAndVerify({
+						factorId: id,
+						code
+					}));
+					const result = verified.ok ? await readAssurance(mfa) : verified;
+					state.set(result.ok ? {
+						verifying: false,
+						...assured(result.data)
+					} : {
+						verifying: false,
+						error: result.error
+					});
+					return result;
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+//#endregion
 //#region src/blocks/mfa/manifest.ts
 /** The `mfa` block's manifest (ADR 0029). */
 const mfaBlock = defineBlock({

package/dist/blocks/moderation/index.d.ts

@@ -0,0 +1,203 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { Ct as Events } from "../../events-vcqenSYU.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-DZN2w69m.js";
+import { t as ModerationSqlOptions } from "../../options-DlohRAYd.js";
+import { c as BlockOf, rn as RecordBinding } from "../../define-block-BVcLQ3DF.js";
+//#region src/blocks/moderation/moderation.d.ts
+interface ModerationOptions extends BlockTemporalOptions, BlockTenantOptions {
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`.
+   */
+  readonly schema?: string;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Moderation>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+declare const STATUSES: readonly ["pending", "visible", "hidden", "removed"];
+/** Where moderated content stands. `pending` waits for a first decision. */
+type ModerationStatus = (typeof STATUSES)[number];
+declare const DECISIONS: readonly ["approve", "hide", "remove", "restore", "ban"];
+/**
+ * A moderator's decision: `approve` and `restore` show the content, `hide`
+ * hides it, `remove` removes it, and `ban` removes it and bans its author.
+ */
+type ModerationDecision = (typeof DECISIONS)[number];
+declare const ACTIONS: readonly ["submit", "approve", "hide", "remove", "restore", "ban", "auto_hide"];
+/** An entry of an item's log: a decision, a resubmission or an automatic hide. */
+type ModerationActionKind = (typeof ACTIONS)[number];
+declare const REPORT_STATUSES: readonly ["open", "resolved", "dismissed"];
+/** A subject under moderation. */
+interface ModerationItem {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subject: RecordRef;
+  readonly authorId?: string;
+  readonly status: ModerationStatus;
+  readonly openReports: number;
+  /** Why it is hidden or removed. */
+  readonly reason?: string;
+  readonly decidedBy?: string;
+  readonly decidedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface ModerationReport {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly itemId: string;
+  readonly reporterId?: string;
+  readonly reason: string;
+  readonly note?: string;
+  /**
+   * `resolved` when the content was hidden or removed, `dismissed` when it
+   * stayed.
+   */
+  readonly status: (typeof REPORT_STATUSES)[number];
+  readonly resolvedBy?: string;
+  readonly resolvedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+}
+interface ModerationAction {
+  readonly id: string;
+  readonly action: ModerationActionKind;
+  readonly fromStatus?: ModerationStatus;
+  readonly toStatus: ModerationStatus;
+  readonly reason?: string;
+  /** Unset for the automatic hide. */
+  readonly actorId?: string;
+  readonly createdAt: Temporal.Instant;
+}
+/** An item with its latest 100 reports and log entries, newest first. */
+interface ModerationItemDetail extends ModerationItem {
+  readonly reports: readonly ModerationReport[];
+  readonly actions: readonly ModerationAction[];
+}
+interface ModerationBan {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly userId: string;
+  readonly reason?: string;
+  readonly bannedBy?: string;
+  /** Unset for a ban without an end. */
+  readonly expiresAt?: Temporal.Instant;
+  readonly liftedBy?: string;
+  readonly liftedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+}
+interface ModerationQueueFilter {
+  /**
+   * Default: what needs a moderator, pending content and content with open
+   * reports.
+   */
+  readonly status?: ModerationStatus;
+  readonly subjectType?: string;
+  /** Default 50, at most 200. */
+  readonly pageSize?: number;
+  /** Items changed before this instant, for the next page. */
+  readonly before?: Temporal.Instant;
+}
+interface Moderation {
+  /**
+   * Reports a subject. Reporting it again while the first report is open
+   * returns that report. `autoHidden` is true when this report reached the
+   * auto-hide threshold.
+   */
+  report(subject: RecordRef, report: {
+    readonly reason: string;
+    readonly note?: string;
+  }): AsyncResult<ModerationReport & {
+    readonly autoHidden: boolean;
+  }>;
+  /** The review queue, most recently changed first. */
+  queue(filter?: ModerationQueueFilter): AsyncResult<readonly ModerationItem[]>;
+  /**
+   * A subject's item with its reports and log, or `null` when nothing moderated
+   * it.
+   */
+  item(subject: RecordRef): AsyncResult<ModerationItemDetail | null>;
+  /** Decides on an item. `ban` needs the ban permission as well. */
+  decide(itemId: string, decision: ModerationDecision, options?: {
+    readonly reason?: string;
+  }): AsyncResult<ModerationItem>;
+  /**
+   * The statuses of the subjects that are not visible, by id, for filtering a
+   * list. Visible and unmoderated subjects are left out. At most 500 ids.
+   */
+  statuses(subjectType: string, ids: readonly string[]): AsyncResult<Readonly<Record<string, ModerationStatus>>>;
+  /** Bans a user in the organization, until `expiresAt` or for good. */
+  ban(userId: string, options?: {
+    readonly reason?: string;
+    readonly expiresAt?: Temporal.Instant;
+  }): AsyncResult<ModerationBan>;
+  /** Lifts a ban; `false` when it was already lifted. */
+  unban(banId: string): AsyncResult<boolean>;
+  /** The organization's bans, newest first: active ones unless `active: false`. */
+  bans(filter?: {
+    readonly active?: boolean;
+    readonly pageSize?: number;
+  }): AsyncResult<readonly ModerationBan[]>;
+}
+/** The `moderation` SQL module as typed calls. */
+export declare function createModeration(options: ModerationOptions): Moderation;
+//#endregion
+//#region src/blocks/moderation/events.d.ts
+/** `moderation_report.created`: a member reported a subject. */
+interface ModerationReportEventData {
+  readonly organizationId: string;
+  /** The report. */
+  readonly id: string;
+  readonly itemId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly reason: string;
+}
+/** `moderation_item.decided`: a moderator, or the auto-hide threshold, decided. */
+interface ModerationDecisionEventData {
+  readonly organizationId: string;
+  /** The moderation item. */
+  readonly id: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly authorId: string | null;
+  readonly action: "approve" | "hide" | "remove" | "restore" | "ban" | "auto_hide";
+  readonly status: "visible" | "hidden" | "removed";
+  readonly previousStatus: "pending" | "visible" | "hidden" | "removed";
+  /** `true` when the auto-hide threshold hid it. */
+  readonly automatic: boolean;
+}
+/** `moderation_ban.created` and `moderation_ban.lifted`. */
+interface ModerationBanEventData {
+  readonly organizationId: string;
+  /** The ban. */
+  readonly id: string;
+  readonly userId: string;
+  readonly expiresAt: string | null;
+}
+/** The events of the `moderation` block: type to data. */
+type ModerationEvents = {
+  readonly "moderation_report.created": ModerationReportEventData;
+  readonly "moderation_item.decided": ModerationDecisionEventData;
+  readonly "moderation_ban.created": ModerationBanEventData;
+  readonly "moderation_ban.lifted": ModerationBanEventData;
+};
+/** The `moderation` block's event types, for its manifest and `onBlockEvent`. */
+export declare const moderationEvents: Events<ModerationEvents>;
+//#endregion
+//#region src/blocks/moderation/record-binding.d.ts
+/** A record's moderation: its status, reports and log, for moderators. */
+export declare const moderationBinding: RecordBinding<Moderation, ModerationItemDetail | null>;
+//#endregion
+//#region src/blocks/moderation/manifest.d.ts
+/** The `moderation` block's manifest (ADR 0029). */
+export declare const moderationBlock: BlockOf<"moderation", typeof createModeration, ModerationEvents, Record<never, never>, never, typeof moderationBinding>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Moderation, type ModerationAction, type ModerationActionKind, type ModerationBan, type ModerationBanEventData, type ModerationDecision, type ModerationDecisionEventData, type ModerationEvents, type ModerationItem, type ModerationItemDetail, type ModerationOptions, type ModerationQueueFilter, type ModerationReport, type ModerationReportEventData, type ModerationSqlOptions, type ModerationStatus, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };