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

package/src/fetchers/firestore.ts

@@ -1,4 +1,8 @@
-import { replaceSecretReference } from '../utils'
+import {
+  replaceSecretReference,
+  generateDateFormatterCode,
+  generateSafeJSONParseCode,
+} from '../utils'
 
 export const validateFirestoreConfig = (
   config: Record<string, unknown>
@@ -67,29 +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)
@@ -102,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)
     }
@@ -150,7 +202,7 @@ export default async function handler(req, res) {
       }
     }
     
-    const safeData = JSON.parse(JSON.stringify(documents))
+    const safeData = JSON.parse(JSON.stringify(documents, dateReplacer))
     
     return res.status(200).json({
       success: true,

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-_]+)/)
@@ -59,8 +77,18 @@ export default async function handler(req, res) {
       })
     }
     
+    let gid = undefined
+    if (sheetUrl) {
+      const gidMatch = sheetUrl.match(/[#&]gid=([0-9]+)/)
+      gid = gidMatch ? gidMatch[1] : undefined
+    }
+    
     let url = \`https://docs.google.com/spreadsheets/d/\${sheetId}/gviz/tq?tqx=out:json&range=\${range}\`
     
+    if (gid) {
+      url += \`&gid=\${gid}\`
+    }
+    
     if (maxRows && maxRows > 0) {
       url += \`&tq=limit \${maxRows}\`
     }
@@ -96,34 +124,146 @@ export default async function handler(req, res) {
       })
     }
     
+    const formatDateValue = (date) => {
+      const options = {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+      }
+      
+      const timeOptions = {
+        hour: '2-digit',
+        minute: '2-digit',
+      }
+      
+      const hasTime = date.getHours() !== 0 || date.getMinutes() !== 0 || date.getSeconds() !== 0
+      
+      if (hasTime) {
+        return date.toLocaleString('en-US', { ...options, ...timeOptions })
+      }
+      
+      return date.toLocaleDateString('en-US', options)
+    }
+    
+    const parseGoogleSheetsValue = (value) => {
+      if (typeof value === 'string') {
+        const dateMatch = value.match(/^Date\\((\\d+),(\\d+),(\\d+)(?:,(\\d+),(\\d+),(\\d+))?\\)$/)
+        if (dateMatch) {
+          const year = parseInt(dateMatch[1], 10)
+          const month = parseInt(dateMatch[2], 10)
+          const day = parseInt(dateMatch[3], 10)
+          const hour = dateMatch[4] ? parseInt(dateMatch[4], 10) : 0
+          const minute = dateMatch[5] ? parseInt(dateMatch[5], 10) : 0
+          const second = dateMatch[6] ? parseInt(dateMatch[6], 10) : 0
+          const date = new Date(year, month, day, hour, minute, second)
+          return formatDateValue(date)
+        }
+      }
+      return value
+    }
+    
     const table = data.table
-    const columns = table.cols.map((col, index) => ({
-      id: col.id || \`col_\${index}\`,
-      label: col.label || \`Column \${index + 1}\`,
-      type: col.type || 'string'
-    }))
+    const rawRows = table.rows || []
+    
+    if (rawRows.length === 0) {
+      return res.status(200).json({
+        success: true,
+        data: [],
+        timestamp: Date.now()
+      })
+    }
+    
+    const firstRow = rawRows[0]
+    const firstRowValues = firstRow.c.map((cell) => cell?.v ?? cell?.f ?? null)
+    
+    const shouldAutoDetect = autoDetectHeader !== false
+    let hasHeaderRow = false
+    
+    if (shouldAutoDetect) {
+      hasHeaderRow = detectHeaderRow(firstRowValues, rawRows)
+    } else {
+      hasHeaderRow = firstRowIsHeader !== false
+    }
     
-    const rows = table.rows.map((row) => {
+    const configColumns = ${JSON.stringify(configColumns)}
+    const useConfigColumns = configColumns && configColumns.length > 0
+    
+    let columns
+    let dataRows
+    
+    if (hasHeaderRow && rawRows.length > 1) {
+      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) => {
+        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
+    }
+    
+    if (maxRows && dataRows.length > maxRows) {
+      dataRows = dataRows.slice(0, maxRows)
+    }
+    
+    const rows = dataRows.map((row) => {
       const rowData = {}
       row.c.forEach((cell, index) => {
-        const columnId = columns[index].id
-        rowData[columnId] = cell?.v ?? null
+        const columnId = columns[index]?.id || \`col_\${index}\`
+        const rawValue = cell?.v ?? cell?.f ?? null
+        rowData[columnId] = parseGoogleSheetsValue(rawValue)
       })
       return rowData
     })
     
-    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset: offsetParam } = req.query
+    const columnsWithData = columns.filter((col, index) => {
+      const hasHeaderData = col.label && col.label !== \`Column \${index + 1}\`
+      const hasDataInColumn = rows.some((row) => {
+        const value = row[col.id]
+        return value !== null && value !== undefined && value !== ''
+      })
+      return hasHeaderData || hasDataInColumn
+    })
     
-    let filteredData = [...rows]
+    const filteredRows = rows.map((row) => {
+      const filteredRow = {}
+      columnsWithData.forEach((col) => {
+        filteredRow[col.id] = row[col.id]
+      })
+      return filteredRow
+    })
+    
+    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]
     
     if (query) {
       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)
           })
         })
@@ -140,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,3 +1,9 @@
+import {
+  generateDateFormatterCode,
+  generateSortFilterHelperCode,
+  generateSafeJSONParseCode,
+} from '../utils'
+
 export const validateJavaScriptConfig = (
   config: Record<string, unknown>
 ): { isValid: boolean; error?: string } => {
@@ -35,25 +41,31 @@ interface JavaScriptConfig {
 
 export const generateJavaScriptFetcher = (config: Record<string, unknown>): string => {
   const jsConfig = config as JavaScriptConfig
-  return `export default async function handler(req, res) {
+  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)
               })
@@ -73,36 +85,107 @@ export const generateJavaScriptFetcher = (config: Record<string, unknown>): stri
         }
       }
       
-      // 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)
@@ -115,7 +198,7 @@ export const generateJavaScriptFetcher = (config: Record<string, unknown>): stri
       }
     }
     
-    const safeData = JSON.parse(JSON.stringify(data))
+    const safeData = JSON.parse(JSON.stringify(data, dateReplacer))
     
     return res.status(200).json({
       success: true,