@dbcube/core 3.0.23 → 3.0.25

package/dist/index.d.mts

@@ -122,19 +122,11 @@ 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,19 +122,11 @@ 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,25 +1243,18 @@ var QueryEngine = class {
 };
 
 // src/lib/SqliteExecutor.ts
-import { exec, spawn as spawn3 } from "child_process";
+import { exec } 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 = [
@@ -1344,173 +1337,7 @@ 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",