fix(workflow-edges): normalize empty-string handles in duplicate-edge check

filterUniqueWorkflowEdges compared handles with ??, so a `sourceHandle: ''`
edge wasn't recognized as a duplicate of an existing null-handle edge —
even though both get persisted as the same null value at insert time
(edge.sourceHandle || null). Falsy-coalesce in the comparison so '' and
null/undefined are treated as the same "no handle" state everywhere.
(Greptile)

Author: waleedlatif1

apps/sim/stores/workflows/workflow/store.test.ts

@@ -352,6 +352,23 @@ describe('workflow store', () => {
       expect(state.edges.some((e) => e.id === 'e2')).toBe(false)
     })
 
+    it('should treat an empty-string handle as equivalent to no handle when deduping', () => {
+      const { batchAddEdges } = useWorkflowStore.getState()
+
+      addBlock('block-1', 'starter', 'Start', { x: 0, y: 0 })
+      addBlock('block-2', 'function', 'End', { x: 200, y: 0 })
+
+      batchAddEdges([
+        { id: 'e1', source: 'block-1', target: 'block-2', sourceHandle: '' },
+        { id: 'e2', source: 'block-1', target: 'block-2' },
+      ])
+
+      const state = useWorkflowStore.getState()
+      expectEdgeCount(state, 1)
+      expect(state.edges.some((e) => e.id === 'e1')).toBe(true)
+      expect(state.edges.some((e) => e.id === 'e2')).toBe(false)
+    })
+
     it('should not add a self-loop edge', () => {
       const { batchAddEdges } = useWorkflowStore.getState()
 

packages/workflow-types/src/workflow.ts

@@ -212,15 +212,27 @@ export interface WorkflowEdgeHandles extends WorkflowEdgeEndpoints {
   targetHandle?: string | null
 }
 
+// Falsy-coalesce (not nullish-coalesce): persistence normalizes a missing
+// handle to `null` via `edge.sourceHandle || null` (see
+// apps/realtime/src/database/operations.ts), which also maps `''` to
+// `null`. Comparing with `??` would treat `''` and `null` as distinct
+// handles pre-insert while both are written as the same `null` value,
+// letting a `sourceHandle: ''` edge slip past the duplicate check.
+function normalizeWorkflowEdgeHandle(handle: string | null | undefined): string | null {
+  return handle || null
+}
+
 function isDuplicateWorkflowEdge(
   edge: WorkflowEdgeHandles,
   existing: WorkflowEdgeHandles
 ): boolean {
   return (
     edge.source === existing.source &&
-    (edge.sourceHandle ?? null) === (existing.sourceHandle ?? null) &&
+    normalizeWorkflowEdgeHandle(edge.sourceHandle) ===
+      normalizeWorkflowEdgeHandle(existing.sourceHandle) &&
     edge.target === existing.target &&
-    (edge.targetHandle ?? null) === (existing.targetHandle ?? null)
+    normalizeWorkflowEdgeHandle(edge.targetHandle) ===
+      normalizeWorkflowEdgeHandle(existing.targetHandle)
   )
 }