@pipefy/pipefy-process-coder 0.1.0 → 0.1.1

package/dist/diff/flow.js

@@ -0,0 +1,258 @@
+import { canonicalString } from "../util/json.js";
+import { flowIdOf, isNewFlow } from "../workspace/flows.js";
+/**
+ * Keys that never carry intent and must not produce a change.
+ *
+ * `sampleData` is generated by testing a step, `lastUpdatedDate` moves on every
+ * write, and the server-minted ids move whenever a version is created. Comparing
+ * them would make every flow permanently dirty.
+ */
+const VOLATILE_NODE_KEYS = new Set(['sampleData', 'lastUpdatedDate']);
+const VOLATILE_FLOW_KEYS = new Set([
+    'created',
+    'updated',
+    'publishedVersionId',
+    'operationStatus',
+    'timeSavedPerRun',
+    'createdBy',
+    'updatedBy',
+    'ownerId',
+    'externalId',
+    'id',
+    'flowId',
+    'projectId',
+    'templateId',
+    'backupFiles',
+    /**
+     * Derived by the API from the inline `{{connections[...]}}` references rather
+     * than supplied, so it is an echo of the nodes and never an intent of its own.
+     */
+    'connectionIds',
+    'state',
+]);
+const comparableNode = (n) => {
+    const out = {};
+    for (const [k, v] of Object.entries(n)) {
+        if (VOLATILE_NODE_KEYS.has(k))
+            continue;
+        if (k.startsWith('_'))
+            continue; // link metadata is compared separately, as structure
+        if (k === 'settings' && v && typeof v === 'object') {
+            const s = {};
+            for (const [sk, sv] of Object.entries(v)) {
+                if (VOLATILE_NODE_KEYS.has(sk))
+                    continue;
+                s[sk] = sv;
+            }
+            out[k] = s;
+            continue;
+        }
+        out[k] = v;
+    }
+    return out;
+};
+const nodeDeltas = (before, after) => {
+    const a = comparableNode(before);
+    const b = comparableNode(after);
+    const keys = [...new Set([...Object.keys(a), ...Object.keys(b)])].sort();
+    const out = [];
+    for (const k of keys) {
+        if (canonicalString(a[k]) !== canonicalString(b[k]))
+            out.push({ key: k, before: a[k], after: b[k] });
+    }
+    // Structure: a node whose place in the chain moved is a change even when its
+    // settings are identical.
+    for (const link of ['_nextAction', '_firstLoopAction', '_children']) {
+        if (canonicalString(before[link]) !== canonicalString(after[link])) {
+            out.push({ key: link, before: before[link], after: after[link] });
+        }
+    }
+    return out;
+};
+const flowLabel = (tree) => String(tree.version['displayName'] ?? flowIdOf(tree) ?? 'flow');
+/** Match flows by id, then by display name for one the workspace is creating. */
+const matchFlows = (before, after) => {
+    const pairs = [];
+    const added = [];
+    const removed = [...before];
+    for (const a of after) {
+        const id = flowIdOf(a);
+        let hitAt = id ? removed.findIndex((b) => flowIdOf(b) === id) : -1;
+        if (hitAt < 0 && isNewFlow(a)) {
+            hitAt = removed.findIndex((b) => flowLabel(b) === flowLabel(a));
+        }
+        if (hitAt >= 0) {
+            pairs.push([removed[hitAt], a]);
+            removed.splice(hitAt, 1);
+        }
+        else {
+            added.push(a);
+        }
+    }
+    return { pairs, added, removed };
+};
+export const diffFlows = (before, after) => {
+    const changes = [];
+    const skipped = [];
+    if (!before || !after) {
+        return { changes, skipped: [{ reason: 'one side has no flows section, so flows are not diffed' }] };
+    }
+    if (before.meta.coverage !== 'complete' || after.meta.coverage !== 'complete') {
+        /**
+         * The whole reason coverage exists. A pipe whose iPaaS could not be reached
+         * reports zero flows, and diffing that against a workspace that has some would
+         * propose deleting every one of them.
+         */
+        return {
+            changes,
+            skipped: [
+                {
+                    reason: `flows coverage is ${before.meta.coverage}/${after.meta.coverage}, not complete — ` +
+                        'not diffed, because absence here is not evidence of absence',
+                },
+            ],
+        };
+    }
+    const { pairs, added, removed } = matchFlows(before.flows, after.flows);
+    for (const tree of added) {
+        changes.push({
+            op: 'flow.create',
+            key: `flow:new:${flowLabel(tree)}`,
+            label: `create flow "${flowLabel(tree)}" (${tree.nodes.length} nodes)`,
+            flowId: null,
+            flowName: flowLabel(tree),
+            afterFlow: tree,
+            deltas: [],
+            flags: [],
+        });
+    }
+    for (const tree of removed) {
+        changes.push({
+            op: 'flow.delete',
+            key: `flow:${flowIdOf(tree)}`,
+            label: `delete flow "${flowLabel(tree)}"`,
+            flowId: flowIdOf(tree),
+            flowName: flowLabel(tree),
+            beforeFlow: tree,
+            deltas: [],
+            flags: ['destructive'],
+        });
+    }
+    for (const [b, a] of pairs) {
+        const flowId = flowIdOf(a) ?? flowIdOf(b);
+        const name = flowLabel(a);
+        if (flowLabel(b) !== flowLabel(a)) {
+            changes.push({
+                op: 'flow.rename',
+                key: `flow:${flowId}:name`,
+                label: `rename flow "${flowLabel(b)}" → "${flowLabel(a)}"`,
+                flowId,
+                flowName: name,
+                deltas: [{ key: 'displayName', before: flowLabel(b), after: flowLabel(a) }],
+                flags: [],
+            });
+        }
+        if (String(b.flow['status'] ?? '') !== String(a.flow['status'] ?? '')) {
+            changes.push({
+                op: 'flow.status',
+                key: `flow:${flowId}:status`,
+                label: `flow "${name}" ${b.flow['status']} → ${a.flow['status']}`,
+                flowId,
+                flowName: name,
+                deltas: [{ key: 'status', before: b.flow['status'], after: a.flow['status'] }],
+                // Enabling a flow arms it against live traffic. That is never incidental.
+                flags: String(a.flow['status']) === 'ENABLED' ? ['arms-flow'] : [],
+            });
+        }
+        const beforeNodes = new Map(b.nodes.map((n) => [n.name, n]));
+        const afterNodes = new Map(a.nodes.map((n) => [n.name, n]));
+        for (const [nodeName, node] of afterNodes) {
+            const prior = beforeNodes.get(nodeName);
+            if (!prior) {
+                changes.push({
+                    op: 'node.create',
+                    key: `flow:${flowId}:node:${nodeName}`,
+                    label: `flow "${name}": add ${nodeName} [${node.type}] ${String(node['displayName'] ?? '')}`.trim(),
+                    flowId,
+                    flowName: name,
+                    nodeName,
+                    after: node,
+                    /**
+                     * The whole intended tree, not just the node: `ADD_ACTION` needs the
+                     * parent this node hangs from, and that is a property of where `node`
+                     * sits in the chain — found by scanning every node's `_nextAction` /
+                     * `_firstLoopAction` / `_children` for `nodeName` (apply/flowops.ts
+                     * `parentOf`), the same lookup a brand-new flow's build already uses.
+                     */
+                    afterFlow: a,
+                    deltas: [],
+                    flags: [],
+                });
+                continue;
+            }
+            const deltas = nodeDeltas(prior, node);
+            if (!deltas.length)
+                continue;
+            const isTrigger = nodeName === 'trigger';
+            changes.push({
+                op: isTrigger ? 'trigger.update' : 'node.update',
+                key: `flow:${flowId}:node:${nodeName}`,
+                label: `flow "${name}": ${isTrigger ? 'trigger' : nodeName} — ${deltas.map((d) => d.key).join(', ')}`,
+                flowId,
+                flowName: name,
+                nodeName,
+                before: prior,
+                after: node,
+                deltas,
+                flags: [],
+            });
+        }
+        for (const [nodeName, node] of beforeNodes) {
+            if (afterNodes.has(nodeName))
+                continue;
+            changes.push({
+                op: 'node.delete',
+                key: `flow:${flowId}:node:${nodeName}`,
+                label: `flow "${name}": delete ${nodeName} [${node.type}]`,
+                flowId,
+                flowName: name,
+                nodeName,
+                before: node,
+                deltas: [],
+                flags: ['destructive'],
+            });
+        }
+    }
+    return { changes, skipped };
+};
+export const renderFlowChanges = (cs) => {
+    const lines = [];
+    for (const s of cs.skipped)
+        lines.push(`  flows not diffed: ${s.reason}`);
+    if (!cs.changes.length) {
+        if (!cs.skipped.length)
+            lines.push('  flows: no changes');
+        return lines.join('\n');
+    }
+    const byFlow = new Map();
+    for (const c of cs.changes) {
+        const k = c.flowId ?? `new:${c.flowName}`;
+        byFlow.set(k, [...(byFlow.get(k) ?? []), c]);
+    }
+    for (const [, group] of byFlow) {
+        lines.push('');
+        lines.push(`  ${group[0]?.flowName ?? 'flow'}`);
+        for (const c of group) {
+            const mark = c.flags.includes('destructive') ? '-' : c.op.endsWith('create') ? '+' : '~';
+            lines.push(`    ${mark} ${c.label}`);
+            for (const d of c.deltas.slice(0, 6)) {
+                const short = (v) => {
+                    const s = canonicalString(v);
+                    return s.length > 90 ? `${s.slice(0, 90)}…` : s;
+                };
+                lines.push(`        ${d.key}: ${short(d.before)} -> ${short(d.after)}`);
+            }
+        }
+    }
+    return lines.join('\n');
+};