chore: import upstream snapshot with attribution

apps/sim/executor/variables/resolvers/reference.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, it } from 'vitest'
+import { navigatePath } from './reference'
+
+describe('navigatePath', () => {
+  describe('basic property access', () => {
+    it.concurrent('should access top-level property', () => {
+      const obj = { name: 'test', value: 42 }
+      expect(navigatePath(obj, ['name'])).toBe('test')
+      expect(navigatePath(obj, ['value'])).toBe(42)
+    })
+
+    it.concurrent('should access nested properties', () => {
+      const obj = { a: { b: { c: 'deep' } } }
+      expect(navigatePath(obj, ['a', 'b', 'c'])).toBe('deep')
+    })
+
+    it.concurrent('should return entire object for empty path', () => {
+      const obj = { name: 'test' }
+      expect(navigatePath(obj, [])).toEqual(obj)
+    })
+
+    it.concurrent('should handle deeply nested objects', () => {
+      const obj = { level1: { level2: { level3: { level4: { value: 'found' } } } } }
+      expect(navigatePath(obj, ['level1', 'level2', 'level3', 'level4', 'value'])).toBe('found')
+    })
+  })
+
+  describe('array indexing', () => {
+    it.concurrent('should access array elements with numeric string index', () => {
+      const obj = { items: ['a', 'b', 'c'] }
+      expect(navigatePath(obj, ['items', '0'])).toBe('a')
+      expect(navigatePath(obj, ['items', '1'])).toBe('b')
+      expect(navigatePath(obj, ['items', '2'])).toBe('c')
+    })
+
+    it.concurrent('should access array elements with bracket notation', () => {
+      const obj = { items: [{ name: 'first' }, { name: 'second' }] }
+      expect(navigatePath(obj, ['items[0]', 'name'])).toBe('first')
+      expect(navigatePath(obj, ['items[1]', 'name'])).toBe('second')
+    })
+
+    it.concurrent('should access nested arrays', () => {
+      const obj = {
+        matrix: [
+          [1, 2],
+          [3, 4],
+          [5, 6],
+        ],
+      }
+      expect(navigatePath(obj, ['matrix', '0', '0'])).toBe(1)
+      expect(navigatePath(obj, ['matrix', '1', '1'])).toBe(4)
+      expect(navigatePath(obj, ['matrix', '2', '0'])).toBe(5)
+    })
+
+    it.concurrent('should access array element properties', () => {
+      const obj = {
+        users: [
+          { id: 1, name: 'Alice' },
+          { id: 2, name: 'Bob' },
+        ],
+      }
+      expect(navigatePath(obj, ['users', '0', 'name'])).toBe('Alice')
+      expect(navigatePath(obj, ['users', '1', 'id'])).toBe(2)
+    })
+  })
+
+  describe('edge cases', () => {
+    it.concurrent('should return undefined for non-existent property', () => {
+      const obj = { name: 'test' }
+      expect(navigatePath(obj, ['nonexistent'])).toBeUndefined()
+    })
+
+    it.concurrent('should return undefined for path through null', () => {
+      const obj = { data: null }
+      expect(navigatePath(obj, ['data', 'value'])).toBeUndefined()
+    })
+
+    it.concurrent('should return undefined for path through undefined', () => {
+      const obj: Record<string, any> = { data: undefined }
+      expect(navigatePath(obj, ['data', 'value'])).toBeUndefined()
+    })
+
+    it.concurrent('should return null when accessing null property', () => {
+      const obj = { value: null }
+      expect(navigatePath(obj, ['value'])).toBeNull()
+    })
+
+    it.concurrent('should return undefined for out of bounds array access', () => {
+      const obj = { items: ['a', 'b'] }
+      expect(navigatePath(obj, ['items', '10'])).toBeUndefined()
+    })
+
+    it.concurrent('should return undefined when accessing array property on non-array', () => {
+      const obj = { data: 'string' }
+      expect(navigatePath(obj, ['data', '0'])).toBeUndefined()
+    })
+
+    it.concurrent('should handle empty object', () => {
+      const obj = {}
+      expect(navigatePath(obj, ['any'])).toBeUndefined()
+    })
+
+    it.concurrent('should handle object with empty string key', () => {
+      const obj = { '': 'empty key value' }
+      expect(navigatePath(obj, [''])).toBe('empty key value')
+    })
+  })
+
+  describe('mixed access patterns', () => {
+    it.concurrent('should handle complex nested structures', () => {
+      const obj = {
+        users: [
+          {
+            name: 'Alice',
+            addresses: [
+              { city: 'NYC', zip: '10001' },
+              { city: 'LA', zip: '90001' },
+            ],
+          },
+          {
+            name: 'Bob',
+            addresses: [{ city: 'Chicago', zip: '60601' }],
+          },
+        ],
+      }
+
+      expect(navigatePath(obj, ['users', '0', 'name'])).toBe('Alice')
+      expect(navigatePath(obj, ['users', '0', 'addresses', '1', 'city'])).toBe('LA')
+      expect(navigatePath(obj, ['users', '1', 'addresses', '0', 'zip'])).toBe('60601')
+    })
+
+    it.concurrent('should return undefined for numeric keys on non-array objects', () => {
+      // navigatePath treats numeric strings as array indices only for arrays
+      // For objects with numeric string keys, the numeric check takes precedence
+      // and returns undefined since the object is not an array
+      const obj = { data: { '0': 'zero', '1': 'one' } }
+      expect(navigatePath(obj, ['data', '0'])).toBeUndefined()
+      expect(navigatePath(obj, ['data', '1'])).toBeUndefined()
+    })
+
+    it.concurrent('should access non-numeric string keys', () => {
+      const obj = { data: { first: 'value1', second: 'value2' } }
+      expect(navigatePath(obj, ['data', 'first'])).toBe('value1')
+      expect(navigatePath(obj, ['data', 'second'])).toBe('value2')
+    })
+  })
+
+  describe('special value types', () => {
+    it.concurrent('should return boolean values', () => {
+      const obj = { active: true, disabled: false }
+      expect(navigatePath(obj, ['active'])).toBe(true)
+      expect(navigatePath(obj, ['disabled'])).toBe(false)
+    })
+
+    it.concurrent('should return numeric values including zero', () => {
+      const obj = { count: 0, value: -5, decimal: 3.14 }
+      expect(navigatePath(obj, ['count'])).toBe(0)
+      expect(navigatePath(obj, ['value'])).toBe(-5)
+      expect(navigatePath(obj, ['decimal'])).toBe(3.14)
+    })
+
+    it.concurrent('should return empty string', () => {
+      const obj = { text: '' }
+      expect(navigatePath(obj, ['text'])).toBe('')
+    })
+
+    it.concurrent('should return empty array', () => {
+      const obj = { items: [] }
+      expect(navigatePath(obj, ['items'])).toEqual([])
+    })
+
+    it.concurrent('should return function values', () => {
+      const fn = () => 'test'
+      const obj = { callback: fn }
+      expect(navigatePath(obj, ['callback'])).toBe(fn)
+    })
+  })
+
+  describe('large array manifests', () => {
+    it('returns undefined for sync index access when the chunk is not cached', () => {
+      const manifest = {
+        __simLargeArrayManifest: true,
+        version: 2,
+        kind: 'array',
+        totalCount: 1,
+        chunkCount: 1,
+        byteSize: 16,
+        chunks: [
+          {
+            ref: {
+              __simLargeValueRef: true,
+              version: 1,
+              id: 'lv_ABCDEFGHIJKL',
+              kind: 'array',
+              size: 16,
+              executionId: 'execution-1',
+            },
+            count: 1,
+            byteSize: 16,
+          },
+        ],
+        preview: [{ id: 1 }],
+      }
+
+      expect(navigatePath(manifest, ['0'])).toBeUndefined()
+      expect(navigatePath(manifest, ['length'])).toBe(1)
+      expect(navigatePath(manifest, ['preview'])).toEqual([{ id: 1 }])
+    })
+  })
+
+  describe('bracket notation edge cases', () => {
+    it.concurrent('should handle bracket notation with property access', () => {
+      const obj = { data: [{ value: 100 }, { value: 200 }] }
+      expect(navigatePath(obj, ['data[0]'])).toEqual({ value: 100 })
+    })
+
+    it.concurrent('should return undefined for bracket notation on non-existent property', () => {
+      const obj = { data: [1, 2, 3] }
+      expect(navigatePath(obj, ['nonexistent[0]'])).toBeUndefined()
+    })
+
+    it.concurrent('should return undefined for bracket notation with null property', () => {
+      const obj = { data: null }
+      expect(navigatePath(obj, ['data[0]'])).toBeUndefined()
+    })
+
+    it.concurrent('should return undefined for bracket notation on non-array', () => {
+      const obj = { data: 'string' }
+      expect(navigatePath(obj, ['data[0]'])).toBeUndefined()
+    })
+  })
+})