better-supabase 0.12.0 → 0.14.0

package/dist/client-BGnJ5WJi.js

@@ -1,438 +0,0 @@
-import { d as toFilterFields, i as checkFilterQuery, t as FILTER_OPERATORS } from "./filter-query-B3lhckKX.js";
-import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
-//#region src/blocks/rules/fields.ts
-const DEFAULT_COLUMN_TYPE = {
-	text: "text",
-	number: "numeric",
-	date: "timestamptz",
-	select: "text",
-	multiselect: "jsonb",
-	boolean: "boolean",
-	relation: "uuid"
-};
-const DATE_TYPES = /* @__PURE__ */ new Set([
-	"date",
-	"timestamp",
-	"timestamptz"
-]);
-const SUBJECT_TYPE = /^[a-z][a-z0-9_]{0,62}$/;
-const FIELD_ID = /^[A-Za-z_][A-Za-z0-9_]*(?:[.][A-Za-z_][A-Za-z0-9_]*)*$/;
-function labelOf(id) {
-	const words = id.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").replaceAll(/[_.-]+/g, " ").trim().toLowerCase();
-	return words.charAt(0).toUpperCase() + words.slice(1);
-}
-/**
-* Declares the fields rules on `subjectType` may test. Sync the catalog with
-* `createRulesAdmin(...).syncFields(catalog)` so the database checks and
-* evaluates trees against the same fields.
-*/
-function defineRuleFields(subjectType, fields) {
-	if (!SUBJECT_TYPE.test(subjectType)) throw new TypeError(`defineRuleFields: "${subjectType}" is not a subject type (lowercase letters, digits and underscores)`);
-	return {
-		subjectType,
-		fields: Object.entries(fields).map(([id, field]) => {
-			const column = field.column ?? id;
-			if (!FIELD_ID.test(id) || !FIELD_ID.test(column)) throw new TypeError(`defineRuleFields(${subjectType}): "${id}" needs an id and column of dotted identifiers`);
-			const allowed = new Set(FILTER_OPERATORS[field.type].map((entry) => entry.value));
-			const unknown = field.operators?.find((name) => !allowed.has(name));
-			if (unknown !== void 0) throw new TypeError(`defineRuleFields(${subjectType}.${id}): "${unknown}" is not a ${field.type} operator`);
-			const columnType = field.columnType ?? DEFAULT_COLUMN_TYPE[field.type];
-			if (field.type === "date" && !DATE_TYPES.has(columnType)) throw new TypeError(`defineRuleFields(${subjectType}.${id}): a date field's columnType is date, timestamp or timestamptz`);
-			return {
-				subjectType,
-				id,
-				label: field.label ?? labelOf(id),
-				description: field.description,
-				type: field.type,
-				column,
-				columnType,
-				nullable: field.nullable ?? true,
-				options: field.options?.map((option) => typeof option === "string" ? {
-					value: option,
-					label: labelOf(option)
-				} : {
-					value: option.value,
-					label: option.label ?? labelOf(option.value)
-				}),
-				operators: field.operators
-			};
-		})
-	};
-}
-/** Catalog fields as list filter fields, for `evaluateFilterQuery` and `checkFilterQuery`. */
-function ruleFilterFieldInfo(fields) {
-	return fields.map((field) => {
-		const allowed = field.operators;
-		return {
-			id: field.id,
-			type: field.type,
-			column: field.column,
-			columnMeta: {
-				db: field.column,
-				type: field.columnType,
-				nullable: field.nullable,
-				hasDefault: false
-			},
-			label: field.label,
-			...field.description === void 0 ? {} : { description: field.description },
-			operators: FILTER_OPERATORS[field.type].filter((entry) => allowed === void 0 || allowed.includes(entry.value)),
-			...field.options === void 0 ? {} : { options: field.options }
-		};
-	});
-}
-/** The `fields` prop of ReUI's Filters for a rule editor. */
-function ruleFilterFields(fields, labels) {
-	return toFilterFields(ruleFilterFieldInfo(fields), labels);
-}
-/** The defaults of `blocks.rules.options`. */
-const RULE_LIMITS = {
-	maxDepth: 4,
-	maxRules: 50,
-	maxValueLength: 1e4,
-	maxValues: 100
-};
-/**
-* The problems `save` would report for a tree, checked in the browser: an
-* empty list when the database will accept it. Unfinished conditions are
-* allowed; they take no part until they have an operator.
-*/
-function checkRuleConditions(conditions, fields, limits = RULE_LIMITS) {
-	const issues = [];
-	checkFilterQuery(conditions, ruleFilterFieldInfo(fields), limits, issues);
-	return issues;
-}
-//#endregion
-//#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 { ruleFilterFieldInfo as _, insertNode as a, removeNode as c, setRuleField as d, setRuleOperator as f, defineRuleFields as g, checkRuleConditions as h, findNode as i, ruleOperators as l, RULE_LIMITS as m, contains as n, moveNode as o, updateNode as p, emptyConditions as r, parentOf as s, createRuleBuilderController as t, setCombinator as u, ruleFilterFields as v };

package/dist/client-BJN0IMEp.d.ts

@@ -1,34 +0,0 @@
-import { n as Controller, t as AuthPort } from "./controller-BZhiIb-N.js";
-import { t as EntitlementClaimOptions } from "./entitlements-CtBGXb3B.js";
-//#region src/blocks/entitlements/client.d.ts
-interface FeatureGateControllerOptions {
-  readonly auth: AuthPort;
-  /** The plan feature, such as `exports`: a key of `entitlements.source.plans`. */
-  readonly feature: string;
-  /** The organization to check. Default the session's active one, from the tenant claim. */
-  readonly organizationId?: string | null;
-  /** `config.claims.features` (default `features`), or `{ claim, keys }` for short codes. */
-  readonly claim?: string | EntitlementClaimOptions;
-  /** The tenant claim, `config.claims.tenant` (default `tenant_id`). */
-  readonly tenantClaim?: string;
-}
-interface FeatureGateSnapshot {
-  /** `undefined` while the session loads; false when signed out or outside an organization. */
-  readonly allowed: boolean | undefined;
-  /** The organization the check ran for. */
-  readonly organizationId: string | undefined;
-}
-interface FeatureGateActions {
-  /** Checks the session again, such as after a refresh the gate did not hear of. */
-  readonly recheck: () => void;
-}
-type FeatureGateController = Controller<FeatureGateSnapshot, FeatureGateActions>;
-/**
- * Whether the active organization's plan includes `feature`, from the
- * session's plan-features claim. It updates when the session does, so a
- * session refresh after checkout opens the gate. UX only: enforce the
- * feature in RLS with `better_supabase.has_entitlement()`.
- */
-declare function createFeatureGateController(options: FeatureGateControllerOptions): FeatureGateController;
-//#endregion
-export { createFeatureGateController as a, FeatureGateSnapshot as i, FeatureGateController as n, FeatureGateControllerOptions as r, FeatureGateActions as t };