better-supabase 0.12.0 → 0.13.0

package/dist/client-BKGVUgo7.js

@@ -0,0 +1,380 @@
+import { t as defineController } from "./controller-BEliOBOv.js";
+//#region src/blocks/forms/validate.ts
+/**
+* `email` as the HTML `<input type="email">` grammar, `date` as RFC 3339
+* `full-date`. Postgres asserts the same formats, so a value this accepts can
+* still fail there only for a mailbox the HTML grammar allows and pg_jsonschema
+* does not.
+*/
+const EMAIL = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+const DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const URI_SCHEME = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function schemaOf(value) {
+	return isObject(value) ? value : {};
+}
+function typeMatches(type, value) {
+	switch (type) {
+		case "string": return typeof value === "string";
+		case "number": return typeof value === "number" && Number.isFinite(value);
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "boolean": return typeof value === "boolean";
+		case "array": return Array.isArray(value);
+		case "object": return isObject(value);
+		case "null": return value === null;
+		default: return true;
+	}
+}
+function equal(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, i) => equal(item, b[i]));
+	if (isObject(a) && isObject(b)) {
+		const keys = Object.keys(a);
+		return keys.length === Object.keys(b).length && keys.every((key) => key in b && equal(a[key], b[key]));
+	}
+	return false;
+}
+function validDate(value) {
+	const match = DATE.exec(value);
+	if (match === null) return false;
+	const [year, month, day] = [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3])
+	];
+	const last = new Date(Date.UTC(year, month, 0)).getUTCDate();
+	return month >= 1 && month <= 12 && day >= 1 && day <= last;
+}
+function formatMatches(format, value) {
+	switch (format) {
+		case "email": return EMAIL.test(value);
+		case "date": return validDate(value);
+		case "uri": return URI_SCHEME.test(value) && URL.canParse(value);
+		default: return true;
+	}
+}
+const SURROGATE_PAIR = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+/** Code points, as JSON Schema counts string length. */
+const lengthOf = (value) => value.length - (value.match(SURROGATE_PAIR)?.length ?? 0);
+const items = (count) => count === 1 ? "1 item" : `${count} items`;
+function check(schema, value, path, issues) {
+	const at = (message) => issues.push({
+		message,
+		path
+	});
+	if ("type" in schema && !typeMatches(schema["type"], value)) {
+		at(`must be ${String(schema["type"])}`);
+		return;
+	}
+	if ("const" in schema && !equal(schema["const"], value)) at(`must be ${JSON.stringify(schema["const"])}`);
+	const allowed = schema["enum"];
+	if (Array.isArray(allowed) && !allowed.some((item) => equal(item, value))) at("must be one of the options");
+	if ("not" in schema) {
+		const inner = [];
+		check(schemaOf(schema["not"]), value, path, inner);
+		if (inner.length === 0) at("is required");
+	}
+	if (typeof value === "string") {
+		const { minLength, maxLength, pattern, format } = schema;
+		if (typeof minLength === "number" && lengthOf(value) < minLength) at(minLength === 1 ? "is required" : `must be at least ${minLength} characters`);
+		if (typeof maxLength === "number" && lengthOf(value) > maxLength) at(`must be at most ${maxLength} characters`);
+		if (typeof pattern === "string" && !new RegExp(pattern, "u").test(value)) at("has the wrong format");
+		if (format !== void 0 && !formatMatches(format, value)) at(`must be a valid ${String(format)}`);
+	}
+	if (typeof value === "number") {
+		const { minimum, maximum } = schema;
+		if (typeof minimum === "number" && value < minimum) at(`must be at least ${minimum}`);
+		if (typeof maximum === "number" && value > maximum) at(`must be at most ${maximum}`);
+	}
+	if (Array.isArray(value)) {
+		const { minItems, maxItems, uniqueItems } = schema;
+		const each = schema["items"];
+		if (typeof minItems === "number" && value.length < minItems) at(`must have at least ${items(minItems)}`);
+		if (typeof maxItems === "number" && value.length > maxItems) at(`must have at most ${items(maxItems)}`);
+		if (uniqueItems === true && value.some((item, i) => value.findIndex((other) => equal(item, other)) !== i)) at("must not repeat an item");
+		if (each !== void 0) for (const [i, item] of value.entries()) check(schemaOf(each), item, [...path, i], issues);
+	}
+	if (isObject(value)) {
+		const properties = schemaOf(schema["properties"]);
+		const required = schema["required"];
+		if (Array.isArray(required)) {
+			for (const key of required) if (typeof key === "string" && !(key in value)) issues.push({
+				message: "is required",
+				path: [...path, key]
+			});
+		}
+		for (const [key, item] of Object.entries(value)) if (key in properties) check(schemaOf(properties[key]), item, [...path, key], issues);
+		else if (schema["additionalProperties"] === false) issues.push({
+			message: "is not a field of this form",
+			path: [...path, key]
+		});
+	}
+	const all = schema["allOf"];
+	if (Array.isArray(all)) for (const part of all) check(schemaOf(part), value, path, issues);
+	if ("if" in schema) {
+		const condition = [];
+		check(schemaOf(schema["if"]), value, path, condition);
+		if (condition.length === 0 && "then" in schema) check(schemaOf(schema["then"]), value, path, issues);
+	}
+}
+/**
+* Checks answers against a form version's schema with the keywords the
+* generator emits, so a form can show errors before it submits. Postgres checks
+* the same schema again on submit; this is not a general JSON Schema
+* validator.
+*/
+function validateAnswers(schema, answers) {
+	const issues = [];
+	check(schema, answers, [], issues);
+	return issues;
+}
+/** A form version's schema as a Standard Schema, for form libraries. */
+function answersSchema(schema) {
+	return { "~standard": {
+		version: 1,
+		vendor: "better-supabase",
+		validate: (value) => {
+			const issues = validateAnswers(schema, value);
+			return issues.length === 0 ? { value } : { issues };
+		}
+	} };
+}
+//#endregion
+//#region src/blocks/forms/questionnaire.ts
+function same(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+const EMPTY = /* @__PURE__ */ new Set([null, ""]);
+/**
+* Whether `condition` holds for `answers`, with the semantics of its JSON
+* Schema `if`.
+*/
+function conditionHolds(condition, answers) {
+	if (condition === void 0) return true;
+	if (!(condition.field in answers)) return false;
+	const value = answers[condition.field];
+	if ("equals" in condition) return same(value, condition.equals);
+	if ("in" in condition) return condition.in.some((item) => same(value, item));
+	return !(value === void 0 || EMPTY.has(value) || Array.isArray(value) && value.length === 0);
+}
+/** The steps whose `showIf` holds. */
+function visibleSteps(definition, answers) {
+	return definition.steps.filter((step) => conditionHolds(step.showIf, answers));
+}
+/** The step's fields whose `showIf` holds. */
+function visibleFields(step, answers) {
+	return step.fields.filter((field) => conditionHolds(field.showIf, answers));
+}
+function visibleKeys(definition, answers) {
+	return new Set(visibleSteps(definition, answers).flatMap((step) => visibleFields(step, answers).map((field) => field.key)));
+}
+/**
+* The answers without the ones for hidden steps and fields. Removing an answer
+* can hide a later field, so it repeats until nothing changes.
+*/
+function pruneAnswers(definition, answers) {
+	const keep = visibleKeys(definition, answers);
+	const next = Object.fromEntries(Object.entries(answers).filter(([key]) => keep.has(key)));
+	return Object.keys(next).length === Object.keys(answers).length ? next : pruneAnswers(definition, next);
+}
+/** The schema's issues for the fields `step` shows. */
+function stepIssues(schema, step, answers) {
+	const keys = new Set(visibleFields(step, answers).map((field) => field.key));
+	return validateAnswers(schema, answers).filter((issue) => {
+		const key = issue.path?.[0];
+		return typeof key === "string" && keys.has(key);
+	});
+}
+/** The state before the first answer. */
+function initialQuestionnaire(form, answers = {}) {
+	return {
+		step: (visibleSteps(form.definition, answers)[0] ?? form.definition.steps[0])?.key ?? "",
+		answers,
+		completed: [],
+		issues: []
+	};
+}
+/**
+* The step on screen, or the nearest visible one before it when an answer hid
+* it.
+*/
+function stepAfterAnswer(form, step, answers) {
+	const visible = new Set(visibleSteps(form.definition, answers).map((item) => item.key));
+	if (visible.has(step)) return step;
+	const order = form.definition.steps.map((item) => item.key);
+	return order.slice(0, Math.max(order.indexOf(step), 0)).toReversed().find((key) => visible.has(key)) ?? order.find((key) => visible.has(key)) ?? step;
+}
+/**
+* The questionnaire as a reducer: answers, the current step and the steps done.
+* `next` checks the step's fields against the version's schema and stays put
+* with `issues` when one fails; hidden steps are skipped.
+*/
+function questionnaireReducer(form, state, action) {
+	const steps = visibleSteps(form.definition, state.answers);
+	const index = steps.findIndex((step) => step.key === state.step);
+	switch (action.type) {
+		case "answer": {
+			const answers = { ...state.answers };
+			if (action.value === void 0) delete answers[action.key];
+			else answers[action.key] = action.value;
+			const issues = state.issues.filter((issue) => issue.path?.[0] !== action.key);
+			return {
+				...state,
+				step: stepAfterAnswer(form, state.step, answers),
+				answers,
+				issues
+			};
+		}
+		case "next": {
+			const current = steps[index];
+			if (current === void 0) return state;
+			const issues = stepIssues(form.schema, current, state.answers);
+			if (issues.length > 0) return {
+				...state,
+				issues
+			};
+			const completed = state.completed.includes(current.key) ? state.completed : [...state.completed, current.key];
+			const following = steps[index + 1];
+			return {
+				...state,
+				step: following?.key ?? current.key,
+				completed,
+				issues: []
+			};
+		}
+		case "back": {
+			const previous = steps[index - 1];
+			return previous === void 0 ? state : {
+				...state,
+				step: previous.key,
+				issues: []
+			};
+		}
+		case "goTo": {
+			const target = steps.findIndex((step) => step.key === action.step);
+			return target !== -1 && steps.slice(0, target).every((step) => state.completed.includes(step.key)) ? {
+				...state,
+				step: action.step,
+				issues: []
+			} : state;
+		}
+		case "reset": return initialQuestionnaire(form, action.answers);
+		default: return action;
+	}
+}
+/** The visible steps with their status, in the shape a Stepper renders. */
+function questionnaireSteps(form, state) {
+	return visibleSteps(form.definition, state.answers).map((step) => ({
+		key: step.key,
+		...step.title === void 0 ? {} : { title: step.title },
+		...step.description === void 0 ? {} : { description: step.description },
+		fields: visibleFields(step, state.answers),
+		completed: state.completed.includes(step.key),
+		active: step.key === state.step
+	}));
+}
+/** The pruned answers, or every issue when the whole form does not pass. */
+function finishQuestionnaire(form, state) {
+	const answers = pruneAnswers(form.definition, state.answers);
+	const issues = validateAnswers(form.schema, answers);
+	return issues.length === 0 ? {
+		ok: true,
+		answers
+	} : {
+		ok: false,
+		issues
+	};
+}
+//#endregion
+//#region src/blocks/forms/client.ts
+function byField(issues) {
+	const out = {};
+	for (const issue of issues) {
+		const key = issue.path?.[0];
+		const name = typeof key === "string" ? key : "";
+		(out[name] ??= []).push(issue.message);
+	}
+	return out;
+}
+function viewOf(form, current, finalIssues, submitting) {
+	const steps = questionnaireSteps(form, current);
+	const index = steps.findIndex((step) => step.active);
+	return {
+		steps,
+		step: steps[index],
+		answers: current.answers,
+		issues: byField([...current.issues, ...finalIssues]),
+		isFirst: index <= 0,
+		isLast: index === steps.length - 1,
+		submitting
+	};
+}
+/**
+* A multi-step form over a form version: the visible steps, the answers, and
+* per-field issues checked against the version's JSON Schema.
+*/
+function createQuestionnaireController(options) {
+	const { form } = options;
+	let current = initialQuestionnaire(form, options.initialAnswers);
+	let finalIssues = [];
+	let submitting = false;
+	return defineController(viewOf(form, current, finalIssues, submitting), (state) => {
+		const show = () => {
+			state.set(viewOf(form, current, finalIssues, submitting));
+		};
+		const dispatch = (action) => {
+			current = questionnaireReducer(form, current, action);
+			show();
+		};
+		return { actions: {
+			setAnswer: (key, value) => {
+				finalIssues = finalIssues.filter((issue) => issue.path?.[0] !== key);
+				dispatch({
+					type: "answer",
+					key,
+					value
+				});
+			},
+			next: () => {
+				dispatch({ type: "next" });
+			},
+			back: () => {
+				dispatch({ type: "back" });
+			},
+			goTo: (step) => {
+				dispatch({
+					type: "goTo",
+					step
+				});
+			},
+			reset: (answers) => {
+				finalIssues = [];
+				dispatch(answers === void 0 ? { type: "reset" } : {
+					type: "reset",
+					answers
+				});
+			},
+			submit: async () => {
+				const result = finishQuestionnaire(form, current);
+				if (!result.ok) {
+					finalIssues = result.issues;
+					show();
+					return false;
+				}
+				submitting = true;
+				show();
+				try {
+					await options.onSubmit(result.answers);
+				} finally {
+					submitting = false;
+					show();
+				}
+				return true;
+			}
+		} };
+	});
+}
+//#endregion
+export { pruneAnswers as a, stepIssues as c, answersSchema as d, validateAnswers as f, initialQuestionnaire as i, visibleFields as l, conditionHolds as n, questionnaireReducer as o, finishQuestionnaire as r, questionnaireSteps as s, createQuestionnaireController as t, visibleSteps as u };

package/dist/client-BNaOcfeH.js

@@ -0,0 +1,58 @@
+import { t as defineController } from "./controller-BEliOBOv.js";
+//#region src/blocks/undo/client.ts
+/**
+* A stack of undo tokens on the client, for a toast's Undo button or a Cmd+Z
+* handler.
+*/
+function createUndoController(options) {
+	return defineController({
+		entries: [],
+		canUndo: false,
+		pending: false,
+		error: void 0
+	}, (state) => {
+		let nextId = 0;
+		const show = (entries, pending, error) => {
+			state.set({
+				entries,
+				pending,
+				error,
+				canUndo: entries.length > 0 && !pending
+			});
+		};
+		return { actions: {
+			push: (token, label = "") => {
+				if (!token) return;
+				nextId += 1;
+				const limit = Math.max(1, options.limit ?? 20);
+				const { entries, pending } = state.get();
+				show([...entries, {
+					id: nextId,
+					label,
+					token
+				}].slice(-limit), pending, void 0);
+			},
+			undo: async () => {
+				const { entries, pending } = state.get();
+				const top = entries.at(-1);
+				if (!top || pending) return false;
+				show(entries.slice(0, -1), true, void 0);
+				let error;
+				let worked = true;
+				try {
+					await options.apply(top.token);
+				} catch (cause) {
+					error = cause;
+					worked = false;
+				}
+				show(state.get().entries, false, error);
+				return worked;
+			},
+			clear: () => {
+				show([], state.get().pending, void 0);
+			}
+		} };
+	});
+}
+//#endregion
+export { createUndoController as t };

package/dist/client-BOuaQA0h.js

@@ -0,0 +1,173 @@
+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 { R as toInstant } from "./block-helpers-DwE32_gT.js";
+import { t as authResult } from "./auth-reply-D02x5NSv.js";
+//#region src/blocks/sessions/client.ts
+const filled = (value) => value === null || value === void 0 || value === "" ? void 0 : value;
+const clientInfo = (raw) => ({
+	id: raw.id,
+	name: raw.name,
+	uri: filled(raw.uri),
+	logoUri: filled(raw.logo_uri)
+});
+const hostOf = (uri) => {
+	try {
+		return new URL(uri).host;
+	} catch {
+		return uri;
+	}
+};
+/**
+* Reads per authorization id. A request the user approved before is used up by
+* its first read, so a second controller for the same id (React Strict Mode
+* mounts twice) has to share the answer.
+*/
+const reads = /* @__PURE__ */ new Map();
+async function readDetails(oauth, authorizationId) {
+	const result = await authResult(() => oauth.getAuthorizationDetails(authorizationId));
+	if (!result.ok) return result;
+	const data = result.data;
+	if (!("authorization_id" in data)) return ok({ redirectUrl: data.redirect_url });
+	return ok({
+		authorizationId: data.authorization_id,
+		client: clientInfo(data.client),
+		user: data.user,
+		scopes: data.scope.split(" ").filter((scope) => scope !== ""),
+		redirectUri: data.redirect_uri,
+		redirectHost: hostOf(data.redirect_uri)
+	});
+}
+const assign = (url) => {
+	globalThis.location.assign(url);
+};
+/**
+* The consent page of the Supabase Auth OAuth server: it reads the request for
+* `authorizationId`, and `approve` or `deny` send the browser to the
+* `redirect_url` that Auth returns, never to a URL from the page.
+*/
+function createOAuthConsentController(options) {
+	const { oauth, authorizationId } = options;
+	const redirect = options.redirect ?? assign;
+	return defineController({
+		request: void 0,
+		redirectUrl: void 0,
+		deciding: void 0,
+		error: void 0
+	}, (state) => {
+		const leave = (url) => {
+			state.set({
+				request: void 0,
+				redirectUrl: url
+			});
+			redirect(url);
+		};
+		const load = async (id) => {
+			let read = reads.get(id);
+			if (read === void 0) {
+				read = readDetails(oauth, id);
+				reads.set(id, read);
+			}
+			const run = state.run();
+			const result = await read;
+			if (run !== state.run()) return;
+			if (!result.ok) {
+				reads.delete(id);
+				state.set({ error: result.error });
+				return;
+			}
+			if ("redirectUrl" in result.data) {
+				leave(result.data.redirectUrl);
+				return;
+			}
+			state.set({
+				request: result.data,
+				error: void 0
+			});
+		};
+		const decide = async (decision) => {
+			const id = state.get().request?.authorizationId;
+			if (id === void 0 || state.get().deciding !== void 0) return err(dbError("invalid_input", "No authorization request to decide"));
+			state.set({
+				deciding: decision,
+				error: void 0
+			});
+			const result = await authResult(() => decision === "approve" ? oauth.approveAuthorization(id, { skipBrowserRedirect: true }) : oauth.denyAuthorization(id, { skipBrowserRedirect: true }));
+			if (!result.ok) {
+				state.set({
+					deciding: void 0,
+					error: result.error
+				});
+				return result;
+			}
+			reads.delete(id);
+			leave(result.data.redirect_url);
+			return ok(result.data.redirect_url);
+		};
+		return {
+			actions: {
+				approve: () => decide("approve"),
+				deny: () => decide("deny")
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				if (authorizationId !== void 0) load(authorizationId);
+			})
+		};
+	});
+}
+/**
+* The OAuth clients (such as MCP clients) the user approved, for a connected
+* agents list.
+*/
+function createOAuthGrantsController(options) {
+	const { oauth } = options;
+	return defineController({
+		grants: void 0,
+		revoking: [],
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const refresh = async () => {
+			ticket += 1;
+			const request = ticket;
+			const result = await authResult(() => oauth.listGrants());
+			if (request !== ticket) return;
+			if (!result.ok) {
+				state.set({ error: result.error });
+				return;
+			}
+			state.set({
+				grants: result.data.map((grant) => ({
+					client: clientInfo(grant.client),
+					scopes: grant.scopes,
+					grantedAt: toInstant(grant.granted_at)
+				})).toSorted((a, b) => b.grantedAt.epochMilliseconds - a.grantedAt.epochMilliseconds),
+				error: void 0
+			});
+		};
+		return {
+			actions: {
+				refresh,
+				revoke: async (clientId) => {
+					state.set((current) => ({
+						revoking: [...current.revoking, clientId],
+						error: void 0
+					}));
+					const result = await authResult(() => oauth.revokeGrant({ clientId }));
+					state.set((current) => ({
+						revoking: current.revoking.filter((each) => each !== clientId),
+						...result.ok ? {} : { error: result.error }
+					}));
+					if (!result.ok) return result;
+					await refresh();
+					return ok(true);
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+//#endregion
+export { createOAuthGrantsController as n, createOAuthConsentController as t };

package/dist/client-BP-8vn9G.d.ts

@@ -0,0 +1,37 @@
+import { b as DbError } from "./result-mijqfoJN.js";
+import { a as Usage, h as UsageStatus } from "./usage-BFwuH7GK.js";
+import { n as Controller, t as AuthPort } from "./controller-lWRcKqCl.js";
+//#region src/blocks/usage/client.d.ts
+interface UsageMeterControllerOptions {
+  /** `createUsage({ transport })`, or a `Pick` with `overview`. */
+  readonly client: Pick<Usage, "overview">;
+  readonly auth: AuthPort;
+  /** The organization whose usage to read; the meter waits without one. */
+  readonly organizationId: string | null;
+  /**
+   * Only these meters, in this order. Default every meter with usage or a
+   * quota.
+   */
+  readonly meters?: readonly string[];
+}
+/** One meter against its quota. */
+interface MeterReading extends UsageStatus {
+  /** `used / limit` from 0 to 1, or `undefined` without a limit. */
+  readonly fraction: number | undefined;
+  /** True once the period's quota is used up. */
+  readonly exceeded: boolean;
+}
+interface UsageMeterSnapshot {
+  /** `undefined` until the first load. */
+  readonly meters: readonly MeterReading[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface UsageMeterActions {
+  /** Reads the usage again, such as after the app records some. */
+  readonly refresh: () => Promise<void>;
+}
+type UsageMeterController = Controller<UsageMeterSnapshot, UsageMeterActions>;
+/** This period's usage of an organization against its plan's quotas, per meter. */
+declare function createUsageMeterController(options: UsageMeterControllerOptions): UsageMeterController;
+//#endregion
+export { UsageMeterSnapshot as a, UsageMeterControllerOptions as i, UsageMeterActions as n, createUsageMeterController as o, UsageMeterController as r, MeterReading as t };