jsql-neo 6.4.0-beta.4 → 6.4.0-beta.6

package/README.md

@@ -3,7 +3,7 @@
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
 > MySQL, PostgreSQL, MongoDB, Redis, SQL, TypeScript, **and the browser**.
 
-> **v6.4.0-beta.4** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.4.0-beta.6** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
 
 ![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
 ![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v6.4.0-beta.4 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.4.0-beta.6 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/database.js

@@ -652,13 +652,13 @@ class Database {
         switch (op.op) {
             case 'createTable':
                 if (op.table && !this._tables[op.table]) {
-                    this.createTable(op.table, op.schema || {});
+                    this._createTableSync(op.table, op.schema || {});
                 }
                 return true;
 
             case 'dropTable':
                 if (op.table && this._tables[op.table]) {
-                    this.dropTable(op.table);
+                    this._dropTableSync(op.table);
                 }
                 return true;
 
@@ -696,22 +696,7 @@ class Database {
     // 表管理
     // ============================================================
 
-    createTable(name, schema) {
-        if (!name || name.length > 64 || name === '.' || name === '..' || /[\x00-\x1f/\\]|\.\./.test(name)) {
-            throw createError('ER_BAD_TABLE_NAME', name);
-        }
-        if (typeof schema === 'string') {
-            const parsed = {};
-            for (const seg of schema.split(',')) {
-                const trimmed = seg.trim();
-                if (!trimmed) continue;
-                const parts = trimmed.split(/\s+/);
-                const field = parts.shift();
-                parsed[field] = parts.join(' ').toLowerCase().trim() || 'string';
-            }
-            schema = parsed;
-        }
-        if (!this._runHooks('beforeCreateTable', [name, schema])) throw createError('ER_PLUGIN_ABORT', 'createTable aborted by plugin');
+    _createTableSync(name, schema) {
         if (this._tables[name] || (this._dirMode && this._meta.tables[name])) {
             throw createError('ER_TABLE_EXISTS_ERROR', name);
         }
@@ -741,13 +726,31 @@ class Database {
         this._markDirty(name);
         this._walWrite({ op: 'createTable', table: name, schema });
         this._emit('createTable', { name, schema });
-        this._runHooks('afterCreateTable', [name, schema]);
         return table;
     }
 
-    dropTable(name) {
-        if (!this._tables[name] && !(this._dirMode && this._meta.tables[name])) throw createError('ER_NO_SUCH_TABLE', name);
-        if (!this._runHooks('beforeDropTable', [name])) return;
+    async createTable(name, schema) {
+        if (!name || name.length > 64 || name === '.' || name === '..' || /[\x00-\x1f/\\]|\.\./.test(name)) {
+            throw createError('ER_BAD_TABLE_NAME', name);
+        }
+        if (typeof schema === 'string') {
+            const parsed = {};
+            for (const seg of schema.split(',')) {
+                const trimmed = seg.trim();
+                if (!trimmed) continue;
+                const parts = trimmed.split(/\s+/);
+                const field = parts.shift();
+                parsed[field] = parts.join(' ').toLowerCase().trim() || 'string';
+            }
+            schema = parsed;
+        }
+        if (!(await this._runHooks('beforeCreateTable', [name, schema]))) throw createError('ER_PLUGIN_ABORT', 'createTable aborted by plugin');
+        const table = this._createTableSync(name, schema);
+        await this._runHooks('afterCreateTable', [name, schema]);
+        return table;
+    }
+
+    _dropTableSync(name) {
         if (this._tables[name]) {
             delete this._tables[name];
         }
@@ -766,7 +769,13 @@ class Database {
         this._walWrite({ op: 'dropTable', table: name });
         this._markDirty(name);
         this._emit('dropTable', { name });
-        this._runHooks('afterDropTable', [name]);
+    }
+
+    async dropTable(name) {
+        if (!this._tables[name] && !(this._dirMode && this._meta.tables[name])) throw createError('ER_NO_SUCH_TABLE', name);
+        if (!(await this._runHooks('beforeDropTable', [name]))) return;
+        this._dropTableSync(name);
+        await this._runHooks('afterDropTable', [name]);
     }
 
     /**
@@ -777,7 +786,7 @@ class Database {
      * 各自都存了一份。漏掉任何一个都会留下一张「半改名」的表：
      * 查得到数据却列不出来，或者反过来。
      */
-    renameTable(oldName, newName, { ifExists = false } = {}) {
+    async renameTable(oldName, newName, { ifExists = false } = {}) {
         if (oldName === newName) {
             if (!this._tables[oldName]) {
                 if (ifExists) return false;
@@ -796,7 +805,7 @@ class Database {
             /[\x00-\x1f/\\]|\.\./.test(newName)) {
             throw createError('ER_BAD_TABLE_NAME', newName);
         }
-        if (!this._runHooks('beforeRenameTable', [oldName, newName])) return false;
+        if (!(await this._runHooks('beforeRenameTable', [oldName, newName]))) return false;
 
         const table = this._tables[oldName];
 
@@ -848,7 +857,7 @@ class Database {
         this._markDirty(newName);
         this._walWrite({ op: 'renameTable', from: oldName, to: newName });
         this._emit('renameTable', { from: oldName, to: newName });
-        this._runHooks('afterRenameTable', [oldName, newName]);
+        await this._runHooks('afterRenameTable', [oldName, newName]);
         return true;
     }
 
@@ -1723,7 +1732,7 @@ class Database {
     }
 
     async start() {
-        this._runHooks('onStart', []);
+        await this._runHooks('onStart', []);
         this._emit('start', {});
         if (this._dirMode && !this._sigInstalled) {
             this._sigInstalled = true;
@@ -1772,11 +1781,11 @@ class Database {
         }
     }
 
-    insert(tableName, data) {
+    async insert(tableName, data) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         const arr = Array.isArray(data) ? data : [data];
-        if (!this._runHooks('beforeInsert', [tableName, arr])) return [];
+        if (!(await this._runHooks('beforeInsert', [tableName, arr]))) return [];
         const pk = this._pkOf(table);
         const ids = [];
         const logged = [];
@@ -1791,20 +1800,20 @@ class Database {
         // 有主键才可幂等回放；无主键表回放会重复插行，故不记录
         if (pk) this._walWrite({ op: 'insert', table: tableName, rows: logged });
         this._emit('insert', { table: tableName, count: arr.length, ids });
-        this._runHooks('afterInsert', [tableName, arr, ids]);
+        await this._runHooks('afterInsert', [tableName, arr, ids]);
         this._markDirty(tableName);
         return ids;
     }
 
     async flush() {
-        if (!this._runHooks('beforeFlush', [])) return;
+        if (!(await this._runHooks('beforeFlush', []))) return;
         if (this._dirMode) {
             this._flushDirty();
             this._saveMeta();
         } else if (!this._memoryMode) {
             this.save();
         }
-        this._runHooks('afterFlush', []);
+        await this._runHooks('afterFlush', []);
         return this;
     }
 
@@ -1822,10 +1831,10 @@ class Database {
         return null;
     }
 
-    find(tableName, filter, opts = {}) {
+    async find(tableName, filter, opts = {}) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeFind', [tableName, { filter, opts }])) return [];
+        if (!(await this._runHooks('beforeFind', [tableName, { filter, opts }]))) return [];
         const { limit, offset = 0 } = opts;
         // P1-4: 软删除模式下不得泄露已删除行——只看可见行
         let rows = table._applyFilterOptimized(table._getVisibleRows(), filter || {});
@@ -1834,7 +1843,7 @@ class Database {
         // P1-11: 返回浅拷贝，防止调用方修改影响内部数据
         rows = rows.map(r => ({ ...r }));
         this._touchTable(tableName);
-        this._runHooks('afterFind', [tableName, { filter, opts }, rows]);
+        await this._runHooks('afterFind', [tableName, { filter, opts }, rows]);
         return rows;
     }
 
@@ -1847,9 +1856,9 @@ class Database {
 
     async query(sql, paramsOrOpts, opts) {
         const { executeSQL } = require('./sql');
-        if (!this._runHooks('beforeQuery', [sql, paramsOrOpts, opts])) return null;
+        if (!(await this._runHooks('beforeQuery', [sql, paramsOrOpts, opts]))) return null;
         const result = await executeSQL(this, sql, paramsOrOpts, opts);
-        this._runHooks('afterQuery', [sql, paramsOrOpts, opts, result]);
+        await this._runHooks('afterQuery', [sql, paramsOrOpts, opts, result]);
         return result;
     }
 
@@ -1857,28 +1866,28 @@ class Database {
         return require('./prepared').createPrepared(this, sql);
     }
 
-    findById(tableName, id) {
+    async findById(tableName, id) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeFind', [tableName, { id }])) return null;
+        if (!(await this._runHooks('beforeFind', [tableName, { id }]))) return null;
         const row = this._resolveId(table, id);
         // P1-4: 软删除行对普通读取不可见
         if (row && row._deleted) return null;
         // P1-11: 返回浅拷贝，防止调用方修改影响内部数据
         const result = row ? { ...row } : null;
         this._touchTable(tableName);
-        this._runHooks('afterFind', [tableName, { id }, result]);
+        await this._runHooks('afterFind', [tableName, { id }, result]);
         return result;
     }
 
-    findByIds(tableName, ids) {
+    async findByIds(tableName, ids) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeFind', [tableName, { ids }])) return null;
+        if (!(await this._runHooks('beforeFind', [tableName, { ids }]))) return null;
         // P1-4: 过滤掉软删除行；P1-11: 返回浅拷贝
         const rows = ids.map(id => this._resolveId(table, id)).filter(r => r !== null && !r._deleted).map(r => ({ ...r }));
         this._touchTable(tableName);
-        this._runHooks('afterFind', [tableName, { ids }, rows]);
+        await this._runHooks('afterFind', [tableName, { ids }, rows]);
         return rows;
     }
 
@@ -1886,21 +1895,21 @@ class Database {
         return this.findByIds(tableName, ids);
     }
 
-    count(tableName) {
+    async count(tableName) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        this._runHooks('beforeCount', [tableName]);
+        if (!(await this._runHooks('beforeCount', [tableName]))) return undefined;
         // P1-4: 软删除模式下只统计可见行
         const n = table._softDelete ? table._getVisibleRows().length : table._rows.length;
         this._touchTable(tableName);
-        this._runHooks('afterCount', [tableName, n]);
+        await this._runHooks('afterCount', [tableName, n]);
         return n;
     }
 
-    updateById(tableName, id, data) {
+    async updateById(tableName, id, data) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeUpdate', [tableName, id, data])) return;
+        if (!(await this._runHooks('beforeUpdate', [tableName, id, data]))) return;
         // P1-9: updateById 绕过类型校验——先校验再更新
         const validated = table._validateDataTypes({ ...data }, true);
         const row = this._resolveId(table, id);
@@ -1925,16 +1934,16 @@ class Database {
         Object.assign(row, validated);
         if (pk) this._walWrite({ op: 'update', table: tableName, pk, id, row: { ...validated } });
         this._emit('update', { table: tableName, id, data: validated });
-        this._runHooks('afterUpdate', [tableName, id, validated, { ok: true }]);
+        await this._runHooks('afterUpdate', [tableName, id, validated, { ok: true }]);
         this._markDirty(tableName);
         return { ok: true };
     }
 
-    updateByIds(tableName, entries) {
+    async updateByIds(tableName, entries) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         const pairs = entries.map(([id, data]) => [id, data]);
-        if (!this._runHooks('beforeUpdate', [tableName, pairs])) return;
+        if (!(await this._runHooks('beforeUpdate', [tableName, pairs]))) return;
         const pk = this._pkOf(table);
         let count = 0;
         for (const [id, data] of pairs) {
@@ -1946,21 +1955,21 @@ class Database {
             }
         }
         this._emit('update', { table: tableName, entries: pairs, result: { ok: true, count } });
-        this._runHooks('afterUpdate', [tableName, pairs, { ok: true, count }]);
+        await this._runHooks('afterUpdate', [tableName, pairs, { ok: true, count }]);
         this._markDirty(tableName);
         return { ok: true, count };
     }
 
-    removeById(tableName, id) {
+    async removeById(tableName, id) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeDelete', [tableName, id])) return;
+        if (!(await this._runHooks('beforeDelete', [tableName, id]))) return;
         if (table._primaryKey) {
             const removed = table.removeById(id);
             if (removed === 0) return { ok: false, error: 'not found' };
             this._walWrite({ op: 'remove', table: tableName, pk: table._primaryKey, id });
             this._emit('delete', { table: tableName, id });
-            this._runHooks('afterDelete', [tableName, id, { ok: true }]);
+            await this._runHooks('afterDelete', [tableName, id, { ok: true }]);
             this._markDirty(tableName);
             return { ok: true };
         }
@@ -1971,15 +1980,15 @@ class Database {
         table._rebuildAllBTrees();
         for (const field of Object.keys(table._indexes)) table.createIndex(field);
         this._emit('delete', { table: tableName, id });
-        this._runHooks('afterDelete', [tableName, id, { ok: true }]);
+        await this._runHooks('afterDelete', [tableName, id, { ok: true }]);
         this._markDirty(tableName);
         return { ok: true };
     }
 
-    removeByIds(tableName, ids) {
+    async removeByIds(tableName, ids) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeDelete', [tableName, ids])) return;
+        if (!(await this._runHooks('beforeDelete', [tableName, ids]))) return;
         let removed = 0;
         if (table._primaryKey) {
             for (const id of ids) removed += table.removeById(id);
@@ -2014,15 +2023,15 @@ class Database {
             for (const field of Object.keys(table._indexes)) table.createIndex(field);
         }
         this._emit('delete', { table: tableName, ids, result: { ok: true, count: removed } });
-        this._runHooks('afterDelete', [tableName, ids, { ok: true, count: removed }]);
+        await this._runHooks('afterDelete', [tableName, ids, { ok: true, count: removed }]);
         this._markDirty(tableName);
         return { ok: true, count: removed };
     }
 
-    removeWhere(tableName, filter) {
+    async removeWhere(tableName, filter) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeDelete', [tableName, [filter]])) return { ok: true, count: 0 };
+        if (!(await this._runHooks('beforeDelete', [tableName, [filter]]))) return { ok: true, count: 0 };
         const before = table._rows.length;
         // P1-4: 只匹配可见行（软删除行已“不存在”，不应被硬删操作波及）
         const matched = table._applyFilter(table._getVisibleRows(), filter || {});
@@ -2033,31 +2042,31 @@ class Database {
         table._rebuildAllBTrees();
         for (const field of Object.keys(table._indexes)) table.createIndex(field);
         this._emit('delete', { table: tableName, ids: [], result: { ok: true, count: removed } });
-        this._runHooks('afterDelete', [tableName, [filter], { ok: true, count: removed }]);
+        await this._runHooks('afterDelete', [tableName, [filter], { ok: true, count: removed }]);
         this._markDirty(tableName);
         return { ok: true, count: removed };
     }
 
-    insertMany(tableName, items) {
+    async insertMany(tableName, items) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         const arr = Array.isArray(items) ? items : [items];
-        if (!this._runHooks('beforeInsert', [tableName, arr])) return [];
+        if (!(await this._runHooks('beforeInsert', [tableName, arr]))) return [];
         const inserted = table.insertMany(arr);
         // P1-6: insertMany 不写 WAL——崩溃恢复时丢失这些操作
         if (table._primaryKey && inserted.length > 0) {
             this._walWrite({ op: 'insert', table: tableName, rows: inserted });
         }
         this._emit('insert', { table: tableName, count: arr.length });
-        this._runHooks('afterInsert', [tableName, arr, inserted]);
+        await this._runHooks('afterInsert', [tableName, arr, inserted]);
         this._markDirty(tableName);
         return inserted;
     }
 
-    update(tableName, query, updates) {
+    async update(tableName, query, updates) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeUpdate', [tableName, query, updates])) return 0;
+        if (!(await this._runHooks('beforeUpdate', [tableName, query, updates]))) return 0;
         const count = table.update(query, updates);
         // P1-6: update 不写 WAL——崩溃恢复时丢失这些操作
         if (table._primaryKey && count > 0) {
@@ -2068,15 +2077,15 @@ class Database {
           }
         }
         this._emit('update', { table: tableName, query, count });
-        this._runHooks('afterUpdate', [tableName, query, updates, count]);
+        await this._runHooks('afterUpdate', [tableName, query, updates, count]);
         this._markDirty(tableName);
         return count;
     }
 
-    delete(tableName, query = {}) {
+    async delete(tableName, query = {}) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
-        if (!this._runHooks('beforeDelete', [tableName, query])) return 0;
+        if (!(await this._runHooks('beforeDelete', [tableName, query]))) return 0;
         // P1-6: delete 不写 WAL——崩溃恢复时丢失这些操作
         if (table._primaryKey) {
           const toDelete = table.find(query);
@@ -2087,7 +2096,7 @@ class Database {
         }
         const count = table.remove(query);
         this._emit('delete', { table: tableName, query, count });
-        this._runHooks('afterDelete', [tableName, query, count]);
+        await this._runHooks('afterDelete', [tableName, query, count]);
         this._markDirty(tableName);
         return count;
     }
@@ -2110,7 +2119,7 @@ class Database {
     }
 
     async stop() {
-        this._runHooks('onStop', []);
+        await this._runHooks('onStop', []);
         this._emit('stop', {});
         // 内存监控定时器：stop() 此前从不清理，重复创建/销毁实例会堆积定时器
         if (this._monitorTimer) { clearInterval(this._monitorTimer); this._monitorTimer = null; }
@@ -2268,7 +2277,7 @@ class Database {
         if (this._jsqlMode) {
             this._jsqlFormat._open();
             for (const [name, t] of this._jsqlFormat.tables) {
-                if (!this._tables[name]) this.createTable(name, t.schema);
+                if (!this._tables[name]) this._createTableSync(name, t.schema);
                 if (t.rowCount > 0) {
                     const { rows } = this._jsqlFormat.readTableSync(name);
                     this._tables[name]._loadRows(rows);
@@ -2291,7 +2300,7 @@ class Database {
             if (data.__schema__) {
                 for (const [name, schema] of Object.entries(data.__schema__)) {
                     if (!this._tables[name]) {
-                        this.createTable(name, schema);
+                        this._createTableSync(name, schema);
                     }
                 }
             }

package/lib/native_client.js

@@ -401,7 +401,7 @@ class JSQL {
       }, this._evictInterval);
       if (this._evictTimer.unref) this._evictTimer.unref();
     }
-    this._runHooks('onStart', []);
+    await this._runHooks('onStart', []);
     this._emit('start', {});
   }
 
@@ -554,7 +554,7 @@ class JSQL {
 
   async _flush() {
     this._flushOpsNow();
-    if (!this._runHooks('beforeFlush', [])) return null;
+    if (!(await this._runHooks('beforeFlush', []))) return null;
     // 先把整个 buffer 原子取出再写入。
     // 旧写法是遍历 this._buffer、await 之后才清空 —— 期间其他协程继续往同一个数组
     // push，同一批行会被多个 flush 重复写入（并发 insert 行数暴涨/丢行）。
@@ -579,7 +579,7 @@ class JSQL {
       });
       throw e;
     }
-    this._runHooks('afterFlush', []);
+    await this._runHooks('afterFlush', []);
     return flushed;
   }
 
@@ -611,7 +611,7 @@ class JSQL {
     const arr = Array.isArray(data) ? data : [data];
     arr.forEach((row, i) => assertRowObject(row, i, arr.length > 1 || Array.isArray(data)));
     var filtered = arr;
-    if (!this._runHooks('beforeInsert', [table, filtered])) return [];
+    if (!(await this._runHooks('beforeInsert', [table, filtered]))) return [];
     if (arr.length > 1) {
       await this._flush();
       let result;
@@ -622,7 +622,7 @@ class JSQL {
         if (!result) result = r;
       }
       this._emit('insert', { table, count: arr.length, ids: result });
-      this._runHooks('afterInsert', [table, filtered, result]);
+      await this._runHooks('afterInsert', [table, filtered, result]);
       return result;
     }
     if (!this._buffer[table]) this._buffer[table] = [];
@@ -631,20 +631,20 @@ class JSQL {
     const flushed = await this._flush();
     const result = flushed && flushed[table] ? flushed[table] : null;
     this._emit('insert', { table, count: arr.length, ids: result });
-    this._runHooks('afterInsert', [table, filtered, result]);
+    await this._runHooks('afterInsert', [table, filtered, result]);
     return result;
   }
 
   async createTable(name, schema) {
     await this._flush();
     if (typeof schema === 'string') schema = parseSchemaString(schema);
-    if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
+    if (!(await this._runHooks('beforeCreateTable', [name, schema]))) return null;
     const r = safeParse(this._n('jsqlCreateTable', name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
     this._tableNames.add(name);
     this._schemas[name] = typeof schema === 'string' ? mapNativeSchema(schema) : schema;
     this._emit('createTable', { name, schema });
-    this._runHooks('afterCreateTable', [name, schema]);
+    await this._runHooks('afterCreateTable', [name, schema]);
     return r;
   }
 
@@ -661,30 +661,30 @@ class JSQL {
 
   async dropTable(name) {
     await this._flush();
-    if (!this._runHooks('beforeDropTable', [name])) return null;
+    if (!(await this._runHooks('beforeDropTable', [name]))) return null;
     const r = safeParse(this._n('jsqlDropTable', 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]);
+    await this._runHooks('afterDropTable', [name]);
     return r;
   }
 
-  findById(table, id) {
+  async findById(table, id) {
     this._flushOpsNow();
-    if (!this._runHooks('beforeFind', [table, { id }])) return null;
+    if (!(await this._runHooks('beforeFind', [table, { id }]))) return null;
     const raw = this._findRawById(table, id);
     if (raw && raw.error) throw new Error(raw.error);
-    this._runHooks('afterFind', [table, { id }, raw]);
+    await this._runHooks('afterFind', [table, { id }, raw]);
     const schema = this._schemas[table];
     if (schema && raw && typeof raw === 'object') return restoreRow(raw, schema);
     return raw;
   }
 
-  findByIds(table, ids) {
+  async findByIds(table, ids) {
     this._flushOpsNow();
-    if (!this._runHooks('beforeFind', [table, { ids }])) return null;
+    if (!(await this._runHooks('beforeFind', [table, { ids }]))) return null;
     let r;
     if (this._pkOf(table)) {
       r = ids.map(id => this._findRawById(table, id)).filter(x => x !== null && !(x && x.error));
@@ -692,7 +692,7 @@ class JSQL {
       r = safeParse(this._n('jsqlFindByIds', table, JSON.stringify(ids)));
     }
     if (r && r.error) throw new Error(r.error);
-    this._runHooks('afterFind', [table, { ids }, r]);
+    await this._runHooks('afterFind', [table, { ids }, r]);
     const schema = this._schemas[table];
     if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
@@ -704,12 +704,12 @@ class JSQL {
 
   async find(table, filter, opts = {}) {
     this._flushOpsNow();
-    if (!this._runHooks('beforeFind', [table, { filter, opts }])) return [];
+    if (!(await this._runHooks('beforeFind', [table, { filter, opts }]))) return [];
     const filterStr = filter ? JSON.stringify(filter) : '';
     const { limit = 100, offset = 0 } = opts;
     const r = safeParse(this._n('jsqlFind', table, filterStr, limit, offset));
     if (r && r.error) throw new Error(r.error);
-    this._runHooks('afterFind', [table, { filter, opts }, r]);
+    await this._runHooks('afterFind', [table, { filter, opts }, r]);
     const schema = this._schemas[table];
     if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
@@ -717,27 +717,27 @@ class JSQL {
 
   async count(table) {
     this._flushOpsNow();
-    this._runHooks('beforeCount', [table]);
+    await this._runHooks('beforeCount', [table]);
     const r = parseInt(this._n('jsqlCount', table), 10);
     const n = isNaN(r) ? 0 : r;
-    this._runHooks('afterCount', [table, n]);
+    await this._runHooks('afterCount', [table, n]);
     return n;
   }
 
-  updateByIds(table, entries) {
+  async updateByIds(table, entries) {
     const pairs = [];
     for (const [id, data] of entries) {
       const seq = this._seqIdByPk(table, id);
       if (seq !== null) pairs.push([seq, data]);
     }
-    if (!this._runHooks('beforeUpdate', [table, pairs])) return;
+    if (!(await this._runHooks('beforeUpdate', [table, pairs]))) return;
     if (!this._opBuffer.update[table]) this._opBuffer.update[table] = [];
     this._opBuffer.update[table].push(...pairs);
     this._scheduleOpFlush();
   }
 
-  removeByIds(table, ids) {
-    if (!this._runHooks('beforeDelete', [table, ids])) return;
+  async removeByIds(table, ids) {
+    if (!(await this._runHooks('beforeDelete', [table, ids]))) return;
     if (!this._opBuffer.remove[table]) this._opBuffer.remove[table] = new Set();
     for (const id of ids) {
       const seq = this._seqIdByPk(table, id);
@@ -746,8 +746,8 @@ class JSQL {
     this._scheduleOpFlush();
   }
 
-  updateById(table, id, data) {
-    if (!this._runHooks('beforeUpdate', [table, id, data])) return;
+  async updateById(table, id, data) {
+    if (!(await this._runHooks('beforeUpdate', [table, id, data]))) return;
     const seq = this._seqIdByPk(table, id);
     if (seq === null) return;
     // 改主键 / UNIQUE 列前先查冲突（同步版，与 lib/database.js 的修复对齐）。
@@ -785,8 +785,8 @@ class JSQL {
     }
   }
 
-  removeById(table, id) {
-    if (!this._runHooks('beforeDelete', [table, id])) return;
+  async removeById(table, id) {
+    if (!(await this._runHooks('beforeDelete', [table, id]))) return;
     const seq = this._seqIdByPk(table, id);
     if (seq === null) return;
     if (!this._opBuffer.remove[table]) this._opBuffer.remove[table] = new Set();
@@ -814,9 +814,9 @@ class JSQL {
    * await db.query("UPDATE users SET age = age + 1 WHERE name = 'A'");
    */
   async query(sql, paramsOrOpts, opts) {
-    if (!this._runHooks('beforeQuery', [sql, paramsOrOpts, opts])) return null;
+    if (!(await this._runHooks('beforeQuery', [sql, paramsOrOpts, opts]))) return null;
     const result = await executeSQL(this, sql, paramsOrOpts, opts);
-    this._runHooks('afterQuery', [sql, paramsOrOpts, opts, result]);
+    await this._runHooks('afterQuery', [sql, paramsOrOpts, opts, result]);
     return result;
   }
 
@@ -847,7 +847,7 @@ class JSQL {
       } catch (e) { /* ignore */ }
       this._handle = null;
     }
-    this._runHooks('onStop', []);
+    await this._runHooks('onStop', []);
     this._emit('stop', {});
   }
 

package/lib/plugin.js

@@ -238,7 +238,7 @@ function applyPlugin(engine, plugin, opts) {
  * - 任一钩子返回 false → 中止（返回 false），引擎据此跳过本次操作；
  * - native 引擎置 `_forbidReentry`，钩子内再次触发引擎操作会抛 ER_PLUGIN_REENTRY。
  */
-async function runHooks(engine, hookName, args) {
+function runHooks(engine, hookName, args) {
   const hooks = engine._hooks && engine._hooks[hookName];
   if (!hooks || hooks.length === 0) return true;
 
@@ -250,16 +250,18 @@ async function runHooks(engine, hookName, args) {
     }
     engine._inHook = true;
   }
-  try {
-    for (const fn of hooks) {
-      // P3-3: runHooks 异步钩子静默失效——支持异步钩子
-      const result = await fn(...args);
-      if (result === false) return false;
+
+  return (async () => {
+    try {
+      for (const fn of hooks) {
+        const result = await fn(...args);
+        if (result === false) return false;
+      }
+      return true;
+    } finally {
+      if (guard) engine._inHook = false;
     }
-    return true;
-  } finally {
-    if (guard) engine._inHook = false;
-  }
+  })();
 }
 
 module.exports = {

package/lib/wasm_client.js

@@ -406,7 +406,7 @@ class JSQL {
 
   async start() {
     wasmBindings.jsql_reset();
-    this._runHooks('onStart', []);
+    await this._runHooks('onStart', []);
     this._emit('start', {});
   }
 
@@ -516,7 +516,7 @@ class JSQL {
   }
 
   async _flush() {
-    if (!this._runHooks('beforeFlush', [])) return null;
+    if (!(await this._runHooks('beforeFlush', []))) return null;
     // 先把整个 buffer 原子取出再写入。
     // 旧写法是遍历 this._buffer 然后在 await 之后才清空 —— 这期间其他协程会继续
     // 往同一个数组 push，导致同一批行被多个 flush 重复写（并发 insert 行数暴涨）。
@@ -541,7 +541,7 @@ class JSQL {
       });
       throw e;
     }
-    this._runHooks('afterFlush', []);
+    await this._runHooks('afterFlush', []);
     return flushed;
   }
 
@@ -559,7 +559,7 @@ class JSQL {
     // 难以定位的 "Cannot convert undefined or null to object"，这里直接给明确 TypeError
     const arr = Array.isArray(data) ? data : [data];
     arr.forEach((row, i) => assertRowObject(row, i, arr.length > 1 || Array.isArray(data)));
-    if (!this._runHooks('beforeInsert', [table, arr])) return [];
+    if (!(await this._runHooks('beforeInsert', [table, arr]))) return [];
     if (arr.length > 1) {
       await this._flush();
       let result;
@@ -570,7 +570,7 @@ class JSQL {
         if (!result) result = r;
       }
       this._emit('insert', { table, count: arr.length, ids: result });
-      this._runHooks('afterInsert', [table, arr, result]);
+      await this._runHooks('afterInsert', [table, arr, result]);
       return result;
     }
     if (!this._buffer[table]) this._buffer[table] = [];
@@ -579,7 +579,7 @@ class JSQL {
     const flushed = await this._flush();
     const result = flushed && flushed[table] ? flushed[table] : null;
     this._emit('insert', { table, count: arr.length, ids: result });
-    this._runHooks('afterInsert', [table, arr, result]);
+    await this._runHooks('afterInsert', [table, arr, result]);
     return result;
   }
 
@@ -590,13 +590,13 @@ class JSQL {
   async createTable(name, schema) {
     await this._flush();
     if (typeof schema === 'string') schema = parseSchemaString(schema);
-    if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
+    if (!(await this._runHooks('beforeCreateTable', [name, schema]))) return null;
     const r = safeJsonParse(wasmBindings.jsql_create_table(name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
     this._tableNames.add(name);
     this._schemas[name] = typeof schema === 'string' ? mapNativeSchema(schema) : schema;
     this._emit('createTable', { name, schema });
-    this._runHooks('afterCreateTable', [name, schema]);
+    await this._runHooks('afterCreateTable', [name, schema]);
     return r;
   }
 
@@ -613,22 +613,22 @@ class JSQL {
 
   async dropTable(name) {
     await this._flush();
-    if (!this._runHooks('beforeDropTable', [name])) return null;
+    if (!(await 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]);
+    await this._runHooks('afterDropTable', [name]);
     return r;
   }
 
   async findById(table, id) {
     await this._flush();
-    if (!this._runHooks('beforeFind', [table, { id }])) return null;
+    if (!(await this._runHooks('beforeFind', [table, { id }]))) return null;
     const r = this._findRawById(table, id);
     if (r && r.error) throw new Error(r.error);
-    this._runHooks('afterFind', [table, { id }, r]);
+    await this._runHooks('afterFind', [table, { id }, r]);
     const schema = this._schemas[table];
     if (schema && r && typeof r === 'object') return restoreRow(r, schema);
     return r;
@@ -636,12 +636,12 @@ class JSQL {
 
   async find(table, filter, opts = {}) {
     await this._flush();
-    if (!this._runHooks('beforeFind', [table, { filter, opts }])) return [];
+    if (!(await 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]);
+    await this._runHooks('afterFind', [table, { filter, opts }, r]);
     const schema = this._schemas[table];
     if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
@@ -649,10 +649,10 @@ class JSQL {
 
   async count(table) {
     await this._flush();
-    this._runHooks('beforeCount', [table]);
+    await this._runHooks('beforeCount', [table]);
     const r = parseInt(wasmBindings.jsql_count(table), 10);
     const n = isNaN(r) ? 0 : r;
-    this._runHooks('afterCount', [table, n]);
+    await this._runHooks('afterCount', [table, n]);
     return n;
   }
 
@@ -662,29 +662,29 @@ class JSQL {
       const seq = this._seqIdByPk(table, id);
       if (seq !== null) pairs.push([seq, data]);
     }
-    if (!this._runHooks('beforeUpdate', [table, pairs])) return;
+    if (!(await 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]);
+    await this._runHooks('afterUpdate', [table, pairs, r]);
     return r;
   }
 
   async removeByIds(table, ids) {
-    if (!this._runHooks('beforeDelete', [table, ids])) return;
+    if (!(await this._runHooks('beforeDelete', [table, ids]))) return;
     await this._flush();
     const seqs = ids.map(id => this._seqIdByPk(table, id)).filter(s => s !== null);
     const r = safeJsonParse(wasmBindings.jsql_remove_by_ids(table, JSON.stringify(seqs)));
     if (r && r.error) throw new Error(r.error);
     this._emit('delete', { table, ids: seqs, result: r });
-    this._runHooks('afterDelete', [table, ids, r]);
+    await this._runHooks('afterDelete', [table, ids, r]);
     return r;
   }
 
   async findByIds(table, ids) {
     await this._flush();
-    if (!this._runHooks('beforeFind', [table, { ids }])) return null;
+    if (!(await this._runHooks('beforeFind', [table, { ids }]))) return null;
     let r;
     if (this._pkOf(table)) {
       r = ids.map(id => this._findRawById(table, id)).filter(x => x !== null && !(x && x.error));
@@ -692,7 +692,7 @@ class JSQL {
       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]);
+    await this._runHooks('afterFind', [table, { ids }, r]);
     const schema = this._schemas[table];
     if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
@@ -703,7 +703,7 @@ class JSQL {
   }
 
   async updateById(table, id, data) {
-    if (!this._runHooks('beforeUpdate', [table, id, data])) return;
+    if (!(await this._runHooks('beforeUpdate', [table, id, data]))) return;
     await this._flush();
     const seq = this._seqIdByPk(table, id);
     if (seq === null) return null;
@@ -716,7 +716,7 @@ class JSQL {
     const r = safeJsonParse(wasmBindings.jsql_update_by_id(table, BigInt(seq), 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]);
+    await this._runHooks('afterUpdate', [table, id, data, r]);
     return r;
   }
 
@@ -750,14 +750,14 @@ class JSQL {
   }
 
   async removeById(table, id) {
-    if (!this._runHooks('beforeDelete', [table, id])) return;
+    if (!(await this._runHooks('beforeDelete', [table, id]))) return;
     await this._flush();
     const seq = this._seqIdByPk(table, id);
     if (seq === null) return null;
     const r = safeJsonParse(wasmBindings.jsql_remove_by_id(table, BigInt(seq)));
     if (r && r.ok === false) throw new Error(r.error || 'remove failed');
     this._emit('delete', { table, id });
-    this._runHooks('afterDelete', [table, id, r]);
+    await this._runHooks('afterDelete', [table, id, r]);
     return r;
   }
 
@@ -818,9 +818,9 @@ class JSQL {
    * const rows = await db.query("SELECT * FROM users WHERE age > ?", [21]);
    */
   async query(sql, paramsOrOpts, opts) {
-    if (!this._runHooks('beforeQuery', [sql, paramsOrOpts, opts])) return null;
+    if (!(await this._runHooks('beforeQuery', [sql, paramsOrOpts, opts]))) return null;
     const result = await executeSQL(this, sql, paramsOrOpts, opts);
-    this._runHooks('afterQuery', [sql, paramsOrOpts, opts, result]);
+    await this._runHooks('afterQuery', [sql, paramsOrOpts, opts, result]);
     return result;
   }
 
@@ -835,7 +835,7 @@ class JSQL {
 
   async stop() {
     await this._flush();
-    this._runHooks('onStop', []);
+    await this._runHooks('onStop', []);
     this._emit('stop', {});
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.4.0-beta.4",
+  "version": "6.4.0-beta.6",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",

package/test/query-opt.test.js

@@ -32,9 +32,9 @@ function ok(name, cond, extra) {
   ok('string prefix z', bt.prefix('z').length === 0);
 }
 
-{
+(async () => {
   const db = new Database(':memory:');
-  db.createTable('users', {
+  await db.createTable('users', {
     id: { type: 'integer', primaryKey: true, autoIncrement: true },
     name: { type: 'string', unique: true },
     age: { type: 'integer' }
@@ -63,11 +63,11 @@ function ok(name, cond, extra) {
 
   const one = db.users.findOne({ name: 'bob' });
   ok('findOne no full clone', one && one.name === 'bob' && one.age === 40);
-}
+})();
 
 (async () => {
   const db = new Database(':memory:');
-  db.createTable('users', {
+  await db.createTable('users', {
     id: { type: 'integer', primaryKey: true, autoIncrement: true },
     name: { type: 'string' },
     age: { type: 'integer' }
@@ -91,18 +91,18 @@ function ok(name, cond, extra) {
   {
     const pdb = new Database(':memory:');
     pdb.use('timestamps', { createdField: 'created_at', updatedField: 'updated_at' });
-    pdb.createTable('notes', { id: { type: 'integer', primaryKey: true, autoIncrement: true }, title: { type: 'string' } });
+    await pdb.createTable('notes', { id: { type: 'integer', primaryKey: true, autoIncrement: true }, title: { type: 'string' } });
     const schema = pdb.getTableSchema('notes');
     ok('use opts timestamps fields', !!(schema && schema.created_at && schema.updated_at), schema);
-    pdb.insert('notes', { title: 'hello' });
+    await pdb.insert('notes', { title: 'hello' });
     const row = pdb.notes.findOne({ title: 'hello' });
     ok('timestamps stamped', !!(row && row.created_at && row.updated_at), row);
 
     let afterInsertHits = 0;
     pdb.on('afterInsert', () => { afterInsertHits++; });
-    pdb.insert('notes', { title: 'one' });
+    await pdb.insert('notes', { title: 'one' });
     ok('single-row afterInsert', afterInsertHits === 1, afterInsertHits);
-    pdb.insert('notes', [{ title: 'a' }, { title: 'b' }]);
+    await pdb.insert('notes', [{ title: 'a' }, { title: 'b' }]);
     ok('batch afterInsert', afterInsertHits === 2, afterInsertHits);
   }