react-native-sqlite-mcp 1.0.1 → 1.0.2

package/dist/db.js

@@ -1,89 +1,52 @@
-import sqlite3 from "sqlite3";
+import initSqlJs from "sql.js";
+import fs from "fs";
 import { logger } from "./logger.js";
-/**
- * Lightweight sqlite3 wrapper with Promise-based API.
- */
-export class Database {
-    db;
-    constructor(filename) {
-        this.db = new sqlite3.Database(filename);
-    }
-    all(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.db.all(sql, params, (err, rows) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(rows);
-            });
-        });
-    }
-    get(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.db.get(sql, params, (err, row) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(row);
-            });
-        });
-    }
-    close() {
-        return new Promise((resolve, reject) => {
-            this.db.close((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
+let SQL = null;
+async function getSqlJs() {
+    if (!SQL) {
+        SQL = await initSqlJs();
+        logger.debug("sql.js WASM engine initialized");
     }
+    return SQL;
 }
-const CACHE_TTL_MS = 60_000; // Close idle connections after 60s
+const CACHE_TTL_MS = 60_000;
 const connectionCache = new Map();
-function getCachedDb(dbPath) {
+async function getCachedDb(dbPath) {
     const existing = connectionCache.get(dbPath);
     if (existing) {
-        // Refresh the idle timer
         clearTimeout(existing.timer);
         existing.lastUsed = Date.now();
         existing.timer = setTimeout(() => evictConnection(dbPath), CACHE_TTL_MS);
         return existing.db;
     }
-    // Open a new connection
-    const db = new Database(dbPath);
+    const sqlJs = await getSqlJs();
+    const buffer = fs.readFileSync(dbPath);
+    const db = new sqlJs.Database(buffer);
     const timer = setTimeout(() => evictConnection(dbPath), CACHE_TTL_MS);
-    connectionCache.set(dbPath, { db, lastUsed: Date.now(), timer });
+    connectionCache.set(dbPath, { db, dbPath, lastUsed: Date.now(), timer });
     logger.debug(`Opened DB connection: ${dbPath}`);
     return db;
 }
-async function evictConnection(dbPath) {
+function evictConnection(dbPath) {
     const entry = connectionCache.get(dbPath);
     if (!entry)
         return;
     connectionCache.delete(dbPath);
     try {
-        await entry.db.close();
+        entry.db.close();
         logger.debug(`Closed idle DB connection: ${dbPath}`);
     }
     catch (e) {
         logger.warn(`Error closing DB: ${dbPath}`, { error: String(e) });
     }
 }
-/**
- * Close all cached connections. Called during graceful shutdown.
- */
 export async function closeAllConnections() {
     const paths = [...connectionCache.keys()];
     for (const p of paths) {
-        await evictConnection(p);
+        evictConnection(p);
     }
     logger.info(`Closed ${paths.length} cached DB connection(s)`);
 }
-// ---------------------------------------------------------------------------
-// Public query API
-// ---------------------------------------------------------------------------
-/** Query timeout — prevents stuck queries from blocking everything */
 const QUERY_TIMEOUT_MS = 30_000;
 function withTimeout(promise, ms, label) {
     return new Promise((resolve, reject) => {
@@ -95,26 +58,31 @@ function withTimeout(promise, ms, label) {
             .catch((err) => { clearTimeout(timer); reject(err); });
     });
 }
-/**
- * Executes a simple query on the database.
- */
+function runQuery(db, sql, params = []) {
+    const stmt = db.prepare(sql);
+    if (params.length > 0)
+        stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+        results.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return results;
+}
 export async function queryDb(dbPath, sql, params = []) {
-    const db = getCachedDb(dbPath);
-    return withTimeout(db.all(sql, params), QUERY_TIMEOUT_MS, sql.slice(0, 80));
+    const db = await getCachedDb(dbPath);
+    return withTimeout(Promise.resolve(runQuery(db, sql, params)), QUERY_TIMEOUT_MS, sql.slice(0, 80));
 }
-/**
- * Returns a detailed schema of all tables in the database.
- */
 export async function inspectSchema(dbPath) {
-    const db = getCachedDb(dbPath);
-    const tables = await withTimeout(db.all("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"), QUERY_TIMEOUT_MS, "inspect_schema:tables");
+    const db = await getCachedDb(dbPath);
+    const tables = runQuery(db, "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;");
     const schemaInfo = {};
     for (const table of tables) {
-        const columns = await db.all(`PRAGMA table_info("${table.name}");`);
-        const createSql = await db.get(`SELECT sql FROM sqlite_master WHERE type='table' AND name=?`, [table.name]);
+        const columns = runQuery(db, `PRAGMA table_info("${table.name}");`);
+        const createSqlRows = runQuery(db, `SELECT sql FROM sqlite_master WHERE type='table' AND name=?`, [table.name]);
         schemaInfo[table.name] = {
             columns,
-            createSql: createSql?.sql
+            createSql: createSqlRows[0]?.sql
         };
     }
     return schemaInfo;

package/dist/locator.js

@@ -49,7 +49,7 @@ export async function listDatabases(bundleId, targetPlatform) {
             }
             return results;
         }
-        // Discover packages to scan
+        // if we have a specific bundleId-use it otherwise hunt
         let packagesToScan = [];
         if (bundleId) {
             packagesToScan = [bundleId];
@@ -76,12 +76,12 @@ export async function listDatabases(bundleId, targetPlatform) {
                 try {
                     await shell(`adb shell run-as ${pkg} ls -d ${baseDir}`, { timeout: 3_000, label: `adb-ls-${pkg}` });
                     let foundFiles = [];
-                    // Find .db / .sqlite / .sqlite3 files recursively
+                    // find .db / .sqlite / .sqlite3 files recursively
                     const findOut = await shell(`adb shell "run-as ${pkg} find ${baseDir} -type f \\( -name \\"*.db\\" -o -name \\"*.sqlite\\" -o -name \\"*.sqlite3\\" \\)"`, { timeout: 8_000, ignoreErrors: true, label: `adb-find-${pkg}` });
                     if (findOut) {
                         foundFiles.push(...findOut.split('\n').map(l => l.trim().replace(/\r/g, '')).filter(Boolean));
                     }
-                    // Also check for extensionless files in /databases
+                    // also check for extensionless files in /databases
                     const lsOut = await shell(`adb shell run-as ${pkg} ls -1p ${baseDir}/databases`, { timeout: 3_000, ignoreErrors: true, label: `adb-ls-dbs-${pkg}` });
                     if (lsOut) {
                         const lsFiles = lsOut.split('\n')
@@ -120,12 +120,6 @@ export async function listDatabases(bundleId, targetPlatform) {
     }
     return results;
 }
-/**
- * Finds the DB file based on platform and a provided/detected filename.
- * If dbNameGlob is empty/undefined, it will auto-select the first discovered database.
- * Prioritizes iOS (simctl), falls back to Android (adb).
- * Returns the local file path (either the iOS original or a pulled Android copy).
- */
 export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
     const locations = await listDatabases(bundleId, targetPlatform);
     if (locations.length === 0) {
@@ -176,7 +170,6 @@ export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
                 continue;
             }
             const [targetDbDir, targetPkg] = appDir.split("::");
-            // Force-stop is best-effort (ensures WAL is flushed)
             await shell(`adb shell am force-stop ${targetPkg}`, { timeout: 5_000, ignoreErrors: true, label: `adb-force-stop-${targetPkg}` });
             const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "rn-sqlite-mcp-"));
             const safeLocalName = targetDbName.replace(/\//g, '_');

package/dist/logger.js

@@ -1,7 +1,3 @@
-/**
- * Structured logging utility for MCP servers.
- * ALL output goes to stderr to avoid polluting the stdio JSON-RPC transport.
- */
 const LOG_LEVELS = {
     debug: 0,
     info: 1,

package/dist/shell.js

@@ -1,8 +1,3 @@
-/**
- * Async shell execution wrapper.
- * Replaces all execSync usage to keep the Node.js event loop alive
- * so MCP stdio transport can continue processing heartbeats/messages.
- */
 import { exec as execCb } from "child_process";
 import { promisify } from "util";
 import { logger } from "./logger.js";
@@ -10,10 +5,6 @@ const execAsync = promisify(execCb);
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-/**
- * Execute a shell command asynchronously with timeout and retry support.
- * This is the core replacement for `execSync` — it does NOT block the event loop.
- */
 export async function shell(command, options = {}) {
     const { timeout = 10_000, retries = 0, retryDelay = 1_000, ignoreErrors = false, label, } = options;
     const tag = label || command.slice(0, 60);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-sqlite-mcp",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Universal React Native SQLite MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -23,11 +23,11 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.0",
-    "sqlite3": "^5.1.7"
+    "sql.js": "^1.14.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.4",
-    "@types/sqlite3": "^3.1.11",
+    "@types/sql.js": "^1.4.9",
     "typescript": "^5.7.3"
   }
 }

package/src/db.ts

@@ -1,51 +1,28 @@
-import sqlite3 from "sqlite3";
+import initSqlJs, { type Database as SqlJsDatabase } from "sql.js";
+import fs from "fs";
 import { logger } from "./logger.js";
 
-export class Database {
-  private db: sqlite3.Database;
+let SQL: Awaited<ReturnType<typeof initSqlJs>> | null = null;
 
-  constructor(filename: string) {
-    this.db = new sqlite3.Database(filename);
-  }
-
-  public all<T>(sql: string, params: any[] = []): Promise<T[]> {
-    return new Promise((resolve, reject) => {
-      this.db.all(sql, params, (err, rows) => {
-        if (err) reject(err);
-        else resolve(rows as Array<T>);
-      });
-    });
-  }
-
-  public get<T>(sql: string, params: any[] = []): Promise<T | undefined> {
-    return new Promise((resolve, reject) => {
-      this.db.get(sql, params, (err, row) => {
-        if (err) reject(err);
-        else resolve(row as T | undefined);
-      });
-    });
-  }
-
-  public close(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.db.close((err) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    });
+async function getSqlJs() {
+  if (!SQL) {
+    SQL = await initSqlJs();
+    logger.debug("sql.js WASM engine initialized");
   }
+  return SQL;
 }
 
 interface CachedConnection {
-  db: Database;
+  db: SqlJsDatabase;
+  dbPath: string;
   lastUsed: number;
   timer: ReturnType<typeof setTimeout>;
 }
 
-const CACHE_TTL_MS = 60_000; // close idle connections after 60s
+const CACHE_TTL_MS = 60_000;
 const connectionCache = new Map<string, CachedConnection>();
 
-function getCachedDb(dbPath: string): Database {
+async function getCachedDb(dbPath: string): Promise<SqlJsDatabase> {
   const existing = connectionCache.get(dbPath);
 
   if (existing) {
@@ -55,21 +32,23 @@ function getCachedDb(dbPath: string): Database {
     return existing.db;
   }
 
-  const db = new Database(dbPath);
-  const timer = setTimeout(() => evictConnection(dbPath), CACHE_TTL_MS);
+  const sqlJs = await getSqlJs();
+  const buffer = fs.readFileSync(dbPath);
+  const db = new sqlJs.Database(buffer);
 
-  connectionCache.set(dbPath, { db, lastUsed: Date.now(), timer });
+  const timer = setTimeout(() => evictConnection(dbPath), CACHE_TTL_MS);
+  connectionCache.set(dbPath, { db, dbPath, lastUsed: Date.now(), timer });
   logger.debug(`Opened DB connection: ${dbPath}`);
   return db;
 }
 
-async function evictConnection(dbPath: string): Promise<void> {
+function evictConnection(dbPath: string): void {
   const entry = connectionCache.get(dbPath);
   if (!entry) return;
 
   connectionCache.delete(dbPath);
   try {
-    await entry.db.close();
+    entry.db.close();
     logger.debug(`Closed idle DB connection: ${dbPath}`);
   } catch (e) {
     logger.warn(`Error closing DB: ${dbPath}`, { error: String(e) });
@@ -79,7 +58,7 @@ async function evictConnection(dbPath: string): Promise<void> {
 export async function closeAllConnections(): Promise<void> {
   const paths = [...connectionCache.keys()];
   for (const p of paths) {
-    await evictConnection(p);
+    evictConnection(p);
   }
   logger.info(`Closed ${paths.length} cached DB connection(s)`);
 }
@@ -98,32 +77,45 @@ function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise
   });
 }
 
+function runQuery(db: SqlJsDatabase, sql: string, params: any[] = []): any[] {
+  const stmt = db.prepare(sql);
+  if (params.length > 0) stmt.bind(params);
+
+  const results: any[] = [];
+  while (stmt.step()) {
+    results.push(stmt.getAsObject());
+  }
+  stmt.free();
+  return results;
+}
+
 export async function queryDb(dbPath: string, sql: string, params: any[] = []): Promise<any[]> {
-  const db = getCachedDb(dbPath);
-  return withTimeout(db.all(sql, params), QUERY_TIMEOUT_MS, sql.slice(0, 80));
+  const db = await getCachedDb(dbPath);
+  return withTimeout(
+    Promise.resolve(runQuery(db, sql, params)),
+    QUERY_TIMEOUT_MS,
+    sql.slice(0, 80)
+  );
 }
 
 export async function inspectSchema(dbPath: string): Promise<any> {
-  const db = getCachedDb(dbPath);
+  const db = await getCachedDb(dbPath);
 
-  const tables = await withTimeout(
-    db.all<{ name: string }>("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"),
-    QUERY_TIMEOUT_MS,
-    "inspect_schema:tables"
-  );
+  const tables = runQuery(db, "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;");
 
   const schemaInfo: Record<string, any> = {};
 
   for (const table of tables) {
-    const columns = await db.all(`PRAGMA table_info("${table.name}");`);
-    const createSql = await db.get<{ sql: string }>(
+    const columns = runQuery(db, `PRAGMA table_info("${table.name}");`);
+    const createSqlRows = runQuery(
+      db,
       `SELECT sql FROM sqlite_master WHERE type='table' AND name=?`,
       [table.name]
     );
 
     schemaInfo[table.name] = {
       columns,
-      createSql: createSql?.sql
+      createSql: createSqlRows[0]?.sql
     };
   }