@teleporthq/teleport-plugin-next-data-source 0.42.8 → 0.42.10

package/src/fetchers/airtable.ts

@@ -1,4 +1,8 @@
-import { replaceSecretReference } from '../utils'
+import {
+  replaceSecretReference,
+  generateDateFormatterCode,
+  generateSafeJSONParseCode,
+} from '../utils'
 
 export const validateAirtableConfig = (
   config: Record<string, unknown>
@@ -34,9 +38,13 @@ export const generateAirtableFetcher = (
 
   return `import fetch from 'node-fetch'
 
+${generateSafeJSONParseCode()}
+
+${generateDateFormatterCode()}
+
 export default async function handler(req, res) {
   try {
-    const { query, view, limit, page, perPage, sortBy, sortOrder, filters, offset: offsetParam } = req.query
+    const { query, view, limit, page, perPage, sortBy, sortOrder, filters, sorts, offset: offsetParam } = req.query
     
     const queryParams = new URLSearchParams()
     
@@ -44,7 +52,17 @@ export default async function handler(req, res) {
       queryParams.append('view', view)
     }
     
-    if (sortBy) {
+    // Handle sorts - new array format
+    if (sorts) {
+      const parsedSorts = safeJSONParse(sorts)
+      if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
+        parsedSorts.forEach((sort, index) => {
+          if (!sort.field) return
+          queryParams.append(\`sort[\${index}][field]\`, sort.field)
+          queryParams.append(\`sort[\${index}][direction]\`, sort.order?.toLowerCase() === 'desc' ? 'desc' : 'asc')
+        })
+      }
+    } else if (sortBy) {
       queryParams.append('sort[0][field]', sortBy)
       queryParams.append('sort[0][direction]', sortOrder || 'asc')
     }
@@ -52,36 +70,68 @@ export default async function handler(req, res) {
     const perPageValue = limit || perPage || 100
     queryParams.append('pageSize', Math.min(parseInt(perPageValue), 100).toString())
     
+    const formatAirtableValue = (value) => {
+      if (typeof value === 'string') {
+        return \`'\${value.replace(/'/g, "\\\\'")}'\`
+      } else if (typeof value === 'number') {
+        return String(value)
+      } else if (typeof value === 'boolean') {
+        return value ? 'TRUE()' : 'FALSE()'
+      }
+      return \`'\${String(value)}'\`
+    }
+    
     if (filters) {
-      const parsedFilters = JSON.parse(filters)
-      const conditions = Object.entries(parsedFilters).map(([field, value]) => {
-        if (Array.isArray(value)) {
-          const arrayConditions = value.map((v) => {
-            if (typeof v === 'string') {
-              return \`{\${field}}='\${v.replace(/'/g, "\\\\'")}'\`
-            } else if (typeof v === 'number') {
-              return \`{\${field}}=\${v}\`
-            } else if (typeof v === 'boolean') {
-              return \`{\${field}}=\${v ? 'TRUE()' : 'FALSE()'}\`
+      const parsedFilters = safeJSONParse(filters)
+      
+      if (Array.isArray(parsedFilters)) {
+        const conditions = parsedFilters.map((filter) => {
+          if (!filter.source || filter.destination === undefined) return null
+          
+          const field = filter.source
+          const value = filter.destination
+          const operand = filter.operand || '='
+          
+          if (Array.isArray(value)) {
+            if (value.length === 0) return null
+            const arrayConditions = value.map((v) => \`{\${field}}=\${formatAirtableValue(v)}\`)
+            return arrayConditions.length > 1
+              ? \`OR(\${arrayConditions.join(',')})\`
+              : arrayConditions[0]
+          } else {
+            const operatorMap = {
+              '=': '=',
+              '!=': '!=',
+              '>': '>',
+              '<': '<',
+              '>=': '>=',
+              '<=': '<=',
             }
-            return \`{\${field}}='\${String(v)}'\`
-          })
-          return arrayConditions.length > 1
-            ? \`OR(\${arrayConditions.join(',')})\`
-            : arrayConditions[0]
-        } else if (typeof value === 'string') {
-          return \`{\${field}}='\${value.replace(/'/g, "\\\\'")}'\`
-        } else if (typeof value === 'number') {
-          return \`{\${field}}=\${value}\`
-        } else if (typeof value === 'boolean') {
-          return \`{\${field}}=\${value ? 'TRUE()' : 'FALSE()'}\`
+            const airtableOp = operatorMap[operand] || '='
+            return \`{\${field}}\${airtableOp}\${formatAirtableValue(value)}\`
+          }
+        }).filter(Boolean)
+        
+        if (conditions.length > 0) {
+          const filterFormula = conditions.length > 1 ? \`AND(\${conditions.join(',')})\` : conditions[0]
+          queryParams.append('filterByFormula', filterFormula)
+        }
+      } else {
+        const conditions = Object.entries(parsedFilters).map(([field, value]) => {
+          if (Array.isArray(value)) {
+            const arrayConditions = value.map((v) => \`{\${field}}=\${formatAirtableValue(v)}\`)
+            return arrayConditions.length > 1
+              ? \`OR(\${arrayConditions.join(',')})\`
+              : arrayConditions[0]
+          } else {
+            return \`{\${field}}=\${formatAirtableValue(value)}\`
+          }
+        })
+        
+        const filterFormula = conditions.length > 1 ? \`AND(\${conditions.join(',')})\` : conditions[0]
+        if (filterFormula) {
+          queryParams.append('filterByFormula', filterFormula)
         }
-        return \`{\${field}}='\${String(value)}'\`
-      })
-      
-      const filterFormula = conditions.length > 1 ? \`AND(\${conditions.join(',')})\` : conditions[0]
-      if (filterFormula) {
-        queryParams.append('filterByFormula', filterFormula)
       }
     }
     
@@ -133,7 +183,7 @@ export default async function handler(req, res) {
       createdTime: record.createdTime
     }))
     
-    const safeData = JSON.parse(JSON.stringify(formattedRecords))
+    const safeData = JSON.parse(JSON.stringify(formattedRecords, dateReplacer))
     
     return res.status(200).json({
       success: true,

package/src/fetchers/clickhouse.ts

@@ -1,4 +1,8 @@
-import { replaceSecretReference } from '../utils'
+import {
+  replaceSecretReference,
+  generateDateFormatterCode,
+  generateSafeJSONParseCode,
+} from '../utils'
 
 export const validateClickHouseConfig = (
   config: Record<string, unknown>
@@ -53,16 +57,21 @@ const getClient = () => {
   return client
 }
 
+${generateSafeJSONParseCode()}
+
+${generateDateFormatterCode()}
+
 export default async function handler(req, res) {
   try {
     const client = getClient()
-    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 = []
     
     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]
         const searchConditions = columns.map(
           (col) => \`positionCaseInsensitive(toString(\${col}), '\${query}') > 0\`
         )
@@ -74,20 +83,66 @@ export default async function handler(req, res) {
       }
     }
     
+    const formatClickHouseValue = (value) => {
+      if (value === null || value === undefined) return 'NULL'
+      if (typeof value === 'string') return \`'\${value.replace(/'/g, "\\\\'")}'\`
+      if (typeof value === 'boolean') return value ? '1' : '0'
+      return String(value)
+    }
+    
+    // Helper to sanitize identifier (prevent SQL injection in column names)
+    const sanitizeIdentifier = (name) => {
+      // Only allow alphanumeric and underscore
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+        throw new Error(\`Invalid identifier: \${name}\`)
+      }
+      return \`\\\`\${name}\\\`\`
+    }
+    
     if (filters) {
-      const parsedFilters = JSON.parse(filters)
-      Object.entries(parsedFilters).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          const formattedValues = value
-            .map((v) => (typeof v === 'string' ? \`'\${v}'\` : v))
-            .join(', ')
-          conditions.push(\`\${key} IN (\${formattedValues})\`)
-        } else if (typeof value === 'string') {
-          conditions.push(\`\${key} = '\${value}'\`)
-        } else {
-          conditions.push(\`\${key} = \${value}\`)
-        }
-      })
+      const parsedFilters = 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 (Array.isArray(value)) {
+            if (value.length === 0) return
+            const formattedValues = value.map(formatClickHouseValue).join(', ')
+            if (operand === '!=') {
+              conditions.push(\`\${field} NOT IN (\${formattedValues})\`)
+            } else {
+              conditions.push(\`\${field} IN (\${formattedValues})\`)
+            }
+          } 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} \${formatClickHouseValue(value)}\`)
+            }
+          }
+        })
+      } else {
+        Object.entries(parsedFilters).forEach(([key, value]) => {
+          const field = sanitizeIdentifier(key)
+          if (Array.isArray(value)) {
+            const formattedValues = value.map(formatClickHouseValue).join(', ')
+            conditions.push(\`\${field} IN (\${formattedValues})\`)
+          } else {
+            conditions.push(\`\${field} = \${formatClickHouseValue(value)}\`)
+          }
+        })
+      }
     }
     
     let sql = \`SELECT * FROM ${tableName}\`
@@ -96,8 +151,22 @@ export default async function handler(req, res) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
     }
     
-    if (sortBy) {
-      sql += \` ORDER BY \${sortBy} \${sortOrder?.toUpperCase() || 'ASC'}\`
+    // 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 \`\${sanitizeIdentifier(sort.field)} \${order}\`
+        }).filter(Boolean)
+        
+        if (orderClauses.length > 0) {
+          sql += \` ORDER BY \${orderClauses.join(', ')}\`
+        }
+      }
+    } else if (sortBy) {
+      sql += \` ORDER BY \${sanitizeIdentifier(sortBy)} \${sortOrder?.toUpperCase() || 'ASC'}\`
     }
     
     const limitValue = limit || perPage
@@ -113,7 +182,7 @@ export default async function handler(req, res) {
     
     const result = await client.query({ query: sql })
     const resultResponse = await result.json()
-    const safeData = JSON.parse(JSON.stringify(resultResponse.data))
+    const safeData = JSON.parse(JSON.stringify(resultResponse.data, dateReplacer))
 
     return res.status(200).json({
       success: true,

package/src/fetchers/csv-file.ts

@@ -1,3 +1,10 @@
+import {
+  generateDateFormatterCode,
+  generateSortFilterHelperCode,
+  generateSafeJSONParseCode,
+} from '../utils'
+import { generateHeaderDetectionCode } from './utils/header-detection'
+
 export const validateCSVConfig = (
   config: Record<string, unknown>
 ): { isValid: boolean; error?: string } => {
@@ -5,11 +12,18 @@ export const validateCSVConfig = (
     return { isValid: false, error: 'Config must be a valid object' }
   }
 
-  if (!config.parsedData || !Array.isArray(config.parsedData)) {
+  if (!config.fileContent && !config.parsedData) {
+    return { isValid: false, error: 'Either fileContent or parsedData must be provided' }
+  }
+
+  if (config.fileContent && typeof config.fileContent !== 'string') {
+    return { isValid: false, error: 'File content must be a string' }
+  }
+
+  if (config.parsedData && !Array.isArray(config.parsedData)) {
     return { isValid: false, error: 'Parsed data must be an array' }
   }
 
-  // Columns are optional - if not provided, we'll infer them from parsedData
   if (config.columns !== undefined) {
     if (!Array.isArray(config.columns)) {
       return { isValid: false, error: 'Columns definition must be an array' }
@@ -26,17 +40,24 @@ export const validateCSVConfig = (
 }
 
 interface CSVFileConfig {
+  fileContent?: string
   parsedData?: unknown[]
-  columns?: Array<{ id: string; [key: string]: unknown }>
+  columns?: Array<{ id: string; label?: string; type?: string }>
+  autoDetectHeader?: boolean
+  firstRowIsHeader?: boolean
 }
 
-export const generateCSVFileFetcher = (config: Record<string, unknown>): string => {
-  const csvConfig = config as CSVFileConfig
-  return `const data = ${JSON.stringify(csvConfig.parsedData || [])}
-
-export default async function handler(req, res) {
+const generateHandlerBody = (): string => {
+  return `
   try {
-    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
+    
+    const labelToIdMap = {}
+    columns.forEach((col) => {
+      if (col.label && col.id) {
+        labelToIdMap[col.label] = col.id
+      }
+    })
     
     let filteredData = [...data]
     
@@ -44,10 +65,11 @@ export default async function handler(req, res) {
       const searchQuery = query.toLowerCase()
       
       if (queryColumns) {
-        const columns = JSON.parse(queryColumns)
+        const searchColumns = safeJSONParse(queryColumns)
         filteredData = filteredData.filter((item) => {
-          return columns.some((col) => {
-            const value = item[col]
+          return searchColumns.some((col) => {
+            const field = labelToIdMap[col] || col
+            const value = getNestedValue(item, field)
             return value && String(value).toLowerCase().includes(searchQuery)
           })
         })
@@ -64,25 +86,98 @@ 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
+            
+            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]) => {
+            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
+            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) {
+      const field = labelToIdMap[sortBy] || sortBy
       filteredData.sort((a, b) => {
-        const aVal = a[sortBy]
-        const bVal = b[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
       })
     }
     
@@ -93,7 +188,7 @@ export default async function handler(req, res) {
       filteredData = filteredData.slice(offsetValue, offsetValue + parseInt(limitValue))
     }
     
-    const safeData = JSON.parse(JSON.stringify(filteredData))
+    const safeData = JSON.parse(JSON.stringify(filteredData, dateReplacer))
     
     return res.status(200).json({
       success: true,
@@ -108,8 +203,142 @@ export default async function handler(req, res) {
       timestamp: Date.now()
     })
   }
+`
+}
+
+export const generateCSVFileFetcher = (config: Record<string, unknown>): string => {
+  const csvConfig = config as CSVFileConfig
+
+  // Get header detection flags, ensuring boolean false values are preserved
+  const autoDetectHeader = csvConfig.autoDetectHeader !== false
+  const firstRowIsHeader = csvConfig.firstRowIsHeader !== false
+  const configColumns = csvConfig.columns || []
+
+  if (csvConfig.fileContent) {
+    const fileContent = csvConfig.fileContent
+    return `const csvContent = ${JSON.stringify(fileContent)}
+const autoDetectHeader = ${autoDetectHeader}
+const firstRowIsHeader = ${firstRowIsHeader}
+const configColumns = ${JSON.stringify(configColumns)}
+
+${generateSafeJSONParseCode()}
+
+${generateDateFormatterCode()}
+
+${generateSortFilterHelperCode()}
+
+${generateHeaderDetectionCode()}
+
+function parseCSVLine(line) {
+  const result = []
+  let current = ''
+  let inQuotes = false
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i]
+    const nextChar = line[i + 1]
+
+    if (char === '"') {
+      if (inQuotes && nextChar === '"') {
+        current += '"'
+        i++
+      } else {
+        inQuotes = !inQuotes
+      }
+    } else if (char === ',' && !inQuotes) {
+      result.push(current)
+      current = ''
+    } else {
+      current += char
+    }
+  }
+
+  result.push(current)
+  return result
+}
+
+function parseCSVContent(content, autoDetect, firstRowHeader, columns) {
+  const lines = content.split('\\n').filter((line) => line.trim())
+  
+  if (lines.length === 0) {
+    return { columns: [], rows: [] }
+  }
+  
+  const allRowValues = lines.map((line) => parseCSVLine(line))
+  const firstRowValues = allRowValues[0]
+  
+  if (firstRowValues.length === 0) {
+    return { columns: [], rows: [] }
+  }
+  
+  const shouldAutoDetect = autoDetect !== false
+  let hasHeaderRow = false
+  
+  if (shouldAutoDetect) {
+    hasHeaderRow = detectHeaderRow(firstRowValues, allRowValues)
+  } else {
+    hasHeaderRow = firstRowHeader !== false
+  }
+  
+  const useConfigColumns = columns && columns.length > 0
+  let parsedColumns
+  let dataStartIndex
+  
+  if (hasHeaderRow && allRowValues.length > 1) {
+    parsedColumns = firstRowValues.map((header, index) => {
+      const configCol = useConfigColumns ? columns[index] : null
+      return {
+        id: configCol?.id || \`col_\${index}\`,
+        label: String(header || configCol?.label || \`Column \${index + 1}\`),
+        type: configCol?.type || 'string'
+      }
+    })
+    dataStartIndex = 1
+  } else {
+    parsedColumns = firstRowValues.map((_, index) => {
+      const configCol = useConfigColumns ? columns[index] : null
+      return {
+        id: configCol?.id || \`col_\${index}\`,
+        label: configCol?.label || \`Column \${index + 1}\`,
+        type: configCol?.type || 'string'
+      }
+    })
+    dataStartIndex = 0
+  }
+  
+  const rows = []
+  for (let i = dataStartIndex; i < allRowValues.length; i++) {
+    const values = allRowValues[i]
+    const row = {}
+    parsedColumns.forEach((col, index) => {
+      const value = values[index]?.trim() || null
+      row[col.id] = value
+    })
+    rows.push(row)
+  }
+  
+  return { columns: parsedColumns, rows }
+}
+
+const { columns, rows: data } = parseCSVContent(csvContent, autoDetectHeader, firstRowIsHeader, configColumns)
+
+export default async function handler(req, res) {${generateHandlerBody()}
+}
+`
+  } else {
+    return `const data = ${JSON.stringify(csvConfig.parsedData || [])}
+const columns = ${JSON.stringify(configColumns)}
+
+${generateSafeJSONParseCode()}
+
+${generateDateFormatterCode()}
+
+${generateSortFilterHelperCode()}
+
+export default async function handler(req, res) {${generateHandlerBody()}
 }
 `
+  }
 }
 
 // tslint:disable-next-line:variable-name