fix(knowledge): reject tag-filter operators invalid for the field type

Greptile P2: documentTagFilterSchema accepted any non-empty operator string, so
an unsupported operator was silently dropped by the query builder instead of
returning 400. Validate the operator against the field type's allowed set
(single source of truth in filters/types) via superRefine.

Author: waleedlatif1

apps/sim/lib/api/contracts/knowledge/documents.test.ts

@@ -43,4 +43,21 @@ describe('parseDocumentTagFiltersParam', () => {
   it('throws when the shape is wrong', () => {
     expect(() => parseDocumentTagFiltersParam(JSON.stringify([{ tagSlot: '' }]))).toThrow()
   })
+
+  it('rejects an operator that is not valid for the field type', () => {
+    // unknown operator
+    expect(() =>
+      parseDocumentTagFiltersParam(
+        JSON.stringify([{ tagSlot: 'tag1', fieldType: 'text', operator: 'bogus', value: 'x' }])
+      )
+    ).toThrow()
+    // valid operator name, wrong field type (contains is text-only)
+    expect(() =>
+      parseDocumentTagFiltersParam(
+        JSON.stringify([
+          { tagSlot: 'number1', fieldType: 'number', operator: 'contains', value: '1' },
+        ])
+      )
+    ).toThrow()
+  })
 })

apps/sim/lib/api/contracts/knowledge/documents.ts

@@ -13,14 +13,28 @@ import {
   wireDateSchema,
 } from '@/lib/api/contracts/knowledge/shared'
 import { defineRouteContract } from '@/lib/api/contracts/types'
+import { getOperatorsForFieldType } from '@/lib/knowledge/filters/types'
 
-export const documentTagFilterSchema = z.object({
-  tagSlot: z.string().min(1),
-  fieldType: z.enum(['text', 'number', 'date', 'boolean']),
-  operator: z.string().min(1),
-  value: z.unknown(),
-  valueTo: z.unknown().optional(),
-})
+export const documentTagFilterSchema = z
+  .object({
+    tagSlot: z.string().min(1),
+    fieldType: z.enum(['text', 'number', 'date', 'boolean']),
+    operator: z.string().min(1),
+    value: z.unknown(),
+    valueTo: z.unknown().optional(),
+  })
+  .superRefine((filter, ctx) => {
+    // Reject operators that aren't valid for the field type so a bad operator
+    // returns a 400 instead of being silently dropped by the query builder.
+    const validOperators = getOperatorsForFieldType(filter.fieldType).map((op) => op.value)
+    if (!validOperators.includes(filter.operator)) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['operator'],
+        message: `Unsupported operator "${filter.operator}" for a ${filter.fieldType} tag filter`,
+      })
+    }
+  })
 export type DocumentTagFilter = z.output<typeof documentTagFilterSchema>
 
 export const listKnowledgeDocumentsQuerySchema = z.object({