@fluidgrids/workflows 0.0.0-stage → 2026.1027.1

package/dist/chunk-5LUIDMF4.js

@@ -0,0 +1,42 @@
+// src/ir/layout.ts
+var LAYOUT_COLUMN_WIDTH = 300;
+var LAYOUT_ROW_HEIGHT = 170;
+function autoLayout(nodeIds, edges) {
+  const depth = /* @__PURE__ */ new Map();
+  const roots = nodeIds.filter((id) => !edges.some((edge) => edge.target === id));
+  const queue = [...roots];
+  for (const id of queue) depth.set(id, 0);
+  const guardLimit = nodeIds.length * nodeIds.length + 1;
+  for (let guard = 0; queue.length > 0 && guard < guardLimit; guard++) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    const currentDepth = depth.get(current) ?? 0;
+    for (const edge of edges) {
+      if (edge.source !== current) continue;
+      const next = currentDepth + 1;
+      if (next > (depth.get(edge.target) ?? -1) && next < nodeIds.length) {
+        depth.set(edge.target, next);
+        queue.push(edge.target);
+      }
+    }
+  }
+  const maxDepth = Math.max(0, ...depth.values());
+  const columns = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    const column = depth.get(id) ?? maxDepth + 1;
+    columns.set(column, [...columns.get(column) ?? [], id]);
+  }
+  const positions = /* @__PURE__ */ new Map();
+  for (const [column, ids] of columns) {
+    ids.forEach((id, row) => {
+      positions.set(id, {
+        x: column * LAYOUT_COLUMN_WIDTH,
+        // `+ 0` turns the -0 Math.round can return into 0, so JSON never sees -0.
+        y: Math.round((row - (ids.length - 1) / 2) * LAYOUT_ROW_HEIGHT) + 0
+      });
+    });
+  }
+  return positions;
+}
+
+export { LAYOUT_COLUMN_WIDTH, LAYOUT_ROW_HEIGHT, autoLayout };

package/dist/chunk-6AIAC2FP.cjs

