@teleporthq/teleport-plugin-next-data-source 0.42.9 → 0.42.11

package/src/fetchers/firestore.ts

@@ -1,4 +1,8 @@
-import { replaceSecretReference, generateDateFormatterCode } from '../utils'
+import {
+  replaceSecretReference,
+  generateDateFormatterCode,
+  generateSafeJSONParseCode,
+} from '../utils'
 
 export const validateFirestoreConfig = (
   config: Record<string, unknown>
@@ -67,31 +71,67 @@ const getFirestore = () => {
   return firestore
 }
 
+${generateSafeJSONParseCode()}
+
 ${generateDateFormatterCode()}
 
 export default async function handler(req, res) {
   try {
     const firestore = getFirestore()
-    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset } = req.query
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, sorts, offset } = req.query
     
     let queryRef = firestore.collection('${tableName}')
     
     if (filters) {
-      const parsedFilters = JSON.parse(filters)
-      Object.entries(parsedFilters).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          queryRef = queryRef.where(key, 'in', value)
-        } else {
-          queryRef = queryRef.where(key, '==', value)
-        }
-      })
+      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 || '='
+          
+          // Map operands to Firestore operators
+          const operatorMap = {
+            '=': '==',
+            '!=': '!=',
+            '>': '>',
+            '<': '<',
+            '>=': '>=',
+            '<=': '<=',
+          }
+          
+          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)
+          }
+        })
+      } else {
+        Object.entries(parsedFilters).forEach(([key, value]) => {
+          if (Array.isArray(value)) {
+            queryRef = queryRef.where(key, 'in', value)
+          } else {
+            queryRef = queryRef.where(key, '==', value)
+          }
+        })
+      }
     }
     
     let usePostFiltering = false
     
     if (query) {
       if (queryColumns) {
-        const columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
+        const parsed = safeJSONParse(queryColumns)
+        const columns = Array.isArray(parsed) ? parsed : [parsed]
         for (const column of columns) {
           queryRef = queryRef
             .where(column, '>=', query)
@@ -104,7 +144,17 @@ export default async function handler(req, res) {
       }
     }
     
-    if (sortBy) {
+    // Handle sorts - new array format
+    if (sorts) {
+      const parsedSorts = safeJSONParse(sorts)
+      if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
+        parsedSorts.forEach((sort) => {
+          if (!sort.field) return
+          const order = sort.order?.toLowerCase() === 'desc' ? 'desc' : 'asc'
+          queryRef = queryRef.orderBy(sort.field, order)
+        })
+      }
+    } else if (sortBy) {
       const sortOrderValue = sortOrder?.toLowerCase() === 'desc' ? 'desc' : 'asc'
       queryRef = queryRef.orderBy(sortBy, sortOrderValue)
     }

package/src/fetchers/google-sheets.ts

@@ -1,3 +1,6 @@
+import { generateSortFilterHelperCode, generateSafeJSONParseCode } from '../utils'
+import { generateHeaderDetectionCode } from './utils/header-detection'
+
 export const validateGoogleSheetsConfig = (
   config: Record<string, unknown>
 ): { isValid: boolean; error?: string } => {
@@ -33,18 +36,33 @@ interface GoogleSheetsConfig {
   sheetName?: string
   range?: string
   maxRows?: number
+  autoDetectHeader?: boolean
+  firstRowIsHeader?: boolean
+  columns?: Array<{ id: string; label?: string; type?: string }>
 }
 
 export const generateGoogleSheetsFetcher = (config: Record<string, unknown>): string => {
   const sheetsConfig = config as GoogleSheetsConfig
+  const autoDetectHeader = sheetsConfig.autoDetectHeader
+  const firstRowIsHeader = sheetsConfig.firstRowIsHeader
+  const configColumns = sheetsConfig.columns || []
+
   return `import fetch from 'node-fetch'
 
+${generateSafeJSONParseCode()}
+
+${generateSortFilterHelperCode()}
+
+${generateHeaderDetectionCode()}
+
 export default async function handler(req, res) {
   try {
     const sheetUrl = ${JSON.stringify(sheetsConfig.sheetUrl)}
     let sheetId = ${JSON.stringify(sheetsConfig.sheetId)}
     const range = ${JSON.stringify(sheetsConfig.range || 'A1:Z1000')}
     const maxRows = ${sheetsConfig.maxRows || 0}
+    const autoDetectHeader = ${autoDetectHeader !== undefined ? autoDetectHeader : true}
+    const firstRowIsHeader = ${firstRowIsHeader !== undefined ? firstRowIsHeader : true}
     
     if (!sheetId && sheetUrl) {
       const match = sheetUrl.match(/\\/d\\/([a-zA-Z0-9-_]+)/)
@@ -158,26 +176,40 @@ export default async function handler(req, res) {
     const firstRow = rawRows[0]
     const firstRowValues = firstRow.c.map((cell) => cell?.v ?? cell?.f ?? null)
     
-    const hasHeaderRow = firstRowValues.every((val) => 
-      val !== null && val !== undefined && val !== '' && typeof val === 'string'
-    )
+    const shouldAutoDetect = autoDetectHeader !== false
+    let hasHeaderRow = false
+    
+    if (shouldAutoDetect) {
+      hasHeaderRow = detectHeaderRow(firstRowValues, rawRows)
+    } else {
+      hasHeaderRow = firstRowIsHeader !== false
+    }
+    
+    const configColumns = ${JSON.stringify(configColumns)}
+    const useConfigColumns = configColumns && configColumns.length > 0
     
     let columns
     let dataRows
     
     if (hasHeaderRow && rawRows.length > 1) {
-      columns = firstRowValues.map((headerValue, index) => ({
-        id: \`col_\${index}\`,
-        label: String(headerValue),
-        type: 'string'
-      }))
+      columns = table.cols.map((col, index) => {
+        const configCol = useConfigColumns ? configColumns[index] : null
+        return {
+          id: configCol?.id || col.id || \`col_\${index}\`,
+          label: String(firstRowValues[index] || col.label || configCol?.label || \`Column \${index + 1}\`),
+          type: configCol?.type || col.type || 'string'
+        }
+      })
       dataRows = rawRows.slice(1)
     } else {
-      columns = table.cols.map((col, index) => ({
-        id: col.id || \`col_\${index}\`,
-        label: col.label || \`Column \${index + 1}\`,
-        type: col.type || 'string'
-      }))
+      columns = table.cols.map((col, index) => {
+        const configCol = useConfigColumns ? configColumns[index] : null
+        return {
+          id: configCol?.id || col.id || \`col_\${index}\`,
+          label: configCol?.label || col.label || \`Column \${index + 1}\`,
+          type: configCol?.type || col.type || 'string'
+        }
+      })
       dataRows = rawRows
     }
     
@@ -212,7 +244,13 @@ export default async function handler(req, res) {
       return filteredRow
     })
     
-    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset: offsetParam } = req.query
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, sorts, offset: offsetParam } = req.query
+    
+    // Create label-to-ID mapping for filters and sorts
+    const labelToIdMap = {}
+    columnsWithData.forEach((col) => {
+      labelToIdMap[col.label] = col.id
+    })
     
     let filteredData = [...filteredRows]
     
@@ -220,10 +258,12 @@ export default async function handler(req, res) {
       const searchQuery = query.toLowerCase()
       
       if (queryColumns) {
-        const searchColumns = JSON.parse(queryColumns)
+        const searchColumns = safeJSONParse(queryColumns)
         filteredData = filteredData.filter((item) => {
           return searchColumns.some((col) => {
-            const value = item[col]
+            // Map label to column ID
+            const field = labelToIdMap[col] || col
+            const value = getNestedValue(item, field)
             return value && String(value).toLowerCase().includes(searchQuery)
           })
         })
@@ -240,25 +280,102 @@ export default async function handler(req, res) {
     }
     
     if (filters) {
-      const parsedFilters = JSON.parse(filters)
-      filteredData = filteredData.filter((item) => {
-        return Object.entries(parsedFilters).every(([key, value]) => {
-          if (Array.isArray(value)) {
-            return value.includes(item[key])
-          }
-          return item[key] === value
+      const parsedFilters = safeJSONParse(filters)
+      
+      if (Array.isArray(parsedFilters)) {
+        filteredData = filteredData.filter((item) => {
+          return parsedFilters.every((filter) => {
+            if (!filter.source || filter.destination === undefined) return true
+            
+            // Map label to column ID
+            const field = labelToIdMap[filter.source] || filter.source
+            const value = getNestedValue(item, field)
+            const target = filter.destination
+            const operand = filter.operand || '='
+            
+            if (Array.isArray(target)) {
+              if (operand === '!=') {
+                return !target.includes(value)
+              }
+              return target.includes(value)
+            }
+            
+            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, '=')
+          })
+        })
+      }
     }
     
-    if (sortBy) {
+    if (sorts) {
+      const parsedSorts = safeJSONParse(sorts)
+      if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
+        filteredData.sort((a, b) => {
+          for (const sort of parsedSorts) {
+            if (!sort.field) continue
+            // Map label to column ID
+            const field = labelToIdMap[sort.field] || sort.field
+            const aVal = getNestedValue(a, field)
+            const bVal = getNestedValue(b, field)
+            const sortOrderValue = sort.order?.toLowerCase() === 'desc' ? -1 : 1
+            
+            let comparison = 0
+            if (aVal === null || aVal === undefined) {
+              comparison = bVal === null || bVal === undefined ? 0 : -1
+            } else if (bVal === null || bVal === undefined) {
+              comparison = 1
+            } else if (typeof aVal === 'number' && typeof bVal === 'number') {
+              comparison = aVal - bVal
+            } else if (aVal instanceof Date && bVal instanceof Date) {
+              comparison = aVal.getTime() - bVal.getTime()
+            } else {
+              const aStr = String(aVal)
+              const bStr = String(bVal)
+              if (aStr < bStr) comparison = -1
+              else if (aStr > bStr) comparison = 1
+            }
+            
+            if (comparison !== 0) return comparison * sortOrderValue
+          }
+          return 0
+        })
+      }
+    } else if (sortBy) {
       filteredData.sort((a, b) => {
-        const aVal = a[sortBy]
-        const bVal = b[sortBy]
+        // Map label to column ID
+        const field = labelToIdMap[sortBy] || sortBy
+        const aVal = getNestedValue(a, field)
+        const bVal = getNestedValue(b, field)
         const sortOrderValue = sortOrder?.toLowerCase() === 'desc' ? -1 : 1
-        if (aVal < bVal) return -sortOrderValue
-        if (aVal > bVal) return sortOrderValue
-        return 0
+        
+        let comparison = 0
+        if (aVal === null || aVal === undefined) {
+          comparison = bVal === null || bVal === undefined ? 0 : -1
+        } else if (bVal === null || bVal === undefined) {
+          comparison = 1
+        } else if (typeof aVal === 'number' && typeof bVal === 'number') {
+          comparison = aVal - bVal
+        } else if (aVal instanceof Date && bVal instanceof Date) {
+          comparison = aVal.getTime() - bVal.getTime()
+        } else {
+          const aStr = String(aVal)
+          const bStr = String(bVal)
+          if (aStr < bStr) comparison = -1
+          else if (aStr > bStr) comparison = 1
+        }
+        
+        return comparison * sortOrderValue
       })
     }
     

package/src/fetchers/javascript.ts

@@ -1,4 +1,8 @@
-import { generateDateFormatterCode } from '../utils'
+import {
+  generateDateFormatterCode,
+  generateSortFilterHelperCode,
+  generateSafeJSONParseCode,
+} from '../utils'
 
 export const validateJavaScriptConfig = (
   config: Record<string, unknown>
@@ -37,27 +41,31 @@ interface JavaScriptConfig {
 
 export const generateJavaScriptFetcher = (config: Record<string, unknown>): string => {
   const jsConfig = config as JavaScriptConfig
-  return `${generateDateFormatterCode()}
+  return `${generateSafeJSONParseCode()}
+
+${generateDateFormatterCode()}
+
+${generateSortFilterHelperCode()}
 
 export default async function handler(req, res) {
   try {
-    const { limit, offset, page, perPage, query, queryColumns, sortBy, sortOrder, filters } = req.query
+    const { limit, offset, page, perPage, query, queryColumns, sortBy, sortOrder, filters, sorts } = req.query
     
     const code = ${JSON.stringify(jsConfig.code)}
     const executeCode = new Function('return ' + code)
     let data = executeCode()
     
     if (Array.isArray(data)) {
-      // 1. Apply search filter
       if (query && query.trim()) {
         const searchQuery = query.toLowerCase()
         
         if (queryColumns) {
           try {
-            const columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
+            const parsed = safeJSONParse(queryColumns)
+            const columns = Array.isArray(parsed) ? parsed : [parsed]
             data = data.filter(item => {
               return columns.some(col => {
-                const value = item[col]
+                const value = getNestedValue(item, col)
                 if (value === null || value === undefined) return false
                 return String(value).toLowerCase().includes(searchQuery)
               })
@@ -77,36 +85,107 @@ export default async function handler(req, res) {
         }
       }
       
-      // 2. Apply custom filters
       if (filters) {
         try {
-          const parsedFilters = typeof filters === 'string' ? JSON.parse(filters) : filters
-          data = data.filter((item) => {
-            return Object.entries(parsedFilters).every(([key, value]) => {
-              if (Array.isArray(value)) {
-                return value.includes(item[key])
-              }
-              return item[key] === value
+          const parsedFilters = 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 (Array.isArray(target)) {
+                  if (operand === '!=') {
+                    return !target.includes(value)
+                  }
+                  return target.includes(value)
+                }
+                
+                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)
         }
       }
       
-      // 3. Apply sorting
-      if (sortBy && sortBy.trim()) {
+      if (sorts) {
+        try {
+          const parsedSorts = safeJSONParse(sorts)
+          if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
+            data.sort((a, b) => {
+              for (const sort of parsedSorts) {
+                if (!sort.field) continue
+                const aVal = getNestedValue(a, sort.field)
+                const bVal = getNestedValue(b, sort.field)
+                const sortOrderValue = sort.order?.toLowerCase() === 'desc' ? -1 : 1
+                
+                let comparison = 0
+                if (aVal === null || aVal === undefined) {
+                  comparison = bVal === null || bVal === undefined ? 0 : -1
+                } else if (bVal === null || bVal === undefined) {
+                  comparison = 1
+                } else if (typeof aVal === 'number' && typeof bVal === 'number') {
+                  comparison = aVal - bVal
+                } else if (aVal instanceof Date && bVal instanceof Date) {
+                  comparison = aVal.getTime() - bVal.getTime()
+                } else {
+                  const aStr = String(aVal)
+                  const bStr = String(bVal)
+                  if (aStr < bStr) comparison = -1
+                  else if (aStr > bStr) comparison = 1
+                }
+                
+                if (comparison !== 0) return comparison * sortOrderValue
+              }
+              return 0
+            })
+          }
+        } catch (err) {
+          console.error('Error parsing sorts:', err)
+        }
+      } else if (sortBy && sortBy.trim()) {
         data.sort((a, b) => {
-          const aVal = a[sortBy]
-          const bVal = b[sortBy]
+          const aVal = getNestedValue(a, sortBy)
+          const bVal = getNestedValue(b, sortBy)
           const sortOrderValue = sortOrder?.toLowerCase() === 'desc' ? -1 : 1
-          if (aVal < bVal) return -sortOrderValue
-          if (aVal > bVal) return sortOrderValue
-          return 0
+          
+          let comparison = 0
+          if (aVal === null || aVal === undefined) {
+            comparison = bVal === null || bVal === undefined ? 0 : -1
+          } else if (bVal === null || bVal === undefined) {
+            comparison = 1
+          } else if (typeof aVal === 'number' && typeof bVal === 'number') {
+            comparison = aVal - bVal
+          } else if (aVal instanceof Date && bVal instanceof Date) {
+            comparison = aVal.getTime() - bVal.getTime()
+          } else {
+            const aStr = String(aVal)
+            const bStr = String(bVal)
+            if (aStr < bStr) comparison = -1
+            else if (aStr > bStr) comparison = 1
+          }
+          
+          return comparison * sortOrderValue
         })
       }
       
-      // 4. Apply pagination
       const limitValue = limit || perPage
       const pageValue = page ? Math.max(1, parseInt(page)) : undefined
       const offsetValue = offset !== undefined ? Math.max(0, parseInt(offset)) : (pageValue && perPage ? (pageValue - 1) * Math.max(1, parseInt(perPage)) : 0)

package/src/fetchers/mariadb.ts

@@ -1,4 +1,8 @@
-import { replaceSecretReference, generateDateFormatterCode } from '../utils'
+import {
+  replaceSecretReference,
+  generateDateFormatterCode,
+  generateSafeJSONParseCode,
+} from '../utils'
 
 interface MariaDBConfig {
   host?: string
@@ -20,6 +24,60 @@ export const generateMariaDBFetcher = (
 
   return `import mariadb from 'mariadb'
 
+${generateSafeJSONParseCode()}
+
+// Helper function to process filters and build conditions
+const processFilters = (filters, conditions, queryParams) => {
+  if (!filters) return
+  
+  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 || '='
+      
+      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)
+      }
+    })
+  }
+}
+
 ${generateDateFormatterCode()}
 
 export default async function handler(req, res) {
@@ -54,7 +112,7 @@ export default async function handler(req, res) {
   }
     })
     
