monsqlize 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -1,7 +1,7 @@
 # 变更日志 (CHANGELOG)
 
 > **说明**: 版本概览摘要，详细变更见 [changelogs/](./changelogs/) 目录  
-> **最后更新**: 2026-04-13
+> **最后更新**: 2026-04-24
 
 ---
 
@@ -9,6 +9,8 @@
 
 | 版本 | 日期 | 变更摘要 | 详细 |
 |------|------|---------|------|
+| [v1.2.2](./changelogs/v1.2.2.md) | 2026-04-24 | 🆕 **新功能**：Model 数据源绑定 — `connection: { pool?, database? }` 支持 Model 绑定指定连接池和/或数据库，四种组合路由，向后兼容；🐛 **Bug Fix**：修复 `Model._clear()` 导致 `msq.model()` 实例缓存失效失效，populate 关系丢失问题 | [查看](./changelogs/v1.2.2.md) |
+| [v1.2.1](./changelogs/v1.2.1.md) | 2026-04-13 | 🐛 **Bug 修复**：`msq.model()` 实例缓存 + 索引去重 + 死代码清理 + `types/monsqlize.ts` 补全 `model()` / `collection()` 类型 | [查看](./changelogs/v1.2.1.md) |
 | [v1.2.0](./changelogs/v1.2.0.md) | 2026-04-13 | 🐛 **Bug 修复 + 新功能**：`findPage` 正式支持 `projection` 投影参数（修复静默忽略问题）+ 有效投影策略自动保护游标排序字段 + 8 个测试用例 | [查看](./changelogs/v1.2.0.md) |
 | [v1.1.9](./changelogs/v1.1.9.md) | 2026-04-02 | 🚨 **P1 Bug 修复**：MultiLevelCache L2→L1 回填 TTL 缺失（null 永久驻留 L1）+ 新增 `backfillLocalTTL` 配置 + Redis `getWithTTL` 方法 + 14 个回归测试 | [查看](./changelogs/v1.1.9.md) |
 | [v1.1.8](./changelogs/v1.1.8.md) | 2026-03-16 | 🆕 **新功能**：Model 热重载支持（`undefine()` + `redefine()` + `_loadModels` reload 模式）+ 22个测试 (100%通过) | [查看](./changelogs/v1.1.8.md) |

package/README.md

@@ -314,78 +314,102 @@ await msq.close();
 
 > **📦 依赖说明**: Model 层需要 `schema-dsl` 包支持（已随 monsqlize 自动安装，无需额外操作）
 
