@libredb/studio 0.9.7 → 0.9.12

package/{src/lib/db/providers/sql/mysql.ts → dist/mysql-I3WJQXN2.mjs}

@@ -1,256 +1,189 @@
-/**
- * MySQL Database Provider
- * Full MySQL support with connection pooling using mysql2
- */
-
-import mysql, { type Pool, type PoolConnection, type RowDataPacket, type FieldPacket } from 'mysql2/promise';
-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';
-
-// ============================================================================
-// MySQL Provider
-// ============================================================================
-
-export class MySQLProvider extends SQLBaseProvider {
-  private pool: Pool | null = null;
-
-  // Transaction support: dedicated connection held outside pool
-  private txConn: PoolConnection | 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 mysql from 'mysql2/promise';
+
+var _MySQLProvider = class _MySQLProvider extends SQLBaseProvider {
+  // 5 minutes
+  constructor(config, options = {}) {
     super(config, options);
+    this.pool = null;
+    // Transaction support: dedicated connection held outside pool
+    this.txConn = null;
+    this.txActive = false;
+    this.txTimeout = null;
+    // Track running query thread IDs for cancellation
+    this.runningQueryThreadIds = /* @__PURE__ */ new Map();
     this.validate();
   }
-
   // ============================================================================
   // Provider Metadata
   // ============================================================================
-
-  public override getCapabilities(): ProviderCapabilities {
-    return {
-      ...super.getCapabilities(),
+  getCapabilities() {
+    return __spreadProps(__spreadValues({}, super.getCapabilities()), {
       defaultPort: 3306,
       supportsExplain: true,
       supportsConnectionString: true,
-      maintenanceOperations: ['analyze', 'optimize', 'check', 'kill'],
-    };
+      maintenanceOperations: ["analyze", "optimize", "check", "kill"]
+    });
   }
-
   // ============================================================================
   // Validation
   // ============================================================================
-
-  public validate(): void {
+  validate() {
     super.validate();
-
     if (!this.config.connectionString) {
       if (!this.config.host) {
-        throw new DatabaseConfigError('Host is required for MySQL', 'mysql');
+        throw new DatabaseConfigError("Host is required for MySQL", "mysql");
       }
       if (!this.config.database) {
-        throw new DatabaseConfigError('Database name is required for MySQL', 'mysql');
+        throw new DatabaseConfigError("Database name is required for MySQL", "mysql");
       }
     }
   }
-
   // ============================================================================
   // Connection Management
   // ============================================================================
-
-  public async connect(): Promise<void> {
+  async connect() {
     if (this.pool) {
       return;
     }
-
     try {
       this.pool = mysql.createPool(this.buildPoolConfig());
-
       const conn = await this.pool.getConnection();
       conn.release();
-
       this.setConnected(true);
     } catch (error) {
       this.setError(error instanceof Error ? error : new Error(String(error)));
       throw new ConnectionError(
         `Failed to connect to MySQL: ${error instanceof Error ? error.message : error}`,
-        'mysql',
+        "mysql",
         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(): mysql.PoolOptions {
-    const baseConfig: mysql.PoolOptions = {
+  buildPoolConfig() {
+    var _a, _b;
+    const baseConfig = {
       connectionLimit: this.poolConfig.max,
       waitForConnections: true,
       queueLimit: 0,
       enableKeepAlive: true,
-      keepAliveInitialDelay: 10000,
+      keepAliveInitialDelay: 1e4
     };
-
     if (this.config.connectionString) {
-      return {
-        ...baseConfig,
-        uri: this.config.connectionString,
-      };
+      return __spreadProps(__spreadValues({}, baseConfig), {
+        uri: this.config.connectionString
+      });
     }
-
-    return {
-      ...baseConfig,
+    return __spreadProps(__spreadValues({}, baseConfig), {
       host: this.config.host,
-      port: this.config.port ?? 3306,
+      port: (_a = this.config.port) != null ? _a : 3306,
       user: this.config.user,
       password: this.config.password,
       database: this.config.database,
       ssl: this.buildSSLConfig(),
-      timezone: this.options.timezone ?? 'Z',
-    };
+      timezone: (_b = this.options.timezone) != null ? _b : "Z"
+    });
   }
-
-  private buildSSLConfig(): mysql.SslOptions | undefined {
+  buildSSLConfig() {
     const connSSL = this.config.ssl;
-
     if (connSSL) {
-      if (connSSL.mode === 'disable') return undefined;
-
-      const ssl: mysql.SslOptions = {
-        rejectUnauthorized: connSSL.mode === 'verify-ca' || connSSL.mode === 'verify-full',
+      if (connSSL.mode === "disable") return void 0;
+      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;
     }
-
     if (this.shouldEnableSSL()) {
       return { rejectUnauthorized: false };
     }
-
-    return undefined;
+    return void 0;
   }
-
   // ============================================================================
   // Query Execution
   // ============================================================================
-
-  private sanitizeRow(row: Record<string, unknown>): Record<string, unknown> {
-    const sanitized: Record<string, unknown> = {};
+  sanitizeRow(row) {
+    const sanitized = {};
     for (const [key, value] of Object.entries(row)) {
       if (Buffer.isBuffer(value)) {
-        sanitized[key] = value.length === 0 ? '' : `0x${value.toString('hex')}`;
+        sanitized[key] = value.length === 0 ? "" : `0x${value.toString("hex")}`;
       } else {
         sanitized[key] = value;
       }
     }
     return sanitized;
   }
-
-  // Track running query thread IDs for cancellation
-  private runningQueryThreadIds = 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;
       const { result, executionTime } = await this.measureExecution(async () => {
-        const conn = await this.pool!.getConnection();
+        const conn = await this.pool.getConnection();
         try {
-          // Track thread ID for cancellation support
           if (queryId) {
             this.runningQueryThreadIds.set(queryId, conn.threadId);
           }
-          const [rows, fields] = await conn.execute<RowDataPacket[]>(sql, params);
+          const [rows, fields] = await conn.execute(sql, params);
           return { rows, fields };
         } catch (error) {
-          throw mapDatabaseError(error, 'mysql', sql);
+          throw mapDatabaseError(error, "mysql", sql);
         } finally {
           if (queryId) this.runningQueryThreadIds.delete(queryId);
           conn.release();
         }
       });
-
       return {
-        rows: (result.rows as unknown[]).map(row => this.sanitizeRow(row as Record<string, unknown>)),
-        fields: result.fields?.map((f: FieldPacket) => f.name) ?? [],
+        rows: result.rows.map((row) => this.sanitizeRow(row)),
+        fields: (_b = (_a = result.fields) == null ? void 0 : _a.map((f) => f.name)) != null ? _b : [],
         rowCount: Array.isArray(result.rows) ? result.rows.length : 0,
-        executionTime,
+        executionTime
       };
     });
   }
-
-  public async cancelQuery(queryId: string): Promise<boolean> {
+  async cancelQuery(queryId) {
     const threadId = this.runningQueryThreadIds.get(queryId);
     if (!threadId) return false;
-
     try {
-      await this.pool!.execute(`KILL QUERY ${threadId}`);
+      await this.pool.execute(`KILL QUERY ${threadId}`);
       return true;
     } catch (error) {
-      console.error('[MySQL] Failed to cancel query:', error);
+      console.error("[MySQL] 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.txConn) {
-      console.warn('[MySQL] Transaction timed out, auto-rolling back');
+      console.warn("[MySQL] Transaction timed out, auto-rolling back");
       try {
         await this.txConn.rollback();
-      } catch { /* ignore */ } finally {
+      } catch (e) {
+      } finally {
         this.txConn.release();
         this.txConn = null;
         this.txActive = false;
@@ -258,20 +191,18 @@ export class MySQLProvider extends SQLBaseProvider {
       }
     }
   }
-
-  public async beginTransaction(): Promise<void> {
+  async beginTransaction() {
     this.ensureConnected();
-    if (this.txActive) throw new QueryError('Transaction already active', 'mysql');
-    this.txConn = await this.pool!.getConnection();
+    if (this.txActive) throw new QueryError("Transaction already active", "mysql");
+    this.txConn = await this.pool.getConnection();
     await this.txConn.beginTransaction();
     this.txActive = true;
-
-    // Auto-rollback after timeout to prevent leaked locks
-    this.txTimeout = setTimeout(() => { this.expireTransaction(); }, MySQLProvider.TX_TIMEOUT_MS);
+    this.txTimeout = setTimeout(() => {
+      this.expireTransaction();
+    }, _MySQLProvider.TX_TIMEOUT_MS);
   }
-
-  public async commitTransaction(): Promise<void> {
-    if (!this.txConn || !this.txActive) throw new QueryError('No active transaction', 'mysql');
+  async commitTransaction() {
+    if (!this.txConn || !this.txActive) throw new QueryError("No active transaction", "mysql");
     this.clearTxTimeout();
     try {
       await this.txConn.commit();
@@ -281,9 +212,8 @@ export class MySQLProvider extends SQLBaseProvider {
       this.txActive = false;
     }
   }
-
-  public async rollbackTransaction(): Promise<void> {
-    if (!this.txConn || !this.txActive) throw new QueryError('No active transaction', 'mysql');
+  async rollbackTransaction() {
+    if (!this.txConn || !this.txActive) throw new QueryError("No active transaction", "mysql");
     this.clearTxTimeout();
     try {
       await this.txConn.rollback();
@@ -293,43 +223,37 @@ export class MySQLProvider extends SQLBaseProvider {
       this.txActive = false;
     }
   }
-
-  public isInTransaction(): boolean {
+  isInTransaction() {
     return this.txActive;
   }
-
-  public async queryInTransaction(sql: string, params?: unknown[]): Promise<QueryResult> {
-    if (!this.txConn || !this.txActive) throw new QueryError('No active transaction', 'mysql');
-
+  async queryInTransaction(sql, params) {
+    if (!this.txConn || !this.txActive) throw new QueryError("No active transaction", "mysql");
     return this.trackQuery(async () => {
+      var _a, _b;
       const { result, executionTime } = await this.measureExecution(async () => {
         try {
-          const [rows, fields] = await this.txConn!.execute<RowDataPacket[]>(sql, params);
+          const [rows, fields] = await this.txConn.execute(sql, params);
           return { rows, fields };
         } catch (error) {
-          throw mapDatabaseError(error, 'mysql', sql);
+          throw mapDatabaseError(error, "mysql", sql);
         }
       });
-
       return {
-        rows: (result.rows as unknown[]).map(row => this.sanitizeRow(row as Record<string, unknown>)),
-        fields: result.fields?.map((f: FieldPacket) => f.name) ?? [],
+        rows: result.rows.map((row) => this.sanitizeRow(row)),
+        fields: (_b = (_a = result.fields) == null ? void 0 : _a.map((f) => f.name)) != null ? _b : [],
         rowCount: Array.isArray(result.rows) ? result.rows.length : 0,
-        executionTime,
+        executionTime
       };
     });
   }
-
   // ============================================================================
   // Schema Operations
   // ============================================================================
-
-  public async getSchema(): Promise<TableSchema[]> {
+  async getSchema() {
     this.ensureConnected();
-
-    const conn = await this.pool!.getConnection();
+    const conn = await this.pool.getConnection();
     try {
-      const [tablesRows] = await conn.execute<RowDataPacket[]>(`
+      const [tablesRows] = await conn.execute(`
         SELECT
           TABLE_NAME as table_name,
           TABLE_ROWS as row_count,
@@ -339,15 +263,12 @@ export class MySQLProvider extends SQLBaseProvider {
         AND TABLE_TYPE = 'BASE TABLE'
         ORDER BY TABLE_NAME ASC;
       `, [this.config.database]);
-
-      const schemas: TableSchema[] = [];
-
+      const schemas = [];
       for (const row of tablesRows) {
         const tableName = row.table_name;
-        const rowCount = parseInt(row.row_count || '0');
-        const sizeBytes = parseInt(row.total_size || '0');
-
-        const [columnsRows] = await conn.execute<RowDataPacket[]>(`
+        const rowCount = parseInt(row.row_count || "0");
+        const sizeBytes = parseInt(row.total_size || "0");
+        const [columnsRows] = await conn.execute(`
           SELECT
             COLUMN_NAME as column_name,
             DATA_TYPE as data_type,
@@ -360,8 +281,7 @@ export class MySQLProvider extends SQLBaseProvider {
           ORDER BY ORDINAL_POSITION
           LIMIT 100;
         `, [this.config.database, tableName]);
-
-        const [fkRows] = await conn.execute<RowDataPacket[]>(`
+        const [fkRows] = await conn.execute(`
           SELECT
             COLUMN_NAME as column_name,
             REFERENCED_TABLE_NAME as referenced_table,
@@ -371,8 +291,7 @@ export class MySQLProvider extends SQLBaseProvider {
           AND TABLE_NAME = ?
           AND REFERENCED_TABLE_NAME IS NOT NULL;
         `, [this.config.database, tableName]);
-
-        const [indexRows] = await conn.execute<RowDataPacket[]>(`
+        const [indexRows] = await conn.execute(`
           SELECT
             INDEX_NAME as index_name,
             GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,
@@ -382,71 +301,70 @@ export class MySQLProvider extends SQLBaseProvider {
           AND TABLE_NAME = ?
           GROUP BY INDEX_NAME, NON_UNIQUE;
         `, [this.config.database, tableName]);
-
         schemas.push({
           name: tableName,
           rowCount,
           size: formatBytes(sizeBytes),
-          columns: columnsRows.map((col) => ({
-            name: col.column_name,
-            type: col.data_type,
-            nullable: col.is_nullable === 'YES',
-            isPrimary: col.column_key === 'PRI',
-            defaultValue: col.column_default ?? undefined,
-          })),
-          indexes: indexRows.map((idx) => ({
-            name: idx.index_name,
-            columns: idx.columns?.split(',') ?? [],
-            unique: Boolean(idx.is_unique),
-          })),
+          columns: columnsRows.map((col) => {
+            var _a;
+            return {
+              name: col.column_name,
+              type: col.data_type,
+              nullable: col.is_nullable === "YES",
+              isPrimary: col.column_key === "PRI",
+              defaultValue: (_a = col.column_default) != null ? _a : void 0
+            };
+          }),
+          indexes: indexRows.map((idx) => {
+            var _a, _b;
+            return {
+              name: idx.index_name,
+              columns: (_b = (_a = idx.columns) == null ? void 0 : _a.split(",")) != null ? _b : [],
+              unique: Boolean(idx.is_unique)
+            };
+          }),
           foreignKeys: fkRows.map((fk) => ({
             columnName: fk.column_name,
             referencedTable: fk.referenced_table,
-            referencedColumn: fk.referenced_column,
-          })),
+            referencedColumn: fk.referenced_column
+          }))
         });
       }
-
       return schemas;
     } finally {
       conn.release();
     }
   }
-
   // ============================================================================
   // Health & Monitoring
   // ============================================================================
-
-  public async getHealth(): Promise<HealthInfo> {
+  async getHealth() {
+    var _a, _b, _c;
     this.ensureConnected();
-
-    const conn = await this.pool!.getConnection();
+    const conn = await this.pool.getConnection();
     try {
-      const [connRows] = await conn.execute<RowDataPacket[]>(
+      const [connRows] = await conn.execute(
         "SHOW STATUS LIKE 'Threads_connected'"
       );
-      const activeConnections = parseInt(connRows[0]?.Value || '0');
-
-      const [sizeRows] = await conn.execute<RowDataPacket[]>(`
+      const activeConnections = parseInt(((_a = connRows[0]) == null ? void 0 : _a.Value) || "0");
+      const [sizeRows] = await conn.execute(`
         SELECT
           ROUND(SUM(DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024, 2) as size_mb
         FROM information_schema.TABLES
         WHERE TABLE_SCHEMA = ?;
       `, [this.config.database]);
-      const databaseSize = `${sizeRows[0]?.size_mb || 0} MB`;
-
-      const [hitRows] = await conn.execute<RowDataPacket[]>(`
+      const databaseSize = `${((_b = sizeRows[0]) == null ? void 0 : _b.size_mb) || 0} MB`;
+      const [hitRows] = await conn.execute(`
         SELECT
           (1 - (
             (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_reads') /
             NULLIF((SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_read_requests'), 0)
           )) * 100 as hit_ratio;
       `);
-      const cacheHitRatio = `${(hitRows[0]?.hit_ratio || 99).toFixed(1)}%`;
-
-      let slowQueries: SlowQuery[] = [];
+      const cacheHitRatio = `${(((_c = hitRows[0]) == null ? void 0 : _c.hit_ratio) || 99).toFixed(1)}%`;
+      let slowQueries = [];
       try {
-        const [slowRows] = await conn.execute<RowDataPacket[]>(`
+        const [slowRows] = await conn.execute(`
           SELECT
             LEFT(sql_text, 100) as query,
             count_star as calls,
@@ -457,15 +375,14 @@ export class MySQLProvider extends SQLBaseProvider {
           LIMIT 5;
         `, [this.config.database]);
         slowQueries = slowRows.map((r) => ({
-          query: r.query || '',
-          calls: parseInt(r.calls || '0'),
-          avgTime: r.avgTime || 'N/A',
+          query: r.query || "",
+          calls: parseInt(r.calls || "0"),
+          avgTime: r.avgTime || "N/A"
         }));
-      } catch {
-        slowQueries = [{ query: 'Performance schema not available', calls: 0, avgTime: 'N/A' }];
+      } catch (e) {
+        slowQueries = [{ query: "Performance schema not available", calls: 0, avgTime: "N/A" }];
       }
-
-      const [sessionRows] = await conn.execute<RowDataPacket[]>(`
+      const [sessionRows] = await conn.execute(`
         SELECT
           ID as pid,
           USER as user,
@@ -478,236 +395,191 @@ export class MySQLProvider extends SQLBaseProvider {
         ORDER BY TIME DESC
         LIMIT 10;
       `, [this.config.database]);
-
-      const activeSessions: ActiveSession[] = sessionRows.map((r) => ({
+      const activeSessions = sessionRows.map((r) => ({
         pid: r.pid,
-        user: r.user || 'unknown',
-        database: r.database || '',
-        state: r.state || 'unknown',
-        query: r.query || '',
-        duration: r.duration || 'N/A',
+        user: r.user || "unknown",
+        database: r.database || "",
+        state: r.state || "unknown",
+        query: r.query || "",
+        duration: r.duration || "N/A"
       }));
-
       return {
         activeConnections,
         databaseSize,
         cacheHitRatio,
         slowQueries,
-        activeSessions,
+        activeSessions
       };
     } finally {
       conn.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 conn = await this.pool!.getConnection();
+      const conn = await this.pool.getConnection();
       try {
-        let sql = '';
-
+        let sql = "";
         switch (type) {
-          case 'analyze':
-            sql = target
-              ? `ANALYZE TABLE ${this.escapeIdentifier(target)}`
-              : `ANALYZE TABLE ${await this.getAllTablesForMaintenance(conn)}`;
+          case "analyze":
+            sql = target ? `ANALYZE TABLE ${this.escapeIdentifier(target)}` : `ANALYZE TABLE ${await this.getAllTablesForMaintenance(conn)}`;
             break;
-          case 'optimize':
-            sql = target
-              ? `OPTIMIZE TABLE ${this.escapeIdentifier(target)}`
-              : `OPTIMIZE TABLE ${await this.getAllTablesForMaintenance(conn)}`;
+          case "optimize":
+            sql = target ? `OPTIMIZE TABLE ${this.escapeIdentifier(target)}` : `OPTIMIZE TABLE ${await this.getAllTablesForMaintenance(conn)}`;
             break;
-          case 'check':
-            sql = target
-              ? `CHECK TABLE ${this.escapeIdentifier(target)}`
-              : `CHECK TABLE ${await this.getAllTablesForMaintenance(conn)}`;
+          case "check":
+            sql = target ? `CHECK TABLE ${this.escapeIdentifier(target)}` : `CHECK TABLE ${await this.getAllTablesForMaintenance(conn)}`;
             break;
-          case 'kill':
+          case "kill":
             if (!target) {
-              throw new QueryError('Target connection ID is required for kill operation', 'mysql');
+              throw new QueryError("Target connection ID is required for kill operation", "mysql");
             }
             const connId = parseInt(target, 10);
             if (isNaN(connId)) {
-              throw new QueryError('Invalid connection ID for kill operation', 'mysql');
+              throw new QueryError("Invalid connection ID for kill operation", "mysql");
             }
             sql = `KILL ${connId}`;
             break;
           default:
-            throw new QueryError(`Unsupported maintenance type for MySQL: ${type}`, 'mysql');
+            throw new QueryError(`Unsupported maintenance type for MySQL: ${type}`, "mysql");
         }
-
         await conn.execute(sql);
         return { success: true };
       } finally {
         conn.release();
       }
     });
-
     return {
       success: result.success,
       executionTime,
-      message: `${type.toUpperCase()} completed successfully`,
+      message: `${type.toUpperCase()} completed successfully`
     };
   }
-
-  private async getAllTablesForMaintenance(conn: PoolConnection): Promise<string> {
-    const [rows] = await conn.execute<RowDataPacket[]>(`
+  async getAllTablesForMaintenance(conn) {
+    const [rows] = await conn.execute(`
       SELECT TABLE_NAME
       FROM information_schema.TABLES
       WHERE TABLE_SCHEMA = ?
       AND TABLE_TYPE = 'BASE TABLE'
       LIMIT 50;
     `, [this.config.database]);
-
-    return rows.map((r) => this.escapeIdentifier(r.TABLE_NAME)).join(', ');
+    return rows.map((r) => this.escapeIdentifier(r.TABLE_NAME)).join(", ");
   }
-
   // ============================================================================
   // Monitoring Operations
   // ============================================================================
-
-  public async getOverview(): Promise<DatabaseOverview> {
+  async getOverview() {
+    var _a, _b, _c, _d, _e, _f, _g;
     this.ensureConnected();
-
-    const conn = await this.pool!.getConnection();
+    const conn = await this.pool.getConnection();
     try {
-      // Get version
-      const [versionRows] = await conn.execute<RowDataPacket[]>('SELECT VERSION() as version');
-      const version = versionRows[0]?.version || 'Unknown';
-
-      // Get uptime
-      const [uptimeRows] = await conn.execute<RowDataPacket[]>(
+      const [versionRows] = await conn.execute("SELECT VERSION() as version");
+      const version = ((_a = versionRows[0]) == null ? void 0 : _a.version) || "Unknown";
+      const [uptimeRows] = await conn.execute(
         "SHOW STATUS LIKE 'Uptime'"
       );
-      const uptimeSeconds = parseInt(uptimeRows[0]?.Value || '0');
+      const uptimeSeconds = parseInt(((_b = uptimeRows[0]) == null ? void 0 : _b.Value) || "0");
       const uptime = this.formatUptimeString(uptimeSeconds);
-
-      // Get active connections
-      const [connRows] = await conn.execute<RowDataPacket[]>(
+      const [connRows] = await conn.execute(
         "SHOW STATUS LIKE 'Threads_connected'"
       );
-      const activeConnections = parseInt(connRows[0]?.Value || '0');
-
-      // Get max connections
-      const [maxConnRows] = await conn.execute<RowDataPacket[]>(
+      const activeConnections = parseInt(((_c = connRows[0]) == null ? void 0 : _c.Value) || "0");
+      const [maxConnRows] = await conn.execute(
         "SHOW VARIABLES LIKE 'max_connections'"
       );
-      const maxConnections = parseInt(maxConnRows[0]?.Value || '151');
-
-      // Get database size
-      const [sizeRows] = await conn.execute<RowDataPacket[]>(`
+      const maxConnections = parseInt(((_d = maxConnRows[0]) == null ? void 0 : _d.Value) || "151");
+      const [sizeRows] = await conn.execute(`
         SELECT SUM(DATA_LENGTH + INDEX_LENGTH) as size_bytes
         FROM information_schema.TABLES
         WHERE TABLE_SCHEMA = ?;
       `, [this.config.database]);
-      const databaseSizeBytes = parseInt(sizeRows[0]?.size_bytes || '0');
-
-      // Get table and index count
-      const [countRows] = await conn.execute<RowDataPacket[]>(`
+      const databaseSizeBytes = parseInt(((_e = sizeRows[0]) == null ? void 0 : _e.size_bytes) || "0");
+      const [countRows] = await conn.execute(`
         SELECT
           COUNT(DISTINCT TABLE_NAME) as table_count,
           COUNT(DISTINCT INDEX_NAME) as index_count
         FROM information_schema.STATISTICS
         WHERE TABLE_SCHEMA = ?;
       `, [this.config.database]);
-
-      const [tableCountRows] = await conn.execute<RowDataPacket[]>(`
+      const [tableCountRows] = await conn.execute(`
         SELECT COUNT(*) as cnt FROM information_schema.TABLES
         WHERE TABLE_SCHEMA = ? AND TABLE_TYPE = 'BASE TABLE';
       `, [this.config.database]);
-
       return {
         version: `MySQL ${version}`,
         uptime,
-        startTime: new Date(Date.now() - uptimeSeconds * 1000),
+        startTime: new Date(Date.now() - uptimeSeconds * 1e3),
         activeConnections,
         maxConnections,
         databaseSize: formatBytes(databaseSizeBytes),
         databaseSizeBytes,
-        tableCount: parseInt(tableCountRows[0]?.cnt || '0'),
-        indexCount: parseInt(countRows[0]?.index_count || '0'),
+        tableCount: parseInt(((_f = tableCountRows[0]) == null ? void 0 : _f.cnt) || "0"),
+        indexCount: parseInt(((_g = countRows[0]) == null ? void 0 : _g.index_count) || "0")
       };
     } finally {
       conn.release();
     }
   }
-
-  public async getPerformanceMetrics(): Promise<PerformanceMetrics> {
+  async getPerformanceMetrics() {
+    var _a, _b, _c, _d, _e, _f;
     this.ensureConnected();
-
-    const conn = await this.pool!.getConnection();
+    const conn = await this.pool.getConnection();
     try {
-      // Calculate cache hit ratio from InnoDB buffer pool
-      const [hitRows] = await conn.execute<RowDataPacket[]>(`
+      const [hitRows] = await conn.execute(`
         SELECT
           (1 - (
             (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_reads') /
             NULLIF((SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_read_requests'), 0)
           )) * 100 as hit_ratio;
       `);
-      const cacheHitRatio = parseFloat(hitRows[0]?.hit_ratio || '99');
-
-      // Get buffer pool usage
-      const [poolRows] = await conn.execute<RowDataPacket[]>(`
+      const cacheHitRatio = parseFloat(((_a = hitRows[0]) == null ? void 0 : _a.hit_ratio) || "99");
+      const [poolRows] = await conn.execute(`
         SELECT
           (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_pages_data') as data_pages,
           (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_pages_total') as total_pages;
       `);
-      const dataPages = parseInt(poolRows[0]?.data_pages || '0');
-      const totalPages = parseInt(poolRows[0]?.total_pages || '1');
-      const bufferPoolUsage = (dataPages / totalPages) * 100;
-
-      // Get queries per second
-      const [qpsRows] = await conn.execute<RowDataPacket[]>(`
+      const dataPages = parseInt(((_b = poolRows[0]) == null ? void 0 : _b.data_pages) || "0");
+      const totalPages = parseInt(((_c = poolRows[0]) == null ? void 0 : _c.total_pages) || "1");
+      const bufferPoolUsage = dataPages / totalPages * 100;
+      const [qpsRows] = await conn.execute(`
         SELECT
           (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Queries') as queries,
           (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Uptime') as uptime;
       `);
-      const queries = parseInt(qpsRows[0]?.queries || '0');
-      const uptime = parseInt(qpsRows[0]?.uptime || '1');
+      const queries = parseInt(((_d = qpsRows[0]) == null ? void 0 : _d.queries) || "0");
+      const uptime = parseInt(((_e = qpsRows[0]) == null ? void 0 : _e.uptime) || "1");
       const queriesPerSecond = queries / uptime;
-
-      // Get deadlocks
-      const [deadlockRows] = await conn.execute<RowDataPacket[]>(
+      const [deadlockRows] = await conn.execute(
         "SHOW STATUS LIKE 'Innodb_deadlocks'"
       );
-      const deadlocks = parseInt(deadlockRows[0]?.Value || '0');
-
+      const deadlocks = parseInt(((_f = deadlockRows[0]) == null ? void 0 : _f.Value) || "0");
       return {
         cacheHitRatio: Math.min(100, Math.max(0, cacheHitRatio)),
         queriesPerSecond: Math.round(queriesPerSecond * 100) / 100,
         bufferPoolUsage: Math.round(bufferPoolUsage * 100) / 100,
-        deadlocks,
+        deadlocks
       };
-    } catch {
-      // Fallback if performance_schema is not available
+    } catch (e) {
       return {
         cacheHitRatio: 99,
         queriesPerSecond: 0,
         bufferPoolUsage: 0,
-        deadlocks: 0,
+        deadlocks: 0
       };
     } finally {
       conn.release();
     }
   }
-
-  public async getSlowQueries(options?: { limit?: number }): Promise<SlowQueryStats[]> {
+  async getSlowQueries(options) {
+    var _a;
     this.ensureConnected();
-    const limit = options?.limit ?? 10;
-
-    const conn = await this.pool!.getConnection();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 10;
+    const conn = await this.pool.getConnection();
     try {
-      const [rows] = await conn.execute<RowDataPacket[]>(`
+      const [rows] = await conn.execute(`
         SELECT
           DIGEST as query_id,
           LEFT(DIGEST_TEXT, 500) as query,
@@ -722,32 +594,29 @@ export class MySQLProvider extends SQLBaseProvider {
         ORDER BY SUM_TIMER_WAIT DESC
         LIMIT ${Number(limit)};
       `, [this.config.database]);
-
       return rows.map((r) => ({
-        queryId: r.query_id || undefined,
-        query: r.query || '',
-        calls: parseInt(r.calls || '0'),
-        totalTime: parseFloat(r.total_time_ms || '0'),
-        avgTime: parseFloat(r.avg_time_ms || '0'),
-        minTime: parseFloat(r.min_time_ms || '0'),
-        maxTime: parseFloat(r.max_time_ms || '0'),
-        rows: parseInt(r.rows_examined || '0'),
+        queryId: r.query_id || void 0,
+        query: r.query || "",
+        calls: parseInt(r.calls || "0"),
+        totalTime: parseFloat(r.total_time_ms || "0"),
+        avgTime: parseFloat(r.avg_time_ms || "0"),
+        minTime: parseFloat(r.min_time_ms || "0"),
+        maxTime: parseFloat(r.max_time_ms || "0"),
+        rows: parseInt(r.rows_examined || "0")
       }));
-    } catch {
-      // Performance schema not available
+    } catch (e) {
       return [];
     } finally {
       conn.release();
     }
   }
-
-  public async getActiveSessions(options?: { limit?: number }): Promise<ActiveSessionDetails[]> {
+  async getActiveSessions(options) {
+    var _a;
     this.ensureConnected();
-    const limit = options?.limit ?? 50;
-
-    const conn = await this.pool!.getConnection();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 50;
+    const conn = await this.pool.getConnection();
     try {
-      const [rows] = await conn.execute<RowDataPacket[]>(`
+      const [rows] = await conn.execute(`
         SELECT
           ID as pid,
           USER as user,
@@ -761,32 +630,31 @@ export class MySQLProvider extends SQLBaseProvider {
         ORDER BY TIME DESC
         LIMIT ${Number(limit)};
       `, [this.config.database]);
-
       return rows.map((r) => {
-        const durationSeconds = parseInt(r.duration_seconds || '0');
+        var _a2;
+        const durationSeconds = parseInt(r.duration_seconds || "0");
         return {
           pid: r.pid,
-          user: r.user || 'unknown',
-          database: r.database_name || '',
-          clientAddr: r.client_addr?.split(':')[0] || undefined,
-          state: r.state || 'unknown',
-          query: r.query || '',
-          duration: this.formatDurationString(durationSeconds * 1000),
-          durationMs: durationSeconds * 1000,
+          user: r.user || "unknown",
+          database: r.database_name || "",
+          clientAddr: ((_a2 = r.client_addr) == null ? void 0 : _a2.split(":")[0]) || void 0,
+          state: r.state || "unknown",
+          query: r.query || "",
+          duration: this.formatDurationString(durationSeconds * 1e3),
+          durationMs: durationSeconds * 1e3
         };
       });
     } finally {
       conn.release();
     }
   }
-
-  public async getTableStats(options?: { schema?: string }): Promise<TableStats[]> {
+  async getTableStats(options) {
+    var _a;
     this.ensureConnected();
-    const schema = options?.schema ?? this.config.database;
-
-    const conn = await this.pool!.getConnection();
+    const schema = (_a = options == null ? void 0 : options.schema) != null ? _a : this.config.database;
+    const conn = await this.pool.getConnection();
     try {
-      const [rows] = await conn.execute<RowDataPacket[]>(`
+      const [rows] = await conn.execute(`
         SELECT
           TABLE_SCHEMA as schema_name,
           TABLE_NAME as table_name,
@@ -801,40 +669,35 @@ export class MySQLProvider extends SQLBaseProvider {
         ORDER BY DATA_LENGTH + INDEX_LENGTH DESC
         LIMIT 100;
       `, [schema]);
-
       return rows.map((r) => {
-        const tableSizeBytes = parseInt(r.table_size_bytes || '0');
-        const indexSizeBytes = parseInt(r.index_size_bytes || '0');
-        const totalSizeBytes = parseInt(r.total_size_bytes || '0');
-        const freeSpaceBytes = parseInt(r.free_space_bytes || '0');
-
-        // Estimate bloat ratio from free space
-        const bloatRatio = totalSizeBytes > 0 ? (freeSpaceBytes / totalSizeBytes) * 100 : 0;
-
+        const tableSizeBytes = parseInt(r.table_size_bytes || "0");
+        const indexSizeBytes = parseInt(r.index_size_bytes || "0");
+        const totalSizeBytes = parseInt(r.total_size_bytes || "0");
+        const freeSpaceBytes = parseInt(r.free_space_bytes || "0");
+        const bloatRatio = totalSizeBytes > 0 ? freeSpaceBytes / totalSizeBytes * 100 : 0;
         return {
-          schemaName: r.schema_name || schema || '',
-          tableName: r.table_name || '',
-          rowCount: parseInt(r.row_count || '0'),
+          schemaName: r.schema_name || schema || "",
+          tableName: r.table_name || "",
+          rowCount: parseInt(r.row_count || "0"),
           tableSize: formatBytes(tableSizeBytes),
           tableSizeBytes,
           indexSize: formatBytes(indexSizeBytes),
           totalSize: formatBytes(totalSizeBytes),
           totalSizeBytes,
-          bloatRatio: Math.round(bloatRatio * 10) / 10,
+          bloatRatio: Math.round(bloatRatio * 10) / 10
         };
       });
     } finally {
       conn.release();
     }
   }
-
-  public async getIndexStats(options?: { schema?: string }): Promise<IndexStats[]> {
+  async getIndexStats(options) {
+    var _a;
     this.ensureConnected();
-    const schema = options?.schema ?? this.config.database;
-
-    const conn = await this.pool!.getConnection();
+    const schema = (_a = options == null ? void 0 : options.schema) != null ? _a : this.config.database;
+    const conn = await this.pool.getConnection();
     try {
-      const [rows] = await conn.execute<RowDataPacket[]>(`
+      const [rows] = await conn.execute(`
         SELECT
           TABLE_SCHEMA as schema_name,
           TABLE_NAME as table_name,
@@ -850,11 +713,9 @@ export class MySQLProvider extends SQLBaseProvider {
         ORDER BY TABLE_NAME, INDEX_NAME
         LIMIT 200;
       `, [schema]);
-
-      // Get index sizes from INNODB_SYS_INDEXES if available
-      const indexSizes: Record<string, number> = {};
+      const indexSizes = {};
       try {
-        const [sizeRows] = await conn.execute<RowDataPacket[]>(`
+        const [sizeRows] = await conn.execute(`
           SELECT
             CONCAT(t.NAME) as full_name,
             SUM(s.INDEX_SIZE * @@innodb_page_size) as size_bytes
@@ -864,45 +725,38 @@ export class MySQLProvider extends SQLBaseProvider {
           WHERE t.NAME LIKE ?
           GROUP BY t.NAME, i.NAME;
         `, [`${schema}/%`]);
-
         for (const row of sizeRows) {
-          indexSizes[row.full_name] = parseInt(row.size_bytes || '0');
+          indexSizes[row.full_name] = parseInt(row.size_bytes || "0");
         }
-      } catch {
-        // INNODB_SYS tables not available
+      } catch (e) {
       }
-
       return rows.map((r) => {
+        var _a2;
         const indexKey = `${r.schema_name}/${r.table_name}`;
         const indexSizeBytes = indexSizes[indexKey] || 0;
-
         return {
-          schemaName: r.schema_name || schema || '',
-          tableName: r.table_name || '',
-          indexName: r.index_name || '',
-          indexType: r.index_type || 'BTREE',
-          columns: r.columns?.split(',') || [],
+          schemaName: r.schema_name || schema || "",
+          tableName: r.table_name || "",
+          indexName: r.index_name || "",
+          indexType: r.index_type || "BTREE",
+          columns: ((_a2 = r.columns) == null ? void 0 : _a2.split(",")) || [],
           isUnique: Boolean(r.is_unique),
           isPrimary: Boolean(r.is_primary),
           indexSize: formatBytes(indexSizeBytes),
           indexSizeBytes,
-          scans: parseInt(r.cardinality || '0'),
+          scans: parseInt(r.cardinality || "0")
         };
       });
     } finally {
       conn.release();
     }
   }
-
-  public async getStorageStats(): Promise<StorageStats[]> {
+  async getStorageStats() {
     this.ensureConnected();
-
-    const conn = await this.pool!.getConnection();
+    const conn = await this.pool.getConnection();
     try {
-      const stats: StorageStats[] = [];
-
-      // Get database size
-      const [dbRows] = await conn.execute<RowDataPacket[]>(`
+      const stats = [];
+      const [dbRows] = await conn.execute(`
         SELECT
           TABLE_SCHEMA as name,
           SUM(DATA_LENGTH + INDEX_LENGTH) as size_bytes
@@ -910,69 +764,64 @@ export class MySQLProvider extends SQLBaseProvider {
         WHERE TABLE_SCHEMA = ?
         GROUP BY TABLE_SCHEMA;
       `, [this.config.database]);
-
       if (dbRows.length > 0) {
-        const sizeBytes = parseInt(dbRows[0].size_bytes || '0');
+        const sizeBytes = parseInt(dbRows[0].size_bytes || "0");
         stats.push({
-          name: 'Data',
-          location: this.config.database || 'default',
+          name: "Data",
+          location: this.config.database || "default",
           size: formatBytes(sizeBytes),
-          sizeBytes,
+          sizeBytes
         });
       }
-
-      // Get binary log size if available
       try {
-        const [binlogRows] = await conn.execute<RowDataPacket[]>('SHOW BINARY LOGS');
-        const binlogSize = binlogRows.reduce((sum, r) => sum + parseInt(r.File_size || '0'), 0);
+        const [binlogRows] = await conn.execute("SHOW BINARY LOGS");
+        const binlogSize = binlogRows.reduce((sum, r) => sum + parseInt(r.File_size || "0"), 0);
         if (binlogSize > 0) {
           stats.push({
-            name: 'Binary Logs',
+            name: "Binary Logs",
             size: formatBytes(binlogSize),
-            sizeBytes: binlogSize,
+            sizeBytes: binlogSize
           });
         }
-      } catch {
-        // Binary logging not enabled
+      } catch (e) {
       }
-
-      // Get InnoDB data file size
       try {
-        const [innodbRows] = await conn.execute<RowDataPacket[]>(
+        const [innodbRows] = await conn.execute(
           "SHOW VARIABLES LIKE 'innodb_data_file_path'"
         );
         if (innodbRows.length > 0) {
           stats.push({
-            name: 'InnoDB',
-            location: innodbRows[0].Value || 'ibdata1',
-            size: 'N/A',
-            sizeBytes: 0,
+            name: "InnoDB",
+            location: innodbRows[0].Value || "ibdata1",
+            size: "N/A",
+            sizeBytes: 0
           });
         }
-      } catch {
-        // Could not get InnoDB info
+      } catch (e) {
       }
-
       return stats;
     } finally {
       conn.release();
     }
   }
-
-  private formatUptimeString(seconds: number): string {
+  formatUptimeString(seconds) {
     const days = Math.floor(seconds / 86400);
-    const hours = Math.floor((seconds % 86400) / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-
+    const hours = Math.floor(seconds % 86400 / 3600);
+    const minutes = Math.floor(seconds % 3600 / 60);
     if (days > 0) return `${days}d ${hours}h`;
     if (hours > 0) return `${hours}h ${minutes}m`;
     return `${minutes}m`;
   }
-
-  private formatDurationString(ms: number): string {
-    if (ms < 1000) return `${ms}ms`;
-    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-    if (ms < 3600000) return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
-    return `${Math.floor(ms / 3600000)}h ${Math.floor((ms % 3600000) / 60000)}m`;
+  formatDurationString(ms) {
+    if (ms < 1e3) return `${ms}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+    if (ms < 36e5) return `${Math.floor(ms / 6e4)}m ${Math.floor(ms % 6e4 / 1e3)}s`;
+    return `${Math.floor(ms / 36e5)}h ${Math.floor(ms % 36e5 / 6e4)}m`;
   }
-}
+};
+_MySQLProvider.TX_TIMEOUT_MS = 5 * 60 * 1e3;
+var MySQLProvider = _MySQLProvider;
+
+export { MySQLProvider };
+//# sourceMappingURL=mysql-I3WJQXN2.mjs.map
+//# sourceMappingURL=mysql-I3WJQXN2.mjs.map