@dbcube/core 3.0.23 → 3.0.24

package/dist/index.cjs

@@ -1293,20 +1293,13 @@ var path5 = __toESM(require("path"));
 var fs3 = __toESM(require("fs"));
 var import_util = require("util");
 var import_module3 = require("module");
-var net2 = __toESM(require("net"));
 var execAsync = (0, import_util.promisify)(import_child_process3.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 = [
@@ -1389,173 +1382,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 = (0, import_child_process3.spawn)(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",