canonical modes search replace counterpart

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/search-replace/workflow-search-replace.tsx

@@ -31,6 +31,7 @@ import {
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/float'
 import { useCurrentWorkflow } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-current-workflow'
 import { getBlock } from '@/blocks'
+import { useWorkspaceCredentials } from '@/hooks/queries/credentials'
 import { useFolderMap } from '@/hooks/queries/folders'
 import { isWorkflowEffectivelyLocked } from '@/hooks/queries/utils/folder-tree'
 import { useWorkflowMap } from '@/hooks/queries/workflows'
@@ -125,6 +126,7 @@ export function WorkflowSearchReplace() {
     setReplacement,
     setActiveMatchId,
   } = useWorkflowSearchReplaceStore()
+  const { data: workspaceCredentials } = useWorkspaceCredentials({ workspaceId, enabled: isOpen })
 
   useRegisterGlobalCommands([
     createCommand({
@@ -149,6 +151,14 @@ export function WorkflowSearchReplace() {
     [currentWorkflow.blocks, currentWorkflow.isSnapshotView, workflowSubblockValues]
   )
 
+  const credentialTypeById = useMemo(
+    () =>
+      Object.fromEntries(
+        (workspaceCredentials ?? []).map((credential) => [credential.id, credential.type])
+      ),
+    [workspaceCredentials]
+  )
+
   const matches = useMemo(
     () =>
       indexWorkflowSearchMatches({
@@ -161,9 +171,11 @@ export function WorkflowSearchReplace() {
         readonlyReason,
         workspaceId,
         workflowId,
+        credentialTypeById,
       }),
     [
       currentWorkflow.isSnapshotView,
+      credentialTypeById,
       query,
       readonlyReason,
       searchBlocks,

apps/sim/hooks/queries/workflow-search-replace.ts

@@ -20,7 +20,10 @@ import {
 } from '@/lib/api/contracts/workspace-files'
 import { createMcpToolId } from '@/lib/mcp/shared'
 import type { Credential } from '@/lib/oauth'
-import { stableStringifyWorkflowSearchValue } from '@/lib/workflows/search-replace/resources'
+import {
+  getWorkflowSearchMatchResourceGroupKey,
+  stableStringifyWorkflowSearchValue,
+} from '@/lib/workflows/search-replace/resources'
 import type {
   WorkflowSearchMatch,
   WorkflowSearchReplacementOption,
@@ -151,6 +154,22 @@ function uniqueSelectorOptionGroups(matches: WorkflowSearchMatch[]): WorkflowSea
   })
 }
 
+function uniqueResourceOptionGroups(
+  matches: WorkflowSearchMatch[],
+  kind: WorkflowSearchMatch['kind'],
+  predicate?: (match: WorkflowSearchMatch) => boolean
+): WorkflowSearchMatch[] {
+  const seen = new Set<string>()
+  return matches.filter((match) => {
+    if (match.kind !== kind || predicate?.(match) === false) return false
+
+    const key = getWorkflowSearchMatchResourceGroupKey(match)
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
 export function useWorkflowSearchOAuthCredentialDetails(
   matches: WorkflowSearchMatch[],
   workflowId?: string
@@ -445,7 +464,7 @@ export function useWorkflowSearchTableReplacementOptions(
   matches: WorkflowSearchMatch[],
   workspaceId?: string
 ) {
-  const tableMatch = useMemo(() => matches.find((match) => match.kind === 'table'), [matches])
+  const tableGroups = useMemo(() => uniqueResourceOptionGroups(matches, 'table'), [matches])
 
   return useQueries({
     queries: [
@@ -456,15 +475,17 @@ export function useWorkflowSearchTableReplacementOptions(
             query: { workspaceId: workspaceId as string, scope: 'active' },
             signal,
           }),
-        enabled: Boolean(workspaceId && tableMatch),
+        enabled: Boolean(workspaceId && tableGroups.length > 0),
         staleTime: 60 * 1000,
         select: (response: ListTablesResponse): WorkflowSearchReplacementOption[] =>
-          response.data.tables.map((table) => ({
-            kind: 'table',
-            value: table.id,
-            label: table.name,
-            resourceGroupKey: tableMatch?.resource?.resourceGroupKey,
-          })),
+          tableGroups.flatMap((match) =>
+            response.data.tables.map((table) => ({
+              kind: 'table',
+              value: table.id,
+              label: table.name,
+              resourceGroupKey: match.resource?.resourceGroupKey,
+            }))
+          ),
       },
     ],
   })
@@ -474,8 +495,8 @@ export function useWorkflowSearchFileReplacementOptions(
   matches: WorkflowSearchMatch[],
   workspaceId?: string
 ) {
-  const fileMatch = useMemo(
-    () => matches.find((match) => match.kind === 'file' && !match.resource?.selectorKey),
+  const fileGroups = useMemo(
+    () => uniqueResourceOptionGroups(matches, 'file', (match) => !match.resource?.selectorKey),
     [matches]
   )
 
@@ -489,21 +510,23 @@ export function useWorkflowSearchFileReplacementOptions(
             query: { scope: 'active' },
             signal,
           }),
-        enabled: Boolean(workspaceId && fileMatch),
+        enabled: Boolean(workspaceId && fileGroups.length > 0),
         staleTime: 60 * 1000,
         select: (response: ListWorkspaceFilesResponse): WorkflowSearchReplacementOption[] =>
-          response.files.map((file) => ({
-            kind: 'file',
-            value: JSON.stringify({
-              name: file.name,
-              path: file.path,
-              key: file.key,
-              size: file.size,
-              type: file.type,
-            }),
-            label: file.name,
-            resourceGroupKey: fileMatch?.resource?.resourceGroupKey,
-          })),
+          fileGroups.flatMap((match) =>
+            response.files.map((file) => ({
+              kind: 'file',
+              value: JSON.stringify({
+                name: file.name,
+                path: file.path,
+                key: file.key,
+                size: file.size,
+                type: file.type,
+              }),
+              label: file.name,
+              resourceGroupKey: match.resource?.resourceGroupKey,
+            }))
+          ),
       },
     ],
   })
@@ -513,7 +536,7 @@ export function useWorkflowSearchMcpServerReplacementOptions(
   matches: WorkflowSearchMatch[],
   workspaceId?: string
 ) {
-  const serverMatch = useMemo(() => matches.find((match) => match.kind === 'mcp-server'), [matches])
+  const serverGroups = useMemo(() => uniqueResourceOptionGroups(matches, 'mcp-server'), [matches])
 
   return useQueries({
     queries: [
@@ -524,15 +547,17 @@ export function useWorkflowSearchMcpServerReplacementOptions(
             query: { workspaceId: workspaceId as string },
             signal,
           }),
-        enabled: Boolean(workspaceId && serverMatch),
+        enabled: Boolean(workspaceId && serverGroups.length > 0),
         staleTime: 60 * 1000,
         select: (response: ListMcpServersResponse): WorkflowSearchReplacementOption[] =>
-          response.data.servers.map((server) => ({
-            kind: 'mcp-server',
-            value: server.id,
-            label: server.name,
-            resourceGroupKey: serverMatch?.resource?.resourceGroupKey,
-          })),
+          serverGroups.flatMap((match) =>
+            response.data.servers.map((server) => ({
+              kind: 'mcp-server',
+              value: server.id,
+              label: server.name,
+              resourceGroupKey: match.resource?.resourceGroupKey,
+            }))
+          ),
       },
     ],
   })
@@ -542,7 +567,7 @@ export function useWorkflowSearchMcpToolReplacementOptions(
   matches: WorkflowSearchMatch[],
   workspaceId?: string
 ) {
-  const toolMatch = useMemo(() => matches.find((match) => match.kind === 'mcp-tool'), [matches])
+  const toolGroups = useMemo(() => uniqueResourceOptionGroups(matches, 'mcp-tool'), [matches])
 
   return useQueries({
     queries: [
@@ -553,15 +578,17 @@ export function useWorkflowSearchMcpToolReplacementOptions(
             query: { workspaceId: workspaceId as string },
             signal,
           }),
-        enabled: Boolean(workspaceId && toolMatch),
+        enabled: Boolean(workspaceId && toolGroups.length > 0),
         staleTime: 60 * 1000,
         select: (response: DiscoverMcpToolsResponse): WorkflowSearchReplacementOption[] =>
-          response.data.tools.map((tool) => ({
-            kind: 'mcp-tool',
-            value: createMcpToolId(tool.serverId, tool.name),
-            label: `${tool.serverName}: ${tool.name}`,
-            resourceGroupKey: toolMatch?.resource?.resourceGroupKey,
-          })),
+          toolGroups.flatMap((match) =>
+            response.data.tools.map((tool) => ({
+              kind: 'mcp-tool',
+              value: createMcpToolId(tool.serverId, tool.name),
+              label: `${tool.serverName}: ${tool.name}`,
+              resourceGroupKey: match.resource?.resourceGroupKey,
+            }))
+          ),
       },
     ],
   })

apps/sim/hooks/use-collaborative-workflow.ts

@@ -12,6 +12,7 @@ import {
 } from '@sim/realtime-protocol/constants'
 import { generateId } from '@sim/utils/id'
 import { useQueryClient } from '@tanstack/react-query'
+import { isEqual } from 'es-toolkit'
 import type { Edge } from 'reactflow'
 import { useShallow } from 'zustand/react/shallow'
 import { requestJson } from '@/lib/api/client/request'
@@ -1566,6 +1567,19 @@ export function useCollaborativeWorkflow() {
         return false
       }
 
+      const staleUpdate = updates.find((update) => {
+        if (!Object.hasOwn(update, 'expectedValue')) return false
+        const currentValue = useSubBlockStore.getState().getValue(update.blockId, update.subblockId)
+        return !isEqual(currentValue, update.expectedValue)
+      })
+      if (staleUpdate) {
+        logger.warn('Skipping batch subblock update because expected value changed', {
+          blockId: staleUpdate.blockId,
+          subblockId: staleUpdate.subblockId,
+        })
+        return false
+      }
+
       if (updates.length > 0) {
         updates.forEach((update) => {
           useSubBlockStore.getState().setValue(update.blockId, update.subblockId, update.value)

apps/sim/lib/workflows/search-replace/dependencies.test.ts

@@ -0,0 +1,24 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { getWorkflowSearchDependentClears } from '@/lib/workflows/search-replace/dependencies'
+import type { SubBlockConfig } from '@/blocks/types'
+
+describe('getWorkflowSearchDependentClears', () => {
+  it('returns transitive dependents without cycling', () => {
+    const subBlocks: SubBlockConfig[] = [
+      { id: 'credential', title: 'Credential', type: 'oauth-input' },
+      { id: 'project', title: 'Project', type: 'project-selector', dependsOn: ['credential'] },
+      { id: 'issue', title: 'Issue', type: 'file-selector', dependsOn: ['project'] },
+      { id: 'assignee', title: 'Assignee', type: 'user-selector', dependsOn: ['issue'] },
+      { id: 'unrelated', title: 'Unrelated', type: 'short-input' },
+    ]
+
+    expect(getWorkflowSearchDependentClears(subBlocks, 'credential')).toEqual([
+      { subBlockId: 'project', reason: 'project depends on credential' },
+      { subBlockId: 'issue', reason: 'issue depends on project' },
+      { subBlockId: 'assignee', reason: 'assignee depends on issue' },
+    ])
+  })
+})

apps/sim/lib/workflows/search-replace/dependencies.ts

@@ -10,8 +10,24 @@ export function getWorkflowSearchDependentClears(
   allSubBlocks: SubBlockConfig[],
   changedSubBlockId: string
 ): DependentClear[] {
-  return getSubBlocksDependingOnChange(allSubBlocks, changedSubBlockId).map((subBlock) => ({
-    subBlockId: subBlock.id,
-    reason: `${subBlock.id} depends on ${changedSubBlockId}`,
-  }))
+  const clears: DependentClear[] = []
+  const visited = new Set<string>([changedSubBlockId])
+  const queue = [changedSubBlockId]
+
+  while (queue.length > 0) {
+    const currentSubBlockId = queue.shift()
+    if (!currentSubBlockId) continue
+
+    for (const subBlock of getSubBlocksDependingOnChange(allSubBlocks, currentSubBlockId)) {
+      if (!subBlock.id || visited.has(subBlock.id)) continue
+      visited.add(subBlock.id)
+      clears.push({
+        subBlockId: subBlock.id,
+        reason: `${subBlock.id} depends on ${currentSubBlockId}`,
+      })
+      queue.push(subBlock.id)
+    }
+  }
+
+  return clears
 }