@hesed/psql 0.2.1 → 0.3.0

package/dist/psql/postgres-utils.js

@@ -1,44 +1,25 @@
-import { encode } from '@toon-format/toon';
 import pg from 'pg';
 import { getPgConnectionOptions } from './config-loader.js';
+import { FORMATTERS } from './formatters.js';
 import { analyzeQuery, applyDefaultLimit, checkBlacklist, getQueryType, requiresConfirmation } from './query-validator.js';
-/**
- * PostgreSQL Database Utility
- * Provides core database operations with safety validation and formatting
- */
 export class PostgreSQLUtil {
     config;
-    connectionPool;
+    connections;
     constructor(config) {
         this.config = config;
-        this.connectionPool = new Map();
+        this.connections = new Map();
     }
-    /**
-     * Close all connections
-     */
     async closeAll() {
-        await Promise.all([...this.connectionPool.values()].map((c) => c.end()));
-        this.connectionPool.clear();
+        const entries = [...this.connections.values()];
+        this.connections.clear();
+        await Promise.allSettled(entries.map(async (clientPromise) => (await clientPromise).end()));
     }
-    /**
-     * Describe table structure
-     */
     async describeTable(profileName, table, format = 'table') {
         try {
             const client = await this.getConnection(profileName);
             const result = await client.query(`SELECT column_name, data_type, character_maximum_length, is_nullable, column_default FROM information_schema.columns WHERE table_name = '${table}' AND table_schema = 'public' ORDER BY ordinal_position`);
-            let output = '';
-            if (format === 'json') {
-                output += this.formatAsJson(result.rows);
-            }
-            else if (format === 'toon') {
-                output += this.formatAsToon(result.rows);
-            }
-            else {
-                output += this.formatAsTable(result.rows, result.fields);
-            }
             return {
-                result: output,
+                result: this.formatRows(result.rows, result.fields, format),
                 structure: result.rows,
                 success: true,
             };
@@ -51,9 +32,6 @@ export class PostgreSQLUtil {
             };
         }
     }
-    /**
-     * Validate and execute a SQL query
-     */
     async executeQuery(profileName, query, format = 'table', skipConfirmation = false) {
         const blacklistCheck = checkBlacklist(query, this.config.safety.blacklistedOperations);
         if (!blacklistCheck.allowed) {
@@ -113,26 +91,13 @@ export class PostgreSQLUtil {
             };
         }
     }
-    /**
-     * Explain query execution plan
-     */
     async explainQuery(profileName, query, format = 'table') {
         try {
             const client = await this.getConnection(profileName);
             const result = await client.query(`EXPLAIN ${query}`);
-            let output = '';
-            if (format === 'json') {
-                output += this.formatAsJson(result.rows);
-            }
-            else if (format === 'toon') {
-                output += this.formatAsToon(result.rows);
-            }
-            else {
-                output += this.formatAsTable(result.rows, result.fields);
-            }
             return {
                 plan: result.rows,
-                result: output,
+                result: this.formatRows(result.rows, result.fields, format),
                 success: true,
             };
         }
@@ -144,90 +109,6 @@ export class PostgreSQLUtil {
             };
         }
     }
