@dbcube/core 3.0.22 → 3.0.23

package/dist/index.d.mts

@@ -122,11 +122,19 @@ interface RunResult {
 declare class SqliteExecutor {
     private binaryPath;
     private dbPath;
+    private connectionId;
+    private tcpPort;
+    private useTcp;
     constructor(dbPath: string);
     private getBinaryPath;
     private executeBinary;
     connect(): Promise<boolean>;
     exists(): Promise<boolean>;
+    private findAvailablePort;
+    private isPortAvailable;
+    private startTcpServer;
+    private sendTcpQuery;
+    private sleep;
     query(sql: string, params?: any[]): Promise<SqliteResult>;
     queryMultiple(sql: string): Promise<SqliteResult>;
     prepare(sql: string): {

package/dist/index.d.ts

@@ -122,11 +122,19 @@ interface RunResult {
 declare class SqliteExecutor {
     private binaryPath;
     private dbPath;
+    private connectionId;
+    private tcpPort;
+    private useTcp;
     constructor(dbPath: string);
     private getBinaryPath;
     private executeBinary;
     connect(): Promise<boolean>;
     exists(): Promise<boolean>;
+    private findAvailablePort;
+    private isPortAvailable;
+    private startTcpServer;
+    private sendTcpQuery;
+    private sleep;
     query(sql: string, params?: any[]): Promise<SqliteResult>;
     queryMultiple(sql: string): Promise<SqliteResult>;
     prepare(sql: string): {

package/dist/index.js

@@ -1243,18 +1243,25 @@ var QueryEngine = class {
 };
 
 // src/lib/SqliteExecutor.ts
-import { exec } from "child_process";
+import { exec, spawn as spawn3 } from "child_process";
 import * as path5 from "path";
 import * as fs3 from "fs";
 import { promisify } from "util";
 import { createRequire as createRequire3 } from "module";
+import * as net2 from "net";
 var execAsync = promisify(exec);
+var globalSqliteServers = /* @__PURE__ */ new Map();
+var globalSqliteConnections = /* @__PURE__ */ new Map();
 var SqliteExecutor = class {
   binaryPath;
   dbPath;
+  connectionId;
+  tcpPort = 9944;
+  useTcp = true;
   constructor(dbPath) {
     this.dbPath = dbPath;
     this.binaryPath = this.getBinaryPath();
+    this.connectionId = `sqlite_${dbPath.replace(/[^a-zA-Z0-9]/g, "_")}`;
   }
   getBinaryPath() {
     const possibleDirs = [
@@ -1337,7 +1344,173 @@ var SqliteExecutor = class {
       return false;
     }
   }
+  async findAvailablePort(startPort) {
+    for (let port = startPort; port >= 9900; port--) {
+      if (await this.isPortAvailable(port)) {
+        return port;
+      }
+    }
+    throw new Error("No available ports found in range 9900-9944");
+  }
+  isPortAvailable(port) {
+    return new Promise((resolve5) => {
+      const tester = net2.createServer();
+      tester.once("error", () => resolve5(false));
+      tester.once("listening", () => {
+        tester.close();
+        resolve5(true);
+      });
+      tester.listen(port, "127.0.0.1");
+    });
+  }
+  async startTcpServer() {
+    this.tcpPort = await this.findAvailablePort(this.tcpPort);
+    return new Promise((resolve5, reject) => {
+      const serverArgs = [
+        "--action",
+        "serve",
+        "--id",
+        this.connectionId,
+        "--database-ref",
+        "config",
+        "--database",
+        this.dbPath
+      ];
+      const serverProcess = spawn3(this.binaryPath, serverArgs);
+      let started = false;
+      const timeout = setTimeout(() => {
+        if (!started) {
+          serverProcess.kill();
+          reject(new Error("SQLite TCP server startup timeout"));
+        }
+      }, 1e4);
+      serverProcess.stdout.on("data", (data) => {
+        const output = data.toString();
+        if (output.includes("SQLite TCP Server started") || output.includes("PROCESS_RESPONSE:")) {
+          if (!started) {
+            started = true;
+            clearTimeout(timeout);
+            const match = output.match(/PROCESS_RESPONSE:(\{.*\})/);
+            if (match) {
+              try {
+                const response = JSON.parse(match[1]);
+                if (response.data && response.data.port) {
+                  this.tcpPort = response.data.port;
+                }
+              } catch (e) {
+              }
+            }
+            globalSqliteServers.set(this.connectionId, {
+              port: this.tcpPort,
+              process: serverProcess
+            });
+            resolve5();
+          }
+        }
+      });
+      serverProcess.stderr.on("data", (data) => {
+        console.error(`[SQLite Server Error] ${data.toString().trim()}`);
+      });
+      serverProcess.on("close", () => {
+        globalSqliteServers.delete(this.connectionId);
+        globalSqliteConnections.delete(this.connectionId);
+      });
+      serverProcess.on("error", (error) => {
+        if (!started) {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+    });
+  }
+  async sendTcpQuery(sql, params) {
+    const serverInfo = globalSqliteServers.get(this.connectionId);
+    if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
+      await this.startTcpServer();
+      await this.sleep(500);
+    }
+    return new Promise((resolve5, reject) => {
+      const client = new net2.Socket();
+      let responseBuffer = "";
+      let isResolved = false;
+      const timeout = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          client.destroy();
+          reject(new Error("TCP query timeout"));
+        }
+      }, 1e4);
+      client.connect(this.tcpPort, "127.0.0.1", () => {
+        const command = {
+          action: "query",
+          query: sql,
+          params: params || []
+        };
+        client.write(JSON.stringify(command) + "\n");
+      });
+      client.on("data", (data) => {
+        responseBuffer += data.toString();
+        const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
+        if (match && !isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          client.destroy();
+          try {
+            const response = JSON.parse(match[1]);
+            if (response.code === 200) {
+              resolve5({
+                status: "success",
+                message: response.message,
+                data: response.data
+              });
+            } else {
+              resolve5({
+                status: "error",
+                message: response.message,
+                data: null
+              });
+            }
+          } catch (error) {
+            reject(new Error("Failed to parse TCP response"));
+          }
+        }
+      });
+      client.on("error", (error) => {
+        if (!isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          this.useTcp = false;
+          this.executeBinary([
+            "--action",
+            "query",
+            "--database",
+            this.dbPath,
+            "--query",
+            sql,
+            ...params && params.length > 0 ? ["--params", JSON.stringify(params)] : []
+          ]).then(resolve5).catch(reject);
+        }
+      });
+      client.on("close", () => {
+        if (!isResolved) {
+          clearTimeout(timeout);
+          reject(new Error("Connection closed without valid response"));
+        }
+      });
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve5) => setTimeout(resolve5, ms));
+  }
   async query(sql, params) {
+    if (this.useTcp) {
+      try {
+        return await this.sendTcpQuery(sql, params);
+      } catch (error) {
+        console.warn("TCP query failed, falling back to direct execution");
+        this.useTcp = false;
+      }
+    }
     const args = [
       "--action",
       "query",