@@ -0,0 +1,185 @@
+'use strict';
+
+var chunkE3APHA6O_cjs = require('./chunk-E3APHA6O.cjs');
+
+// src/builder/refs.ts
+var REF_MODEL = /* @__PURE__ */ Symbol.for("fluidgrids.workflows.ref");
+var PREDICATE = /* @__PURE__ */ Symbol.for("fluidgrids.workflows.predicate");
+var PREDICATE_OPERATORS = {
+  eq: { operator: "==", unary: false },
+  neq: { operator: "!=", unary: false },
+  gt: { operator: ">", unary: false },
+  gte: { operator: ">=", unary: false },
+  lt: { operator: "<", unary: false },
+  lte: { operator: "<=", unary: false },
+  contains: { operator: "contains", unary: false },
+  notContains: { operator: "notContains", unary: false },
+  startsWith: { operator: "startsWith", unary: false },
+  endsWith: { operator: "endsWith", unary: false },
+  matches: { operator: "regex", unary: false },
+  hasProperty: { operator: "hasProperty", unary: false },
+  isEmpty: { operator: "isEmpty", unary: true },
+  isNotEmpty: { operator: "isNotEmpty", unary: true },
+  isNull: { operator: "isNull", unary: true },
+  isNotNull: { operator: "isNotNull", unary: true },
+  isTrue: { operator: "isTrue", unary: true },
+  isFalse: { operator: "isFalse", unary: true }
+};
+var RESERVED_REF_KEYS = /* @__PURE__ */ new Set([
+  "then",
+  "toJSON",
+  "toString",
+  "valueOf"
+]);
+var BuilderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BuilderError";
+  }
+};
+function isRuleValue(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function conditionField(ref) {
+  const segments = ref.path.map((segment) => {
+    const text = segment.kind === "index" ? String(segment.index) : segment.key;
+    if (text === "" || text.includes(".")) {
+      throw new BuilderError(
+        `A condition cannot address the key "${text}" (condition fields are dot-separated); use a raw condition tree`
+      );
+    }
+    return text;
+  });
+  switch (ref.root.kind) {
+    case "node":
+      if (ref.root.nodeId.includes(".")) {
+        throw new BuilderError(
+          `A condition cannot address node "${ref.root.nodeId}"; its id contains a dot`
+        );
+      }
+      return ["WorkflowState", ref.root.nodeId, ...segments].join(".");
+    case "json":
+      return ["output", ...segments].join(".");
+    default:
+      throw new BuilderError(
+        `A condition can compare node outputs and $json only, not $${ref.root.kind}; use an expression`
+      );
+  }
+}
+function makePredicate(target, operator, args, unary) {
+  const rule = { type: "rule", field: conditionField(target), operator };
+  if (!unary) {
+    if (args.length < 1 || !isRuleValue(args[0])) {
+      throw new BuilderError(
+        `The "${operator}" comparison needs a string, number, boolean or null value`
+      );
+    }
+    rule.value = args[0];
+  } else if (args.length > 0) {
+    throw new BuilderError(`The "${operator}" comparison takes no value`);
+  }
+  return { [PREDICATE]: rule };
+}
+function callOnRef(model, args) {
+  const last = model.path[model.path.length - 1];
+  if (last?.kind !== "key") {
+    throw new BuilderError("A reference is not a function; call a comparison such as .gte(500)");
+  }
+  const parent = { root: model.root, path: model.path.slice(0, -1) };
+  if (last.key === "is") {
+    const [operator, ...rest] = args;
+    if (typeof operator !== "string" || operator === "") {
+      throw new BuilderError(".is(operator, value) needs an operator name");
+    }
+    return makePredicate(parent, operator, rest, rest.length === 0);
+  }
+  const known = PREDICATE_OPERATORS[last.key];
+  if (!known) {
+    throw new BuilderError(`"${last.key}" is not a comparison; references are data, not functions`);
+  }
+  return makePredicate(parent, known.operator, args, known.unary);
+}
+function makeRef(root, path = []) {
+  const model = { root, path };
+  const render = () => chunkE3APHA6O_cjs.formatRefTemplate(model);
+  const target = function fluidgridsRef() {
+    return void 0;
+  };
+  const handler = {
+    get(_target, property) {
+      if (property === REF_MODEL) return model;
+      if (property === Symbol.toPrimitive) return render;
+      if (typeof property === "symbol") return void 0;
+      if (property === "then") return void 0;
+      if (property === "toJSON" || property === "toString" || property === "valueOf") return render;
+      return makeRef(root, [...path, chunkE3APHA6O_cjs.segmentFromKey(property)]);
+    },
+    apply(_target, _thisArg, args) {
+      return callOnRef(model, args);
+    },
+    has(_target, property) {
+      return property === REF_MODEL;
+    },
+    set() {
+      throw new BuilderError("References are read-only");
+    }
+  };
+  return new Proxy(target, handler);
+}
+function refModelOf(value) {
+  if ((typeof value === "function" || typeof value === "object") && value !== null && REF_MODEL in value) {
+    const model = value[REF_MODEL];
+    return model;
+  }
+  return void 0;
+}
+function isPredicate(value) {
+  return typeof value === "object" && value !== null && PREDICATE in value;
+}
+function predicateTree(predicate) {
+  return predicate[PREDICATE];
+}
+function group(combinator, predicates) {
+  if (predicates.length === 0)
+    throw new BuilderError(`${combinator.toLowerCase()}() needs at least one condition`);
+  for (const predicate of predicates) {
+    if (!isPredicate(predicate))
+      throw new BuilderError(`${combinator.toLowerCase()}() takes conditions only`);
+  }
+  return { [PREDICATE]: { type: "group", combinator, children: predicates.map(predicateTree) } };
+}
+function and(...predicates) {
+  return group("AND", predicates);
+}
+function or(...predicates) {
+  return group("OR", predicates);
+}
+function conditionTreeOf(predicate) {
+  const tree = predicateTree(predicate);
+  return tree.type === "group" ? tree : { type: "group", combinator: "AND", children: [tree] };
+}
+function expr(strings, ...values) {
+  let out = strings[0] ?? "";
+  values.forEach((value, index) => {
+    const model = refModelOf(value);
+    if (model) out += chunkE3APHA6O_cjs.formatRefTemplate(model);
+    else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      out += String(value);
+    } else {
+      throw new BuilderError("expr`\u2026` interpolates references, strings, numbers and booleans only");
+    }
+    out += strings[index + 1] ?? "";
+  });
+  return out;
+}
+
+exports.BuilderError = BuilderError;
+exports.PREDICATE_OPERATORS = PREDICATE_OPERATORS;
+exports.RESERVED_REF_KEYS = RESERVED_REF_KEYS;
+exports.and = and;
+exports.conditionTreeOf = conditionTreeOf;
+exports.expr = expr;
+exports.isPredicate = isPredicate;
+exports.makeRef = makeRef;
+exports.or = or;
+exports.refModelOf = refModelOf;

