jsql-neo 3.5.2 → 4.0.0

package/lib/mod.js

@@ -0,0 +1,316 @@
+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;
+
+class ModApi {
+  constructor(collector) {
+    this._collector = collector;
+  }
+
+  nameset(name) {
+    if (typeof name !== 'string' || !name) {
+      throw new Error('nameset: module name must be a non-empty string');
+    }
+    if (this._collector.nameSet) {
+      throw new Error('nameset: module name already declared');
+    }
+    this._collector.name = name;
+    this._collector.nameSet = true;
+  }
+
+  priority(n) {
+    this._collector.priority = n;
+    return this;
+  }
+
+  depends(name) {
+    if (typeof name === 'string') name = [name];
+    for (const d of name) {
+      if (typeof d !== 'string' || !d) {
+        throw new Error('depends: dependency names must be non-empty strings');
+      }
+    }
+    this._collector.depends = [...(this._collector.depends || []), ...name];
+    return this;
+  }
+
+  api(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+      throw new Error('api: must be an object');
+    }
+    this._collector.api = obj;
+    return this;
+  }
+
+  on(hook, fn) {
+    if (typeof fn !== 'function') throw new Error('on: hook must be a function');
+    if (!this._collector.hooks[hook]) this._collector.hooks[hook] = [];
+    this._collector.hooks[hook].push(fn);
+    return this;
+  }
+
+  onEvent(fn) {
+    if (typeof fn !== 'function') throw new Error('onEvent: must be a function');
+    this._collector.onEvent = fn;
+    return this;
+  }
+
+  install(fn) {
+    if (typeof fn !== 'function') throw new Error('install: must be a function');
+    this._collector.install = fn;
+    return this;
+  }
+}
+
+class ModuleManager {
+  constructor(configPath = CONFIG_PATH) {
+    this._configPath = configPath;
+    this._modules = [];
+    this._load();
+  }
+
+  _load() {
+    try {
+      if (!fs.existsSync(this._configPath)) return;
+      const data = JSON.parse(fs.readFileSync(this._configPath, 'utf8'));
+      if (Array.isArray(data)) {
+        this._modules = data;
+      } else if (Array.isArray(data.modules)) {
+        this._modules = data.modules;
+      }
+    } catch (e) {
+      this._modules = [];
+    }
+  }
+
+  save() {
+    const dir = path.dirname(this._configPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(this._configPath, JSON.stringify({ modules: this._modules }, null, 2), 'utf8');
+  }
+
+  list() {
+    return this._modules.map(m => ({ ...m }));
+  }
+
+  find(name) {
+    return this._modules.find(m => m.name === name) || null;
+  }
+
+  add(address) {
+    const resolved = path.resolve(address);
+    if (!fs.existsSync(resolved)) {
+      throw new Error(`Module file not found: ${resolved}`);
+    }
+    if (fs.statSync(resolved).isDirectory()) {
+      throw new Error(`Expected a module file, got directory: ${resolved}`);
+    }
+
+    const plugin = this._loadModuleFile(resolved);
+    const name = plugin.name;
+
+    if (this.find(name)) {
+      throw new Error(`Module already registered: ${name}`);
+    }
+
+    const entry = {
+      name,
+      path: resolved,
+      enabled: false,
+      priority: plugin.priority || 0,
+      depends: plugin.depends || [],
+      addedAt: Date.now()
+    };
+    this._modules.push(entry);
+    this.save();
+    return { ...entry };
+  }
+
+  enable(name, opts = {}) {
+    const m = this.find(name);
+    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);
+
+    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 };
+  }
+
+  disable(name) {
+    const m = this.find(name);
+    if (!m) throw new Error(`Module not found: ${name}`);
+    if (!m.enabled) return { ...m, ok: true, message: 'already disabled' };
+    for (const other of this._modules) {
+      const plugin = this._loadModuleFile(other.path);
+      if (plugin.depends && plugin.depends.includes(name) && other.enabled) {
+        this.disable(other.name);
+      }
+    }
+    m.enabled = false;
+    this.save();
+    return { ...m, ok: true };
+  }
+
+  enableAll() {
+    const names = this._modules.map(m => m.name);
+    for (const name of names) {
+      try { this.enable(name); } catch (e) { /* skip failed */ }
+    }
+    this.save();
+    return this.list().filter(m => m.enabled).length;
+  }
+
+  disableAll() {
+    for (const m of this._modules) m.enabled = false;
+    this.save();
+    return this._modules.length;
+  }
+
+  applyTo(db) {
+    const enabled = this._sortEnabled();
+    for (const entry of enabled) {
+      const plugin = this._loadModuleFile(entry.path);
+      db.use(plugin);
+    }
+    return db;
+  }
+
+  api(name) {
+    const m = this.find(name);
+    if (!m) throw new Error(`Module not found: ${name}`);
+    const plugin = this._loadModuleFile(m.path);
+    return plugin.api || null;
+  }
+
+  _sortEnabled() {
+    const enabled = this._modules.filter(m => m.enabled).map(m => ({ ...m }));
+    const resolved = new Set();
+    const order = [];
+    const cache = new Map();
+
+    const resolve = (name, chain) => {
+      if (resolved.has(name)) return;
+      const entry = enabled.find(m => m.name === name);
+      if (!entry) return;
+      if (chain.has(name)) throw new Error(`Circular module dependency: ${[...chain, name].join(' -> ')}`);
+
+      let plugin;
+      if (cache.has(entry.path)) {
+        plugin = cache.get(entry.path);
+      } else {
+        plugin = this._loadModuleFile(entry.path);
+        cache.set(entry.path, plugin);
+      }
+
+      for (const dep of (plugin.depends || [])) {
+        resolve(dep, new Set([...chain, name]));
+      }
+      resolved.add(name);
+      order.push(entry);
+    };
+
+    for (const entry of enabled) resolve(entry.name, new Set());
+
+    order.sort((a, b) => (a.priority || 0) - (b.priority || 0));
+    return order;
+  }
+
+  remove(name) {
+    const idx = this._modules.findIndex(m => m.name === name);
+    if (idx === -1) throw new Error(`Module not found: ${name}`);
+    const [removed] = this._modules.splice(idx, 1);
+    this.save();
+    return removed;
+  }
+
+  get(name) {
+    const m = this.find(name);
+    if (!m) throw new Error(`Module not found: ${name}`);
+    return this._loadModuleFile(m.path);
+  }
+
+  _loadModuleFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+
+    if (ext === '.json') {
+      const obj = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      return {
+        name: obj.name || path.basename(filePath, ext),
+        ...obj
+      };
+    }
+
+    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 }
+    });
+
+    try {
+      vm.runInContext(code, context, { filename: 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;
+    }
+    return plugin;
+  }
+}
+
+module.exports = { ModuleManager, ModApi, CONFIG_PATH };

