feat: propagate errors up subgraphs and show slot errors in subgraphs (#6963)

https://github.com/user-attachments/assets/6531879d-a8a2-420a-aaca-ee329386dd1a

┆Issue is synchronized with this [Notion
page](https://www.notion.so/PR-6963-feat-propagate-errors-up-subgraphs-and-show-slot-errors-in-subgraphs-2b76d73d3650813e8391fac0a5e6dc9b)
by [Unito](https://www.unito.io)

---------

Co-authored-by: github-actions <github-actions@github.com>

tests-ui/tests/store/executionStore.test.ts

@@ -129,3 +129,170 @@ describe('useExecutionStore - NodeLocatorId conversions', () => {
     })
   })
 })
+
+describe('useExecutionStore - Node Error Lookups', () => {
+  let store: ReturnType<typeof useExecutionStore>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    setActivePinia(createPinia())
+    store = useExecutionStore()
+  })
+
+  describe('getNodeErrors', () => {
+    it('should return undefined when no errors exist', () => {
+      const result = store.getNodeErrors('123')
+      expect(result).toBeUndefined()
+    })
+
+    it('should return node error by locator ID for root graph node', () => {
+      store.lastNodeErrors = {
+        '123': {
+          errors: [
+            {
+              type: 'validation_error',
+              message: 'Invalid input',
+              details: 'Width must be positive',
+              extra_info: { input_name: 'width' }
+            }
+          ],
+          class_type: 'TestNode',
+          dependent_outputs: []
+        }
+      }
+
+      const result = store.getNodeErrors('123')
+      expect(result).toBeDefined()
+      expect(result?.errors).toHaveLength(1)
+      expect(result?.errors[0].message).toBe('Invalid input')
+    })
+
+    it('should return node error by locator ID for subgraph node', () => {
+      const subgraphUuid = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
+      const mockSubgraph = {
+        id: subgraphUuid,
+        _nodes: []
+      }
+
+      const mockNode = {
+        id: 123,
+        isSubgraphNode: () => true,
+        subgraph: mockSubgraph
+      } as any
+
+      vi.mocked(app.graph.getNodeById).mockReturnValue(mockNode)
+
+      store.lastNodeErrors = {
+        '123:456': {
+          errors: [
+            {
+              type: 'validation_error',
+              message: 'Invalid subgraph input',
+              details: 'Missing required input',
+              extra_info: { input_name: 'image' }
+            }
+          ],
+          class_type: 'SubgraphNode',
+          dependent_outputs: []
+        }
+      }
+
+      const locatorId = `${subgraphUuid}:456`
+      const result = store.getNodeErrors(locatorId)
+      expect(result).toBeDefined()
+      expect(result?.errors[0].message).toBe('Invalid subgraph input')
+    })
+  })
+
+  describe('slotHasError', () => {
+    it('should return false when node has no errors', () => {
+      const result = store.slotHasError('123', 'width')
+      expect(result).toBe(false)
+    })
+
+    it('should return false when node has errors but slot is not mentioned', () => {
+      store.lastNodeErrors = {
+        '123': {
+          errors: [
+            {
+              type: 'validation_error',
+              message: 'Invalid input',
+              details: 'Width must be positive',
+              extra_info: { input_name: 'width' }
+            }
+          ],
+          class_type: 'TestNode',
+          dependent_outputs: []
+        }
+      }
+
+      const result = store.slotHasError('123', 'height')
+      expect(result).toBe(false)
+    })
+
+    it('should return true when slot has error', () => {
+      store.lastNodeErrors = {
+        '123': {
+          errors: [
+            {
+              type: 'validation_error',
+              message: 'Invalid input',
+              details: 'Width must be positive',
+              extra_info: { input_name: 'width' }
+            }
+          ],
+          class_type: 'TestNode',
+          dependent_outputs: []
+        }
+      }
+
+      const result = store.slotHasError('123', 'width')
+      expect(result).toBe(true)
+    })
+
+    it('should return true when multiple errors exist for the same slot', () => {
+      store.lastNodeErrors = {
+        '123': {
+          errors: [
+            {
+              type: 'validation_error',
+              message: 'Invalid input',
+              details: 'Width must be positive',
+              extra_info: { input_name: 'width' }
+            },
+            {
+              type: 'validation_error',
+              message: 'Invalid range',
+              details: 'Width must be less than 1000',
+              extra_info: { input_name: 'width' }
+            }
+          ],
+          class_type: 'TestNode',
+          dependent_outputs: []
+        }
+      }
+
+      const result = store.slotHasError('123', 'width')
+      expect(result).toBe(true)
+    })
+
+    it('should handle errors without extra_info', () => {
+      store.lastNodeErrors = {
+        '123': {
+          errors: [
+            {
+              type: 'validation_error',
+              message: 'General error',
+              details: 'Something went wrong'
+            }
+          ],
+          class_type: 'TestNode',
+          dependent_outputs: []
+        }
+      }
+
+      const result = store.slotHasError('123', 'width')
+      expect(result).toBe(false)
+    })
+  })
+})