-    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset } = req.query
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, sorts, offset } = req.query
     
     const conditions = []
     const queryParams = []
@@ -64,7 +122,7 @@ export default async function handler(req, res) {
       
       if (queryColumns) {
         // Use specified columns
-        columns = JSON.parse(queryColumns)
+        columns = safeJSONParse(queryColumns)
       } else {
         // Fallback: Get all columns from information_schema
         try {
@@ -88,19 +146,8 @@ export default async function handler(req, res) {
       }
     }
     
-    if (filters) {
-      const parsedFilters = JSON.parse(filters)
-      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)
-        }
-      })
-    }
+    // Apply filters using helper function
+    processFilters(filters, conditions, queryParams)
     
     let sql = \`SELECT * FROM \\\`${tableName}\\\`\`
     
@@ -108,7 +155,21 @@ export default async function handler(req, res) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
     }
     
-    if (sortBy) {
+    // Handle sorts - new array format
+    if (sorts) {
+      const parsedSorts = safeJSONParse(sorts)
+      if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
+        const orderClauses = parsedSorts.map((sort) => {
+          if (!sort.field) return null
+          const order = sort.order?.toUpperCase() === 'DESC' ? 'DESC' : 'ASC'
+          return \`\\\`\${sort.field}\\\` \${order}\`
+        }).filter(Boolean)
+        
+        if (orderClauses.length > 0) {
+          sql += \` ORDER BY \${orderClauses.join(', ')}\`
+        }
+      }
+    } else if (sortBy) {
       sql += \` ORDER BY \\\`\${sortBy}\\\` \${sortOrder?.toUpperCase() || 'ASC'}\`
     }
     
@@ -205,7 +266,8 @@ async function getCount(req, res) {
       
       if (queryColumns) {
         // Use specified columns
-        columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
+        const parsed = safeJSONParse(queryColumns)
+        columns = Array.isArray(parsed) ? parsed : [parsed]
       } else {
         // Fallback: Get all columns from information_schema
         try {
@@ -229,13 +291,8 @@ async function getCount(req, res) {
       }
     }
 
-    if (filters) {
-      const parsedFilters = JSON.parse(filters)
-      for (const filter of parsedFilters) {
-        conditions.push(\`\${filter.column} \${filter.operator} ?\`)
-        queryParams.push(filter.value)
-      }
-    }
+    // Apply filters using helper function
+    processFilters(filters, conditions, queryParams)
 
     let countSql = \`SELECT COUNT(*) as count FROM ${tableName}\`
     if (conditions.length > 0) {