@teleporthq/teleport-plugin-next-data-source 0.42.1 → 0.42.3

package/src/fetchers/firestore.ts

@@ -85,12 +85,20 @@ export default async function handler(req, res) {
       })
     }
     
-    if (query && queryColumns) {
-      const columns = JSON.parse(queryColumns)
-      for (const column of columns) {
-        queryRef = queryRef
-          .where(column, '>=', query)
-          .where(column, '<=', query + '\\uf8ff')
+    let usePostFiltering = false
+    
+    if (query) {
+      if (queryColumns) {
+        const columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
+        for (const column of columns) {
+          queryRef = queryRef
+            .where(column, '>=', query)
+            .where(column, '<=', query + '\\uf8ff')
+        }
+      } else {
+        // Firestore doesn't support full-text search without queryColumns
+        // We'll fetch all data and filter in JavaScript
+        usePostFiltering = true
       }
     }
     
@@ -100,17 +108,20 @@ export default async function handler(req, res) {
     }
     
     const limitValue = limit || perPage
-    if (limitValue) {
-      queryRef = queryRef.limit(parseInt(limitValue))
-    }
-    
     const offsetValue = offset !== undefined ? parseInt(offset) : (page && perPage && parseInt(page) > 1 ? (parseInt(page) - 1) * parseInt(perPage) : undefined)
-    if (offsetValue !== undefined) {
-      queryRef = queryRef.offset(offsetValue)
+    
+    // Only apply pagination at query level if not post-filtering
+    if (!usePostFiltering) {
+      if (limitValue) {
+        queryRef = queryRef.limit(parseInt(limitValue))
+      }
+      if (offsetValue !== undefined) {
+        queryRef = queryRef.offset(offsetValue)
+      }
     }
     
     const snapshot = await queryRef.get()
-    const documents = []
+    let documents = []
     snapshot.forEach((doc) => {
       documents.push({
         id: doc.id,
@@ -118,6 +129,27 @@ export default async function handler(req, res) {
       })
     })
     
+    // Apply post-filtering if needed
+    if (usePostFiltering && query) {
+      const searchQuery = query.toLowerCase()
+      documents = documents.filter((item) => {
+        try {
+          const stringified = JSON.stringify(item).toLowerCase()
+          return stringified.includes(searchQuery)
+        } catch {
+          return false
+        }
+      })
+      
+      // Apply pagination after filtering
+      if (limitValue) {
+        const start = offsetValue || 0
+        documents = documents.slice(start, start + parseInt(limitValue))
+      } else if (offsetValue) {
+        documents = documents.slice(offsetValue)
+      }
+    }
+    
     const safeData = JSON.parse(JSON.stringify(documents))
     
     return res.status(200).json({

package/src/fetchers/javascript.ts

@@ -37,28 +37,31 @@ export const generateJavaScriptFetcher = (config: Record<string, unknown>): stri
   const jsConfig = config as JavaScriptConfig
   return `export default async function handler(req, res) {
   try {
-    const { limit, offset, page, perPage, query, queryColumns } = req.query
+    const { limit, offset, page, perPage, query, queryColumns, sortBy, sortOrder, filters } = req.query
     
     const code = ${JSON.stringify(jsConfig.code)}
     const executeCode = new Function('return ' + code)
     let data = executeCode()
     
     if (Array.isArray(data)) {
-      if (query) {
+      // 1. Apply search filter
+      if (query && query.trim()) {
         const searchQuery = query.toLowerCase()
         
         if (queryColumns) {
-          // Search specific columns
-          const columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
-          data = data.filter(item => {
-            return columns.some(col => {
-              const value = item[col]
-              if (value === null || value === undefined) return false
-              return String(value).toLowerCase().includes(searchQuery)
+          try {
+            const columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
+            data = data.filter(item => {
+              return columns.some(col => {
+                const value = item[col]
+                if (value === null || value === undefined) return false
+                return String(value).toLowerCase().includes(searchQuery)
+              })
             })
-          })
+          } catch (err) {
+            console.error('Error parsing queryColumns:', err)
+          }
         } else {
-          // Search across all fields by stringifying the entire record
           data = data.filter(item => {
             try {
               const stringified = JSON.stringify(item).toLowerCase()
@@ -70,11 +73,43 @@ 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
+            })
+          })
+        } catch (err) {
+          console.error('Error parsing filters:', err)
+        }
+      }
+      
+      // 3. Apply sorting
+      if (sortBy && sortBy.trim()) {
+        data.sort((a, b) => {
+          const aVal = a[sortBy]
+          const bVal = b[sortBy]
+          const sortOrderValue = sortOrder?.toLowerCase() === 'desc' ? -1 : 1
+          if (aVal < bVal) return -sortOrderValue
+          if (aVal > bVal) return sortOrderValue
+          return 0
+        })
+      }
+      
+      // 4. Apply pagination
       const limitValue = limit || perPage
-      const offsetValue = offset !== undefined ? parseInt(offset) : (page && perPage ? (parseInt(page) - 1) * parseInt(perPage) : 0)
+      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)
       
       if (limitValue) {
-        data = data.slice(offsetValue, offsetValue + parseInt(limitValue))
+        const limitInt = Math.max(1, parseInt(limitValue))
+        data = data.slice(offsetValue, offsetValue + limitInt)
       } else if (offsetValue > 0) {
         data = data.slice(offsetValue)
       }

package/src/fetchers/redshift.ts

@@ -66,15 +66,38 @@ export default async function handler(req, res) {
     const queryParams = []
     let paramIndex = 1
     
-    if (query && queryColumns) {
-      const columns = JSON.parse(queryColumns)
-      const searchConditions = columns.map((col) => {
-        const condition = \`\${col}::text ILIKE $\${paramIndex}\`
-        paramIndex++
-        return condition
-      })
-      columns.forEach(() => queryParams.push(\`%\${query}%\`))
-      conditions.push(\`(\${searchConditions.join(' OR ')})\`)
+    if (query) {
+      let columns = []
+      
+      if (queryColumns) {
+        columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
+      } else {
+        // Fallback: Get all columns from information_schema
+        try {
+          const schemaQuery = 'SELECT column_name FROM information_schema.columns WHERE table_name = $1' + 
+            ${schema ? `' AND table_schema = $2'` : `''`} + 
+            ' ORDER BY ordinal_position'
+          const schemaParams = ${
+            schema
+              ? `[${JSON.stringify(tableName)}, ${JSON.stringify(schema)}]`
+              : `[${JSON.stringify(tableName)}]`
+          }
+          const schemaResult = await pool.query(schemaQuery, schemaParams)
+          columns = schemaResult.rows.map(row => row.column_name)
+        } catch (schemaError) {
+          console.warn('Failed to fetch column names from information_schema:', schemaError.message)
+        }
+      }
+      
+      if (columns.length > 0) {
+        const searchConditions = columns.map((col) => {
+          const condition = \`\${col}::text ILIKE $\${paramIndex}\`
+          paramIndex++
+          return condition
+        })
+        columns.forEach(() => queryParams.push(\`%\${query}%\`))
+        conditions.push(\`(\${searchConditions.join(' OR ')})\`)
+      }
     }
     
     if (filters) {

package/src/fetchers/rest-api.ts

@@ -77,7 +77,7 @@ export const generateRESTAPIFetcher = (config: Record<string, unknown>): string
 
 export default async function handler(req, res) {
   try {
-    const { offset, limit } = req.query
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset } = req.query
     
     const url = ${JSON.stringify(restConfig.url)}
     const method = ${JSON.stringify(restConfig.method || 'GET')}
@@ -116,13 +116,75 @@ export default async function handler(req, res) {
     
     let data = await response.json()
     
-    // Apply offset and limit if data is an array and parameters are provided
+    // Apply filtering, sorting, and pagination if data is an array
     if (Array.isArray(data)) {
-      const offsetValue = offset !== undefined ? parseInt(offset) : 0
-      const limitValue = limit !== undefined ? parseInt(limit) : undefined
+      // 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])
+            data = data.filter((item) => {
+              return columns.some((col) => {
+                const value = item[col]
+                if (value === null || value === undefined) return false
+                return String(value).toLowerCase().includes(searchQuery)
+              })
+            })
+          } catch (err) {
+            console.error('Error parsing queryColumns:', err)
+          }
+        } else {
+          // Search across all fields
+          data = data.filter((item) => {
+            try {
+              const stringified = JSON.stringify(item).toLowerCase()
+              return stringified.includes(searchQuery)
+            } catch {
+              return false
+            }
+          })
+        }
+      }
+      
+      // 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
+            })
+          })
+        } catch (err) {
+          console.error('Error parsing filters:', err)
+        }
+      }
+      
+      // 3. Apply sorting
+      if (sortBy && sortBy.trim()) {
+        data.sort((a, b) => {
+          const aVal = a[sortBy]
+          const bVal = b[sortBy]
+          const sortOrderValue = sortOrder?.toLowerCase() === 'desc' ? -1 : 1
+          if (aVal < bVal) return -sortOrderValue
+          if (aVal > bVal) return sortOrderValue
+          return 0
+        })
+      }
+      
+      // 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)
       
-      if (limitValue !== undefined) {
-        data = data.slice(offsetValue, offsetValue + limitValue)
+      if (limitValue) {
+        const limitInt = Math.max(1, parseInt(limitValue))
+        data = data.slice(offsetValue, offsetValue + limitInt)
       } else if (offsetValue > 0) {
         data = data.slice(offsetValue)
       }

package/src/fetchers/turso.ts

@@ -48,14 +48,20 @@ export default async function handler(req, res) {
     let sql = \`SELECT * FROM ${tableName}\`
     const whereClauses = []
     const queryParams = []
+    let searchQueryColumns = null
     
-    if (query && queryColumns) {
-      const columns = JSON.parse(queryColumns)
-      const searchConditions = columns.map((col) => \`\${col} LIKE ?\`)
-      whereClauses.push(\`(\${searchConditions.join(' OR ')})\`)
-      columns.forEach(() => {
-        queryParams.push(\`%\${query}%\`)
-      })
+    if (query) {
+      if (queryColumns) {
+        const columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
+        const searchConditions = columns.map((col) => \`\${col} LIKE ?\`)
+        whereClauses.push(\`(\${searchConditions.join(' OR ')})\`)
+        columns.forEach(() => {
+          queryParams.push(\`%\${query}%\`)
+        })
+      } else {
+        // Store query for post-filtering if columns not specified
+        searchQueryColumns = query
+      }
     }
     
     if (filters) {
@@ -84,14 +90,17 @@ export default async function handler(req, res) {
     const limitValue = limit || perPage
     const offsetValue = offset !== undefined ? parseInt(offset) : (page && perPage ? (parseInt(page) - 1) * parseInt(perPage) : undefined)
     
-    if (limitValue) {
-      sql += \` LIMIT ?\`
-      queryParams.push(parseInt(limitValue))
-    }
-    
-    if (offsetValue !== undefined) {
-      sql += \` OFFSET ?\`
-      queryParams.push(offsetValue)
+    // Only apply SQL pagination if we're not doing post-filtering
+    if (!searchQueryColumns) {
+      if (limitValue) {
+        sql += \` LIMIT ?\`
+        queryParams.push(parseInt(limitValue))
+      }
+      
+      if (offsetValue !== undefined) {
+        sql += \` OFFSET ?\`
+        queryParams.push(offsetValue)
+      }
     }
     
     const result = await client.execute({
@@ -99,7 +108,7 @@ export default async function handler(req, res) {
       args: queryParams
     })
     
-    const data = result.rows.map((row) => {
+    let data = result.rows.map((row) => {
       const obj = {}
       result.columns.forEach((col, idx) => {
         obj[col] = row[col]
@@ -107,6 +116,27 @@ export default async function handler(req, res) {
       return obj
     })
     
+    // Apply post-filtering for search without queryColumns
+    if (searchQueryColumns) {
+      const searchQuery = searchQueryColumns.toLowerCase()
+      data = data.filter((item) => {
+        try {
+          const stringified = JSON.stringify(item).toLowerCase()
+          return stringified.includes(searchQuery)
+        } catch {
+          return false
+        }
+      })
+      
+      // Apply pagination after filtering
+      if (limitValue) {
+        const start = offsetValue || 0
+        data = data.slice(start, start + parseInt(limitValue))
+      } else if (offsetValue) {
+        data = data.slice(offsetValue)
+      }
+    }
+    
     const safeData = JSON.parse(JSON.stringify(data))
     
     return res.status(200).json({