jsql-neo 4.0.2 → 4.1.0

package/lib/mod.js

@@ -2,7 +2,6 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const Module = require('module');
-const vm = require('vm');
 
 const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.config', 'jsql', 'mod.config');
 const CONFIG_PATH = process.env.JSQL_MOD_CONFIG || DEFAULT_CONFIG_PATH;
@@ -90,8 +89,9 @@ class ModuleManager {
 
   save() {
     const dir = path.dirname(this._configPath);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     fs.writeFileSync(this._configPath, JSON.stringify({ modules: this._modules }, null, 2), 'utf8');
+    try { fs.chmodSync(this._configPath, 0o600); } catch (e) {}
   }
 
   list() {
@@ -102,7 +102,7 @@ class ModuleManager {
     return this._modules.find(m => m.name === name) || null;
   }
 
-  add(address) {
+  add(address, opts = {}) {
     const resolved = path.resolve(address);
     if (!fs.existsSync(resolved)) {
       throw new Error(`Module file not found: ${resolved}`);
@@ -136,22 +136,30 @@ class ModuleManager {
     if (!m) throw new Error(`Module not found: ${name}. Use 'jsql mod add --address <path>' first.`);
     if (m.enabled) return { ...m, ok: true, message: 'already enabled' };
 
-    const plugin = this._loadModuleFile(m.path);
+    const enabling = this._enablingStack || (this._enablingStack = new Set());
+    if (enabling.has(name)) throw new Error(`Circular module dependency: ${[...enabling, name].join(' -> ')}`);
+    enabling.add(name);
 
-    if (plugin.depends && plugin.depends.length > 0) {
-      for (const dep of plugin.depends) {
-        const depMod = this.find(dep);
-        if (!depMod) throw new Error(`Module '${name}' depends on '${dep}' which is not registered`);
-        if (!depMod.enabled && opts.withDeps !== false) {
-          this.enable(dep, opts);
+    try {
+      const plugin = this._loadModuleFile(m.path);
+
+      if (plugin.depends && plugin.depends.length > 0) {
+        for (const dep of plugin.depends) {
+          const depMod = this.find(dep);
+          if (!depMod) throw new Error(`Module '${name}' depends on '${dep}' which is not registered`);
+          if (!depMod.enabled && opts.withDeps !== false) {
+            this.enable(dep, opts);
+          }
         }
       }
-    }
 
-    m.enabled = true;
-    m.priority = plugin.priority || m.priority || 0;
-    this.save();
-    return { ...m, ok: true };
+      m.enabled = true;
+      m.priority = plugin.priority || m.priority || 0;
+      this.save();
+      return { ...m, ok: true };
+    } finally {
+      enabling.delete(name);
+    }
   }
 
   disable(name) {
@@ -207,9 +215,9 @@ class ModuleManager {
     const cache = new Map();
 
     const resolve = (name, chain) => {
-      if (resolved.has(name)) return;
+      if (resolved.has(name)) return 0;
       const entry = enabled.find(m => m.name === name);
-      if (!entry) return;
+      if (!entry) return 0;
       if (chain.has(name)) throw new Error(`Circular module dependency: ${[...chain, name].join(' -> ')}`);
 
       let plugin;
@@ -220,17 +228,21 @@ class ModuleManager {
         cache.set(entry.path, plugin);
       }
 
+      let maxDepDepth = -1;
       for (const dep of (plugin.depends || [])) {
-        resolve(dep, new Set([...chain, name]));
+        const d = resolve(dep, new Set([...chain, name]));
+        maxDepDepth = Math.max(maxDepDepth, d);
       }
       resolved.add(name);
-      order.push(entry);
+      order.push({ entry, depth: maxDepDepth + 1 });
+      return maxDepDepth + 1;
     };
 
     for (const entry of enabled) resolve(entry.name, new Set());
 
-    order.sort((a, b) => (a.priority || 0) - (b.priority || 0));
-    return order;
+    // 依赖深度优先，同层按 priority 排序：保证被依赖方始终先应用
+    order.sort((a, b) => a.depth - b.depth || (a.entry.priority || 0) - (b.entry.priority || 0));
+    return order.map(o => o.entry);
   }
 
   remove(name) {
@@ -258,57 +270,21 @@ class ModuleManager {
       };
     }
 
-    const code = fs.readFileSync(filePath, 'utf8');
-    const collector = { name: null, nameSet: false, hooks: {} };
-    const sandboxModule = new Module(filePath, module);
-    sandboxModule.filename = filePath;
-    sandboxModule.paths = Module._nodeModulePaths(path.dirname(filePath));
-    const sandboxRequire = Module.createRequire(filePath);
-
-    const jsqlMod = new ModApi(collector);
-    const context = vm.createContext({
-      module: sandboxModule,
-      exports: sandboxModule.exports,
-      require: sandboxRequire,
-      __filename: filePath,
-      __dirname: path.dirname(filePath),
-      console,
-      process,
-      Buffer,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      URL,
-      URLSearchParams,
-      TextEncoder,
-      TextDecoder,
-      jsql: { mod: jsqlMod }
-    });
-
+    // JS 模块使用 Node.js require 直接加载（信任模型——模块由管理员通过 CLI 管理，
+    // 与 npm 包模型相同，无安全隔离假设）。
+    // 如需防止非预期代码执行，请使用 JSON-only 模块（只声明 hooks/api 无代码执行能力）。
+    const resolved = path.isAbsolute(filePath) ? filePath : require.resolve(filePath);
+    delete require.cache[resolved];
+    let plugin;
     try {
-      vm.runInContext(code, context, { filename: filePath });
+      plugin = require(filePath);
     } catch (e) {
       throw new Error(`Failed to load module ${filePath}: ${e.message}`);
     }
-
-    const sandboxExports = sandboxModule.exports;
-    const hasExports = sandboxExports && Object.keys(sandboxExports).length > 0;
-    const plugin = hasExports ? sandboxExports : {
-      hooks: collector.hooks,
-      onEvent: collector.onEvent,
-      install: collector.install
-    };
-
-    const meta = {
-      name: collector.name || plugin.name || path.basename(filePath, ext),
-      priority: collector.priority !== undefined ? collector.priority : plugin.priority,
-      depends: collector.depends || plugin.depends,
-      api: collector.api || plugin.api
-    };
-    for (const [k, v] of Object.entries(meta)) {
-      if (v !== undefined && v !== null) plugin[k] = v;
+    if (typeof plugin === 'function') {
+      return { install: plugin, name: path.basename(filePath, ext) };
     }
+    if (!plugin.name) plugin.name = path.basename(filePath, ext);
     return plugin;
   }
 }

package/lib/mysql_compat.js

@@ -7,6 +7,10 @@
 const { executeSQL, applyParams, escapeValue, escapeId } = require('./sql');
 const Database = require('./database');
 
+function isQueryResult(r) {
+  return !!r && typeof r === 'object' && Array.isArray(r.rows) && Array.isArray(r.columns);
+}
+
 function toResultPacket(r, table) {
   if (isQueryResult(r)) {
     const columns = r.columns || [];
@@ -174,36 +178,149 @@ class Connection {
 class Pool {
   constructor(options = {}) {
     this.config = options;
-    this._connection = null;
+    this.connectionLimit = options.connectionLimit || 10;
+    this.queueLimit = options.queueLimit || 0;
+    this.idleTimeout = options.idleTimeout != null ? options.idleTimeout : 300000;
+    this._connections = [];
+    this._waiters = [];
+    this._closed = false;
+    this._sharedEngine = null;
+    this._reaper = setInterval(() => this._reapIdle(), Math.max(1000, Math.floor(this.idleTimeout / 10) || 10000));
+    this._reaper.unref();
   }
 
-  async _getConnection() {
-    if (!this._connection) {
-      this._connection = new Connection(this.config);
-      await this._connection._getEngine();
+  _createConnection() {
+    const conn = new Connection(this.config);
+    conn._pool = this;
+    if (!conn.database && !conn.engine && !conn.filename) {
+      conn.database = this._sharedEngine;
     }
-    return this._connection;
+    const origDestroy = conn.destroy.bind(conn);
+    conn.destroy = () => {
+      this._remove(conn);
+      origDestroy();
+    };
+    return conn;
   }
 
-  query(...args) {
-    return this._getConnection().then(conn => conn.query(...args));
+  async _ensureSharedEngine() {
+    if (!this._sharedEngine) {
+      this._sharedEngine = new Database(':memory:');
+      if (typeof this._sharedEngine.start === 'function') await this._sharedEngine.start();
+    }
+    return this._sharedEngine;
   }
 
-  getConnection(cb) {
-    const p = this._getConnection().then(conn => {
-      const release = conn.release.bind(conn);
-      return { connection: conn, release };
+  _remove(conn) {
+    const idx = this._connections.indexOf(conn);
+    if (idx !== -1) this._connections.splice(idx, 1);
+  }
+
+  _reapIdle() {
+    if (this.idleTimeout <= 0) return;
+    const now = Date.now();
+    for (const conn of this._connections.slice()) {
+      if (conn.state === 'released' && !conn._inUse && now - (conn._releasedAt || 0) > this.idleTimeout) {
+        this._remove(conn);
+        if (conn._ownEngine && conn.engine && typeof conn.engine.stop === 'function') {
+          conn.engine.stop().catch(() => {});
+        }
+        conn.state = 'destroyed';
+      }
+    }
+  }
+
+  _acquire() {
+    if (this._closed) return Promise.reject(new Error('Pool is closed'));
+    const free = this._connections.find(c => c.state === 'released' && !c._inUse);
+    if (free) {
+      free._inUse = true;
+      free.state = 'acquired';
+      return Promise.resolve(free);
+    }
+    if (this._connections.length < this.connectionLimit) {
+      return this._ensureSharedEngine().then(() => {
+        if (this._connections.length >= this.connectionLimit) {
+          return this._waitForConnection();
+        }
+        const conn = this._createConnection();
+        this._connections.push(conn);
+        conn._inUse = true;
+        conn.state = 'acquired';
+        return conn._getEngine().then(
+          () => conn,
+          err => {
+            this._remove(conn);
+            throw err;
+          }
+        );
+      });
+    }
+    return this._waitForConnection();
+  }
+
+  _waitForConnection() {
+    return new Promise((resolve, reject) => {
+      this._waiters.push({ resolve, reject });
+      if (this.queueLimit > 0 && this._waiters.length > this.queueLimit) {
+        const w = this._waiters.shift();
+        w.reject(new Error('Pool queue limit exceeded'));
+      }
     });
+  }
+
+  _release(conn) {
+    conn._inUse = false;
+    conn.state = 'released';
+    conn._releasedAt = Date.now();
+    const w = this._waiters.shift();
+    if (w) {
+      conn._inUse = true;
+      conn.state = 'acquired';
+      w.resolve(conn);
+    }
+  }
+
+  async _getConnection() {
+    return this._acquire();
+  }
+
+  async query(...args) {
+    const conn = await this._acquire();
+    try {
+      return await conn.query(...args);
+    } finally {
+      this._release(conn);
+    }
+  }
+
+  async getConnection(cb) {
+    const p = (async () => {
+      const conn = await this._acquire();
+      let released = false;
+      const release = () => {
+        if (released) return;
+        released = true;
+        if (conn.state === 'destroyed') {
+          this._remove(conn);
+          return;
+        }
+        this._release(conn);
+      };
+      return { connection: conn, release };
+    })();
     if (cb) p.then(r => cb(null, r.connection, r.release), err => cb(err));
     return p;
   }
 
-  end(cb) {
+  async end(cb) {
     const p = (async () => {
-      if (this._connection) {
-        await this._connection.end();
-        this._connection = null;
-      }
+      this._closed = true;
+      if (this._reaper) { clearInterval(this._reaper); this._reaper = null; }
+      const err = new Error('Pool is closed');
+      for (const w of this._waiters.splice(0)) w.reject(err);
+      const conns = this._connections.splice(0);
+      await Promise.allSettled(conns.map(c => c.end()));
       return undefined;
     })();
     if (cb) p.then(() => cb(null), err => cb(err));