mm_mongodb 1.5.3 → 1.5.5

package/eslint.config.js

@@ -0,0 +1,211 @@
+'use strict';
+
+const namingConventionPlugin = require('mm_eslint');
+
+/**
+ * 基于个人规则的ESLint配置
+ * 符合最新ESLint Flat Config格式
+ */
+
+module.exports = [
+  {
+    files: ['**/*.js'],
+    plugins: {
+      'naming-convention': namingConventionPlugin,
+      'jsdoc': require('eslint-plugin-jsdoc')
+    },
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      parserOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module'
+      }
+    },
+    
+    // 命名规范规则 - 由自定义插件处理
+    rules: {
+      // 自定义命名规范插件规则（优先使用）
+      'naming-convention/class-name': 'error',
+      'naming-convention/function-name': 'error',
+      'naming-convention/method-name': 'error',
+      'naming-convention/variable-name': 'warn',
+      'naming-convention/constant-name': 'error',
+      'naming-convention/private-method-naming': 'warn',
+      'naming-convention/private-variable-naming': 'warn',
+      'naming-convention/param-name': 'warn',
+      'naming-convention/property-name': 'warn',
+      'naming-convention/instance-property': 'warn',
+      
+      // 禁用与命名规范插件冲突的默认规则
+      'camelcase': 'off',
+      'id-match': 'off',
+      'new-cap': 'off',
+      'id-length': 'off',
+      'id-denylist': 'off',
+      'id-blacklist': 'off'
+    }
+  },
+  
+  {
+    // 代码风格规则
+    rules: {
+      // 最大行长度100字符
+      'max-len': ['error', {
+        code: 100,
+        ignoreComments: true,
+        ignoreUrls: true,
+        ignoreStrings: true,
+        ignoreTemplateLiterals: true
+      }],
+      
+      // 缩进2空格
+      'indent': ['error', 2, {
+        SwitchCase: 1,
+        VariableDeclarator: 1,
+        outerIIFEBody: 1,
+        MemberExpression: 1,
+        FunctionDeclaration: { parameters: 1, body: 1 },
+        FunctionExpression: { parameters: 1, body: 1 },
+        CallExpression: { arguments: 1 },
+        ArrayExpression: 1,
+        ObjectExpression: 1,
+        ImportDeclaration: 1,
+        flatTernaryExpressions: false,
+        ignoreComments: false
+      }],
+      
+      // 单引号
+      'quotes': ['error', 'single', {
+        avoidEscape: true,
+        allowTemplateLiterals: true
+      }],
+      
+      // 禁止制表符
+      'no-tabs': 'error',
+      
+      // 行尾分号
+      'semi': ['error', 'always'],
+      
+      // 逗号风格
+      'comma-style': ['error', 'last'],
+      
+      // 逗号后必须有空格，逗号前不能有空格
+      'comma-spacing': ['error', {
+        before: false,
+        after: true
+      }]
+    }
+  },
+  
+  {
+    // 错误处理规则
+    rules: {
+      // 必须进行参数校验
+      'no-unused-vars': ['error', {
+        args: 'all',
+        argsIgnorePattern: '^_',
+        caughtErrors: 'all',
+        caughtErrorsIgnorePattern: '^_',
+        destructuredArrayIgnorePattern: '^_',
+        varsIgnorePattern: '^_',
+        ignoreRestSiblings: true
+      }],
+      
+      // 建议使用try-catch
+      'no-unsafe-finally': 'warn',
+      
+      // 禁止直接抛出字符串
+      'no-throw-literal': 'error'
+    }
+  },
+  
+  {
+    // 最佳实践规则
+    rules: {
+      // 优先使用async/await
+      'prefer-promise-reject-errors': 'error',
+      
+      // 避免副作用
+      'no-param-reassign': ['error', {
+        props: true,
+        ignorePropertyModificationsFor: [
+          'acc', // for reduce accumulators
+          'accumulator', // for reduce accumulators
+          'e', // for e.returnvalue
+          'ctx', // for Koa routing
+          'context', // for Koa routing
+          'req', // for Express requests
+          'request', // for Express requests
+          'res', // for Express responses
+          'response', // for Express responses
+          '$scope', // for Angular 1 scopes
+          'staticContext' // for ReactRouter context
+        ]
+      }],
+      
+      // 优先链式编程
+      'prefer-object-spread': 'error',
+      
+      // 优先函数式编程
+      'prefer-arrow-callback': 'error',
+      
+      // 方法长度限制
+      'max-lines-per-function': ['warn', {
+        max: 40,
+        skipBlankLines: true,
+        skipComments: true
+      }],
+      
+      // 复杂度限制
+      'complexity': ['warn', 10]
+    }
+  },
+  
+  {
+    // JSDoc规则
+    rules: {
+      // 要求公开方法有JSDoc注释
+      'jsdoc/require-jsdoc': ['warn', {
+        publicOnly: true,
+        require: {
+          FunctionDeclaration: true,
+          MethodDefinition: true,
+          ClassDeclaration: true,
+          ArrowFunctionExpression: false,
+          FunctionExpression: false
+        }
+      }],
+      
+      // 检查JSDoc语法
+      'jsdoc/check-alignment': 'warn',
+      'jsdoc/check-indentation': 'warn',
+      'jsdoc/check-param-names': 'warn',
+      'jsdoc/check-syntax': 'warn',
+      'jsdoc/check-tag-names': 'warn',
+      'jsdoc/check-types': 'warn',
+      'jsdoc/no-undefined-types': 'warn',
+      'jsdoc/require-description': 'warn',
+      'jsdoc/require-param': 'warn',
+      'jsdoc/require-param-description': 'warn',
+      'jsdoc/require-param-name': 'warn',
+      'jsdoc/require-param-type': 'warn',
+      'jsdoc/require-returns': 'warn',
+      'jsdoc/require-returns-check': 'warn',
+      'jsdoc/require-returns-description': 'warn',
+      'jsdoc/require-returns-type': 'warn',
+      'jsdoc/valid-types': 'warn'
+    }
+  },
+  
+  {
+    // 忽略规则
+    ignores: [
+      'node_modules/**',
+      'dist/**',
+      'build/**',
+      'coverage/**',
+      '*.min.js'
+    ]
+  }
+];