-    /**
-     * Format query results as CSV
-     */
-    formatAsCsv(rows, fields) {
-        if (!rows || rows.length === 0) {
-            return '';
-        }
-        const columnNames = fields.map((f) => f.name);
-        let csv = columnNames.join(',') + '\n';
-        for (const row of rows) {
-            const values = columnNames.map((name) => {
-                const value = row[name] ?? '';
-                const str = String(value);
-                if (str.includes(',') || str.includes('"') || str.includes('\n')) {
-                    return '"' + str.replaceAll('"', '""') + '"';
-                }
-                return str;
-            });
-            csv += values.join(',') + '\n';
-        }
-        return csv;
-    }
-    /**
-     * Format query results as JSON
-     */
-    formatAsJson(rows) {
-        return JSON.stringify(rows, null, 2);
-    }
-    /**
-     * Format query results as table
-     */
-    formatAsTable(rows, fields) {
-        if (!rows || rows.length === 0) {
-            return 'No results';
-        }
-        const columnNames = fields.map((f) => f.name);
-        const columnWidths = columnNames.map((name) => {
-            const dataWidth = Math.max(...rows.map((row) => String(row[name] ?? '').length));
-            return Math.max(name.length, dataWidth, 3);
-        });
-        let table = '┌' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┬') + '┐\n';
-        table += '│ ' + columnNames.map((name, i) => name.padEnd(columnWidths[i])).join(' │ ') + ' │\n';
-        table += '├' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┼') + '┤\n';
-        for (const row of rows) {
-            table +=
-                '│ ' +
-                    columnNames
-                        .map((name, i) => {
-                        const value = row[name] ?? 'NULL';
-                        return String(value).padEnd(columnWidths[i]);
-                    })
-                        .join(' │ ') +
-                    ' │\n';
-        }
-        table += '└' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┴') + '┘';
-        return table;
-    }
-    /**
-     * Format query results as TOON
-     */
-    formatAsToon(rows) {
-        if (!rows || rows.length === 0) {
-            return '';
-        }
-        const serializedRows = rows.map((row) => {
-            const serialized = {};
-            for (const [key, value] of Object.entries(row)) {
-                if (value instanceof Date) {
-                    serialized[key] = Number.isNaN(value.getTime()) ? null : value.toISOString();
-                }
-                else if (Buffer.isBuffer(value)) {
-                    serialized[key] = value.toString('base64');
-                }
-                else {
-                    serialized[key] = value;
-                }
-            }
-            return serialized;
-        });
-        return encode(serializedRows);
-    }
-    /**
-     * List all databases
-     */
     async listDatabases(profileName) {
         try {
             const client = await this.getConnection(profileName);
@@ -247,9 +128,6 @@ export class PostgreSQLUtil {
             };
         }
     }
-    /**
-     * List all tables in current database
-     */
     async listTables(profileName) {
         try {
             const client = await this.getConnection(profileName);
@@ -269,26 +147,13 @@ export class PostgreSQLUtil {
             };
         }
     }
-    /**
-     * Show table indexes
-     */
     async showIndexes(profileName, table, format = 'table') {
         try {
             const client = await this.getConnection(profileName);
             const result = await client.query(`SELECT indexname, indexdef FROM pg_indexes WHERE tablename = '${table}' AND schemaname = 'public'`);
-            let output = '';
-            if (format === 'json') {
-                output += this.formatAsJson(result.rows);
-            }
-            else if (format === 'toon') {
-                output += this.formatAsToon(result.rows);
-            }
-            else {
-                output += this.formatAsTable(result.rows, result.fields);
-            }
             return {
                 indexes: result.rows,
-                result: output,
+                result: this.formatRows(result.rows, result.fields, format),
                 success: true,
             };
         }
@@ -300,9 +165,6 @@ export class PostgreSQLUtil {
             };
         }
     }
-    /**
-     * Test database connection
-     */
     async testConnection(profileName) {
         try {
             const client = await this.getConnection(profileName);
@@ -323,42 +185,37 @@ export class PostgreSQLUtil {
             };
         }
     }
-    /**
-     * Format rows for SELECT/EXPLAIN query result
-     */
+    formatRows(rows, fields, format) {
+        return FORMATTERS[format](rows, fields);
+    }
     formatSelectResult(rows, fields, format) {
         const rowCount = Array.isArray(rows) ? rows.length : 0;
-        let result = `Query executed successfully. Rows returned: ${rowCount}\n\n`;
-        switch (format) {
-            case 'csv': {
-                result += this.formatAsCsv(rows, fields);
-                break;
-            }
-            case 'json': {
-                result += this.formatAsJson(rows);
-                break;
-            }
-            case 'toon': {
-                result += this.formatAsToon(rows);
-                break;
-            }
-            default: {
-                result += this.formatAsTable(rows, fields);
-            }
-        }
-        return result;
+        return `Query executed successfully. Rows returned: ${rowCount}\n\n` + this.formatRows(rows, fields, format);
     }
