jsql-neo 5.4.2 → 6.0.0-beta2

package/lib/wasm_client.js

@@ -1,5 +1,9 @@
 const path = require('path');
 const { executeSQL } = require('./sql');
+const {
+  createHookRegistry, applyPlugin, buildPluginContext, registerHook,
+  runHooks, getPluginApis
+} = require('./plugin');
 const wasmBindings = require(path.join(__dirname, '..', 'wasm', 'jsql_neo_wasm.js'));
 
 function safeJsonParse(str) {
@@ -294,17 +298,7 @@ class JSQL {
     this._autoPlugins = opts.modules !== false;
 
     this._plugins = [];
-    this._hooks = {
-      beforeInsert: [], afterInsert: [],
-      beforeUpdate: [], afterUpdate: [],
-      beforeDelete: [], afterDelete: [],
-      beforeFind: [], afterFind: [],
-      beforeCreateTable: [], afterCreateTable: [],
-      beforeDropTable: [], afterDropTable: [],
-      beforeFlush: [], afterFlush: [],
-      beforeCount: [], afterCount: [],
-      onStart: [], onStop: []
-    };
+    this._hooks = createHookRegistry();
     this._eventListeners = [];
     if (this._autoPlugins) {
       const { ModuleManager } = require('./mod');
@@ -312,47 +306,16 @@ class JSQL {
     }
   }
 
-  use(plugin) {
-    if (typeof plugin === 'function') {
-      plugin = { install: plugin };
-    }
-    if (plugin.hooks) {
-      for (const [event, fn] of Object.entries(plugin.hooks)) {
-        if (this._hooks[event]) {
-          this._hooks[event].push(fn);
-        }
-      }
-    }
-    if (typeof plugin.install === 'function') {
-      plugin.install(this, this._buildCtx(plugin));
-    }
-    if (typeof plugin.onEvent === 'function') {
-      this._eventListeners.push(plugin.onEvent);
-    }
-    this._plugins.push(plugin);
-    return this;
+  use(plugin, opts) {
+    return applyPlugin(this, plugin, opts);
   }
 
   _buildCtx(plugin) {
-    const self = this;
-    return {
-      name: plugin.name || 'anonymous',
-      engine: this,
-      plugin,
-      on(hook, fn) { return self.on(hook, fn); },
-      onEvent(fn) { return self.onEvent(fn); },
-      emit(eventName, data) { self._emit(eventName, data); },
-      tables() { return Array.from(self._tableNames); },
-      hasTable(name) { return self._tableNames.has(name); },
-      getTableSchema(name) { return self._schemas[name] || null; }
-    };
+    return buildPluginContext(this, plugin);
   }
 
   on(event, fn) {
-    if (this._hooks[event]) {
-      this._hooks[event].push(fn);
-    }
-    return this;
+    return registerHook(this, event, fn);
   }
 
   onEvent(fn) {
@@ -360,6 +323,22 @@ class JSQL {
     return this;
   }
 
+  /** 广播事件（插件上下文 / 外部均可调用） */
+  emit(eventName, data) {
+    this._emit(eventName, data);
+    return this;
+  }
+
+  /** 主动触发一个钩子（含插件自定义钩子） */
+  runHook(hookName, ...args) {
+    return this._runHooks(hookName, args);
+  }
+
+  /** 取插件对外暴露的 API（由 plugin.api 声明） */
+  plugin(name) {
+    return getPluginApis(this).get(name) || null;
+  }
+
   _emit(eventName, data) {
     for (const fn of this._eventListeners) {
       try { fn(eventName, data); } catch (e) { /* ignore */ }
@@ -367,16 +346,7 @@ class JSQL {
   }
 
   _runHooks(hookName, args) {
-    const hooks = this._hooks[hookName];
-    if (!hooks || hooks.length === 0) return true;
-    for (const fn of hooks) {
-      const r = fn(...args);
-      if (r === false) return false;
-      if (r !== undefined && args.length > 0) {
-        args[0] = r;
-      }
-    }
-    return true;
+    return runHooks(this, hookName, args);
   }
 
   async start() {
@@ -533,6 +503,17 @@ class JSQL {
     return r;
   }
 
+  async addColumn(table, name, def) {
+    await this._flush();
+    const mapped = mapNativeSchema({ [name]: def })[name];
+    const r = safeJsonParse(wasmBindings.jsql_add_column(table, name, JSON.stringify(mapped)));
+    if (r && r.ok === false) throw new Error(r.error || 'add column failed');
+    if (!this._schemas[table]) this._schemas[table] = {};
+    this._schemas[table][name] = mapped;
+    this._emit('addColumn', { table, name, def: mapped });
+    return r;
+  }
+
   async dropTable(name) {
     await this._flush();
     if (!this._runHooks('beforeDropTable', [name])) return null;
@@ -705,7 +686,10 @@ class JSQL {
    * const rows = await db.query("SELECT * FROM users WHERE age > ?", [21]);
    */
   async query(sql, paramsOrOpts, opts) {
-    return executeSQL(this, sql, paramsOrOpts, opts);
+    if (!this._runHooks('beforeQuery', [sql, paramsOrOpts, opts])) return null;
+    const result = await executeSQL(this, sql, paramsOrOpts, opts);
+    this._runHooks('afterQuery', [sql, paramsOrOpts, opts, result]);
+    return result;
   }
 
   async stop() {

package/nativesrc/jsql-neo-core/Cargo.lock

@@ -171,13 +171,14 @@ dependencies = [
 
 [[package]]
 name = "jsql-neo-core"
-version = "0.1.0"
+version = "6.0.0"
 dependencies = [
  "bincode",
  "chrono",
  "crc32fast",
  "itoa",
  "js-sys",
+ "regex-lite",
  "rustc-hash",
  "ryu",
  "serde",
@@ -242,6 +243,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "regex-lite"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.3"

package/nativesrc/jsql-neo-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsql-neo-core"
-version = "5.4.0"
+version = "6.0.0"
 edition = "2021"
 description = "Embedded database engine — core library (supports WASM)"
 
@@ -16,6 +16,8 @@ itoa = "1"
 ryu = "1"
 rustc-hash = "2"
 bincode = "1"
+# 线性时间、无回溯的正则引擎：用于 $like / $regex 模糊查询（无 ReDoS 风险）
+regex-lite = "0.1"
 wasm-bindgen = { version = "0.2", optional = true }
 js-sys = { version = "0.3", optional = true }
 

package/nativesrc/jsql-neo-core/src/engine/hybrid.rs

@@ -161,6 +161,13 @@ impl HybridEngine {
 
     /// 把单个表写盘（原子：tmp + rename）
     pub fn flush_table(&self, name: &str) -> Result<(), String> {
+        self.flush_table_inner(name)?;
+        self.save_meta();
+        Ok(())
+    }
+
+    /// 写盘但不落 meta.json —— 批量 flush 时由调用方统一写一次，避免 N 次 meta 写放大
+    fn flush_table_inner(&self, name: &str) -> Result<(), String> {
         if self.store_dir.is_none() { return Ok(()); }
         let json = {
             let mem = self.mem.borrow();
@@ -190,7 +197,6 @@ impl HybridEngine {
         fs::write(&tmp, json).map_err(|e| format!("write {}: {}", tmp.display(), e))?;
         let final_path = self.table_path(name, &file);
         fs::rename(&tmp, &final_path).map_err(|e| format!("rename {}: {}", final_path.display(), e))?;
-        self.save_meta();
         Ok(())
     }
 
@@ -201,7 +207,7 @@ impl HybridEngine {
         if names.is_empty() { return Ok(0); }
         let mut flushed = 0;
         for name in &names {
-            if self.flush_table(name).is_ok() {
+            if self.flush_table_inner(name).is_ok() {
                 self.dirty.borrow_mut().remove(name);
                 flushed += 1;
             }
@@ -212,17 +218,25 @@ impl HybridEngine {
 
     /// LRU 驱逐一个最冷已落盘表（返回被驱逐的表名）
     pub fn evict_one(&self) -> Option<String> {
-        let names: Vec<String> = self.mem.borrow().tables.keys().cloned().collect();
-        let dirty = self.dirty.borrow();
-        let candidates: Vec<String> = names.into_iter()
-            .filter(|n| !dirty.contains(n) && self.meta.borrow().contains_key(n))
-            .collect();
-        if candidates.is_empty() { return None; }
-        let mut sorted = candidates;
-        sorted.sort_by_key(|n| self.last_access.borrow().get(n).copied().unwrap_or(0));
-        let victim = sorted.remove(0);
-        self.mem.borrow_mut().tables.remove(&victim);
-        Some(victim)
+        let victim = {
+            let mem = self.mem.borrow();
+            let dirty = self.dirty.borrow();
+            let meta = self.meta.borrow();
+            let access = self.last_access.borrow();
+            let mut best: Option<(u64, &str)> = None;
+            for name in mem.tables.keys() {
+                if dirty.contains(name) || !meta.contains_key(name) { continue; }
+                let ts = access.get(name).copied().unwrap_or(0);
+                if best.map_or(true, |(bts, _)| ts < bts) {
+                    best = Some((ts, name.as_str()));
+                }
+            }
+            best.map(|(_, n)| n.to_string())
+        };
+        if let Some(ref v) = victim {
+            self.mem.borrow_mut().tables.remove(v);
+        }
+        victim
     }
 
     /// 批量二进制插入（native_client encodeBatch 格式），兼容原 jsql_insert_buf 性能路径
@@ -324,6 +338,19 @@ impl Engine for HybridEngine {
         Ok(())
     }
 
+    fn add_column(&mut self, table: &str, name: &str, fs: FieldSchema) -> Result<(), String> {
+        // 先更新内存表结构（含已有行回填），再同步持久化元数据中的 schema。
+        self.mem.borrow_mut().add_column(table, name, fs.clone())?;
+        if let Some(tm) = self.meta.borrow_mut().get_mut(table) {
+            if !tm.schema.iter().any(|(n, _)| n == name) {
+                tm.schema.push((name.to_string(), fs));
+            }
+            self.save_meta();
+            self.mark_dirty(table);
+        }
+        Ok(())
+    }
+
     fn drop_table(&mut self, name: &str) -> Result<(), String> {
         let in_mem = self.mem.borrow().tables.contains_key(name);
         let in_meta = self.meta.borrow().contains_key(name);
@@ -391,6 +418,16 @@ impl Engine for HybridEngine {
         r
     }
 
+    fn find_json(&self, table: &str, filter: &Option<HashMap<String, serde_json::Value>>,
+                 limit: Option<usize>, offset: Option<usize>,
+                 cursor: Option<String>,
+                 order_by: &Option<String>, order: &Option<String>) -> Result<(String, Option<String>, bool), String> {
+        self.ensure_table(table);
+        let r = self.mem.borrow().find_json(table, filter, limit, offset, cursor, order_by, order);
+        if r.is_ok() { self.touch(table); }
+        r
+    }
+
     fn count(&self, table: &str) -> Result<usize, String> {
         self.ensure_table(table);
         let r = self.mem.borrow().count(table);

package/nativesrc/jsql-neo-core/src/engine/memory.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
-use crate::engine::table::Table;
+use crate::engine::table::{Table, matches_filter};
 use crate::engine::{validate_table_name, Engine};
-use crate::types::{Row, TableDefinition};
+use crate::types::{Row, TableDefinition, FieldSchema};
 
 pub struct MemoryEngine {
     pub tables: HashMap<String, Table>,
@@ -35,6 +35,14 @@ impl Engine for MemoryEngine {
         Ok(())
     }
 
+    fn add_column(&mut self, table: &str, name: &str, fs: FieldSchema) -> Result<(), String> {
+        let t = self.tables.get_mut(table).ok_or_else(|| format!("table '{}' not found", table))?;
+        if !t.add_column(name, &fs) {
+            return Err(format!("column '{}' already exists in table '{}'", name, table));
+        }
+        Ok(())
+    }
+
     fn drop_table(&mut self, name: &str) -> Result<(), String> {
         self.tables.remove(name).map(|_| ()).ok_or_else(|| format!("table '{}' not found", name))
     }
@@ -82,6 +90,18 @@ impl Engine for MemoryEngine {
         Ok((rows, next_cursor, has_more))
     }
 
+    fn find_json(&self, table: &str, filter: &Option<HashMap<String, serde_json::Value>>,
+                 limit: Option<usize>, offset: Option<usize>,
+                 cursor: Option<String>,
+                 order_by: &Option<String>, order: &Option<String>) -> Result<(String, Option<String>, bool), String> {
+        let t = self.tables.get(table).ok_or_else(|| format!("table '{}' not found", table))?;
+        let off = cursor.as_deref().and_then(|c| c.strip_prefix('c')?.parse().ok()).or(offset);
+        let off_val = off.unwrap_or(0);
+        let (json, has_more) = t.find_rows_json(filter, limit, off, order_by, order);
+        let next_cursor = if has_more { Some(format!("c{}", off_val + limit.unwrap())) } else { None };
+        Ok((json, next_cursor, has_more))
+    }
+
     fn count(&self, table: &str) -> Result<usize, String> {
         let t = self.tables.get(table).ok_or_else(|| format!("table '{}' not found", table))?;
         Ok(t.count())
@@ -109,17 +129,20 @@ impl Engine for MemoryEngine {
 
     fn update_by_filter(&mut self, table: &str, filter: &Option<HashMap<String, serde_json::Value>>,
                         data: HashMap<String, serde_json::Value>) -> Result<usize, String> {
-        let ids: Vec<u64> = {
-            let t = self.tables.get(table).ok_or_else(|| format!("table '{}' not found", table))?;
-            t.rows.iter()
-                .filter(|r| filter.as_ref().map_or(true, |f| t.row_matches(r, f)))
-                .map(|r| r.id)
-                .collect()
+        let t = self.tables.get_mut(table).ok_or_else(|| format!("table '{}' not found", table))?;
+        let ids: Vec<u64> = match filter {
+            Some(f) => {
+                let conds = t.parse_filter(f);
+                t.rows.iter()
+                    .filter(|r| matches_filter(t.get_row_values(r), &conds))
+                    .map(|r| r.id)
+                    .collect()
+            }
+            None => t.rows.iter().map(|r| r.id).collect(),
         };
         let count = ids.len();
         for id in &ids {
-            let t = self.tables.get_mut(table).ok_or_else(|| format!("table '{}' not found", table))?;
-            t.update_row(*id, data.clone());
+            t.update_row_ref(*id, &data);
         }
         Ok(count)
     }
@@ -127,19 +150,19 @@ impl Engine for MemoryEngine {
     fn remove_by_filter(&mut self, table: &str, filter: &Option<HashMap<String, serde_json::Value>>) -> Result<usize, String> {
         let t = self.tables.get_mut(table).ok_or_else(|| format!("table '{}' not found", table))?;
         let len_before = t.rows.len();
-        if filter.is_none() {
-            t.rows.clear();
-            t.pk_index.clear();
-            return Ok(len_before);
-        }
-        let f = filter.as_ref().unwrap();
-        let mut to_remove = Vec::new();
-        for (i, r) in t.rows.iter().enumerate() {
-            let matches = f.iter().all(|(k, v)| {
-                t.field_index.get(k).and_then(|&pos| t.get_row_values(r).get(pos)).map_or(false, |fv| fv.eq_json(v))
-            });
-            if matches { to_remove.push(i); }
-        }
+        let f = match filter {
+            None => {
+                t.rows.clear();
+                t.pk_index.clear();
+                return Ok(len_before);
+            }
+            Some(f) => f,
+        };
+        let conds = t.parse_filter(f);
+        let to_remove: Vec<usize> = t.rows.iter().enumerate()
+            .filter(|(_, r)| matches_filter(t.get_row_values(r), &conds))
+            .map(|(i, _)| i)
+            .collect();
         for i in to_remove.into_iter().rev() {
             t.remove_row_by_idx(i);
         }

package/nativesrc/jsql-neo-core/src/engine/mod.rs

@@ -30,10 +30,12 @@ pub fn validate_table_name(name: &str) -> Result<(), String> {
 }
 
 use std::collections::HashMap;
-use crate::types::{Row, TableDefinition};
+use crate::types::{Row, TableDefinition, FieldSchema};
 
 pub trait Engine {
     fn create_table(&mut self, def: TableDefinition) -> Result<(), String>;
+    /// 运行期加列：扩展表结构并为已有行回填默认值（见 `Table::add_column`）。
+    fn add_column(&mut self, table: &str, name: &str, fs: FieldSchema) -> Result<(), String>;
     fn drop_table(&mut self, name: &str) -> Result<(), String>;
     fn has_table(&self, name: &str) -> bool;
     fn list_tables(&self) -> Vec<String>;
@@ -46,6 +48,16 @@ pub trait Engine {
             limit: Option<usize>, offset: Option<usize>,
             cursor: Option<String>,
             order_by: &Option<String>, order: &Option<String>) -> Result<(Vec<Row>, Option<String>, bool), String>;
+    /// 与 `find` 等价，但直接产出 JSON 字符串，省掉 `Row` / `HashMap<String, Value>`
+    /// 中间表示与随之而来的二次序列化。默认实现回退到 `find`。
+    fn find_json(&self, table: &str, filter: &Option<HashMap<String, serde_json::Value>>,
+                 limit: Option<usize>, offset: Option<usize>,
+                 cursor: Option<String>,
+                 order_by: &Option<String>, order: &Option<String>) -> Result<(String, Option<String>, bool), String> {
+        let (rows, cursor, has_more) = self.find(table, filter, limit, offset, cursor, order_by, order)?;
+        let json = serde_json::to_string(&rows).unwrap_or_else(|_| "[]".to_string());
+        Ok((json, cursor, has_more))
+    }
     fn count(&self, table: &str) -> Result<usize, String>;
     fn update_by_id(&mut self, table: &str, id: u64, data: HashMap<String, serde_json::Value>) -> Result<bool, String>;
     fn update_by_ids(&mut self, table: &str, batch: Vec<(u64, HashMap<String, serde_json::Value>)>) -> Result<usize, String>;