fix(sailpoint): reject empty aggregation definitions

Author: waleedlatif1

apps/sim/lib/internal/sailpoint/execute-tool.test.ts

@@ -412,6 +412,20 @@ describe('SailPoint internal tool handler', () => {
     expect(mockFetch).not.toHaveBeenCalled()
   })
 
+  it.each([
+    ['aggregationsDsl', {}],
+    ['aggregationsDsl', '{}'],
+    ['aggregations', {}],
+    ['aggregations', '{}'],
+  ])('rejects an empty %s aggregate definition', async (field, value) => {
+    const response = await request('sailpoint_search_aggregate', { [field]: value })
+    expect(response.status).toBe(400)
+    expect(await response.json()).toMatchObject({
+      error: expect.stringContaining('must be a non-empty object'),
+    })
+    expect(mockFetch).not.toHaveBeenCalled()
+  })
+
   it.each([
     [
       'sailpoint_list_entitlements',

apps/sim/lib/internal/sailpoint/schema.ts

@@ -1,3 +1,4 @@
+import { isRecordLike } from '@sim/utils/object'
 import { z } from 'zod'
 import { FileInputSchema } from '@/lib/uploads/utils/file-schemas'
 
@@ -198,11 +199,15 @@ const schemas = {
     ...pagination(),
   }).superRefine((value, ctx) => {
     validateSearchQuerySelection(value, ctx, false)
-    if (!value.aggregationsDsl && !value.aggregations) {
+    const hasAggregationsDsl =
+      isRecordLike(value.aggregationsDsl) && Object.keys(value.aggregationsDsl).length > 0
+    const hasAggregations =
+      isRecordLike(value.aggregations) && Object.keys(value.aggregations).length > 0
+    if (!hasAggregationsDsl && !hasAggregations) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
         path: ['aggregationsDsl'],
-        message: 'aggregationsDsl or aggregations is required',
+        message: 'aggregationsDsl or aggregations must be a non-empty object',
       })
     }
   }),

apps/sim/tools/sailpoint/definitions.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest'
+import { sailpointSearchAggregateTool } from '@/tools/sailpoint/definitions'
+import type { SailPointSearchAggregateParams } from '@/tools/sailpoint/types'
+
+const credentials = { clientId: 'client', clientSecret: 'secret', tenant: 'tenant' }
+
+function operationInput(params: SailPointSearchAggregateParams) {
+  return sailpointSearchAggregateTool.operation.input(params)
+}
+
+describe('SailPoint Search Aggregate tool input', () => {
+  it.each([
+    ['aggregationsDsl', {}],
+    ['aggregationsDsl', '{}'],
+    ['aggregations', {}],
+    ['aggregations', '{}'],
+  ] as const)('rejects an empty %s definition', (field, value) => {
+    expect(() => operationInput({ ...credentials, [field]: value })).toThrow(
+      'aggregationsDsl or aggregations must be a non-empty object'
+    )
+  })
+
+  it('accepts either non-empty aggregation representation', () => {
+    expect(
+      operationInput({ ...credentials, aggregationsDsl: { names: { terms: { field: 'name' } } } })
+    ).toMatchObject({ aggregationsDsl: { names: { terms: { field: 'name' } } } })
+    expect(
+      operationInput({ ...credentials, aggregations: { names: { type: 'TERM', field: 'name' } } })
+    ).toMatchObject({ aggregations: { names: { type: 'TERM', field: 'name' } } })
+  })
+})

apps/sim/tools/sailpoint/definitions.ts

@@ -1,3 +1,4 @@
+import { isRecordLike } from '@sim/utils/object'
 import {
   createSailPointListOutputs,
   createSailPointOperationInput,
@@ -170,7 +171,8 @@ function segmentedListInput(params: SailPointSegmentedListParams, maxLimit = 250
 
 function searchInput(
   params: SailPointSearchBodyParams,
-  queryRequired = false
+  queryRequired = false,
+  aggregationsRequired = false
 ): Record<string, unknown> {
   const query = parseJsonValue(params.query, 'query')
   const queryDsl = parseJsonValue(params.queryDsl, 'queryDsl')
@@ -181,6 +183,15 @@ function searchInput(
   const aggregations = parseJsonValue(params.aggregations, 'aggregations')
   const filters = parseJsonValue(params.filters, 'filters')
 
+  if (aggregationsRequired) {
+    const hasAggregationsDsl =
+      isRecordLike(aggregationsDsl) && Object.keys(aggregationsDsl).length > 0
+    const hasAggregations = isRecordLike(aggregations) && Object.keys(aggregations).length > 0
+    if (!hasAggregationsDsl && !hasAggregations) {
+      throw new Error('aggregationsDsl or aggregations must be a non-empty object')
+    }
+  }
+
   const hasQueryInput = Boolean(query || queryDsl || textQuery || typeAheadQuery)
   if (queryRequired || params.queryType || hasQueryInput) {
     const queryType = params.queryType ?? 'SAILPOINT'
@@ -441,7 +452,7 @@ export const sailpointSearchAggregateTool = defineSailPointTool<SailPointSearchA
   input: (params) => {
     validatePagination(params.limit, params.offset)
     return {
-      ...searchInput(params),
+      ...searchInput(params, false, true),
       limit: params.limit,
       offset: params.offset,
       count: params.count,