package/index.js

@@ -12,31 +12,32 @@ const MongoClient = require('mongodb').MongoClient;
  * @description MongoDB帮助类
  */
 class MongoDB extends Base {
+	static config = {
+		// 服务器地址
+		host: "localhost",
+		// 端口号
+		port: 27017,
+		// 数据库名
+		database: "mm",
+		// 用户名
+		user: "",
+		// 密码
+		password: "",
+		// 连接选项 (MongoDB驱动7.x版本支持的参数)
+		min_pool_size: 10,
+		max_pool_size: 100,
+		connect_timeout_ms: 10000,
+		server_selection_timeout_ms: 5000,
+		retry_writes: true
+	};
+
 	/**
 	 * @description 创建MongoDB帮助类函数 (构造函数)
 	 * @param {Object} config 配置参数
 	 * @constructor
 	 */
 	constructor(config) {
-		super();
-		this.config = {
-			// 服务器地址
-			host: "localhost",
-			// 端口号
-			port: 27017,
-			// 数据库名
-			database: "mm",
-			// 用户名
-			user: "",
-			// 密码
-			password: "",
-			// 连接选项 (MongoDB驱动7.x版本支持的参数)
-			min_pool_size: 10,
-			max_pool_size: 100,
-			connect_timeout_ms: 10000,
-			server_selection_timeout_ms: 5000,
-			retry_writes: true
-		};
+		super(MongoDB.config);
 
 		// 数据库连接器
 		this.conn = null;
@@ -102,7 +103,7 @@ MongoDB.prototype._withRetry = async function (operation, operationName) {
 			return await operation();
 		} catch (error) {
 			lastError = error;
-			this.logger('error', `${operationName} 第${attempt}次尝试失败:`, error);
+			this.log('error', `${operationName} 第${attempt}次尝试失败:`, error);
 
 			// 如果不是最后一次尝试，则等待后重试
 			if (attempt < maxAttempts) {
@@ -138,16 +139,16 @@ MongoDB.prototype._ensureConnected = async function () {
 
 				// 检查连接是否成功
 				if (this.db && this.db.collection) {
-					this.logger('debug', `[_ensureConnected] 连接成功，db对象存在，开始初始化collection，table=${this.table}`);
+					this.log('debug', `[_ensureConnected] 连接成功，db对象存在，开始初始化collection，table=${this.table}`);
 					this.connected = true;
 					this.connectAttempts = 0;
 
 					// 保存collection引用到实例变量
 					try {
 						this.collection = this.db.collection(this.table);
-						this.logger('debug', `[_ensureConnected] 成功初始化collection: ${this.table}`);
+						this.log('debug', `[_ensureConnected] 成功初始化collection: ${this.table}`);
 					} catch (err) {
-						this.logger('error', `[_ensureConnected] 初始化collection失败:`, err);
+						this.log('error', `[_ensureConnected] 初始化collection失败:`, err);
 						this.collection = null;
 					}
 
@@ -156,14 +157,14 @@ MongoDB.prototype._ensureConnected = async function () {
 						await this._ensureIndexes();
 					}
 
-					this.logger('info', `成功连接到数据库，表名: ${this.table}`);
+					this.log('info', `成功连接到数据库，表名: ${this.table}`);
 				} else {
-					this.logger('error', `[_ensureConnected] 连接失败，db对象为空或不具有collection方法`);
+					this.log('error', `[_ensureConnected] 连接失败，db对象为空或不具有collection方法`);
 					throw new Error('数据库连接失败，db对象为空');
 				}
 			}
 		} catch (error) {
-			this.logger('error', `连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`, error);
+			this.log('error', `连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`, error);
 
 			// 重置连接Promise，允许下次重试
 			this.connectPromise = null;
@@ -173,7 +174,7 @@ MongoDB.prototype._ensureConnected = async function () {
 				throw error;
 			} else {
 				// 超过重试次数，记录严重错误
-				this.logger('error', '达到最大连接重试次数，连接失败');
+				this.log('error', '达到最大连接重试次数，连接失败');
 				this.emit('error', new Error('数据库连接失败，已达到最大重试次数'));
 			}
 		}
@@ -207,7 +208,7 @@ MongoDB.prototype._ensureIndexes = async function () {
 	} catch (error) {
 		// 忽略索引已存在的错误
 		if (error.code !== 85) {
-			this.logger('error', '创建索引失败:', error);
+			this.log('error', '创建索引失败:', error);
 		}
 	}
 };
@@ -230,7 +231,7 @@ MongoDB.prototype.get = async function (key) {
 		});
 		return result ? result.value : null;
 	} catch (error) {
-		this.logger('error', '获取缓存失败:', error);
+		this.log('error', '获取缓存失败:', error);
 		this.emit('error', error);
 	}
 };
@@ -280,7 +281,7 @@ MongoDB.prototype.clear = async function (pattern) {
 			error,
 			pattern
 		});
-		this.logger('error', '清空缓存失败:', error);
+		this.log('error', '清空缓存失败:', error);
 		return false;
 	}
 };
@@ -313,7 +314,7 @@ MongoDB.prototype.keys = async function (pattern = '*') {
 		});
 		return results.map(item => item.key);
 	} catch (error) {
-		this.logger('error', '获取键列表失败:', error);
+		this.log('error', '获取键列表失败:', error);
 		return [];
 	}
 };
@@ -357,12 +358,11 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 
 			// 直接尝试获取collection，使用实例的table属性
 			if (!this.collection && this.db && this.db.collection) {
-				this.logger('debug', `[ttl] 设置模式：直接获取collection, table=${this.table}`);
+				this.log('debug', `[ttl] 设置模式：直接获取collection, table=${this.table}`);
 		try {
 			this.collection = this.db.collection(this.table);
-			this.logger('debug', `[ttl] 设置模式：成功获取collection`);
 				} catch (err) {
-					this.logger('error', `[ttl] 设置模式：获取collection失败:`, err);
+					this.log('error', `[ttl] 设置模式：获取collection失败:`, err);
 					this.collection = null;
 				}
 			}
