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

package/src/fetchers/postgresql.ts

@@ -0,0 +1,247 @@
+import { replaceSecretReference } from '../utils'
+
+interface PostgreSQLConfig {
+  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 }
+  options?: { schema?: string }
+}
+
+export const generatePostgreSQLFetcher = (
+  config: Record<string, unknown>,
+  tableName: string
+): string => {
+  const pgConfig = config as PostgreSQLConfig
+  const schema = pgConfig.options?.schema
+
+  return `import { Pool } from 'pg'
+
+let pool = null
+
+const getPool = () => {
+  if (pool) return pool
+  
+  pool = new Pool({
+    host: ${JSON.stringify(pgConfig.host)},
+    port: ${pgConfig.port || 5432},
+    user: ${JSON.stringify(pgConfig.user || pgConfig.username)},
+    password: ${replaceSecretReference(pgConfig.password)},
+    database: ${JSON.stringify(pgConfig.database)},
+    ssl: ${
+      pgConfig.ssl === false
+        ? 'false'
+        : pgConfig.sslConfig
+        ? `{
+      ${pgConfig.sslConfig.ca ? `ca: ${replaceSecretReference(pgConfig.sslConfig.ca)},` : ''}
+      ${pgConfig.sslConfig.cert ? `cert: ${replaceSecretReference(pgConfig.sslConfig.cert)},` : ''}
+      ${pgConfig.sslConfig.key ? `key: ${replaceSecretReference(pgConfig.sslConfig.key)},` : ''}
+      rejectUnauthorized: false
+    }`
+        : '{ rejectUnauthorized: false }'
+    }
+  })
+  
+  return pool
+}
+
+export default async function handler(req, res) {
+  try {
+    const pool = getPool()
+    ${schema ? `await pool.query('SET search_path TO ${schema}')` : ''}
+    
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset } = req.query
+    
+    const conditions = []
+    const queryParams = []
+    let paramIndex = 1
+    
+    if (query) {
+      let columns = []
+      
+      if (queryColumns) {
+        // Use specified columns
+        columns = JSON.parse(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)
+          // Continue without search if we can't get columns
+        }
+      }
+      
+      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) {
+      const parsedFilters = JSON.parse(filters)
+      Object.entries(parsedFilters).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          const placeholders = value.map(() => \`$\${paramIndex++}\`)
+          queryParams.push(...value)
+          conditions.push(\`\${key} IN (\${placeholders.join(', ')})\`)
+        } else {
+          conditions.push(\`\${key} = $\${paramIndex}\`)
+          queryParams.push(value)
+          paramIndex++
+        }
+      })
+    }
+    
+    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 pool.query(sql, queryParams)
+    const rows = Array.isArray(result?.rows) ? result.rows : []
+    const plainRows = rows.map((row) =>
+      row && typeof row.toJSON === 'function' ? row.toJSON() : row
+    )
+    const safeData = JSON.parse(JSON.stringify(plainRows))
+
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('PostgreSQL fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}
+
+export const generatePostgreSQLCountFetcher = (
+  config: Record<string, unknown>,
+  tableName: string
+): string => {
+  const pgConfig = config as PostgreSQLConfig
+  const hasSchema = !!pgConfig.options?.schema
+
+  return `
+async function getCount(req, res) {
+  const pool = getPool()
+
+  try {
+    const { query, queryColumns, filters } = req.query
+    const conditions = []
+    const queryParams = []
+    let paramIndex = 1
+
+    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 schemaQuery = \`
+            SELECT column_name 
+            FROM information_schema.columns 
+            WHERE table_name = $1
+            ${hasSchema ? `AND table_schema = $2` : ''}
+            ORDER BY ordinal_position
+          \`
+          const schemaParams = ${
+            hasSchema
+              ? `[${JSON.stringify(tableName)}, ${JSON.stringify(pgConfig.options!.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)
+          // Continue without search if we can't get columns
+        }
+      }
+      
+      if (columns.length > 0) {
+        const searchConditions = columns.map(col => \`\${col}::text ILIKE $\${paramIndex++}\`).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} $\${paramIndex++}\`)
+        queryParams.push(filter.value)
+      }
+    }
+
+    let countSql = \`SELECT COUNT(*) FROM ${tableName}\`
+    if (conditions.length > 0) {
+      countSql += \` WHERE \${conditions.join(' AND ')}\`
+    }
+
+    const result = await pool.query(countSql, queryParams)
+    const count = parseInt(result.rows[0].count, 10)
+
+    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/redis.ts

@@ -0,0 +1,152 @@
+import { replaceSecretReference } from '../utils'
+
+export const validateRedisConfig = (
+  config: Record<string, unknown>
+): { isValid: boolean; error?: string } => {
+  if (!config || typeof config !== 'object') {
+    return { isValid: false, error: 'Config must be a valid object' }
+  }
+
+  // If connectionString is provided, validate it
+  if (config.connectionString) {
+    if (typeof config.connectionString !== 'string' || config.connectionString.trim() === '') {
+      return { isValid: false, error: 'Connection string must be a non-empty string' }
+    }
+
+    // Only validate format if it's not a secret reference that will be resolved at runtime
+    const connStr = config.connectionString as string
+    if (
+      !connStr.startsWith('teleporthq.secrets.') &&
+      !connStr.startsWith('redis://') &&
+      !connStr.startsWith('rediss://')
+    ) {
+      return { isValid: false, error: 'Invalid Redis connection string format' }
+    }
+
+    return { isValid: true }
+  }
+
+  // If no connectionString, host/port/etc will be used to build one
+  if (!config.host || typeof config.host !== 'string') {
+    return { isValid: false, error: 'Redis host is required when connectionString is not provided' }
+  }
+
+  return { isValid: true }
+}
+
+interface RedisConfig {
+  connectionString?: string
+  host?: string
+  port?: number
+  database?: number
+  password?: string
+  username?: string
+  selectedTables?: Record<string, unknown>
+}
+
+export const generateRedisFetcher = (config: Record<string, unknown>): string => {
+  const redisConfig = config as RedisConfig
+  const host = redisConfig.host
+  const port = redisConfig.port
+  const username = redisConfig.username
+  const password = redisConfig.password
+  const database = redisConfig.database
+  const hasUsername = username
+
+  // Build connection string from parts if not provided
+  let connectionString = redisConfig.connectionString
+  if (!connectionString) {
+    connectionString = `redis://${hasUsername ? `${username}:${password}@` : ''}${host}:${
+      port || 6379
+    }`
+  }
+
+  return `import { createClient } from 'redis'
+
+export default async function handler(req, res) {
+  let client = null
+  try {
+    client = createClient({
+      url: ${replaceSecretReference(connectionString)}${
+    database ? `,\n      database: ${database}` : ''
+  }
+    })
+    
+    await client.connect()
+    
+    const { query, limit, page, perPage, sortBy, sortOrder, filters, offset } = req.query
+    
+    const pattern = (filters && JSON.parse(filters).pattern) || query || '*'
+    const keys = await client.keys(pattern)
+    
+    const limitValue = limit || perPage || 100
+    const skipValue = offset !== undefined ? parseInt(offset) : ((parseInt(page) || 1) - 1) * parseInt(limitValue)
+    const paginatedKeys = keys.slice(skipValue, skipValue + parseInt(limitValue))
+    
+    const results = []
+    for (const key of paginatedKeys) {
+      const type = await client.type(key)
+      const ttl = await client.ttl(key)
+      let value
+      
+      switch (type) {
+        case 'string':
+          value = await client.get(key)
+          break
+        case 'list':
+          value = await client.lRange(key, 0, -1)
+          break
+        case 'set':
+          value = await client.sMembers(key)
+          break
+        case 'zset':
+          value = await client.zRange(key, 0, -1)
+          break
+        case 'hash':
+          value = await client.hGetAll(key)
+          break
+        default:
+          value = null
+      }
+      
+      results.push({
+        key,
+        type,
+        value,
+        ttl: ttl === -1 ? null : ttl
+      })
+    }
+    
+    if (sortBy) {
+      const sortOrderValue = sortOrder?.toLowerCase() === 'desc' ? -1 : 1
+      results.sort((a, b) => {
+        const aVal = a[sortBy]
+        const bVal = b[sortBy]
+        if (aVal < bVal) return -sortOrderValue
+        if (aVal > bVal) return sortOrderValue
+        return 0
+      })
+    }
+    
+    const safeData = JSON.parse(JSON.stringify(results))
+    
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('Redis fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  } finally {
+    if (client) {
+      await client.quit()
+    }
+  }
+}
+`
+}

package/src/fetchers/redshift.ts

@@ -0,0 +1,138 @@
+import { replaceSecretReference } from '../utils'
+
+interface RedshiftConfig {
+  host?: string
+  port?: number
+  user?: string
+  password?: string
+  database?: string
+  ssl?: boolean | { ca?: string; cert?: string; key?: string; rejectUnauthorized?: boolean }
+  sslConfig?: { ca?: string; cert?: string; key?: string; rejectUnauthorized?: boolean }
+  options?: { schema?: string }
+}
+
+export const generateRedshiftFetcher = (
+  config: Record<string, unknown>,
+  tableName: string
+): string => {
+  const redshiftConfig = config as RedshiftConfig
+  const host = redshiftConfig.host
+  const port = redshiftConfig.port
+  const user = redshiftConfig.user
+  const password = redshiftConfig.password
+  const database = redshiftConfig.database
+  const ssl = redshiftConfig.ssl
+  const sslConfig = redshiftConfig.sslConfig
+  const schema = redshiftConfig.options?.schema
+
+  return `import { Pool } from 'pg'
+
+let pool = null
+
+const getPool = () => {
+  if (pool) return pool
+  
+  pool = new Pool({
+    host: ${JSON.stringify(host)},
+    port: ${port || 5439},
+    user: ${JSON.stringify(user)},
+    password: ${replaceSecretReference(password)},
+    database: ${JSON.stringify(database)},
+    ssl: ${
+      ssl === false
+        ? '{ rejectUnauthorized: false }'
+        : sslConfig
+        ? `{
+      ${sslConfig.ca ? `ca: ${replaceSecretReference(sslConfig.ca)},` : ''}
+      ${sslConfig.cert ? `cert: ${replaceSecretReference(sslConfig.cert)},` : ''}
+      ${sslConfig.key ? `key: ${replaceSecretReference(sslConfig.key)},` : ''}
+      rejectUnauthorized: ${sslConfig.rejectUnauthorized !== false}
+    }`
+        : '{ rejectUnauthorized: false }' // Default to SSL with no cert verification for Redshift
+    }
+  })
+  
+  return pool
+}
+
+export default async function handler(req, res) {
+  try {
+    const pool = getPool()
+    ${schema ? `await pool.query('SET search_path TO ${schema}')` : ''}
+    
+    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, offset } = req.query
+    
+    const conditions = []
+    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 (filters) {
+      const parsedFilters = JSON.parse(filters)
+      Object.entries(parsedFilters).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          const placeholders = value.map(() => \`$\${paramIndex++}\`)
+          queryParams.push(...value)
+          conditions.push(\`\${key} IN (\${placeholders.join(', ')})\`)
+        } else {
+          conditions.push(\`\${key} = $\${paramIndex}\`)
+          queryParams.push(value)
+          paramIndex++
+        }
+      })
+    }
+    
+    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 pool.query(sql, queryParams)
+    const rows = Array.isArray(result?.rows) ? result.rows : []
+    const plainRows = rows.map((row) =>
+      row && typeof row.toJSON === 'function' ? row.toJSON() : row
+    )
+    const safeData = JSON.parse(JSON.stringify(plainRows))
+
+    return res.status(200).json({
+      success: true,
+      data: safeData,
+      timestamp: Date.now()
+    })
+  } catch (error) {
+    console.error('Redshift fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}

package/src/fetchers/rest-api.ts

@@ -0,0 +1,148 @@
+export const validateRESTAPIConfig = (
+  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' || config.url.trim() === '') {
+    return { isValid: false, error: 'URL is required' }
+  }
+
+  try {
+    const url = new URL(config.url)
+    if (!['http:', 'https:'].includes(url.protocol)) {
+      return { isValid: false, error: 'URL must use HTTP or HTTPS protocol' }
+    }
+  } catch {
+    return { isValid: false, error: 'Invalid URL format' }
+  }
+
+  if (config.method) {
+    const validMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE']
+    if (typeof config.method !== 'string' || !validMethods.includes(config.method.toUpperCase())) {
+      return { isValid: false, error: 'Invalid HTTP method' }
+    }
+  }
+
+  return { isValid: true }
+}
+
+interface Authorization {
+  type?: string
+  credentials?: {
+    apiKey?: string
+    token?: string
+    username?: string
+    password?: string
+    clientSecret?: string
+  }
+}
+
+const generateAuthCode = (authorization: Authorization): string => {
+  if (!authorization || authorization.type === 'none') {
+    return ''
+  }
+
+  const { type, credentials } = authorization
+
+  switch (type) {
+    case 'api-key':
+      return `headers['Authorization'] = 'ApiKey ${credentials.apiKey}'`
+    case 'bearer-token':
+    case 'jwt-bearer':
+      return `headers['Authorization'] = 'Bearer ${credentials.token}'`
+    case 'basic-auth':
+      return `headers['Authorization'] = 'Basic ' + Buffer.from('${credentials.username}:${credentials.password}').toString('base64')`
+    case 'oauth2':
+      return `headers['Authorization'] = 'Bearer ${credentials.clientSecret}'`
+    default:
+      return ''
+  }
+}
+
+interface RESTAPIConfig {
+  url?: string
+  method?: string
+  headers?: Record<string, string>
+  authorization?: Authorization
+  bodyType?: string
+}
+
+export const generateRESTAPIFetcher = (config: Record<string, unknown>): string => {
+  const restConfig = config as RESTAPIConfig
+  const authCode = generateAuthCode(restConfig.authorization || {})
+
+  return `import fetch from 'node-fetch'
+
+export default async function handler(req, res) {
+  try {
+    const { offset, limit } = req.query
+    
+    const url = ${JSON.stringify(restConfig.url)}
+    const method = ${JSON.stringify(restConfig.method || 'GET')}
+    
+    const headers = ${JSON.stringify(restConfig.headers || {})}
+    ${authCode}
+    
+    const options = {
+      method,
+      headers
+    }
+    
+    ${
+      restConfig.method === 'POST' || restConfig.method === 'PUT' || restConfig.method === 'PATCH'
+        ? `
+    if (req.body) {
+      options.body = ${
+        restConfig.bodyType === 'json' || !restConfig.bodyType
+          ? 'JSON.stringify(req.body)'
+          : 'req.body'
+      }
+    }
+    `
+        : ''
+    }
+    
+    const response = await fetch(url, options)
+    
+    if (!response.ok) {
+      return res.status(response.status).json({
+        success: false,
+        error: \`HTTP \${response.status}: \${response.statusText}\`,
+        timestamp: Date.now()
+      })
+    }
+    
+    let data = await response.json()
+    
+    // Apply offset and limit if data is an array and parameters are provided
+    if (Array.isArray(data)) {
+      const offsetValue = offset !== undefined ? parseInt(offset) : 0
+      const limitValue = limit !== undefined ? parseInt(limit) : undefined
+      
+      if (limitValue !== undefined) {
+        data = data.slice(offsetValue, offsetValue + 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('REST API fetch error:', error)
+    return res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to fetch data',
+      timestamp: Date.now()
+    })
+  }
+}
+`
+}