jsql-neo 6.4.0-beta.1 → 6.4.0-beta.11

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.1** — 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.11** — 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.1 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.4.0-beta.11 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/database.js

@@ -56,6 +56,35 @@ function parseFieldShorthand(str) {
     return def;
 }
 
+/**
+ * 深度相等比较两个行对象（用于无主键表的行匹配）。
+ * 剥离内部字段（_rid, _deleted）后逐字段比较。
+ */
+function _rowDeepEqual(a, b) {
+    if (a === b) return true;
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') return false;
+    const strip = (obj) => {
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (k === '_rid' || k === '_deleted') continue;
+            out[k] = v;
+        }
+        return out;
+    };
+    const sa = strip(a), sb = strip(b);
+    const ka = Object.keys(sa), kb = Object.keys(sb);
+    if (ka.length !== kb.length) return false;
+    for (const k of ka) {
+        if (!Object.prototype.hasOwnProperty.call(sb, k)) return false;
+        const va = sa[k], vb = sb[k];
+        if (va === vb) continue;
+        if (va === null || va === undefined || vb === null || vb === undefined) return false;
+        if (typeof va === 'number' && typeof vb === 'number' && va === vb) continue;
+        if (String(va) !== String(vb)) return false;
+    }
+    return true;
+}
+
 class Database {
     /**
      * @param {string} filePath - 数据库文件/目录路径，传 null 或 ':memory:' 使用内存模式
@@ -113,6 +142,12 @@ class Database {
         this._plugins = [];
         this._hooks = createHookRegistry();
         this._eventListeners = [];
+
+        // P1: {modules:true} 自动加载插件（mod.config + ~/.jsql/plugins/）
+        this._autoPlugins = options.modules !== false;
+        if (this._autoPlugins) {
+            this._loadAutoPlugins();
+        }
         this._tableNames = new Set(Object.keys(this._tables));
         this._migrations = [];
         this._observers = [];      // 响应式观察者
@@ -617,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;
 
@@ -661,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);
         }
@@ -706,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];
         }
@@ -731,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]);
     }
 
     /**
@@ -742,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;
@@ -761,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];
 
@@ -813,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;
     }
 
@@ -1570,6 +1614,80 @@ class Database {
         return buildPluginContext(this, plugin);
     }
 
+    /**
+     * P1 修复：{modules:true} 自动加载插件。
+     * 1. 通过 ModuleManager 读取 ~/.config/jsql/mod.config，应用已启用的模块
+     * 2. 扫描 ~/.jsql/plugins/ 加载 registry 安装的插件
+     */
+    _loadAutoPlugins() {
+        // 1. mod.config 中的模块
+        try {
+            const { ModuleManager } = require('./mod');
+            new ModuleManager().applyTo(this);
+        } catch (e) {
+            if (process.env.JSQL_DEBUG) console.warn('[database] Failed to load mod.config:', e.message);
+        }
+        // 2. ~/.jsql/plugins/ 中的 registry 插件
+        try {
+            this._loadInstalledPlugins();
+        } catch (e) {
+            if (process.env.JSQL_DEBUG) console.warn('[database] Failed to load installed plugins:', e.message);
+        }
+    }
+
+    /**
+     * 扫描 ~/.jsql/plugins/ 目录，加载已安装的 registry 插件。
+     * 兼容两种布局：根级入口文件 + plugins/ 子目录入口文件。
+     */
+    _loadInstalledPlugins() {
+        const os = require('os');
+        const fs = require('fs');
+        const PLUGIN_DIR = path.join(os.homedir(), '.jsql', 'plugins');
+        if (!fs.existsSync(PLUGIN_DIR)) return;
+        const entries = fs.readdirSync(PLUGIN_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+            const dir = path.join(PLUGIN_DIR, entry.name);
+            const manifestPath = path.join(dir, 'manifest.json');
+            if (!fs.existsSync(manifestPath)) continue;
+            let manifest;
+            try {
+                manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            } catch { continue; }
+            if (manifest.disabled) continue;
+            const pluginName = manifest.name || entry.name;
+            // 查找入口文件：manifest.main || manifest.entry || 'index.js'
+            const entryFile = manifest.main || manifest.entry || 'index.js';
+            // 兼容两种路径：根级 + plugins/ 子目录
+            const candidates = [
+                path.join(dir, entryFile),
+                path.join(dir, entryFile + '.js'),
+                path.join(dir, 'plugins', entryFile),
+                path.join(dir, 'plugins', entryFile + '.js'),
+            ];
+            let entryPath = null;
+            for (const c of candidates) {
+                if (fs.existsSync(c) && fs.statSync(c).isFile()) {
+                    entryPath = c;
+                    break;
+                }
+            }
+            if (!entryPath) continue;
+            try {
+                const resolved = require.resolve(entryPath);
+                delete require.cache[resolved];
+                const plugin = require(resolved);
+                if (typeof plugin === 'function') {
+                    this.use({ name: pluginName, install: plugin });
+                } else if (plugin && typeof plugin === 'object') {
+                    if (!plugin.name) plugin.name = pluginName;
+                    this.use(plugin);
+                }
+            } catch (e) {
+                if (process.env.JSQL_DEBUG) console.warn('[database] Failed to load plugin', entry.name, e.message);
+            }
+        }
+    }n
     on(event, fn) {
         return registerHook(this, event, fn);
     }
@@ -1614,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;
@@ -1663,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 = [];
@@ -1682,33 +1800,41 @@ 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;
     }
 
     _resolveId(table, id) {
         const pk = this._pkOf(table);
         if (pk) return table._rows.find(r => r[pk] === id) || null;
-        return table._rows[id - 1] || null;
+        // 无主键表：id 是行对象（可能是 find() 返回的浅拷贝）时，用内容匹配代替引用比较。
+        // 做法：逐行比对所有字段值是否相等；是数字时当 1-based 行号。
+        if (id && typeof id === 'object') {
+            const keys = Object.keys(id);
+            return table._rows.find(r => keys.every(k => r[k] === id[k])) || null;
+        }
+        const idx = Number(id);
+        if (!isNaN(idx)) return table._rows[idx - 1] || null;
+        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 || {});
@@ -1717,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;
     }
 
