@libredb/studio 0.9.7 → 0.9.12

package/{src/lib/db/providers/sql/postgres.ts → dist/postgres-O5KOQUVP.mjs}

@@ -1,214 +1,132 @@
-/**
- * PostgreSQL Database Provider
- * Full PostgreSQL support with connection pooling
- */
-
-import { Pool, type PoolClient, type PoolConfig as PgPoolConfig } from 'pg';
-import { SQLBaseProvider } from './sql-base';
-import {
-  type DatabaseConnection,
-  type TableSchema,
-  type QueryResult,
-  type HealthInfo,
-  type MaintenanceType,
-  type MaintenanceResult,
-  type ProviderOptions,
-  type ProviderCapabilities,
-  type SlowQuery,
-  type ActiveSession,
-  type DatabaseOverview,
-  type PerformanceMetrics,
-  type SlowQueryStats,
-  type ActiveSessionDetails,
-  type TableStats,
-  type IndexStats,
-  type StorageStats,
-} from '../../types';
-import {
-  DatabaseConfigError,
-  ConnectionError,
-  QueryError,
-  mapDatabaseError,
-} from '../../errors';
-import { formatBytes } from '../../utils/pool-manager';
-
-// ============================================================================
-// Type Definitions
-// ============================================================================
-
-interface PgStatActivityRow {
-  datname?: string;
-  pid?: number;
-  usename?: string;
-  application_name?: string;
-  client_addr?: string;
-  backend_start?: string | Date;
-  state?: string;
-  query?: string;
-  [key: string]: unknown;
-}
-
-// ============================================================================
-// PostgreSQL Provider
-// ============================================================================
-
-export class PostgresProvider extends SQLBaseProvider {
-  private pool: Pool | null = null;
-
-  // Transaction support: dedicated client held outside pool
-  private txClient: PoolClient | null = null;
-  private txActive = false;
-  private txTimeout: ReturnType<typeof setTimeout> | null = null;
-  private static readonly TX_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
-
-  constructor(config: DatabaseConnection, options: ProviderOptions = {}) {
+import { SQLBaseProvider } from './chunk-R3POCJK6.mjs';
+import { formatBytes } from './chunk-QJP5FZRY.mjs';
+import { DatabaseConfigError, ConnectionError, mapDatabaseError, QueryError } from './chunk-CZVV3JJB.mjs';
+import { __spreadProps, __spreadValues } from './chunk-4LVB3K53.mjs';
+import { Pool } from 'pg';
+
+var _PostgresProvider = class _PostgresProvider extends SQLBaseProvider {
+  // 5 minutes
+  constructor(config, options = {}) {
     super(config, options);
+    this.pool = null;
+    // Transaction support: dedicated client held outside pool
+    this.txClient = null;
+    this.txActive = false;
+    this.txTimeout = null;
+    // ============================================================================
+    // Query Execution
+    // ============================================================================
+    // Track running query PIDs for cancellation
+    this.runningQueryPids = /* @__PURE__ */ new Map();
     this.validate();
   }
-
   // ============================================================================
   // Provider Metadata
   // ============================================================================
-
-  public override getCapabilities(): ProviderCapabilities {
-    return {
-      ...super.getCapabilities(),
+  getCapabilities() {
+    return __spreadProps(__spreadValues({}, super.getCapabilities()), {
       defaultPort: 5432,
       supportsExplain: true,
       supportsConnectionString: true,
-      maintenanceOperations: ['vacuum', 'analyze', 'reindex', 'kill'],
-    };
+      maintenanceOperations: ["vacuum", "analyze", "reindex", "kill"]
+    });
   }
-
   // ============================================================================
   // Validation
   // ============================================================================
-
-  public validate(): void {
+  validate() {
     super.validate();
-
     if (!this.config.connectionString) {
       if (!this.config.host) {
-        throw new DatabaseConfigError('Host is required for PostgreSQL', 'postgres');
+        throw new DatabaseConfigError("Host is required for PostgreSQL", "postgres");
       }
       if (!this.config.database) {
-        throw new DatabaseConfigError('Database name is required for PostgreSQL', 'postgres');
+        throw new DatabaseConfigError("Database name is required for PostgreSQL", "postgres");
       }
     }
   }
-
   // ============================================================================
   // Connection Management
   // ============================================================================
-
-  public async connect(): Promise<void> {
+  async connect() {
     if (this.pool) {
       return;
     }
-
     try {
       const poolConfig = this.buildPoolConfig();
       this.pool = new Pool(poolConfig);
-
       const client = await this.pool.connect();
       client.release();
-
       this.setConnected(true);
     } catch (error) {
       this.setError(error instanceof Error ? error : new Error(String(error)));
       throw new ConnectionError(
         `Failed to connect to PostgreSQL: ${error instanceof Error ? error.message : error}`,
-        'postgres',
+        "postgres",
         this.config.host,
         this.config.port
       );
     }
   }
-
-  public async disconnect(): Promise<void> {
+  async disconnect() {
     if (this.pool) {
       await this.pool.end();
       this.pool = null;
       this.setConnected(false);
     }
   }
-
-  private buildPoolConfig(): PgPoolConfig {
+  buildPoolConfig() {
+    var _a;
     const sslConfig = this.buildSSLConfig();
-
-    const baseConfig: PgPoolConfig = {
+    const baseConfig = {
       min: this.poolConfig.min,
       max: this.poolConfig.max,
       idleTimeoutMillis: this.poolConfig.idleTimeout,
       connectionTimeoutMillis: this.poolConfig.acquireTimeout,
       statement_timeout: this.queryTimeout,
-      ssl: sslConfig,
+      ssl: sslConfig
     };
-
     if (this.config.connectionString) {
-      return {
-        ...baseConfig,
-        connectionString: this.config.connectionString,
-      };
+      return __spreadProps(__spreadValues({}, baseConfig), {
+        connectionString: this.config.connectionString
+      });
     }
-
-    return {
-      ...baseConfig,
+    return __spreadProps(__spreadValues({}, baseConfig), {
       host: this.config.host,
-      port: this.config.port ?? 5432,
+      port: (_a = this.config.port) != null ? _a : 5432,
       user: this.config.user,
       password: this.config.password,
-      database: this.config.database,
-    };
+      database: this.config.database
+    });
   }
-
-  private buildSSLConfig(): PgPoolConfig['ssl'] {
+  buildSSLConfig() {
     const connSSL = this.config.ssl;
-
-    // Explicit SSL config from connection takes priority
     if (connSSL) {
-      if (connSSL.mode === 'disable') return false;
-
-      const ssl: Record<string, unknown> = {
-        rejectUnauthorized: connSSL.mode === 'verify-ca' || connSSL.mode === 'verify-full',
+      if (connSSL.mode === "disable") return false;
+      const ssl = {
+        rejectUnauthorized: connSSL.mode === "verify-ca" || connSSL.mode === "verify-full"
       };
-
       if (connSSL.caCert) ssl.ca = connSSL.caCert;
       if (connSSL.clientCert) ssl.cert = connSSL.clientCert;
       if (connSSL.clientKey) ssl.key = connSSL.clientKey;
-
-      return ssl as PgPoolConfig['ssl'];
+      return ssl;
     }
-
-    // Auto-detect for cloud providers
     if (this.shouldEnableSSL()) {
       return { rejectUnauthorized: false };
     }
-
-    // Provider options fallback
     if (this.options.ssl === false) return false;
-
-    return undefined;
+    return void 0;
   }
-
-  // ============================================================================
-  // Query Execution
-  // ============================================================================
-
-  // Track running query PIDs for cancellation
-  private runningQueryPids = new Map<string, number>();
-
-  public async query(sql: string, params?: unknown[], queryId?: string): Promise<QueryResult> {
+  async query(sql, params, queryId) {
     this.ensureConnected();
-
     return this.trackQuery(async () => {
+      var _a, _b, _c;
       const { result, executionTime } = await this.measureExecution(async () => {
         try {
-          const client = await this.pool!.connect();
+          const client = await this.pool.connect();
           try {
-            // Track PID for cancellation support
             if (queryId) {
-              const pidRes = await client.query('SELECT pg_backend_pid() as pid');
+              const pidRes = await client.query("SELECT pg_backend_pid() as pid");
               this.runningQueryPids.set(queryId, pidRes.rows[0].pid);
             }
             const res = await client.query(sql, params);
@@ -219,58 +137,54 @@ export class PostgresProvider extends SQLBaseProvider {
           }
         } catch (error) {
           if (queryId) this.runningQueryPids.delete(queryId);
-          throw mapDatabaseError(error, 'postgres', sql);
+          throw mapDatabaseError(error, "postgres", sql);
         }
       });
-
       return {
         rows: result.rows,
-        fields: result.fields?.map((f) => f.name) ?? [],
-        rowCount: result.rowCount ?? 0,
-        executionTime,
+        fields: (_b = (_a = result.fields) == null ? void 0 : _a.map((f) => f.name)) != null ? _b : [],
+        rowCount: (_c = result.rowCount) != null ? _c : 0,
+        executionTime
       };
     });
   }
-
-  public async cancelQuery(queryId: string): Promise<boolean> {
+  async cancelQuery(queryId) {
+    var _a;
     const pid = this.runningQueryPids.get(queryId);
     if (!pid) return false;
-
     try {
-      const client = await this.pool!.connect();
+      const client = await this.pool.connect();
       try {
-        const res = await client.query('SELECT pg_cancel_backend($1) as cancelled', [pid]);
-        return res.rows[0]?.cancelled === true;
+        const res = await client.query("SELECT pg_cancel_backend($1) as cancelled", [pid]);
+        return ((_a = res.rows[0]) == null ? void 0 : _a.cancelled) === true;
       } finally {
         client.release();
       }
     } catch (error) {
-      console.error('[Postgres] Failed to cancel query:', error);
+      console.error("[Postgres] Failed to cancel query:", error);
       return false;
     }
   }
-
   // ============================================================================
   // Transaction Support
   // ============================================================================
-
-  private clearTxTimeout(): void {
+  clearTxTimeout() {
     if (this.txTimeout) {
       clearTimeout(this.txTimeout);
       this.txTimeout = null;
     }
   }
-
   /**
    * Force-expire an active transaction (auto-rollback).
    * Called by the timeout timer, but also available for testing.
    */
-  public async expireTransaction(): Promise<void> {
+  async expireTransaction() {
     if (this.txActive && this.txClient) {
-      console.warn('[Postgres] Transaction timed out, auto-rolling back');
+      console.warn("[Postgres] Transaction timed out, auto-rolling back");
       try {
-        await this.txClient.query('ROLLBACK');
-      } catch { /* ignore */ } finally {
+        await this.txClient.query("ROLLBACK");
+      } catch (e) {
+      } finally {
         this.txClient.release();
         this.txClient = null;
         this.txActive = false;
@@ -278,78 +192,67 @@ export class PostgresProvider extends SQLBaseProvider {
       }
     }
   }
-
-  public async beginTransaction(): Promise<void> {
+  async beginTransaction() {
     this.ensureConnected();
-    if (this.txActive) throw new QueryError('Transaction already active', 'postgres');
-    this.txClient = await this.pool!.connect();
-    await this.txClient.query('BEGIN');
+    if (this.txActive) throw new QueryError("Transaction already active", "postgres");
+    this.txClient = await this.pool.connect();
+    await this.txClient.query("BEGIN");
     this.txActive = true;
-
-    // Auto-rollback after timeout to prevent leaked locks
-    this.txTimeout = setTimeout(() => { this.expireTransaction(); }, PostgresProvider.TX_TIMEOUT_MS);
+    this.txTimeout = setTimeout(() => {
+      this.expireTransaction();
+    }, _PostgresProvider.TX_TIMEOUT_MS);
   }
-
-  public async commitTransaction(): Promise<void> {
-    if (!this.txClient || !this.txActive) throw new QueryError('No active transaction', 'postgres');
+  async commitTransaction() {
+    if (!this.txClient || !this.txActive) throw new QueryError("No active transaction", "postgres");
     this.clearTxTimeout();
     try {
-      await this.txClient.query('COMMIT');
+      await this.txClient.query("COMMIT");
     } finally {
       this.txClient.release();
       this.txClient = null;
       this.txActive = false;
     }
   }
-
-  public async rollbackTransaction(): Promise<void> {
-    if (!this.txClient || !this.txActive) throw new QueryError('No active transaction', 'postgres');
+  async rollbackTransaction() {
+    if (!this.txClient || !this.txActive) throw new QueryError("No active transaction", "postgres");
     this.clearTxTimeout();
     try {
-      await this.txClient.query('ROLLBACK');
+      await this.txClient.query("ROLLBACK");
     } finally {
       this.txClient.release();
       this.txClient = null;
       this.txActive = false;
     }
   }
-
-  public isInTransaction(): boolean {
+  isInTransaction() {
     return this.txActive;
   }
-
-  public async queryInTransaction(sql: string, params?: unknown[]): Promise<QueryResult> {
-    if (!this.txClient || !this.txActive) throw new QueryError('No active transaction', 'postgres');
-
+  async queryInTransaction(sql, params) {
+    if (!this.txClient || !this.txActive) throw new QueryError("No active transaction", "postgres");
     return this.trackQuery(async () => {
+      var _a, _b, _c;
       const { result, executionTime } = await this.measureExecution(async () => {
         try {
-          return await this.txClient!.query(sql, params);
+          return await this.txClient.query(sql, params);
         } catch (error) {
-          throw mapDatabaseError(error, 'postgres', sql);
+          throw mapDatabaseError(error, "postgres", sql);
         }
       });
-
       return {
         rows: result.rows,
-        fields: result.fields?.map((f) => f.name) ?? [],
-        rowCount: result.rowCount ?? 0,
-        executionTime,
+        fields: (_b = (_a = result.fields) == null ? void 0 : _a.map((f) => f.name)) != null ? _b : [],
+        rowCount: (_c = result.rowCount) != null ? _c : 0,
+        executionTime
       };
     });
   }
-
   // ============================================================================
   // Schema Operations
   // ============================================================================
-
-  public async getSchema(): Promise<TableSchema[]> {
+  async getSchema() {
     this.ensureConnected();
-
-    const client = await this.pool!.connect();
+    const client = await this.pool.connect();
     try {
-      // Optimized single query to fetch all schema information
-      // This replaces the N+1 pattern (1 + N*4 queries) with a single query
       const result = await client.query(`
         WITH tables_info AS (
           SELECT
@@ -450,94 +353,57 @@ export class PostgresProvider extends SQLBaseProvider {
         LEFT JOIN index_info ii ON ii.table_schema = ti.table_schema AND ii.table_name = ti.table_name
         ORDER BY ti.table_schema, ti.table_name ASC;
       `);
-
-      interface SchemaRow {
-        table_schema: string;
-        table_name: string;
-        row_count: string;
-        total_size: string;
-        pk_columns: string[];
-        columns?: Array<{
-          name: string;
-          type: string;
-          nullable: boolean;
-          defaultValue?: string | null;
-        }>;
-        indexes?: Array<{
-          name: string;
-          columns: string[];
-          unique: boolean;
-        }>;
-        foreign_keys?: Array<{
-          columnName: string;
-          referencedSchema: string;
-          referencedTable: string;
-          referencedColumn: string;
-        }>;
-      }
-
-      return result.rows.map((row: SchemaRow) => {
+      return result.rows.map((row) => {
         const schemaName = row.table_schema;
         const tableName = row.table_name;
-        const displayName = schemaName === 'public' ? tableName : `${schemaName}.${tableName}`;
-        const rowCount = Math.max(0, parseInt(row.row_count || '0'));
-        const sizeBytes = parseInt(row.total_size || '0');
-        const pkColumns: string[] = row.pk_columns || [];
-
-        // Parse columns and add isPrimary flag
-        const columns = (row.columns || []).map((col) => ({
-          name: col.name,
-          type: col.type,
-          nullable: col.nullable,
-          isPrimary: pkColumns.includes(col.name),
-          defaultValue: col.defaultValue ?? undefined,
-        }));
-
-        // Parse indexes
+        const displayName = schemaName === "public" ? tableName : `${schemaName}.${tableName}`;
+        const rowCount = Math.max(0, parseInt(row.row_count || "0"));
+        const sizeBytes = parseInt(row.total_size || "0");
+        const pkColumns = row.pk_columns || [];
+        const columns = (row.columns || []).map((col) => {
+          var _a;
+          return {
+            name: col.name,
+            type: col.type,
+            nullable: col.nullable,
+            isPrimary: pkColumns.includes(col.name),
+            defaultValue: (_a = col.defaultValue) != null ? _a : void 0
+          };
+        });
         const indexes = (row.indexes || []).map((idx) => ({
           name: idx.name,
           columns: Array.isArray(idx.columns) ? idx.columns : [],
-          unique: idx.unique,
+          unique: idx.unique
         }));
-
-        // Parse foreign keys
         const foreignKeys = (row.foreign_keys || []).map((fk) => ({
           columnName: fk.columnName,
-          referencedTable: fk.referencedSchema === 'public'
-            ? fk.referencedTable
-            : `${fk.referencedSchema}.${fk.referencedTable}`,
-          referencedColumn: fk.referencedColumn,
+          referencedTable: fk.referencedSchema === "public" ? fk.referencedTable : `${fk.referencedSchema}.${fk.referencedTable}`,
+          referencedColumn: fk.referencedColumn
         }));
-
         return {
           name: displayName,
           rowCount,
           size: formatBytes(sizeBytes),
           columns,
           indexes,
-          foreignKeys,
+          foreignKeys
         };
       });
     } finally {
       client.release();
     }
   }
-
   // ============================================================================
   // Health & Monitoring
   // ============================================================================
-
-  public async getHealth(): Promise<HealthInfo> {
+  async getHealth() {
     this.ensureConnected();
-
-    const client = await this.pool!.connect();
+    const client = await this.pool.connect();
     try {
-      const connRes = await client.query('SELECT count(*) FROM pg_stat_activity');
-
-      const sizeRes = await client.query('SELECT pg_size_pretty(pg_database_size($1))', [
-        this.config.database,
+      const connRes = await client.query("SELECT count(*) FROM pg_stat_activity");
+      const sizeRes = await client.query("SELECT pg_size_pretty(pg_database_size($1))", [
+        this.config.database
       ]);
-
       const cacheRes = await client.query(`
         SELECT
           sum(heap_blks_read) as heap_read,
@@ -548,8 +414,7 @@ export class PostgresProvider extends SQLBaseProvider {
           ) as ratio
         FROM pg_statio_user_tables;
       `);
-
-      let slowQueries: SlowQuery[] = [];
+      let slowQueries = [];
       try {
         const slowRes = await client.query(`
           SELECT
@@ -564,14 +429,13 @@ export class PostgresProvider extends SQLBaseProvider {
         slowQueries = slowRes.rows.map((r) => ({
           query: r.query,
           calls: r.calls,
-          avgTime: r.avgtime,
+          avgTime: r.avgtime
         }));
-      } catch {
+      } catch (e) {
         slowQueries = [
-          { query: 'pg_stat_statements extension not enabled', calls: 0, avgTime: 'N/A' },
+          { query: "pg_stat_statements extension not enabled", calls: 0, avgTime: "N/A" }
         ];
       }
-
       const sessionsRes = await client.query(`
         SELECT
           pid,
@@ -590,125 +454,100 @@ export class PostgresProvider extends SQLBaseProvider {
         ORDER BY xact_start DESC NULLS LAST
         LIMIT 10;
       `, [this.config.database]);
-
-      const activeSessions: ActiveSession[] = sessionsRes.rows.map((r) => ({
+      const activeSessions = sessionsRes.rows.map((r) => ({
         pid: r.pid,
-        user: r.user || 'unknown',
-        database: r.database || '',
+        user: r.user || "unknown",
+        database: r.database || "",
         state: r.state,
-        query: r.query || '',
-        duration: r.duration,
+        query: r.query || "",
+        duration: r.duration
       }));
-
       return {
         activeConnections: parseInt(connRes.rows[0].count),
         databaseSize: sizeRes.rows[0].pg_size_pretty,
         cacheHitRatio: `${cacheRes.rows[0].ratio}%`,
         slowQueries,
-        activeSessions,
+        activeSessions
       };
     } finally {
       client.release();
     }
   }
-
   // ============================================================================
   // Maintenance Operations
   // ============================================================================
-
-  public async runMaintenance(
-    type: MaintenanceType,
-    target?: string
-  ): Promise<MaintenanceResult> {
+  async runMaintenance(type, target) {
     this.ensureConnected();
-
     const { result, executionTime } = await this.measureExecution(async () => {
-      const client = await this.pool!.connect();
+      const client = await this.pool.connect();
       try {
-        let sql = '';
-
+        let sql = "";
         switch (type) {
-          case 'vacuum':
-            sql = target
-              ? `VACUUM ANALYZE public.${this.escapeIdentifier(target)}`
-              : 'VACUUM ANALYZE';
+          case "vacuum":
+            sql = target ? `VACUUM ANALYZE public.${this.escapeIdentifier(target)}` : "VACUUM ANALYZE";
             break;
-          case 'analyze':
-            sql = target
-              ? `ANALYZE public.${this.escapeIdentifier(target)}`
-              : 'ANALYZE';
+          case "analyze":
+            sql = target ? `ANALYZE public.${this.escapeIdentifier(target)}` : "ANALYZE";
             break;
-          case 'reindex':
-            sql = target
-              ? `REINDEX TABLE public.${this.escapeIdentifier(target)}`
-              : `REINDEX DATABASE ${this.escapeIdentifier(this.config.database || '')}`;
+          case "reindex":
+            sql = target ? `REINDEX TABLE public.${this.escapeIdentifier(target)}` : `REINDEX DATABASE ${this.escapeIdentifier(this.config.database || "")}`;
             break;
-          case 'kill':
+          case "kill":
             if (!target) {
-              throw new QueryError('Target PID is required for kill operation', 'postgres');
+              throw new QueryError("Target PID is required for kill operation", "postgres");
             }
             const pid = parseInt(target, 10);
             if (isNaN(pid)) {
-              throw new QueryError('Invalid PID for kill operation', 'postgres');
+              throw new QueryError("Invalid PID for kill operation", "postgres");
             }
             sql = `SELECT pg_terminate_backend(${pid})`;
             break;
           default:
-            throw new QueryError(`Unsupported maintenance type: ${type}`, 'postgres');
+            throw new QueryError(`Unsupported maintenance type: ${type}`, "postgres");
         }
-
         await client.query(sql);
         return { success: true };
       } finally {
         client.release();
       }
     });
-
     return {
       success: result.success,
       executionTime,
-      message: `${type.toUpperCase()} completed successfully`,
+      message: `${type.toUpperCase()} completed successfully`
     };
   }
-
   // ============================================================================
   // Pool Statistics
   // ============================================================================
-
-  public getPoolStats() {
+  getPoolStats() {
     if (!this.pool) {
       return { total: 0, idle: 0, active: 0, waiting: 0 };
     }
-
     return {
       total: this.pool.totalCount,
       idle: this.pool.idleCount,
       active: this.pool.totalCount - this.pool.idleCount,
-      waiting: this.pool.waitingCount,
+      waiting: this.pool.waitingCount
     };
   }
-
   // ============================================================================
   // Extended Monitoring Methods
   // ============================================================================
-
   /**
    * Get database overview metrics
    */
-  public async getOverview(): Promise<DatabaseOverview> {
+  async getOverview() {
+    var _a;
     this.ensureConnected();
-
-    const client = await this.pool!.connect();
+    const client = await this.pool.connect();
     try {
-      // Get version and uptime
       const infoRes = await client.query(`
         SELECT
           version() as version,
           pg_postmaster_start_time() as start_time,
           EXTRACT(EPOCH FROM (now() - pg_postmaster_start_time()))::bigint as uptime_seconds
       `);
-
-      // Get connection counts
       const connRes = await client.query(`
         SELECT
           count(*) as active_connections,
@@ -716,56 +555,43 @@ export class PostgresProvider extends SQLBaseProvider {
         FROM pg_stat_activity
         WHERE datname = $1
       `, [this.config.database]);
-
-      // Get database size
       const sizeRes = await client.query(`
         SELECT
           pg_size_pretty(pg_database_size($1)) as database_size,
           pg_database_size($1) as database_size_bytes
       `, [this.config.database]);
-
-      // Get table and index counts (all user schemas)
       const countRes = await client.query(`
         SELECT
           (SELECT count(*) FROM pg_tables WHERE schemaname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')) as table_count,
           (SELECT count(*) FROM pg_indexes WHERE schemaname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')) as index_count
       `);
-
-      const uptimeSeconds = parseInt(infoRes.rows[0].uptime_seconds || '0');
+      const uptimeSeconds = parseInt(infoRes.rows[0].uptime_seconds || "0");
       const days = Math.floor(uptimeSeconds / 86400);
-      const hours = Math.floor((uptimeSeconds % 86400) / 3600);
-      const minutes = Math.floor((uptimeSeconds % 3600) / 60);
-      const uptime = days > 0
-        ? `${days}d ${hours}h ${minutes}m`
-        : hours > 0
-          ? `${hours}h ${minutes}m`
-          : `${minutes}m`;
-
+      const hours = Math.floor(uptimeSeconds % 86400 / 3600);
+      const minutes = Math.floor(uptimeSeconds % 3600 / 60);
+      const uptime = days > 0 ? `${days}d ${hours}h ${minutes}m` : hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
       return {
-        version: infoRes.rows[0].version?.split(',')[0] || 'PostgreSQL',
+        version: ((_a = infoRes.rows[0].version) == null ? void 0 : _a.split(",")[0]) || "PostgreSQL",
         uptime,
-        startTime: infoRes.rows[0].start_time ? new Date(infoRes.rows[0].start_time) : undefined,
-        activeConnections: parseInt(connRes.rows[0].active_connections || '0'),
-        maxConnections: parseInt(connRes.rows[0].max_connections || '100'),
-        databaseSize: sizeRes.rows[0].database_size || '0 bytes',
-        databaseSizeBytes: parseInt(sizeRes.rows[0].database_size_bytes || '0'),
-        tableCount: parseInt(countRes.rows[0].table_count || '0'),
-        indexCount: parseInt(countRes.rows[0].index_count || '0'),
+        startTime: infoRes.rows[0].start_time ? new Date(infoRes.rows[0].start_time) : void 0,
+        activeConnections: parseInt(connRes.rows[0].active_connections || "0"),
+        maxConnections: parseInt(connRes.rows[0].max_connections || "100"),
+        databaseSize: sizeRes.rows[0].database_size || "0 bytes",
+        databaseSizeBytes: parseInt(sizeRes.rows[0].database_size_bytes || "0"),
+        tableCount: parseInt(countRes.rows[0].table_count || "0"),
+        indexCount: parseInt(countRes.rows[0].index_count || "0")
       };
     } finally {
       client.release();
     }
   }
-
   /**
    * Get performance metrics
    */
-  public async getPerformanceMetrics(): Promise<PerformanceMetrics> {
+  async getPerformanceMetrics() {
     this.ensureConnected();
-
-    const client = await this.pool!.connect();
+    const client = await this.pool.connect();
     try {
-      // Get cache hit ratio
       const cacheRes = await client.query(`
         SELECT
           COALESCE(
@@ -774,8 +600,6 @@ export class PostgresProvider extends SQLBaseProvider {
           ) as cache_hit_ratio
         FROM pg_statio_user_tables
       `);
-
-      // Get transaction stats
       const txRes = await client.query(`
         SELECT
           xact_commit,
@@ -786,9 +610,7 @@ export class PostgresProvider extends SQLBaseProvider {
         FROM pg_stat_database
         WHERE datname = $1
       `, [this.config.database]);
-
-      // Get checkpoint stats (optional - columns may not exist in older PG versions)
-      let checkpointWriteTime = '0';
+      let checkpointWriteTime = "0";
       try {
         const checkpointRes = await client.query(`
           SELECT
@@ -797,44 +619,39 @@ export class PostgresProvider extends SQLBaseProvider {
           FROM pg_stat_bgwriter
         `);
         const checkpointRow = checkpointRes.rows[0] || {};
-        const writeTime = parseFloat(checkpointRow.checkpoint_write_time || '0');
-        const syncTime = parseFloat(checkpointRow.checkpoint_sync_time || '0');
-        checkpointWriteTime = `${((writeTime + syncTime) / 1000).toFixed(1)}s`;
-      } catch {
-        // checkpoint_write_time doesn't exist in older PostgreSQL versions
-        checkpointWriteTime = 'N/A';
+        const writeTime = parseFloat(checkpointRow.checkpoint_write_time || "0");
+        const syncTime = parseFloat(checkpointRow.checkpoint_sync_time || "0");
+        checkpointWriteTime = `${((writeTime + syncTime) / 1e3).toFixed(1)}s`;
+      } catch (e) {
+        checkpointWriteTime = "N/A";
       }
-
       const txRow = txRes.rows[0] || {};
-      const blksHit = parseInt(txRow.blks_hit || '0');
-      const blksRead = parseInt(txRow.blks_read || '0');
-      const bufferPoolUsage = blksHit + blksRead > 0
-        ? Math.round((blksHit / (blksHit + blksRead)) * 100)
-        : 100;
-
+      const blksHit = parseInt(txRow.blks_hit || "0");
+      const blksRead = parseInt(txRow.blks_read || "0");
+      const bufferPoolUsage = blksHit + blksRead > 0 ? Math.round(blksHit / (blksHit + blksRead) * 100) : 100;
       return {
-        cacheHitRatio: parseFloat(cacheRes.rows[0].cache_hit_ratio || '100'),
-        transactionsPerSecond: undefined, // Would need time-based sampling
-        queriesPerSecond: undefined, // Would need time-based sampling
+        cacheHitRatio: parseFloat(cacheRes.rows[0].cache_hit_ratio || "100"),
+        transactionsPerSecond: void 0,
+        // Would need time-based sampling
+        queriesPerSecond: void 0,
+        // Would need time-based sampling
         bufferPoolUsage,
-        deadlocks: parseInt(txRow.deadlocks || '0'),
-        checkpointWriteTime,
+        deadlocks: parseInt(txRow.deadlocks || "0"),
+        checkpointWriteTime
       };
     } finally {
       client.release();
     }
   }
-
   /**
    * Get slow query statistics from pg_stat_statements
    */
-  public async getSlowQueries(options?: { limit?: number }): Promise<SlowQueryStats[]> {
+  async getSlowQueries(options) {
+    var _a;
     this.ensureConnected();
-    const limit = options?.limit ?? 10;
-
-    const client = await this.pool!.connect();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 10;
+    const client = await this.pool.connect();
     try {
-      // Try pg_stat_statements first (requires extension)
       try {
         const res = await client.query(`
           SELECT
@@ -854,22 +671,19 @@ export class PostgresProvider extends SQLBaseProvider {
           ORDER BY total_exec_time DESC
           LIMIT $2
         `, [this.config.database, limit]);
-
         return res.rows.map((r) => ({
           queryId: r.query_id,
-          query: r.query || '',
-          calls: parseInt(r.calls || '0'),
-          totalTime: parseFloat(r.total_time || '0'),
-          avgTime: parseFloat(r.avg_time || '0'),
-          minTime: parseFloat(r.min_time || '0'),
-          maxTime: parseFloat(r.max_time || '0'),
-          rows: parseInt(r.rows || '0'),
-          sharedBlksHit: parseInt(r.shared_blks_hit || '0'),
-          sharedBlksRead: parseInt(r.shared_blks_read || '0'),
+          query: r.query || "",
+          calls: parseInt(r.calls || "0"),
+          totalTime: parseFloat(r.total_time || "0"),
+          avgTime: parseFloat(r.avg_time || "0"),
+          minTime: parseFloat(r.min_time || "0"),
+          maxTime: parseFloat(r.max_time || "0"),
+          rows: parseInt(r.rows || "0"),
+          sharedBlksHit: parseInt(r.shared_blks_hit || "0"),
+          sharedBlksRead: parseInt(r.shared_blks_read || "0")
         }));
-      } catch {
-        // Fallback: use pg_stat_activity for currently running queries
-        // This doesn't provide historical stats, but shows active queries
+      } catch (e) {
         const fallbackRes = await client.query(`
           SELECT
             pid::text as query_id,
@@ -888,33 +702,31 @@ export class PostgresProvider extends SQLBaseProvider {
           ORDER BY query_start ASC NULLS LAST
           LIMIT $2
         `, [this.config.database, limit]);
-
         return fallbackRes.rows.map((r) => ({
           queryId: r.query_id,
-          query: r.query || '',
-          calls: parseInt(r.calls || '1'),
-          totalTime: parseFloat(r.total_time || '0'),
-          avgTime: parseFloat(r.avg_time || '0'),
-          minTime: undefined,
-          maxTime: undefined,
-          rows: parseInt(r.rows || '0'),
-          sharedBlksHit: undefined,
-          sharedBlksRead: undefined,
+          query: r.query || "",
+          calls: parseInt(r.calls || "1"),
+          totalTime: parseFloat(r.total_time || "0"),
+          avgTime: parseFloat(r.avg_time || "0"),
+          minTime: void 0,
+          maxTime: void 0,
+          rows: parseInt(r.rows || "0"),
+          sharedBlksHit: void 0,
+          sharedBlksRead: void 0
         }));
       }
     } finally {
       client.release();
     }
   }
-
   /**
    * Get active sessions with detailed information
    */
-  public async getActiveSessions(options?: { limit?: number }): Promise<ActiveSessionDetails[]> {
+  async getActiveSessions(options) {
+    var _a;
     this.ensureConnected();
-    const limit = options?.limit ?? 50;
-
-    const client = await this.pool!.connect();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 50;
+    const client = await this.pool.connect();
     try {
       const res = await client.query(`
         SELECT
@@ -950,42 +762,36 @@ export class PostgresProvider extends SQLBaseProvider {
           query_start DESC NULLS LAST
         LIMIT $2
       `, [this.config.database, limit]);
-
       return res.rows.map((r) => ({
         pid: r.pid,
-        user: r.user || 'unknown',
-        database: r.database || '',
-        applicationName: r.application_name || undefined,
-        clientAddr: r.client_addr || undefined,
+        user: r.user || "unknown",
+        database: r.database || "",
+        applicationName: r.application_name || void 0,
+        clientAddr: r.client_addr || void 0,
         state: r.state,
-        query: r.query || '',
-        queryStart: r.query_start ? new Date(r.query_start) : undefined,
+        query: r.query || "",
+        queryStart: r.query_start ? new Date(r.query_start) : void 0,
         duration: r.duration,
-        durationMs: parseFloat(r.duration_ms || '0'),
-        waitEventType: r.wait_event_type || undefined,
-        waitEvent: r.wait_event || undefined,
-        blocked: false, // Could be enhanced with pg_locks query
+        durationMs: parseFloat(r.duration_ms || "0"),
+        waitEventType: r.wait_event_type || void 0,
+        waitEvent: r.wait_event || void 0,
+        blocked: false
+        // Could be enhanced with pg_locks query
       }));
     } finally {
       client.release();
     }
   }
-
   /**
    * Get table statistics
    */
-  public async getTableStats(options?: { schema?: string }): Promise<TableStats[]> {
+  async getTableStats(options) {
     this.ensureConnected();
-    const schema = options?.schema;
-
-    const client = await this.pool!.connect();
+    const schema = options == null ? void 0 : options.schema;
+    const client = await this.pool.connect();
     try {
-      // If schema is specified, filter by it; otherwise get all user schemas
-      const whereClause = schema
-        ? `WHERE schemaname = $1`
-        : `WHERE schemaname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')`;
+      const whereClause = schema ? `WHERE schemaname = $1` : `WHERE schemaname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')`;
       const params = schema ? [schema] : [];
-
       const res = await client.query(`
         SELECT
           schemaname as schema_name,
@@ -1012,47 +818,36 @@ export class PostgresProvider extends SQLBaseProvider {
         ${whereClause}
         ORDER BY pg_total_relation_size(schemaname || '.' || relname) DESC
       `, params);
-
       return res.rows.map((r) => ({
         schemaName: r.schema_name,
         tableName: r.table_name,
-        rowCount: parseInt(r.row_count || '0'),
-        liveRowCount: parseInt(r.live_row_count || '0'),
-        deadRowCount: parseInt(r.dead_row_count || '0'),
-        tableSize: r.table_size || '0 bytes',
-        tableSizeBytes: parseInt(r.table_size_bytes || '0'),
-        indexSize: r.index_size || '0 bytes',
-        indexSizeBytes: parseInt(r.index_size_bytes || '0'),
-        totalSize: r.total_size || '0 bytes',
-        totalSizeBytes: parseInt(r.total_size_bytes || '0'),
-        lastVacuum: r.last_vacuum || r.last_autovacuum
-          ? new Date(r.last_vacuum || r.last_autovacuum)
-          : undefined,
-        lastAnalyze: r.last_analyze || r.last_autoanalyze
-          ? new Date(r.last_analyze || r.last_autoanalyze)
-          : undefined,
-        bloatRatio: parseFloat(r.bloat_ratio || '0'),
+        rowCount: parseInt(r.row_count || "0"),
+        liveRowCount: parseInt(r.live_row_count || "0"),
+        deadRowCount: parseInt(r.dead_row_count || "0"),
+        tableSize: r.table_size || "0 bytes",
+        tableSizeBytes: parseInt(r.table_size_bytes || "0"),
+        indexSize: r.index_size || "0 bytes",
+        indexSizeBytes: parseInt(r.index_size_bytes || "0"),
+        totalSize: r.total_size || "0 bytes",
+        totalSizeBytes: parseInt(r.total_size_bytes || "0"),
+        lastVacuum: r.last_vacuum || r.last_autovacuum ? new Date(r.last_vacuum || r.last_autovacuum) : void 0,
+        lastAnalyze: r.last_analyze || r.last_autoanalyze ? new Date(r.last_analyze || r.last_autoanalyze) : void 0,
+        bloatRatio: parseFloat(r.bloat_ratio || "0")
       }));
     } finally {
       client.release();
     }
   }
-
   /**
    * Get index statistics
    */
-  public async getIndexStats(options?: { schema?: string }): Promise<IndexStats[]> {
+  async getIndexStats(options) {
     this.ensureConnected();
-    const schema = options?.schema;
-
-    const client = await this.pool!.connect();
+    const schema = options == null ? void 0 : options.schema;
+    const client = await this.pool.connect();
     try {
-      // If schema is specified, filter by it; otherwise get all user schemas
-      const whereClause = schema
-        ? `WHERE s.schemaname = $1`
-        : `WHERE s.schemaname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')`;
+      const whereClause = schema ? `WHERE s.schemaname = $1` : `WHERE s.schemaname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')`;
       const params = schema ? [schema] : [];
-
       const res = await client.query(`
         SELECT
           s.schemaname as schema_name,
@@ -1087,7 +882,6 @@ export class PostgresProvider extends SQLBaseProvider {
                  ix.indisunique, ix.indisprimary, s.relid
         ORDER BY s.idx_scan DESC
       `, params);
-
       return res.rows.map((r) => ({
         schemaName: r.schema_name,
         tableName: r.table_name,
@@ -1096,27 +890,23 @@ export class PostgresProvider extends SQLBaseProvider {
         columns: Array.isArray(r.columns) ? r.columns : [],
         isUnique: r.is_unique || false,
         isPrimary: r.is_primary || false,
-        indexSize: r.index_size || '0 bytes',
-        indexSizeBytes: parseInt(r.index_size_bytes || '0'),
-        scans: parseInt(r.scans || '0'),
-        usageRatio: parseFloat(r.usage_ratio || '0'),
+        indexSize: r.index_size || "0 bytes",
+        indexSizeBytes: parseInt(r.index_size_bytes || "0"),
+        scans: parseInt(r.scans || "0"),
+        usageRatio: parseFloat(r.usage_ratio || "0")
       }));
     } finally {
       client.release();
     }
   }
-
   /**
    * Get storage statistics including tablespaces and WAL
    */
-  public async getStorageStats(): Promise<StorageStats[]> {
+  async getStorageStats() {
     this.ensureConnected();
-
-    const client = await this.pool!.connect();
+    const client = await this.pool.connect();
     try {
-      const results: StorageStats[] = [];
-
-      // Get tablespace info
+      const results = [];
       const tsRes = await client.query(`
         SELECT
           spcname as name,
@@ -1127,53 +917,53 @@ export class PostgresProvider extends SQLBaseProvider {
         FROM pg_tablespace
         WHERE spcname NOT LIKE 'pg_global'
       `);
-
       for (const row of tsRes.rows) {
         results.push({
           name: row.name,
-          location: row.location || 'default',
-          size: row.size || '0 bytes',
-          sizeBytes: parseInt(row.size_bytes || '0'),
-          usagePercent: undefined, // Would need disk space info
+          location: row.location || "default",
+          size: row.size || "0 bytes",
+          sizeBytes: parseInt(row.size_bytes || "0"),
+          usagePercent: void 0
+          // Would need disk space info
         });
       }
-
-      // Get WAL info (if superuser or has permissions)
       try {
         const walRes = await client.query(`
           SELECT
             pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), '0/0')) as wal_size,
             pg_wal_lsn_diff(pg_current_wal_lsn(), '0/0') as wal_size_bytes
         `);
-
         if (walRes.rows.length > 0) {
           results.push({
-            name: 'WAL',
-            location: 'pg_wal',
-            size: walRes.rows[0].wal_size || '0 bytes',
-            sizeBytes: parseInt(walRes.rows[0].wal_size_bytes || '0'),
-            walSize: walRes.rows[0].wal_size || '0 bytes',
-            walSizeBytes: parseInt(walRes.rows[0].wal_size_bytes || '0'),
+            name: "WAL",
+            location: "pg_wal",
+            size: walRes.rows[0].wal_size || "0 bytes",
+            sizeBytes: parseInt(walRes.rows[0].wal_size_bytes || "0"),
+            walSize: walRes.rows[0].wal_size || "0 bytes",
+            walSizeBytes: parseInt(walRes.rows[0].wal_size_bytes || "0")
           });
         }
-      } catch {
-        // WAL info requires superuser, ignore if not available
+      } catch (e) {
       }
-
       return results;
     } finally {
       client.release();
     }
   }
-
-  public async getPgStatActivity(): Promise<PgStatActivityRow[]> {
+  async getPgStatActivity() {
     this.ensureConnected();
-    const client = await this.pool!.connect();
+    const client = await this.pool.connect();
     try {
-      const res = await client.query('SELECT * FROM pg_stat_activity');
-      return res.rows as PgStatActivityRow[];
+      const res = await client.query("SELECT * FROM pg_stat_activity");
+      return res.rows;
     } finally {
       client.release();
     }
   }
-}
+};
+_PostgresProvider.TX_TIMEOUT_MS = 5 * 60 * 1e3;
+var PostgresProvider = _PostgresProvider;
+
+export { PostgresProvider };
+//# sourceMappingURL=postgres-O5KOQUVP.mjs.map
+//# sourceMappingURL=postgres-O5KOQUVP.mjs.map