better-supabase 0.13.0 → 0.14.0

package/dist/client-Bni68sve.d.ts

@@ -0,0 +1,136 @@
+import { D as ValidationIssue } from "./result-C6jDfedy.js";
+import { n as Controller } from "./controller-DAD4hbl4.js";
+import { a as FormDefinition, c as FormJson, f as FormStep, i as FormCondition, l as FormJsonSchema, o as FormField } from "./form-definition-BjEtH8BT.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/forms/validate.d.ts
+/** A submission's answers, by field key. */
+type FormAnswers = {
+  readonly [key: string]: FormJson;
+};
+/**
+ * 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.
+ */
+declare function validateAnswers(schema: FormJsonSchema, answers: unknown): readonly ValidationIssue[];
+/** A form version's schema as a Standard Schema, for form libraries. */
+declare function answersSchema(schema: FormJsonSchema): StandardSchemaV1<unknown, FormAnswers>;
+//#endregion
+//#region src/blocks/forms/questionnaire.d.ts
+/**
+ * Whether `condition` holds for `answers`, with the semantics of its JSON
+ * Schema `if`.
+ */
+declare function conditionHolds(condition: FormCondition | undefined, answers: FormAnswers): boolean;
+/** The steps whose `showIf` holds. */
+declare function visibleSteps(definition: FormDefinition, answers: FormAnswers): readonly FormStep[];
+/** The step's fields whose `showIf` holds. */
+declare function visibleFields(step: FormStep, answers: FormAnswers): readonly FormField[];
+/**
+ * The answers without the ones for hidden steps and fields. Removing an answer
+ * can hide a later field, so it repeats until nothing changes.
+ */
+declare function pruneAnswers(definition: FormDefinition, answers: FormAnswers): FormAnswers;
+/** The schema's issues for the fields `step` shows. */
+declare function stepIssues(schema: FormJsonSchema, step: FormStep, answers: FormAnswers): readonly ValidationIssue[];
+interface QuestionnaireState {
+  /** The step on screen, by key. */
+  readonly step: string;
+  readonly answers: FormAnswers;
+  /** The steps that passed their checks on `next`. */
+  readonly completed: readonly string[];
+  /** The issues of the step on screen after a `next` or `submit` that failed. */
+  readonly issues: readonly ValidationIssue[];
+}
+type QuestionnaireAction = {
+  readonly type: "answer";
+  readonly key: string;
+  readonly value: FormJson | undefined;
+} | {
+  readonly type: "next";
+} | {
+  readonly type: "back";
+} | {
+  readonly type: "goTo";
+  readonly step: string;
+} | {
+  readonly type: "reset";
+  readonly answers?: FormAnswers;
+};
+interface QuestionnaireForm {
+  readonly definition: FormDefinition;
+  /** The version's generated schema. */
+  readonly schema: FormJsonSchema;
+}
+/** The state before the first answer. */
+declare function initialQuestionnaire(form: QuestionnaireForm, answers?: FormAnswers): QuestionnaireState;
+/**
+ * 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.
+ */
+declare function questionnaireReducer(form: QuestionnaireForm, state: QuestionnaireState, action: QuestionnaireAction): QuestionnaireState;
+interface QuestionnaireStepView {
+  readonly key: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly fields: readonly FormField[];
+  readonly completed: boolean;
+  readonly active: boolean;
+}
+/** The visible steps with their status, in the shape a Stepper renders. */
+declare function questionnaireSteps(form: QuestionnaireForm, state: QuestionnaireState): readonly QuestionnaireStepView[];
+/** The pruned answers, or every issue when the whole form does not pass. */
+declare function finishQuestionnaire(form: QuestionnaireForm, state: QuestionnaireState): {
+  readonly ok: true;
+  readonly answers: FormAnswers;
+} | {
+  readonly ok: false;
+  readonly issues: readonly ValidationIssue[];
+};
+//#endregion
+//#region src/blocks/forms/client.d.ts
+interface QuestionnaireOptions {
+  /** A form version, or anything with its `definition` and `schema`. */
+  readonly form: QuestionnaireForm;
+  /** Answers to start from, such as a saved draft. */
+  readonly initialAnswers?: FormAnswers;
+  /** Receives the answers of the visible fields once the whole form passes. */
+  readonly onSubmit: (answers: FormAnswers) => Promise<void> | void;
+}
+interface QuestionnaireSnapshot {
+  /** The visible steps, for a Stepper's items. */
+  readonly steps: readonly QuestionnaireStepView[];
+  /** The step on screen. */
+  readonly step: QuestionnaireStepView | undefined;
+  readonly answers: FormAnswers;
+  /**
+   * Issues by field key: the step on screen's after `next`, every field's after
+   * a failed `submit`.
+   */
+  readonly issues: Readonly<Record<string, readonly string[]>>;
+  readonly isFirst: boolean;
+  readonly isLast: boolean;
+  readonly submitting: boolean;
+}
+interface QuestionnaireActions {
+  /** `undefined` removes the answer. */
+  readonly setAnswer: (key: string, value: FormJson | undefined) => void;
+  /** Checks the step and moves to the next visible one. */
+  readonly next: () => void;
+  readonly back: () => void;
+  /** Moves to a step whose earlier steps are done, for a clickable Stepper. */
+  readonly goTo: (step: string) => void;
+  /** Checks the whole form, then calls `onSubmit`. Returns whether it passed. */
+  readonly submit: () => Promise<boolean>;
+  readonly reset: (answers?: FormAnswers) => void;
+}
+type QuestionnaireController = Controller<QuestionnaireSnapshot, QuestionnaireActions>;
+/**
+ * A multi-step form over a form version: the visible steps, the answers, and
+ * per-field issues checked against the version's JSON Schema.
+ */
+declare function createQuestionnaireController(options: QuestionnaireOptions): QuestionnaireController;
+//#endregion
+export { visibleFields as _, createQuestionnaireController as a, answersSchema as b, QuestionnaireState as c, finishQuestionnaire as d, initialQuestionnaire as f, stepIssues as g, questionnaireSteps as h, QuestionnaireSnapshot as i, QuestionnaireStepView as l, questionnaireReducer as m, QuestionnaireController as n, QuestionnaireAction as o, pruneAnswers as p, QuestionnaireOptions as r, QuestionnaireForm as s, QuestionnaireActions as t, conditionHolds as u, visibleSteps as v, validateAnswers as x, FormAnswers as y };

