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

package/src/fetchers/csv-file.ts

@@ -2,6 +2,7 @@ import {
   generateDateFormatterCode,
   generateSortFilterHelperCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
 } from '../utils'
 import { generateHeaderDetectionCode } from './utils/header-detection'
 
@@ -86,17 +87,15 @@ const generateHandlerBody = (): string => {
     }
     
     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
-            
-            const field = labelToIdMap[filter.source] || filter.source
+      if (filterTree) {
+        filteredData = filteredData.filter((item) =>
+          evaluateFilterTree(filterTree, (condition) => {
+            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 === '!=') {
@@ -107,18 +106,7 @@ const generateHandlerBody = (): string => {
             
             return compareValues(value, target, operand)
           })
-        })
-      } else {
-        filteredData = filteredData.filter((item) => {
-          return Object.entries(parsedFilters).every(([key, value]) => {
-            const field = labelToIdMap[key] || key
-            const itemValue = getNestedValue(item, field)
-            if (Array.isArray(value)) {
-              return value.includes(itemValue)
-            }
-            return compareValues(itemValue, value, '=')
-          })
-        })
+        )
       }
     }
     
@@ -227,6 +215,8 @@ ${generateDateFormatterCode()}
 
 ${generateSortFilterHelperCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateHeaderDetectionCode()}
 
 function parseCSVLine(line) {
@@ -335,6 +325,8 @@ ${generateDateFormatterCode()}
 
 ${generateSortFilterHelperCode()}
 
+${generateFilterTreeHelpersCode()}
+
 export default async function handler(req, res) {${generateHandlerBody()}
 }
 `

package/src/fetchers/firestore.ts

@@ -2,6 +2,7 @@ import {
   replaceSecretReference,
   generateDateFormatterCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
 } from '../utils'
 
 export const validateFirestoreConfig = (
@@ -73,6 +74,8 @@ const getFirestore = () => {
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateDateFormatterCode()}
 
 export default async function handler(req, res) {
@@ -83,46 +86,49 @@ export default async function handler(req, res) {
     let queryRef = firestore.collection('${tableName}')
     
     if (filters) {
-      const parsedFilters = safeJSONParse(filters)
+      const filterTree = normalizeFilterTree(safeJSONParse(filters))
       
-      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 || '='
-          
-          // Map operands to Firestore operators
-          const operatorMap = {
-            '=': '==',
-            '!=': '!=',
-            '>': '>',
-            '<': '<',
-            '>=': '>=',
-            '<=': '<=',
-          }
+      if (filterTree) {
+        // Chained .where() calls are ANDed, so an OR group is built with
+        // Firestore's composite Filter API instead.
+        const operatorMap = {
+          '=': '==',
+          '!=': '!=',
+          '>': '>',
+          '<': '<',
+          '>=': '>=',
+          '<=': '<=',
+        }
+        
+        const buildCondition = (condition) => {
+          const field = condition.source
+          const value = condition.destination
+          const operand = condition.operand
           
           if (Array.isArray(value)) {
-            if (value.length === 0) return
-            if (operand === '!=') {
-              queryRef = queryRef.where(field, 'not-in', value)
-            } else {
-              queryRef = queryRef.where(field, 'in', value)
-            }
-          } else {
-            const firestoreOp = operatorMap[operand] || '=='
-            queryRef = queryRef.where(field, firestoreOp, value)
+            if (value.length === 0) return null
+            return admin.firestore.Filter.where(field, operand === '!=' ? 'not-in' : 'in', value)
           }
-        })
-      } else {
-        Object.entries(parsedFilters).forEach(([key, value]) => {
-          if (Array.isArray(value)) {
-            queryRef = queryRef.where(key, 'in', value)
-          } else {
-            queryRef = queryRef.where(key, '==', value)
+          
+          return admin.firestore.Filter.where(field, operatorMap[operand] || '==', value)
+        }
+        
+        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'
+              ? admin.firestore.Filter.or(...parts)
+              : admin.firestore.Filter.and(...parts)
           }
-        })
+          return buildCondition(node)
+        }
+        
+        const filterExpression = buildNode(filterTree)
+        if (filterExpression) {
+          queryRef = queryRef.where(filterExpression)
+        }
       }
     }
     

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()}