package/lib/mysql_compat.js

@@ -0,0 +1,232 @@
+// © Vexify 2026 All Rights Reserved.
+/**
+ * MySQL API 兼容层 — createConnection / createPool / query
+ * 底层用 JSQL SQL 执行器，接口形状对齐 mysql / mysql2 包。
+ */
+
+const { executeSQL, applyParams, escapeValue, escapeId } = require('./sql');
+const Database = require('./database');
+
+function toResultPacket(r, table) {
+  if (isQueryResult(r)) {
+    const columns = r.columns || [];
+    const rows = (r.rows || []).map(vals => {
+      const obj = {};
+      columns.forEach((c, j) => { obj[c] = vals[j]; });
+      return obj;
+    });
+    const fields = columns.map(name => ({
+      name,
+      table: table || '',
+      type: 253,
+      length: 1024,
+      flags: 0,
+      charsetNr: 45,
+    }));
+    return { rows, fields };
+  }
+  return {
+    fieldCount: 0,
+    affectedRows: r && r.affectedRows !== undefined ? r.affectedRows : 0,
+    insertId: r && r.insertId !== undefined ? r.insertId : 0,
+    serverStatus: 2,
+    warningCount: 0,
+    message: r ? r.type + (r.table ? ' ' + r.table : '') : '',
+    protocol41: true,
+    changedRows: r && r.affectedRows !== undefined ? r.affectedRows : 0,
+  };
+}
+
+class Connection {
+  constructor(options = {}) {
+    this.config = {
+      host: options.host || 'localhost',
+      port: options.port || 3306,
+      user: options.user || 'root',
+      password: options.password || '',
+      database: options.database || null,
+      multipleStatements: options.multipleStatements === true,
+    };
+    this.safety = options.safety !== false;
+    this.allowComments = options.allowComments === true;
+    this.database = options.database && typeof options.database === 'object' && !options.filename && typeof options.database.start === 'function'
+      ? options.database
+      : (options.engine || null);
+    this.filename = options.filename || (typeof options.database === 'string' ? options.database : null);
+    this.engine = null;
+    this._ownEngine = false;
+    this.state = 'disconnected';
+  }
+
+  async _getEngine() {
+    if (this.engine) return this.engine;
+    if (this.database) {
+      this.engine = this.database;
+      if (typeof this.engine.start === 'function') await this.engine.start();
+    } else {
+      this.engine = new Database(this.filename || ':memory:');
+      if (typeof this.engine.start === 'function') await this.engine.start();
+      this._ownEngine = true;
+    }
+    this.state = 'connected';
+    return this.engine;
+  }
+
+  connect(cb) {
+    const p = this._getEngine().then(() => this);
+    if (cb) p.then(c => cb(null, c), err => cb(err));
+    return p;
+  }
+
+  async query(...args) {
+    let sql, values, cb;
+    if (typeof args[0] === 'object' && args[0] !== null && typeof args[0].sql === 'string') {
+      sql = args[0].sql;
+      values = args[0].values;
+      cb = typeof args[1] === 'function' ? args[1] : null;
+    } else {
+      sql = args[0];
+      values = Array.isArray(args[1]) ? args[1] : null;
+      cb = typeof args[1] === 'function' ? args[1] : (typeof args[2] === 'function' ? args[2] : null);
+    }
+    const p = (async () => {
+      const engine = await this._getEngine();
+      const finalSql = applyParams(sql, values);
+      const r = await executeSQL(engine, finalSql, {
+        safety: this.safety,
+        allowComments: this.allowComments,
+        maxStatements: this.config.multipleStatements ? null : 1,
+      });
+      const results = Array.isArray(r) ? r : [r];
+      const last = results[results.length - 1];
+      const packet = toResultPacket(last, last ? last.table : null);
+      if (isQueryResult(last)) {
+        const arr = [packet.rows, packet.fields];
+        arr.rows = packet.rows;
+        arr.fields = packet.fields;
+        return arr;
+      }
+      const arr = [packet];
+      arr.rows = null;
+      arr.fields = null;
+      return arr;
+    })();
+    if (cb) {
+      p.then(res => {
+        if (res && res.rows && res.fields) cb(null, res.rows, res.fields);
+        else if (res && res[0] && res[0].insertId !== undefined) cb(null, res[0]);
+        else cb(null, res[0]);
+      }, err => cb(err));
+      return undefined;
+    }
+    return p;
+  }
+
+  beginTransaction(cb) {
+    const p = this.query('BEGIN');
+    if (cb) p.then(() => cb(null), err => cb(err));
+    return p;
+  }
+
+  commit(cb) {
+    const p = this.query('COMMIT');
+    if (cb) p.then(() => cb(null), err => cb(err));
+    return p;
+  }
+
+  rollback(cb) {
+    const p = this.query('ROLLBACK');
+    if (cb) p.then(() => cb(null), err => cb(err));
+    return p;
+  }
+
+  ping(cb) {
+    const p = this._getEngine().then(() => true);
+    if (cb) p.then(ok => cb(null, ok), err => cb(err));
+    return p;
+  }
+
+  release() {
+    this.state = 'released';
+  }
+
+  destroy() {
+    this.state = 'destroyed';
+  }
+
+  end(cb) {
+    const p = (async () => {
+      if (this._ownEngine && this.engine && typeof this.engine.stop === 'function') {
+        await this.engine.stop();
+      }
+      this.state = 'closed';
+      return undefined;
+    })();
+    if (cb) p.then(() => cb(null), err => cb(err));
+    return p;
+  }
+
+  promise() {
+    return this;
+  }
+}
+
+class Pool {
+  constructor(options = {}) {
+    this.config = options;
+    this._connection = null;
+  }
+
+  async _getConnection() {
+    if (!this._connection) {
+      this._connection = new Connection(this.config);
+      await this._connection._getEngine();
+    }
+    return this._connection;
+  }
+
+  query(...args) {
+    return this._getConnection().then(conn => conn.query(...args));
+  }
+
+  getConnection(cb) {
+    const p = this._getConnection().then(conn => {
+      const release = conn.release.bind(conn);
+      return { connection: conn, release };
+    });
+    if (cb) p.then(r => cb(null, r.connection, r.release), err => cb(err));
+    return p;
+  }
+
+  end(cb) {
+    const p = (async () => {
+      if (this._connection) {
+        await this._connection.end();
+        this._connection = null;
+      }
+      return undefined;
+    })();
+    if (cb) p.then(() => cb(null), err => cb(err));
+    return p;
+  }
+
+  promise() {
+    return this;
+  }
+}
+
+function createConnection(options) {
+  return new Connection(options || {});
+}
+
+function createPool(options) {
+  return new Pool(options || {});
+}
+
+module.exports = {
+  createConnection,
+  createPool,
+  escape: escapeValue,
+  escapeId,
+  format: applyParams,
+};