package/dist/client-BrtwaIBh.d.ts

@@ -0,0 +1,74 @@
+import { b as DbError, f as Result } from "./result-C6jDfedy.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/billing/client.d.ts
+/**
+ * A plan the picker lists: a key from the app's plan catalog, plus whatever the
+ * app shows.
+ */
+interface PlanOption {
+  readonly key: string;
+  readonly name: string;
+}
+/** The plans to offer and the tenant's current plan. */
+interface PlanCatalog<P> {
+  readonly plans: readonly P[];
+  /** The key of the tenant's current plan, `undefined` without a subscription. */
+  readonly current: string | undefined;
+}
+/**
+ * Where Checkout continues: Stripe's hosted page, or `undefined` when the
+ * server finished the change itself.
+ */
+interface CheckoutStarted {
+  readonly url: string | undefined;
+}
+interface PlanPickerControllerOptions<P extends {
+  readonly key: string;
+} = PlanOption> {
+  readonly auth: AuthPort;
+  /**
+   * The plans and the current one, such as a server action that reads the app's
+   * plan catalog and the tenant's subscription. It throws on failure.
+   */
+  readonly load: () => Promise<PlanCatalog<P>>;
+  /** What a server already loaded: the first load is skipped. */
+  readonly initial?: PlanCatalog<P>;
+  /**
+   * Starts Checkout for a plan key on the server, such as a server action that
+   * calls `billing.checkout()`. The controller never talks to Stripe: the
+   * secret key stays on the server.
+   */
+  readonly checkout: (plan: string) => Promise<Result<CheckoutStarted>>;
+  /**
+   * Opens the Checkout URL: `location.assign(url)` on the web,
+   * `WebBrowser.openBrowserAsync(url)` from `expo-web-browser` in React
+   * Native.
+   */
+  readonly open: (url: string) => void | Promise<void>;
+}
+interface PlanPickerSnapshot<P> {
+  /** `undefined` until the first load. */
+  readonly plans: readonly P[] | undefined;
+  readonly current: string | undefined;
+  /** The plan whose Checkout is starting. */
+  readonly pending: string | undefined;
+  readonly error: DbError | undefined;
+}
+interface PlanPickerActions {
+  /**
+   * Starts Checkout for `plan` and opens its URL; a failure is also kept in
+   * `error`. Choosing the current plan does nothing.
+   */
+  readonly choose: (plan: string) => Promise<Result<CheckoutStarted>>;
+  readonly refresh: () => Promise<void>;
+}
+type PlanPickerController<P> = Controller<PlanPickerSnapshot<P>, PlanPickerActions>;
+/**
+ * The plans with the tenant's current one, for a plan picker: `choose` starts
+ * Checkout through the injected server action and opens the URL it returns.
+ */
+declare function createPlanPickerController<P extends {
+  readonly key: string;
+} = PlanOption>(options: PlanPickerControllerOptions<P>): PlanPickerController<P>;
+//#endregion
+export { PlanPickerController as a, createPlanPickerController as c, PlanPickerActions as i, PlanCatalog as n, PlanPickerControllerOptions as o, PlanOption as r, PlanPickerSnapshot as s, CheckoutStarted as t };

