fix(integrations): preserve defaults and refresh Search access

Author: waleedlatif1

apps/sim/blocks/blocks/flow.ts

@@ -888,10 +888,15 @@ export const FlowBlock: BlockConfig = {
       tool: (params) => `flow_${params.operation || 'search_entities'}`,
       params: (params) => {
         const result: Record<string, unknown> = {}
-        if (params.limit != null && params.limit !== '') result.limit = Number(params.limit)
+        result.limit =
+          params.limit == null || (typeof params.limit === 'string' && !params.limit.trim())
+            ? undefined
+            : Number(params.limit)
         for (const key of ['includeResolved', 'resolved', 'isVariant']) {
-          if (params[key] != null && params[key] !== '')
-            result[key] = params[key] === true || params[key] === 'true'
+          result[key] =
+            params[key] == null || params[key] === ''
+              ? undefined
+              : params[key] === true || params[key] === 'true'
         }
         return result
       },

apps/sim/blocks/blocks/jama.ts

@@ -708,12 +708,12 @@ export const JamaBlock: BlockConfig = {
     items: {
       type: 'json',
       description:
-        'List Items, Search Items, or List Baseline Items results (id, documentKey, globalId, itemType, project, createdDate, modifiedDate, lastActivityDate, createdBy, modifiedBy, fields, version)',
+        'Item list and search results (id, documentKey, globalId, itemType, project, createdDate, modifiedDate, lastActivityDate, createdBy, modifiedBy, fields, version)',
     },
     item: {
       type: 'json',
       description:
-        'Get Item Version result (id, documentKey, globalId, itemType, project, createdDate, modifiedDate, lastActivityDate, createdBy, modifiedBy, fields, version)',
+        'Get Item or Get Item Version result (id, documentKey, globalId, itemType, project, createdDate, modifiedDate, lastActivityDate, createdBy, modifiedBy, fields, version)',
     },
     id: { type: 'number', description: 'Created resource ID' },
     location: { type: 'string', description: 'Created resource API URL' },

apps/sim/executor/handlers/generic/handler.test.ts

@@ -16,8 +16,18 @@ import bufferPostFixture from '@/tools/buffer/__fixtures__/post.json'
 import { bufferCreatePostTool } from '@/tools/buffer/create_post'
 import { bufferEditPostTool } from '@/tools/buffer/edit_post'
 import type { BufferCreatePostParams, BufferEditPostParams } from '@/tools/buffer/types'
+import { flowCreateBranchTool } from '@/tools/flow/create-branch'
+import { flowListCommentsTool } from '@/tools/flow/list-comments'
+import { flowListEntitiesTool } from '@/tools/flow/list-entities'
 import { flowSetValueTool } from '@/tools/flow/set-value'
-import type { FlowSetValueParams } from '@/tools/flow/types'
+import type {
+  FlowCreateBranchParams,
+  FlowListCommentsParams,
+  FlowListEntitiesParams,
+  FlowSetValueParams,
+  FlowUpdateCommentParams,
+} from '@/tools/flow/types'
+import { flowUpdateCommentTool } from '@/tools/flow/update-comment'
 import { mcpRunOperationTool } from '@/tools/mcp/run-operation'
 import type { ToolConfig } from '@/tools/types'
 import { getTool } from '@/tools/utils'
@@ -92,6 +102,8 @@ describe('GenericBlockHandler', () => {
       writes.length = 0
       mockGetBlock.mockReturnValue(FlowBlock)
       mockGetTool.mockReturnValue(flowSetValueTool)
+      mockBlock.metadata = { id: 'flow', name: 'Flow' }
+      mockBlock.config = { tool: 'flow_set_value', params: {} }
       const { validateRequiredParametersAfterMerge } =
         await vi.importActual<typeof import('@/tools/utils')>('@/tools/utils')
       mockExecuteTool.mockImplementation(async (toolId: string, params: FlowSetValueParams) => {
@@ -105,21 +117,13 @@ describe('GenericBlockHandler', () => {
     it.each(values.map((value) => ({ value, encoded: JSON.stringify(value) })))(
       'preserves the JSON value $encoded on the provider wire',
       async ({ value, encoded }) => {
-        await handler.execute(
-          mockContext,
-          {
-            ...mockBlock,
-            metadata: { id: 'flow', name: 'Flow' },
-            config: { tool: 'flow_set_value', params: {} },
-          },
-          {
-            operation: 'set_value',
-            projectId: 'project',
-            entityId: 'entity',
-            fieldKey: 'name',
-            value: encoded,
-          }
-        )
+        await handler.execute(mockContext, mockBlock, {
+          operation: 'set_value',
+          projectId: 'project',
+          entityId: 'entity',
+          fieldKey: 'name',
+          value: encoded,
+        })
         expect(writes).toEqual([{ key: 'name', value }])
       }
     )
@@ -128,27 +132,140 @@ describe('GenericBlockHandler', () => {
       'rejects omitted or malformed JSON before sending a field write (%s)',
       async (value) => {
         await expect(
-          handler.execute(
-            mockContext,
-            {
-              ...mockBlock,
-              metadata: { id: 'flow', name: 'Flow' },
-              config: { tool: 'flow_set_value', params: {} },
-            },
-            {
-              operation: 'set_value',
-              projectId: 'project',
-              entityId: 'entity',
-              fieldKey: 'name',
-              value,
-            }
-          )
+          handler.execute(mockContext, mockBlock, {
+            operation: 'set_value',
+            projectId: 'project',
+            entityId: 'entity',
+            fieldKey: 'name',
+            value,
+          })
         ).rejects.toThrow()
         expect(writes).toEqual([])
       }
     )
+
+    it('rejects a whitespace-only field key before sending a write', async () => {
+      await expect(
+        handler.execute(mockContext, mockBlock, {
+          operation: 'set_value',
+          projectId: 'project',
+          entityId: 'entity',
+          fieldKey: ' \t ',
+          value: '"updated"',
+        })
+      ).rejects.toThrow('Field key is required')
+      expect(writes).toEqual([])
+    })
+  })
+
+  describe('Flow list limits', () => {
+    const requests: string[] = []
+
+    beforeEach(() => {
+      requests.length = 0
+      mockGetBlock.mockReturnValue(FlowBlock)
+      mockGetTool.mockReturnValue(flowListEntitiesTool)
+      mockExecuteTool.mockImplementation(
+        async (_toolId: string, params: FlowListEntitiesParams) => {
+          const url = flowListEntitiesTool.request.url
+          requests.push(typeof url === 'function' ? url(params) : url)
+          return { success: true, output: {} }
+        }
+      )
+      mockBlock.metadata = { id: 'flow', name: 'Flow' }
+      mockBlock.config = { tool: 'flow_list_entities', params: {} }
+    })
+
+    it.each([
+      { limit: null, expected: '50' },
+      { limit: '', expected: '50' },
+      { limit: '  ', expected: '50' },
+      { limit: '25', expected: '25' },
+    ])('sends page size $expected when the Limit input is $limit', async ({ limit, expected }) => {
+      await handler.execute(mockContext, mockBlock, {
+        operation: 'list_entities',
+        domain: 'https://api.example.com',
+        projectId: 'project',
+        limit,
+      })
+      expect(requests.map((url) => new URL(url).searchParams.get('limit'))).toEqual([expected])
+    })
+
+    it('rejects an explicit zero instead of silently replacing it with the default', async () => {
+      await expect(
+        handler.execute(mockContext, mockBlock, {
+          operation: 'list_entities',
+          domain: 'https://api.example.com',
+          projectId: 'project',
+          limit: '0',
+        })
+      ).rejects.toThrow('Limit must be an integer between 1 and 1000')
+      expect(requests).toEqual([])
+    })
   })
 
+  it.each([
+    { selection: 'untouched', value: null, expected: undefined },
+    { selection: 'cleared', value: '', expected: undefined },
+    { selection: 'No', value: 'false', expected: false },
+    { selection: 'Yes', value: true, expected: true },
+  ])(
+    'sends optional Flow booleans correctly for $selection dropdowns',
+    async ({ value, expected }) => {
+      const requests: { includeResolved: string | null; body: unknown }[] = []
+      mockGetBlock.mockReturnValue(FlowBlock)
+      mockBlock.metadata = { id: 'flow', name: 'Flow' }
+
+      for (const tool of [flowListCommentsTool, flowUpdateCommentTool, flowCreateBranchTool]) {
+        mockGetTool.mockReturnValue(tool)
+        mockBlock.config = { tool: tool.id, params: {} }
+        mockExecuteTool.mockImplementation(
+          async (
+            _toolId: string,
+            params: FlowListCommentsParams & FlowUpdateCommentParams & FlowCreateBranchParams
+          ) => {
+            const url = tool.request.url
+            requests.push({
+              includeResolved: new URL(
+                typeof url === 'function' ? url(params) : url
+              ).searchParams.get('include_resolved'),
+              body: await Response.json(tool.request.body?.(params) ?? null).json(),
+            })
+            return { success: true, output: {} }
+          }
+        )
+        await handler.execute(mockContext, mockBlock, {
+          operation: tool.id.replace('flow_', ''),
+          domain: 'https://api.example.com',
+          projectId: 'project',
+          entityId: 'entity',
+          commentId: 'comment',
+          text: 'Updated comment',
+          branchName: 'Pilot',
+          includeResolved: value,
+          resolved: value,
+          isVariant: value,
+        })
+      }
+
+      expect(requests).toEqual([
+        { includeResolved: expected === undefined ? null : String(expected), body: null },
+        {
+          includeResolved: null,
+          body:
+            expected === undefined
+              ? { text: 'Updated comment' }
+              : { text: 'Updated comment', resolved: expected },
+        },
+        {
+          includeResolved: null,
+          body:
+            expected === undefined ? { name: 'Pilot' } : { name: 'Pilot', is_variant: expected },
+        },
+      ])
+    }
+  )
+
   it.each([
     {
       selection: 'keep-current scheduling',

apps/sim/hooks/queries/organization-accounts.test.tsx

@@ -18,7 +18,10 @@ import { ApiClientError } from '@/lib/api/client/errors'
 import { listOrganizationAccountPeopleContract } from '@/lib/api/contracts/organization-accounts'
 import { resourceScopeKey } from '@/lib/core/resource-scope'
 import { useOrganizationAccountPeople } from '@/hooks/queries/organization-accounts'
-import { useRemovePersonalSearchCredential } from '@/hooks/queries/personal-search-integrations'
+import {
+  useRemovePersonalSearchCredential,
+  useSavePersonalSearchCredential,
+} from '@/hooks/queries/personal-search-integrations'
 import { knowledgeKeys } from '@/hooks/queries/utils/knowledge-keys'
 
 const mockRequestJson = apiClientRequestMockFns.mockRequestJson
@@ -29,9 +32,11 @@ describe('organization accounts', () => {
   let client: QueryClient
   let result: ReturnType<typeof useOrganizationAccountPeople>
   let removal: ReturnType<typeof useRemovePersonalSearchCredential>
+  let save: ReturnType<typeof useSavePersonalSearchCredential>
 
-  function RemovalProbe() {
+  function CredentialMutationProbe() {
     removal = useRemovePersonalSearchCredential()
+    save = useSavePersonalSearchCredential()
     return null
   }
 
@@ -139,36 +144,50 @@ describe('organization accounts', () => {
     expect(result.data?.pages).toHaveLength(1)
   })
 
-  it('clears disconnected Search content while preserving another organization’s results', async () => {
-    const search = knowledgeKeys.search(
-      resourceScopeKey({ kind: 'organization', organizationId: 'org-1' }),
-      'private content'
-    )
-    const otherSearch = knowledgeKeys.search(
-      resourceScopeKey({ kind: 'organization', organizationId: 'org-2' }),
-      'private content'
-    )
-    const document = knowledgeKeys.document('knowledge-1', 'document-1')
-    client.setQueryData(search, [{ content: 'disconnected source content' }])
-    client.setQueryData(otherSearch, [{ content: 'other organization content' }])
-    client.setQueryData(document, { content: 'disconnected document content' })
-    mockRequestJson.mockResolvedValueOnce({ success: true })
+  it.each(['remove', 'reconnect'] as const)(
+    'clears cached Search content after %s while preserving another organization’s results',
+    async (action) => {
+      const search = knowledgeKeys.search(
+        resourceScopeKey({ kind: 'organization', organizationId: 'org-1' }),
+        'private content'
+      )
+      const otherSearch = knowledgeKeys.search(
+        resourceScopeKey({ kind: 'organization', organizationId: 'org-2' }),
+        'private content'
+      )
+      const document = knowledgeKeys.document('knowledge-1', 'document-1')
+      client.setQueryData(search, [{ content: 'previous credential content' }])
+      client.setQueryData(otherSearch, [{ content: 'other organization content' }])
+      client.setQueryData(document, { content: 'previous credential document' })
+      mockRequestJson.mockResolvedValueOnce(
+        action === 'remove' ? { success: true } : { credentialId: 'credential-1' }
+      )
 
-    await act(async () =>
-      root.render(
-        <QueryClientProvider client={client}>
-          <RemovalProbe />
-        </QueryClientProvider>
+      await act(async () =>
+        root.render(
+          <QueryClientProvider client={client}>
+            <CredentialMutationProbe />
+          </QueryClientProvider>
+        )
       )
-    )
-    await act(async () => {
-      await removal.mutateAsync({ organizationId: 'org-1', credentialId: 'credential-1' })
-    })
+      await act(async () => {
+        const body = { organizationId: 'org-1', credentialId: 'credential-1' }
+        if (action === 'remove') await removal.mutateAsync(body)
+        else
+          await save.mutateAsync({
+            ...body,
+            providerId: 'flow-service-account',
+            apiToken: 'rotated-token',
+            domain: 'https://api.flowengineering.com',
+            providerWorkspaceId: 'workspace-1',
+          })
+      })
 
-    expect(client.getQueryData(search)).toBeUndefined()
-    expect(client.getQueryData(document)).toBeUndefined()
-    expect(client.getQueryData(otherSearch)).toEqual([{ content: 'other organization content' }])
-  })
+      expect(client.getQueryData(search)).toBeUndefined()
+      expect(client.getQueryData(document)).toBeUndefined()
+      expect(client.getQueryData(otherSearch)).toEqual([{ content: 'other organization content' }])
+    }
+  )
 
   it.each([400, 401, 403, 404, 409, 422])(
     'does not retry a non-retryable %s response',

apps/sim/hooks/queries/personal-search-integrations.ts

@@ -70,7 +70,7 @@ export function useConnectPersonalSearchIntegration() {
   })
 }
 
-/** Saves a member-owned provider credential and refreshes both Search connection inventories. */
+/** Saves a member-owned provider credential and clears Search content fetched with prior access. */
 export function useSavePersonalSearchCredential() {
   const client = useQueryClient()
   return useMutation({
@@ -82,12 +82,7 @@ export function useSavePersonalSearchCredential() {
           queryKey: organizationAccountsKeys.detail(body.organizationId),
         }),
         client.invalidateQueries({ queryKey: personalSearchIntegrationKeys.lists() }),
-        client.invalidateQueries({
-          queryKey: searchSourceKeys.list({
-            kind: 'organization',
-            organizationId: body.organizationId,
-          }),
-        }),
+        resetOrganizationSearchAccess(client, body.organizationId),
       ]),
   })
 }