db-mcp 4.0.0 → 5.0.0

package/dist/server/registration/audit-tools/search.d.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { AuditLogger } from "../../../audit/logger.js";
+/**
+ * Register the sqlite_audit_search tool.
+ */
+export declare function registerAuditSearchTool(server: McpServer, auditLogger: AuditLogger | null): void;
+//# sourceMappingURL=search.d.ts.map

package/dist/server/registration/audit-tools/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/server/registration/audit-tools/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAe5D;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,WAAW,GAAG,IAAI,GAC9B,IAAI,CA6EN"}

package/dist/server/registration/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./built-in-tools.js";
 export * from "./help-resources.js";
-export { registerAuditResource, registerAuditBackupTools, registerAuditSearchTool, } from "./audit-tools.js";
+export { registerAuditResource, registerAuditBackupTools, registerAuditSearchTool, } from "./audit-tools/index.js";
 export * from "./observability-resources.js";
 export * from "./admin-tools.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/registration/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/registration/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAC1B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/registration/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,wBAAwB,CAAC;AAChC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC"}

package/dist/{sqlite-D4WCNPU4.js → sqlite-XWZPEZJO.js}

@@ -1,8 +1,8 @@
-import { getCoreTools, getJsonHelperTools, getJsonOperationTools, getTextTools, getStatsTools, getVirtualTools, getVectorTools, getGeoTools, getAdminTools, getIntrospectionTools, getMigrationTools, getCodeModeTools, executeRead, executeWrite, isDDL, executeGeneral, getResourceDefinitions, getPromptDefinitions, applyCommonPragmas, autoEnableWal, detectAndSetJsonbSupport, SchemaManager } from './chunk-TGE7LFAR.js';
-export { getCoreTools } from './chunk-TGE7LFAR.js';
-import { DatabaseAdapter } from './chunk-EQF3WZHX.js';
-import { getToolGroupIcon, VERSION } from './chunk-R5M4WKDM.js';
-import { createModuleLogger, ConnectionError, ConfigurationError, ERROR_CODES, DbMcpError } from './chunk-Y57WFKAP.js';
+import { getCoreTools, getJsonHelperTools, getJsonOperationTools, getTextTools, getStatsTools, getVirtualTools, getVectorTools, getGeoTools, getAdminTools, getIntrospectionTools, getMigrationTools, getCodeModeTools, executeRead, executeWrite, isDDL, executeGeneral, getResourceDefinitions, getPromptDefinitions, applyCommonPragmas, autoEnableWal, detectAndSetJsonbSupport, SchemaManager } from './chunk-UE7GVOBV.js';
+export { getCoreTools } from './chunk-UE7GVOBV.js';
+import { DatabaseAdapter } from './chunk-27C5EE6U.js';
+import { getToolGroupIcon, VERSION } from './chunk-2TYICG7B.js';
+import { createModuleLogger, ConnectionError, ConfigurationError, ERROR_CODES, DbMcpError, ErrorCategory } from './chunk-XLIYO3YA.js';
 import initSqlJs from 'sql.js';
 
 // src/adapters/sqlite/tools/index.ts
