pglens 1.0.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pglens",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "A simple PostgreSQL database viewer tool",
   "main": "src/server.js",
   "bin": {

package/src/db/connection.js

@@ -1,13 +1,16 @@
 /**
  * Database Connection Pool Manager
  * 
- * Manages PostgreSQL connection pool using postgres library.
+ * Manages PostgreSQL connection pools using postgres library.
  * Provides connection pooling for efficient database access.
+ * Supports multiple simultaneous connections.
  */
 
 const postgres = require('postgres');
+const crypto = require('crypto');
 
-let sql = null;
+// Map to store multiple connections: id -> { pool, name, connectionString }
+const connections = new Map();
 
 /**
  * Create a wrapper that provides pg-compatible query interface.
@@ -25,49 +28,98 @@ function createPoolWrapper(sqlClient) {
   };
 }
 
+/**
+ * Extract database name from connection string
+ * @param {string} connectionString 
+ * @returns {string} Database name or 'Unknown'
+ */
+function getDatabaseName(connectionString) {
+  try {
+    const url = new URL(connectionString);
+    return url.pathname.replace(/^\//, '') || 'postgres';
+  } catch (e) {
+    return 'postgres';
+  }
+}
+
 /**
  * Create a new connection pool.
- * Closes existing pool if one exists.
  * @param {string} connectionString - PostgreSQL connection string
  * @param {string} sslMode - SSL mode: disable, require, prefer, verify-ca, verify-full
- * @returns {Promise} The created connection wrapper
+ * @param {string} [customName] - Optional custom name for the connection
+ * @returns {Promise<{id: string, name: string}>} The created connection info
  */
-function createPool(connectionString, sslMode = 'prefer') {
-  if (sql) {
-    sql.end();
-  }
-
+function createPool(connectionString, sslMode = 'prefer', customName = null) {
   const sslConfig = getSslConfig(sslMode);
   const poolConfig = {
     max: 10,
     idle_timeout: 30,
     connect_timeout: 10,
+    timeout: 30, // Query timeout in seconds
   };
 
   if (sslConfig !== null) {
     poolConfig.ssl = sslConfig;
   }
 
-  sql = postgres(connectionString, poolConfig);
+  const sql = postgres(connectionString, poolConfig);
 
   // Test the connection
   return sql`SELECT NOW()`
     .then(() => {
       console.log('✓ Connected to PostgreSQL database');
-      return createPoolWrapper(sql);
+
+      // Check if this connection string already exists
+      for (const [existingId, existingConn] of connections.entries()) {
+        if (existingConn.connectionString === connectionString) {
+          // If a custom name is provided and different from existing, update it
+          if (customName && customName !== existingConn.name) {
+            existingConn.name = customName;
+          }
+          // Return the existing connection details
+          sql.end();
+          return { id: existingId, name: existingConn.name, reused: true };
+        }
+      }
+
+      const id = crypto.randomUUID();
+      const name = customName || getDatabaseName(connectionString);
+
+      connections.set(id, {
+        pool: sql,
+        name,
+        connectionString,
+        sslMode
+      });
+
+      return { id, name };
     })
     .catch((err) => {
       console.error('✗ Failed to connect to PostgreSQL database:', err.message);
       const recommendation = getSslModeRecommendation(err, sslMode);
       if (recommendation) {
-        console.error(`\n💡 SSL Mode Recommendation: Try using --sslmode ${recommendation}`);
-        console.error(`   Current SSL mode: ${sslMode}`);
-        console.error(`   Suggested command: Add --sslmode ${recommendation} to your command\n`);
+        console.error(`\n💡 SSL Mode Recommendation: Try using sslmode '${recommendation}'`);
       }
       throw err;
     });
 }
 
+/**
+ * Check if a specific connection is active.
+ * @param {string} connectionId - Connection ID
+ * @returns {Promise<boolean>} True if connected
+ */
+function checkConnection(connectionId) {
+  const conn = connections.get(connectionId);
+  if (!conn) {
+    return Promise.resolve(false);
+  }
+
+  return conn.pool`SELECT 1`
+    .then(() => true)
+    .catch(() => false);
+}
+
 /**
  * Analyze connection error and recommend appropriate SSL mode.
  * @param {Error} error - Connection error object
@@ -170,31 +222,115 @@ function getSslConfig(sslMode) {
 }
 
 /**
- * Get the current connection pool.
- * @returns {object} The connection pool wrapper
- * @throws {Error} If pool is not initialized
+ * Get a connection pool by ID.
+ * @param {string} connectionId - The connection ID
+ * @returns {object|null} The connection pool wrapper or null if not found
  */
-function getPool() {
-  if (!sql) {
-    throw new Error('Database pool not initialized. Call createPool first.');
+function getPool(connectionId) {
+  const conn = connections.get(connectionId);
+  if (!conn) {
+    return null;
   }
-  return createPoolWrapper(sql);
+  return createPoolWrapper(conn.pool);
 }
 
 /**
- * Close the connection pool gracefully.
+ * Get list of all active connections.
+ * @returns {Array<{id: string, name: string}>} List of connections
+ */
+function getConnections() {
+  const result = [];
+  for (const [id, conn] of connections.entries()) {
+    result.push({
+      id,
+      name: conn.name,
+      connectionString: conn.connectionString,
+      sslMode: conn.sslMode
+    });
+  }
+  return result;
+}
+
+/**
+ * Update an existing connection.
+ * @param {string} id - Connection ID to update
+ * @param {string} connectionString - New connection string
+ * @param {string} sslMode - New SSL mode
+ * @param {string} name - New name
+ * @returns {Promise<{id: string, name: string}>} Updated connection info
+ */
+async function updateConnection(id, connectionString, sslMode, name) {
+  const existingConn = connections.get(id);
+  if (!existingConn) {
+    throw new Error('Connection not found');
+  }
+
+  const sslConfig = getSslConfig(sslMode);
+  const poolConfig = {
+    max: 10,
+    idle_timeout: 30,
+    connect_timeout: 10,
+    timeout: 30, // Query timeout in seconds
+  };
+
+  if (sslConfig !== null) {
+    poolConfig.ssl = sslConfig;
+  }
+
+  const sql = postgres(connectionString, poolConfig);
+
+  // Test the new connection
+  return sql`SELECT NOW()`
+    .then(async () => {
+      console.log('✓ Updated connection to PostgreSQL database');
+
+      // Close old pool
+      await existingConn.pool.end();
+
+      // Update map with new pool and details
+      connections.set(id, {
+        pool: sql,
+        name: name || getDatabaseName(connectionString),
+        connectionString,
+        sslMode
+      });
+
+      return { id, name: connections.get(id).name };
+    })
+    .catch((err) => {
+      console.error('✗ Failed to update connection:', err.message);
+      throw err;
+    });
+}
+
+/**
+ * Close a specific connection pool.
+ * @param {string} connectionId - The connection ID to close
  * @returns {Promise} Promise that resolves when pool is closed
  */
-function closePool() {
-  if (sql) {
-    return sql.end();
+async function closePool(connectionId) {
+  if (connectionId) {
+    const conn = connections.get(connectionId);
+    if (conn) {
+      await conn.pool.end();
+      connections.delete(connectionId);
+    }
+  } else {
+    // Close all connections (e.g., on server shutdown)
+    const promises = [];
+    for (const conn of connections.values()) {
+      promises.push(conn.pool.end());
+    }
+    await Promise.all(promises);
+    connections.clear();
   }
-  return Promise.resolve();
 }
 
 module.exports = {
   createPool,
   getPool,
   closePool,
+  checkConnection,
+  getConnections,
+  updateConnection
 };
-

package/src/routes/api.js

@@ -14,10 +14,119 @@
  */
 
 const express = require('express');
-const { getPool } = require('../db/connection');
+const { getPool, createPool, closePool, checkConnection, getConnections, updateConnection } = require('../db/connection');
 
 const router = express.Router();
 
+/**
+ * Middleware to check if connected to database
+ */
+const requireConnection = async (req, res, next) => {
+  const connectionId = req.headers['x-connection-id'];
+  if (!connectionId) {
+    return res.status(400).json({ error: 'Connection ID header required' });
+  }
+
+  const pool = getPool(connectionId);
+  if (!pool) {
+    return res.status(503).json({ error: 'Not connected to database or invalid connection ID' });
+  }
+
+  req.pool = pool;
+  next();
+};
+
+/**
+ * POST /api/connect
+ * Connect to a PostgreSQL database
+ */
+router.post('/connect', async (req, res) => {
+  const { url, sslMode, name } = req.body;
+
+  if (!url) {
+    return res.status(400).json({ error: 'Connection string is required' });
+  }
+
+  try {
+    const { id, name: connectionName } = await createPool(url, sslMode || 'prefer', name);
+    res.json({ connected: true, connectionId: id, name: connectionName });
+  } catch (error) {
+    res.status(400).json({
+      connected: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * PUT /api/connections/:id
+ * Update an existing connection
+ */
+router.put('/connections/:id', async (req, res) => {
+  const { id } = req.params;
+  const { url, sslMode, name } = req.body;
+
+  if (!url) {
+    return res.status(400).json({ error: 'Connection string is required' });
+  }
+
+  try {
+    const { name: connectionName } = await updateConnection(id, url, sslMode || 'prefer', name);
+    res.json({ updated: true, connectionId: id, name: connectionName });
+  } catch (error) {
+    res.status(400).json({
+      updated: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/connections
+ * List active connections
+ */
+router.get('/connections', (req, res) => {
+  const connections = getConnections();
+  res.json({ connections });
+});
+
+/**
+ * POST /api/disconnect
+ * Disconnect from a database
+ */
+router.post('/disconnect', async (req, res) => {
+  const connectionId = req.body.connectionId || req.headers['x-connection-id'];
+
+  if (!connectionId) {
+    return res.status(400).json({ error: 'Connection ID required' });
+  }
+
+  try {
+    await closePool(connectionId);
+    res.json({ connected: false });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/status
+ * Check connection status
+ */
+router.get('/status', async (req, res) => {
+  const connectionId = req.headers['x-connection-id'];
+  if (!connectionId) {
+    return res.json({ connected: false });
+  }
+
+  try {
+    const connected = await checkConnection(connectionId);
+    res.json({ connected });
+  } catch (error) {
+    res.json({ connected: false, error: error.message });
+  }
+});
+
 /**
  * Sanitize table name to prevent SQL injection.
  * Only allows alphanumeric characters, underscores, and dots.
@@ -40,9 +149,9 @@ function sanitizeTableName(tableName) {
  * 
  * Response: { tables: string[] }
  */
-router.get('/tables', async (req, res) => {
+router.get('/tables', requireConnection, async (req, res) => {
   try {
-    const pool = getPool();
+    const pool = req.pool;
     const result = await pool.query(`
       SELECT table_name 
       FROM information_schema.tables 
@@ -88,6 +197,147 @@ async function getPrimaryKeyColumn(pool, tableName) {
   }
 }
 
+/**
+ * Get foreign key relationships for a table.
+ * Queries information_schema to get foreign key constraints and their references.
+ * @param {Pool} pool - Database connection pool
+ * @param {string} tableName - Name of the table
+ * @returns {Promise<Object>} Object mapping column names to their foreign key references { table, column }
+ */
+async function getForeignKeyRelations(pool, tableName) {
+  try {
+    const fkQuery = `
+      SELECT
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public';
+    `;
+    const result = await pool.query(fkQuery, [tableName]);
+    const foreignKeys = {};
+    result.rows.forEach(row => {
+      foreignKeys[row.column_name] = {
+        table: row.foreign_table_name,
+        column: row.foreign_column_name
+      };
+    });
+    return foreignKeys;
+  } catch (error) {
+    console.error('Error getting foreign key relations:', error);
+    return {};
+  }
+}
+
+/**
+ * Get all primary key columns for a table.
+ * @param {Pool} pool - Database connection pool
+ * @param {string} tableName - Name of the table
+ * @returns {Promise<Set>} Set of primary key column names
+ */
+async function getPrimaryKeyColumns(pool, tableName) {
+  try {
+    const pkQuery = `
+      SELECT kcu.column_name
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public';
+    `;
+    const result = await pool.query(pkQuery, [tableName]);
+    const pkColumns = new Set();
+    result.rows.forEach(row => {
+      pkColumns.add(row.column_name);
+    });
+    return pkColumns;
+  } catch (error) {
+    console.error('Error getting primary key columns:', error);
+    return new Set();
+  }
+}
+
+/**
+ * Get all unique constraint columns for a table.
+ * @param {Pool} pool - Database connection pool
+ * @param {string} tableName - Name of the table
+ * @returns {Promise<Set>} Set of unique constraint column names
+ */
+async function getUniqueColumns(pool, tableName) {
+  try {
+    const uniqueQuery = `
+      SELECT kcu.column_name
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      WHERE tc.constraint_type = 'UNIQUE'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public';
+    `;
+    const result = await pool.query(uniqueQuery, [tableName]);
+    const uniqueColumns = new Set();
+    result.rows.forEach(row => {
+      uniqueColumns.add(row.column_name);
+    });
+    return uniqueColumns;
+  } catch (error) {
+    console.error('Error getting unique columns:', error);
+    return new Set();
+  }
+}
+
+/**
+ * Get column metadata (datatypes and key relationships) for a table.
+ * Queries information_schema.columns to get column names and their data types,
+ * and includes key relationship information (primary keys, foreign keys, unique constraints).
+ * @param {Pool} pool - Database connection pool
+ * @param {string} tableName - Name of the table
+ * @returns {Promise<Object>} Object mapping column names to metadata objects with dataType, isPrimaryKey, isForeignKey, foreignKeyRef, isUnique
+ */
+async function getColumnMetadata(pool, tableName) {
+  try {
+    const metadataQuery = `
+      SELECT column_name, data_type
+      FROM information_schema.columns
+      WHERE table_schema = 'public'
+      AND table_name = $1
+      ORDER BY ordinal_position;
+    `;
+    const result = await pool.query(metadataQuery, [tableName]);
+
+    const primaryKeyColumns = await getPrimaryKeyColumns(pool, tableName);
+    const foreignKeyRelations = await getForeignKeyRelations(pool, tableName);
+    const uniqueColumns = await getUniqueColumns(pool, tableName);
+
+    const columns = {};
+    result.rows.forEach(row => {
+      const columnName = row.column_name;
+      columns[columnName] = {
+        dataType: row.data_type,
+        isPrimaryKey: primaryKeyColumns.has(columnName),
+        isForeignKey: !!foreignKeyRelations[columnName],
+        foreignKeyRef: foreignKeyRelations[columnName] || null,
+        isUnique: uniqueColumns.has(columnName)
+      };
+    });
+    return columns;
+  } catch (error) {
+    console.error('Error getting column metadata:', error);
+    return {};
+  }
+}
+
 /**
  * GET /api/tables/:tableName
  * 
@@ -110,22 +360,36 @@ async function getPrimaryKeyColumn(pool, tableName) {
  *   limit: number,
  *   isApproximate: boolean,
  *   nextCursor: string|null,
- *   hasPrimaryKey: boolean
+ *   hasPrimaryKey: boolean,
+ *   columns: Object - Map of column names to metadata objects with:
+ *     - dataType: string
+ *     - isPrimaryKey: boolean
+ *     - isForeignKey: boolean
+ *     - foreignKeyRef: { table: string, column: string } | null
+ *     - isUnique: boolean
  * }
  */
-router.get('/tables/:tableName', async (req, res) => {
+router.get('/tables/:tableName', requireConnection, async (req, res) => {
   try {
     const tableName = sanitizeTableName(req.params.tableName);
     const page = parseInt(req.query.page || '1', 10);
     const limit = parseInt(req.query.limit || '100', 10);
     const cursor = req.query.cursor;
+    const sortColumn = req.query.sortColumn ? req.query.sortColumn : null;
+    const sortDirection = req.query.sortDirection === 'desc' ? 'DESC' : 'ASC';
 
     if (page < 1 || limit < 1) {
       return res.status(400).json({ error: 'Page and limit must be positive integers' });
     }
 
-    const pool = getPool();
+    const pool = req.pool;
     const primaryKeyColumn = await getPrimaryKeyColumn(pool, tableName);
+    const columnMetadata = await getColumnMetadata(pool, tableName);
+
+    // Validate sortColumn if provided
+    if (sortColumn && !columnMetadata[sortColumn]) {
+      return res.status(400).json({ error: 'Invalid sort column' });
+    }
 
     const countQuery = `SELECT COUNT(*) as total FROM "${tableName}"`;
     const countResult = await pool.query(countQuery);
@@ -135,7 +399,22 @@ router.get('/tables/:tableName', async (req, res) => {
     let dataResult;
     let nextCursor = null;
 
-    if (primaryKeyColumn && cursor) {
+    if (sortColumn) {
+      // Custom Sorting: Use OFFSET-based pagination
+      // Always add primary key (if exists) as secondary sort for stability
+      const offset = (page - 1) * limit;
+      let orderByClause = `ORDER BY "${sortColumn}" ${sortDirection}`;
+
+      if (primaryKeyColumn && sortColumn !== primaryKeyColumn) {
+        orderByClause += `, "${primaryKeyColumn}" ASC`;
+      }
+
+      const query = `SELECT * FROM "${tableName}" ${orderByClause} LIMIT $1 OFFSET $2`;
+      dataResult = await pool.query(query, [limit, offset]);
+
+      // Cursor not valid for custom sorts in this simple implementation
+      nextCursor = null;
+    } else if (primaryKeyColumn && cursor) {
       // Cursor-based pagination: WHERE id > cursor (most efficient for forward navigation)
       const cursorQuery = `SELECT * FROM "${tableName}" WHERE "${primaryKeyColumn}" > $1 ORDER BY "${primaryKeyColumn}" ASC LIMIT $2`;
       const cursorParams = [cursor, limit];
@@ -173,7 +452,7 @@ router.get('/tables/:tableName', async (req, res) => {
       }
       dataResult = await pool.query(query, queryParams);
 
-      // Calculate cursor for next page if primary key exists
+      // Calculate cursor for next page if primary key exists (only if default sort)
       if (primaryKeyColumn && dataResult.rows.length > 0) {
         const lastRow = dataResult.rows[dataResult.rows.length - 1];
         nextCursor = lastRow[primaryKeyColumn];
@@ -188,6 +467,7 @@ router.get('/tables/:tableName', async (req, res) => {
       isApproximate,
       nextCursor,
       hasPrimaryKey: !!primaryKeyColumn,
+      columns: columnMetadata,
     };
     res.json(responseData);
   } catch (error) {
@@ -197,4 +477,3 @@ router.get('/tables/:tableName', async (req, res) => {
 });
 
 module.exports = router;
-