@@ -1730,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;
     }
 
@@ -1740,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;
     }
 
@@ -1769,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);
@@ -1808,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) {
@@ -1829,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 };
         }
@@ -1854,33 +1980,42 @@ 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);
         } else {
-            // 无主键表没有稳定的行标识，_resolveId 只能把 id 当 1-based 行号，
-            // 而 _rowPkId 在无主键时回退到 row.id（业务列名）——
-            // 两者语义不一致，导致 DELETE ... WHERE id IN (3,5) 删错行。
-            // 这里先按「行对象 === id」尝试（SQL 层可以直接传行引用），
-            // 退化到行号解析；并一次性收集目标后统一移除，避免边删边移位。
-            const targets = [];
+            // 无主键表没有稳定的行标识，P1-11 后 find() 返回浅拷贝（{...r}），
+            // 对象引用与 table._rows 里的原对象不同，不能用 Set.has(row) 做引用匹配。
+            // _resolveId 对无主键表做 table._rows[id-1]，传入对象时 id-1=NaN → undefined。
+            // 所以这里对对象 id 做深度相等匹配，对值 id 走 _resolveId（1-based 行号）。
             const seen = new Set();
-            const push = (row) => { if (row && !seen.has(row)) { seen.add(row); targets.push(row); } };
+            const targets = [];
             for (const id of ids) {
-                if (id && typeof id === 'object') { push(id); continue; }
-                push(this._resolveId(table, id));
+                let rowIndex;
+                if (id && typeof id === 'object') {
+                    // id 是行对象（find() 返回的浅拷贝），用深度相等匹配
+                    rowIndex = table._rows.findIndex(r => _rowDeepEqual(r, id));
+                } else {
+                    // id 是值（1-based 行号），_resolveId 能处理
+                    const original = this._resolveId(table, id);
+                    if (original) rowIndex = table._rows.indexOf(original);
+                }
+                if (rowIndex >= 0 && !seen.has(rowIndex)) {
+                    seen.add(rowIndex);
+                    targets.push(rowIndex);
+                }
             }
             if (targets.length) {
-                table._rows = table._rows.filter(r => !seen.has(r));
+                table._rows = table._rows.filter((_, idx) => !seen.has(idx));
                 removed = targets.length;
             }
             table._rebuildPKIndex();
@@ -1888,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 || {});
@@ -1907,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) {
@@ -1942,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);
@@ -1961,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;
     }
@@ -1984,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; }
@@ -2142,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);
@@ -2165,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);
                     }
                 }
             }