@teleporthq/teleport-plugin-next-data-source 0.40.15

package/src/fetchers/google-sheets.ts

@@ -0,0 +1,189 @@
+export const validateGoogleSheetsConfig = (
+  config: Record<string, unknown>
+): { isValid: boolean; error?: string } => {
+  if (!config || typeof config !== 'object') {
+    return { isValid: false, error: 'Config must be a valid object' }
+  }
+
+  if (!config.sheetId && !config.sheetUrl) {
+    return { isValid: false, error: 'Google Sheets ID or URL is required' }
+  }
+
+  if (config.sheetId && typeof config.sheetId !== 'string') {
+    return { isValid: false, error: 'Sheet ID must be a string' }
+  }
+
+  if (config.sheetUrl) {
+    if (typeof config.sheetUrl !== 'string') {
+      return { isValid: false, error: 'Sheet URL must be a string' }
+    }
+
+    if (!config.sheetUrl.includes('docs.google.com/spreadsheets')) {
+      return { isValid: false, error: 'Invalid Google Sheets URL format' }
+    }
+  }
+
+  return { isValid: true }
+}
+
+interface GoogleSheetsConfig {
+  sheetId?: string
+  sheetUrl?: string
+  apiKey?: string
+  sheetName?: string
+  range?: string
+  maxRows?: number
+}
+
+export const generateGoogleSheetsFetcher = (config: Record<string, unknown>): string => {
+  const sheetsConfig = config as GoogleSheetsConfig
+  return `import fetch from 'node-fetch'
+
+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}
+    
+    if (!sheetId && sheetUrl) {
+      const match = sheetUrl.match(/\\/d\\/([a-zA-Z0-9-_]+)/)
+      sheetId = match ? match[1] : undefined
+    }
+    
+    if (!sheetId) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid Google Sheets URL or Sheet ID',
+        timestamp: Date.now()
+      })
+    }
+    
+    let url = \`https://docs.google.com/spreadsheets/d/\${sheetId}/gviz/tq?tqx=out:json&range=\${range}\`
+    
+    if (maxRows && maxRows > 0) {
+      url += \`&tq=limit \${maxRows}\`
+    }
+    
+    const response = await fetch(url)
+    
+    if (!response.ok) {
+      return res.status(response.status).json({
+        success: false,
+        error: \`HTTP \${response.status}: \${response.statusText}\`,
+        timestamp: Date.now()
+      })
+    }
+    
+    const text = await response.text()
+    const jsonMatch = text.match(/google\\.visualization\\.Query\\.setResponse\\((.*)\\);/)
+    
+    if (!jsonMatch) {
+      return res.status(500).json({
+        success: false,
+        error: 'Unable to parse Google Sheets response',
+        timestamp: Date.now()
+      })
+    }
+    
+    const data = JSON.parse(jsonMatch[1])
+    
+    if (data.status === 'error') {
+      return res.status(500).json({
+        success: false,
+        error: data.errors?.[0]?.detailed_message || 'Failed to fetch Google Sheets data',
+        timestamp: Date.now()
+      })
+    }
+    
+    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 rows = table.rows.map((row) => {
+      const rowData = {}
+      row.c.forEach((cell, index) => {
+        const columnId = columns[index].id
+        rowData[columnId] = cell?.v ?? null
+      })
+      return rowData
+    })
+    
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset: offsetParam } = req.query
+    
+    let filteredData = [...rows]
+    
+    if (query) {
+      const searchQuery = query.toLowerCase()
+      
+      if (queryColumns) {
+        const searchColumns = JSON.parse(queryColumns)
+        filteredData = filteredData.filter((item) => {
+          return searchColumns.some((col) => {
+            const value = item[col]
+            return value && String(value).toLowerCase().includes(searchQuery)
+          })
+        })
+      } else {
+        filteredData = filteredData.filter((item) => {
+          try {
+            const stringified = JSON.stringify(item).toLowerCase()
+            return stringified.includes(searchQuery)
+          } catch {
+            return false
+          }
+        })
+      }
+    }
+    
+    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
+        })
+      })
+    }
+    
+    if (sortBy) {
+      filteredData.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
+      })
+    }
+    
+    const limitValue = limit || perPage
+    const offsetValue = offsetParam !== undefined ? parseInt(offsetParam) : (page && perPage ? (parseInt(page) - 1) * parseInt(perPage) : 0)
+    
+    if (limitValue) {
+      filteredData = filteredData.slice(offsetValue, offsetValue + parseInt(limitValue))
+    }
+    
+    const safeData = JSON.parse(JSON.stringify(filteredData))
+    
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('Google Sheets fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}

package/src/fetchers/index.ts

@@ -0,0 +1,32 @@
+export { generatePostgreSQLFetcher, generatePostgreSQLCountFetcher } from './postgresql'
+export { generateMySQLFetcher, generateMySQLCountFetcher } from './mysql'
+export { generateMariaDBFetcher, generateMariaDBCountFetcher } from './mariadb'
+export { generateRedshiftFetcher } from './redshift'
+export {
+  generateMongoDBFetcher,
+  generateMongoDBCountFetcher,
+  validateMongoDBConfig,
+} from './mongodb'
+export { generateRedisFetcher, validateRedisConfig } from './redis'
+export { generateFirestoreFetcher, validateFirestoreConfig } from './firestore'
+export { generateClickHouseFetcher, validateClickHouseConfig } from './clickhouse'
+export { generateAirtableFetcher, validateAirtableConfig } from './airtable'
+export {
+  generateSupabaseFetcher,
+  generateSupabaseCountFetcher,
+  validateSupabaseConfig,
+} from './supabase'
+export { generateTursoFetcher, validateTursoConfig } from './turso'
+export { generateRESTAPIFetcher, validateRESTAPIConfig } from './rest-api'
+export {
+  generateJavaScriptFetcher,
+  generateJavaScriptCountFetcher,
+  validateJavaScriptConfig,
+} from './javascript'
+export { generateCSVFileFetcher, generateCSVCountFetcher, validateCSVConfig } from './csv-file'
+export {
+  generateStaticCollectionFetcher,
+  generateStaticCollectionCountFetcher,
+  validateStaticCollectionConfig,
+} from './static-collection'
+export { generateGoogleSheetsFetcher, validateGoogleSheetsConfig } from './google-sheets'

package/src/fetchers/javascript.ts

@@ -0,0 +1,150 @@
+export const validateJavaScriptConfig = (
+  config: Record<string, unknown>
+): { isValid: boolean; error?: string } => {
+  if (!config || typeof config !== 'object') {
+    return { isValid: false, error: 'Config must be a valid object' }
+  }
+
+  if (!config.code || typeof config.code !== 'string' || config.code.trim() === '') {
+    return { isValid: false, error: 'JavaScript code is required' }
+  }
+
+  const dangerousPatterns = [
+    /require\s*\(/i,
+    /import\s+/i,
+    /eval\s*\(/i,
+    /Function\s*\(/i,
+    /process\./i,
+    /global\./i,
+    /\.exec\s*\(/i,
+  ]
+
+  for (const pattern of dangerousPatterns) {
+    if (pattern.test(config.code)) {
+      console.warn('[Data Source] Warning: JavaScript code contains potentially dangerous patterns')
+      break
+    }
+  }
+
+  return { isValid: true }
+}
+
+interface JavaScriptConfig {
+  code?: string
+}
+
+export const generateJavaScriptFetcher = (config: Record<string, unknown>): string => {
+  const jsConfig = config as JavaScriptConfig
+  return `export default async function handler(req, res) {
+  try {
+    const { limit, offset, page, perPage, query, queryColumns } = req.query
+    
+    const code = ${JSON.stringify(jsConfig.code)}
+    const executeCode = new Function('return ' + code)
+    let data = executeCode()
+    
+    if (Array.isArray(data)) {
+      if (query) {
+        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)
+            })
+          })
+        } else {
+          // Search across all fields by stringifying the entire record
+          data = data.filter(item => {
+            try {
+              const stringified = JSON.stringify(item).toLowerCase()
+              return stringified.includes(searchQuery)
+            } catch {
+              return false
+            }
+          })
+        }
+      }
+      
+      const limitValue = limit || perPage
+      const offsetValue = offset !== undefined ? parseInt(offset) : (page && perPage ? (parseInt(page) - 1) * parseInt(perPage) : 0)
+      
+      if (limitValue) {
+        data = data.slice(offsetValue, offsetValue + parseInt(limitValue))
+      } else if (offsetValue > 0) {
+        data = data.slice(offsetValue)
+      }
+    }
+    
+    const safeData = JSON.parse(JSON.stringify(data))
+    
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('JavaScript execution error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to execute code',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}
+
+// tslint:disable-next-line:variable-name
+export const generateJavaScriptCountFetcher = (_config: any): string => {
+  return `
+async function getCount(req, res) {
+  try {
+    const { query, queryColumns } = req.query
+    const fakeReq = { query: { query, queryColumns }, method: 'GET' }
+    let result = null
+    let statusCode = 200
+    
+    const fakeRes = {
+      status: (code) => {
+        statusCode = code
+        return fakeRes
+      },
+      json: (data) => {
+        result = data
+        return fakeRes
+      },
+    }
+    
+    await handler(fakeReq, fakeRes)
+    
+    if (statusCode !== 200 || !result || !result.success) {
+      return res.status(500).json({
+        success: false,
+        error: 'Failed to get data for counting',
+        timestamp: Date.now()
+      })
+    }
+    
+    const count = Array.isArray(result.data) ? result.data.length : 0
+    
+    return res.status(200).json({
+      success: true,
+      count: count,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('Error getting count:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to get count',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}

package/src/fetchers/mariadb.ts

@@ -0,0 +1,230 @@
+import { replaceSecretReference } from '../utils'
+
+interface MariaDBConfig {
+  host?: string
+  port?: number
+  user?: string
+  username?: string
+  password?: string
+  database?: string
+  ssl?: boolean | { ca?: string; cert?: string; key?: string; rejectUnauthorized?: boolean }
+  sslConfig?: { ca?: string; cert?: string; key?: string; rejectUnauthorized?: boolean }
+}
+
+export const generateMariaDBFetcher = (
+  config: Record<string, unknown>,
+  tableName: string
+): string => {
+  const mariaConfig = config as MariaDBConfig
+  const database = mariaConfig.database
+
+  return `import mariadb from 'mariadb'
+
+export default async function handler(req, res) {
+  let pool = null
+  try {
+    pool = mariadb.createPool({
+      host: ${JSON.stringify(mariaConfig.host)},
+      port: ${mariaConfig.port || 3306},
+      user: ${JSON.stringify(mariaConfig.user)},
+      password: ${replaceSecretReference(mariaConfig.password)},
+      database: ${JSON.stringify(mariaConfig.database)},
+      ssl: ${mariaConfig.ssl || false}${
+    mariaConfig.sslConfig
+      ? `,
+      sslConfig: {
+        ${
+          mariaConfig.sslConfig.ca ? `ca: ${replaceSecretReference(mariaConfig.sslConfig.ca)},` : ''
+        }
+        ${
+          mariaConfig.sslConfig.cert
+            ? `cert: ${replaceSecretReference(mariaConfig.sslConfig.cert)},`
+            : ''
+        }
+        ${
+          mariaConfig.sslConfig.key
+            ? `key: ${replaceSecretReference(mariaConfig.sslConfig.key)},`
+            : ''
+        }
+        rejectUnauthorized: ${mariaConfig.sslConfig.rejectUnauthorized !== false}
+      }`
+      : ''
+  }
+    })
+    
+    const connection = await pool.getConnection()
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset } = req.query
+    
+    const conditions = []
+    const queryParams = []
+    
+    if (query) {
+      let columns = []
+      
+      if (queryColumns) {
+        // Use specified columns
+        columns = JSON.parse(queryColumns)
+      } else {
+        // Fallback: Get all columns from information_schema
+        try {
+          const schemaRows = await connection.query(
+            \`SELECT COLUMN_NAME FROM information_schema.COLUMNS 
+             WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? 
+             ORDER BY ORDINAL_POSITION\`,
+            [${JSON.stringify(database)}, ${JSON.stringify(tableName)}]
+          )
+          columns = schemaRows.map(row => row.COLUMN_NAME)
+        } catch (schemaError) {
+          console.warn('Failed to fetch column names from information_schema:', schemaError.message)
+          // Continue without search if we can't get columns
+        }
+      }
+      
+      if (columns.length > 0) {
+        const searchConditions = columns.map((col) => \`CAST(\\\`\${col}\\\` AS CHAR) LIKE ?\`)
+        columns.forEach(() => queryParams.push(\`%\${query}%\`))
+        conditions.push(\`(\${searchConditions.join(' OR ')})\`)
+      }
+    }
+    
+    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)
+        }
+      })
+    }
+    
+    let sql = \`SELECT * FROM \\\`${tableName}\\\`\`
+    
+    if (conditions.length > 0) {
+      sql += \` WHERE \${conditions.join(' AND ')}\`
+    }
+    
+    if (sortBy) {
+      sql += \` ORDER BY \\\`\${sortBy}\\\` \${sortOrder?.toUpperCase() || 'ASC'}\`
+    }
+    
+    const limitValue = limit || perPage
+    const offsetValue = offset !== undefined ? parseInt(offset) : (page && perPage ? (parseInt(page) - 1) * parseInt(perPage) : undefined)
+    
+    if (limitValue) {
+      sql += \` LIMIT \${limitValue}\`
+    }
+    
+    if (offsetValue !== undefined) {
+      sql += \` OFFSET \${offsetValue}\`
+    }
+    
+    const rows = await connection.query(sql, queryParams)
+    const rowArray = Array.isArray(rows) ? rows : []
+    const plainRows = rowArray.map((row) =>
+      row && typeof row.toJSON === 'function' ? row.toJSON() : row
+    )
+    const safeData = JSON.parse(JSON.stringify(plainRows))
+    connection.release()
+    
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('MariaDB fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  } finally {
+    if (pool) {
+      await pool.end()
+    }
+  }
+}
+`
+}
+
+export const generateMariaDBCountFetcher = (
+  config: Record<string, unknown>,
+  tableName: string
+): string => {
+  const mariaConfig = config as MariaDBConfig
+  const database = mariaConfig.database
+
+  return `
+async function getCount(req, res) {
+  const connection = getConnection()
+
+  try {
+    const { query, queryColumns, filters } = req.query
+    const conditions = []
+    const queryParams = []
+
+    if (query) {
+      let columns = []
+      
+      if (queryColumns) {
+        // Use specified columns
+        columns = typeof queryColumns === 'string' ? JSON.parse(queryColumns) : (Array.isArray(queryColumns) ? queryColumns : [queryColumns])
+      } else {
+        // Fallback: Get all columns from information_schema
+        try {
+          const schemaRows = await connection.query(
+            \`SELECT COLUMN_NAME FROM information_schema.COLUMNS 
+             WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? 
+             ORDER BY ORDINAL_POSITION\`,
+            [${JSON.stringify(database)}, ${JSON.stringify(tableName)}]
+          )
+          columns = schemaRows.map(row => row.COLUMN_NAME)
+        } catch (schemaError) {
+          console.warn('Failed to fetch column names from information_schema:', schemaError.message)
+          // Continue without search if we can't get columns
+        }
+      }
+      
+      if (columns.length > 0) {
+        const searchConditions = columns.map(col => \`CAST(\${col} AS CHAR) LIKE ?\`).join(' OR ')
+        conditions.push(\`(\${searchConditions})\`)
+        columns.forEach(() => queryParams.push(\`%\${query}%\`))
+      }
+    }
+
+    if (filters) {
+      const parsedFilters = JSON.parse(filters)
+      for (const filter of parsedFilters) {
+        conditions.push(\`\${filter.column} \${filter.operator} ?\`)
+        queryParams.push(filter.value)
+      }
+    }
+
+    let countSql = \`SELECT COUNT(*) as count FROM ${tableName}\`
+    if (conditions.length > 0) {
+      countSql += \` WHERE \${conditions.join(' AND ')}\`
+    }
+
+    const [rows] = await connection.execute(countSql, queryParams)
+    const count = rows[0].count
+
+    return res.status(200).json({
+      success: true,
+      count: count,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('Error getting count:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to get count',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}