@@ -425,12 +425,12 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 
 			// 直接尝试获取collection，使用实例的table属性
 			if (!this.collection && this.db && this.db.collection) {
-				this.logger('debug', `[ttl] 直接获取collection, table=${this.table}`);
+				this.log('debug', `[ttl] 直接获取collection, table=${this.table}`);
 		try {
 			this.collection = this.db.collection(this.table);
-			this.logger('debug', `[ttl] 成功获取collection`);
+			this.log('debug', `[ttl] 成功获取collection`);
 				} catch (err) {
-					this.logger('error', `[ttl] 获取collection失败:`, err);
+					this.log('error', `[ttl] 获取collection失败:`, err);
 					this.collection = null;
 				}
 			}
@@ -442,17 +442,17 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 
 			// 查询键是否存在及过期时间
 		const item = await this.collection.findOne({ key });
-		this.logger('debug', `[ttl] 查询键结果: item=${JSON.stringify(item)}`);
+		this.log('debug', `[ttl] 查询键结果: item=${JSON.stringify(item)}`);
 
 		if (!item) {
 			// 键不存在返回-2
-			this.logger('debug', `[ttl] 键 ${key} 不存在，返回-2`);
+			this.log('debug', `[ttl] 键 ${key} 不存在，返回-2`);
 			return -2;
 		}
 
 		if (!item.expire_at) {
 			// 没有过期时间返回-1
-			this.logger('debug', `[ttl] 键 ${key} 没有过期时间，返回-1`);
+			this.log('debug', `[ttl] 键 ${key} 没有过期时间，返回-1`);
 			return -1;
 			}
 
@@ -471,7 +471,7 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 		}
 	} catch (error) {
 		this.emit('ttl:error', { key, seconds, error });
-		this.logger('error', `[ttl] 操作失败:`, error);
+		this.log('error', `[ttl] 操作失败:`, error);
 		return arguments.length === 1 ? -2 : false;
 	}
 };
