mm_mongodb 1.5.2 → 1.5.4

package/eslint.config.js

@@ -0,0 +1,68 @@
+const jsdoc = require('eslint-plugin-jsdoc');
+
+module.exports = [
+  {
+    files: ['lib/**/*.js'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'script'
+    },
+    plugins: {
+      jsdoc: jsdoc
+    },
+    rules: {
+      // JSDoc相关规则 - 设置为error级别强制要求
+      'jsdoc/require-jsdoc': ['error', {
+        require: {
+          FunctionDeclaration: true,
+          MethodDefinition: true,
+          ClassDeclaration: true,
+          ArrowFunctionExpression: true
+        }
+      }],
+      'jsdoc/check-param-names': 'off',
+      'jsdoc/check-tag-names': 'off',
+      'jsdoc/check-types': 'off',
+      'jsdoc/require-param': 'off',
+      'jsdoc/require-param-description': 'off',
+      'jsdoc/require-returns': 'off',
+      'jsdoc/require-returns-description': 'off',
+      
+      // 基础语法规则
+      'no-unused-vars': ['error', { args: 'none', vars: 'all' }],
+      'no-console': 'warn',
+      
+      // 代码风格规则
+      'indent': ['error', 2],
+      'quotes': ['error', 'single'],
+      'semi': ['error', 'always'],
+      'comma-dangle': ['error', 'never'],
+      'no-trailing-spaces': 'error',
+      'eol-last': 'error',
+      'max-len': ['error', { code: 100 }],
+      'max-lines-per-function': ['error', { max: 40 }],
+      'complexity': ['error', 12],
+      'max-depth': ['error', 4],
+      'max-params': ['error', 4],
+      
+      // 命名规则
+      'id-length': ['error', {
+        min: 1,
+        max: 20,
+        properties: 'always'
+      }]
+    }
+  },
+  {
+    files: ['test/**/*.js'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'script'
+    },
+    rules: {
+      // 测试文件中允许使用console
+      'no-console': 'off',
+      'no-unused-vars': 'off'
+    }
+  }
+];

package/index.js

@@ -102,7 +102,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 +138,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 +156,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 +173,7 @@ MongoDB.prototype._ensureConnected = async function () {
 				throw error;
 			} else {
 				// 超过重试次数，记录严重错误
-				this.logger('error', '达到最大连接重试次数，连接失败');
+				this.log('error', '达到最大连接重试次数，连接失败');
 				this.emit('error', new Error('数据库连接失败，已达到最大重试次数'));
 			}
 		}
@@ -207,7 +207,7 @@ MongoDB.prototype._ensureIndexes = async function () {
 	} catch (error) {
 		// 忽略索引已存在的错误
 		if (error.code !== 85) {
-			this.logger('error', '创建索引失败:', error);
+			this.log('error', '创建索引失败:', error);
 		}
 	}
 };
@@ -230,7 +230,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 +280,7 @@ MongoDB.prototype.clear = async function (pattern) {
 			error,
 			pattern
 		});
-		this.logger('error', '清空缓存失败:', error);
+		this.log('error', '清空缓存失败:', error);
 		return false;
 	}
 };
@@ -313,7 +313,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 +357,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 +424,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 +441,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 +470,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 +508,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 +565,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 +604,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 +629,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 +678,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 +713,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 +748,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 +793,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 +823,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 +868,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 +922,7 @@ MongoDB.prototype.addStr = async function (key, value) {
 			value,
 			error
 		});
-		this.logger('error', '添加字符串失败:', error);
+		this.log('error', '添加字符串失败:', error);
 		return 0;
 	}
 };
@@ -960,7 +959,7 @@ MongoDB.prototype.sort = async function (key, options = {}) {
 
 		return sorted;
 	} catch (error) {
-		this.logger('error', '排序失败:', error);
+		this.log('error', '排序失败:', error);
 		return [];
 	}
 };
@@ -994,7 +993,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 +1023,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 +1048,7 @@ MongoDB.prototype.hgetall = async function (key) {
 		}
 		return item.value;
 	} catch (error) {
-		this.logger('error', '哈希表获取全部失败:', error);
+		this.log('error', '哈希表获取全部失败:', error);
 		return {};
 	}
 };
@@ -1109,7 +1108,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 +1130,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 +1156,7 @@ MongoDB.prototype.expire = async function (key, seconds) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'expire操作被事件处理器取消');
+			this.log('debug', 'expire操作被事件处理器取消');
 			return false;
 		}
 
@@ -1181,7 +1180,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 +1210,7 @@ MongoDB.prototype.incr = async function (key, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'incr操作被事件处理器取消');
+			this.log('debug', 'incr操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1246,7 +1245,7 @@ MongoDB.prototype.incr = async function (key, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '递增操作失败:', error);
+		this.log('error', '递增操作失败:', error);
 		return 0;
 	}
 };
@@ -1268,7 +1267,7 @@ MongoDB.prototype.decr = async function (key, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			this.logger('debug', 'decr操作被事件处理器取消');
+			this.log('debug', 'decr操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1303,7 +1302,7 @@ MongoDB.prototype.decr = async function (key, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '递减操作失败:', error);
+		this.log('error', '递减操作失败:', error);
 		return 0;
 	}
 };
