better-supabase 0.12.0 → 0.13.0

package/dist/client-DAcVF-YJ.js

@@ -0,0 +1,134 @@
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, k as recordsOf, n as applyTemporal, o as blockCall } from "./block-helpers-DwE32_gT.js";
+import { r as withBlockHooks } from "./block-hooks-C1r-R2r0.js";
+//#region src/blocks/reactions/reactions.ts
+/** The topic the module broadcasts an organization's reaction changes to. */
+function reactionsTopic(organizationId, topic = "reactions") {
+	return `${topic}:${organizationId}`;
+}
+function countsOf(value, fn) {
+	return recordsOf(value, fn).map((row) => ({
+		emoji: textOf(row["emoji"]),
+		count: Number(row["count"]),
+		reacted: row["reacted"] === true,
+		actors: Array.isArray(row["actors"]) ? row["actors"].map((actor) => textOf(actor)) : []
+	}));
+}
+function emojiOf(value, fn) {
+	const row = recordOf(value, fn);
+	const attachmentId = optionalText(row["attachmentId"]);
+	const url = optionalText(row["url"]);
+	return {
+		id: textOf(row["id"]),
+		shortcode: textOf(row["shortcode"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		...attachmentId === void 0 ? {} : { attachmentId },
+		...url === void 0 ? {} : { url }
+	};
+}
+/** The `reactions` SQL module as typed calls. */
+function createReactions(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	return withBlockHooks({
+		react: (organizationId, subjectType, subjectId, emoji, react = {}) => call("react", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			emoji,
+			present: react.present ?? true,
+			actor: react.actor ?? null
+		}, (value) => countsOf(value, "react")),
+		summary: (organizationId, subjectType, subjectIds) => call("reaction_summary", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_ids: [...subjectIds]
+		}, (value) => Object.fromEntries(Object.entries(recordOf(value, "reaction_summary")).map(([id, counts]) => [id, countsOf(counts, "reaction_summary")]))),
+		customEmoji: (organizationId) => call("list_custom_emoji", { tenant: organizationId }, (value) => recordsOf(value, "list_custom_emoji").map((row) => emojiOf(row, "list_custom_emoji"))),
+		saveCustomEmoji: (organizationId, input) => call("save_custom_emoji", {
+			tenant: organizationId,
+			shortcode: input.shortcode,
+			attachment_id: input.attachmentId ?? null,
+			url: input.url ?? null
+		}, (value) => emojiOf(value, "save_custom_emoji")),
+		deleteCustomEmoji: (id) => call("delete_custom_emoji", { emoji_id: id }, (value) => value === true)
+	}, options.hooks, {
+		block: "reactions",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/reactions/client.ts
+const sameIds = (a, b) => a.length === b.length && a.every((id, index) => id === b[index]);
+/**
+* The reactions of the subjects on screen, loaded again when anyone in the
+* organization reacts to one of them. `toggle` feeds an emoji picker.
+*/
+function createReactionsController(options) {
+	const { client, organizationId, subjectType } = options;
+	const topic = options.topic === void 0 ? "reactions" : options.topic;
+	let subjects = [...options.subjectIds];
+	let watching = false;
+	return defineController({
+		reactions: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const refresh = async () => {
+			ticket += 1;
+			const request = ticket;
+			const result = await client.summary(organizationId, subjectType, subjects);
+			if (request !== ticket) return;
+			state.set(result.ok ? {
+				reactions: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		const watched = (payload) => typeof payload !== "object" || payload === null || !("subjectId" in payload) || !("subjectType" in payload) || payload.subjectType === subjectType && typeof payload.subjectId === "string" && subjects.includes(payload.subjectId);
+		return {
+			actions: {
+				refresh,
+				setSubjects: (subjectIds) => {
+					if (sameIds(subjects, subjectIds)) return;
+					subjects = [...subjectIds];
+					if (watching) refresh();
+				},
+				toggle: async (subjectId, emoji) => {
+					const present = !state.get().reactions?.[subjectId]?.some((reaction) => reaction.emoji === emoji && reaction.reacted);
+					const result = await client.react(organizationId, subjectType, subjectId, emoji, { present });
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					state.set((current) => ({
+						error: void 0,
+						reactions: {
+							...current.reactions,
+							[subjectId]: result.data
+						}
+					}));
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				watching = true;
+				refresh();
+				const leave = topic ? options.ports.topic(reactionsTopic(organizationId, topic), {
+					onMessage: (_event, payload) => {
+						if (watched(payload)) refresh();
+					},
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				}).leave : void 0;
+				return () => {
+					watching = false;
+					leave?.();
+				};
+			})
+		};
+	});
+}
+//#endregion
+export { createReactions as n, reactionsTopic as r, createReactionsController as t };

package/dist/client-DCuE1rFm.js

@@ -0,0 +1,441 @@
+import { d as toFilterFields, i as checkFilterQuery, t as FILTER_OPERATORS } from "./filter-query-D4ZSwbcJ.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.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 };