@teleporthq/teleport-plugin-next-data-source 0.43.62 → 0.43.64

package/src/fetchers/google-sheets.ts

@@ -1,4 +1,8 @@
-import { generateSortFilterHelperCode, generateSafeJSONParseCode } from '../utils'
+import {
+  generateSortFilterHelperCode,
+  generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
+} from '../utils'
 import { generateHeaderDetectionCode } from './utils/header-detection'
 
 export const validateGoogleSheetsConfig = (
@@ -53,6 +57,8 @@ ${generateSafeJSONParseCode()}
 
 ${generateSortFilterHelperCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateHeaderDetectionCode()}
 
 export default async function handler(req, res) {
@@ -280,18 +286,16 @@ export default async function handler(req, res) {
     }
     
     if (filters) {
-      const parsedFilters = safeJSONParse(filters)
+      const filterTree = normalizeFilterTree(safeJSONParse(filters))
       
-      if (Array.isArray(parsedFilters)) {
-        filteredData = filteredData.filter((item) => {
-          return parsedFilters.every((filter) => {
-            if (!filter.source || filter.destination === undefined) return true
-            
+      if (filterTree) {
+        filteredData = filteredData.filter((item) =>
+          evaluateFilterTree(filterTree, (condition) => {
             // Map label to column ID
-            const field = labelToIdMap[filter.source] || filter.source
+            const field = labelToIdMap[condition.source] || condition.source
             const value = getNestedValue(item, field)
-            const target = filter.destination
-            const operand = filter.operand || '='
+            const target = condition.destination
+            const operand = condition.operand
             
             if (Array.isArray(target)) {
               if (operand === '!=') {
@@ -302,19 +306,7 @@ export default async function handler(req, res) {
             
             return compareValues(value, target, operand)
           })
-        })
-      } else {
-        filteredData = filteredData.filter((item) => {
-          return Object.entries(parsedFilters).every(([key, value]) => {
-            // Map label to column ID
-            const field = labelToIdMap[key] || key
-            const itemValue = getNestedValue(item, field)
-            if (Array.isArray(value)) {
-              return value.includes(itemValue)
-            }
-            return compareValues(itemValue, value, '=')
-          })
-        })
+        )
       }
     }
     

package/src/fetchers/javascript.ts

@@ -2,6 +2,7 @@ import {
   generateDateFormatterCode,
   generateSortFilterHelperCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
 } from '../utils'
 
 export const validateJavaScriptConfig = (
@@ -47,6 +48,8 @@ ${generateDateFormatterCode()}
 
 ${generateSortFilterHelperCode()}
 
+${generateFilterTreeHelpersCode()}
+
 export default async function handler(req, res) {
   try {
     const { limit, offset, page, perPage, query, queryColumns, sortBy, sortOrder, filters, sorts } = req.query
@@ -87,17 +90,14 @@ export default async function handler(req, res) {
       
       if (filters) {
         try {
-          const parsedFilters = safeJSONParse(filters)
+          const filterTree = normalizeFilterTree(safeJSONParse(filters))
           
-          if (Array.isArray(parsedFilters)) {
-            data = data.filter((item) => {
-              return parsedFilters.every((filter) => {
-                if (!filter.source || filter.destination === undefined) return true
-                
-                const field = filter.source
-                const value = getNestedValue(item, field)
-                const target = filter.destination
-                const operand = filter.operand || '='
+          if (filterTree) {
+            data = data.filter((item) =>
+              evaluateFilterTree(filterTree, (condition) => {
+                const value = getNestedValue(item, condition.source)
+                const target = condition.destination
+                const operand = condition.operand
                 
                 if (Array.isArray(target)) {
                   if (operand === '!=') {
@@ -108,17 +108,7 @@ export default async function handler(req, res) {
                 
                 return compareValues(value, target, operand)
               })
-            })
-          } else {
-            data = data.filter((item) => {
-              return Object.entries(parsedFilters).every(([key, value]) => {
-                const itemValue = getNestedValue(item, key)
-                if (Array.isArray(value)) {
-                  return value.includes(itemValue)
-                }
-                return compareValues(itemValue, value, '=')
-              })
-            })
+            )
           }
         } catch (err) {
           console.error('Error parsing filters:', err)

package/src/fetchers/mariadb.ts

@@ -2,6 +2,7 @@ import {
   replaceSecretReference,
   generateDateFormatterCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
 
@@ -27,58 +28,46 @@ export const generateMariaDBFetcher = (
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateSearchEscapeHelpersCode()}
 
 // Helper function to process filters and build conditions
 const processFilters = (filters, conditions, queryParams) => {
   if (!filters) return
   
-  const parsedFilters = safeJSONParse(filters)
+  const filterTree = normalizeFilterTree(safeJSONParse(filters))
+  if (!filterTree) return
   
-  if (Array.isArray(parsedFilters)) {
-    parsedFilters.forEach((filter) => {
-      if (!filter.source || filter.destination === undefined) return
-      
-      const field = \`\\\`\${filter.source}\\\`\`
-      const value = filter.destination
-      const operand = filter.operand || '='
-      
-      if (Array.isArray(value)) {
-        if (value.length === 0) return
-        const placeholders = value.map(() => '?').join(', ')
-        queryParams.push(...value)
-        if (operand === '!=') {
-          conditions.push(\`\${field} NOT IN (\${placeholders})\`)
-        } else {
-          conditions.push(\`\${field} IN (\${placeholders})\`)
-        }
-      } else {
-        if (value === null) {
-          if (operand === '=') {
-            conditions.push(\`\${field} IS NULL\`)
-          } else if (operand === '!=') {
-            conditions.push(\`\${field} IS NOT NULL\`)
-          }
-        } else {
-          const validOps = ['=', '!=', '>', '<', '>=', '<=']
-          const sqlOperator = validOps.includes(operand) ? operand : '='
-          conditions.push(\`\${field} \${sqlOperator} ?\`)
-          queryParams.push(value)
-        }
-      }
-    })
-  } else {
-    Object.entries(parsedFilters).forEach(([key, value]) => {
-      if (Array.isArray(value)) {
-        const placeholders = value.map(() => '?').join(', ')
-        queryParams.push(...value)
-        conditions.push(\`\\\`\${key}\\\` IN (\${placeholders})\`)
-      } else {
-        conditions.push(\`\\\`\${key}\\\` = ?\`)
-        queryParams.push(value)
-      }
-    })
+  const buildCondition = (condition) => {
+    const field = \`\\\`\${condition.source}\\\`\`
+    const value = condition.destination
+    const operand = condition.operand
+    
+    if (Array.isArray(value)) {
+      if (value.length === 0) return null
+      const placeholders = value.map(() => '?').join(', ')
+      queryParams.push(...value)
+      return operand === '!='
+        ? \`\${field} NOT IN (\${placeholders})\`
+        : \`\${field} IN (\${placeholders})\`
+    }
+    
+    if (value === null) {
+      if (operand === '=') return \`\${field} IS NULL\`
+      if (operand === '!=') return \`\${field} IS NOT NULL\`
+      return null
+    }
+    
+    // Validate operator to prevent SQL injection
+    const validOps = ['=', '!=', '>', '<', '>=', '<=']
+    const sqlOperator = validOps.includes(operand) ? operand : '='
+    queryParams.push(value)
+    return \`\${field} \${sqlOperator} ?\`
   }
+  
+  const clause = buildFilterTreeClause(filterTree, buildCondition)
+  if (clause) conditions.push(clause)
 }
 
 ${generateDateFormatterCode()}

package/src/fetchers/mongodb.ts

@@ -2,6 +2,7 @@ import {
   replaceSecretReference,
   generateDateFormatterCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
 } from '../utils'
 
 export const validateMongoDBConfig = (
@@ -73,95 +74,79 @@ export const generateMongoDBFetcher = (
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 // Helper function to process filters
 const processFilters = (filters, filter) => {
   if (!filters) return
   
-  const parsedFilters = safeJSONParse(filters)
+  const filterTree = normalizeFilterTree(safeJSONParse(filters))
+  if (!filterTree) return
   
-  if (Array.isArray(parsedFilters)) {
-    parsedFilters.forEach((filterItem) => {
-      if (!filterItem.source || filterItem.destination === undefined) return
-      
-      const field = filterItem.source
-      const value = filterItem.destination
-      const operand = filterItem.operand || '='
-      
-      // Handle _id specially
-      const processValue = (v) => {
-        if (field === '_id' && typeof v === 'string') {
-          try {
-            return new ObjectId(v)
-          } catch (e) {
-            return v
-          }
-        }
+  const processValue = (field, v) => {
+    if (field === '_id' && typeof v === 'string') {
+      try {
+        return new ObjectId(v)
+      } catch (e) {
         return v
       }
-      
-      if (Array.isArray(value)) {
-        const processedValues = value.map(processValue)
-        if (operand === '!=') {
-          filter[field] = { $nin: processedValues }
-        } else {
-          filter[field] = { $in: processedValues }
-        }
-      } else {
-        const processedValue = processValue(value)
-        
-        // Handle null values
-        if (processedValue === null) {
-          if (operand === '=') {
-            filter[field] = null
-          } else if (operand === '!=') {
-            filter[field] = { $ne: null }
-          }
-        } else {
-          // Map operand to MongoDB operators
-          switch (operand) {
-            case '=':
-              filter[field] = processedValue
-              break
-            case '!=':
-              filter[field] = { $ne: processedValue }
-              break
-            case '>':
-              filter[field] = { $gt: processedValue }
-              break
-            case '>=':
-              filter[field] = { $gte: processedValue }
-              break
-            case '<':
-              filter[field] = { $lt: processedValue }
-              break
-            case '<=':
-              filter[field] = { $lte: processedValue }
-              break
-            default:
-              filter[field] = processedValue
-          }
-        }
-      }
-    })
-  } else {
-    Object.entries(parsedFilters).forEach(([key, value]) => {
-      if (key === '_id') {
-        if (Array.isArray(value)) {
-          filter[key] = {
-            $in: value.map((id) => (typeof id === 'string' ? new ObjectId(id) : id))
-          }
-        } else if (typeof value === 'string') {
-          filter[key] = new ObjectId(value)
-        } else {
-          filter[key] = value
-        }
-      } else if (Array.isArray(value)) {
-        filter[key] = { $in: value }
-      } else {
-        filter[key] = value
-      }
-    })
+    }
+    return v
   }
+  
+  const buildCondition = (condition) => {
+    const field = condition.source
+    const value = condition.destination
+    const operand = condition.operand
+    
+    if (Array.isArray(value)) {
+      const processedValues = value.map((entry) => processValue(field, entry))
+      return operand === '!='
+        ? { [field]: { $nin: processedValues } }
+        : { [field]: { $in: processedValues } }
+    }
+    
+    const processedValue = processValue(field, value)
+    
+    if (processedValue === null) {
+      if (operand === '=') return { [field]: null }
+      if (operand === '!=') return { [field]: { $ne: null } }
+      return null
+    }
+    
+    switch (operand) {
+      case '!=':
+        return { [field]: { $ne: processedValue } }
+      case '>':
+        return { [field]: { $gt: processedValue } }
+      case '>=':
+        return { [field]: { $gte: processedValue } }
+      case '<':
+        return { [field]: { $lt: processedValue } }
+      case '<=':
+        return { [field]: { $lte: processedValue } }
+      default:
+        return { [field]: processedValue }
+    }
+  }
+  
+  const buildNode = (node) => {
+    if (node.type === 'group') {
+      const parts = node.children.map(buildNode).filter(Boolean)
+      if (parts.length === 0) return null
+      if (parts.length === 1) return parts[0]
+      return node.operator === 'or' ? { $or: parts } : { $and: parts }
+    }
+    return buildCondition(node)
+  }
+  
+  const query = buildNode(filterTree)
+  if (!query) return
+  
+  // Merged under $and rather than assigned onto filter directly: the search
+  // above may already own filter.$or, and two conditions on the same field
+  // would otherwise overwrite each other.
+  filter.$and = (filter.$and || []).concat([query])
 }
 
 ${generateDateFormatterCode()}

package/src/fetchers/mysql.ts

@@ -2,6 +2,7 @@ import {
   replaceSecretReference,
   generateDateFormatterCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
 
@@ -64,59 +65,46 @@ const getConnection = () => {
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateSearchEscapeHelpersCode()}
 
 // Helper function to process filters and build conditions
 const processFilters = (filters, conditions, queryParams) => {
   if (!filters) return
   
-  const parsedFilters = safeJSONParse(filters)
+  const filterTree = normalizeFilterTree(safeJSONParse(filters))
+  if (!filterTree) return
   
-  if (Array.isArray(parsedFilters)) {
-    parsedFilters.forEach((filter) => {
-      if (!filter.source || filter.destination === undefined) return
-      
-      const field = mysql.escapeId(filter.source)
-      const value = filter.destination
-      const operand = filter.operand || '='
-      
-      if (Array.isArray(value)) {
-        if (value.length === 0) return
-        const placeholders = value.map(() => '?').join(', ')
-        queryParams.push(...value)
-        if (operand === '!=') {
-          conditions.push(\`\${field} NOT IN (\${placeholders})\`)
-        } else {
-          conditions.push(\`\${field} IN (\${placeholders})\`)
-        }
-      } else {
-        if (value === null) {
-          if (operand === '=') {
-            conditions.push(\`\${field} IS NULL\`)
-          } else if (operand === '!=') {
-            conditions.push(\`\${field} IS NOT NULL\`)
-          }
-        } else {
-          // Validate operator to prevent SQL injection
-          const validOps = ['=', '!=', '>', '<', '>=', '<=']
-          const sqlOperator = validOps.includes(operand) ? operand : '='
-          conditions.push(\`\${field} \${sqlOperator} ?\`)
-          queryParams.push(value)
-        }
-      }
-    })
-  } else {
-    Object.entries(parsedFilters).forEach(([key, value]) => {
-      if (Array.isArray(value)) {
-        const placeholders = value.map(() => '?').join(', ')
-        queryParams.push(...value)
-        conditions.push(\`\${mysql.escapeId(key)} IN (\${placeholders})\`)
-      } else {
-        conditions.push(\`\${mysql.escapeId(key)} = ?\`)
-        queryParams.push(value)
-      }
-    })
+  const buildCondition = (condition) => {
+    const field = mysql.escapeId(condition.source)
+    const value = condition.destination
+    const operand = condition.operand
+    
+    if (Array.isArray(value)) {
+      if (value.length === 0) return null
+      const placeholders = value.map(() => '?').join(', ')
+      queryParams.push(...value)
+      return operand === '!='
+        ? \`\${field} NOT IN (\${placeholders})\`
+        : \`\${field} IN (\${placeholders})\`
+    }
+    
+    if (value === null) {
+      if (operand === '=') return \`\${field} IS NULL\`
+      if (operand === '!=') return \`\${field} IS NOT NULL\`
+      return null
+    }
+    
+    // Validate operator to prevent SQL injection
+    const validOps = ['=', '!=', '>', '<', '>=', '<=']
+    const sqlOperator = validOps.includes(operand) ? operand : '='
+    queryParams.push(value)
+    return \`\${field} \${sqlOperator} ?\`
   }
+  
+  const clause = buildFilterTreeClause(filterTree, buildCondition)
+  if (clause) conditions.push(clause)
 }
 
 ${generateDateFormatterCode()}

package/src/fetchers/postgresql.ts

@@ -3,6 +3,7 @@ import {
   generateDateFormatterCode,
   generateSafeJSONParseCode,
   generateSearchEscapeHelpersCode,
+  generateFilterTreeHelpersCode,
 } from '../utils'
 import {
   generateSortFallbackFieldHelper,
@@ -62,78 +63,67 @@ const getClient = () => {
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateSearchEscapeHelpersCode()}
 
-// Helper function to process filters and build conditions
+// Builds one SQL clause for the whole filter tree, so an OR group nested in
+// the root AND keeps its meaning instead of being flattened into ANDs.
 const processFilters = (filters, conditions, queryParams, paramIndex) => {
   if (!filters) return paramIndex
   
-  const parsedFilters = safeJSONParse(filters)
+  const filterTree = normalizeFilterTree(safeJSONParse(filters))
+  if (!filterTree) return paramIndex
   
-  if (Array.isArray(parsedFilters)) {
-    parsedFilters.forEach((filter) => {
-      if (!filter.source || filter.destination === undefined) return
-      
-      const field = filter.source
-      const value = filter.destination
-      const operand = filter.operand || '='
-      
-      if (Array.isArray(value)) {
-        if (value.length === 0) return
-        if (operand === 'array_overlap') {
-          conditions.push(\`jsonb_exists_any(NULLIF(\${field}, '')::jsonb, $\${paramIndex}::text[])\`)
-          queryParams.push(value.map((entry) => String(entry)))
-          paramIndex++
-          return
-        }
-        const placeholders = value.map(() => \`$\${paramIndex++}\`)
-        queryParams.push(...value)
-        if (operand === '!=') {
-          conditions.push(\`\${field} NOT IN (\${placeholders.join(', ')})\`)
-        } else {
-          conditions.push(\`\${field} IN (\${placeholders.join(', ')})\`)
-        }
-      } else {
-        if (operand === 'array_overlap') {
-          if (value === '' || value === null || value === undefined) return
-          // A single comma-joined string (the multi-select Category Filter's
-          // ?categoryFilter=a,b,c) expands to multiple ids; one id stays one.
-          const overlapValues = String(value).split(',').map((entry) => entry.trim()).filter(Boolean)
-          if (overlapValues.length === 0) return
-          conditions.push(\`jsonb_exists_any(NULLIF(\${field}, '')::jsonb, $\${paramIndex}::text[])\`)
-          queryParams.push(overlapValues)
-          paramIndex++
-          return
-        }
-        if (value === null) {
-          if (operand === '=') {
-            conditions.push(\`\${field} IS NULL\`)
-          } else if (operand === '!=') {
-            conditions.push(\`\${field} IS NOT NULL\`)
-          }
-        } else {
-          const validOps = ['=', '!=', '>', '<', '>=', '<=']
-          const sqlOperator = validOps.includes(operand) ? operand : '='
-          conditions.push(\`\${field} \${sqlOperator} $\${paramIndex}\`)
-          queryParams.push(value)
-          paramIndex++
-        }
-      }
-    })
-  } else {
-    Object.entries(parsedFilters).forEach(([key, value]) => {
-      if (Array.isArray(value)) {
-        const placeholders = value.map(() => \`$\${paramIndex++}\`)
-        queryParams.push(...value)
-        conditions.push(\`\${key} IN (\${placeholders.join(', ')})\`)
-      } else {
-        conditions.push(\`\${key} = $\${paramIndex}\`)
-        queryParams.push(value)
+  const buildCondition = (condition) => {
+    const field = condition.source
+    const value = condition.destination
+    const operand = condition.operand
+    
+    if (Array.isArray(value)) {
+      if (value.length === 0) return null
+      if (operand === 'array_overlap') {
+        const clause = \`jsonb_exists_any(NULLIF(\${field}, '')::jsonb, $\${paramIndex}::text[])\`
+        queryParams.push(value.map((entry) => String(entry)))
         paramIndex++
+        return clause
       }
-    })
+      const placeholders = value.map(() => \`$\${paramIndex++}\`)
+      queryParams.push(...value)
+      return operand === '!='
+        ? \`\${field} NOT IN (\${placeholders.join(', ')})\`
+        : \`\${field} IN (\${placeholders.join(', ')})\`
+    }
+    
+    if (operand === 'array_overlap') {
+      if (value === '' || value === null || value === undefined) return null
+      // A single comma-joined string (the multi-select Category Filter's
+      // ?categoryFilter=a,b,c) expands to multiple ids; one id stays one.
+      const overlapValues = String(value).split(',').map((entry) => entry.trim()).filter(Boolean)
+      if (overlapValues.length === 0) return null
+      const clause = \`jsonb_exists_any(NULLIF(\${field}, '')::jsonb, $\${paramIndex}::text[])\`
+      queryParams.push(overlapValues)
+      paramIndex++
+      return clause
+    }
+    
+    if (value === null) {
+      if (operand === '=') return \`\${field} IS NULL\`
+      if (operand === '!=') return \`\${field} IS NOT NULL\`
+      return null
+    }
+    
+    const validOps = ['=', '!=', '>', '<', '>=', '<=']
+    const sqlOperator = validOps.includes(operand) ? operand : '='
+    const clause = \`\${field} \${sqlOperator} $\${paramIndex}\`
+    queryParams.push(value)
+    paramIndex++
+    return clause
   }
   
+  const clause = buildFilterTreeClause(filterTree, buildCondition)
+  if (clause) conditions.push(clause)
+  
   return paramIndex
 }
 

package/src/fetchers/redis.ts

@@ -2,6 +2,7 @@ import {
   replaceSecretReference,
   generateDateFormatterCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
 } from '../utils'
 
 export const validateRedisConfig = (
@@ -69,6 +70,8 @@ export const generateRedisFetcher = (config: Record<string, unknown>): string =>
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateDateFormatterCode()}
 
 export default async function handler(req, res) {
@@ -88,14 +91,12 @@ export default async function handler(req, res) {
     
     // Extract pattern from filters if available (new format)
     if (filters) {
-      const parsedFilters = safeJSONParse(filters)
-      if (Array.isArray(parsedFilters)) {
-        const patternFilter = parsedFilters.find(f => f.source === 'pattern')
+      const filterTree = normalizeFilterTree(safeJSONParse(filters))
+      if (filterTree) {
+        const patternFilter = flattenFilterConditions(filterTree).find((f) => f.source === 'pattern')
         if (patternFilter) {
           pattern = patternFilter.destination || pattern
         }
-      } else {
-        pattern = parsedFilters.pattern || pattern
       }
     }