better-supabase 0.7.1 → 0.9.0

package/dist/graph-Cs28bOlK.js

@@ -0,0 +1,360 @@
+import { c as optionalTemporal } from "./temporal-CB5Fpo5d.js";
+import { i as checkFilterQuery, t as FILTER_OPERATORS } from "./filter-query-B3lhckKX.js";
+import { t as evaluateFilterQuery } from "./filter-evaluate-C0ULNfS7.js";
+//#region src/blocks/workflow-builder/graph.ts
+/** Kept local: the static executor runs this file inside the workflow VM. */
+const isGraphRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const WORKFLOW_NODE_KINDS = [
+	"trigger",
+	"step",
+	"sleep",
+	"approval",
+	"condition"
+];
+const OPERATORS = [
+	"equals",
+	"notEquals",
+	"exists",
+	"truthy",
+	"greaterThan",
+	"lessThan",
+	"contains"
+];
+const DURATION = /^(\d+)(ms|s|m|h|d)$/;
+const UNIT_MS = /* @__PURE__ */ new Map([
+	["ms", 1],
+	["s", 1e3],
+	["m", 6e4],
+	["h", 36e5],
+	["d", 864e5]
+]);
+/** A sleep duration in milliseconds; `undefined` when `value` isn't one. */
+function durationMs(value) {
+	if (typeof value === "number") return Number.isFinite(value) && value > 0 ? Math.round(value) : void 0;
+	if (typeof value !== "string") return;
+	const match = DURATION.exec(value.trim());
+	if (match === null) return;
+	const factor = UNIT_MS.get(match[2] ?? "");
+	const ms = Number(match[1]) * (factor ?? 0);
+	return ms > 0 ? ms : void 0;
+}
+const CONDITION_PATH = /^(input|results|subject)(\.[^.]+)*$/;
+const FILTER_LIMITS = {
+	maxDepth: 4,
+	maxRules: 50,
+	maxValueLength: 1e4,
+	maxValues: 100
+};
+const MAX_FILTER_FIELDS = 100;
+const isFilterType = (value) => typeof value === "string" && Object.hasOwn(FILTER_OPERATORS, value);
+function filterFieldOf(value, pattern) {
+	if (!isGraphRecord(value)) return;
+	const { id, type, columnType } = value;
+	if (typeof id !== "string" || !pattern.test(id) || !isFilterType(type) || columnType !== void 0 && typeof columnType !== "string") return;
+	return {
+		id,
+		type,
+		...columnType === void 0 ? {} : { columnType }
+	};
+}
+const columnTypeOf = (field) => field.columnType ?? (field.type === "date" ? "timestamptz" : "text");
+function fieldInfoOf(field) {
+	return {
+		id: field.id,
+		type: field.type,
+		column: field.id,
+		columnMeta: {
+			db: field.id,
+			type: columnTypeOf(field),
+			nullable: true,
+			hasDefault: false
+		},
+		label: field.id,
+		operators: FILTER_OPERATORS[field.type]
+	};
+}
+/**
+* `{ filter, fields }` as a checked filter condition whose field ids match
+* `pattern`; `undefined` when it isn't one or the tree has no finished rule.
+*/
+function filterConditionOf(value, pattern = CONDITION_PATH) {
+	if (!isGraphRecord(value) || !Array.isArray(value["fields"]) || value["fields"].length > MAX_FILTER_FIELDS) return;
+	const fields = [];
+	for (const entry of value["fields"]) {
+		const field = filterFieldOf(entry, pattern);
+		if (field === void 0) return;
+		fields.push(field);
+	}
+	const issues = [];
+	const filter = checkFilterQuery(value["filter"], fields.map(fieldInfoOf), FILTER_LIMITS, issues);
+	return filter === void 0 || issues.length > 0 ? void 0 : {
+		filter,
+		fields
+	};
+}
+/**
+* Whether a filter condition holds for `record`. Relative dates resolve
+* against `Date.now()`, which the workflow runtime keeps deterministic.
+*/
+function matchesFilter(condition, record) {
+	const T = optionalTemporal();
+	return evaluateFilterQuery(condition.filter, record, condition.fields.map((field) => ({
+		id: field.id,
+		type: field.type,
+		column: field.id,
+		columnMeta: {
+			type: columnTypeOf(field),
+			nullable: true
+		}
+	})), T === void 0 ? {} : { now: T.Instant.fromEpochMilliseconds(Date.now()) }).matched;
+}
+const EVENT_PATH = /^(type|tenant|payload)(\.[^.]+)*$/;
+/**
+* Whether an event trigger's `config.when` (a `WorkflowFilterCondition`
+* over `type`, `tenant` and `payload...`) lets `event` start a run. True
+* without a `when`; false when `when` isn't a valid one.
+*/
+function triggerMatches(config, event) {
+	const when = config["when"];
+	if (when === void 0) return true;
+	const condition = filterConditionOf(when, EVENT_PATH);
+	return condition !== void 0 && matchesFilter(condition, {
+		type: event.type,
+		tenant: event.tenant ?? null,
+		payload: event.payload ?? {}
+	});
+}
+/** Why an event trigger's `config.when` can't be used, or `undefined` when it can. */
+function triggerWhenProblem(config) {
+	const when = config["when"];
+	return when === void 0 || filterConditionOf(when, EVENT_PATH) !== void 0 ? void 0 : "config.when is a { filter, fields } filter with at least one finished rule over type, tenant or payload fields";
+}
+/** The node's condition, or `undefined` when its config isn't one. */
+function conditionOf(node) {
+	const config = node.config;
+	if (config === void 0) return;
+	if (config["filter"] !== void 0) return filterConditionOf(config);
+	const path = config["path"];
+	const op = OPERATORS.find((known) => known === config["op"]);
+	if (typeof path !== "string" || op === void 0) return;
+	if (!CONDITION_PATH.test(path)) return;
+	return {
+		path,
+		op,
+		value: config["value"]
+	};
+}
+/** Reads `path` (`input...`, `results...` or `subject...`) from the run's data. */
+function readPath(scope, path) {
+	const [root, ...rest] = path.split(".");
+	let value = root === "input" ? scope.input : root === "subject" ? scope.subject : scope.results;
+	for (const key of rest) if (Array.isArray(value)) value = value[Number(key)];
+	else if (isGraphRecord(value)) value = value[key];
+	else return;
+	return value;
+}
+/** Whether `condition` holds for the run's data. */
+function evaluateCondition(condition, scope) {
+	if ("filter" in condition) return matchesFilter(condition, scope);
+	const actual = readPath(scope, condition.path);
+	const expected = condition.value;
+	switch (condition.op) {
+		case "equals": return JSON.stringify(actual) === JSON.stringify(expected);
+		case "notEquals": return JSON.stringify(actual) !== JSON.stringify(expected);
+		case "exists": return actual !== void 0 && actual !== null;
+		case "truthy": return Boolean(actual);
+		case "greaterThan": return typeof actual === "number" && typeof expected === "number" && actual > expected;
+		case "lessThan": return typeof actual === "number" && typeof expected === "number" && actual < expected;
+		case "contains":
+			if (typeof actual === "string") return typeof expected === "string" && actual.includes(expected);
+			return Array.isArray(actual) && actual.some((item) => JSON.stringify(item) === JSON.stringify(expected));
+		default: {
+			const unknown = condition.op;
+			throw new TypeError(`workflow-builder: unknown operator "${String(unknown)}"`);
+		}
+	}
+}
+/** Whether an approval payload approves: anything but `{ approved: false }`. */
+const approved = (payload) => !(isGraphRecord(payload) && payload["approved"] === false);
+/**
+* The nodes in an order that runs every source before its targets, keeping
+* the graph's order among independent nodes; `undefined` when edges form a
+* cycle.
+*/
+function topologicalOrder(graph) {
+	const indegree = new Map(graph.nodes.map((node) => [node.id, 0]));
+	const targets = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		if (!indegree.has(edge.source) || !indegree.has(edge.target)) continue;
+		indegree.set(edge.target, (indegree.get(edge.target) ?? 0) + 1);
+		targets.set(edge.source, [...targets.get(edge.source) ?? [], edge.target]);
+	}
+	const byId = new Map(graph.nodes.map((node) => [node.id, node]));
+	const order = [];
+	const ready = graph.nodes.filter((node) => indegree.get(node.id) === 0);
+	while (ready.length > 0) {
+		const node = ready.shift();
+		if (node === void 0) break;
+		order.push(node);
+		for (const target of targets.get(node.id) ?? []) {
+			const left = (indegree.get(target) ?? 0) - 1;
+			indegree.set(target, left);
+			const next = byId.get(target);
+			if (left === 0 && next !== void 0) ready.push(next);
+		}
+	}
+	return order.length === graph.nodes.length ? order : void 0;
+}
+/** `value` as a node, or `undefined` when its id or kind is missing. */
+function nodeOf(value) {
+	if (!isGraphRecord(value)) return;
+	const id = value["id"];
+	const kind = WORKFLOW_NODE_KINDS.find((known) => known === value["kind"]);
+	if (typeof id !== "string" || kind === void 0) return;
+	const { label, step, config, position } = value;
+	return {
+		id,
+		kind,
+		...typeof label === "string" ? { label } : {},
+		...typeof step === "string" ? { step } : {},
+		...isGraphRecord(config) ? { config } : {},
+		...isGraphRecord(position) && typeof position["x"] === "number" && typeof position["y"] === "number" ? { position: {
+			x: position["x"],
+			y: position["y"]
+		} } : {}
+	};
+}
+/** `value` as an edge, or `undefined` when its ends are missing. */
+function edgeOf(value) {
+	if (!isGraphRecord(value)) return;
+	const { id, source, target, branch } = value;
+	if (typeof source !== "string" || typeof target !== "string") return;
+	return {
+		id: typeof id === "string" ? id : `${source}->${target}`,
+		source,
+		target,
+		...branch === "true" || branch === "false" ? { branch } : {}
+	};
+}
+/** Node ids reach generated source and SQL; `validate_workflow_graph` uses the same pattern. */
+const NODE_ID = /^[A-Za-z0-9_-]{1,100}$/;
+const BRANCHING = /* @__PURE__ */ new Set(["condition", "approval"]);
+/**
+* Problems that keep `graph` from running, as messages; empty when it can.
+* Pass the step library's names to check that every step node uses one
+* (`publish` checks it again in SQL).
+*/
+function validateGraph(graph, steps) {
+	if (!isGraphRecord(graph) || !Array.isArray(graph["nodes"]) || !Array.isArray(graph["edges"])) return ["A graph has a nodes array and an edges array"];
+	const errors = [];
+	const library = steps === void 0 ? void 0 : new Set(steps);
+	const nodes = /* @__PURE__ */ new Map();
+	let triggers = 0;
+	for (const value of graph["nodes"]) {
+		const id = isGraphRecord(value) ? value["id"] : void 0;
+		if (!isGraphRecord(value) || typeof id !== "string" || !NODE_ID.test(id)) {
+			errors.push("Every node has an id of 1 to 100 letters, digits, underscores or hyphens");
+			continue;
+		}
+		if (nodes.has(id)) errors.push(`Node ${id} appears twice`);
+		const node = nodeOf(value);
+		if (node === void 0) {
+			errors.push(`Node ${id} has an unknown kind`);
+			continue;
+		}
+		nodes.set(id, node);
+		switch (node.kind) {
+			case "trigger":
+				triggers += 1;
+				break;
+			case "step":
+				if (typeof node.step !== "string" || node.step.length === 0) errors.push(`Node ${id} names no step`);
+				else if (library !== void 0 && !library.has(node.step)) errors.push(`Node ${id} uses step ${node.step}, which is not in the step library`);
+				break;
+			case "sleep":
+				if (durationMs(node.config?.["duration"]) === void 0) errors.push(`Node ${id} has no valid duration`);
+				break;
+			case "approval": break;
+			case "condition":
+				if (conditionOf(node) === void 0) errors.push(`Node ${id} has no valid condition`);
+				break;
+			default: {
+				const unknown = node.kind;
+				errors.push(`Node ${id} has an unknown kind ${String(unknown)}`);
+			}
+		}
+	}
+	if (triggers === 0) errors.push("A graph has at least one trigger node");
+	const edgeIds = /* @__PURE__ */ new Set();
+	const edges = [];
+	for (const value of graph["edges"]) {
+		const id = isGraphRecord(value) && typeof value["id"] === "string" ? value["id"] : "?";
+		if (!isGraphRecord(value) || typeof value["source"] !== "string" || typeof value["target"] !== "string" || !nodes.has(value["source"]) || !nodes.has(value["target"])) {
+			errors.push(`Edge ${id} joins a node that does not exist`);
+			continue;
+		}
+		if (edgeIds.has(id)) errors.push(`Edge ${id} appears twice`);
+		edgeIds.add(id);
+		const source = nodes.get(value["source"]);
+		const target = nodes.get(value["target"]);
+		const branch = value["branch"];
+		if (branch !== void 0) {
+			if (branch !== "true" && branch !== "false") errors.push(`Edge ${id} has a branch other than "true" or "false"`);
+			else if (source !== void 0 && !BRANCHING.has(source.kind)) errors.push(`Edge ${id} branches from a ${source.kind} node`);
+		}
+		if (target?.kind === "trigger") errors.push(`Edge ${id} leads into the trigger node`);
+		edges.push({
+			id,
+			source: value["source"],
+			target: value["target"]
+		});
+	}
+	if (errors.length === 0 && topologicalOrder({
+		nodes: [...nodes.values()],
+		edges
+	}) === void 0) errors.push("The graph has a cycle");
+	return errors;
+}
+const nodeContent = (node) => JSON.stringify([
+	node.kind,
+	node.step,
+	node.label,
+	node.config
+]);
+const edgeKey = (edge) => `${edge.source}->${edge.target}${edge.branch === void 0 ? "" : `:${edge.branch}`}`;
+/** What changed from `before` to `after`, by node id and by edge ends. */
+function diffGraphs(before, after) {
+	const old = new Map(before.nodes.map((node) => [node.id, node]));
+	const now = new Map(after.nodes.map((node) => [node.id, node]));
+	const oldEdges = new Set(before.edges.map(edgeKey));
+	const newEdges = new Set(after.edges.map(edgeKey));
+	return {
+		nodes: {
+			added: [...now.keys()].filter((id) => !old.has(id)),
+			removed: [...old.keys()].filter((id) => !now.has(id)),
+			changed: [...now.values()].filter((node) => {
+				const previous = old.get(node.id);
+				return previous !== void 0 && nodeContent(previous) !== nodeContent(node);
+			}).map((node) => node.id)
+		},
+		edges: {
+			added: [...newEdges].filter((key) => !oldEdges.has(key)),
+			removed: [...oldEdges].filter((key) => !newEdges.has(key))
+		}
+	};
+}
+/** `value` as a graph, or an empty one when it isn't shaped like one. */
+function graphOf(value) {
+	if (!isGraphRecord(value)) return {
+		nodes: [],
+		edges: []
+	};
+	const nodes = Array.isArray(value["nodes"]) ? value["nodes"] : [];
+	const edges = Array.isArray(value["edges"]) ? value["edges"] : [];
+	return {
+		nodes: nodes.flatMap((node) => nodeOf(node) ?? []),
+		edges: edges.flatMap((edge) => edgeOf(edge) ?? [])
+	};
+}
+//#endregion
+export { evaluateCondition as a, isGraphRecord as c, triggerMatches as d, triggerWhenProblem as f, durationMs as i, matchesFilter as l, conditionOf as n, filterConditionOf as o, validateGraph as p, diffGraphs as r, graphOf as s, approved as t, topologicalOrder as u };