package/dist/chunk-6BEW4QD6.js

@@ -0,0 +1,95 @@
+import { isRecord, setOwn } from './chunk-UJNHTS6D.js';
+
+// src/ir/manifest.ts
+function operationsOf(manifest) {
+  const operations = Array.isArray(manifest.operations) ? manifest.operations : manifest.operations.operations;
+  return Array.isArray(operations) ? operations.filter((operation) => isRecord(operation) && typeof operation.name === "string") : [];
+}
+function isTriggerOperation(operation) {
+  if (typeof operation.role === "string") return operation.role.toLowerCase() === "trigger";
+  return operation.type === "trigger" || operation.type === "subscription";
+}
+function fieldOf(value) {
+  if (typeof value === "string") return { type: value };
+  return isRecord(value) ? value : {};
+}
+function fieldSchema(value) {
+  const field = fieldOf(value);
+  const description = typeof field.description === "string" ? { description: field.description } : {};
+  const choices = Array.isArray(field.enum) ? field.enum : Array.isArray(field.options) ? field.options : void 0;
+  if (choices && choices.every((choice) => typeof choice === "string")) {
+    return { enum: choices, ...description };
+  }
+  if (field.format === "binary") {
+    return {
+      type: "object",
+      description: field.description ?? "File reference",
+      properties: { fileId: { type: "string" } }
+    };
+  }
+  switch (field.type) {
+    case "string":
+    case "code":
+    case "workflow":
+    case "time":
+      return { type: "string", ...description };
+    case "date":
+    case "datetime":
+      return { type: "string", format: "date-time", ...description };
+    case "integer":
+      return { type: "integer", ...description };
+    case "number":
+      return { type: "number", ...description };
+    case "boolean":
+      return { type: "boolean", ...description };
+    case "array": {
+      const items = field.items !== void 0 ? { items: fieldSchema(field.items) } : {};
+      return { type: "array", ...items, ...description };
+    }
+    case "object": {
+      if (isRecord(field.properties)) {
+        const properties = {};
+        for (const [name, child] of Object.entries(field.properties))
+          setOwn(properties, name, fieldSchema(child));
+        return { type: "object", properties, ...description };
+      }
+      return { type: "object", ...description };
+    }
+    default:
+      return { ...description };
+  }
+}
+function fieldsSchema(fields) {
+  const properties = {};
+  const required = [];
+  for (const [name, field] of Object.entries(fields ?? {})) {
+    setOwn(properties, name, fieldSchema(field));
+    if (fieldOf(field).required === true) required.push(name);
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function findManifest(manifests, nodeType) {
+  const candidates = manifests.filter((manifest) => manifest.nodeType === nodeType);
+  return candidates.sort((a, b) => compareVersions(b.nodeVersion, a.nodeVersion))[0];
+}
+function compareVersions(left, right) {
+  const a = (left ?? "").split(".");
+  const b = (right ?? "").split(".");
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] ?? "";
+    const y = b[i] ?? "";
+    const nx = Number(x);
+    const ny = Number(y);
+    if (x !== y) {
+      if (Number.isFinite(nx) && Number.isFinite(ny) && x !== "" && y !== "") return nx - ny;
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+export { compareVersions, fieldSchema, fieldsSchema, findManifest, isTriggerOperation, operationsOf };

package/dist/chunk-6U446SKY.js

@@ -0,0 +1,263 @@
+import { autoLayout } from './chunk-5LUIDMF4.js';
+import { sha256Tagged, canonicalJson } from './chunk-IHKXLG6I.js';
+import { isRecord, cloneJson, deepEqual, setOwn } from './chunk-UJNHTS6D.js';
+
+// src/ir/node-types.ts
+var EXECUTOR_INTERNAL_TYPES = /* @__PURE__ */ new Set([
+  "internal:if",
+  "internal:switch",
+  "internal:loop",
+  "internal:merge",
+  "internal:set",
+  "internal:filter",
+  "internal:aggregate",
+  "internal:wait",
+  "internal:noop",
+  "internal:code",
+  "internal:http",
+  "internal:transform",
+  "internal:validate",
+  "internal:log",
+  "internal:error",
+  "internal:subworkflow",
+  "internal:compare-datasets",
+  "internal:split-out",
+  "internal:limit",
+  "internal:dedupe",
+  "internal:sort",
+  "internal:datatable",
+  "internal:respond-to-webhook",
+  "internal:send-and-wait",
+  "if",
+  "switch",
+  "loop",
+  "merge",
+  "set",
+  "filter",
+  "aggregate",
+  "wait",
+  "noop",
+  "code",
+  "http",
+  "transform",
+  "validate",
+  "log",
+  "error",
+  "subworkflow"
+]);
+var CODE_WORKFLOW_NODE_TYPE = "internal:code-workflow";
+var WAIT_FOR_SIGNAL_NODE_TYPE = "internal:wait-for-signal";
+var V2_NODE_TYPES = /* @__PURE__ */ new Set([
+  CODE_WORKFLOW_NODE_TYPE,
+  WAIT_FOR_SIGNAL_NODE_TYPE
+]);
+var INTERNAL_TRIGGER_TYPES = /* @__PURE__ */ new Set([
+  "internal:api",
+  "internal:schedule",
+  "internal:webhook",
+  "internal:form",
+  "internal:error-trigger",
+  "internal:workflow-call",
+  "internal:rss-feed",
+  "internal:http-poll",
+  "internal:database-poll",
+  "internal:email-imap",
+  "internal:file-upload",
+  "internal:record-change",
+  "internal:state-change"
+]);
+function usesMergedParameters(type) {
+  const lower = type.toLowerCase();
+  return EXECUTOR_INTERNAL_TYPES.has(lower) || V2_NODE_TYPES.has(lower);
+}
+
+// src/ir/normalize.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value !== "";
+}
+function firstTruthy(...values) {
+  for (const value of values) if (value) return value;
+  return void 0;
+}
+function readPosition(value) {
+  if (!isRecord(value)) return void 0;
+  const { x, y } = value;
+  return typeof x === "number" && typeof y === "number" && Number.isFinite(x) && Number.isFinite(y) ? { x, y } : void 0;
+}
+function removeIfEmpty(parent, key) {
+  const value = parent[key];
+  if (isRecord(value) && Object.keys(value).length === 0) delete parent[key];
+}
+function normalizeLabel(node, data) {
+  if (node["label"] === void 0 && typeof data["label"] === "string")
+    node["label"] = data["label"];
+  if (data["label"] !== void 0 && deepEqual(data["label"], node["label"])) delete data["label"];
+}
+function normalizeOperation(node, data) {
+  if (!isNonEmptyString(node["operation_name"]) && isNonEmptyString(data["operation_name"])) {
+    node["operation_name"] = data["operation_name"];
+  }
+}
+function normalizeVersion(node, data, merged) {
+  if (merged) return;
+  const effective = firstTruthy(data["version"], node["version"]);
+  if (typeof effective === "string") node["version"] = effective;
+  if (data["nodeVersion"] !== void 0 && deepEqual(data["nodeVersion"], node["version"])) {
+    delete data["nodeVersion"];
+  }
+}
+function normalizeExternalState(node, data) {
+  const args = isRecord(node["args"]) ? node["args"] : void 0;
+  const dataArgs = isRecord(data["args"]) ? data["args"] : void 0;
+  const effective = firstTruthy(args?.["state"], dataArgs?.["state"]);
+  if (effective !== void 0 && args?.["state"] === void 0) {
+    const nextArgs = args ?? {};
+    nextArgs["state"] = effective;
+    node["args"] = nextArgs;
+  }
+  const rootState = isRecord(node["args"]) ? node["args"]["state"] : void 0;
+  if (dataArgs && dataArgs["state"] !== void 0 && deepEqual(dataArgs["state"], rootState)) {
+    delete dataArgs["state"];
+  }
+}
+function normalizeMergedState(node, data) {
+  const args = isRecord(node["args"]) ? node["args"] : {};
+  const dataArgs = isRecord(data["args"]) ? data["args"] : void 0;
+  const config = isRecord(node["config"]) ? node["config"] : void 0;
+  const dataState = isRecord(dataArgs?.["state"]) ? dataArgs["state"] : void 0;
+  const rootState = isRecord(args["state"]) ? args["state"] : void 0;
+  if (config === void 0 && dataState === void 0) return;
+  args["state"] = { ...config, ...dataState, ...rootState };
+  node["args"] = args;
+  if (config !== void 0) delete node["config"];
+  if (dataArgs && dataState !== void 0) delete dataArgs["state"];
+}
+function normalizeConnections(node, data) {
+  const dataArgs = isRecord(data["args"]) ? data["args"] : void 0;
+  if (!dataArgs) return;
+  for (const key of ["connections", "credentials"]) {
+    const args = isRecord(node["args"]) ? node["args"] : void 0;
+    if (!args?.[key] && dataArgs[key]) {
+      const nextArgs = args ?? {};
+      nextArgs[key] = dataArgs[key];
+      node["args"] = nextArgs;
+    }
+    const rootValue = isRecord(node["args"]) ? node["args"][key] : void 0;
+    if (dataArgs[key] !== void 0 && deepEqual(dataArgs[key], rootValue)) delete dataArgs[key];
+  }
+}
+function normalizeContext(node, data) {
+  const dataArgs = isRecord(data["args"]) ? data["args"] : void 0;
+  const args = isRecord(node["args"]) ? node["args"] : void 0;
+  if (!dataArgs || dataArgs["context"] === void 0) return;
+  if (args && deepEqual(dataArgs["context"], args["context"])) delete dataArgs["context"];
+}
+function normalizeErrorConfig(node, data) {
+  const dataArgs = isRecord(data["args"]) ? data["args"] : void 0;
+  const dataState = isRecord(dataArgs?.["state"]) ? dataArgs["state"] : void 0;
+  const effective = node["errorConfig"] ?? data["errorConfig"] ?? dataState?.["errorConfig"];
+  if (effective !== void 0 && effective !== null) node["errorConfig"] = effective;
+  else if (node["errorConfig"] === null) delete node["errorConfig"];
+  if (data["errorConfig"] !== void 0 && deepEqual(data["errorConfig"], node["errorConfig"])) {
+    delete data["errorConfig"];
+  }
+}
+function normalizeExecutionSettings(node, data) {
+  const root = isRecord(node["executionSettings"]) ? node["executionSettings"] : void 0;
+  const mirror = isRecord(data["executionSettings"]) ? data["executionSettings"] : void 0;
+  if (!root && !mirror) return;
+  const merged = { ...root };
+  for (const [key, value] of Object.entries(mirror ?? {}))
+    if (!Object.hasOwn(merged, key)) setOwn(merged, key, value);
+  if (root?.["executeOnce"] === true || mirror?.["executeOnce"] === true)
+    merged["executeOnce"] = true;
+  if (mirror && Object.hasOwn(mirror, "runOn")) {
+    merged["runOn"] = mirror["runOn"];
+    data["executionSettings"] = { runOn: mirror["runOn"] };
+  } else {
+    if (mirror) delete data["executionSettings"];
+  }
+  node["executionSettings"] = merged;
+}
+function normalizeDisabled(node, data) {
+  if (node["disabled"] === true || data["disabled"] === true) node["disabled"] = true;
+  delete data["disabled"];
+}
+function normalizeNode(raw) {
+  if (!isRecord(raw)) return raw;
+  const node = cloneJson(raw);
+  const type = typeof node["type"] === "string" ? node["type"] : "";
+  const merged = usesMergedParameters(type);
+  const data = isRecord(node["data"]) ? node["data"] : {};
+  normalizeLabel(node, data);
+  normalizeOperation(node, data);
+  normalizeVersion(node, data, merged);
+  normalizeErrorConfig(node, data);
+  if (merged) normalizeMergedState(node, data);
+  else normalizeExternalState(node, data);
+  normalizeConnections(node, data);
+  normalizeContext(node, data);
+  normalizeExecutionSettings(node, data);
+  normalizeDisabled(node, data);
+  if (isRecord(data["args"])) removeIfEmpty(data, "args");
+  if (Object.keys(data).length === 0) delete node["data"];
+  else node["data"] = data;
+  return node;
+}
+function normalizeDefinition(definition) {
+  if (!isRecord(definition) || !isRecord(definition["data"])) return definition;
+  const doc = cloneJson(definition);
+  const data = doc["data"];
+  const rawNodes = Array.isArray(data["nodes"]) ? data["nodes"] : [];
+  const nodes = rawNodes.map(normalizeNode);
+  data["nodes"] = nodes;
+  const edges = Array.isArray(data["edges"]) ? data["edges"].filter(isRecord) : [];
+  const ids = nodes.flatMap(
+    (node) => isRecord(node) && typeof node["id"] === "string" ? [node["id"]] : []
+  );
+  const missing = nodes.some(
+    (node) => isRecord(node) && readPosition(node["position"]) === void 0
+  );
+  if (missing) {
+    const meta = isRecord(doc["meta"]) ? doc["meta"] : void 0;
+    const metaLayout = isRecord(meta?.["layout"]) ? meta["layout"] : void 0;
+    const computed = autoLayout(
+      ids,
+      edges.flatMap(
+        (edge) => typeof edge["source"] === "string" && typeof edge["target"] === "string" ? [{ source: edge["source"], target: edge["target"] }] : []
+      )
+    );
+    for (const node of nodes) {
+      if (!isRecord(node) || typeof node["id"] !== "string") continue;
+      if (readPosition(node["position"]) !== void 0) continue;
+      const fromMeta = readPosition(metaLayout?.[node["id"]]);
+      const position = fromMeta ?? computed.get(node["id"]);
+      if (position) node["position"] = { x: position.x, y: position.y };
+    }
+  }
+  doc["schemaVersion"] = 2;
+  return doc;
+}
+
+// src/ir/hash.ts
+function hashedProjection(definition) {
+  const normalized = normalizeDefinition(definition);
+  if (!isRecord(normalized)) return normalized;
+  const copy = { ...normalized };
+  delete copy["authoring"];
+  return copy;
+}
+function irHash(definition) {
+  return sha256Tagged(canonicalJson(hashedProjection(definition)));
+}
+function sourceHash(files) {
+  const entries = [...files].sort(
+    (a, b) => a.path === b.path ? a.content < b.content ? -1 : a.content > b.content ? 1 : 0 : a.path < b.path ? -1 : 1
+  ).map((file) => [file.path, file.content]);
+  return sha256Tagged(canonicalJson(entries));
+}
+function buildIdOf(bundle) {
+  return sha256Tagged(bundle);
+}
+
+export { CODE_WORKFLOW_NODE_TYPE, INTERNAL_TRIGGER_TYPES, V2_NODE_TYPES, WAIT_FOR_SIGNAL_NODE_TYPE, buildIdOf, hashedProjection, irHash, normalizeDefinition, sourceHash, usesMergedParameters };