-    /**
-     * Get or create PostgreSQL client for a profile
-     */
     async getConnection(profileName) {
-        if (this.connectionPool.has(profileName)) {
-            return this.connectionPool.get(profileName);
+        const existing = this.connections.get(profileName);
+        if (existing) {
+            try {
+                const client = await existing;
+                await client.query('SELECT 1');
+                return client;
+            }
+            catch {
+                this.connections.delete(profileName);
+            }
+        }
+        const clientPromise = (async () => {
+            const client = new pg.Client(getPgConnectionOptions(this.config, profileName));
+            await client.connect();
+            return client;
+        })();
+        this.connections.set(profileName, clientPromise);
+        try {
+            return await clientPromise;
+        }
+        catch (error) {
+            this.connections.delete(profileName);
+            throw error;
         }
-        const options = getPgConnectionOptions(this.config, profileName);
-        const client = new pg.Client(options);
-        await client.connect();
-        this.connectionPool.set(profileName, client);
-        return client;
     }
 }

package/dist/psql/query-validator.d.ts

@@ -1,7 +1,3 @@
-/**
- * Query Validation and Safety Module
- * Provides SQL query analysis and safety checks
- */
 interface BlacklistCheckResult {
     allowed: boolean;
     reason?: string;
@@ -15,24 +11,9 @@ interface QueryWarning {
     message: string;
     suggestion: string;
 }
-/**
- * Check if query contains blacklisted operations
- */
 export declare function checkBlacklist(query: string, blacklistedOperations: string[]): BlacklistCheckResult;
-/**
- * Check if query requires user confirmation
- */
 export declare function requiresConfirmation(query: string, confirmationOperations: string[]): ConfirmationCheckResult;
-/**
- * Get query type (SELECT, INSERT, UPDATE, etc.)
- */
 export declare function getQueryType(query: string): string;
-/**
- * Analyze query for potential issues and provide warnings
- */
 export declare function analyzeQuery(query: string): QueryWarning[];
-/**
- * Apply default LIMIT to SELECT queries if not present
- */
 export declare function applyDefaultLimit(query: string, defaultLimit: number): string;
 export {};

package/dist/psql/query-validator.js

@@ -1,10 +1,3 @@
-/**
- * Query Validation and Safety Module
- * Provides SQL query analysis and safety checks
- */
-/**
- * Check if query contains blacklisted operations
- */
 export function checkBlacklist(query, blacklistedOperations) {
     const normalizedQuery = query.trim().toUpperCase();
     for (const operation of blacklistedOperations) {
@@ -18,9 +11,6 @@ export function checkBlacklist(query, blacklistedOperations) {
     }
     return { allowed: true };
 }
-/**
- * Check if query requires user confirmation
- */
 export function requiresConfirmation(query, confirmationOperations) {
     const normalizedQuery = query.trim().toUpperCase();
     for (const operation of confirmationOperations) {
@@ -34,21 +24,27 @@ export function requiresConfirmation(query, confirmationOperations) {
     }
     return { required: false };
 }
-/**
- * Get query type (SELECT, INSERT, UPDATE, etc.)
- */
 export function getQueryType(query) {
     const normalizedQuery = query.trim().toUpperCase();
     const firstWord = normalizedQuery.split(/\s+/)[0];
-    const knownTypes = ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'DROP', 'CREATE', 'ALTER', 'TRUNCATE', 'EXPLAIN'];
+    const knownTypes = [
+        'SELECT',
+        'INSERT',
+        'UPDATE',
+        'DELETE',
+        'DROP',
+        'CREATE',
+        'ALTER',
+        'TRUNCATE',
+        'SHOW',
+        'DESCRIBE',
+        'EXPLAIN',
+    ];
     if (knownTypes.includes(firstWord)) {
         return firstWord;
     }
     return 'UNKNOWN';
 }
-/**
- * Analyze query for potential issues and provide warnings
- */
 export function analyzeQuery(query) {
     const warnings = [];
     const normalizedQuery = query.trim().toUpperCase();
@@ -79,9 +75,6 @@ export function analyzeQuery(query) {
     }
     return warnings;
 }
-/**
- * Apply default LIMIT to SELECT queries if not present
- */
 export function applyDefaultLimit(query, defaultLimit) {
     const normalizedQuery = query.trim().toUpperCase();
     if (normalizedQuery.startsWith('SELECT') && !normalizedQuery.includes('LIMIT')) {