package/dist/groups-CxonH3u5.js

@@ -0,0 +1,16 @@
+//#region src/blocks/search/groups.ts
+/** Groups matches by subject type, in the order the best match of each appears. */
+function groupHits(hits) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const hit of hits) {
+		const items = groups.get(hit.subjectType);
+		if (items === void 0) groups.set(hit.subjectType, [hit]);
+		else items.push(hit);
+	}
+	return [...groups].map(([key, items]) => ({
+		key,
+		items
+	}));
+}
+//#endregion
+export { groupHits as t };

package/dist/guards-6F2bCtQR.js

@@ -0,0 +1,12 @@
+//#region src/core/guards.ts
+/**
+* `Array.isArray` narrows `unknown` and readonly arrays to `any[]`; this keeps
+* the element type (or `unknown`).
+*/
+function isList(value) {
+	return Array.isArray(value);
+}
+/** A plain object: not null and not an array. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+export { isRecord as n, isList as t };

package/dist/h3/index.d.ts

@@ -1,4 +1,4 @@
-import { n as RouteGuardOptions } from "../refusal-DhSU2Vvr.js";
+import { n as RouteGuardOptions } from "../refusal-oD3ISM9h.js";
 import { t as Validated } from "../shared-DDSjEGDR.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 //#region src/bridges/h3.d.ts
@@ -6,7 +6,7 @@ import { AnyEntry, Contributions } from "@supabase/middleware";
 interface H3Event<Context extends object> {
   readonly req: Request;
   readonly context: Context & {
-    /** Nitro's Cloudflare presets put the bindings here. */
+    /** Where Nitro 2's Cloudflare presets put the bindings. */
     readonly cloudflare?: {
       readonly env?: unknown;
     } | undefined;