@@ -1327,7 +1326,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 +1367,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 +1391,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 +1432,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 +1456,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 +1497,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 +1544,7 @@ MongoDB.prototype.exists = async function (key) {
 			return result !== null;
 		}
 	} catch (error) {
-		this.logger('error', '检查键是否存在失败:', error);
+		this.log('error', '检查键是否存在失败:', error);
 		throw error;
 	}
 };
@@ -1575,7 +1574,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 +1600,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 +1649,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 +1686,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 +1734,7 @@ MongoDB.prototype.hdelMulti = async function (key, fields) {
 		}
 		return deleted;
 	} catch (error) {
-		this.logger('error', '增加整数值失败:', error);
+		this.log('error', '增加整数值失败:', error);
 		return false;
 	}
 };
@@ -1761,7 +1760,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 +1786,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 +1814,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 +1844,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 +1873,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 +1902,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 +1945,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 +1975,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 +2012,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 +2071,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 +2102,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 +2128,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 +2169,7 @@ MongoDB.prototype.saddMulti = async function (key, members) {
 
 		return addedCount;
 	} catch (error) {
-		this.logger('error', '集合并发添加失败:', error);
+		this.log('error', '集合并发添加失败:', error);
 		return 0;
 	}
 };
@@ -2213,7 +2212,7 @@ MongoDB.prototype.sremMulti = async function (key, members) {
 
 		return removedCount;
 	} catch (error) {
-		this.logger('error', '集合并发删除失败:', error);
+		this.log('error', '集合并发删除失败:', error);
 		return 0;
 	}
 };
@@ -2259,7 +2258,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 +2316,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 +2363,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 +2392,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 +2443,7 @@ MongoDB.prototype.sismember = async function (key, member) {
 			member,
 			error
 		});
-		this.logger('error', '检查集合成员失败:', error);
+		this.log('error', '检查集合成员失败:', error);
 		return false;
 	}
 };
@@ -2472,7 +2471,7 @@ MongoDB.prototype.clearExpire = async function () {
 		this.emit('clearExpire:error', {
 			error
 		});
-		this.logger('error', '清空过期数据失败:', error);
+		this.log('error', '清空过期数据失败:', error);
 		return false;
 	}
 };
@@ -2498,7 +2497,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 +2519,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 +2531,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 +2554,7 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
 			seconds,
 			error
 		});
-		this.logger('error', '批量设置失败:', error);
+		this.log('error', '批量设置失败:', error);
 		return false;
 	}
 };
@@ -2601,7 +2600,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 +2638,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 +2664,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 +2700,7 @@ MongoDB.prototype.zrem = async function (key, member) {
 
 		return removedCount;
 	} catch (error) {
-		this.logger('error', '有序集合删除成员失败:', error);
+		this.log('error', '有序集合删除成员失败:', error);
 		return 0;
 	}
 };
@@ -2731,7 +2730,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 +2763,7 @@ MongoDB.prototype.lpop = async function (key) {
 		});
 		return popped;
 	} catch (error) {
-		this.logger('error', '列表弹出头部元素失败:', error);
+		this.log('error', '列表弹出头部元素失败:', error);
 		return null;
 	}
 };
@@ -2797,7 +2796,7 @@ MongoDB.prototype.rpop = async function (key) {
 		});
 		return popped;
 	} catch (error) {
-		this.logger('error', '列表弹出尾部元素失败:', error);
+		this.log('error', '列表弹出尾部元素失败:', error);
 		return null;
 	}
 };
@@ -2832,7 +2831,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 +2852,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 +2905,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 +2931,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 +2977,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 +3014,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 +3035,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 +3057,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 +3076,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 +3139,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 +3173,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 +3205,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 +3234,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 +3275,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 +3308,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 +3346,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 +3369,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 +3381,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 +3425,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 +3470,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 +3520,7 @@ MongoDB.prototype.del = async function (key) {
 			key,
 			error: error
 		});
-		this.logger('error', '删除缓存失败:', error);
+		this.log('error', '删除缓存失败:', error);
 		return false;
 	}
 };
@@ -3547,7 +3546,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 +3604,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 +3620,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 +3635,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 +3690,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 +3860,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 +3877,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 +3896,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 +3916,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 +3931,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,7 +3946,7 @@ 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;
 	}
 };
@@ -3973,7 +3972,7 @@ if (!$.pool.mongoDB) {
  * @param {Object} config 配置参数
  * @return {Object} 返回一个MongoDB类实例
  */
-function mongodb_admin(scope, config) {
+function mongodbAdmin(scope, config) {
 	if (!scope) {
 		scope = 'sys';
 	}
@@ -3995,4 +3994,4 @@ function mongodb_admin(scope, config) {
 /**
  * @module 导出MongoDB管理器
  */
-exports.mongodb_admin = mongodb_admin;
+exports.mongodbAdmin = mongodbAdmin;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_mongodb",
-    "version": "1.5.2",
+    "version": "1.5.4",
     "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');