+Model 层有两种使用方式，二者**互斥**，选其一即可：
+
+| 方式 | 适合场景 |
+|------|---------|
+| **手动注册**（`Model.define()`）| 少量 Model、测试环境、需要精确控制加载顺序 |
+| **自动加载**（`models:` 配置项）| 生产环境，Model 文件统一放在一个目录下 |
+
+#### 方式一：手动注册
+
 ```javascript
 const MonSQLize = require('monsqlize');
 const { Model } = MonSQLize;
 
-const msq = new MonSQLize({
-    type: 'mongodb',
-    databaseName: 'mydb',
-    config: { uri: 'mongodb://localhost:27017' },
-    cache: { enabled: true },
-    models: './models'  // 🆕 v1.0.7: 自动加载 Model 文件
-});
-
-await msq.connect();  // 自动加载 models/*.model.js
-
-// 1. 定义 Model（带 Schema 验证、Relations 和 Hooks）
+// 1. 先在 connect() 之前调用 Model.define() 注册所有 Model
 Model.define('users', {
-    // 🔴 Schema 验证（默认启用，v1.0.7+，基于 schema-dsl 库）
     schema: (dsl) => dsl({
-        username: 'string:3-32!',      // 必需，3-32 字符
-        email: 'email!',               // 必需，邮箱格式
-        password: 'string:6-!',        // 必需，至少 6 字符
-        age: 'number:0-120',           // 可选，0-120 范围
-        role: 'string?'                // 可选字符串
+        username: 'string:3-32!',
+        email: 'email!',
+        password: 'string:6-!',
+        age: 'number:0-120'
     }),
-    
-    // Relations（关联查询）
     relations: {
-        posts: {  // 用户的文章
-            from: 'posts',
-            localField: '_id',
-            foreignField: 'userId',
-            single: false
-        }
+        posts: { from: 'posts', localField: '_id', foreignField: 'userId', single: false }
     },
-    
-    // Hooks（生命周期钩子）
     hooks: (model) => ({
-        insert: {
-            before: async (ctx, doc) => {
-                doc.createdAt = new Date();  // 自动添加时间戳
-                return doc;
-            }
-        }
+        insert: { before: async (ctx, doc) => { doc.createdAt = new Date(); return doc; } }
     }),
-    
-    // 自定义方法
     methods: (model) => ({
-        instance: {
-            // 文档方法（注入到查询结果）
-            checkPassword(password) {
-                return this.password === password;
-            }
-        },
-        static: {
-            // Model 方法
-            async findByUsername(username) {
-                return await model.findOne({ username });
-            }
-        }
+        instance: { checkPassword(password) { return this.password === password; } },
+        static: { async findByUsername(username) { return await model.findOne({ username }); } }
     })
 });
 
 Model.define('posts', {
-    schema: (dsl) => dsl({
-        title: 'string:1-200!',
-        content: 'string!',
-        userId: 'string!'
-    })
+    schema: (dsl) => dsl({ title: 'string:1-200!', content: 'string!', userId: 'string!' })
 });
 
-// 2. 使用 Model
+// 2. 创建实例并连接
+const msq = new MonSQLize({
+    type: 'mongodb',
+    databaseName: 'mydb',
+    config: { uri: 'mongodb://localhost:27017' },
+    cache: { enabled: true }
+});
+await msq.connect();
+
+// 3. 获取 Model 并使用
 const User = msq.model('users');
+```
+
+#### 方式二：自动加载（推荐用于生产环境）
+
+将每个 Model 单独放在一个文件里，`connect()` 时自动扫描目录加载，无需手动 `Model.define()`：
+
+```javascript
+// app.js
+const path = require('path');
+
+const msq = new MonSQLize({
+    type: 'mongodb',
+    databaseName: 'mydb',
+    config: { uri: 'mongodb://localhost:27017' },
+    // 推荐用绝对路径，避免受 process.cwd() 影响
+    models: path.join(__dirname, 'models')
+    // 或完整配置：
+    // models: { path: path.join(__dirname, 'models'), pattern: '*.model.js', recursive: true }
+});
+
+await msq.connect();            // ← 自动扫描 models/*.model.{js,ts,mjs,cjs}
+
+const User = msq.model('users'); // 直接使用，无需 Model.define()
+```
+
+> 相对路径（如 `'./models'`）以 `process.cwd()` 为基准，即 Node.js 进程的启动目录。为避免歧义，推荐始终使用 `path.join(__dirname, 'models')` 这样的绝对路径。
+
+```javascript
+// models/user.model.js  ← 每个 Model 独立一个文件
+module.exports = {
+    name: 'users',              // 集合名称（必需）
+    schema: (dsl) => dsl({
+        username: 'string:3-32!',
+        email: 'email!'
+    }),
+    methods: (model) => ({
+        static: {
+            async findByUsername(username) { return await model.findOne({ username }); }
+        }
+    })
+};
+```
+
+> 详细说明（完整配置项、文件格式、错误处理）见 [docs/model.md — Model 自动加载](./docs/model.md#model-自动加载v107)
+
+#### 两种方式共同的后续操作
+
+```javascript
 
 // ✅ Schema 验证自动生效
 try {
@@ -432,6 +456,35 @@ await User.insertOne(doc, { skipValidation: true });
 - ✅ **Relations** - 定义表关系（hasOne/hasMany/belongsTo）
 - ✅ **自定义方法** - instance 方法注入到文档，static 方法挂载到 Model
 - ✅ **自动缓存** - Populate 查询结果也会缓存
+- ✅ **数据源绑定** - `connection: { pool?, database? }` 绑定指定连接池和/或数据库（v1.2.2+）
+
+**数据源绑定示例（v1.2.2+）**：
+
+```js
+// 在多连接池场景中，将 Model 绑定到指定的连接池 + 数据库
+const msq = new MonSQLize({
+  uri: 'mongodb://localhost:27017',
+  databaseName: 'main_db',
+  pools: [{ name: 'analytics', uri: 'mongodb://analytics-host:27017' }]
+});
+
+// 绑定到不同数据库（使用默认连接池）
+Model.define('AuditLog', {
+  schema: (dsl) => dsl({ action: 'string!', userId: 'string!' }),
+  connection: { database: 'audit_db' }
+});
+
+// 绑定到不同连接池 + 不同数据库
+Model.define('AnalyticsReport', {
+  schema: (dsl) => dsl({ reportId: 'string!', data: 'object' }),
+  connection: { pool: 'analytics', database: 'reports_db' }
+});
+
+// 调用时自动路由，无需手动切换
+const AuditLogModel  = msq.model('AuditLog');       // → audit_db（默认池）
+const ReportModel    = msq.model('AnalyticsReport'); // → reports_db（analytics 池）
+const UserModel      = msq.model('users');           // → main_db（原逻辑，向后兼容）
+```
 
 📖 **详细文档**：[Model 层完整指南](./docs/model.md) | [Populate API](./docs/populate.md) | [Hooks API](./docs/hooks.md) | [Schema 验证](./docs/model.md#schema-验证)
 

package/index.d.ts

@@ -178,6 +178,7 @@ declare module 'monsqlize' {
     export import DefaultValue = Model.DefaultValue;
     export import HookContext = Model.HookContext;
     export import ValidationResult = Model.ValidationResult;
+    export import ModelConnection = Model.ModelConnection;
     export import ModelDefinition = Model.ModelDefinition;
     export import RelationConfig = Model.RelationConfig;
     export import PopulateConfig = Model.PopulateConfig;

package/lib/index.js

@@ -678,7 +678,10 @@ module.exports = class {
   }
 
   /**
-   * 获取 Model 实例
+   * 获取 Model 实例（缓存复用）
+   *
+   * 同一 collectionName 多次调用返回同一实例。
+   * Model.redefine() / Model.undefine() 后自动失效，close() 后全部清空。
    *
    * @param {string} collectionName - 集合名称
    * @returns {ModelInstance} Model 实例
@@ -710,8 +713,19 @@ module.exports = class {
       throw err;
     }
 
-    // 检查 Model 是否已定义
     const Model = require("./model");
+
+    // 缓存命中 + redefine 失效检查
+    if (this._modelInstances && this._modelInstances.has(collectionName)) {
+      if (!Model._redefinedNames.has(collectionName)) {
+        return this._modelInstances.get(collectionName);
+      }
+      // redefine 后需要重建实例
+      this._modelInstances.delete(collectionName);
+      Model._redefinedNames.delete(collectionName);
+    }
+
+    // 检查 Model 是否已定义
     if (!Model.has(collectionName)) {
       const err = new Error(
         `Model '${collectionName}' is not defined. Call Model.define() first.`,
@@ -723,12 +737,68 @@ module.exports = class {
     // 获取 Model 定义
     const modelDef = Model.get(collectionName);
 
-    // 获取 collection 实例
-    const collection = this.dbInstance.collection(collectionName);
+    // 获取 collection 实例（v1.2.2+ 支持 connection 路由）
+    const connection = modelDef.definition.connection;
+    const collection = (connection && (connection.pool || connection.database))
+      ? this._resolveModelCollection(collectionName, connection)
+      : this.dbInstance.collection(collectionName);
+
+    // 创建 ModelInstance 并缓存
+    const instance = new Model.ModelInstance(collection, modelDef.definition, this);
+
+    if (!this._modelInstances) this._modelInstances = new Map();
+    this._modelInstances.set(collectionName, instance);
+
+    return instance;
+  }
+
+  /**
+   * 解析 Model 绑定的 collection（内部方法）
+   *
+   * 根据 Model 定义中的 connection 配置，将请求路由到正确的连接池和数据库。
+   *
+   * 四种组合：
+   *   1. pool + database → 指定池、指定数据库
+   *   2. pool 只配置  → 指定池、实例默认 databaseName
+   *   3. database 只配置 → 默认连接池、指定数据库
+   *   4. 均未配置   → 原逻辑（此方法不会被调用）
+   *
+   * @private
+   * @param {string} collectionName - 集合名称
+   * @param {{ pool?: string, database?: string }} connection - Model 的 connection 配置
+   * @returns {Object} monSQLize 包装 collection 对象
+   * @since v1.2.2
+   */
+  _resolveModelCollection(collectionName, connection) {
+    const poolName = connection.pool;
+    const dbName   = connection.database || this.databaseName;
+
+    if (poolName) {
+      if (!this._poolManager) {
+        const err = new Error(
+          `Model '${collectionName}' requires pool '${poolName}' but no pools are configured. ` +
+          `Add 'pools' to MonSQLize constructor options.`
+        );
+        err.code = 'NO_POOL_MANAGER';
+        throw err;
+      }
+
+      const client = this._poolManager._getPool(poolName);
+      if (!client) {
+        const availablePools = this._poolManager.getPoolNames().join(', ');
+        const err = new Error(
+          `Pool '${poolName}' not found. Available pools: [${availablePools}]`
+        );
+        err.code = 'POOL_NOT_FOUND';
+        throw err;
+      }
 
-    // 创建 ModelInstance
-    const ModelInstanceClass = require("./model").ModelInstance;
-    return new ModelInstanceClass(collection, modelDef.definition, this);
+      // 指定池 + 数据库：通过 adapter 的 collectionFromClient 复用包装逻辑
+      return this._adapter.collectionFromClient(client, dbName, collectionName);
+    }
+
+    // 只切换数据库，用默认连接
+    return this.dbInstance.db(dbName).collection(collectionName);
   }
 
   /**
@@ -1007,6 +1077,12 @@ module.exports = class {
     this.dbInstance = null;
     this._connecting = null;
 
+    // 清理 ModelInstance 缓存
+    if (this._modelInstances) {
+      this._modelInstances.clear();
+      this._modelInstances = null;
+    }
+
     return null;
   }
 };

package/lib/model/index.js

@@ -58,6 +58,14 @@ class Model {
    */
   static _registry = new Map();
 
+  /**
+   * 已被 redefine 的 collectionName 集合（用于缓存失效通知）
+   * @private
+   * @type {Set<string>}
+   * @since 1.2.1
+   */
+  static _redefinedNames = new Set();
+
   /**
    * 定义并注册 Model
    *
@@ -152,6 +160,11 @@ class Model {
         this._validateOptions(definition.options);
       }
 
+      // ========== 验证 connection 配置（v1.2.2+）==========
+      if (definition.connection) {
+        this._validateConnection(definition.connection);
+      }
+
       // ========== 解析 timestamps 配置 ==========
       const timestampsConfig = this._parseTimestampsConfig(
         definition.options?.timestamps,
@@ -214,6 +227,37 @@ class Model {
     }
   }
 
+  /**
+   * 验证 connection 配置
+   *
+   * @private
+   * @param {Object} connection - connection 配置对象
+   * @throws {Error} 配置不合法时抛出错误
+   *
+   * @since v1.2.2
+   */
+  static _validateConnection(connection) {
+    if (!connection || typeof connection !== 'object') {
+      return;
+    }
+
+    if (connection.pool !== undefined) {
+      if (typeof connection.pool !== 'string' || connection.pool.trim() === '') {
+        const err = new Error('connection.pool must be a non-empty string');
+        err.code = 'INVALID_MODEL_DEFINITION';
+        throw err;
+      }
+    }
+
+    if (connection.database !== undefined) {
+      if (typeof connection.database !== 'string' || connection.database.trim() === '') {
+        const err = new Error('connection.database must be a non-empty string');
+        err.code = 'INVALID_MODEL_DEFINITION';
+        throw err;
+      }
+    }
+  }
+
   /**
    * 验证 options 配置
    * @private
@@ -396,6 +440,8 @@ class Model {
    * @since 1.1.7
    */
   static undefine(collectionName) {
+    // 标记需要缓存失效（MonSQLize.model() 检查此标记）
+    this._redefinedNames.add(collectionName);
     return this._registry.delete(collectionName);
   }
 
@@ -434,6 +480,8 @@ class Model {
   static redefine(collectionName, definition) {
     this.undefine(collectionName);
     this.define(collectionName, definition);
+    // 标记需要缓存失效（MonSQLize.model() 检查此标记）
+    this._redefinedNames.add(collectionName);
   }
 
   /**
@@ -442,7 +490,12 @@ class Model {
    * @private
    */
   static _clear() {
+    // 将所有已注册名标记为需要缓存失效，让 msq.model() 重建 ModelInstance
+    for (const name of this._registry.keys()) {
+      this._redefinedNames.add(name);
+    }
     this._registry.clear();
+    // 注意：不清除 _redefinedNames，确保 msq 实例缓存能感知本次 clear
   }
 }
 
@@ -662,38 +715,6 @@ class ModelInstance {
     }
   }
 
-  /**
-   * 创建索引
-   *
-   * @private
-   * @returns {Promise<void>}
-   */
-  async _createIndexes() {
-    if (!Array.isArray(this.indexes) || this.indexes.length === 0) {
-      return;
-    }
-
-    try {
-      // 使用 createIndexes 批量创建索引
-      await this.collection.createIndexes(this.indexes);
-
-      if (this.msq && this.msq.logger) {
-        this.msq.logger.info(
-          `[Model] Created ${this.indexes.length} index(es) for ${this.collection.collectionName}`,
-        );
-      }
-    } catch (err) {
-      // 索引创建失败仅记录警告
-      if (this.msq && this.msq.logger) {
-        this.msq.logger.warn(
-          `[Model] Failed to create indexes for ${this.collection.collectionName}:`,
-          err.message,
-        );
-      }
-      throw err;
-    }
-  }
-
   /**
    * 将实例方法注入到文档对象
    *

package/lib/mongodb/index.js

@@ -336,6 +336,31 @@ module.exports = class {
         };
     }
 
+    /**
+     * 从指定 MongoClient 创建包装 collection（用于多连接池 Model 绑定场景）
+     *
+     * 当 Model 定义了 `connection.pool` 时，`msq.model()` 会调用此方法，
+     * 将指定连接池的 MongoClient 传入，复用现有 collection() 的完整包装逻辑
+     * （runner、缓存、慢查询等），避免重复实现。
+     *
+     * 线程安全说明：Node.js 单线程，临时替换 this.client 的同步操作无竞态风险。
+     *
+     * @param {import('mongodb').MongoClient} client - 指定连接池的 MongoClient 实例
+     * @param {string} databaseName - 数据库名称
+     * @param {string} collectionName - 集合名称
+     * @returns {Object} monSQLize 包装 collection 对象
+     * @since v1.2.2
+     */
+    collectionFromClient(client, databaseName, collectionName) {
+        const originalClient = this.client;
+        this.client = client;
+        try {
+            return this.collection(databaseName, collectionName);
+        } finally {
+            this.client = originalClient;
+        }
+    }
+
     /**
  * 关闭连接并释放资源
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monsqlize",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "A lightweight MongoDB ORM with multi-level caching, transaction support, distributed features, Saga distributed transactions, unified expression system with 122 operators, and universal function caching (100% MongoDB support)",
   "main": "lib/index.js",
   "module": "index.mjs",
@@ -114,7 +114,7 @@
   },
   "dependencies": {
     "async-lock": "^1.4.1",
-    "mongodb": "^6.17.0",
+    "mongodb": "^6.21.0",
     "schema-dsl": "^1.2.4",
     "ssh2": "^1.17.0"
   }

package/types/model/definition.ts

@@ -106,5 +106,47 @@ export interface ModelDefinition<T = any> {
      * }
      */
     statics?: Record<string, (...args: any[]) => any>;
+
+    /**
+     * 数据源绑定配置（v1.2.2+）
+     *
+     * 声明此 Model 使用哪个连接池和/或数据库。
+     * 不配置时行为与 v1.2.1 完全相同（向后兼容）。
+     *
+     * @example
+     * // 绑定到指定连接池 + 数据库
+     * connection: { pool: 'analytics', database: 'reports_db' }
+     *
+     * @example
+     * // 只切换数据库（使用默认连接池）
+     * connection: { database: 'logs_db' }
+     *
+     * @since v1.2.2
+     */
+    connection?: ModelConnection;
+}
+
+/**
+ * Model 数据源绑定配置
+ *
+ * 声明 Model 使用哪个连接池（pool）和/或数据库（database）。
+ * 两个字段均为可选：
+ *   - 只指定 pool   → 使用该池 + 实例初始化时的 databaseName
+ *   - 只指定 database → 使用默认连接池 + 指定数据库
+ *   - 两者都指定    → 使用指定池 + 指定数据库
+ *   - 均不指定      → 与原来完全相同（向后兼容）
+ *
+ * @since v1.2.2
+ */
+export interface ModelConnection {
+    /**
+     * 连接池名称，须与 MonSQLize 构造函数 `pools[].name` 对应
+     */
+    pool?: string;
+
+    /**
+     * 数据库名称，不指定时使用实例初始化时的 `databaseName`
+     */
+    database?: string;
 }
 

package/types/monsqlize.ts

@@ -4,12 +4,13 @@
  */
 
 import type { TransactionOptions } from './options';
-import type { DbAccessor, HealthView } from './collection';
+import type { DbAccessor, HealthView, Collection } from './collection';
 import type { CacheLike } from './cache';
 import type { Transaction } from './transaction';
 import type { Lock, LockOptions } from './lock';
 import type { ExpressionFunction } from './base';
 import type { MetaInfo } from './pagination';
+import type { ModelInstance } from './model';
 
 /**
  * MonSQLize 主类
@@ -46,6 +47,29 @@ export interface MonSQLize {
      */
     health(): Promise<HealthView>;
 
+    /**
+     * 获取 Model 实例（缓存复用）
+     *
+     * 同一 collectionName 多次调用返回同一实例。
+     * Model.redefine() / Model.undefine() 后自动失效，close() 后全部清空。
+     *
+     * @param collectionName - 已注册的集合名称
+     * @returns ModelInstance 实例
+     * @throws 数据库未连接（NOT_CONNECTED）
+     * @throws Model 未定义（MODEL_NOT_DEFINED）
+     * @since 1.0.3
+     */
+    model(collectionName: string): ModelInstance;
+
+    /**
+     * 获取原始集合实例
+     *
+     * @param collectionName - 集合名称
+     * @returns Collection 实例
+     * @throws 数据库未连接（NOT_CONNECTED）
+     */
+    collection(collectionName: string): Collection;
+
 
     // ============================================================================
     // 事件系统