@libredb/studio 0.9.7 → 0.9.13

package/{src/lib/db/providers/sql/mssql.ts → dist/mssql-ZH5VP2C5.mjs}

@@ -1,142 +1,83 @@
-/**
- * Microsoft SQL Server Database Provider
- * Full MSSQL support with connection pooling (SQL Authentication)
- */
-
+import { SQLBaseProvider, DEFAULT_QUERY_LIMIT, MAX_UNLIMITED_ROWS, analyzeQuery } 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 mssql from 'mssql';
-import { SQLBaseProvider } from './sql-base';
-import {
-  type DatabaseConnection,
-  type TableSchema,
-  type QueryResult,
-  type HealthInfo,
-  type MaintenanceType,
-  type MaintenanceResult,
-  type ProviderOptions,
-  type ProviderCapabilities,
-  type ProviderLabels,
-  type SlowQuery,
-  type ActiveSession,
-  type DatabaseOverview,
-  type PerformanceMetrics,
-  type SlowQueryStats,
-  type ActiveSessionDetails,
-  type TableStats,
-  type IndexStats,
-  type StorageStats,
-  type PreparedQuery,
-  type QueryPrepareOptions,
-} from '../../types';
-import {
-  DatabaseConfigError,
-  ConnectionError,
-  QueryError,
-  mapDatabaseError,
-} from '../../errors';
-import { formatBytes } from '../../utils/pool-manager';
-import {
-  analyzeQuery,
-  DEFAULT_QUERY_LIMIT,
-  MAX_UNLIMITED_ROWS,
-} from '../../utils/query-limiter';
-
-// ============================================================================
-// MSSQL Provider
-// ============================================================================
-
-export class MSSQLProvider extends SQLBaseProvider {
-  private pool: mssql.ConnectionPool | null = null;
-
-  // Transaction support
-  private txTransaction: mssql.Transaction | null = null;
-  private txActive = false;
-
-  // Track running requests for cancellation
-  private runningRequests = new Map<string, mssql.Request>();
 
-  constructor(config: DatabaseConnection, options: ProviderOptions = {}) {
+var MSSQLProvider = class extends SQLBaseProvider {
+  constructor(config, options = {}) {
     super(config, options);
+    this.pool = null;
+    // Transaction support
+    this.txTransaction = null;
+    this.txActive = false;
+    // Track running requests for cancellation
+    this.runningRequests = /* @__PURE__ */ new Map();
     this.validate();
   }
-
   // ============================================================================
   // Provider Metadata
   // ============================================================================
-
-  public override getCapabilities(): ProviderCapabilities {
-    return {
-      ...super.getCapabilities(),
+  getCapabilities() {
+    return __spreadProps(__spreadValues({}, super.getCapabilities()), {
       defaultPort: 1433,
       supportsExplain: true,
       supportsConnectionString: true,
-      maintenanceOperations: ['analyze', 'check', 'optimize', 'kill'],
-    };
+      maintenanceOperations: ["analyze", "check", "optimize", "kill"]
+    });
   }
-
-  public override getLabels(): ProviderLabels {
-    return {
-      ...super.getLabels(),
-      analyzeAction: 'Update Statistics',
-      vacuumAction: 'Rebuild Indexes',
-      analyzeGlobalLabel: 'Update Stats',
-      analyzeGlobalTitle: 'Update Statistics',
-      analyzeGlobalDesc: 'Updates query optimizer statistics for all tables to improve query performance.',
-      vacuumGlobalLabel: 'Rebuild Indexes',
-      vacuumGlobalTitle: 'Rebuild All Indexes',
-      vacuumGlobalDesc: 'Rebuilds all indexes to reclaim space and reduce fragmentation.',
-    };
+  getLabels() {
+    return __spreadProps(__spreadValues({}, super.getLabels()), {
+      analyzeAction: "Update Statistics",
+      vacuumAction: "Rebuild Indexes",
+      analyzeGlobalLabel: "Update Stats",
+      analyzeGlobalTitle: "Update Statistics",
+      analyzeGlobalDesc: "Updates query optimizer statistics for all tables to improve query performance.",
+      vacuumGlobalLabel: "Rebuild Indexes",
+      vacuumGlobalTitle: "Rebuild All Indexes",
+      vacuumGlobalDesc: "Rebuilds all indexes to reclaim space and reduce fragmentation."
+    });
   }
-
   // ============================================================================
   // SQL Dialect Overrides
   // ============================================================================
-
-  protected override escapeIdentifier(identifier: string): string {
-    const escaped = identifier.replace(/\]/g, ']]');
+  escapeIdentifier(identifier) {
+    const escaped = identifier.replace(/\]/g, "]]");
     return `[${escaped}]`;
   }
-
   // ============================================================================
   // Validation
   // ============================================================================
-
-  public validate(): void {
+  validate() {
     super.validate();
-
     if (!this.config.connectionString) {
       if (!this.config.host) {
-        throw new DatabaseConfigError('Host is required for SQL Server', 'mssql');
+        throw new DatabaseConfigError("Host is required for SQL Server", "mssql");
       }
       if (!this.config.database) {
-        throw new DatabaseConfigError('Database name is required for SQL Server', 'mssql');
+        throw new DatabaseConfigError("Database name is required for SQL Server", "mssql");
       }
     }
   }
-
   // ============================================================================
   // Connection Management
   // ============================================================================
-
-  private buildConfig(): mssql.config {
-    const host = this.config.host || 'localhost';
+  buildConfig() {
+    const host = this.config.host || "localhost";
     const port = this.config.port || 1433;
-    const isAzure = host.endsWith('.database.windows.net');
-
+    const isAzure = host.endsWith(".database.windows.net");
     const sslConfig = this.config.ssl;
-    // SQL Server 2022+ enforces encryption by default; always encrypt and trust self-signed certs for non-Azure
     let encrypt = true;
     let trustServerCertificate = !isAzure;
-
     if (sslConfig) {
-      if (sslConfig.mode === 'disable') {
+      if (sslConfig.mode === "disable") {
         encrypt = false;
       } else {
         encrypt = true;
-        trustServerCertificate = sslConfig.mode === 'require';
+        trustServerCertificate = sslConfig.mode === "require";
       }
     }
-
-    const config: mssql.config = {
+    const config = {
       user: this.config.user,
       password: this.config.password,
       server: host,
@@ -145,183 +86,145 @@ export class MSSQLProvider extends SQLBaseProvider {
       pool: {
         min: this.poolConfig.min,
         max: this.poolConfig.max,
-        idleTimeoutMillis: this.poolConfig.idleTimeout,
+        idleTimeoutMillis: this.poolConfig.idleTimeout
       },
       options: {
         encrypt,
         trustServerCertificate,
         connectTimeout: this.poolConfig.acquireTimeout,
-        requestTimeout: this.queryTimeout,
-      },
+        requestTimeout: this.queryTimeout
+      }
     };
-
-    // Named instance support
     if (this.config.instanceName) {
-      config.options = {
-        ...config.options,
-        instanceName: this.config.instanceName,
-      };
-      // When using instance name, port is auto-negotiated via SQL Server Browser
-      delete (config as Record<string, unknown>).port;
+      config.options = __spreadProps(__spreadValues({}, config.options), {
+        instanceName: this.config.instanceName
+      });
+      delete config.port;
     }
-
     return config;
   }
-
-  public async connect(): Promise<void> {
+  async connect() {
     if (this.pool) {
       return;
     }
-
     try {
       const config = this.buildConfig();
       this.pool = new mssql.ConnectionPool(config);
       await this.pool.connect();
-
-      // Test the connection
-      await this.pool.request().query('SELECT 1 AS test');
-
+      await this.pool.request().query("SELECT 1 AS test");
       this.setConnected(true);
     } catch (error) {
       this.setError(error instanceof Error ? error : new Error(String(error)));
       throw new ConnectionError(
         `Failed to connect to SQL Server: ${error instanceof Error ? error.message : error}`,
-        'mssql',
+        "mssql",
         this.config.host,
         this.config.port
       );
     }
   }
-
-  public async disconnect(): Promise<void> {
+  async disconnect() {
     if (this.pool) {
       try {
         await this.pool.close();
-      } catch {
-        // Force close on error
+      } catch (e) {
       }
       this.pool = null;
       this.setConnected(false);
     }
   }
-
   // ============================================================================
   // Query Execution
   // ============================================================================
-
-  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 () => {
         try {
-          const request = this.pool!.request();
-
+          const request = this.pool.request();
           if (queryId) {
             this.runningRequests.set(queryId, request);
           }
-
-          // Add parameters
           if (params && params.length > 0) {
             params.forEach((p, i) => {
               request.input(`p${i + 1}`, p);
             });
           }
-
           const res = await request.query(sql);
           return res;
         } catch (error) {
-          throw mapDatabaseError(error, 'mssql', sql);
+          throw mapDatabaseError(error, "mssql", sql);
         } finally {
           if (queryId) this.runningRequests.delete(queryId);
         }
       });
-
       const recordset = result.recordset || [];
-      const fields = recordset.columns
-        ? Object.keys(recordset.columns)
-        : recordset.length > 0
-          ? Object.keys(recordset[0])
-          : [];
-
+      const fields = recordset.columns ? Object.keys(recordset.columns) : recordset.length > 0 ? Object.keys(recordset[0]) : [];
       return {
-        rows: recordset as Record<string, unknown>[],
+        rows: recordset,
         fields,
-        rowCount: result.rowsAffected?.[0] ?? recordset.length,
-        executionTime,
+        rowCount: (_b = (_a = result.rowsAffected) == null ? void 0 : _a[0]) != null ? _b : recordset.length,
+        executionTime
       };
     });
   }
-
-  public async cancelQuery(queryId: string): Promise<boolean> {
+  async cancelQuery(queryId) {
     const request = this.runningRequests.get(queryId);
     if (!request) return false;
-
     try {
       request.cancel();
       return true;
     } catch (error) {
-      console.error('[MSSQL] Failed to cancel query:', error);
+      console.error("[MSSQL] Failed to cancel query:", error);
       return false;
     }
   }
-
   // ============================================================================
   // Query Preparation (MSSQL TOP / OFFSET FETCH)
   // ============================================================================
-
-  public override prepareQuery(query: string, options: QueryPrepareOptions = {}): PreparedQuery {
+  prepareQuery(query, options = {}) {
     const { limit = DEFAULT_QUERY_LIMIT, offset = 0, unlimited = false } = options;
     const effectiveLimit = unlimited ? MAX_UNLIMITED_ROWS : limit;
     const queryInfo = analyzeQuery(query);
-
-    if (queryInfo.type === 'SELECT' && !queryInfo.hasLimit) {
+    if (queryInfo.type === "SELECT" && !queryInfo.hasLimit) {
       let modifiedSql = query.trim();
-      const hasSemicolon = modifiedSql.endsWith(';');
+      const hasSemicolon = modifiedSql.endsWith(";");
       if (hasSemicolon) modifiedSql = modifiedSql.slice(0, -1).trim();
-
       if (offset > 0) {
-        // OFFSET FETCH requires ORDER BY
         const hasOrderBy = /\bORDER\s+BY\b/i.test(modifiedSql);
         if (!hasOrderBy) {
           modifiedSql = `${modifiedSql} ORDER BY (SELECT NULL)`;
         }
         modifiedSql = `${modifiedSql} OFFSET ${offset} ROWS FETCH NEXT ${effectiveLimit} ROWS ONLY`;
       } else {
-        // Inject TOP N after SELECT
         modifiedSql = modifiedSql.replace(
           /^(\s*SELECT\s+)(DISTINCT\s+)?/i,
           `$1$2TOP ${effectiveLimit} `
         );
       }
-
-      if (hasSemicolon) modifiedSql += ';';
-
+      if (hasSemicolon) modifiedSql += ";";
       return {
         query: modifiedSql,
         wasLimited: true,
         limit: effectiveLimit,
-        offset,
+        offset
       };
     }
-
     return { query, wasLimited: false, limit: effectiveLimit, offset };
   }
-
   // ============================================================================
   // Transaction Support
   // ============================================================================
-
-  public async beginTransaction(): Promise<void> {
+  async beginTransaction() {
     this.ensureConnected();
-    if (this.txActive) throw new QueryError('Transaction already active', 'mssql');
-    this.txTransaction = new mssql.Transaction(this.pool!);
+    if (this.txActive) throw new QueryError("Transaction already active", "mssql");
+    this.txTransaction = new mssql.Transaction(this.pool);
     await this.txTransaction.begin();
     this.txActive = true;
   }
-
-  public async commitTransaction(): Promise<void> {
-    if (!this.txTransaction || !this.txActive) throw new QueryError('No active transaction', 'mssql');
+  async commitTransaction() {
+    if (!this.txTransaction || !this.txActive) throw new QueryError("No active transaction", "mssql");
     try {
       await this.txTransaction.commit();
     } finally {
@@ -329,9 +232,8 @@ export class MSSQLProvider extends SQLBaseProvider {
       this.txActive = false;
     }
   }
-
-  public async rollbackTransaction(): Promise<void> {
-    if (!this.txTransaction || !this.txActive) throw new QueryError('No active transaction', 'mssql');
+  async rollbackTransaction() {
+    if (!this.txTransaction || !this.txActive) throw new QueryError("No active transaction", "mssql");
     try {
       await this.txTransaction.rollback();
     } finally {
@@ -339,18 +241,16 @@ export class MSSQLProvider extends SQLBaseProvider {
       this.txActive = false;
     }
   }
-
-  public isInTransaction(): boolean {
+  isInTransaction() {
     return this.txActive;
   }
-
-  public async queryInTransaction(sql: string, params?: unknown[]): Promise<QueryResult> {
-    if (!this.txTransaction || !this.txActive) throw new QueryError('No active transaction', 'mssql');
-
+  async queryInTransaction(sql, params) {
+    if (!this.txTransaction || !this.txActive) throw new QueryError("No active transaction", "mssql");
     return this.trackQuery(async () => {
+      var _a, _b;
       const { result, executionTime } = await this.measureExecution(async () => {
         try {
-          const request = new mssql.Request(this.txTransaction!);
+          const request = new mssql.Request(this.txTransaction);
           if (params && params.length > 0) {
             params.forEach((p, i) => {
               request.input(`p${i + 1}`, p);
@@ -358,32 +258,26 @@ export class MSSQLProvider extends SQLBaseProvider {
           }
           return await request.query(sql);
         } catch (error) {
-          throw mapDatabaseError(error, 'mssql', sql);
+          throw mapDatabaseError(error, "mssql", sql);
         }
       });
-
       const recordset = result.recordset || [];
       const fields = recordset.length > 0 ? Object.keys(recordset[0]) : [];
-
       return {
-        rows: recordset as Record<string, unknown>[],
+        rows: recordset,
         fields,
-        rowCount: result.rowsAffected?.[0] ?? recordset.length,
-        executionTime,
+        rowCount: (_b = (_a = result.rowsAffected) == null ? void 0 : _a[0]) != null ? _b : recordset.length,
+        executionTime
       };
     });
   }
-
   // ============================================================================
   // Schema Operations
   // ============================================================================
-
-  public async getSchema(): Promise<TableSchema[]> {
+  async getSchema() {
     this.ensureConnected();
-
     try {
-      // Get tables
-      const tablesRes = await this.pool!.request().query(`
+      const tablesRes = await this.pool.request().query(`
         SELECT
           s.name AS schema_name,
           t.name AS table_name,
@@ -396,9 +290,7 @@ export class MSSQLProvider extends SQLBaseProvider {
         ORDER BY s.name, t.name
       `);
       const tables = tablesRes.recordset || [];
-
-      // Get columns
-      const colsRes = await this.pool!.request().query(`
+      const colsRes = await this.pool.request().query(`
         SELECT
           TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE,
           IS_NULLABLE, COLUMN_DEFAULT, ORDINAL_POSITION
@@ -406,9 +298,7 @@ export class MSSQLProvider extends SQLBaseProvider {
         ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
       `);
       const allCols = colsRes.recordset || [];
-
-      // Get primary keys
-      const pkRes = await this.pool!.request().query(`
+      const pkRes = await this.pool.request().query(`
         SELECT
           s.name AS schema_name,
           t.name AS table_name,
@@ -420,15 +310,13 @@ export class MSSQLProvider extends SQLBaseProvider {
         JOIN sys.schemas s ON t.schema_id = s.schema_id
         WHERE i.is_primary_key = 1
       `);
-      const pkMap = new Map<string, Set<string>>();
+      const pkMap = /* @__PURE__ */ new Map();
       for (const row of pkRes.recordset || []) {
         const key = `${row.schema_name}.${row.table_name}`;
-        if (!pkMap.has(key)) pkMap.set(key, new Set());
-        pkMap.get(key)!.add(row.column_name);
+        if (!pkMap.has(key)) pkMap.set(key, /* @__PURE__ */ new Set());
+        pkMap.get(key).add(row.column_name);
       }
-
-      // Get foreign keys
-      const fkRes = await this.pool!.request().query(`
+      const fkRes = await this.pool.request().query(`
         SELECT
           OBJECT_SCHEMA_NAME(fk.parent_object_id) AS schema_name,
           OBJECT_NAME(fk.parent_object_id) AS table_name,
@@ -438,19 +326,17 @@ export class MSSQLProvider extends SQLBaseProvider {
         FROM sys.foreign_keys fk
         JOIN sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id
       `);
-      const fksByTable = new Map<string, Array<{ columnName: string; referencedTable: string; referencedColumn: string }>>();
+      const fksByTable = /* @__PURE__ */ new Map();
       for (const row of fkRes.recordset || []) {
         const key = `${row.schema_name}.${row.table_name}`;
         if (!fksByTable.has(key)) fksByTable.set(key, []);
-        fksByTable.get(key)!.push({
+        fksByTable.get(key).push({
           columnName: row.column_name,
           referencedTable: row.ref_table,
-          referencedColumn: row.ref_column,
+          referencedColumn: row.ref_column
         });
       }
-
-      // Get indexes
-      const idxRes = await this.pool!.request().query(`
+      const idxRes = await this.pool.request().query(`
         SELECT
           s.name AS schema_name,
           t.name AS table_name,
@@ -466,99 +352,85 @@ export class MSSQLProvider extends SQLBaseProvider {
         WHERE i.name IS NOT NULL AND i.is_primary_key = 0
         ORDER BY s.name, t.name, i.name, ic.key_ordinal
       `);
-
-      const idxByTable = new Map<string, Map<string, { unique: boolean; columns: string[] }>>();
+      const idxByTable = /* @__PURE__ */ new Map();
       for (const row of idxRes.recordset || []) {
         const key = `${row.schema_name}.${row.table_name}`;
-        if (!idxByTable.has(key)) idxByTable.set(key, new Map());
-        const tableIdxs = idxByTable.get(key)!;
+        if (!idxByTable.has(key)) idxByTable.set(key, /* @__PURE__ */ new Map());
+        const tableIdxs = idxByTable.get(key);
         if (!tableIdxs.has(row.index_name)) {
           tableIdxs.set(row.index_name, { unique: row.is_unique, columns: [] });
         }
-        tableIdxs.get(row.index_name)!.columns.push(row.column_name);
+        tableIdxs.get(row.index_name).columns.push(row.column_name);
       }
-
-      // Group columns by table
-      const colsByTable = new Map<string, typeof allCols>();
+      const colsByTable = /* @__PURE__ */ new Map();
       for (const c of allCols) {
         const key = `${c.TABLE_SCHEMA}.${c.TABLE_NAME}`;
         if (!colsByTable.has(key)) colsByTable.set(key, []);
-        colsByTable.get(key)!.push(c);
+        colsByTable.get(key).push(c);
       }
-
-      return tables.map((t: Record<string, unknown>) => {
-        const schemaName = String(t.schema_name || 'dbo');
-        const tableName = String(t.table_name || '');
+      return tables.map((t) => {
+        const schemaName = String(t.schema_name || "dbo");
+        const tableName = String(t.table_name || "");
         const key = `${schemaName}.${tableName}`;
-        const displayName = schemaName === 'dbo' ? tableName : `${schemaName}.${tableName}`;
-        const pks = pkMap.get(key) || new Set();
-
-        const columns = (colsByTable.get(key) || []).map((c: Record<string, unknown>) => ({
-          name: String(c.COLUMN_NAME || ''),
-          type: String(c.DATA_TYPE || ''),
-          nullable: String(c.IS_NULLABLE || '') === 'YES',
-          isPrimary: pks.has(String(c.COLUMN_NAME || '')),
-          defaultValue: c.COLUMN_DEFAULT ? String(c.COLUMN_DEFAULT) : undefined,
+        const displayName = schemaName === "dbo" ? tableName : `${schemaName}.${tableName}`;
+        const pks = pkMap.get(key) || /* @__PURE__ */ new Set();
+        const columns = (colsByTable.get(key) || []).map((c) => ({
+          name: String(c.COLUMN_NAME || ""),
+          type: String(c.DATA_TYPE || ""),
+          nullable: String(c.IS_NULLABLE || "") === "YES",
+          isPrimary: pks.has(String(c.COLUMN_NAME || "")),
+          defaultValue: c.COLUMN_DEFAULT ? String(c.COLUMN_DEFAULT) : void 0
         }));
-
         const foreignKeys = fksByTable.get(key) || [];
-
-        const tableIdxs = idxByTable.get(key) || new Map();
+        const tableIdxs = idxByTable.get(key) || /* @__PURE__ */ new Map();
         const indexes = Array.from(tableIdxs.entries()).map(([name, info]) => ({
           name,
           columns: info.columns,
-          unique: info.unique,
+          unique: info.unique
         }));
-
         return {
           name: displayName,
           rowCount: Number(t.row_count || 0),
           columns,
           indexes,
-          foreignKeys,
+          foreignKeys
         };
       });
     } catch (error) {
-      throw mapDatabaseError(error, 'mssql');
+      throw mapDatabaseError(error, "mssql");
     }
   }
-
   // ============================================================================
   // Health & Monitoring
   // ============================================================================
-
-  public async getHealth(): Promise<HealthInfo> {
+  async getHealth() {
+    var _a, _b, _c;
     this.ensureConnected();
-
     try {
       let activeConnections = 0;
-      let databaseSize = 'N/A';
-      let cacheHitRatio = 'N/A';
-      const slowQueries: SlowQuery[] = [];
-      const activeSessions: ActiveSession[] = [];
-
-      // Active connections
+      let databaseSize = "N/A";
+      let cacheHitRatio = "N/A";
+      const slowQueries = [];
+      const activeSessions = [];
       try {
-        const connRes = await this.pool!.request().query(
+        const connRes = await this.pool.request().query(
           `SELECT COUNT(*) AS cnt FROM sys.dm_exec_sessions WHERE is_user_process = 1`
         );
-        activeConnections = connRes.recordset[0]?.cnt || 0;
-      } catch { /* DMV may require permissions */ }
-
-      // Database size
+        activeConnections = ((_a = connRes.recordset[0]) == null ? void 0 : _a.cnt) || 0;
+      } catch (e) {
+      }
       try {
-        const sizeRes = await this.pool!.request().query(`
+        const sizeRes = await this.pool.request().query(`
           SELECT
             CAST(SUM(size) * 8.0 / 1024 AS DECIMAL(10,2)) AS size_mb
           FROM sys.database_files
         `);
-        const mb = Number(sizeRes.recordset[0]?.size_mb || 0);
+        const mb = Number(((_b = sizeRes.recordset[0]) == null ? void 0 : _b.size_mb) || 0);
         databaseSize = mb > 1024 ? `${(mb / 1024).toFixed(2)} GB` : `${mb} MB`;
-      } catch { /* ignore */ }
-
-      // Cache hit ratio
+      } catch (e) {
+      }
       try {
-        const cacheRes = await this.pool!.request().query(`
+        const cacheRes = await this.pool.request().query(`
           SELECT
             CAST(
               (a.cntr_value * 1.0 / NULLIF(b.cntr_value, 0)) * 100
@@ -571,12 +443,11 @@ export class MSSQLProvider extends SQLBaseProvider {
             AND b.counter_name = 'Buffer cache hit ratio base'
             AND b.object_name LIKE '%Buffer Manager%'
         `);
-        cacheHitRatio = `${cacheRes.recordset[0]?.hit_ratio || 0}%`;
-      } catch { /* ignore */ }
-
-      // Slow queries
+        cacheHitRatio = `${((_c = cacheRes.recordset[0]) == null ? void 0 : _c.hit_ratio) || 0}%`;
+      } catch (e) {
+      }
       try {
-        const slowRes = await this.pool!.request().query(`
+        const slowRes = await this.pool.request().query(`
           SELECT TOP 5
             SUBSTRING(qt.text, 1, 100) AS query,
             qs.execution_count AS calls,
@@ -588,16 +459,15 @@ export class MSSQLProvider extends SQLBaseProvider {
         `);
         for (const row of slowRes.recordset || []) {
           slowQueries.push({
-            query: String(row.query || ''),
+            query: String(row.query || ""),
             calls: Number(row.calls || 0),
-            avgTime: `${row.avg_time_ms}ms`,
+            avgTime: `${row.avg_time_ms}ms`
           });
         }
-      } catch { /* DMV permissions */ }
-
-      // Active sessions
+      } catch (e) {
+      }
       try {
-        const sessRes = await this.pool!.request().query(`
+        const sessRes = await this.pool.request().query(`
           SELECT TOP 10
             s.session_id AS pid,
             s.login_name AS [user],
@@ -614,48 +484,43 @@ export class MSSQLProvider extends SQLBaseProvider {
         for (const row of sessRes.recordset || []) {
           activeSessions.push({
             pid: Number(row.pid || 0),
-            user: String(row.user || 'unknown'),
-            database: String(row.database || ''),
-            state: String(row.state || 'unknown'),
-            query: String(row.query || ''),
-            duration: String(row.duration || 'N/A'),
+            user: String(row.user || "unknown"),
+            database: String(row.database || ""),
+            state: String(row.state || "unknown"),
+            query: String(row.query || ""),
+            duration: String(row.duration || "N/A")
           });
         }
-      } catch { /* ignore */ }
-
+      } catch (e) {
+      }
       return { activeConnections, databaseSize, cacheHitRatio, slowQueries, activeSessions };
     } catch (error) {
-      throw mapDatabaseError(error, 'mssql');
+      throw mapDatabaseError(error, "mssql");
     }
   }
-
   // ============================================================================
   // Maintenance Operations
   // ============================================================================
-
-  public async runMaintenance(type: MaintenanceType, target?: string): Promise<MaintenanceResult> {
+  async runMaintenance(type, target) {
     this.ensureConnected();
-
     const { result, executionTime } = await this.measureExecution(async () => {
       try {
-        let sql = '';
-
+        let sql = "";
         switch (type) {
-          case 'analyze':
+          case "analyze":
             if (target) {
-              sql = `UPDATE STATISTICS [${target.replace(/\]/g, ']]')}]`;
+              sql = `UPDATE STATISTICS [${target.replace(/\]/g, "]]")}]`;
             } else {
               sql = `EXEC sp_updatestats`;
             }
             break;
-          case 'check':
+          case "check":
             sql = `DBCC CHECKDB WITH NO_INFOMSGS`;
             break;
-          case 'optimize':
+          case "optimize":
             if (target) {
-              sql = `ALTER INDEX ALL ON [${target.replace(/\]/g, ']]')}] REBUILD`;
+              sql = `ALTER INDEX ALL ON [${target.replace(/\]/g, "]]")}] REBUILD`;
             } else {
-              // Rebuild all indexes on all tables
               sql = `
                 DECLARE @sql NVARCHAR(MAX) = '';
                 SELECT @sql = @sql + 'ALTER INDEX ALL ON [' + s.name + '].[' + t.name + '] REBUILD;'
@@ -666,78 +531,68 @@ export class MSSQLProvider extends SQLBaseProvider {
               `;
             }
             break;
-          case 'kill':
+          case "kill":
             if (!target) {
-              throw new QueryError('Target SPID is required for kill operation', 'mssql');
+              throw new QueryError("Target SPID is required for kill operation", "mssql");
             }
             const spid = parseInt(target, 10);
             if (isNaN(spid)) {
-              throw new QueryError('Invalid SPID for kill operation', 'mssql');
+              throw new QueryError("Invalid SPID for kill operation", "mssql");
             }
             sql = `KILL ${spid}`;
             break;
           default:
-            throw new QueryError(`Unsupported maintenance type: ${type}`, 'mssql');
+            throw new QueryError(`Unsupported maintenance type: ${type}`, "mssql");
         }
-
-        await this.pool!.request().query(sql);
+        await this.pool.request().query(sql);
         return { success: true };
       } catch (error) {
-        throw mapDatabaseError(error, 'mssql');
+        throw mapDatabaseError(error, "mssql");
       }
     });
-
     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.size,
       idle: this.pool.available,
       active: this.pool.size - this.pool.available,
-      waiting: this.pool.pending,
+      waiting: this.pool.pending
     };
   }
-
   // ============================================================================
   // Extended Monitoring Methods
   // ============================================================================
-
-  public async getOverview(): Promise<DatabaseOverview> {
+  async getOverview() {
+    var _a, _b, _c, _d, _e, _f;
     this.ensureConnected();
-
     try {
-      let version = 'SQL Server';
-      let uptime = 'N/A';
-      let startTime: Date | undefined;
+      let version = "SQL Server";
+      let uptime = "N/A";
+      let startTime;
       let activeConnections = 0;
       let maxConnections = 0;
-      let databaseSize = '0 bytes';
+      let databaseSize = "0 bytes";
       let databaseSizeBytes = 0;
       let tableCount = 0;
       let indexCount = 0;
-
-      // Version
       try {
-        const vRes = await this.pool!.request().query(`SELECT @@VERSION AS version`);
-        version = String(vRes.recordset[0]?.version || '').split('\n')[0];
-      } catch { /* ignore */ }
-
-      // Uptime
+        const vRes = await this.pool.request().query(`SELECT @@VERSION AS version`);
+        version = String(((_a = vRes.recordset[0]) == null ? void 0 : _a.version) || "").split("\n")[0];
+      } catch (e) {
+      }
       try {
-        const upRes = await this.pool!.request().query(`
+        const upRes = await this.pool.request().query(`
           SELECT sqlserver_start_time,
                  DATEDIFF(SECOND, sqlserver_start_time, GETDATE()) AS uptime_seconds
           FROM sys.dm_os_sys_info
@@ -745,65 +600,67 @@ export class MSSQLProvider extends SQLBaseProvider {
         if (upRes.recordset[0]) {
           const secs = Number(upRes.recordset[0].uptime_seconds || 0);
           const days = Math.floor(secs / 86400);
-          const hours = Math.floor((secs % 86400) / 3600);
-          const minutes = Math.floor((secs % 3600) / 60);
+          const hours = Math.floor(secs % 86400 / 3600);
+          const minutes = Math.floor(secs % 3600 / 60);
           uptime = days > 0 ? `${days}d ${hours}h ${minutes}m` : hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
           startTime = new Date(upRes.recordset[0].sqlserver_start_time);
         }
-      } catch { /* ignore */ }
-
-      // Connections
+      } catch (e) {
+      }
       try {
-        const connRes = await this.pool!.request().query(`
+        const connRes = await this.pool.request().query(`
           SELECT
             COUNT(*) AS active_connections,
             (SELECT CAST(value_in_use AS INT) FROM sys.configurations WHERE name = 'user connections') AS max_connections
           FROM sys.dm_exec_sessions
           WHERE is_user_process = 1
         `);
-        activeConnections = Number(connRes.recordset[0]?.active_connections || 0);
-        maxConnections = Number(connRes.recordset[0]?.max_connections || 32767);
-        if (maxConnections === 0) maxConnections = 32767; // 0 means unlimited
-      } catch { /* ignore */ }
-
-      // Database size
+        activeConnections = Number(((_b = connRes.recordset[0]) == null ? void 0 : _b.active_connections) || 0);
+        maxConnections = Number(((_c = connRes.recordset[0]) == null ? void 0 : _c.max_connections) || 32767);
+        if (maxConnections === 0) maxConnections = 32767;
+      } catch (e) {
+      }
       try {
-        const sizeRes = await this.pool!.request().query(`
+        const sizeRes = await this.pool.request().query(`
           SELECT SUM(CAST(size AS BIGINT)) * 8 * 1024 AS size_bytes FROM sys.database_files
         `);
-        databaseSizeBytes = Number(sizeRes.recordset[0]?.size_bytes || 0);
+        databaseSizeBytes = Number(((_d = sizeRes.recordset[0]) == null ? void 0 : _d.size_bytes) || 0);
         databaseSize = formatBytes(databaseSizeBytes);
-      } catch { /* ignore */ }
-
-      // Table/index counts
+      } catch (e) {
+      }
       try {
-        const cntRes = await this.pool!.request().query(`
+        const cntRes = await this.pool.request().query(`
           SELECT
             (SELECT COUNT(*) FROM sys.tables WHERE type = 'U') AS table_count,
             (SELECT COUNT(*) FROM sys.indexes WHERE object_id IN (SELECT object_id FROM sys.tables WHERE type = 'U') AND name IS NOT NULL) AS index_count
         `);
-        tableCount = Number(cntRes.recordset[0]?.table_count || 0);
-        indexCount = Number(cntRes.recordset[0]?.index_count || 0);
-      } catch { /* ignore */ }
-
+        tableCount = Number(((_e = cntRes.recordset[0]) == null ? void 0 : _e.table_count) || 0);
+        indexCount = Number(((_f = cntRes.recordset[0]) == null ? void 0 : _f.index_count) || 0);
+      } catch (e) {
+      }
       return {
-        version, uptime, startTime, activeConnections, maxConnections,
-        databaseSize, databaseSizeBytes, tableCount, indexCount,
+        version,
+        uptime,
+        startTime,
+        activeConnections,
+        maxConnections,
+        databaseSize,
+        databaseSizeBytes,
+        tableCount,
+        indexCount
       };
     } catch (error) {
-      throw mapDatabaseError(error, 'mssql');
+      throw mapDatabaseError(error, "mssql");
     }
   }
-
-  public async getPerformanceMetrics(): Promise<PerformanceMetrics> {
+  async getPerformanceMetrics() {
+    var _a;
     this.ensureConnected();
-
     try {
       let cacheHitRatio = 100;
-      let bufferPoolUsage: number | undefined;
-
+      let bufferPoolUsage;
       try {
-        const cacheRes = await this.pool!.request().query(`
+        const cacheRes = await this.pool.request().query(`
           SELECT
             CAST(
               (a.cntr_value * 1.0 / NULLIF(b.cntr_value, 0)) * 100
@@ -816,25 +673,24 @@ export class MSSQLProvider extends SQLBaseProvider {
             AND b.counter_name = 'Buffer cache hit ratio base'
             AND b.object_name LIKE '%Buffer Manager%'
         `);
-        cacheHitRatio = Number(cacheRes.recordset[0]?.hit_ratio || 100);
+        cacheHitRatio = Number(((_a = cacheRes.recordset[0]) == null ? void 0 : _a.hit_ratio) || 100);
         bufferPoolUsage = cacheHitRatio;
-      } catch { /* ignore */ }
-
+      } catch (e) {
+      }
       return {
         cacheHitRatio,
-        bufferPoolUsage,
+        bufferPoolUsage
       };
     } catch (error) {
-      throw mapDatabaseError(error, 'mssql');
+      throw mapDatabaseError(error, "mssql");
     }
   }
-
-  public async getSlowQueries(options?: { limit?: number }): Promise<SlowQueryStats[]> {
+  async getSlowQueries(options) {
+    var _a;
     this.ensureConnected();
-    const limit = options?.limit ?? 10;
-
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 10;
     try {
-      const res = await this.pool!.request().query(`
+      const res = await this.pool.request().query(`
         SELECT TOP ${limit}
           CAST(qs.query_hash AS VARCHAR(50)) AS query_id,
           SUBSTRING(qt.text, 1, 500) AS query,
@@ -851,10 +707,9 @@ export class MSSQLProvider extends SQLBaseProvider {
         WHERE qs.execution_count > 0
         ORDER BY qs.total_elapsed_time DESC
       `);
-
-      return (res.recordset || []).map((r: Record<string, unknown>) => ({
-        queryId: String(r.query_id || ''),
-        query: String(r.query || ''),
+      return (res.recordset || []).map((r) => ({
+        queryId: String(r.query_id || ""),
+        query: String(r.query || ""),
         calls: Number(r.calls || 0),
         totalTime: Number(r.total_time || 0),
         avgTime: Number(r.avg_time || 0),
@@ -862,19 +717,18 @@ export class MSSQLProvider extends SQLBaseProvider {
         maxTime: Number(r.max_time || 0),
         rows: Number(r.row_cnt || 0),
         sharedBlksHit: Number(r.logical_reads || 0),
-        sharedBlksRead: Number(r.physical_reads || 0),
+        sharedBlksRead: Number(r.physical_reads || 0)
       }));
-    } catch {
+    } catch (e) {
       return [];
     }
   }
-
-  public async getActiveSessions(options?: { limit?: number }): Promise<ActiveSessionDetails[]> {
+  async getActiveSessions(options) {
+    var _a;
     this.ensureConnected();
-    const limit = options?.limit ?? 50;
-
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 50;
     try {
-      const res = await this.pool!.request().query(`
+      const res = await this.pool.request().query(`
         SELECT TOP ${limit}
           s.session_id AS pid,
           s.login_name AS [user],
@@ -897,32 +751,29 @@ export class MSSQLProvider extends SQLBaseProvider {
           CASE s.status WHEN 'running' THEN 0 WHEN 'sleeping' THEN 1 ELSE 2 END,
           s.last_request_start_time DESC
       `);
-
-      return (res.recordset || []).map((r: Record<string, unknown>) => ({
+      return (res.recordset || []).map((r) => ({
         pid: Number(r.pid || 0),
-        user: String(r.user || 'unknown'),
-        database: String(r.database || ''),
-        applicationName: r.application_name ? String(r.application_name) : undefined,
-        clientAddr: r.client_addr ? String(r.client_addr) : undefined,
-        state: String(r.state || 'unknown'),
-        query: String(r.query || ''),
-        queryStart: r.query_start ? new Date(String(r.query_start)) : undefined,
-        duration: String(r.duration || 'N/A'),
+        user: String(r.user || "unknown"),
+        database: String(r.database || ""),
+        applicationName: r.application_name ? String(r.application_name) : void 0,
+        clientAddr: r.client_addr ? String(r.client_addr) : void 0,
+        state: String(r.state || "unknown"),
+        query: String(r.query || ""),
+        queryStart: r.query_start ? new Date(String(r.query_start)) : void 0,
+        duration: String(r.duration || "N/A"),
         durationMs: Number(r.duration_ms || 0),
-        waitEventType: r.wait_type ? String(r.wait_type) : undefined,
-        waitEvent: r.last_wait_type ? String(r.last_wait_type) : undefined,
-        blocked: Boolean(r.is_blocked),
+        waitEventType: r.wait_type ? String(r.wait_type) : void 0,
+        waitEvent: r.last_wait_type ? String(r.last_wait_type) : void 0,
+        blocked: Boolean(r.is_blocked)
       }));
-    } catch {
+    } catch (e) {
       return [];
     }
   }
-
-  public async getTableStats(): Promise<TableStats[]> {
+  async getTableStats() {
     this.ensureConnected();
-
     try {
-      const res = await this.pool!.request().query(`
+      const res = await this.pool.request().query(`
         SELECT
           s.name AS schema_name,
           t.name AS table_name,
@@ -941,14 +792,13 @@ export class MSSQLProvider extends SQLBaseProvider {
         GROUP BY s.name, t.name, t.object_id
         ORDER BY SUM(a.total_pages) DESC
       `);
-
-      return (res.recordset || []).map((r: Record<string, unknown>) => {
+      return (res.recordset || []).map((r) => {
         const tableSizeBytes = Number(r.table_size_bytes || 0);
         const indexSizeBytes = Number(r.index_size_bytes || 0);
         const totalSizeBytes = Number(r.total_size_bytes || 0);
         return {
-          schemaName: String(r.schema_name || 'dbo'),
-          tableName: String(r.table_name || ''),
+          schemaName: String(r.schema_name || "dbo"),
+          tableName: String(r.table_name || ""),
           rowCount: Number(r.row_count || 0),
           tableSize: formatBytes(tableSizeBytes),
           tableSizeBytes,
@@ -956,19 +806,17 @@ export class MSSQLProvider extends SQLBaseProvider {
           indexSizeBytes,
           totalSize: formatBytes(totalSizeBytes),
           totalSizeBytes,
-          lastAnalyze: r.last_stats_update ? new Date(String(r.last_stats_update)) : undefined,
+          lastAnalyze: r.last_stats_update ? new Date(String(r.last_stats_update)) : void 0
         };
       });
-    } catch {
+    } catch (e) {
       return [];
     }
   }
-
-  public async getIndexStats(): Promise<IndexStats[]> {
+  async getIndexStats() {
     this.ensureConnected();
-
     try {
-      const res = await this.pool!.request().query(`
+      const res = await this.pool.request().query(`
         SELECT
           s.name AS schema_name,
           t.name AS table_name,
@@ -989,9 +837,7 @@ export class MSSQLProvider extends SQLBaseProvider {
                  i.object_id, i.index_id, u.user_seeks, u.user_scans, u.user_lookups
         ORDER BY SUM(a.total_pages) DESC
       `);
-
-      // Get columns for each index
-      const colRes = await this.pool!.request().query(`
+      const colRes = await this.pool.request().query(`
         SELECT
           s.name AS schema_name,
           t.name AS table_name,
@@ -1006,40 +852,36 @@ export class MSSQLProvider extends SQLBaseProvider {
         WHERE i.name IS NOT NULL AND t.type = 'U'
         ORDER BY s.name, t.name, i.name, ic.key_ordinal
       `);
-
-      const colMap = new Map<string, string[]>();
+      const colMap = /* @__PURE__ */ new Map();
       for (const c of colRes.recordset || []) {
         const key = `${c.schema_name}.${c.table_name}.${c.index_name}`;
         if (!colMap.has(key)) colMap.set(key, []);
-        colMap.get(key)!.push(String(c.column_name));
+        colMap.get(key).push(String(c.column_name));
       }
-
-      return (res.recordset || []).map((r: Record<string, unknown>) => {
+      return (res.recordset || []).map((r) => {
         const key = `${r.schema_name}.${r.table_name}.${r.index_name}`;
         const idxSizeBytes = Number(r.index_size_bytes || 0);
         return {
-          schemaName: String(r.schema_name || 'dbo'),
-          tableName: String(r.table_name || ''),
-          indexName: String(r.index_name || ''),
-          indexType: String(r.index_type || ''),
+          schemaName: String(r.schema_name || "dbo"),
+          tableName: String(r.table_name || ""),
+          indexName: String(r.index_name || ""),
+          indexType: String(r.index_type || ""),
           columns: colMap.get(key) || [],
           isUnique: Boolean(r.is_unique),
           isPrimary: Boolean(r.is_primary_key),
           indexSize: formatBytes(idxSizeBytes),
           indexSizeBytes: idxSizeBytes,
-          scans: Number(r.scans || 0),
+          scans: Number(r.scans || 0)
         };
       });
-    } catch {
+    } catch (e) {
       return [];
     }
   }
-
-  public async getStorageStats(): Promise<StorageStats[]> {
+  async getStorageStats() {
     this.ensureConnected();
-
     try {
-      const res = await this.pool!.request().query(`
+      const res = await this.pool.request().query(`
         SELECT
           name,
           physical_name AS location,
@@ -1048,18 +890,21 @@ export class MSSQLProvider extends SQLBaseProvider {
         FROM sys.database_files
         ORDER BY size DESC
       `);
-
-      return (res.recordset || []).map((r: Record<string, unknown>) => {
+      return (res.recordset || []).map((r) => {
         const sizeBytes = Number(r.size_bytes || 0);
         return {
-          name: String(r.name || ''),
-          location: String(r.location || ''),
+          name: String(r.name || ""),
+          location: String(r.location || ""),
           size: formatBytes(sizeBytes),
-          sizeBytes,
+          sizeBytes
         };
       });
-    } catch {
+    } catch (e) {
       return [];
     }
   }
-}
+};
+
+export { MSSQLProvider };
+//# sourceMappingURL=mssql-ZH5VP2C5.mjs.map
+//# sourceMappingURL=mssql-ZH5VP2C5.mjs.map