better-supabase 0.13.0 → 0.15.0

package/dist/blocks/automations/index.js

@@ -0,0 +1,553 @@
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { t as FILTER_OPERATORS } from "../../filter-query-DMoKo82_.js";
+import { a as ok, r as err } from "../../result-ntFBW2p2.js";
+import { t as automationsSqlOptions } from "../../options-BMGClqoa.js";
+import { n as whileSignedIn, t as defineController } from "../../controller-BEliOBOv.js";
+import { B as dbTransport, H as rpcTransport, U as sqlTransport } from "../../block-helpers-CtBdjgO4.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { n as createActionRegistry, r as defineAction, t as actionKey } from "../../automation-D41DXyvT.js";
+import { a as ruleFilterFields, i as ruleFilterFieldInfo, n as checkRuleConditions, r as defineRuleFields, t as RULE_LIMITS } from "../../fields-B0zaJAO3.js";
+import { a as createRuleSink, c as ruleOf, i as createRuleDispatcher, l as ruleRecordFields, n as createAutomations, o as evaluateRule, r as createAutomationsAdmin, s as eventTarget } from "../../automations-BYsz43AG.js";
+import { t as defineConversionAction } from "../../conversion-Dq1S7xzE.js";
+//#region src/blocks/automations/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/automations/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.upsert(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
+//#region src/blocks/automations/actions.ts
+function invalid(call, problem) {
+	return err(dbError("invalid_request", `The ${call.origin.type} "${call.origin.name}" has a ${call.action.kind} action ${problem}`, { hint: "ACTION_CONFIG_INVALID" }));
+}
+function originLabel(origin) {
+	switch (origin.type) {
+		case "automation": return "Rule";
+		case "workflow": return "Workflow";
+		case "sequence": return "Sequence";
+		default: return origin.type;
+	}
+}
+function textConfig(config, key) {
+	const value = config?.[key];
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/**
+* The `approvals.request` action: starts an approval of the subject for the
+* action in `config.action`, such as `{ kind: "approvals.request", config: {
+* action: "manager_review" } }`.
+*/
+function approvalsAction(approvals) {
+	return defineAction({
+		kind: "approvals.request",
+		title: "Request an approval",
+		run: (call) => {
+			const { action, context, origin } = call;
+			const name = textConfig(action.config, "action");
+			if (name === void 0) return invalid(call, "without config.action");
+			const reason = textConfig(action.config, "reason");
+			return approvals.request({
+				type: context.subjectType,
+				id: context.subjectId
+			}, {
+				action: name,
+				reason: reason ?? `${originLabel(origin)}: ${origin.name}`,
+				...context.payload === void 0 ? {} : { payload: context.payload }
+			});
+		}
+	});
+}
+function recipientsOf(config, payload) {
+	const listed = config?.["recipients"];
+	const field = textConfig(config, "recipientField");
+	return [listed, field === void 0 ? void 0 : payload?.[field]].flat().filter((value) => typeof value === "string" && value !== "");
+}
+/**
+* The `notify` action: sends the notification type in `config.type` to the user
+* ids in `config.recipients` and in the payload column that
+* `config.recipientField` names, with `config.data` and the payload as its
+* data: `{ kind: "notify", config: { type: "task.assigned", recipientField:
+* "assignee_id" } }`.
+*/
+function notifyAction(notifier) {
+	return defineAction({
+		kind: "notify",
+		title: "Send a notification",
+		run: async (call) => {
+			const { action, context, origin } = call;
+			const type = textConfig(action.config, "type");
+			if (type === void 0) return invalid(call, "without config.type");
+			const recipients = recipientsOf(action.config, context.payload);
+			if (recipients.length === 0) return invalid(call, "without recipients (config.recipients or a filled config.recipientField)");
+			const data = action.config?.["data"];
+			const sent = await notifier.send(type, {
+				recipients,
+				tenant: context.organizationId,
+				key: call.key,
+				subject: {
+					type: context.subjectType,
+					id: context.subjectId
+				},
+				data: {
+					...context.payload,
+					...typeof data === "object" && data !== null ? data : {},
+					[origin.type === "automation" ? "rule" : origin.type]: origin.name
+				}
+			});
+			return ok(sent);
+		}
+	});
+}
+/**
+* The `set_field` action: writes `config.value` to the subject's
+* `config.field`: `{ kind: "set_field", config: { field: "status", value:
+* "review" } }`. The setter decides which fields it accepts.
+*/
+function setFieldAction(setField) {
+	return defineAction({
+		kind: "set_field",
+		title: "Set a field",
+		run: (call) => {
+			const { action, context } = call;
+			const field = textConfig(action.config, "field");
+			if (field === void 0) return invalid(call, "without config.field");
+			if (action.config === void 0 || !Object.hasOwn(action.config, "value")) return invalid(call, "without config.value");
+			return setField({
+				organizationId: context.organizationId,
+				subjectType: context.subjectType,
+				subjectId: context.subjectId,
+				field,
+				value: action.config["value"]
+			});
+		}
+	});
+}
+/**
+* The `webhook` action: queues a delivery to the endpoint in
+* `config.endpointId`, typed `config.type` or the trigger, with the payload as
+* its data: `{ kind: "webhook", config: { endpointId: "..." } }`.
+*/
+function webhookAction(webhooks) {
+	return defineAction({
+		kind: "webhook",
+		title: "Send a webhook",
+		run: (call) => {
+			const { action, context, origin } = call;
+			const endpointId = textConfig(action.config, "endpointId");
+			if (endpointId === void 0) return invalid(call, "without config.endpointId");
+			const type = textConfig(action.config, "type") ?? origin.trigger;
+			if (type === void 0) return invalid(call, "without config.type");
+			return webhooks.dispatch({
+				endpointId,
+				type,
+				data: {
+					subjectType: context.subjectType,
+					subjectId: context.subjectId,
+					...context.payload
+				},
+				...context.eventId === void 0 ? {} : { eventId: context.eventId }
+			});
+		}
+	});
+}
+/**
+* The `workflow` action: starts the workflow definition in `config.definition`
+* on the subject, with the payload as its input: `{ kind: "workflow", config: {
+* definition: "..." } }`. Workflows start only this way, so a retried event
+* starts no second run.
+*/
+function workflowAction(workflows) {
+	return defineAction({
+		kind: "workflow",
+		title: "Start a workflow",
+		run: (call) => {
+			const { action, context } = call;
+			const definition = textConfig(action.config, "definition");
+			if (definition === void 0) return invalid(call, "without config.definition");
+			return workflows.run({
+				definition,
+				input: context.payload ?? {},
+				idempotencyKey: call.key,
+				subject: {
+					type: context.subjectType,
+					id: context.subjectId
+				},
+				tenant: context.organizationId
+			});
+		}
+	});
+}
+//#endregion
+//#region src/blocks/automations/events.ts
+/** The `rules` block's event types, for its manifest and `onBlockEvent`. */
+const automationsEvents = defineEvents({
+	"rule.saved": event(),
+	"rule.enabled": event(),
+	"rule.disabled": event(),
+	"rule.removed": event(),
+	"rule.matched": event()
+});
+//#endregion
+//#region src/blocks/automations/manifest.ts
+/** The `automations` block's manifest (ADR 0029). */
+const automationsBlock = defineBlock({
+	name: "automations",
+	sql: ["automations"],
+	options: { automations: automationsSqlOptions },
+	events: automationsEvents,
+	create: createAutomations,
+	category: "automation",
+	recipes: ["rule-builder"],
+	actions: [
+		{
+			kind: "approvals.request",
+			title: "Request an approval"
+		},
+		{
+			kind: "notify",
+			title: "Send a notification"
+		},
+		{
+			kind: "set_field",
+			title: "Set a field"
+		},
+		{
+			kind: "webhook",
+			title: "Send a webhook"
+		},
+		{
+			kind: "workflow",
+			title: "Start a workflow"
+		}
+	]
+});
+//#endregion
+export { RULE_LIMITS, actionKey, approvalsAction, automationsBlock, automationsEvents, checkRuleConditions, contains, createActionRegistry, createAutomations, createAutomationsAdmin, createRuleBuilderController, createRuleDispatcher, createRuleSink, dbTransport, defineAction, defineConversionAction, defineRuleFields, emptyConditions, evaluateRule, eventTarget, extendBlock, findNode, insertNode, moveNode, notifyAction, parentOf, removeNode, rpcTransport, ruleFilterFieldInfo, ruleFilterFields, ruleOf, ruleOperators, ruleRecordFields, setCombinator, setFieldAction, setRuleField, setRuleOperator, sqlTransport, updateNode, webhookAction, withBlockHooks, workflowAction, wrapTransport };