pglens 1.1.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pglens",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "description": "A simple PostgreSQL database viewer tool",
   "main": "src/server.js",
   "bin": {
@@ -31,4 +31,4 @@
     "express": "^4.18.2",
     "postgres": "^3.4.3"
   }
-}
+}

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 
@@ -202,7 +311,7 @@ async function getColumnMetadata(pool, tableName) {
       SELECT column_name, data_type
       FROM information_schema.columns
       WHERE table_schema = 'public'
-        AND table_name = $1
+      AND table_name = $1
       ORDER BY ordinal_position;
     `;
     const result = await pool.query(metadataQuery, [tableName]);
@@ -260,21 +369,28 @@ async function getColumnMetadata(pool, tableName) {
  *     - 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);
     const totalCount = parseInt(countResult.rows[0].total, 10);
@@ -283,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];
@@ -321,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];
@@ -346,4 +477,3 @@ router.get('/tables/:tableName', async (req, res) => {
 });
 
 module.exports = router;
-

package/src/server.js

@@ -19,43 +19,85 @@ const apiRoutes = require('./routes/api');
 
 /**
  * Start the Express server.
- * @param {string} connectionString - PostgreSQL connection string
- * @param {number} port - Port number to listen on
- * @param {string} sslMode - SSL mode for database connection
  */
-function startServer(connectionString, port, sslMode) {
+const fs = require('fs');
+const os = require('os');
+const net = require('net');
+
+const PORT_FILE = path.join(os.homedir(), '.pglens.port');
+
+/**
+ * Check if a port is in use.
+ * @param {number} port 
+ * @returns {Promise<boolean>}
+ */
+function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+    server.once('listening', () => {
+      server.close();
+      resolve(false);
+    });
+    server.listen(port);
+  });
+}
+
+/**
+ * Start the Express server.
+ */
+async function startServer() {
   const app = express();
+  let port = 54321;
+
+  // Try to find an available port starting from 54321
+  if (await isPortInUse(port)) {
+    port = 0; // Let OS choose a random available port
+  }
 
   app.use(cors());
   app.use(express.json());
 
-  createPool(connectionString, sslMode)
-    .then(() => {
-      app.use('/api', apiRoutes);
-
-      const clientPath = path.join(__dirname, '../client');
-      app.use(express.static(clientPath));
-
-      app.get('*', (_, res) => {
-        res.sendFile(path.join(clientPath, 'index.html'));
-      });
-
-      app.listen(port, () => {
-        console.log(`✓ Server running on http://localhost:${port}`);
-        console.log(`  Open your browser to view your database`);
-      });
-
-      process.on('SIGINT', () => {
-        console.log('\nShutting down...');
-        closePool().then(() => {
-          process.exit(0);
-        });
-      });
-    })
-    .catch((error) => {
-      console.error('Failed to start server:', error.message);
-      process.exit(1);
+  app.use('/api', apiRoutes);
+
+  const clientPath = path.join(__dirname, '../client');
+  app.use(express.static(clientPath));
+
+  app.get('*', (_, res) => {
+    res.sendFile(path.join(clientPath, 'index.html'));
+  });
+
+  const server = app.listen(port, () => {
+    const actualPort = server.address().port;
+    console.log(`✓ Server running on http://localhost:${actualPort}`);
+    console.log(`  Open your browser to view your database`);
+
+    // Write port to file for CLI to read
+    fs.writeFileSync(PORT_FILE, actualPort.toString());
+  });
+
+  const shutdown = () => {
+    console.log('\nShutting down...');
+    if (fs.existsSync(PORT_FILE)) {
+      try {
+        fs.unlinkSync(PORT_FILE);
+      } catch (e) {
+        // Ignore removal errors
+      }
+    }
+    closePool().then(() => {
+      process.exit(0);
     });
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
 }
 
 module.exports = { startServer };