@dbcube/core 1.0.12 → 1.0.13

package/dist/index.cjs

@@ -298,7 +298,7 @@ var Engine = class {
     return this.config;
   }
   async run(binary, args) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const child = (0, import_child_process.spawn)(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
@@ -314,7 +314,7 @@ var Engine = class {
         if (!isResolved) {
           isResolved = true;
           clearTimeout(timeoutId);
-          resolve2(response);
+          resolve3(response);
         }
       };
       child.stdout.on("data", (data) => {
@@ -382,93 +382,248 @@ var Engine = class {
   }
 };
 
-// src/lib/DbConfig.ts
-var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+// src/lib/SqliteExecutor.ts
+var import_child_process2 = require("child_process");
 var path2 = __toESM(require("path"));
+var import_util = require("util");
+var execAsync = (0, import_util.promisify)(import_child_process2.exec);
+var SqliteExecutor = class {
+  binaryPath;
+  dbPath;
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.binaryPath = this.getBinaryPath();
+  }
+  getBinaryPath() {
+    const binDir = path2.resolve(__dirname, "..", "bin");
+    const platform2 = process.platform;
+    const extension = platform2 === "win32" ? ".exe" : "";
+    const binaryName = `sqlite-engine${extension}`;
+    return path2.join(binDir, binaryName);
+  }
+  async executeBinary(args) {
+    const command = `"${this.binaryPath}" ${args.map((arg) => `"${arg}"`).join(" ")}`;
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        maxBuffer: 10 * 1024 * 1024,
+        // 10MB buffer
+        timeout: 3e4
+        // 30s timeout
+      });
+      if (stderr && stderr.trim()) {
+        console.warn("SQLite Engine Warning:", stderr);
+      }
+      const result = JSON.parse(stdout.trim());
+      return result;
+    } catch (error) {
+      if (error.stdout) {
+        try {
+          const result = JSON.parse(error.stdout.trim());
+          return result;
+        } catch (parseError) {
+        }
+      }
+      throw new Error(`SQLite execution failed: ${error.message}`);
+    }
+  }
+  async connect() {
+    try {
+      const result = await this.executeBinary([
+        "--action",
+        "connect",
+        "--database",
+        this.dbPath
+      ]);
+      return result.status === "success";
+    } catch (error) {
+      return false;
+    }
+  }
+  async exists() {
+    try {
+      const result = await this.executeBinary([
+        "--action",
+        "exists",
+        "--database",
+        this.dbPath
+      ]);
+      return result.status === "success" && result.data === true;
+    } catch (error) {
+      return false;
+    }
+  }
+  async query(sql, params) {
+    const args = [
+      "--action",
+      "query",
+      "--database",
+      this.dbPath,
+      "--query",
+      sql
+    ];
+    if (params && params.length > 0) {
+      args.push("--params", JSON.stringify(params));
+    }
+    return this.executeBinary(args);
+  }
+  // Método para múltiples queries (como lo hace better-sqlite3)
+  async queryMultiple(sql) {
+    return this.query(sql);
+  }
+  // Método prepare que simula prepared statements
+  prepare(sql) {
+    return {
+      all: async (...params) => {
+        const result = await this.query(sql, params);
+        if (result.status === "error") {
+          throw new Error(result.message);
+        }
+        return Array.isArray(result.data) ? result.data : [];
+      },
+      run: async (...params) => {
+        const result = await this.query(sql, params);
+        if (result.status === "error") {
+          throw new Error(result.message);
+        }
+        if (typeof result.data === "object" && result.data.hasOwnProperty("changes") && result.data.hasOwnProperty("lastID")) {
+          return result.data;
+        }
+        return { changes: 0, lastID: 0 };
+      }
+    };
+  }
+  // Para compatibilidad con better-sqlite3 API sincrona usando deasync si es necesario
+  prepareSync(sql) {
+    const deasync = require("deasync");
+    return {
+      all: (...params) => {
+        let result;
+        let done = false;
+        let error;
+        this.query(sql, params).then((res) => {
+          if (res.status === "error") {
+            error = new Error(res.message);
+          } else {
+            result = Array.isArray(res.data) ? res.data : [];
+          }
+          done = true;
+        }).catch((err) => {
+          error = err;
+          done = true;
+        });
+        deasync.loopWhile(() => !done);
+        if (error) throw error;
+        return result;
+      },
+      run: (...params) => {
+        let result;
+        let done = false;
+        let error;
+        this.query(sql, params).then((res) => {
+          if (res.status === "error") {
+            error = new Error(res.message);
+          } else if (typeof res.data === "object" && res.data.hasOwnProperty("changes") && res.data.hasOwnProperty("lastID")) {
+            result = res.data;
+          } else {
+            result = { changes: 0, lastID: 0 };
+          }
+          done = true;
+        }).catch((err) => {
+          error = err;
+          done = true;
+        });
+        deasync.loopWhile(() => !done);
+        if (error) throw error;
+        return result;
+      }
+    };
+  }
+};
+
+// src/lib/DbConfig.ts
+var path3 = __toESM(require("path"));
 var import_fs = __toESM(require("fs"));
