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

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

package/src/fetchers/redshift.ts

@@ -2,6 +2,7 @@ import {
   replaceSecretReference,
   generateDateFormatterCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
 
@@ -56,6 +57,8 @@ const getClient = () => {
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateSearchEscapeHelpersCode()}
 
 ${generateDateFormatterCode()}
@@ -119,54 +122,39 @@ export default async function handler(req, res) {
     }
     
     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 = sanitizeIdentifier(filter.source)
-          const value = filter.destination
-          const operand = filter.operand || '='
+      if (filterTree) {
+        const buildCondition = (condition) => {
+          const field = sanitizeIdentifier(condition.source)
+          const value = condition.destination
+          const operand = condition.operand
           
           if (Array.isArray(value)) {
-            if (value.length === 0) return
+            if (value.length === 0) return null
             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 (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++
-            }
+            return operand === '!='
+              ? \`\${field} NOT IN (\${placeholders.join(', ')})\`
+              : \`\${field} IN (\${placeholders.join(', ')})\`
           }
-        })
-      } else {
-        Object.entries(parsedFilters).forEach(([key, value]) => {
-          const field = sanitizeIdentifier(key)
-          if (Array.isArray(value)) {
-            const placeholders = value.map(() => \`$\${paramIndex++}\`)
-            queryParams.push(...value)
-            conditions.push(\`\${field} IN (\${placeholders.join(', ')})\`)
-          } else {
-            conditions.push(\`\${field} = $\${paramIndex}\`)
-            queryParams.push(value)
-            paramIndex++
+          
+          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)
       }
     }
     

package/src/fetchers/rest-api.ts

@@ -2,6 +2,7 @@ import {
   generateDateFormatterCode,
   generateSortFilterHelperCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
 } from '../utils'
 
 export const validateRESTAPIConfig = (
@@ -87,6 +88,8 @@ ${generateDateFormatterCode()}
 
 ${generateSortFilterHelperCode()}
 
+${generateFilterTreeHelpersCode()}
+
 export default async function handler(req, res) {
   try {
     const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, sorts, offset } = req.query
@@ -160,17 +163,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 === '!=') {
@@ -181,17 +181,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/supabase.ts

@@ -3,6 +3,7 @@ import {
   generateDateFormatterCode,
   generateSafeJSONParseCode,
   generateSearchEscapeHelpersCode,
+  generateFilterTreeHelpersCode,
 } from '../utils'
 
 export const validateSupabaseConfig = (
@@ -127,6 +128,8 @@ const getClient = () => {
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateSearchEscapeHelpersCode()}
 
 // Helper function to process filter values
@@ -144,12 +147,12 @@ const applyFilters = (queryRef, filters) => {
   const parsedFilters = 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 || '='
+    const filterTree = normalizeFilterTree(parsedFilters)
+    
+    const applyCondition = (condition) => {
+      const field = condition.source
+      const value = condition.destination
+      const operand = condition.operand
       
       if (Array.isArray(value)) {
         const processedValues = value.map(processFilterValue)
@@ -158,43 +161,103 @@ const applyFilters = (queryRef, filters) => {
         } else {
           queryRef = queryRef.in(field, processedValues)
         }
-      } else {
-        const processedValue = processFilterValue(value)
-        
-        // Handle null values
-        if (processedValue === null) {
-          if (operand === '=') {
-            queryRef = queryRef.is(field, null)
-          } else if (operand === '!=') {
-            queryRef = queryRef.not(field, 'is', null)
-          }
-        } else {
-          // Map operand to Supabase methods
-          switch (operand) {
-            case '=':
-              queryRef = queryRef.eq(field, processedValue)
-              break
-            case '!=':
-              queryRef = queryRef.neq(field, processedValue)
-              break
-            case '>':
-              queryRef = queryRef.gt(field, processedValue)
-              break
-            case '>=':
-              queryRef = queryRef.gte(field, processedValue)
-              break
-            case '<':
-              queryRef = queryRef.lt(field, processedValue)
-              break
-            case '<=':
-              queryRef = queryRef.lte(field, processedValue)
-              break
-            default:
-              queryRef = queryRef.eq(field, processedValue)
-          }
+        return
+      }
+      
+      const processedValue = processFilterValue(value)
+      
+      // Handle null values
+      if (processedValue === null) {
+        if (operand === '=') {
+          queryRef = queryRef.is(field, null)
+        } else if (operand === '!=') {
+          queryRef = queryRef.not(field, 'is', null)
         }
+        return
       }
-    })
+      
+      // Map operand to Supabase methods
+      switch (operand) {
+        case '!=':
+          queryRef = queryRef.neq(field, processedValue)
+          break
+        case '>':
+          queryRef = queryRef.gt(field, processedValue)
+          break
+        case '>=':
+          queryRef = queryRef.gte(field, processedValue)
+          break
+        case '<':
+          queryRef = queryRef.lt(field, processedValue)
+          break
+        case '<=':
+          queryRef = queryRef.lte(field, processedValue)
+          break
+        default:
+          queryRef = queryRef.eq(field, processedValue)
+      }
+    }
+    
+    // An OR group cannot be expressed by chaining (chained filters are ANDed),
+    // so it is emitted as one PostgREST or=(...) expression instead.
+    const POSTGREST_OPERANDS = { '=': 'eq', '!=': 'neq', '>': 'gt', '>=': 'gte', '<': 'lt', '<=': 'lte' }
+    
+    const toExprValue = (value) => {
+      if (value === null || value === undefined) return 'null'
+      const asString = String(value)
+      return /[,.:()"\\s]/.test(asString) ? '"' + asString.replace(/"/g, '\\\\"') + '"' : asString
+    }
+    
+    const conditionToExpr = (condition) => {
+      const field = condition.source
+      const value = condition.destination
+      const operand = condition.operand
+      
+      if (Array.isArray(value)) {
+        const list = '(' + value.map((entry) => toExprValue(processFilterValue(entry))).join(',') + ')'
+        return operand === '!=' ? field + '.not.in.' + list : field + '.in.' + list
+      }
+      
+      const processedValue = processFilterValue(value)
+      if (processedValue === null) {
+        return operand === '!=' ? field + '.not.is.null' : field + '.is.null'
+      }
+      
+      return field + '.' + (POSTGREST_OPERANDS[operand] || 'eq') + '.' + toExprValue(processedValue)
+    }
+    
+    const nodeToExpr = (node) => {
+      if (node.type === 'group') {
+        const parts = node.children.map(nodeToExpr).filter(Boolean)
+        if (parts.length === 0) return null
+        if (parts.length === 1) return parts[0]
+        return (node.operator === 'or' ? 'or' : 'and') + '(' + parts.join(',') + ')'
+      }
+      return conditionToExpr(node)
+    }
+    
+    const applyNode = (node) => {
+      if (node.type !== 'group') {
+        applyCondition(node)
+        return
+      }
+      if (node.operator === 'and') {
+        node.children.forEach(applyNode)
+        return
+      }
+      if (node.children.length === 1) {
+        applyNode(node.children[0])
+        return
+      }
+      const parts = node.children.map(nodeToExpr).filter(Boolean)
+      if (parts.length > 0) {
+        queryRef = queryRef.or(parts.join(','))
+      }
+    }
+    
+    if (filterTree) {
+      applyNode(filterTree)
+    }
   } else {
     // Old format: object with key-value pairs (backward compatibility)
     Object.entries(parsedFilters).forEach(([key, value]) => {

package/src/fetchers/teleport.ts

@@ -2,6 +2,7 @@ import {
   replaceSecretReference,
   generateDateFormatterCode,
   generateSafeJSONParseCode,
+  generateFilterTreeHelpersCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
 import {
@@ -146,81 +147,69 @@ const getClient = () => {
 
 ${generateSafeJSONParseCode()}
 
+${generateFilterTreeHelpersCode()}
+
 ${generateSearchEscapeHelpersCode()}
 ${getTransformationCode(tableName, transformOptions)}
 ${getTransformWrapperCode(tableName)}
 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') {
-          // Row column is a JSON array (e.g. category_ids). Match when it
-          // shares any element with the destination set. jsonb ?| (function
-          // form) avoids the '?' placeholder-token ambiguity some drivers hit.
-          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') {
+        // Row column is a JSON array (e.g. category_ids). Match when it
+        // shares any element with the destination set. jsonb ?| (function
+        // form) avoids the '?' placeholder-token ambiguity some drivers hit.
+        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
 }