chore: import upstream snapshot with attribution

apps/sim/hooks/selectors/registry.test.ts

@@ -0,0 +1,150 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockEnsureQueryData, mockGetWorkflows, mockGetFolderMap } = vi.hoisted(() => ({
+  mockEnsureQueryData: vi.fn().mockResolvedValue(undefined),
+  mockGetWorkflows: vi.fn(),
+  mockGetFolderMap: vi.fn().mockReturnValue({}),
+}))
+
+vi.mock('@/app/_shell/providers/get-query-client', () => ({
+  getQueryClient: vi.fn(() => ({
+    ensureQueryData: mockEnsureQueryData,
+  })),
+}))
+
+vi.mock('@/hooks/queries/utils/workflow-cache', () => ({
+  getWorkflows: mockGetWorkflows,
+  getWorkflowById: vi.fn((workspaceId: string, workflowId: string) =>
+    mockGetWorkflows(workspaceId).find((workflow: { id: string }) => workflow.id === workflowId)
+  ),
+}))
+
+vi.mock('@/hooks/queries/utils/folder-cache', () => ({
+  getFolderMap: mockGetFolderMap,
+}))
+
+vi.mock('@/hooks/queries/utils/workflow-list-query', () => ({
+  getWorkflowListQueryOptions: vi.fn((workspaceId: string) => ({
+    queryKey: ['workflows', 'list', workspaceId, 'active'],
+  })),
+}))
+
+import { getSelectorDefinition } from '@/hooks/selectors/registry'
+
+describe('sim.workflows selector', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockEnsureQueryData.mockResolvedValue(undefined)
+    mockGetWorkflows.mockReturnValue([
+      { id: 'wf-1', name: 'Alpha Workflow', folderId: null },
+      { id: 'wf-2', name: 'Bravo Workflow', folderId: null },
+    ])
+    mockGetFolderMap.mockReturnValue({})
+  })
+
+  it('requires an explicit workspaceId in selector context', () => {
+    const definition = getSelectorDefinition('sim.workflows')
+
+    expect(definition.enabled?.({ key: 'sim.workflows', context: {} })).toBe(false)
+    expect(definition.staleTime).toBe(60_000)
+    expect(
+      definition.getQueryKey({
+        key: 'sim.workflows',
+        context: { workspaceId: 'ws-1', excludeWorkflowId: 'wf-2' },
+      })
+    ).toEqual(['selectors', 'sim.workflows', 'ws-1', 'wf-2'])
+  })
+
+  it('reads workflow options from the scoped workflow cache', async () => {
+    const definition = getSelectorDefinition('sim.workflows')
+
+    const options = await definition.fetchList!({
+      key: 'sim.workflows',
+      context: { workspaceId: 'ws-1', excludeWorkflowId: 'wf-2' },
+    })
+
+    expect(mockEnsureQueryData).toHaveBeenCalledWith({
+      queryKey: ['workflows', 'list', 'ws-1', 'active'],
+    })
+    expect(mockGetWorkflows).toHaveBeenCalledWith('ws-1')
+    expect(options).toEqual([{ id: 'wf-1', label: 'Alpha Workflow' }])
+  })
+
+  it('resolves workflow labels by id using the same workspace scope', async () => {
+    const definition = getSelectorDefinition('sim.workflows')
+
+    const option = await definition.fetchById?.({
+      key: 'sim.workflows',
+      context: { workspaceId: 'ws-1' },
+      detailId: 'wf-2',
+    })
+
+    expect(mockEnsureQueryData).toHaveBeenCalledWith({
+      queryKey: ['workflows', 'list', 'ws-1', 'active'],
+    })
+    expect(mockGetWorkflows).toHaveBeenCalledWith('ws-1')
+    expect(option).toEqual({ id: 'wf-2', label: 'Bravo Workflow' })
+  })
+
+  it('disambiguates duplicate workflow names with their folder path', async () => {
+    mockGetWorkflows.mockReturnValue([
+      { id: 'wf-root', name: 'Pipeline', folderId: null },
+      { id: 'wf-eng', name: 'Pipeline', folderId: 'folder-eng' },
+      { id: 'wf-eng-backend', name: 'Pipeline', folderId: 'folder-backend' },
+      { id: 'wf-unique', name: 'Solo Workflow', folderId: 'folder-eng' },
+    ])
+    mockGetFolderMap.mockReturnValue({
+      'folder-eng': {
+        id: 'folder-eng',
+        name: 'Engineering',
+        parentId: null,
+        workspaceId: 'ws-1',
+      },
+      'folder-backend': {
+        id: 'folder-backend',
+        name: 'Backend',
+        parentId: 'folder-eng',
+        workspaceId: 'ws-1',
+      },
+    })
+
+    const definition = getSelectorDefinition('sim.workflows')
+    const options = await definition.fetchList!({
+      key: 'sim.workflows',
+      context: { workspaceId: 'ws-1' },
+    })
+
+    const labelById = Object.fromEntries(options.map((o) => [o.id, o.label]))
+    expect(labelById['wf-root']).toBe('Pipeline (Root)')
+    expect(labelById['wf-eng']).toBe('Pipeline (Engineering)')
+    expect(labelById['wf-eng-backend']).toBe('Pipeline (Engineering / Backend)')
+    expect(labelById['wf-unique']).toBe('Solo Workflow')
+  })
+
+  it('disambiguates a single workflow lookup when its name has duplicates', async () => {
+    mockGetWorkflows.mockReturnValue([
+      { id: 'wf-1', name: 'Pipeline', folderId: 'folder-a' },
+      { id: 'wf-2', name: 'Pipeline', folderId: null },
+    ])
+    mockGetFolderMap.mockReturnValue({
+      'folder-a': {
+        id: 'folder-a',
+        name: 'Alpha',
+        parentId: null,
+        workspaceId: 'ws-1',
+      },
+    })
+
+    const definition = getSelectorDefinition('sim.workflows')
+    const option = await definition.fetchById?.({
+      key: 'sim.workflows',
+      context: { workspaceId: 'ws-1' },
+      detailId: 'wf-1',
+    })
+
+    expect(option).toEqual({ id: 'wf-1', label: 'Pipeline (Alpha)' })
+  })
+})