-var rootPath = path2.resolve(process.cwd(), ".dbcube");
+var rootPath = path3.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
-  db = null;
+  executor = null;
   database;
   constructor(config) {
     this.database = config.DATABASE;
   }
-  ifExist() {
+  async ifExist() {
     if (this.database) {
       const dbPath = this.database || ":memory:";
-      const configPath = path2.join(rootPath, dbPath + ".db");
+      const configPath = path3.join(rootPath, dbPath + ".db");
       if (!import_fs.default.existsSync(rootPath)) {
         import_fs.default.mkdirSync(rootPath, { recursive: true });
       }
       if (import_fs.default.existsSync(configPath)) {
         return true;
       }
+      if (!this.executor) {
+        this.executor = new SqliteExecutor(configPath);
+      }
+      return await this.executor.exists();
     }
     return false;
   }
   async connect() {
-    return new Promise((resolve2, reject) => {
+    return new Promise(async (resolve3, reject) => {
       try {
-        if (!this.db) {
+        if (!this.executor) {
           const dbPath = this.database || ":memory:";
-          const configPath = path2.join(rootPath, dbPath + ".db");
+          const configPath = path3.join(rootPath, dbPath + ".db");
           if (!import_fs.default.existsSync(rootPath)) {
             import_fs.default.mkdirSync(rootPath, { recursive: true });
           }
-          this.db = new import_better_sqlite3.default(configPath);
+          this.executor = new SqliteExecutor(configPath);
+          const connected = await this.executor.connect();
+          if (!connected) {
+            throw new Error("Failed to connect to SQLite database");
+          }
         }
-        resolve2(this.db);
+        resolve3(this.executor);
       } catch (error) {
         reject(error);
       }
     });
   }
   async disconnect() {
-    return new Promise((resolve2) => {
-      if (this.db) {
-        this.db.close();
-        this.db = null;
+    return new Promise((resolve3) => {
+      if (this.executor) {
+        this.executor = null;
       }
-      resolve2();
+      resolve3();
     });
   }
   async query(sqlQuery) {
-    return new Promise(async (resolve2) => {
+    return new Promise(async (resolve3) => {
       try {
         if (typeof sqlQuery !== "string") {
           throw new Error("The SQL query must be a string.");
         }
-        if (!this.db) {
+        if (!this.executor) {
           await this.connect();
         }
-        if (!this.db) {
+        if (!this.executor) {
           throw new Error("Database connection is not available.");
         }
-        const sqlCommands = sqlQuery.split(";").filter((cmd) => cmd.trim().length > 0);
-        const results = [];
-        for (const command of sqlCommands) {
-          const query = `${command};`;
-          const isSelect = query.trim().toLowerCase().startsWith("select");
-          if (isSelect) {
-            const stmt = this.db.prepare(query);
-            const rows = stmt.all();
-            results.push(rows);
-          } else {
-            const stmt = this.db.prepare(query);
-            const result = stmt.run();
-            results.push({
-              changes: result.changes,
-              lastID: result.lastInsertRowid
-            });
-          }
+        const result = await this.executor.queryMultiple(sqlQuery);
+        if (result.status === "error") {
+          resolve3({
+            status: "error",
+            message: result.message,
+            data: null
+          });
+        } else {
+          resolve3({
+            status: "success",
+            message: "Query executed successfully",
+            data: result.data
+          });
         }
-        resolve2({
-          status: "success",
-          message: "Query executed successfully",
-          data: results.length === 1 ? results[0] : results
-        });
       } catch (error) {
-        resolve2({
+        resolve3({
           status: "error",
           message: error.message || "An error occurred while executing the query.",
           data: null
@@ -477,7 +632,7 @@ var SQLite = class {
     });
   }
   async queryWithParameters(sqlQuery, params = []) {
-    return new Promise(async (resolve2) => {
+    return new Promise(async (resolve3) => {
       try {
         if (typeof sqlQuery !== "string") {
           throw new Error("The SQL query must be a string.");
@@ -485,35 +640,29 @@ var SQLite = class {
         if (!Array.isArray(params)) {
           throw new Error("Parameters must be an array.");
         }
-        if (!this.db) {
+        if (!this.executor) {
           await this.connect();
         }
-        if (!this.db) {
+        if (!this.executor) {
           throw new Error("Database connection is not available.");
         }
-        const isSelect = sqlQuery.trim().toLowerCase().startsWith("select");
-        const stmt = this.db.prepare(sqlQuery);
-        if (isSelect) {
-          const rows = stmt.all(...params);
-          resolve2({
-            status: "success",
-            message: "Query executed successfully",
-            data: rows
+        const result = await this.executor.query(sqlQuery, params);
+        if (result.status === "error") {
+          resolve3({
+            status: "error",
+            message: result.message,
+            data: null
           });
         } else {
-          const result = stmt.run(...params);
-          resolve2({
+          resolve3({
             status: "success",
             message: "Query executed successfully",
-            data: {
-              changes: result.changes,
-              lastID: result.lastInsertRowid
-            }
+            data: result.data
           });
         }
       } catch (error) {
         console.log(error);
-        resolve2({
+        resolve3({
           status: "error",
           message: error.message || "An error occurred while executing the query.",
           data: null
@@ -608,7 +757,7 @@ var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
 var fs2 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 var import_events = require("events");
 var FileLogger = class _FileLogger extends import_events.EventEmitter {
   static watchers = /* @__PURE__ */ new Map();
@@ -623,7 +772,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
    */
   static async write(filePath, message, level = "INFO", append = true) {
     try {
-      const dir = path3.dirname(filePath);
+      const dir = path4.dirname(filePath);
       if (!fs2.existsSync(dir)) {
         fs2.mkdirSync(dir, { recursive: true });
       }
@@ -662,7 +811,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
     const buffer = _FileLogger.buffers.get(filePath);
     if (buffer && buffer.length > 0) {
       try {
-        const dir = path3.dirname(filePath);
+        const dir = path4.dirname(filePath);
         if (!fs2.existsSync(dir)) {
           fs2.mkdirSync(dir, { recursive: true });
         }
@@ -983,7 +1132,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
 var ComputedFieldProcessor = class {
   static async getComputedFields(name) {
     let computedFields = [];
-    if (DbConfig_default.ifExist()) {
+    if (await DbConfig_default.ifExist()) {
       await DbConfig_default.connect();
       try {
         const tableExistsQuery = `SELECT name FROM sqlite_master WHERE type='table' AND name='dbcube_computes_config'`;
@@ -1282,7 +1431,7 @@ var TableProcessor = class {
       }
       return true;
     }
-    if (DbConfig_default.ifExist()) {
+    if (await DbConfig_default.ifExist()) {
       await DbConfig_default.connect();
       try {
         const tableExistsQuery = `SELECT name FROM sqlite_master WHERE type='table' AND name='dbcube_computes_config'`;
@@ -1324,7 +1473,7 @@ var TableProcessor = class {
     }
   }
   static async saveQuery(table_ref, database_ref, struct) {
-    if (DbConfig_default.ifExist()) {
+    if (await DbConfig_default.ifExist()) {
       await DbConfig_default.connect();
       try {
         await DbConfig_default.query(`DELETE FROM dbcube_schemas_config WHERE table_ref='${table_ref}' AND database_ref='${database_ref}'`);
@@ -1340,7 +1489,7 @@ var TableProcessor = class {
 var TriggerProcessor = class {
   static async getTriggers(name) {
     let triggers = [];
-    if (DbConfig_default.ifExist()) {
+    if (await DbConfig_default.ifExist()) {
       await DbConfig_default.connect();
       try {
         const tableExistsQuery = `SELECT name FROM sqlite_master WHERE type='table' AND name='dbcube_triggers_config'`;