package/dist/client-BtRx0-kn.js

@@ -0,0 +1,82 @@
+import { a as ok, t as AsyncResult } from "./result-B3m7xtRY.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { t as currentTenant } from "./tenant-source-bqWpSr86.js";
+//#region src/blocks/access/client.ts
+/**
+* Joins the `permissions(keys)` calls made in the same tick for one tenant into
+* one `my_permissions` call, so every `<Can>` on a screen costs one round trip.
+* Each caller gets back only the keys it asked for.
+*/
+function batchPermissions(source) {
+	const pending = /* @__PURE__ */ new Map();
+	const flush = (tenant, batch) => {
+		pending.delete(tenant);
+		const keys = [...batch.keys];
+		source.permissions(keys, { tenant }).then((result) => {
+			for (const waiter of batch.waiters) waiter(result);
+		});
+	};
+	return { permissions: (keys, options) => {
+		const tenant = currentTenant(options?.tenant);
+		if (keys === void 0 || tenant === void 0) return source.permissions(keys, options);
+		return AsyncResult.from(() => new Promise((resolve) => {
+			let batch = pending.get(tenant);
+			if (batch === void 0) {
+				const created = {
+					keys: /* @__PURE__ */ new Set(),
+					waiters: []
+				};
+				batch = created;
+				pending.set(tenant, created);
+				queueMicrotask(() => {
+					flush(tenant, created);
+				});
+			}
+			const wanted = new Set(keys);
+			for (const key of wanted) batch.keys.add(key);
+			batch.waiters.push((result) => {
+				resolve(result.ok ? ok({
+					tenant,
+					keys: result.data.keys.filter((key) => wanted.has(key))
+				}) : result);
+			});
+		}));
+	} };
+}
+/**
+* Which of `keys` the caller holds in `tenant`, for showing or hiding UI. It
+* loads again when another user signs in. UX only: RLS and the SQL functions
+* check every key again.
+*/
+function createPermissionsController(options) {
+	const { client, keys, tenant } = options;
+	return defineController({
+		permissions: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			if (tenant === void 0) return;
+			const run = state.run();
+			const result = await client.permissions(keys, { tenant });
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				permissions: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: { refresh },
+			start: () => {
+				if (tenant === void 0) return;
+				return whileSignedIn(options.auth, () => {
+					refresh();
+					return () => {
+						state.set({ permissions: void 0 });
+					};
+				});
+			}
+		};
+	});
+}
+//#endregion
+export { createPermissionsController as n, batchPermissions as t };

