better-supabase 0.12.0 → 0.13.0

package/dist/client-B4JPQgf-.d.ts

@@ -0,0 +1,165 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-mijqfoJN.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-DyA5BAW4.js";
+import { n as BlockHooks } from "./block-hooks-BadAniNI.js";
+import { i as KeyboardPort } from "./ports-n3ZWSS_I.js";
+import { n as Controller } from "./controller-lWRcKqCl.js";
+//#region src/blocks/search/search.d.ts
+interface SearchOptions extends Pick<BlockOptions, "transport" | "service" | "schema" | "mappers"> {
+  /** `withBlockHooks` hooks around the methods. */
+  readonly hooks?: BlockHooks<Search>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** One match, with the title and URL from `config.subjects`. */
+interface SearchHit {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  /** A fragment of the body around the match, without markup. */
+  readonly snippet: string | null;
+  readonly score: number;
+}
+interface SearchQuery {
+  /** Subject types to search. Default: every type with a `search` entry. */
+  readonly types?: readonly string[];
+  /** One tenant. Default: every tenant the caller can read. */
+  readonly organizationId?: string | null;
+  /** At most 100. Default 20. */
+  readonly limit?: number;
+  /**
+   * The query's embedding, when the index keeps embeddings
+   * (`blocks.search.options.dimensions` and `vector-search`): the results fuse
+   * full-text and nearest-neighbour ranks.
+   */
+  readonly embedding?: readonly number[] | null;
+}
+/** A subject the caller opened or starred (the share-links per-user state). */
+interface SearchUserItem {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  readonly openedAt: Temporal.Instant | undefined;
+  readonly starredAt: Temporal.Instant | undefined;
+}
+interface SearchListOptions {
+  /** At most 100. Default 10. */
+  readonly limit?: number;
+  readonly types?: readonly string[];
+}
+/** A document whose text has no embedding yet. */
+interface PendingEmbedding {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** Pass it back to `setEmbedding`, which skips text that changed since. */
+  readonly contentHash: string;
+  /** The title and body to embed. */
+  readonly text: string;
+}
+/** Embeds texts in order, one vector per text: an AI SDK `embedMany` call. */
+type Embedder = (texts: readonly string[]) => Promise<readonly (readonly number[])[]>;
+interface Search {
+  /**
+   * Searches as the caller: `websearch_to_tsquery` syntax (`"exact phrase"`,
+   * `-word`, `or`), prefixes for typeahead and trigram matches for typos. Rows
+   * the caller can't read, and trashed rows, are left out.
+   */
+  search(q: string, query?: SearchQuery): AsyncResult<readonly SearchHit[]>;
+  /** The caller's recently opened subjects, newest first. */
+  recents(options?: SearchListOptions): AsyncResult<readonly SearchUserItem[]>;
+  /** The caller's starred subjects, newest first. */
+  favorites(options?: SearchListOptions): AsyncResult<readonly SearchUserItem[]>;
+  /** Records that the caller opened a subject, for `recents`. */
+  touch(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Stars or unstars a subject for the caller, for `favorites`. */
+  star(subjectType: string, subjectId: string, starred?: boolean): AsyncResult<boolean>;
+  /** Reads one row into the index again. Service only. */
+  refresh(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Drops one subject from the index. Service only. */
+  remove(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Indexes every row of one type, or of all of them. Service only. */
+  reindex(subjectType?: string): AsyncResult<number>;
+  /** Documents without an embedding, oldest first. Service only. */
+  pendingEmbeddings(limit?: number): AsyncResult<readonly PendingEmbedding[]>;
+  /** Stores an embedding unless the text changed. Service only. */
+  setEmbedding(document: Pick<PendingEmbedding, "subjectType" | "subjectId" | "contentHash">, embedding: readonly number[]): AsyncResult<boolean>;
+  /**
+   * Embeds up to `limit` pending documents with `embed` and stores them. Run it
+   * from a job or cron. Service only. Resolves to the number stored.
+   */
+  embedPending(embed: Embedder, limit?: number): AsyncResult<number>;
+}
+/**
+ * The `search` SQL module as typed calls. Build it with the caller's transport
+ * for `search`, `recents` and `favorites`, and pass `service` for the index
+ * maintenance methods.
+ */
+declare function createSearch(options: SearchOptions): Search;
+//#endregion
+//#region src/blocks/search/groups.d.ts
+/** A row of the dialog: a match, a recent or a favorite. */
+interface CommandSearchItem {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  readonly snippet?: string | null;
+}
+/** One heading of the dialog: `favorites`, `recents`, or a subject type. */
+interface CommandSearchGroup {
+  readonly key: string;
+  readonly items: readonly CommandSearchItem[];
+}
+/** Groups matches by subject type, in the order the best match of each appears. */
+declare function groupHits(hits: readonly SearchHit[]): readonly CommandSearchGroup[];
+//#endregion
+//#region src/blocks/search/client.d.ts
+interface CommandSearchOptions {
+  readonly client: Pick<Search, "search" | "recents" | "favorites" | "touch" | "star">;
+  /** Toggles the dialog on Cmd+K and Ctrl+K. Without it there is no shortcut. */
+  readonly keyboard?: KeyboardPort;
+  /** One tenant. Default: every tenant the caller can read. */
+  readonly organizationId?: string | null;
+  readonly types?: readonly string[];
+  /** Results per query. Default 20. */
+  readonly limit?: number;
+  /** Recents and favorites shown before the user types. Default 5. */
+  readonly listLimit?: number;
+  /** Milliseconds between the last keystroke and the query. Default 150. */
+  readonly debounceMs?: number;
+}
+interface CommandSearchSnapshot {
+  readonly open: boolean;
+  readonly query: string;
+  /**
+   * Favorites and recents for an empty query, otherwise the matches by subject
+   * type.
+   */
+  readonly groups: readonly CommandSearchGroup[];
+  readonly results: readonly SearchHit[];
+  readonly recents: readonly SearchUserItem[];
+  readonly favorites: readonly SearchUserItem[];
+  /** True while a query newer than `results` is running. */
+  readonly loading: boolean;
+  readonly error: DbError | undefined;
+}
+interface CommandSearchActions {
+  readonly setOpen: (open: boolean) => void;
+  readonly setQuery: (query: string) => void;
+  /** Records the item as opened (for recents) and closes the dialog. */
+  readonly select: (item: CommandSearchItem) => Promise<void>;
+  readonly star: (item: CommandSearchItem, starred?: boolean) => Promise<void>;
+}
+type CommandSearchController = Controller<CommandSearchSnapshot, CommandSearchActions>;
+/**
+ * State for a Cmd+K dialog over the `search` module: a debounced query that
+ * ignores stale responses, favorites and recents for an empty query, and
+ * `select` that records the open.
+ */
+declare function createCommandSearchController(options: CommandSearchOptions): CommandSearchController;
+//#endregion
+export { createSearch as _, createCommandSearchController as a, groupHits as c, Search as d, SearchHit as f, SearchUserItem as g, SearchQuery as h, CommandSearchSnapshot as i, Embedder as l, SearchOptions as m, CommandSearchController as n, CommandSearchGroup as o, SearchListOptions as p, CommandSearchOptions as r, CommandSearchItem as s, CommandSearchActions as t, PendingEmbedding as u };

package/dist/client-BAYh7P2h.js

@@ -0,0 +1,211 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { a as ok, r as err } from "./result-DIT_qp4G.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { t as authResult } from "./auth-reply-D02x5NSv.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
+export { createStepUpController as n, needsStepUp as r, createMfaController as t };