Function addNodeToStore

ts/workflow-builder/src/utils/graphOperations.ts:103–178

(store: CanvasStore, nodeDef: NodeDefinition, position?: { x: number; y: number })

/** Add a node to the store given a node definition and optional position. Returns the new node ID, or null if the node cannot be added. */
export function addNodeToStore(store: CanvasStore, nodeDef: NodeDefinition, position?: { x: number; y: number }): string | null {
  if (!canAddNode(store, nodeDef)) return null;

  const nodeId = generateId();

  // Initialize parameters with default values. Clone so object/array defaults
  // (Expression, weekdays `[]`, memory-refs `[]`) aren't shared by reference
  // across instances or with the definition itself — a shared mutable default
  // would alias on edit.
  const args: Record<string, unknown> = {};
  nodeDef.parameters.forEach((param) => {
    if (param.default !== undefined) {
      args[param.id] = structuredClone(param.default);
    }
  });

  // Seed outputs directly into args:
  //  - Static outputs: `args[out.id] = { active: true, mode: "emit", name: out.id }` (OutputBinding)
  //  - List outputs: `args[out.id] = []` (empty OutputDeclaration[] — user adds entries)
  for (const out of nodeDef.outputs ?? []) {
    if (out.type === "static") {
      args[out.id] = { active: true, mode: "emit", name: out.id };
    } else {
      args[out.id] = [];
    }
  }

  const nodeData: NodeBase = {
    id: nodeId,
    type: nodeDef.type,
    arguments: args,
  };
  if (nodeDef.type === "FunctionCall") {
    const functionDef = nodeDef as FunctionNodeDefinition;
    const functionNode = nodeData as FunctionCallNode;
    functionNode.functionInfo = functionDef.functionInfo;
    // Seed input bindings keyed by arg uid — empty expressions with the declared dataType.
    // Output bindings were already seeded above by the generic outputs[] loop since
    // buildFunctionNodeDef now emits real StaticOutput entries.
    for (const arg of functionDef.functionInfo.arguments) {
      args[paramKey(arg)] = { expression: "", references: [], dataType: arg.dataType };
    }
    // Generic seeding uses the output id as the default emit name, but for function
    // returns we want the return's variable name.
    for (const ret of functionDef.functionInfo.returns) {
      args[paramKey(ret)] = { active: true, mode: "emit" as const, name: ret.name };
    }
  }

  // Deduplicate emit binding names against existing variables on the canvas
  const existingNames = collectVariableNames(store);
  deduplicateEmitNames(nodeData as NodeData, existingNames);

  // Nudge position if another node is already nearby (avoids stacking on click-to-add)
  const currentNodes = store.getState().nodes;
  let pos = position || { x: 250, y: 100 };
  const SNAP_DISTANCE = 50;
  while (currentNodes.some((n) => Math.abs(n.position.x - pos.x) < SNAP_DISTANCE && Math.abs(n.position.y - pos.y) < SNAP_DISTANCE)) {