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

package/src/fetchers/airtable.ts

@@ -0,0 +1,153 @@
+import { replaceSecretReference } from '../utils'
+
+export const validateAirtableConfig = (
+  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.baseId || typeof config.baseId !== 'string' || config.baseId.trim() === '') {
+    return { isValid: false, error: 'Airtable base ID is required' }
+  }
+
+  if (!config.personalAccessToken || typeof config.personalAccessToken !== 'string') {
+    return { isValid: false, error: 'Airtable personal access token is required' }
+  }
+
+  return { isValid: true }
+}
+
+interface AirtableConfig {
+  baseId?: string
+  personalAccessToken?: string
+  selectedTables?: Record<string, unknown>
+}
+
+export const generateAirtableFetcher = (
+  config: Record<string, unknown>,
+  tableName: string
+): string => {
+  const airtableConfig = config as AirtableConfig
+  const baseId = airtableConfig.baseId
+  const personalAccessToken = airtableConfig.personalAccessToken
+
+  return `import fetch from 'node-fetch'
+
+export default async function handler(req, res) {
+  try {
+    const { query, view, limit, page, perPage, sortBy, sortOrder, filters, offset: offsetParam } = req.query
+    
+    const queryParams = new URLSearchParams()
+    
+    if (view) {
+      queryParams.append('view', view)
+    }
+    
+    if (sortBy) {
+      queryParams.append('sort[0][field]', sortBy)
+      queryParams.append('sort[0][direction]', sortOrder || 'asc')
+    }
+    
+    const perPageValue = limit || perPage || 100
+    queryParams.append('pageSize', Math.min(parseInt(perPageValue), 100).toString())
+    
+    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()'}\`
+            }
+            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()'}\`
+        }
+        return \`{\${field}}='\${String(value)}'\`
+      })
+      
+      const filterFormula = conditions.length > 1 ? \`AND(\${conditions.join(',')})\` : conditions[0]
+      if (filterFormula) {
+        queryParams.append('filterByFormula', filterFormula)
+      }
+    }
+    
+    let url = \`https://api.airtable.com/v0/${baseId}/\${encodeURIComponent('${tableName}')}\`
+    if (queryParams.toString()) {
+      url += \`?\${queryParams.toString()}\`
+    }
+    
+    const allRecords = []
+    let airtableOffset
+    const skipValue = offsetParam !== undefined ? parseInt(offsetParam) : (page ? (parseInt(page) - 1) * parseInt(perPageValue) : 0)
+    const totalRecordsNeeded = skipValue + parseInt(perPageValue)
+    
+    do {
+      const fetchUrl = airtableOffset ? \`\${url}&offset=\${airtableOffset}\` : url
+      const response = await fetch(fetchUrl, {
+        method: 'GET',
+        headers: {
+          Authorization: \`Bearer ${replaceSecretReference(personalAccessToken, {
+            templateLiteral: true,
+          })}\`,
+          'Content-Type': 'application/json'
+        }
+      })
+      
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}))
+        return res.status(response.status).json({
+          success: false,
+          error: errorData.error?.message || \`HTTP \${response.status}: \${response.statusText}\`,
+          timestamp: Date.now()
+        })
+      }
+      
+      const data = await response.json()
+      allRecords.push(...data.records)
+      airtableOffset = data.offset
+      
+      if (allRecords.length >= totalRecordsNeeded || !airtableOffset) {
+        break
+      }
+    } while (airtableOffset)
+    
+    const paginatedRecords = allRecords.slice(skipValue, skipValue + parseInt(perPageValue))
+    
+    const formattedRecords = paginatedRecords.map((record) => ({
+      id: record.id,
+      ...record.fields,
+      createdTime: record.createdTime
+    }))
+    
+    const safeData = JSON.parse(JSON.stringify(formattedRecords))
+    
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('Airtable fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}

package/src/fetchers/clickhouse.ts

@@ -0,0 +1,127 @@
+import { replaceSecretReference } from '../utils'
+
+export const validateClickHouseConfig = (
+  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.url || typeof config.url !== 'string') {
+    return { isValid: false, error: 'ClickHouse URL is required' }
+  }
+
+  if (!config.username || typeof config.username !== 'string') {
+    return { isValid: false, error: 'ClickHouse username is required' }
+  }
+
+  if (!config.password || typeof config.password !== 'string') {
+    return { isValid: false, error: 'ClickHouse password is required' }
+  }
+
+  return { isValid: true }
+}
+
+interface ClickHouseConfig {
+  url?: string
+  username?: string
+  password?: string
+}
+
+export const generateClickHouseFetcher = (
+  config: Record<string, unknown>,
+  tableName: string
+): string => {
+  const clickConfig = config as ClickHouseConfig
+  const url = clickConfig.url
+  const username = clickConfig.username
+  const password = clickConfig.password
+
+  return `import { createClient } from '@clickhouse/client'
+
+let client = null
+
+const getClient = () => {
+  if (client) return client
+  
+  client = createClient({
+    url: ${JSON.stringify(url)},
+    username: ${JSON.stringify(username)},
+    password: ${replaceSecretReference(password)}
+  })
+  
+  return client
+}
+
+export default async function handler(req, res) {
+  try {
+    const client = getClient()
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset } = req.query
+    
+    const conditions = []
+    
+    if (query && queryColumns) {
+      const columns = JSON.parse(queryColumns)
+      const searchConditions = columns.map(
+        (col) => \`positionCaseInsensitive(toString(\${col}), '\${query}') > 0\`
+      )
+      conditions.push(\`(\${searchConditions.join(' OR ')})\`)
+    }
+    
+    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}\`)
+        }
+      })
+    }
+    
+    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 result = await client.query({ query: sql })
+    const resultResponse = await result.json()
+    const safeData = JSON.parse(JSON.stringify(resultResponse.data))
+
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('ClickHouse fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}

package/src/fetchers/csv-file.ts

@@ -0,0 +1,163 @@
+export const validateCSVConfig = (
+  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.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' }
+    }
+
+    for (const column of config.columns) {
+      if (!column || typeof column !== 'object' || !column.id || typeof column.id !== 'string') {
+        return { isValid: false, error: 'Each column must have a valid id' }
+      }
+    }
+  }
+
+  return { isValid: true }
+}
+
+interface CSVFileConfig {
+  parsedData?: unknown[]
+  columns?: Array<{ id: string; [key: string]: unknown }>
+}
+
+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) {
+  try {
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset: offsetParam } = req.query
+    
+    let filteredData = [...data]
+    
+    if (query) {
+      const searchQuery = query.toLowerCase()
+      
+      if (queryColumns) {
+        const columns = JSON.parse(queryColumns)
+        filteredData = filteredData.filter((item) => {
+          return columns.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('CSV fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}
+
+// tslint:disable-next-line:variable-name
+export const generateCSVCountFetcher = (_config: any): string => {
+  return `
+async function getCount(req, res) {
+  try {
+    const { query, queryColumns, filters } = req.query
+    const fakeReq = { query: { query, queryColumns, filters }, 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/firestore.ts

@@ -0,0 +1,138 @@
+import { replaceSecretReference } from '../utils'
+
+export const validateFirestoreConfig = (
+  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.serviceAccount || typeof config.serviceAccount !== 'string') {
+    return { isValid: false, error: 'Firestore service account JSON is required' }
+  }
+
+  const serviceAccount = config.serviceAccount as string
+
+  // If serviceAccount is a secret reference, we assume the runtime env var will contain valid JSON
+  // Example: "teleporthq.secrets.DATA_SOURCE_FIRESTORE_SERVICE_ACCOUNT"
+  if (!serviceAccount.startsWith('teleporthq.secrets.')) {
+    try {
+      const parsed = JSON.parse(serviceAccount)
+      if (!parsed.project_id || !parsed.private_key || !parsed.client_email) {
+        return { isValid: false, error: 'Invalid Firestore service account JSON structure' }
+      }
+    } catch {
+      return { isValid: false, error: 'Service account must be valid JSON' }
+    }
+  }
+
+  return { isValid: true }
+}
+
+interface FirestoreConfig {
+  serviceAccount?: string
+  selectedTables?: Record<string, unknown>
+}
+
+export const generateFirestoreFetcher = (
+  config: Record<string, unknown>,
+  tableName: string
+): string => {
+  const firestoreConfig = config as FirestoreConfig
+  const serviceAccount = firestoreConfig.serviceAccount
+
+  return `import * as admin from 'firebase-admin'
+
+let firestore = null
+
+const getFirestore = () => {
+  if (firestore) return firestore
+  
+  const rawServiceAccount = ${replaceSecretReference(serviceAccount)}
+  let serviceAccount
+
+  try {
+    serviceAccount = JSON.parse(rawServiceAccount)
+  } catch (error) {
+    throw new Error('Invalid Firestore service account JSON: ' + error.message)
+  }
+  
+  if (!admin.apps.length) {
+    admin.initializeApp({
+      credential: admin.credential.cert(serviceAccount)
+    })
+  }
+  
+  firestore = admin.firestore()
+  return firestore
+}
+
+export default async function handler(req, res) {
+  try {
+    const firestore = getFirestore()
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, 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)
+        }
+      })
+    }
+    
+    if (query && queryColumns) {
+      const columns = JSON.parse(queryColumns)
+      for (const column of columns) {
+        queryRef = queryRef
+          .where(column, '>=', query)
+          .where(column, '<=', query + '\\uf8ff')
+      }
+    }
+    
+    if (sortBy) {
+      const sortOrderValue = sortOrder?.toLowerCase() === 'desc' ? 'desc' : 'asc'
+      queryRef = queryRef.orderBy(sortBy, sortOrderValue)
+    }
+    
+    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)
+    }
+    
+    const snapshot = await queryRef.get()
+    const documents = []
+    snapshot.forEach((doc) => {
+      documents.push({
+        id: doc.id,
+        ...doc.data()
+      })
+    })
+    
+    const safeData = JSON.parse(JSON.stringify(documents))
+    
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('Firestore fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}