@@ -509,19 +509,19 @@ MongoDB.prototype.persist = async function (key) {
 
 		// 直接尝试获取collection，不依赖_ensureConnected的复杂逻辑
 		if (!this.collection && this.db && this.db.collection) {
-			this.logger('debug', `[persist] 直接获取collection, table=${this.table}`);
+			this.log('debug', `[persist] 直接获取collection, table=${this.table}`);
 			try {
 				this.collection = this.db.collection(this.table);
-				this.logger('debug', `[persist] 成功获取collection`);
+				this.log('debug', `[persist] 成功获取collection`);
 			} catch (err) {
-				this.logger('error', `[persist] 获取collection失败:`, err);
+				this.log('error', `[persist] 获取collection失败:`, err);
 				this.collection = null;
 			}
 		}
 
 		// 再次检查collection
 		if (!this.collection) {
-			this.logger('error', 'persist: collection is undefined');
+			this.log('error', 'persist: collection is undefined');
 			this.emit('persist:error', {
 				key: finalKey,
 				error: new Error('collection is undefined')
@@ -566,7 +566,7 @@ MongoDB.prototype.persist = async function (key) {
 		});
 		return success;
 	} catch (error) {
-		this.logger('error', 'persist error:', error);
+		this.log('error', 'persist error:', error);
 		this.emit('persist:error', {
 			key,
 			error
@@ -605,7 +605,7 @@ MongoDB.prototype._add = async function (key, value, expire) {
 		}
 		return true;
 	} catch (error) {
-		this.logger('error', '添加缓存失败:', error);
+		this.log('error', '添加缓存失败:', error);
 		return false;
 	}
 };
@@ -630,7 +630,7 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			this.logger('debug', `add操作被事件处理器取消 [${key}]`);
+			this.log('debug', `add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -679,7 +679,7 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 		});
 		return true;
 	} catch (error) {
-		this.logger('error', `添加缓存失败 [${key}]:`, error);
+		this.log('error', `添加缓存失败 [${key}]:`, error);
 		// 触发错误事件
 		this.emit('add:error', {
 			key,
@@ -714,7 +714,7 @@ MongoDB.prototype._addNum = async function (key, value = 1) {
 		await this._add(key, newValue);
 		return newValue;
 	} catch (error) {
-		this.logger('error', '增加整数值失败:', error);
+		this.log('error', '增加整数值失败:', error);
 		return false;
 	}
 };
@@ -749,7 +749,7 @@ MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'addInt操作被事件处理器取消');
+			this.log('debug', 'addInt操作被事件处理器取消');
 			return 0;
 		}
 
@@ -794,7 +794,7 @@ MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '增加整数值失败:', error);
+		this.log('error', '增加整数值失败:', error);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -824,7 +824,7 @@ MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'addFloat操作被事件处理器取消');
+			this.log('debug', 'addFloat操作被事件处理器取消');
 			return 0.0;
 		}
 
@@ -869,7 +869,7 @@ MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '增加浮点数值失败:', error);
+		this.log('error', '增加浮点数值失败:', error);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0.0;
 	}
@@ -923,7 +923,7 @@ MongoDB.prototype.addStr = async function (key, value) {
 			value,
 			error
 		});
-		this.logger('error', '添加字符串失败:', error);
+		this.log('error', '添加字符串失败:', error);
 		return 0;
 	}
 };
@@ -960,7 +960,7 @@ MongoDB.prototype.sort = async function (key, options = {}) {
 
 		return sorted;
 	} catch (error) {
-		this.logger('error', '排序失败:', error);
+		this.log('error', '排序失败:', error);
 		return [];
 	}
 };
@@ -994,7 +994,7 @@ MongoDB.prototype.hset = async function (key, field, value) {
 		await this._add(key, hash);
 		return true; // hset操作成功返回true
 	} catch (error) {
-		this.logger('error', '哈希表设置失败:', error);
+		this.log('error', '哈希表设置失败:', error);
 		throw error;
 	}
 };
@@ -1024,7 +1024,7 @@ MongoDB.prototype.hget = async function (key, field) {
 		}
 		return item.value[field] !== undefined ? item.value[field] : undefined;
 	} catch (error) {
-		this.logger('error', '哈希表获取失败:', error);
+		this.log('error', '哈希表获取失败:', error);
 		return null; // 与Redis保持一致，错误时返回null
 	}
 };
@@ -1049,7 +1049,7 @@ MongoDB.prototype.hgetall = async function (key) {
 		}
 		return item.value;
 	} catch (error) {
-		this.logger('error', '哈希表获取全部失败:', error);
+		this.log('error', '哈希表获取全部失败:', error);
 		return {};
 	}
 };
@@ -1109,7 +1109,7 @@ MongoDB.prototype.hdel = async function (key, fields) {
 
 		return deletedCount;
 	} catch (error) {
-		this.logger('error', 'hdel操作失败:', error);
+		this.log('error', 'hdel操作失败:', error);
 		return 0;
 	}
 };
@@ -1131,7 +1131,7 @@ MongoDB.prototype.has = async function (key) {
 		});
 		return result !== null;
 	} catch (error) {
-		this.logger('error', '[has] 检查键是否存在失败:', error);
+		this.log('error', '[has] 检查键是否存在失败:', error);
 		throw error;
 	}
 };
@@ -1157,7 +1157,7 @@ MongoDB.prototype.expire = async function (key, seconds) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'expire操作被事件处理器取消');
+			this.log('debug', 'expire操作被事件处理器取消');
 			return false;
 		}
 
@@ -1181,7 +1181,7 @@ MongoDB.prototype.expire = async function (key, seconds) {
 		return result === true || (typeof result === 'number' && result >= -2);
 	} catch (error) {
 		// 记录错误日志
-		this.logger('error', 'expire方法执行错误', { error: error.message, key, seconds });
+		this.log('error', 'expire方法执行错误', { error: error.message, key, seconds });
 
 		// 触发错误事件
 		this.emit('expire:error', {
@@ -1211,7 +1211,7 @@ MongoDB.prototype.incr = async function (key, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'incr操作被事件处理器取消');
+			this.log('debug', 'incr操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1246,7 +1246,7 @@ MongoDB.prototype.incr = async function (key, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '递增操作失败:', error);
+		this.log('error', '递增操作失败:', error);
 		return 0;
 	}
 };
@@ -1268,7 +1268,7 @@ MongoDB.prototype.decr = async function (key, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'decr操作被事件处理器取消');
+			this.log('debug', 'decr操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1303,7 +1303,7 @@ MongoDB.prototype.decr = async function (key, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '递减操作失败:', error);
+		this.log('error', '递减操作失败:', error);
 		return 0;
 	}
 };
@@ -1327,7 +1327,7 @@ MongoDB.prototype.incrby = async function (key, value = 1, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'incrby操作被事件处理器取消');
+			this.log('debug', 'incrby操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1368,7 +1368,7 @@ MongoDB.prototype.incrby = async function (key, value = 1, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '递增操作失败:', error);
+		this.log('error', '递增操作失败:', error);
 		return 0;
 	}
 };
@@ -1392,7 +1392,7 @@ MongoDB.prototype.decrby = async function (key, value = 1, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'decrby操作被事件处理器取消');
+			this.log('debug', 'decrby操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1433,7 +1433,7 @@ MongoDB.prototype.decrby = async function (key, value = 1, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '递减操作失败:', error);
+		this.log('error', '递减操作失败:', error);
 		return 0;
 	}
 };
@@ -1457,7 +1457,7 @@ MongoDB.prototype.incrbyfloat = async function (key, value = 1.0, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'incrbyfloat操作被事件处理器取消');
+			this.log('debug', 'incrbyfloat操作被事件处理器取消');
 			return 0.0;
 		}
 
@@ -1498,7 +1498,7 @@ MongoDB.prototype.incrbyfloat = async function (key, value = 1.0, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '浮点递增操作失败:', error);
+		this.log('error', '浮点递增操作失败:', error);
 		return 0.0;
 	}
 };
@@ -1545,7 +1545,7 @@ MongoDB.prototype.exists = async function (key) {
 			return result !== null;
 		}
 	} catch (error) {
-		this.logger('error', '检查键是否存在失败:', error);
+		this.log('error', '检查键是否存在失败:', error);
 		throw error;
 	}
 };
@@ -1575,7 +1575,7 @@ MongoDB.prototype._set = async function (key, value, expire) {
 		);
 		return true;
 	} catch (error) {
-		this.logger('error', '设置缓存失败:', error);
+		this.log('error', '设置缓存失败:', error);
 		return false;
 	} // 与CacheBase保持一致，返回false而不是抛出异常
 };
@@ -1601,7 +1601,7 @@ MongoDB.prototype.hmset = async function (key, ...fieldValues) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('warn', 'hmset: 键名无效');
+			this.log('warn', 'hmset: 键名无效');
 			return 0;
 		}
 
@@ -1650,7 +1650,7 @@ MongoDB.prototype.hmset = async function (key, ...fieldValues) {
 
 		return true; // 操作成功返回true
 	} catch (error) {
-		this.logger('error', '[hmset] 哈希表批量设置失败:', error);
+		this.log('error', '[hmset] 哈希表批量设置失败:', error);
 		return false; // 操作失败返回false
 	}
 };
@@ -1687,7 +1687,7 @@ MongoDB.prototype.hmget = async function (key, fields) {
 
 		return values;
 	} catch (error) {
-		this.logger('error', 'hmget操作失败:', error);
+		this.log('error', 'hmget操作失败:', error);
 		// 错误时返回与fields长度相同的null数组
 		const fieldArray = Array.isArray(fields) ? fields : [fields];
 		return fieldArray.map(() => null);
@@ -1735,7 +1735,7 @@ MongoDB.prototype.hdelMulti = async function (key, fields) {
 		}
 		return deleted;
 	} catch (error) {
-		this.logger('error', '增加整数值失败:', error);
+		this.log('error', '增加整数值失败:', error);
 		return false;
 	}
 };
@@ -1761,7 +1761,7 @@ MongoDB.prototype.hvals = async function (key) {
 		}
 		return Object.values(item.value);
 	} catch (error) {
-		this.logger('error', '哈希表获取所有值失败:', error);
+		this.log('error', '哈希表获取所有值失败:', error);
 		return [];
 	}
 };
@@ -1787,7 +1787,7 @@ MongoDB.prototype.hkeys = async function (key) {
 		}
 		return Object.keys(item.value);
 	} catch (error) {
-		this.logger('error', '哈希表获取所有字段名失败:', error);
+		this.log('error', '哈希表获取所有字段名失败:', error);
 		return [];
 	}
 };
@@ -1815,7 +1815,7 @@ MongoDB.prototype.hlen = async function (key) {
 		// 使用Object.keys获取自有属性数量，这比for-in循环更高效
 		return Object.keys(item.value).length;
 	} catch (error) {
-		this.logger('error', 'hlen操作失败:', error);
+		this.log('error', 'hlen操作失败:', error);
 		return 0;
 	}
 };
@@ -1845,7 +1845,7 @@ MongoDB.prototype.hexists = async function (key, field) {
 		}
 		return field in item.value;
 	} catch (error) {
-		this.logger('error', '哈希表字段是否存在失败:', error);
+		this.log('error', '哈希表字段是否存在失败:', error);
 		return false;
 	}
 };
@@ -1874,7 +1874,7 @@ MongoDB.prototype.rpush = async function (key, value) {
 		await this._add(key, list);
 		return list.length;
 	} catch (error) {
-		this.logger('error', '列表尾部添加失败:', error);
+		this.log('error', '列表尾部添加失败:', error);
 		return 0;
 	}
 };
@@ -1903,7 +1903,7 @@ MongoDB.prototype.lpush = async function (key, value) {
 		await this._add(key, list);
 		return list.length;
 	} catch (error) {
-		this.logger('error', '列表头部添加失败:', error);
+		this.log('error', '列表头部添加失败:', error);
 		return 0;
 	}
 };
@@ -1946,7 +1946,7 @@ MongoDB.prototype.lrange = async function (key, start, stop) {
 
 		return item.value.slice(startIndex, endIndex + 1);
 	} catch (error) {
-		this.logger('error', '列表范围查询失败:', error);
+		this.log('error', '列表范围查询失败:', error);
 		return [];
 	}
 };
@@ -1976,7 +1976,7 @@ MongoDB.prototype.lindex = async function (key, index) {
 
 		return item.value[realIndex];
 	} catch (error) {
-		this.logger('error', '获取列表索引元素失败:', error);
+		this.log('error', '获取列表索引元素失败:', error);
 		return null;
 	}
 };
@@ -2013,7 +2013,7 @@ MongoDB.prototype.lset = async function (key, index, value) {
 		});
 		return true;
 	} catch (error) {
-		this.logger('error', '设置列表索引元素失败:', error);
+		this.log('error', '设置列表索引元素失败:', error);
 		return false;
 	}
 };
@@ -2072,7 +2072,7 @@ MongoDB.prototype.lrem = async function (key, count, value) {
 
 		return removedCount;
 	} catch (error) {
-		this.logger('error', '删除列表元素失败:', error);
+		this.log('error', '删除列表元素失败:', error);
 		return 0;
 	}
 };
@@ -2103,7 +2103,7 @@ MongoDB.prototype.ltrim = async function (key, start, stop) {
 		});
 		return true;
 	} catch (error) {
-		this.logger('error', '增加整数值失败:', error);
+		this.log('error', '增加整数值失败:', error);
 		return false;
 	}
 };
@@ -2129,7 +2129,7 @@ MongoDB.prototype.llen = async function (key) {
 		}
 		return item.value.length;
 	} catch (error) {
-		this.logger('error', '获取列表长度失败:', error);
+		this.log('error', '获取列表长度失败:', error);
 		return 0;
 	}
 };
@@ -2170,7 +2170,7 @@ MongoDB.prototype.saddMulti = async function (key, members) {
 
 		return addedCount;
 	} catch (error) {
-		this.logger('error', '集合并发添加失败:', error);
+		this.log('error', '集合并发添加失败:', error);
 		return 0;
 	}
 };
@@ -2213,7 +2213,7 @@ MongoDB.prototype.sremMulti = async function (key, members) {
 
 		return removedCount;
 	} catch (error) {
-		this.logger('error', '集合并发删除失败:', error);
+		this.log('error', '集合并发删除失败:', error);
 		return 0;
 	}
 };
@@ -2259,7 +2259,7 @@ MongoDB.prototype.sdiff = async function (...keys) {
 		// 找出在baseSet中但不在其他所有集合中的元素
 		return baseSet.filter(member => !otherSetsStr.has(JSON.stringify(member)));
 	} catch (error) {
-		this.logger('error', '集合差集失败:', error);
+		this.log('error', '集合差集失败:', error);
 		return [];
 	}
 };
@@ -2317,7 +2317,7 @@ MongoDB.prototype.sinter = async function (...keys) {
 			return otherSetsStr.every(set => set.has(memberStr));
 		});
 	} catch (error) {
-		this.logger('error', '集合交集失败:', error);
+		this.log('error', '集合交集失败:', error);
 		return [];
 	}
 };
@@ -2364,7 +2364,7 @@ MongoDB.prototype.sunion = async function (...keys) {
 
 		return Array.from(uniqueMap.values());
 	} catch (error) {
-		this.logger('error', '集合并集失败:', error);
+		this.log('error', '集合并集失败:', error);
 		return [];
 	}
 };
@@ -2393,7 +2393,7 @@ MongoDB.prototype.scard = async function (key) {
 		const uniqueItems = new Set(item.value.map(m => JSON.stringify(m)));
 		return uniqueItems.size;
 	} catch (error) {
-		this.logger('error', '获取集合成员数量失败:', error);
+		this.log('error', '获取集合成员数量失败:', error);
 		return 0;
 	}
 };
@@ -2444,7 +2444,7 @@ MongoDB.prototype.sismember = async function (key, member) {
 			member,
 			error
 		});
-		this.logger('error', '检查集合成员失败:', error);
+		this.log('error', '检查集合成员失败:', error);
 		return false;
 	}
 };
@@ -2472,7 +2472,7 @@ MongoDB.prototype.clearExpire = async function () {
 		this.emit('clearExpire:error', {
 			error
 		});
-		this.logger('error', '清空过期数据失败:', error);
+		this.log('error', '清空过期数据失败:', error);
 		return false;
 	}
 };
@@ -2498,7 +2498,7 @@ MongoDB.prototype.mget = async function (...keys) {
 		// 返回与输入键顺序对应的数组，不存在的键对应位置返回undefined
 		return keyArray.map(key => resultMap.hasOwnProperty(key) ? resultMap[key] : undefined);
 	} catch (error) {
-		this.logger('error', '批量获取失败:', error);
+		this.log('error', '批量获取失败:', error);
 		throw error;
 	}
 };
@@ -2520,7 +2520,7 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'mset操作被事件处理器取消');
+			this.log('debug', 'mset操作被事件处理器取消');
 			return false;
 		}
 
@@ -2532,7 +2532,7 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
 
 		// 参数验证，确保keyValues是对象且不为null
 		if (typeof finalData !== 'object' || finalData === null || Array.isArray(finalData)) {
-			this.logger('warn', 'mset: 参数必须是非空对象');
+			this.log('warn', 'mset: 参数必须是非空对象');
 			return false;
 		}
 
@@ -2555,7 +2555,7 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '批量设置失败:', error);
+		this.log('error', '批量设置失败:', error);
 		return false;
 	}
 };
@@ -2601,7 +2601,7 @@ MongoDB.prototype.zadd = async function (key, score, member) {
 		await this._add(key, sortedSet);
 		return true;
 	} catch (error) {
-		this.logger('error', '增加浮点数值失败:', error);
+		this.log('error', '增加浮点数值失败:', error);
 		return false;
 	}
 };
@@ -2639,7 +2639,7 @@ MongoDB.prototype.zrangebyscore = async function (key, min, max) {
 			.filter(item => item.score >= min && item.score <= max)
 			.map(item => item.member);
 	} catch (error) {
-		this.logger('error', '有序集合范围查询失败:', error);
+		this.log('error', '有序集合范围查询失败:', error);
 		return [];
 	}
 };
@@ -2665,7 +2665,7 @@ MongoDB.prototype.zcard = async function (key) {
 		}
 		return item.value.length;
 	} catch (error) {
-		this.logger('error', '有序集合成员数量失败:', error);
+		this.log('error', '有序集合成员数量失败:', error);
 		return 0;
 	}
 };
@@ -2701,7 +2701,7 @@ MongoDB.prototype.zrem = async function (key, member) {
 
 		return removedCount;
 	} catch (error) {
-		this.logger('error', '有序集合删除成员失败:', error);
+		this.log('error', '有序集合删除成员失败:', error);
 		return 0;
 	}
 };
@@ -2731,7 +2731,7 @@ MongoDB.prototype.zscore = async function (key, member) {
 		const found = item.value.find(item => JSON.stringify(item.member) === memberStr);
 		return found ? found.score : null;
 	} catch (error) {
-		this.logger('error', '获取成员分数失败:', error);
+		this.log('error', '获取成员分数失败:', error);
 		return null;
 	}
 };
@@ -2764,7 +2764,7 @@ MongoDB.prototype.lpop = async function (key) {
 		});
 		return popped;
 	} catch (error) {
-		this.logger('error', '列表弹出头部元素失败:', error);
+		this.log('error', '列表弹出头部元素失败:', error);
 		return null;
 	}
 };
@@ -2797,7 +2797,7 @@ MongoDB.prototype.rpop = async function (key) {
 		});
 		return popped;
 	} catch (error) {
-		this.logger('error', '列表弹出尾部元素失败:', error);
+		this.log('error', '列表弹出尾部元素失败:', error);
 		return null;
 	}
 };
@@ -2832,7 +2832,7 @@ MongoDB.prototype.smembers = async function (key) {
 		});
 		return Array.from(uniqueMap.values());
 	} catch (error) {
-		this.logger('error', '获取集合所有成员失败:', error);
+		this.log('error', '获取集合所有成员失败:', error);
 		return [];
 	}
 };
@@ -2853,7 +2853,7 @@ MongoDB.prototype.findOne = async function (query, options = {}) {
 		// 不需要额外的sanitize，MongoDB驱动会处理
 		return await this.db.collection(this.table).findOne(query, options);
 	} catch (error) {
-		this.logger('error', '查询单条数据失败:', error);
+		this.log('error', '查询单条数据失败:', error);
 		return null;
 	}
 };
@@ -2906,21 +2906,21 @@ MongoDB.prototype.open = async function () {
 
 				// 设置连接事件监听
 				this.conn.on('error', (err) => {
-					this.logger('error', '连接错误:', err);
+					this.log('error', '连接错误:', err);
 					this.connected = false;
 				});
 
 				this.conn.on('close', () => {
-					this.logger('warn', '连接已关闭');
+					this.log('warn', '连接已关闭');
 					this.connected = false;
 				});
 
-				this.logger('info',
+				this.log('info',
 					`成功连接到 ${this.config.host}:${this.config.port}/${this.config.database}`
 				);
 				return true;
 			} catch (error) {
-				this.logger('error', 'MongoDB连接失败:', error);
+				this.log('error', 'MongoDB连接失败:', error);
 			}
 		}, '数据库连接');
 	}
@@ -2932,8 +2932,8 @@ MongoDB.prototype.open = async function () {
  */
 MongoDB.prototype.close = async function () {
 	if (this.conn) {
-		this.logger('info', `关闭连接`);
-		await this.conn.close().catch(err => this.logger('error', '关闭MongoDB连接时出错:', err));
+		this.log('info', `关闭连接`);
+		await this.conn.close().catch(err => this.log('error', '关闭MongoDB连接时出错:', err));
 		this.conn = null;
 		this.db = null;
 		this.connected = false;
@@ -2978,13 +2978,13 @@ MongoDB.prototype.createIndex = async function (keys, options = {}) {
 			throw new Error('数据库未连接或未指定表名');
 		}
 
-		this.logger('info',
+		this.log('info',
 			`创建索引: ${this.table}, keys: ${JSON.stringify(keys)}, options: ${JSON.stringify(options)}`
 		);
 
 		return await this.db.collection(this.table).createIndex(keys, options);
 	} catch (error) {
-		this.logger('error', `创建索引失败: ${error.message}`);
+		this.log('error', `创建索引失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -3015,12 +3015,12 @@ MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
 			expireAfterSeconds: expireAfterSeconds
 		};
 
-		this.logger('info',
+		this.log('info',
 			`创建TTL索引: ${this.table}, keys: ${JSON.stringify(keys)}, 过期时间: ${expireAfterSeconds}秒`);
 
 		return await this.db.collection(this.table).createIndex(keys, options);
 	} catch (error) {
-		this.logger('error', `创建TTL索引失败: ${error.message}`);
+		this.log('error', `创建TTL索引失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -3036,10 +3036,10 @@ MongoDB.prototype.getIndexes = async function () {
 				throw new Error('未指定表名');
 			}
 
-			this.logger('info', `获取索引: ${this.table}`);
+			this.log('info', `获取索引: ${this.table}`);
 			return await this.db.collection(this.table).indexes();
 		} catch (error) {
-			this.logger('error', `[getIndexes] 获取索引失败: ${error.message}`);
+			this.log('error', `[getIndexes] 获取索引失败: ${error.message}`);
 			return [];
 		}
 };
@@ -3058,11 +3058,11 @@ MongoDB.prototype.dropIndex = async function (indexName) {
 		throw new TypeError('索引名称不能为空');
 	}
 	try {
-		this.logger('info', `[dropIndex] 删除索引: ${this.table}, 索引名: ${indexName}`);
+		this.log('info', `[dropIndex] 删除索引: ${this.table}, 索引名: ${indexName}`);
 		await this.db.collection(this.table).dropIndex(indexName);
 		return true;
 	} catch (error) {
-		this.logger('error', `[dropIndex] 删除索引失败: ${error.message}`);
+		this.log('error', `[dropIndex] 删除索引失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -3077,11 +3077,11 @@ MongoDB.prototype.dropTable = async function () {
 		throw new Error('未指定表名');
 	}
 	try {
-		this.logger('info', `[dropTable] 删除集合: ${this.table}`);
+		this.log('info', `[dropTable] 删除集合: ${this.table}`);
 		await this.db.collection(this.table).drop();
 		return true;
 	} catch (error) {
-		this.logger('error', `[dropTable] 删除集合失败: ${error.message}`);
+		this.log('error', `[dropTable] 删除集合失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -3140,7 +3140,7 @@ MongoDB.prototype.get = async function (key) {
 		});
 		return result ? result.value : null;
 	} catch (error) {
-		this.logger('error', `获取键值失败: ${error.message}`);
+		this.log('error', `获取键值失败: ${error.message}`);
 		return null;
 	}
 };
@@ -3174,7 +3174,7 @@ MongoDB.prototype.setForList = async function (key, array, seconds = 0) {
 		this.emit('setForList:before', beforeEventData);
 
 		if (beforeEventData.cancel) {
-			this.logger('debug', `[setForList] setForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3206,7 +3206,7 @@ MongoDB.prototype.setForList = async function (key, array, seconds = 0) {
 			value: array,
 			error
 		});
-		this.logger('error', `[setForList] setForList操作失败: ${error.message}`);
+		this.log('error', `[setForList] setForList操作失败: ${error.message}`);
 		return 0;
 	}
 };
@@ -3235,7 +3235,7 @@ MongoDB.prototype.addForList = async function (key, value, seconds = 0) {
 		this.emit('addForList:before', beforeEventData);
 
 		if (beforeEventData.cancel) {
-			this.logger('debug', `addForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3276,7 +3276,7 @@ MongoDB.prototype.addForList = async function (key, value, seconds = 0) {
 			value,
 			error
 		});
-		this.logger('error', `addForList操作失败: ${error.message}`);
+		this.log('error', `addForList操作失败: ${error.message}`);
 		return 0;
 	}
 };
@@ -3309,7 +3309,7 @@ MongoDB.prototype.hasForList = async function (key, value) {
 		const valueStr = JSON.stringify(value);
 		return array.some(item => JSON.stringify(item) === valueStr);
 	} catch (error) {
-		this.logger('error', `hasForList操作失败: ${error.message}`);
+		this.log('error', `hasForList操作失败: ${error.message}`);
 		return false;
 	}
 };
@@ -3347,7 +3347,7 @@ MongoDB.prototype.getForList = async function (key, start = 0, stop = -1) {
 
 		return result;
 	} catch (error) {
-		this.logger('error', `getForList操作失败: ${error.message}`);
+		this.log('error', `getForList操作失败: ${error.message}`);
 		return [];
 	}
 };
@@ -3370,7 +3370,7 @@ MongoDB.prototype.clearForList = async function (key) {
 		// 使用set方法直接设置为空数组，与其他模块行为一致
 		return await this.set(key, []);
 	} catch (error) {
-		this.logger('error', `clearForList操作失败: ${error.message}`);
+		this.log('error', `clearForList操作失败: ${error.message}`);
 		return false;
 	}
 };
@@ -3382,7 +3382,7 @@ MongoDB.prototype.has = async function (key) {
 		const exists = await this.exists(key);
 		return exists > 0;
 	} catch (error) {
-		this.logger('error', `检查键是否存在失败: ${error.message}`);
+		this.log('error', `检查键是否存在失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -3426,7 +3426,7 @@ MongoDB.prototype.exists = async function (key) {
 			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 	} catch (error) {
-		this.logger('error', `检查键是否存在失败: ${error.message}`);
+		this.log('error', `检查键是否存在失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -3471,7 +3471,7 @@ MongoDB.prototype.del = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			this.logger('debug', `del操作被事件处理器取消 [${key}]`);
+			this.log('debug', `del操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3521,7 +3521,7 @@ MongoDB.prototype.del = async function (key) {
 			key,
 			error: error
 		});
-		this.logger('error', '删除缓存失败:', error);
+		this.log('error', '删除缓存失败:', error);
 		return false;
 	}
 };
@@ -3547,7 +3547,7 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			this.logger('debug', `add操作被事件处理器取消 [${key}]`);
+			this.log('debug', `add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3605,7 +3605,7 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 			ttl: seconds,
 			error
 		});
-		this.logger('error', `添加键值失败: ${error.message}`);
+		this.log('error', `添加键值失败: ${error.message}`);
 		return false;
 	}
 };
@@ -3621,7 +3621,7 @@ MongoDB.prototype.set = async function (key, value, seconds) {
 	try {
 		// 键名必须是非空字符串
 		if (!key || typeof key !== 'string') {
-			this.logger('error', '参数错误: key必须是非空字符串');
+			this.log('error', '参数错误: key必须是非空字符串');
 			return false;
 		}
 
@@ -3636,7 +3636,7 @@ MongoDB.prototype.set = async function (key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			this.logger('debug', `set操作被事件处理器取消 [${key}]`);
+			this.log('debug', `set操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3691,7 +3691,7 @@ MongoDB.prototype.set = async function (key, value, seconds) {
 			ttl: seconds,
 			error
 		});
-		this.logger('error', `设置键值失败: ${error.message}`);
+		this.log('error', `设置键值失败: ${error.message}`);
 		return false;
 	}
 };
@@ -3861,7 +3861,7 @@ MongoDB.prototype.find = async function (query, options = {}) {
 		const cursor = this.db.collection(this.table).find(safeQuery, options);
 		return await cursor.toArray();
 	} catch (error) {
-		this.logger('error', '查询失败:', error);
+		this.log('error', '查询失败:', error);
 		return [];
 	}
 };
@@ -3878,7 +3878,7 @@ MongoDB.prototype.count = async function (query = {}) {
 		const safeQuery = this._sanitizeQuery(query);
 		return await this.db.collection(this.table).countDocuments(safeQuery);
 	} catch (error) {
-		this.logger('error', '计算文档数量失败:', error);
+		this.log('error', '计算文档数量失败:', error);
 		return 0;
 	}
 };
@@ -3897,7 +3897,7 @@ MongoDB.prototype._sanitizeQuery = function (query) {
 		// 防止NoSQL注入，如 {$ne: null} 等操作符注入
 		if (key.startsWith('$') && typeof key === 'string' && !Array.isArray(value) && typeof value === 'object' &&
 			value !== null) {
-			this.logger('warn', '检测到可能的操作符注入尝试:', key);
+			this.log('warn', '检测到可能的操作符注入尝试:', key);
 			continue;
 		}
 		sanitized[key] = value;
@@ -3917,7 +3917,7 @@ MongoDB.prototype.startTransaction = async function () {
 		session.startTransaction();
 		return session;
 	} catch (error) {
-		this.logger('error', '[startTransaction] 启动事务失败:', error);
+		this.log('error', '[startTransaction] 启动事务失败:', error);
 		throw error;
 	}
 };
@@ -3932,7 +3932,7 @@ MongoDB.prototype.commitTransaction = async function (session) {
 		await session.commitTransaction();
 		await session.endSession();
 	} catch (error) {
-		this.logger('error', '[commitTransaction] 提交事务失败:', error);
+		this.log('error', '[commitTransaction] 提交事务失败:', error);
 		throw error;
 	}
 };
@@ -3947,16 +3947,11 @@ MongoDB.prototype.rollbackTransaction = async function (session) {
 		await session.abortTransaction();
 		await session.endSession();
 	} catch (error) {
-		this.logger('error', '[rollbackTransaction] 回滚事务失败:', error);
+		this.log('error', '[rollbackTransaction] 回滚事务失败:', error);
 		throw error;
 	}
 };
 