@@ -19,7 +19,11 @@ interface H3Event<Context extends object> {
   } | undefined;
 }
 interface ToH3Options<Context extends object> {
-  /** The host's env object for `getEnv`; defaults to `event.context.cloudflare.env`. */
+  /**
+   * The host's env object for `getEnv`. Defaults to the Cloudflare bindings:
+   * `event.req.runtime.cloudflare.env` (Nitro 3), then
+   * `event.context.cloudflare.env`.
+   */
   readonly env?: (event: H3Event<Context>) => unknown;
 }
 /** H3 2 middleware, typed structurally so the package does not import `h3`. */

package/dist/h3/index.js

@@ -1,5 +1,5 @@
-import { i as toResponse, n as bufferInPlace, t as around } from "../shared-CBxosKK3.js";
-import { a as routeRefusal, n as guardedLocals, t as errorResponse } from "../refusal-CeJWxmkH.js";
+import { a as toResponse, i as nitroCloudflareEnv, n as bufferInPlace, t as around } from "../shared-BmMcMoW9.js";
+import { a as routeRefusal, n as guardedLocals, t as errorResponse } from "../refusal-br4Ma9Cf.js";
 //#region src/bridges/h3.ts
 /**
 * Runs an entry array as H3 2 middleware (`app.use(...)`, Nitro and Nuxt
@@ -16,7 +16,7 @@ function toH3(entries, options = {}) {
 	const run = around(entries);
 	return (event, next) => {
 		bufferInPlace(event.req);
-		const env = options.env ? options.env(event) : event.context.cloudflare?.env;
+		const env = options.env ? options.env(event) : nitroCloudflareEnv(event.req) ?? event.context.cloudflare?.env;
 		return run(event.req, env, async (contributions) => {
 			Object.assign(event.context, contributions);
 			const value = await next();

package/dist/h3/v1/index.d.ts

@@ -1,4 +1,4 @@
-import { n as RouteGuardOptions } from "../../refusal-DhSU2Vvr.js";
+import { n as RouteGuardOptions } from "../../refusal-oD3ISM9h.js";
 import { t as Validated } from "../../shared-DDSjEGDR.js";
 import { n as NodeRequestHead, t as NodeHeaderTarget } from "../../node-headers-AO06VhqH.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";

package/dist/h3/v1/index.js

@@ -1,5 +1,5 @@
-import { a as routeRefusal, n as guardedLocals, t as errorResponse } from "../../refusal-CeJWxmkH.js";
-import { t as beforeRoute } from "../../before-route-CnR0C0Jr.js";
+import { a as routeRefusal, n as guardedLocals, t as errorResponse } from "../../refusal-br4Ma9Cf.js";
+import { t as beforeRoute } from "../../before-route-B98js9m_.js";
 import { n as headRequest, t as applyWebHeaders } from "../../node-headers-C71zNQHe.js";
 //#region src/h3/v1/index.ts
 /**