jsql-neo 3.5.2 → 4.0.0

package/lib/table.js

@@ -187,9 +187,12 @@ class Table {
                 const pkVal = data[this._primaryKey];
                 if (pkVal !== undefined && pkVal !== null) this._pkIndex.set(pkVal, rowIdx);
             }
+            for (const [field, tree] of Object.entries(this._btrees)) {
+                const val = data[field];
+                if (val !== undefined && val !== null) tree.insert(val, rowIdx);
+            }
             items[i] = data;
         }
-        this._btreesDirty = true;
         this._dirty = true;
         this._db._markDirty();
         for (const hook of this._hooks.afterInsert) {
@@ -353,26 +356,37 @@ class Table {
 
         const toRemove = this._applyFilterOptimized(this._getVisibleRows(), query);
         let count = 0;
+        const removeIndices = [];
 
         for (const row of toRemove) {
             const index = this._rows.indexOf(row);
             if (index === -1) continue;
-
-            // 外键 CASCADE / SET NULL：查找所有引用此表的子表
             this._cascadeForeignKeys(row);
-
-            if (this._softDelete) {
-                this._rows[index]._deleted = true;
-                this._rows[index]._deletedAt = Date.now();
-            } else {
-                this._removeFromIndexes(index, row);
-                this._rows.splice(index, 1);
-                this._adjustBTreeAfterRemove(index);
-            }
+            this._removeFromIndexes(index, row);
+            removeIndices.push(index);
             count++;
         }
 
         if (count > 0) {
+            removeIndices.sort((a, b) => b - a);
+            for (const idx of removeIndices) {
+                const lastIdx = this._rows.length - 1;
+                if (idx < lastIdx) {
+                    const lastRow = this._rows[lastIdx];
+                    this._rows[idx] = lastRow;
+                    if (this._pkIndex && this._primaryKey) {
+                        this._pkIndex.set(lastRow[this._primaryKey], idx);
+                    }
+                    for (const [field, tree] of Object.entries(this._btrees)) {
+                        const val = lastRow[field];
+                        if (val !== undefined && val !== null) {
+                            tree.remove(val, lastIdx);
+                            tree.insert(val, idx);
+                        }
+                    }
+                }
+                this._rows.pop();
+            }
             this._dirty = true;
             this._db._markDirty();
             for (const hook of this._hooks.afterRemove) {
@@ -402,14 +416,23 @@ class Table {
         const row = this._rows[rowIndex];
         if (!row || row._deleted) return 0;
         this._cascadeForeignKeys(row);
-        if (this._softDelete) {
-            row._deleted = true;
-            row._deletedAt = Date.now();
-        } else {
-            this._removeFromIndexes(rowIndex, row);
-            this._rows.splice(rowIndex, 1);
-            this._adjustBTreeAfterRemove(rowIndex);
+        this._removeFromIndexes(rowIndex, row);
+        const lastIdx = this._rows.length - 1;
+        if (rowIndex < lastIdx) {
+            const lastRow = this._rows[lastIdx];
+            this._rows[rowIndex] = lastRow;
+            if (this._pkIndex && this._primaryKey) {
+                this._pkIndex.set(lastRow[this._primaryKey], rowIndex);
+            }
+            for (const [field, tree] of Object.entries(this._btrees)) {
+                const val = lastRow[field];
+                if (val !== undefined && val !== null) {
+                    tree.remove(val, lastIdx);
+                    tree.insert(val, rowIndex);
+                }
+            }
         }
+        this._rows.pop();
         this._dirty = true;
         this._db._markDirty();
         for (const hook of this._hooks.afterRemove) {
@@ -992,7 +1015,6 @@ class Table {
     }
 
     _addToIndexes(rowIndex, data) {
-        this._ensureBTrees();
         if (this._pkIndex && this._primaryKey) {
             const pkVal = data[this._primaryKey];
             if (pkVal !== undefined && pkVal !== null) this._pkIndex.set(pkVal, rowIndex);
@@ -1015,7 +1037,6 @@ class Table {
     }
 
     _removeFromIndexes(rowIndex, data) {
-        this._ensureBTrees();
         if (this._pkIndex && this._primaryKey) {
             this._pkIndex.delete(data[this._primaryKey]);
         }

package/lib/wasm_client.js

@@ -122,24 +122,119 @@ class JSQL {
     this._flushThreshold = opts.flushThreshold || 5000;
     this._buffer = {};
     this._bufferSize = 0;
+    this._tableNames = new Set();
+    this._schemas = {};
+    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._eventListeners = [];
+    if (this._autoPlugins) {
+      const { ModuleManager } = require('./mod');
+      new ModuleManager().applyTo(this);
+    }
   }
 
-  async start() {}
+  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;
+  }
+
+  _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; }
+    };
+  }
+
+  on(event, fn) {
+    if (this._hooks[event]) {
+      this._hooks[event].push(fn);
+    }
+    return this;
+  }
+
+  onEvent(fn) {
+    this._eventListeners.push(fn);
+    return this;
+  }
+
+  _emit(eventName, data) {
+    for (const fn of this._eventListeners) {
+      try { fn(eventName, data); } catch (e) { /* ignore */ }
+    }
+  }
+
+  _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;
+  }
+
+  async start() {
+    this._runHooks('onStart', []);
+    this._emit('start', {});
+  }
 
   async _insertBatch(table, rows) {
-    const bin = encodeBatch(rows);
-    const r = safeJsonParse(wasmBindings.jsql_insert_buf(table, bin));
+    const r = safeJsonParse(wasmBindings.jsql_insert_json(table, JSON.stringify(rows)));
     if (r && r.error) throw new Error(r.error);
     return r;
   }
 
   async _flush() {
+    if (!this._runHooks('beforeFlush', [])) return null;
+    const flushed = {};
     for (const [table, rows] of Object.entries(this._buffer)) {
       if (rows.length === 0) continue;
-      await this._insertBatch(table, rows);
+      const r = await this._insertBatch(table, rows);
+      flushed[table] = r;
     }
     this._buffer = {};
     this._bufferSize = 0;
+    this._runHooks('afterFlush', []);
+    return flushed;
   }
 
   async flush() {
@@ -148,6 +243,7 @@ class JSQL {
 
   async insert(table, data) {
     const arr = Array.isArray(data) ? data : [data];
+    if (!this._runHooks('beforeInsert', [table, arr])) return [];
     if (arr.length > 1) {
       await this._flush();
       let result;
@@ -157,68 +253,140 @@ class JSQL {
         if (r && r.error) throw new Error(r.error);
         if (!result) result = r;
       }
+      this._emit('insert', { table, count: arr.length, ids: result });
+      this._runHooks('afterInsert', [table, arr, result]);
       return result;
     }
     if (!this._buffer[table]) this._buffer[table] = [];
     this._buffer[table].push(arr[0]);
     this._bufferSize++;
-    if (this._bufferSize >= this._flushThreshold) {
-      await this._flush();
-    }
+    const flushed = await this._flush();
+    return flushed && flushed[table] ? flushed[table] : null;
   }
 
   async createTable(name, schema) {
     await this._flush();
+    if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
     const r = safeJsonParse(wasmBindings.jsql_create_table(name, JSON.stringify(schema)));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
+    this._tableNames.add(name);
+    this._schemas[name] = schema;
+    this._emit('createTable', { name, schema });
+    this._runHooks('afterCreateTable', [name, schema]);
     return r;
   }
 
   async dropTable(name) {
     await this._flush();
+    if (!this._runHooks('beforeDropTable', [name])) return null;
     const r = safeJsonParse(wasmBindings.jsql_drop_table(name));
     if (r && r.ok === false) throw new Error(r.error || 'drop table failed');
+    this._tableNames.delete(name);
+    delete this._schemas[name];
+    this._emit('dropTable', { name });
+    this._runHooks('afterDropTable', [name]);
     return r;
   }
 
   async findById(table, id) {
     await this._flush();
+    if (!this._runHooks('beforeFind', [table, { id }])) return null;
     const r = safeJsonParse(wasmBindings.jsql_find_by_id(table, BigInt(id)));
     if (r && r.error) throw new Error(r.error);
+    this._runHooks('afterFind', [table, { id }, r]);
     return r;
   }
 
   async find(table, filter, opts = {}) {
     await this._flush();
+    if (!this._runHooks('beforeFind', [table, { filter, opts }])) return [];
     const filterStr = filter ? JSON.stringify(filter) : '';
     const { limit = 100, offset = 0 } = opts;
     const r = safeJsonParse(wasmBindings.jsql_find(table, filterStr, limit, offset));
     if (r && r.error) throw new Error(r.error);
+    this._runHooks('afterFind', [table, { filter, opts }, r]);
     return r;
   }
 
   async count(table) {
     await this._flush();
+    this._runHooks('beforeCount', [table]);
     const r = parseInt(wasmBindings.jsql_count(table), 10);
-    return isNaN(r) ? 0 : r;
+    const n = isNaN(r) ? 0 : r;
+    this._runHooks('afterCount', [table, n]);
+    return n;
+  }
+
+  async updateByIds(table, entries) {
+    const pairs = entries.map(([id, data]) => [Number(id), data]);
+    if (!this._runHooks('beforeUpdate', [table, pairs])) return;
+    await this._flush();
+    const r = safeJsonParse(wasmBindings.jsql_update_by_ids(table, JSON.stringify(pairs)));
+    if (r && r.error) throw new Error(r.error);
+    this._emit('update', { table, entries: pairs, result: r });
+    this._runHooks('afterUpdate', [table, pairs, r]);
+    return r;
+  }
+
+  async removeByIds(table, ids) {
+    if (!this._runHooks('beforeDelete', [table, ids])) return;
+    await this._flush();
+    const r = safeJsonParse(wasmBindings.jsql_remove_by_ids(table, JSON.stringify(ids)));
+    if (r && r.error) throw new Error(r.error);
+    this._emit('delete', { table, ids, result: r });
+    this._runHooks('afterDelete', [table, ids, r]);
+    return r;
+  }
+
+  async findByIds(table, ids) {
+    await this._flush();
+    if (!this._runHooks('beforeFind', [table, { ids }])) return null;
+    const r = safeJsonParse(wasmBindings.jsql_find_by_ids(table, JSON.stringify(ids)));
+    if (r && r.error) throw new Error(r.error);
+    this._runHooks('afterFind', [table, { ids }, r]);
+    return r;
+  }
+
+  findByIdsRaw(table, ids) {
+    return this.findByIds(table, ids);
   }
 
   async updateById(table, id, data) {
+    if (!this._runHooks('beforeUpdate', [table, id, data])) return;
     await this._flush();
     const r = safeJsonParse(wasmBindings.jsql_update_by_id(table, BigInt(id), JSON.stringify(data)));
     if (r && r.ok === false) throw new Error(r.error || 'update failed');
+    this._emit('update', { table, id, data });
+    this._runHooks('afterUpdate', [table, id, data, r]);
     return r;
   }
 
   async removeById(table, id) {
+    if (!this._runHooks('beforeDelete', [table, id])) return;
     await this._flush();
     const r = safeJsonParse(wasmBindings.jsql_remove_by_id(table, BigInt(id)));
     if (r && r.ok === false) throw new Error(r.error || 'remove failed');
+    this._emit('delete', { table, id });
+    this._runHooks('afterDelete', [table, id, r]);
     return r;
   }
 
+  async hasTable(name) {
+    return this._tableNames.has(name);
+  }
+
+  async getTables() {
+    return Array.from(this._tableNames);
+  }
+
+  async getTableSchema(name) {
+    return this._schemas[name] || null;
+  }
+
   async stop() {
     await this._flush();
+    this._runHooks('onStop', []);
+    this._emit('stop', {});
   }
 }
 

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

@@ -0,0 +1,24 @@
+[package]
+name = "jsql-neo-core"
+version = "0.1.0"
+edition = "2021"
+description = "Embedded database engine — core library (supports WASM)"
+
+[lib]
+crate-type = ["lib", "cdylib"]
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1", features = ["preserve_order"] }
+chrono = { version = "0.4", default-features = false, features = ["clock", "wasmbind"] }
+crc32fast = "1"
+itoa = "1"
+ryu = "1"
+rustc-hash = "2"
+bincode = "1"
+wasm-bindgen = { version = "0.2", optional = true }
+js-sys = { version = "0.3", optional = true }
+
+[features]
+default = []
+wasm = ["wasm-bindgen", "js-sys"]