@@ -34,6 +34,142 @@ function getAllToolDefinitions(adapter) {
 function getToolsByGroup(adapter, group) {
   return getAllToolDefinitions(adapter).filter((tool) => tool.group === group);
 }
+
+// src/adapters/sqlite/read-write-lock.ts
+var ReadWriteLock = class {
+  activeReaders = 0;
+  isWriting = false;
+  readWaiters = [];
+  readHead = 0;
+  writeWaiters = [];
+  writeHead = 0;
+  maxConcurrentReaders;
+  consecutiveWriters = 0;
+  MAX_CONSECUTIVE_WRITERS = 5;
+  constructor(options) {
+    this.maxConcurrentReaders = options?.maxConcurrentReaders ?? 10;
+  }
+  /**
+   * Acquire a read lock.
+   * Multiple readers can acquire the lock simultaneously up to maxConcurrentReaders.
+   * If a writer is currently active OR there are writers waiting (fairness),
+   * the read request is queued.
+   */
+  async acquireRead() {
+    return new Promise((resolve, reject) => {
+      const grantRead = () => {
+        this.activeReaders++;
+        let released = false;
+        resolve(() => {
+          if (released) return;
+          released = true;
+          this.releaseRead();
+        });
+      };
+      const writersWaiting = this.writeWaiters.length - this.writeHead > 0;
+      if (this.isWriting || writersWaiting && this.consecutiveWriters < this.MAX_CONSECUTIVE_WRITERS || this.activeReaders >= this.maxConcurrentReaders) {
+        this.readWaiters.push({ resolve: grantRead, reject });
+      } else {
+        grantRead();
+      }
+    });
+  }
+  /**
+   * Acquire a write lock.
+   * Writers have exclusive access.
+   * If there are active readers or an active writer, the write request is queued.
+   */
+  async acquireWrite() {
+    return new Promise((resolve, reject) => {
+      const grantWrite = () => {
+        this.isWriting = true;
+        this.consecutiveWriters++;
+        let released = false;
+        resolve(() => {
+          if (released) return;
+          released = true;
+          this.releaseWrite();
+        });
+      };
+      if (this.isWriting || this.activeReaders > 0) {
+        this.writeWaiters.push({ resolve: grantWrite, reject });
+      } else {
+        grantWrite();
+      }
+    });
+  }
+  releaseRead() {
+    this.activeReaders--;
+    this.processQueues();
+  }
+  releaseWrite() {
+    this.isWriting = false;
+    this.processQueues();
+  }
+  popReader() {
+    if (this.readHead >= this.readWaiters.length) return void 0;
+    const req = this.readWaiters[this.readHead++];
+    if (this.readHead > 100) {
+      this.readWaiters = this.readWaiters.slice(this.readHead);
+      this.readHead = 0;
+    }
+    return req;
+  }
+  popWriter() {
+    if (this.writeHead >= this.writeWaiters.length) return void 0;
+    const req = this.writeWaiters[this.writeHead++];
+    if (this.writeHead > 100) {
+      this.writeWaiters = this.writeWaiters.slice(this.writeHead);
+      this.writeHead = 0;
+    }
+    return req;
+  }
+  processQueues() {
+    const writersWaiting = this.writeWaiters.length - this.writeHead > 0;
+    const readersWaiting = this.readWaiters.length - this.readHead > 0;
+    if (!writersWaiting || readersWaiting && this.consecutiveWriters >= this.MAX_CONSECUTIVE_WRITERS) {
+      this.consecutiveWriters = 0;
+    }
+    if (writersWaiting && this.activeReaders === 0 && !this.isWriting && this.consecutiveWriters < this.MAX_CONSECUTIVE_WRITERS) {
+      const nextWriter = this.popWriter();
+      nextWriter?.resolve(() => void 0);
+      return;
+    }
+    if (!this.isWriting && (!writersWaiting || this.consecutiveWriters >= this.MAX_CONSECUTIVE_WRITERS)) {
+      while (this.readWaiters.length - this.readHead > 0 && this.activeReaders < this.maxConcurrentReaders) {
+        const nextReader = this.popReader();
+        nextReader?.resolve(() => void 0);
+      }
+    }
+  }
+  /**
+   * Get current lock statistics
+   */
+  getStats() {
+    return {
+      activeReaders: this.activeReaders,
+      isWriting: this.isWriting,
+      waitingReaders: this.readWaiters.length - this.readHead,
+      waitingWriters: this.writeWaiters.length - this.writeHead
+    };
+  }
+  /**
+   * Force release all waiting locks (useful for shutdown)
+   */
+  dispose() {
+    const cancelError = new ConnectionError("Database connection shutting down", "CONNECTION_CLOSED");
+    for (let i = this.readHead; i < this.readWaiters.length; i++) {
+      this.readWaiters[i]?.reject(cancelError);
+    }
+    for (let i = this.writeHead; i < this.writeWaiters.length; i++) {
+      this.writeWaiters[i]?.reject(cancelError);
+    }
+    this.readWaiters = [];
+    this.readHead = 0;
+    this.writeWaiters = [];
+    this.writeHead = 0;
+  }
+};
 var log = createModuleLogger("SQLITE");
 var _sqlJsPromise = null;
 function getSqlJs() {
@@ -168,7 +304,7 @@ async function fallBackDescribeTable(adapter, tableName) {
     throw new DbMcpError(
       "Invalid table name",
       "SQLITE_INVALID_TABLE",
-      "validation" /* VALIDATION */
+      ErrorCategory.VALIDATION
     );
   }
   const result = await adapter.executeReadQuery(
@@ -248,6 +384,7 @@ async function fallBackGetIndexes(adapter, table) {
 }
 
 // src/adapters/sqlite/sqlite-adapter.ts
+var DDL_NAME_REGEX = /(?:table|view|index)\s+([a-zA-Z0-9_]+)/i;
 var SqliteAdapter = class extends DatabaseAdapter {
   type = "sqlite";
   name = "SQLite Adapter";
@@ -267,6 +404,7 @@ var SqliteAdapter = class extends DatabaseAdapter {
     return this.config?.filePath ?? this.config?.connectionString ?? ":memory:";
   }
   db = null;
+  rwLock = new ReadWriteLock();
   config = null;
   schemaManager = null;
   cachedToolDefinitions = null;
@@ -284,6 +422,7 @@ var SqliteAdapter = class extends DatabaseAdapter {
    * Disconnect from the database
    */
   async disconnect() {
+    this.rwLock.dispose();
     if (this.db) {
       await disconnectSqliteDatabase(this.db, this.config);
       this.db = null;
@@ -321,10 +460,15 @@ var SqliteAdapter = class extends DatabaseAdapter {
   /**
    * Execute a read-only query
    */
-  executeReadQuery(sql, params) {
+  async executeReadQuery(sql, params) {
     this.ensureConnected();
     this.validateQuery(sql, true);
-    return executeRead(this.ensureDb(), sql, params);
+    const release = await this.rwLock.acquireRead();
+    try {
+      return await executeRead(this.ensureDb(), sql, params);
+    } finally {
+      release();
+    }
   }
   /**
    * Execute a write query
@@ -332,9 +476,15 @@ var SqliteAdapter = class extends DatabaseAdapter {
   async executeWriteQuery(sql, params) {
     this.ensureConnected();
     this.validateQuery(sql, false);
-    const result = await executeWrite(this.ensureDb(), sql, params);
+    const release = await this.rwLock.acquireWrite();
+    let result;
+    try {
+      result = await executeWrite(this.ensureDb(), sql, params);
+    } finally {
+      release();
+    }
     if (isDDL(sql)) {
-      const match = /(?:table|view|index)\s+([a-zA-Z0-9_]+)/i.exec(sql);
+      const match = DDL_NAME_REGEX.exec(sql);
       if (match?.[1] && this.schemaManager) {
         this.schemaManager.clearTableCache(match[1]);
       } else {
@@ -350,9 +500,15 @@ var SqliteAdapter = class extends DatabaseAdapter {
   async executeQuery(sql, params) {
     this.ensureConnected();
     this.validateQuery(sql, false);
-    const result = await executeGeneral(this.ensureDb(), sql, params);
+    const release = await this.rwLock.acquireWrite();
+    let result;
+    try {
+      result = await executeGeneral(this.ensureDb(), sql, params);
+    } finally {
+      release();
+    }
     if (isDDL(sql)) {
-      const match = /(?:table|view|index)\s+([a-zA-Z0-9_]+)/i.exec(sql);
+      const match = DDL_NAME_REGEX.exec(sql);
       if (match?.[1] && this.schemaManager) {
         this.schemaManager.clearTableCache(match[1]);
       } else {
@@ -365,12 +521,16 @@ var SqliteAdapter = class extends DatabaseAdapter {
   /**
    * Execute a SQL script containing multiple statements
    */
-  executeScript(sql) {
+  async executeScript(sql) {
     this.ensureConnected();
-    this.ensureDb().run(sql);
+    const release = await this.rwLock.acquireWrite();
+    try {
+      this.ensureDb().run(sql);
+    } finally {
+      release();
+    }
     this.clearSchemaCache();
     this.emit("schemaChanged");
-    return Promise.resolve();
   }
   /**
    * Get full database schema (cached via SchemaManager)
@@ -451,8 +611,8 @@ var SqliteAdapter = class extends DatabaseAdapter {
       // SpatiaLite not bundled
       transactions: true,
       preparedStatements: true,
-      connectionPooling: false
-      // sql.js is single-connection
+      connectionPooling: true
+      // Managed by ReadWriteLock for WASM
     };
   }
   /**
@@ -550,6 +710,12 @@ var SqliteAdapter = class extends DatabaseAdapter {
     }
     return db;
   }
+  /**
+   * Get pool statistics
+   */
+  getPoolStats() {
+    return this.rwLock.getStats();
+  }
   /**
    * Get the raw database instance (for tools)
    */
@@ -559,8 +725,15 @@ var SqliteAdapter = class extends DatabaseAdapter {
   /**
    * Execute raw SQL and return results (for tools)
    */
-  rawQuery(sql, params) {
-    return executeGeneral(this.ensureDb(), sql, params);
+  async rawQuery(sql, params) {
+    const trimmed = sql.trim().toUpperCase();
+    const isRead = trimmed.startsWith("SELECT") || trimmed.startsWith("EXPLAIN") || trimmed.startsWith("PRAGMA") && !sql.includes("=");
+    const release = isRead ? await this.rwLock.acquireRead() : await this.rwLock.acquireWrite();
+    try {
+      return await executeGeneral(this.ensureDb(), sql, params);
+    } finally {
+      release();
+    }
   }
 };
 function createSqliteAdapter() {