-/**
- * 导出MongoDB类
- */
-exports.MongoDB = MongoDB;
-
 /**
  * 确保连接池对象存在
  */
@@ -3992,7 +3987,7 @@ function mongodbAdmin(scope, config) {
 	return obj;
 }
 
-/**
- * @module 导出MongoDB管理器
- */
-exports.mongodbAdmin = mongodbAdmin;
+module.exports = {
+	MongoDB,
+	mongodbAdmin
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_mongodb",
-    "version": "1.5.3",
+    "version": "1.5.5",
     "description": "MongoDB数据库操作模块，提供简洁易用的API、缓存功能以及完整的Redis兼容接口，支持事件系统、事务和连接池管理",
     "main": "index.js",
     "scripts": {
@@ -36,7 +36,7 @@
     },
     "homepage": "https://gitee.com/qiuwenwu91/mm_mongodb#readme",
     "dependencies": {
-        "mm_expand": "^1.9.7",
+        "mm_expand": "^2.0.0",
         "mongodb": "^7.0.0"
     }
 }

package/test.js

@@ -1,5 +1,5 @@
 const MongoDB = require('./index.js').MongoDB;
-const mongodb_admin = require('./index.js').mongodb_admin;
+const mongodbAdmin = require('./index.js').mongodbAdmin;
 
 async function test() {
     try {
@@ -12,7 +12,7 @@ async function test() {
             password: '',
             database: 'mm'
         };
-        var rs = mongodb_admin('sys', config);
+        var rs = mongodbAdmin('sys', config);
         await rs.open();
         await rs.addTable('cache_test');