package/dist/client-BteuBPIy.js

@@ -0,0 +1,337 @@
+import { t as FILTER_OPERATORS } from "./filter-query-D4ZSwbcJ.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { n as checkRuleConditions, t as RULE_LIMITS } from "./fields-DK30XCgc.js";
+//#region src/blocks/rules/tree.ts
+/** The operators a field allows, in the order the editor lists them. */
+function ruleOperators(field) {
+	const allowed = field.operators;
+	return FILTER_OPERATORS[field.type].filter((entry) => allowed === void 0 || allowed.includes(entry.value));
+}
+/** An empty `and` group, the tree a new rule starts with. */
+const emptyConditions = (id = "root") => ({
+	id,
+	type: "group",
+	combinator: "and",
+	rules: []
+});
+/** The node with `id`, or `undefined`. */
+function findNode(tree, id) {
+	if (tree.id === id) return tree;
+	if (tree.type === "rule") return;
+	for (const child of tree.rules) {
+		const found = findNode(child, id);
+		if (found !== void 0) return found;
+	}
+}
+/** The group that holds `id`, or `undefined` for the root and unknown ids. */
+function parentOf(tree, id) {
+	for (const child of tree.rules) {
+		if (child.id === id) return tree;
+		if (child.type === "group") {
+			const found = parentOf(child, id);
+			if (found !== void 0) return found;
+		}
+	}
+}
+/** Whether `id` is `ancestor` or sits anywhere under it. */
+function contains(ancestor, id) {
+	return findNode(ancestor, id) !== void 0;
+}
+function mapTree(tree, visit) {
+	const walk = (node) => {
+		const next = visit(node);
+		if (next === null || next.type === "rule") return next;
+		const rules = next.rules.flatMap((child) => walk(child) ?? []);
+		return rules.length === next.rules.length && rules.every((child, index) => child === next.rules[index]) ? next : {
+			...next,
+			rules
+		};
+	};
+	const root = walk(tree);
+	return root?.type === "group" ? root : tree;
+}
+/** Replaces the node with `id` by what `change` returns. */
+function updateNode(tree, id, change) {
+	return mapTree(tree, (node) => node.id === id ? change(node) : node);
+}
+/** Drops the node with `id` and everything under it; the root stays. */
+function removeNode(tree, id) {
+	if (tree.id === id) return tree;
+	return mapTree(tree, (node) => node.id === id ? null : node);
+}
+/**
+* Adds `node` to the group `parent` at `index` (the end by default). Unchanged
+* when `parent` isn't a group in the tree.
+*/
+function insertNode(tree, parent, node, index) {
+	return mapTree(tree, (current) => {
+		if (current.id !== parent || current.type !== "group") return current;
+		const rules = [...current.rules];
+		const at = index === void 0 ? rules.length : Math.max(0, Math.min(index, rules.length));
+		rules.splice(at, 0, node);
+		return {
+			...current,
+			rules
+		};
+	});
+}
+/**
+* Moves the node with `id` into the group `parent`, where it ends up at `index`
+* (as `arrayMove` counts it). Unchanged for the root, an unknown node or group,
+* or a move into the node itself.
+*/
+function moveNode(tree, id, parent, index) {
+	const node = findNode(tree, id);
+	const target = findNode(tree, parent);
+	if (node === void 0 || parentOf(tree, id) === void 0 || target?.type !== "group" || contains(node, parent)) return tree;
+	return insertNode(removeNode(tree, id), parent, node, index);
+}
+/** Changes a group's `and` or `or`. */
+function setCombinator(tree, id, combinator) {
+	return updateNode(tree, id, (node) => node.type === "group" ? {
+		...node,
+		combinator
+	} : node);
+}
+const arityOf = (field, operator) => field === void 0 ? void 0 : FILTER_OPERATORS[field.type].find((entry) => entry.value === operator)?.arity;
+function withoutValue(rule) {
+	const { value: _value, ...rest } = rule;
+	return rest;
+}
+/**
+* Points a rule at another field. A field of the same type keeps the operator
+* it allows, and its value; another type starts at the field's first operator
+* without a value.
+*/
+function setRuleField(rule, field, previous) {
+	const operators = ruleOperators(field);
+	const keep = previous?.type === field.type && operators.some((entry) => entry.value === rule.operator);
+	const path = field.id.split(".");
+	return keep ? {
+		...rule,
+		path
+	} : withoutValue({
+		...rule,
+		path,
+		operator: operators[0]?.value ?? ""
+	});
+}
+/**
+* Changes a rule's operator. The value stays when the new operator takes the
+* same kind of value (one, many or a range), and is dropped otherwise.
+*/
+function setRuleOperator(rule, operator, field) {
+	const same = arityOf(field, rule.operator) === arityOf(field, operator);
+	const next = {
+		...rule,
+		operator
+	};
+	return same && arityOf(field, operator) !== "none" ? next : withoutValue(next);
+}
+//#endregion
+//#region src/blocks/rules/client.ts
+const draftOf = (snapshot) => JSON.stringify([
+	snapshot.name,
+	snapshot.conditions,
+	snapshot.actions,
+	snapshot.stopProcessing
+]);
+const fieldById = (fields, id) => fields?.find((field) => field.id === id);
+/**
+* The editor state of one rule: the field catalog, the condition tree and the
+* edits to it, with validation, dirty state and save.
+*/
+function createRuleBuilderController(options) {
+	const { client, organizationId } = options;
+	const limits = options.limits ?? RULE_LIMITS;
+	const newId = options.newId ?? (() => crypto.randomUUID());
+	const blank = {
+		name: "",
+		conditions: options.initial ?? emptyConditions(),
+		actions: [],
+		stopProcessing: false
+	};
+	return defineController({
+		rule: void 0,
+		fields: void 0,
+		...blank,
+		locked: options.locked ?? [],
+		issues: [],
+		dirty: false,
+		loading: true,
+		saving: false,
+		error: void 0
+	}, (state) => {
+		let baseline = draftOf(blank);
+		const issuesOf = (conditions, fields) => fields === void 0 ? [] : checkRuleConditions(conditions, fields, limits);
+		const edit = (patch) => {
+			state.set((current) => {
+				const next = {
+					...current,
+					...patch
+				};
+				return {
+					...patch,
+					issues: issuesOf(next.conditions, current.fields),
+					dirty: draftOf(next) !== baseline
+				};
+			});
+		};
+		const isLocked = (id) => state.get().locked.includes(id);
+		/** Locked nodes, and groups that hold one, stay where they are. */
+		const holdsLocked = (id) => {
+			const node = findNode(state.get().conditions, id);
+			return node !== void 0 && state.get().locked.some((locked) => findNode(node, locked) !== void 0);
+		};
+		const editTree = (id, change) => {
+			if (isLocked(id)) return;
+			edit({ conditions: change(state.get().conditions) });
+		};
+		const editRule = (id, change) => {
+			editTree(id, (tree) => updateNode(tree, id, (node) => node.type === "rule" ? change(node, state.get().fields) : node));
+		};
+		const restore = (rule) => {
+			const draft = rule === void 0 ? blank : {
+				name: rule.name,
+				conditions: rule.conditions,
+				actions: rule.actions,
+				stopProcessing: rule.stopProcessing
+			};
+			baseline = draftOf(draft);
+			state.set((current) => ({
+				rule,
+				...draft,
+				issues: issuesOf(draft.conditions, current.fields),
+				dirty: false
+			}));
+		};
+		const refresh = async () => {
+			const run = state.run();
+			state.set({ loading: true });
+			const [fields, rule] = await Promise.all([client.fields(options.subjectType), options.rule === null ? Promise.resolve(void 0) : client.get(options.rule)]);
+			if (run !== state.run()) return;
+			const failure = rule?.ok === false ? rule.error : void 0;
+			state.set({
+				loading: false,
+				error: fields.ok ? failure : fields.error,
+				...fields.ok ? { fields: fields.data } : {}
+			});
+			if (rule === void 0 || rule.ok) restore(rule?.data);
+		};
+		const addRule = (group, field) => {
+			const id = newId();
+			const target = group ?? state.get().conditions.id;
+			const chosen = field === void 0 ? void 0 : fieldById(state.get().fields, field);
+			const operator = chosen === void 0 ? "" : ruleOperators(chosen)[0]?.value ?? "";
+			edit({ conditions: insertNode(state.get().conditions, target, {
+				id,
+				type: "rule",
+				path: chosen === void 0 ? [] : chosen.id.split("."),
+				operator
+			}) });
+			return id;
+		};
+		const addGroup = (group, combinator = "and") => {
+			const id = newId();
+			const target = group ?? state.get().conditions.id;
+			edit({ conditions: insertNode(state.get().conditions, target, {
+				id,
+				type: "group",
+				combinator,
+				rules: []
+			}) });
+			return id;
+		};
+		const save = async (saveOptions = {}) => {
+			const current = state.get();
+			const run = state.run();
+			state.set({
+				saving: true,
+				error: void 0
+			});
+			const saved = await client.save(organizationId, {
+				...current.rule === void 0 ? {
+					subjectType: options.subjectType,
+					...options.trigger === void 0 ? {} : { trigger: options.trigger }
+				} : {
+					id: current.rule.id,
+					version: current.rule.version
+				},
+				name: current.name,
+				conditions: current.conditions,
+				actions: current.actions,
+				stopProcessing: current.stopProcessing,
+				...saveOptions.enabled === void 0 ? {} : { enabled: saveOptions.enabled }
+			});
+			if (run !== state.run()) return saved.ok ? saved.data : void 0;
+			state.set({ saving: false });
+			if (!saved.ok) {
+				state.set({ error: saved.error });
+				return;
+			}
+			restore(saved.data);
+			return saved.data;
+		};
+		return {
+			actions: {
+				refresh,
+				addRule,
+				addGroup,
+				remove: (id) => {
+					if (!holdsLocked(id)) edit({ conditions: removeNode(state.get().conditions, id) });
+				},
+				move: (id, group, index) => {
+					if (!holdsLocked(id)) edit({ conditions: moveNode(state.get().conditions, id, group, index) });
+				},
+				setField: (id, field) => {
+					editRule(id, (rule, fields) => {
+						const next = fieldById(fields, field);
+						return next === void 0 ? rule : setRuleField(rule, next, fieldById(fields, rule.path.join(".")));
+					});
+				},
+				setOperator: (id, operator) => {
+					editRule(id, (rule, fields) => setRuleOperator(rule, operator, fieldById(fields, rule.path.join("."))));
+				},
+				setValue: (id, value) => {
+					editRule(id, (rule) => ({
+						...rule,
+						value
+					}));
+				},
+				setNegated: (id, negated) => {
+					editRule(id, (rule) => ({
+						...rule,
+						negated
+					}));
+				},
+				setCombinator: (group, combinator) => {
+					editTree(group, (tree) => setCombinator(tree, group, combinator));
+				},
+				setName: (name) => {
+					edit({ name });
+				},
+				setActions: (actions) => {
+					edit({ actions });
+				},
+				setStopProcessing: (stopProcessing) => {
+					edit({ stopProcessing });
+				},
+				lock: (id) => {
+					if (!isLocked(id)) state.set({ locked: [...state.get().locked, id] });
+				},
+				unlock: (id) => {
+					state.set({ locked: state.get().locked.filter((locked) => locked !== id) });
+				},
+				reset: () => {
+					restore(state.get().rule);
+				},
+				save
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+//#endregion
+export { insertNode as a, removeNode as c, setRuleField as d, setRuleOperator as f, findNode as i, ruleOperators as l, contains as n, moveNode as o, updateNode as p, emptyConditions as r, parentOf as s, createRuleBuilderController as t, setCombinator as u };