Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

3.2 KB
Raw Blame
import type { CustomNode } from "@/app/(platform)/build/components/FlowEditor/nodes/CustomNode/CustomNode";
import type { CustomEdge } from "@/app/(platform)/build/components/FlowEditor/edges/CustomEdge";
import isEqual from "lodash/isEqual";

export function cleanNode(node: CustomNode) {
  return {
    id: node.id,
    // Note: position is intentionally excluded to prevent draft saves when dragging nodes
    data: {
      hardcodedValues: node.data.hardcodedValues,
      title: node.data.title,
      block_id: node.data.block_id,
      metadata: node.data.metadata,
    },
  };
}

export function cleanEdge(edge: CustomEdge) {
  return {
    id: edge.id,
    source: edge.source,
    target: edge.target,
    sourceHandle: edge.sourceHandle,
    targetHandle: edge.targetHandle,
  };
}

export function cleanNodes(nodes: CustomNode[]) {
  return nodes.map(cleanNode);
}

export function cleanEdges(edges: CustomEdge[]) {
  return edges.map(cleanEdge);
}

export interface DraftDiff {
  nodes: {
    added: number;
    removed: number;
    modified: number;
  };
  edges: {
    added: number;
    removed: number;
    modified: number;
  };
}

/**
 * Calculate the diff between draft and current nodes/edges.
 * - Added: items in draft but not in current (will be restored)
 * - Removed: items in current but not in draft (will be removed if draft is loaded)
 * - Modified: items with same ID but different content
 */
export function calculateDraftDiff(
  draftNodes: CustomNode[],
  draftEdges: CustomEdge[],
  currentNodes: CustomNode[],
  currentEdges: CustomEdge[],
): DraftDiff {
  const draftNodeIds = new Set(draftNodes.map((n) => n.id));
  const currentNodeIds = new Set(currentNodes.map((n) => n.id));
  const draftEdgeIds = new Set(draftEdges.map((e) => e.id));
  const currentEdgeIds = new Set(currentEdges.map((e) => e.id));

  // Nodes diff
  const nodesAdded = draftNodes.filter((n) => !currentNodeIds.has(n.id)).length;
  const nodesRemoved = currentNodes.filter(
    (n) => !draftNodeIds.has(n.id),
  ).length;

  // Modified nodes: same ID but different content
  const draftNodeMap = new Map(draftNodes.map((n) => [n.id, cleanNode(n)]));
  const currentNodeMap = new Map(currentNodes.map((n) => [n.id, cleanNode(n)]));
  let nodesModified = 0;
  for (const [id, draftClean] of draftNodeMap) {
    const currentClean = currentNodeMap.get(id);
    if (currentClean && !isEqual(draftClean, currentClean)) {
      nodesModified++;
    }
  }

  // Edges diff
  const edgesAdded = draftEdges.filter((e) => !currentEdgeIds.has(e.id)).length;
  const edgesRemoved = currentEdges.filter(
    (e) => !draftEdgeIds.has(e.id),
  ).length;

  // Modified edges: same ID but different content
  const draftEdgeMap = new Map(draftEdges.map((e) => [e.id, cleanEdge(e)]));
  const currentEdgeMap = new Map(currentEdges.map((e) => [e.id, cleanEdge(e)]));
  let edgesModified = 0;
  for (const [id, draftClean] of draftEdgeMap) {
    const currentClean = currentEdgeMap.get(id);
    if (currentClean && !isEqual(draftClean, currentClean)) {
      edgesModified++;
    }
  }

  return {
    nodes: {
      added: nodesAdded,
      removed: nodesRemoved,
      modified: nodesModified,
    },
    edges: {
      added: edgesAdded,
      removed: edgesRemoved,
      modified: edgesModified,
    },
  };
}