mm_mongodb 2.0.3 → 2.0.4

package/index.js

@@ -1,2839 +1,24 @@
 /**
  * @fileOverview MongoDB帮助类函数
- * @author <a href="http://qww.elins.cn">邱文武</a>
- * @version 2.0.0
- *
- * 接口与 mm_redis / mm_cachebase 完全对齐：
- * - 全异步 API（所有方法返回 Promise）
- * - 冒号风格事件（xxx:before / xxx:after / xxx:error）
- * - 统一方法签名与返回值
+ * @description 参考 mm_redis 结构，index.js 为薄包装，类定义在 lib/mongodb.js
  */
-const {
-	Base
-} = require('mm_expand');
-const MongoClient = require('mongodb').MongoClient;
+const MongoDB = require('./lib/mongodb');
+const Admin = require('mm_corejs').Admin;
 
 /**
- * @description MongoDB帮助类
+ * MongoDB 管理器实例（Admin 工厂）
+ * 支持 os.js 调用：require('mm_mongodb').admin.setServer(os) -> admin.get('os', config)
  */
-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(MongoDB.config);
-
-		// 数据库连接器
-		this.conn = null;
-		// 操作的数据库
-		this.db = null;
-		// 表名
-		this.table = "cache";
-		/**
-		 * 页码
-		 */
-		this.page = 1;
-		/**
-		 * 每页显示条数
-		 */
-		this.size = 0;
-		// 连接状态
-		this.connected = false;
-		// 连接Promise缓存
-		this.connectPromise = null;
-		// 连接重试次数
-		this.connectAttempts = 0;
-		this.maxConnectAttempts = 3;
-		// 发布订阅频道回调
-		this._channels = {};
-
-		this.setConfig(config);
-		// 验证配置
-		this._validateConfig();
-	}
-}
-
-// ==================== 内部辅助方法 ====================
-
-/**
- * @private
- * @description 验证配置有效性
- * @throws {Error} 配置无效时抛出错误
- */
-MongoDB.prototype._validateConfig = function () {
-	if (!this.config.host || typeof this.config.host !== 'string') {
-		throw new TypeError('host必须是有效的字符串');
-	}
-
-	if (!Number.isInteger(this.config.port) || this.config.port < 1 || this.config.port > 65535) {
-		throw new TypeError('port必须是1-65535之间的整数');
-	}
-
-	if (!this.config.database || typeof this.config.database !== 'string') {
-		throw new TypeError('database必须是有效的字符串');
-	}
-};
-
-/**
- * @private
- * @description 执行带重试的操作
- * @param {Function} operation 要执行的操作
- * @param {String} operationName 操作名称
- * @return {Promise} 操作结果
- */
-MongoDB.prototype._withRetry = async function (operation, operationName) {
-	const maxAttempts = 3;
-	const delayMS = 1000;
-	let lastError;
-
-	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-		try {
-			return await operation();
-		} catch (error) {
-			lastError = error;
-			this.log('error', `${operationName} 第${attempt}次尝试失败:`, error);
-
-			if (attempt < maxAttempts) {
-				await new Promise(resolve => setTimeout(resolve, delayMS));
-			}
-		}
-	}
-
-	this.emit('error', lastError);
-};
-
-/**
- * @description 确保数据库连接已建立
- * @private
- * @return {Promise<void>}
- */
-MongoDB.prototype._ensureConnected = async function () {
-	if (this.connectPromise) {
-		return this.connectPromise;
-	}
-
-	this.connectPromise = (async () => {
-		try {
-			if (!this.db || !this.connected) {
-				this.connectAttempts++;
-
-				await this.open();
-
-				if (this.db && this.db.collection) {
-					this.connected = true;
-					this.connectAttempts = 0;
-
-					try {
-						this.collection = this.db.collection(this.table);
-					} catch (err) {
-						this.log('error', `[_ensureConnected] 初始化collection失败:`, err);
-						this.collection = null;
-					}
-
-					if (this.collection) {
-						await this._ensureIndexes();
-					}
-				} else {
-					throw new Error('数据库连接失败，db对象为空');
-				}
-			}
-		} catch (error) {
-			this.log('error', `连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`, error);
-			this.connectPromise = null;
-
-			if (this.connectAttempts < this.maxConnectAttempts) {
-				throw error;
-			} else {
-				this.log('error', '达到最大连接重试次数，连接失败');
-				this.emit('error', new Error('数据库连接失败，已达到最大重试次数'));
-			}
-		}
-	})();
-
-	return this.connectPromise;
-};
-
-/**
- * @description 确保索引已创建
- * @private
- * @return {Promise<void>}
- */
-MongoDB.prototype._ensureIndexes = async function () {
-	try {
-		if (!this.db || !this.db.collection) {
-			throw new Error('数据库连接无效，无法创建索引');
-		}
-
-		// 创建TTL索引用于自动过期
-		await this.db.collection(this.table).createIndex({
-			expire_at: 1
-		}, {
-			expireAfterSeconds: 0
-		});
-		// 创建key索引加速查询
-		await this.db.collection(this.table).createIndex({
-			key: 1
-		}, {
-			unique: true
-		});
-	} catch (error) {
-		if (error.code !== 85) {
-			this.log('error', '创建索引失败:', error);
-		}
-	}
-};
-
-/**
- * @private
- * @description 清理查询条件，防止注入攻击
- * @param {Object} query 查询条件
- * @return {Object} 安全的查询条件
- */
-MongoDB.prototype._sanitizeQuery = function (query) {
-	const sanitized = {};
-	for (const [key, value] of Object.entries(query)) {
-		if (key.startsWith('$') && typeof key === 'string' && !Array.isArray(value) && typeof value === 'object' &&
-			value !== null) {
-			this.log('warn', '检测到可能的操作符注入尝试:', key);
-			continue;
-		}
-		sanitized[key] = value;
-	}
-	return sanitized;
-};
-
-// ==================== 连接管理 ====================
-
-/**
- * @description 设置Url
- */
-MongoDB.prototype.setUrl = function () {
-	var url = "mongodb://";
-	if (this.config.user) {
-		url += encodeURIComponent(this.config.user);
-	}
-	if (this.config.password) {
-		url += ':' + encodeURIComponent(this.config.password)
-	}
-	if (this.config.user || this.config.password) {
-		url += '@'
-	}
-	url += this.config.host + ":" + this.config.port + "/";
-	url += this.config.database;
-
-	var params = [];
-	if (this.config.min_pool_size) params.push('minPoolSize=' + this.config.min_pool_size);
-	if (this.config.max_pool_size) params.push('maxPoolSize=' + this.config.max_pool_size);
-	if (this.config.connect_timeout_ms) params.push('connectTimeoutMS=' + this.config.connect_timeout_ms);
-	if (this.config.server_selection_timeout_ms) params.push('serverSelectionTimeoutMS=' + this.config.server_selection_timeout_ms);
-	if (this.config.retry_writes !== undefined) params.push('retryWrites=' + (this.config.retry_writes ? 'true' : 'false'));
-
-	if (params.length > 0) {
-		url += '?' + params.join('&');
-	}
-
-	return url;
-};
-
-/**
- * @description 连接MongoDB数据库
- * @return {Promise<Boolean>} 连接成功返回true, 失败抛出错误
- */
-MongoDB.prototype.open = async function () {
-	if (!this.conn) {
-		return await this._withRetry(async () => {
-			try {
-				this.conn = await MongoClient.connect(this.setUrl());
-				this.db = this.conn.db(this.config.database);
-				this.connected = true;
-
-				this.conn.on('error', (err) => {
-					this.log('error', '连接错误:', err);
-					this.connected = false;
-				});
-
-				this.conn.on('close', () => {
-					this.log('warn', '连接已关闭');
-					this.connected = false;
-				});
-
-				return true;
-			} catch (error) {
-				this.log('error', 'MongoDB连接失败:', error);
-			}
-		}, '数据库连接');
-	}
-	return true;
-};
-
-/**
- * @description 关闭数据库连接
- * @return {Promise<Boolean>} 关闭结果
- */
-MongoDB.prototype.close = async function () {
-	if (this.conn) {
-		await this.conn.close().catch(err => this.log('error', '关闭MongoDB连接时出错:', err));
-		this.conn = null;
-		this.db = null;
-		this.connected = false;
-		this._channels = {};
-	}
-	return true;
-};
-
-/**
- * @description 检查连接状态（与 mm_redis 接口对齐）
- * @return {Boolean} 是否已连接
- */
-MongoDB.prototype.isConnected = function () {
-	return this.connected;
-};
-
-// ==================== 核心 CRUD 方法 ====================
-
-/**
- * @description 查询单条数据
- * @param {Object} query 查询条件对象
- * @param {Object} options 查询选项
- * @return {Promise<Object|null>} 查询结果
- */
-MongoDB.prototype.findOne = async function (query, options = {}) {
-	await this._ensureConnected();
-	try {
-		if (typeof query !== 'object' || query === null) {
-			return null;
-		}
-		return await this.db.collection(this.table).findOne(query, options);
-	} catch (error) {
-		this.log('error', '查询单条数据失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 查询缓存
- * @param {Object} query 查询条件对象
- * @param {Object} options 查询选项
- * @return {Promise<Array>} 查询结果数组
- */
-MongoDB.prototype.find = async function (query, options = {}) {
-	await this._ensureConnected();
-	try {
-		const safeQuery = this._sanitizeQuery(query);
-		const cursor = this.db.collection(this.table).find(safeQuery, options);
-		return await cursor.toArray();
-	} catch (error) {
-		this.log('error', '查询失败:', error);
-		return [];
-	}
-};
-
-/**
- * @description 增加一条缓存
- * @param {Object} obj 对象
- * @return {Promise|Object} 执行结果
- */
-MongoDB.prototype.addObj = async function (obj) {
-	await this._ensureConnected();
-	try {
-		this.emit('addObj:before', { table: this.table, data: obj });
-		const result = await this.db.collection(this.table).insertOne(obj);
-		this.emit('addObj:after', { table: this.table, data: obj, result });
-		return result;
-	} catch (error) {
-		this.emit('addObj:error', { table: this.table, data: obj, error });
-		throw error;
-	}
-};
-
-/**
- * @description 增加多条缓存
- * @param {Array} list 对象数组
- * @return {Promise|Object} 执行结果
- */
-MongoDB.prototype.addList = async function (list) {
-	await this._ensureConnected();
-	try {
-		this.emit('addList:before', { table: this.table, data: list });
-		const result = await this.db.collection(this.table).insertMany(list);
-		this.emit('addList:after', { table: this.table, data: list, result });
-		return result;
-	} catch (error) {
-		this.emit('addList:error', { table: this.table, data: list, error });
-		throw error;
-	}
-};
-
-/**
- * @description 删除缓存
- * @param {Object|String} query 查询条件对象或键名
- * @return {Promise|Object} 执行结果
- */
-MongoDB.prototype.delete = async function (query) {
-	await this._ensureConnected();
-	try {
-		const safeQuery = typeof query === 'string' ? { key: query } : query;
-		this.emit('delete:before', { table: this.table, query: safeQuery });
-		const result = await this.db.collection(this.table).deleteMany(safeQuery);
-		this.emit('delete:after', { table: this.table, query: safeQuery, result });
-		return result;
-	} catch (error) {
-		this.emit('delete:error', { table: this.table, query, error });
-		throw error;
-	}
-};
-
-/**
- * @description 修改缓存
- * @param {Object|String} query 查询条件对象或键名
- * @param {Object} body 修改对象
- * @param {Object} options 附加选项
- * @return {Promise|Object} 执行结果
- */
-MongoDB.prototype.setting = async function (query, body, options = {}) {
-	await this._ensureConnected();
-	try {
-		const safeQuery = typeof query === 'string' ? { key: query } : query;
-
-		let updateBody;
-		if (typeof query === 'string') {
-			updateBody = { $set: { value: body } };
-		} else if (!body.$set && !body.$inc && !body.$push) {
-			updateBody = { $set: body };
-		} else {
-			updateBody = body;
-		}
-
-		const updateOptions = Object.assign({ multi: true }, options);
-
-		this.emit('setting:before', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions });
-		const result = await this.db.collection(this.table).updateMany(safeQuery, updateBody, updateOptions);
-		this.emit('setting:after', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions, result });
-
-		return typeof query === 'string' ? result.modifiedCount > 0 : result;
-	} catch (error) {
-		this.emit('setting:error', { table: this.table, query, update: body, options, error });
-		return typeof query === 'string' ? false : null;
-	}
-};
-
-/**
- * @description 计算文档数量
- * @param {Object} query 查询条件对象
- * @return {Promise<Number>} 文档数量
- */
-MongoDB.prototype.count = async function (query = {}) {
-	await this._ensureConnected();
-	try {
-		const safeQuery = this._sanitizeQuery(query);
-		return await this.db.collection(this.table).countDocuments(safeQuery);
-	} catch (error) {
-		this.log('error', '计算文档数量失败:', error);
-		return 0;
-	}
-};
-
-// ==================== 表与索引管理 ====================
-
-/**
- * @description 创建数据表
- * @param {String} table 表名
- * @return {Promise|Object} 执行结果
- */
-MongoDB.prototype.addTable = async function (table) {
-	if (typeof table !== 'string' || !table) {
-		throw new TypeError('table必须是有效的字符串');
-	}
-	await this._ensureConnected();
-	if (table) {
-		this.table = table;
-	} else {
-		table = this.table;
-	}
-	return this.db.createCollection(table);
-};
-
-/**
- * @description 创建索引
- * @param {Object} keys 索引键配置
- * @param {Object} options 索引选项
- * @returns {Promise<Object>} 创建索引的结果
- */
-MongoDB.prototype.createIndex = async function (keys, options = {}) {
-	if (typeof keys !== 'object' || keys === null || Array.isArray(keys)) {
-		throw new TypeError('keys必须是非空对象');
-	}
-	await this._ensureConnected();
-	try {
-		if (!this.db || !this.table) {
-			throw new Error('数据库未连接或未指定表名');
-		}
-		return await this.db.collection(this.table).createIndex(keys, options);
-	} catch (error) {
-		this.log('error', `创建索引失败: ${error.message}`);
-		throw error;
-	}
-};
-
-/**
- * @description 创建TTL索引（数据自动过期）
- * @param {Object} keys 索引键配置
- * @param {Number} expireAfterSeconds 过期时间（秒）
- * @returns {Promise<Object>} 创建索引的结果
- */
-MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
-	if (typeof keys !== 'object' || keys === null || Array.isArray(keys)) {
-		throw new TypeError('keys必须是非空对象');
-	}
-	if (typeof expireAfterSeconds !== 'number' || expireAfterSeconds < 0) {
-		throw new TypeError('expireAfterSeconds必须是非负数');
-	}
-	await this._ensureConnected();
-	try {
-		if (!this.db || !this.table) {
-			throw new Error('数据库未连接或未指定表名');
-		}
-		const options = { background: true, expireAfterSeconds: expireAfterSeconds };
-		return await this.db.collection(this.table).createIndex(keys, options);
-	} catch (error) {
-		this.log('error', `创建TTL索引失败: ${error.message}`);
-		throw error;
-	}
-};
-
-/**
- * @description 获取集合的所有索引
- * @returns {Promise<Array>} 索引信息数组
- */
-MongoDB.prototype.getIndexes = async function () {
-	await this._ensureConnected();
-	try {
-		if (!this.table) {
-			throw new Error('未指定表名');
-		}
-		return await this.db.collection(this.table).indexes();
-	} catch (error) {
-		this.log('error', `[getIndexes] 获取索引失败: ${error.message}`);
-		return [];
-	}
-};
-
-/**
- * @description 删除指定索引
- * @param {String} indexName 索引名称
- * @returns {Promise<Boolean>} 是否删除成功
- */
-MongoDB.prototype.dropIndex = async function (indexName) {
-	await this._ensureConnected();
-	if (!this.table) {
-		throw new TypeError('未指定表名');
-	}
-	if (!indexName) {
-		throw new TypeError('索引名称不能为空');
-	}
-	try {
-		await this.db.collection(this.table).dropIndex(indexName);
-		return true;
-	} catch (error) {
-		this.log('error', `[dropIndex] 删除索引失败: ${error.message}`);
-		throw error;
-	}
-};
-
-/**
- * @description 删除集合（表）
- * @returns {Promise<Boolean>} 是否删除成功
- */
-MongoDB.prototype.dropTable = async function () {
-	await this._ensureConnected();
-	if (!this.table) {
-		throw new Error('未指定表名');
-	}
-	try {
-		await this.db.collection(this.table).drop();
-		return true;
-	} catch (error) {
-		this.log('error', `[dropTable] 删除集合失败: ${error.message}`);
-		throw error;
-	}
-};
-
-// ==================== 事务管理 ====================
-
-/**
- * @description 启动事务
- * @return {Promise<Object>} 会话对象
- */
-MongoDB.prototype.startTransaction = async function () {
-	await this._ensureConnected();
-	try {
-		const session = this.conn.startSession();
-		session.startTransaction();
-		return session;
-	} catch (error) {
-		this.log('error', '[startTransaction] 启动事务失败:', error);
-		throw error;
-	}
-};
-
-/**
- * @description 提交事务
- * @param {Object} session 会话对象
- * @return {Promise<void>}
- */
-MongoDB.prototype.commitTransaction = async function (session) {
-	try {
-		await session.commitTransaction();
-		await session.endSession();
-	} catch (error) {
-		this.log('error', '[commitTransaction] 提交事务失败:', error);
-		throw error;
-	}
-};
-
-/**
- * @description 回滚事务
- * @param {Object} session 会话对象
- * @return {Promise<void>}
- */
-MongoDB.prototype.rollbackTransaction = async function (session) {
-	try {
-		await session.abortTransaction();
-		await session.endSession();
-	} catch (error) {
-		this.log('error', '[rollbackTransaction] 回滚事务失败:', error);
-		throw error;
-	}
-};
-
-// ==================== Redis 兼容 API - 键值操作 ====================
-
-/**
- * @description 设置键值对
- * @param {String} key 键名
- * @param {*} value 值
- * @param {Number} [seconds=0] 过期时间（秒），0表示永不过期
- * @return {Promise<Boolean>} 是否设置成功
- */
-MongoDB.prototype.set = async function (key, value, seconds = 0) {
-	await this._ensureConnected();
-	try {
-		if (!key || typeof key !== 'string') {
-			this.log('error', '参数错误: key必须是非空字符串');
-			return false;
-		}
-
-		const ctx = { key, value, seconds, cancel: false };
-		this.emit('set:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `set操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		const { key: finalKey, value: finalValue, seconds: finalSeconds } = ctx;
-
-		const updateData = { $set: { value: finalValue } };
-
-		if (finalSeconds && typeof finalSeconds === 'number' && finalSeconds > 0) {
-			updateData.$set.expire_at = new Date(Date.now() + finalSeconds * 1000);
-		} else {
-			updateData.$unset = { expire_at: "" };
-		}
-
-		const result = await this.db.collection(this.table).updateOne(
-			{ key: finalKey },
-			updateData,
-			{ upsert: true }
-		);
-
-		this.emit('set:after', { key: finalKey, value: finalValue, seconds: finalSeconds, success: result.acknowledged });
-		return result.acknowledged;
-	} catch (error) {
-		this.emit('set:error', { key, value, seconds, error });
-		this.log('error', `设置键值失败: ${error.message}`);
-		return false;
-	}
-};
-
-/**
- * @description 获取键值
- * @param {String} key 键名
- * @return {Promise<Object|null>} 返回键值，不存在或错误返回null
- */
-MongoDB.prototype.get = async function (key) {
-	await this._ensureConnected();
-	try {
-		this.emit('get:before', { key });
-
-		if (!key || typeof key !== 'string') {
-			return null;
-		}
-
-		const result = await this.db.collection(this.table).findOne({ key: key });
-		const value = result ? result.value : null;
-
-		this.emit('get:after', { key, value });
-		return value;
-	} catch (error) {
-		this.log('error', `获取键值失败: ${error.message}`);
-		this.emit('get:error', { key, error });
-		return null;
-	}
-};
-
-/**
- * @description 删除键
- * @param {String|Array<String>} key 键名或键名数组
- * @return {Promise<Number>} 删除的键数量
- */
-MongoDB.prototype.del = async function (key) {
-	if (!key) {
-		throw new TypeError('key必须是非空字符串或非空字符串数组');
-	}
-
-	if (typeof key === 'string') {
-		if (!key) throw new TypeError('key必须是非空字符串');
-	} else if (Array.isArray(key)) {
-		for (const k of key) {
-			if (!k || typeof k !== 'string') {
-				throw new TypeError('key必须是非空字符串或非空字符串数组');
-			}
-		}
-	} else {
-		throw new TypeError('key必须是非空字符串或非空字符串数组');
-	}
-
-	await this._ensureConnected();
-	try {
-		const ctx = { key, cancel: false };
-		this.emit('del:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const { key: finalKey } = ctx;
-		let deletedCount = 0;
-
-		if (Array.isArray(finalKey)) {
-			const result = await this.db.collection(this.table).deleteMany({
-				key: { $in: finalKey }
-			});
-			deletedCount = result.deletedCount;
-		} else {
-			const result = await this.db.collection(this.table).deleteOne({ key: finalKey });
-			deletedCount = result.deletedCount;
-		}
-
-		this.emit('del:after', { key: finalKey, success: deletedCount > 0, deleted: deletedCount });
-		return deletedCount;
-	} catch (error) {
-		this.emit('del:error', { key, error });
-		this.log('error', '删除缓存失败:', error);
-		return 0;
-	}
-};
-
-/**
- * @description 检查键是否存在
- * @param {String|Array<String>} key 键名或键名数组
- * @return {Promise<Number>} 存在返回1（单键）或计数（多键），不存在返回0
- */
-MongoDB.prototype.exists = async function (key) {
-	await this._ensureConnected();
-	try {
-		this.emit('exists:before', { key });
-
-		if (!key) {
-			throw new TypeError('key必须是非空字符串或非空字符串数组');
-		}
-
-		if (typeof key === 'string') {
-			const result = await this.db.collection(this.table).findOne(
-				{ key: key },
-				{ projection: { _id: 1 } }
-			);
-			const count = result ? 1 : 0;
-			this.emit('exists:after', { key, result: count });
-			return count;
-		} else if (Array.isArray(key)) {
-			for (const k of key) {
-				if (!k || typeof k !== 'string') {
-					throw new TypeError('key数组中的每个元素必须是非空字符串');
-				}
-			}
-			const count = await this.db.collection(this.table).countDocuments({
-				key: { $in: key }
-			});
-			this.emit('exists:after', { key, result: count });
-			return count;
-		} else {
-			throw new TypeError('key必须是非空字符串或非空字符串数组');
-		}
-	} catch (error) {
-		this.log('error', `检查键是否存在失败: ${error.message}`);
-		return 0;
-	}
-};
-
-/**
- * @description 检查键是否存在
- * @param {String} key 键名
- * @return {Promise<Boolean>} 是否存在
- */
-MongoDB.prototype.has = async function (key) {
-	const result = await this.exists(key);
-	return result > 0;
-};
-
-/**
- * @description 获取并设置值
- * @param {String} key 键名
- * @param {*} value 新值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Object|null>} 旧值
- */
-MongoDB.prototype.getset = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return null;
-		}
-		const oldValue = await this.get(key);
-		await this.set(key, value, seconds);
-		return oldValue;
-	} catch (error) {
-		this.log('error', 'Failed to getset:', error);
-		return null;
-	}
-};
-
-/**
- * @description 仅当键不存在时设置值（SETNX 语义）
- * @param {String} key 键名
- * @param {*} value 值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Boolean>} 键不存在并设置成功返回true，键已存在返回false
- */
-MongoDB.prototype.add = async function (key, value, seconds = 0) {
-	await this._ensureConnected();
-	try {
-		const ctx = { key, value, seconds, cancel: false };
-		this.emit('add:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey, value: finalValue, seconds: finalSeconds } = ctx;
-
-		const existing = await this.db.collection(this.table).findOne({ key: finalKey });
-		if (existing) {
-			this.emit('add:after', { key: finalKey, value: finalValue, seconds: finalSeconds, success: false });
-			return false;
-		}
-
-		const data = { key: finalKey, value: finalValue };
-		if (finalSeconds && finalSeconds > 0) {
-			data.expire_at = new Date(Date.now() + finalSeconds * 1000);
-		}
-
-		const result = await this.db.collection(this.table).insertOne(data);
-		const success = result.acknowledged;
-
-		this.emit('add:after', { key: finalKey, value: finalValue, seconds: finalSeconds, success });
-		return success;
-	} catch (error) {
-		this.emit('add:error', { key, value, seconds, error });
-		this.log('error', `添加键值失败: ${error.message}`);
-		return false;
-	}
-};
-
-// ==================== Redis 兼容 API - 批量操作 ====================
-
-/**
- * @description 一次性设置多个键值对
- * @param {Object} obj 键值对对象
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Boolean>} 成功返回true，失败返回false
- */
-MongoDB.prototype.mset = async function (obj, seconds = 0) {
-	try {
-		const ctx = { keyValuePairs: obj, seconds, cancel: false };
-		this.emit('mset:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { keyValuePairs: finalData, seconds: finalSeconds } = ctx;
-
-		if (typeof finalData !== 'object' || finalData === null || Array.isArray(finalData)) {
-			this.log('warn', 'mset: 参数必须是非空对象');
-			return false;
-		}
-
-		await this._ensureConnected();
-		for (const [key, value] of Object.entries(finalData)) {
-			await this.set(key, value, finalSeconds);
-		}
-
-		this.emit('mset:after', { keyValuePairs: finalData, seconds: finalSeconds, result: true });
-		return true;
-	} catch (error) {
-		this.emit('mset:error', { keyValuePairs: obj, seconds, error });
-		this.log('error', '批量设置失败:', error);
-		return false;
-	}
-};
-
-/**
- * @description 批量获取多个键的值
- * @param {Array} keys 键名数组
- * @return {Promise<Array>} 值数组，不存在的键返回null
- */
-MongoDB.prototype.mget = async function (keys) {
-	try {
-		this.emit('mget:before', { keys });
-
-		if (!Array.isArray(keys)) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const results = await this.db.collection(this.table).find({
-			key: { $in: keys }
-		}).toArray();
-
-		const resultMap = {};
-		results.forEach(item => {
-			resultMap[item.key] = item.value;
-		});
-
-		// 返回与输入键顺序对应的数组，不存在的键返回null
-		const values = keys.map(key => resultMap.hasOwnProperty(key) ? resultMap[key] : null);
-
-		this.emit('mget:after', { keys, results: values });
-		return values;
-	} catch (error) {
-		this.log('error', '批量获取失败:', error);
-		return [];
-	}
-};
-
-// ==================== Redis 兼容 API - 过期时间管理 ====================
-
-/**
- * @description 设置键的过期时间
- * @param {String} key 键名
- * @param {Number} seconds 过期时间（秒）
- * @return {Promise<Boolean>} 是否成功
- */
-MongoDB.prototype.expire = async function (key, seconds) {
-	try {
-		seconds = parseInt(seconds) || 0;
-
-		const ctx = { key, seconds, cancel: false };
-		this.emit('expire:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey, seconds: finalSeconds } = ctx;
-
-		await this._ensureConnected();
-
-		const count = await this.db.collection(this.table).countDocuments({ key: finalKey });
-		if (count === 0) {
-			this.emit('expire:after', { key: finalKey, seconds: finalSeconds, result: false });
-			return false;
-		}
-
-		const updateData = {};
-		if (finalSeconds === 0 || finalSeconds === -1) {
-			updateData.$unset = { expire_at: 1 };
-		} else if (finalSeconds > 0) {
-			updateData.$set = { expire_at: new Date(Date.now() + finalSeconds * 1000) };
-		} else {
-			updateData.$set = { expire_at: new Date(0) };
-		}
-
-		await this.db.collection(this.table).updateOne({ key: finalKey }, updateData, { upsert: false });
-
-		this.emit('expire:after', { key: finalKey, seconds: finalSeconds, result: true });
-		return true;
-	} catch (error) {
-		this.emit('expire:error', { key, seconds, error });
-		this.log('error', 'expire方法执行错误', { error: error.message, key, seconds });
-		return false;
-	}
-};
-
-/**
- * @description 设置键的过期时间（毫秒）
- * @param {String} key 键名
- * @param {Number} milliseconds 过期时间（毫秒）
- * @return {Promise<Boolean>} 是否成功
- */
-MongoDB.prototype.pexpire = async function (key, milliseconds) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (typeof milliseconds !== 'number' || milliseconds <= 0) {
-			throw new TypeError('milliseconds必须是正数');
-		}
-
-		const ctx = { key, ttl: milliseconds, cancel: false };
-		this.emit('pexpire:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey, ttl: finalMilliseconds } = ctx;
-
-		await this._ensureConnected();
-
-		const count = await this.db.collection(this.table).countDocuments({ key: finalKey });
-		if (count === 0) {
-			this.emit('pexpire:after', { key: finalKey, ttl: finalMilliseconds, result: false });
-			return false;
-		}
-
-		await this.db.collection(this.table).updateOne(
-			{ key: finalKey },
-			{ $set: { expire_at: new Date(Date.now() + finalMilliseconds) } },
-			{ upsert: false }
-		);
-
-		this.emit('pexpire:after', { key: finalKey, ttl: finalMilliseconds, result: true });
-		return true;
-	} catch (error) {
-		this.emit('pexpire:error', { key, ttl: milliseconds, error });
-		this.log('error', `Failed to set pexpire for key ${key}:`, error);
-		return false;
-	}
-};
-
-/**
- * @description 移除键的过期时间
- * @param {String} key 键名
- * @return {Promise<Boolean>} 是否成功移除
- */
-MongoDB.prototype.persist = async function (key) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-
-		const ctx = { key, cancel: false };
-		this.emit('persist:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey } = ctx;
-
-		await this._ensureConnected();
-
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-		if (!item) {
-			this.emit('persist:after', { key: finalKey, success: false });
-			return false;
-		}
-
-		if (!item.expire_at) {
-			this.emit('persist:after', { key: finalKey, success: true });
-			return true;
-		}
-
-		const result = await this.db.collection(this.table).updateOne(
-			{ key: finalKey },
-			{ $unset: { expire_at: 1 } },
-			{ upsert: false }
-		);
-
-		const success = result.modifiedCount > 0;
-		this.emit('persist:after', { key: finalKey, success });
-		return success;
-	} catch (error) {
-		this.emit('persist:error', { key, error });
-		this.log('error', 'persist error:', error);
-		return false;
-	}
-};
-
-/**
- * @description 获取或设置键的过期时间
- * @param {String} key 键名
- * @param {Number} [seconds] 过期时间（秒），不传则获取剩余过期时间
- * @return {Promise<Number|Boolean>} 不传seconds返回剩余秒数（-1无过期，-2已过期），传seconds返回是否设置成功
- */
-MongoDB.prototype.ttl = async function (key, seconds) {
-	try {
-		this.emit('ttl:before', { key, seconds });
-
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-
-		const isSetMode = arguments.length > 1 && seconds !== undefined;
-
-		await this._ensureConnected();
-
-		if (isSetMode) {
-			const result = await this.expire(key, seconds);
-			this.emit('ttl:after', { key, seconds, success: result });
-			return result;
-		} else {
-			const item = await this.db.collection(this.table).findOne({ key });
-
-			if (!item) {
-				return -2;
-			}
-
-			if (!item.expire_at) {
-				return -1;
-			}
-
-			const expireTime = new Date(item.expire_at).getTime();
-			const currentTime = Date.now();
-			const remainingSeconds = Math.ceil((expireTime - currentTime) / 1000);
-
-			if (remainingSeconds <= 0) {
-				return -2;
-			}
-
-			return remainingSeconds;
-		}
-	} catch (error) {
-		this.emit('ttl:error', { key, seconds, error });
-		this.log('error', `[ttl] 操作失败:`, error);
-		return arguments.length === 1 ? -2 : false;
-	}
-};
-
-// ==================== Redis 兼容 API - 哈希表操作 ====================
-
-/**
- * @description 设置哈希表字段
- * @param {String} key 哈希表键名
- * @param {String} field 字段名
- * @param {*} value 值
- * @return {Promise<Boolean>} 操作结果
- */
-MongoDB.prototype.hset = async function (key, field, value) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-		if (typeof field !== 'string' || !field) {
-			throw new TypeError('field必须是有效的字符串');
-		}
-
-		const ctx = { key, field, value, cancel: false };
-		this.emit('hset:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey, field: finalField, value: finalValue } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-		let hash = item && typeof item.value === 'object' && item.value !== null && !Array.isArray(item.value)
-			? item.value : {};
-
-		hash[finalField] = finalValue;
-
-		await this.set(finalKey, hash);
-
-		this.emit('hset:after', { key: finalKey, field: finalField, value: finalValue, success: true });
-		return true;
-	} catch (error) {
-		this.emit('hset:error', { key, field, value, error });
-		this.log('error', '哈希表设置失败:', error);
-		return false;
-	}
-};
-
-/**
- * @description 获取哈希表字段值
- * @param {String} key 哈希表键名
- * @param {String} field 字段名
- * @return {Promise<Object|null>} 字段值，不存在或错误返回null
- */
-MongoDB.prototype.hget = async function (key, field) {
-	try {
-		this.emit('hget:before', { key, field });
-
-		if (typeof key !== 'string' || !key || typeof field !== 'string' || !field) {
-			return null;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || typeof item.value !== 'object' || item.value === null || Array.isArray(item.value)) {
-			return null;
-		}
-
-		const value = Object.prototype.hasOwnProperty.call(item.value, field) ? item.value[field] : null;
-		this.emit('hget:after', { key, field, value });
-		return value;
-	} catch (error) {
-		this.log('error', '哈希表获取失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 获取哈希表所有字段和值
- * @param {String} key 哈希表键名
- * @return {Promise<Object>} 哈希表内容
- */
-MongoDB.prototype.hgetall = async function (key) {
-	try {
-		this.emit('hgetall:before', { key });
-
-		if (typeof key !== 'string' || !key) {
-			return {};
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || typeof item.value !== 'object' || item.value === null || Array.isArray(item.value)) {
-			return {};
-		}
-
-		const result = { ...item.value };
-		this.emit('hgetall:after', { key, result });
-		return result;
-	} catch (error) {
-		this.log('error', '哈希表获取全部失败:', error);
-		return {};
-	}
-};
-
-/**
- * @description 删除哈希表字段
- * @param {String} key 哈希表键名
- * @param {String|Array<String>} field 字段名或字段名数组
- * @return {Promise<Number>} 删除的字段数量
- */
-MongoDB.prototype.hdel = async function (key, fields) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-		if (!fields || (typeof fields !== 'string' && !Array.isArray(fields))) {
-			throw new TypeError('fields必须是字符串或字符串数组');
-		}
-
-		const ctx = { key, field: fields, cancel: false };
-		this.emit('hdel:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const fieldArray = Array.isArray(fields) ? fields : [fields];
-		if (fieldArray.length === 0) {
-			return 0;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || typeof item.value !== 'object' || item.value === null || Array.isArray(item.value)) {
-			this.emit('hdel:after', { key, field: fields, success: false, deleted: 0 });
-			return 0;
-		}
-
-		let deletedCount = 0;
-		const updatedValue = { ...item.value };
-
-		fieldArray.forEach(field => {
-			if (field && Object.prototype.hasOwnProperty.call(updatedValue, field)) {
-				delete updatedValue[field];
-				deletedCount++;
-			}
-		});
-
-		if (deletedCount > 0) {
-			await this.db.collection(this.table).updateOne(
-				{ key },
-				{ $set: { value: updatedValue, updated_at: new Date() } }
-			);
-		}
-
-		this.emit('hdel:after', { key, field: fields, success: deletedCount > 0, deleted: deletedCount });
-		return deletedCount;
-	} catch (error) {
-		this.emit('hdel:error', { key, field: fields, error });
-		this.log('error', 'hdel操作失败:', error);
-		return 0;
-	}
-};
-
-/**
- * @description 批量设置哈希表字段
- * @param {String} key 哈希表键名
- * @param {Object} obj 包含多个字段的对象
- * @return {Promise<Boolean>} 操作结果
- */
-MongoDB.prototype.hmset = async function (key, obj) {
-	try {
-		if (!key || typeof key !== 'string' || !obj || typeof obj !== 'object' || Array.isArray(obj)) {
-			return false;
-		}
-
-		const ctx = { key, value: obj, cancel: false };
-		this.emit('hmset:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey, value: finalObj } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-		let hash = item && typeof item.value === 'object' && item.value !== null && !Array.isArray(item.value)
-			? item.value : {};
-
-		Object.assign(hash, finalObj);
-		await this.set(finalKey, hash);
-
-		this.emit('hmset:after', { key: finalKey, value: finalObj, success: true });
-		return true;
-	} catch (error) {
-		this.emit('hmset:error', { key, value: obj, error });
-		this.log('error', '[hmset] 哈希表批量设置失败:', error);
-		return false;
-	}
-};
-
-/**
- * @description 批量获取哈希表字段
- * @param {String} key 哈希表键名
- * @param {Array} fields 字段名数组
- * @return {Promise<Array>} 字段值数组，不存在的字段返回null
- */
-MongoDB.prototype.hmget = async function (key, fields) {
-	try {
-		this.emit('hmget:before', { key, fields });
-
-		if (!key || typeof key !== 'string' || !Array.isArray(fields)) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		const fieldArray = Array.isArray(fields) ? fields : [fields];
-
-		if (!item || typeof item.value !== 'object' || item.value === null || Array.isArray(item.value)) {
-			return fieldArray.map(() => null);
-		}
-
-		const values = fieldArray.map(field =>
-			Object.prototype.hasOwnProperty.call(item.value, field) ? item.value[field] : null
-		);
-
-		this.emit('hmget:after', { key, fields, results: values });
-		return values;
-	} catch (error) {
-		this.emit('hmget:error', { key, fields, error });
-		this.log('error', 'hmget操作失败:', error);
-		const fieldArray = Array.isArray(fields) ? fields : [fields];
-		return fieldArray.map(() => null);
-	}
-};
-
-/**
- * @description 获取哈希表字段数量
- * @param {String} key 哈希表键名
- * @return {Promise<Number>} 字段数量
- */
-MongoDB.prototype.hlen = async function (key) {
-	try {
-		this.emit('hlen:before', { key });
-
-		if (typeof key !== 'string' || !key) {
-			return 0;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || typeof item.value !== 'object' || item.value === null || Array.isArray(item.value)) {
-			return 0;
-		}
-
-		const result = Object.keys(item.value).length;
-		this.emit('hlen:after', { key, result });
-		return result;
-	} catch (error) {
-		this.emit('hlen:error', { key, error });
-		this.log('error', 'hlen操作失败:', error);
-		return 0;
-	}
-};
-
-/**
- * @description 哈希表字段是否存在
- * @param {String} key 键名
- * @param {String} field 字段名
- * @return {Promise<Boolean>} 是否存在
- */
-MongoDB.prototype.hexists = async function (key, field) {
-	try {
-		if (typeof key !== 'string' || !key || typeof field !== 'string' || !field) {
-			return false;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || typeof item.value !== 'object' || item.value === null) {
-			return false;
-		}
-		return Object.prototype.hasOwnProperty.call(item.value, field);
-	} catch (error) {
-		this.log('error', '哈希表字段是否存在失败:', error);
-		return false;
-	}
-};
-
-/**
- * @description 哈希表获取所有值
- * @param {String} key 键名
- * @return {Promise<Array>} 值数组
- */
-MongoDB.prototype.hvals = async function (key) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || typeof item.value !== 'object' || item.value === null) {
-			return [];
-		}
-		return Object.values(item.value);
-	} catch (error) {
-		this.log('error', '哈希表获取所有值失败:', error);
-		return [];
-	}
-};
-
-/**
- * @description 哈希表获取所有字段名
- * @param {String} key 键名
- * @return {Promise<Array>} 字段名数组
- */
-MongoDB.prototype.hkeys = async function (key) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || typeof item.value !== 'object' || item.value === null) {
-			return [];
-		}
-		return Object.keys(item.value);
-	} catch (error) {
-		this.log('error', '哈希表获取所有字段名失败:', error);
-		return [];
-	}
-};
-
-// ==================== Redis 兼容 API - 数值操作 ====================
-
-/**
- * @description 将键的值增加1
- * @param {String} key 键
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的值，失败返回null
- */
-MongoDB.prototype.incr = async function (key, seconds = 0) {
-	try {
-		const ctx = { key, seconds, cancel: false };
-		this.emit('incr:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const { key: finalKey, seconds: finalSeconds } = ctx;
-
-		if (typeof finalKey !== 'string' || !finalKey) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-
-		await this._ensureConnected();
-		const result = await this.addInt(finalKey, 1, finalSeconds);
-
-		this.emit('incr:after', { key: finalKey, seconds: finalSeconds, result, success: true });
-		return result;
-	} catch (error) {
-		this.emit('incr:error', { key, seconds, error });
-		this.log('error', '递增操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 将键的值减少1
- * @param {String} key 键
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 减少后的值，失败返回null
- */
-MongoDB.prototype.decr = async function (key, seconds = 0) {
-	try {
-		const ctx = { key, seconds, cancel: false };
-		this.emit('decr:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const { key: finalKey, seconds: finalSeconds } = ctx;
-
-		if (typeof finalKey !== 'string' || !finalKey) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-
-		await this._ensureConnected();
-		const result = await this.addInt(finalKey, -1, finalSeconds);
-
-		this.emit('decr:after', { key: finalKey, seconds: finalSeconds, result, success: true });
-		return result;
-	} catch (error) {
-		this.emit('decr:error', { key, seconds, error });
-		this.log('error', '递减操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 将键的值增加指定整数
- * @param {String} key 键
- * @param {Number} increment 增量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的值，失败返回null
- */
-MongoDB.prototype.incrby = async function (key, increment = 1, seconds = 0) {
-	try {
-		const ctx = { key, increment, seconds, cancel: false };
-		this.emit('incrby:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const { key: finalKey, increment: finalIncrement, seconds: finalSeconds } = ctx;
-
-		if (typeof finalKey !== 'string' || !finalKey) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-
-		await this._ensureConnected();
-		const result = await this.addInt(finalKey, Number(finalIncrement) || 0, finalSeconds);
-
-		this.emit('incrby:after', { key: finalKey, increment: finalIncrement, seconds: finalSeconds, result, success: true });
-		return result;
-	} catch (error) {
-		this.emit('incrby:error', { key, increment, seconds, error });
-		this.log('error', '递增操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 将键的值减少指定整数
- * @param {String} key 键
- * @param {Number} decrement 减量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 减少后的值，失败返回null
- */
-MongoDB.prototype.decrby = async function (key, decrement = 1, seconds = 0) {
-	try {
-		const ctx = { key, decrement, seconds, cancel: false };
-		this.emit('decrby:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const { key: finalKey, decrement: finalDecrement, seconds: finalSeconds } = ctx;
-
-		if (typeof finalKey !== 'string' || !finalKey) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-
-		await this._ensureConnected();
-		const result = await this.addInt(finalKey, -(Number(finalDecrement) || 0), finalSeconds);
-
-		this.emit('decrby:after', { key: finalKey, decrement: finalDecrement, seconds: finalSeconds, result, success: true });
-		return result;
-	} catch (error) {
-		this.emit('decrby:error', { key, decrement, seconds, error });
-		this.log('error', '递减操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 将键的值增加指定浮点数
- * @param {String} key 键
- * @param {Number} [increment=1.0] 增量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的值，失败返回null
- */
-MongoDB.prototype.incrbyfloat = async function (key, increment = 1.0, seconds = 0) {
-	try {
-		const ctx = { key, increment, seconds, cancel: false };
-		this.emit('incrbyfloat:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const { key: finalKey, increment: finalIncrement, seconds: finalSeconds } = ctx;
-
-		if (typeof finalKey !== 'string' || !finalKey) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-
-		await this._ensureConnected();
-		const result = await this.addFloat(finalKey, Number(finalIncrement) || 0.0, finalSeconds);
-
-		this.emit('incrbyfloat:after', { key: finalKey, increment: finalIncrement, seconds: finalSeconds, result, success: true });
-		return result;
-	} catch (error) {
-		this.emit('incrbyfloat:error', { key, increment, seconds, error });
-		this.log('error', '浮点递增操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 增加整数值（兼容方法）
- * @param {String} key 键名
- * @param {Number} value 要增加的整数值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的值，失败返回null
- */
-MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-
-		const ctx = { key, value, seconds, cancel: false };
-		this.emit('addInt:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const { key: finalKey, value: finalValue, seconds: finalSeconds } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-		let currentValue = 0;
-
-		if (item) {
-			currentValue = Number(item.value) || 0;
-		}
-
-		const newValue = Math.floor(currentValue + Number(finalValue));
-		await this.set(finalKey, newValue, finalSeconds);
-
-		this.emit('addInt:after', { key: finalKey, value: finalValue, seconds: finalSeconds, result: newValue, success: true });
-		return newValue;
-	} catch (error) {
-		this.emit('addInt:error', { key, value, seconds, error });
-		this.log('error', '增加整数值失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 增加浮点数（兼容方法）
- * @param {String} key 键名
- * @param {Number} num 要增加的浮点数值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的值，失败返回null
- */
-MongoDB.prototype.addFloat = async function (key, num = 1.0, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-
-		const ctx = { key, num, seconds, cancel: false };
-		this.emit('addFloat:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const { key: finalKey, num: finalNum, seconds: finalSeconds } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-		let currentValue = 0.0;
-
-		if (item) {
-			currentValue = Number(item.value) || 0.0;
-		}
-
-		const newValue = currentValue + Number(finalNum);
-		await this.set(finalKey, newValue, finalSeconds);
-
-		this.emit('addFloat:after', { key: finalKey, num: finalNum, seconds: finalSeconds, result: newValue, success: true });
-		return newValue;
-	} catch (error) {
-		this.emit('addFloat:error', { key, num, seconds, error });
-		this.log('error', '增加浮点数值失败:', error);
-		return null;
-	}
-};
-
-// ==================== Redis 兼容 API - 字符串操作 ====================
-
-/**
- * @description 追加字符串（对齐 mm_redis 的 setrange）
- * @param {String} key 键名
- * @param {String} value 要追加的字符串
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 追加后字符串的长度，失败返回null
- */
-MongoDB.prototype.setrange = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (value === undefined || value === null) {
-			value = '';
-		}
-
-		const ctx = { key, value, seconds, cancel: false };
-		this.emit('setrange:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const { key: finalKey, value: finalValue, seconds: finalSeconds } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-		const currentValue = item ? String(item.value) : '';
-		const newValue = currentValue + String(finalValue);
-
-		await this.set(finalKey, newValue, finalSeconds);
-
-		const length = newValue.length;
-		this.emit('setrange:after', { key: finalKey, value: finalValue, seconds: finalSeconds, result: length, success: true });
-		return length;
-	} catch (error) {
-		this.emit('setrange:error', { key, value, seconds, error });
-		this.log('error', 'setrange操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 向字符串末尾追加内容
- * @param {String} key 键名
- * @param {String} value 要追加的内容
- * @return {Promise<Number>} 追加后的字符串长度，失败返回null
- */
-MongoDB.prototype.append = async function (key, value) {
-	try {
-		if (!key || typeof key !== 'string' || typeof value !== 'string') {
-			return null;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-		const current = item && typeof item.value === 'string' ? item.value : '';
-
-		const newValue = current + value;
-		await this.set(key, newValue);
-
-		return newValue.length;
-	} catch (error) {
-		this.log('error', `Failed to append for key ${key}:`, error);
-		return null;
-	}
-};
-
-/**
- * @description 获取字符串长度
- * @param {String} key 键名
- * @return {Promise<Number>} 字符串长度，不存在返回0
- */
-MongoDB.prototype.strlen = async function (key) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || typeof item.value !== 'string') {
-			return 0;
-		}
-
-		return item.value.length;
-	} catch (error) {
-		this.log('error', `Failed to strlen for key ${key}:`, error);
-		return 0;
-	}
-};
-
-// ==================== Redis 兼容 API - 列表操作 ====================
-
-/**
- * @description 设置列表
- * @param {String} key 键名
- * @param {Array} value 列表值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 列表长度
- */
-MongoDB.prototype.setForList = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		if (!Array.isArray(value)) {
-			throw new TypeError('value必须是数组类型');
-		}
-
-		const ctx = { key, value, seconds, cancel: false };
-		this.emit('setForList:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const { key: finalKey, value: finalValue, seconds: finalSeconds } = ctx;
-
-		await this._ensureConnected();
-		await this.set(finalKey, finalValue, finalSeconds);
-
-		const length = finalValue.length;
-		this.emit('setForList:after', { key: finalKey, value: finalValue, seconds: finalSeconds, result: length, success: true });
-		return length;
-	} catch (error) {
-		this.emit('setForList:error', { key, value, seconds, error });
-		this.log('error', `[setForList] 操作失败: ${error.message}`);
-		return 0;
-	}
-};
-
-/**
- * @description 向列表中添加元素
- * @param {String} key 键名
- * @param {*} value 要添加的元素
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 添加后列表的长度
- */
-MongoDB.prototype.addForList = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		const ctx = { key, value, seconds, cancel: false };
-		this.emit('addForList:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const { key: finalKey, value: finalValue, seconds: finalSeconds } = ctx;
-
-		await this._ensureConnected();
-		let currentArray = await this.get(finalKey);
-		if (!Array.isArray(currentArray)) {
-			currentArray = [];
-		}
-
-		currentArray.push(finalValue);
-		await this.set(finalKey, currentArray, finalSeconds);
-
-		const length = currentArray.length;
-		this.emit('addForList:after', { key: finalKey, value: finalValue, seconds: finalSeconds, result: length, success: true });
-		return length;
-	} catch (error) {
-		this.emit('addForList:error', { key, value, seconds, error });
-		this.log('error', `addForList操作失败: ${error.message}`);
-		return 0;
-	}
-};
-
-/**
- * @description 检查列表中是否存在指定元素
- * @param {String} key 键名
- * @param {*} value 要检查的元素值
- * @return {Promise<Boolean>} 存在返回true，不存在返回false
- */
-MongoDB.prototype.hasForList = async function (key, value) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return false;
-		}
-
-		const ctx = { key, value, cancel: false };
-		this.emit('hasForList:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey, value: finalValue } = ctx;
-
-		await this._ensureConnected();
-		const array = await this.get(finalKey);
-
-		if (!Array.isArray(array)) {
-			this.emit('hasForList:after', { key: finalKey, value: finalValue, result: false });
-			return false;
-		}
-
-		const valueStr = JSON.stringify(finalValue);
-		const result = array.some(item => JSON.stringify(item) === valueStr);
-
-		this.emit('hasForList:after', { key: finalKey, value: finalValue, result });
-		return result;
-	} catch (error) {
-		this.emit('hasForList:error', { key, value, error });
-		this.log('error', `hasForList操作失败: ${error.message}`);
-		return false;
-	}
-};
-
-/**
- * @description 获取列表指定范围的元素
- * @param {String} key 键名
- * @param {Number} [start=0] 起始索引
- * @param {Number} [end=-1] 结束索引
- * @return {Promise<Array>} 元素数组
- */
-MongoDB.prototype.getForList = async function (key, start = 0, end = -1) {
-	try {
-		this.emit('getForList:before', { key, start, end });
-
-		if (!key || typeof key !== 'string') {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const array = await this.get(key);
-		const list = Array.isArray(array) ? array : [];
-
-		// 处理Redis风格的索引范围，符合 LRANGE 语义
-		const startIndex = start < 0 ? Math.max(0, list.length + start) : start;
-		const endIndex = end < 0 ? Math.max(0, list.length + end + 1) : end + 1;
-
-		const result = list.slice(startIndex, endIndex);
-		this.emit('getForList:after', { key, start, end, result });
-		return result;
-	} catch (error) {
-		this.log('error', `getForList操作失败: ${error.message}`);
-		return [];
-	}
-};
-
-/**
- * @description 清空列表
- * @param {String} key 键名
- * @return {Promise<Boolean>} 是否成功
- */
-MongoDB.prototype.clearForList = async function (key) {
-	try {
-		const ctx = { key, cancel: false };
-		this.emit('clearForList:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey } = ctx;
-
-		if (!finalKey || typeof finalKey !== 'string') {
-			return false;
-		}
-
-		await this._ensureConnected();
-		const result = await this.set(finalKey, []);
-
-		this.emit('clearForList:after', { key: finalKey, result });
-		return result;
-	} catch (error) {
-		this.emit('clearForList:error', { key, error });
-		this.log('error', `clearForList操作失败: ${error.message}`);
-		return false;
-	}
-};
-
-// ==================== Redis 兼容 API - 集合操作 ====================
-
-/**
- * @description 将成员添加到集合
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @return {Promise<Number>} 添加的成员数量
- */
-MongoDB.prototype.sadd = async function (key, members) {
-	try {
-		const ctx = {
-			key,
-			members: Array.isArray(members) ? members : [members],
-			cancel: false
-		};
-		this.emit('sadd:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const { key: finalKey, members: finalMembers } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-		let set = item && Array.isArray(item.value) ? [...new Set(item.value)] : [];
-		let addedCount = 0;
-
-		finalMembers.forEach(member => {
-			const memberStr = String(member);
-			if (!set.includes(memberStr)) {
-				set.push(memberStr);
-				addedCount++;
-			}
-		});
-
-		if (addedCount > 0) {
-			await this.set(finalKey, set);
-		}
-
-		this.emit('sadd:after', { key: finalKey, members: finalMembers, result: addedCount });
-		return addedCount;
-	} catch (error) {
-		this.emit('sadd:error', { key, members, error });
-		this.log('error', `添加集合成员失败 [${key}]:`, error);
-		return 0;
-	}
-};
-
-/**
- * @description 从集合中移除成员
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @return {Promise<Number>} 移除的成员数量
- */
-MongoDB.prototype.srem = async function (key, members) {
-	try {
-		const ctx = {
-			key,
-			members: Array.isArray(members) ? members : [members],
-			cancel: false
-		};
-		this.emit('srem:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const { key: finalKey, members: finalMembers } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-
-		if (!item || !Array.isArray(item.value)) {
-			return 0;
-		}
-
-		let set = [...new Set(item.value)];
-		const originalLength = set.length;
-		const membersToRemove = new Set(finalMembers.map(m => String(m)));
-
-		set = set.filter(member => !membersToRemove.has(member));
-
-		const removedCount = originalLength - set.length;
-		if (removedCount > 0) {
-			await this.set(finalKey, set);
-		}
-
-		this.emit('srem:after', { key: finalKey, members: finalMembers, result: removedCount });
-		return removedCount;
-	} catch (error) {
-		this.emit('srem:error', { key, members, error });
-		this.log('error', `移除集合成员失败 [${key}]:`, error);
-		return 0;
-	}
-};
-
-/**
- * @description 检查成员是否在集合中
- * @param {String} key 键
- * @param {String} member 成员
- * @return {Promise<Boolean>} 是否存在
- */
-MongoDB.prototype.sismember = async function (key, member) {
-	try {
-		this.emit('sismember:before', { key, member });
-
-		if (typeof key !== 'string' || !key) {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (member === undefined || member === null) {
-			throw new TypeError('member不能为undefined或null');
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		const memberStr = String(member);
-		let result = false;
-		if (item && Array.isArray(item.value)) {
-			result = item.value.includes(memberStr);
-		}
-
-		this.emit('sismember:after', { key, member, result });
-		return result;
-	} catch (error) {
-		this.emit('sismember:error', { key, member, error });
-		this.log('error', '检查集合成员失败:', error);
-		return false;
-	}
-};
-
-/**
- * @description 获取集合中的所有成员
- * @param {String} key 键
- * @return {Promise<Array>} 成员数组
- */
-MongoDB.prototype.smembers = async function (key) {
-	try {
-		this.emit('smembers:before', { key });
-
-		if (typeof key !== 'string' || !key) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || !Array.isArray(item.value)) {
-			return [];
-		}
-
-		// 去重并返回
-		const result = [...new Set(item.value)];
-		this.emit('smembers:after', { key, result });
-		return result;
-	} catch (error) {
-		this.log('error', '获取集合所有成员失败:', error);
-		return [];
-	}
-};
-
-/**
- * @description 获取集合中的成员数量
- * @param {String} key 键
- * @return {Promise<Number>} 成员数量
- */
-MongoDB.prototype.scard = async function (key) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			return 0;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || !Array.isArray(item.value)) {
-			return 0;
-		}
-
-		return new Set(item.value).size;
-	} catch (error) {
-		this.log('error', '获取集合成员数量失败:', error);
-		return 0;
-	}
-};
-
-/**
- * @description 获取多个集合的交集
- * @param {...String} keys 键名列表
- * @return {Promise<Array>} 交集成员数组
- */
-MongoDB.prototype.sinter = async function (...keys) {
-	try {
-		if (keys.length === 0) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const items = await Promise.all(keys.map(key => this.db.collection(this.table).findOne({ key })));
-
-		const sets = items.map(item =>
-			item && Array.isArray(item.value) ? new Set(item.value.map(m => String(m))) : new Set()
-		);
-
-		// 如果有任一集合为空，交集为空
-		if (sets.some(set => set.size === 0)) {
-			return [];
-		}
-
-		const result = Array.from(sets[0]).filter(member =>
-			sets.every(set => set.has(member))
-		);
-		return result;
-	} catch (error) {
-		this.log('error', '获取集合交集失败:', error);
-		return [];
-	}
-};
-
-/**
- * @description 获取多个集合的并集
- * @param {...String} keys 键名列表
- * @return {Promise<Array>} 并集成员数组
- */
-MongoDB.prototype.sunion = async function (...keys) {
-	try {
-		if (keys.length === 0) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const items = await Promise.all(keys.map(key => this.db.collection(this.table).findOne({ key })));
-
-		const resultSet = new Set();
-		items.forEach(item => {
-			if (item && Array.isArray(item.value)) {
-				item.value.forEach(member => resultSet.add(String(member)));
-			}
-		});
-
-		return Array.from(resultSet);
-	} catch (error) {
-		this.log('error', '获取集合并集失败:', error);
-		return [];
-	}
-};
-
-/**
- * @description 获取多个集合的差集（第一个集合减去其余集合）
- * @param {...String} keys 键名列表
- * @return {Promise<Array>} 差集成员数组
- */
-MongoDB.prototype.sdiff = async function (...keys) {
-	try {
-		if (keys.length === 0) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const items = await Promise.all(keys.map(key => this.db.collection(this.table).findOne({ key })));
-
-		const firstItem = items[0];
-		if (!firstItem || !Array.isArray(firstItem.value)) {
-			return [];
-		}
-
-		const firstSet = new Set(firstItem.value.map(m => String(m)));
-		const otherSets = items.slice(1).map(item =>
-			item && Array.isArray(item.value) ? new Set(item.value.map(m => String(m))) : new Set()
-		);
-
-		const result = Array.from(firstSet).filter(member =>
-			!otherSets.some(set => set.has(member))
-		);
-		return result;
-	} catch (error) {
-		this.log('error', '获取集合差集失败:', error);
-		return [];
-	}
-};
-
-// ==================== Redis 兼容 API - 有序集合操作 ====================
-
-/**
- * @description 添加成员到有序集合
- * @param {String} key 键
- * @param {Number} score 分数
- * @param {String} member 成员
- * @return {Promise<Boolean>} 是否成功（新成员返回true，更新返回false）
- */
-MongoDB.prototype.zadd = async function (key, score, member) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-		if (typeof score !== 'number' || isNaN(score)) {
-			throw new TypeError('score必须是有效的数字');
-		}
-
-		const ctx = { key, score, member, cancel: false };
-		this.emit('zadd:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const { key: finalKey, score: finalScore, member: finalMember } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-		let sortedSet = item && Array.isArray(item.value) ? item.value : [];
-
-		const memberStr = JSON.stringify(finalMember);
-		const existingIndex = sortedSet.findIndex(entry => JSON.stringify(entry.member) === memberStr);
-
-		let isNew = false;
-		if (existingIndex >= 0) {
-			sortedSet[existingIndex].score = finalScore;
-		} else {
-			sortedSet.push({ score: finalScore, member: finalMember });
-			isNew = true;
-		}
-
-		sortedSet.sort((a, b) => a.score - b.score);
-		await this.set(finalKey, sortedSet);
-
-		this.emit('zadd:after', { key: finalKey, score: finalScore, member: finalMember, success: isNew });
-		return isNew;
-	} catch (error) {
-		this.emit('zadd:error', { key, score, member, error });
-		this.log('error', '添加有序集合成员失败:', error);
-		return false;
-	}
-};
-
-/**
- * @description 从有序集合中移除成员
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @return {Promise<Number>} 移除的成员数量
- */
-MongoDB.prototype.zrem = async function (key, members) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			throw new TypeError('key必须是有效的字符串');
-		}
-
-		const ctx = {
-			key,
-			members: Array.isArray(members) ? members : [members],
-			cancel: false
-		};
-		this.emit('zrem:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const { key: finalKey, members: finalMembers } = ctx;
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key: finalKey });
-
-		if (!item || !Array.isArray(item.value)) {
-			return 0;
-		}
-
-		const membersToRemove = new Set(finalMembers.map(m => JSON.stringify(m)));
-		const filtered = item.value.filter(entry => !membersToRemove.has(JSON.stringify(entry.member)));
-		const removedCount = item.value.length - filtered.length;
-
-		if (removedCount > 0) {
-			await this.set(finalKey, filtered);
-		}
-
-		this.emit('zrem:after', { key: finalKey, members: finalMembers, result: removedCount });
-		return removedCount;
-	} catch (error) {
-		this.emit('zrem:error', { key, members, error });
-		this.log('error', '有序集合删除成员失败:', error);
-		return 0;
-	}
-};
-
-/**
- * @description 获取有序集合中成员的分数
- * @param {String} key 键
- * @param {String} member 成员
- * @return {Promise<Number|null>} 分数，不存在返回null
- */
-MongoDB.prototype.zscore = async function (key, member) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			return null;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || !Array.isArray(item.value)) {
-			return null;
-		}
-
-		const memberStr = JSON.stringify(member);
-		const found = item.value.find(entry => JSON.stringify(entry.member) === memberStr);
-		return found ? found.score : null;
-	} catch (error) {
-		this.log('error', '获取成员分数失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 获取有序集合中成员的排名（分数从小到大）
- * @param {String} key 键
- * @param {String} member 成员
- * @return {Promise<Number|null>} 排名，不存在返回null
- */
-MongoDB.prototype.zrank = async function (key, member) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			return null;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || !Array.isArray(item.value)) {
-			return null;
-		}
-
-		// 按分数从小到大排序
-		const sorted = [...item.value].sort((a, b) => a.score - b.score);
-		const memberStr = JSON.stringify(member);
-		const rank = sorted.findIndex(entry => JSON.stringify(entry.member) === memberStr);
-		return rank >= 0 ? rank : null;
-	} catch (error) {
-		this.log('error', '获取有序集合成员排名失败:', error);
-		return null;
-	}
-};
-
-/**
- * @description 获取有序集合中指定范围的成员
- * @param {String} key 键
- * @param {Number} start 起始索引
- * @param {Number} stop 结束索引
- * @param {Boolean} [withScores=false] 是否返回分数
- * @return {Promise<Array>} 成员数组
- */
-MongoDB.prototype.zrange = async function (key, start, stop, withScores = false) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			return [];
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || !Array.isArray(item.value)) {
-			return [];
-		}
-
-		// 按分数从小到大排序
-		const sorted = [...item.value].sort((a, b) => a.score - b.score);
-		const len = sorted.length;
-
-		// 处理负索引
-		const startIndex = start < 0 ? Math.max(0, len + start) : start;
-		const endIndex = stop < 0 ? Math.max(0, len + stop + 1) : stop + 1;
-
-		if (startIndex >= len) {
-			return [];
-		}
-
-		const slice = sorted.slice(startIndex, endIndex);
-		if (withScores) {
-			return slice.map(entry => ({ member: entry.member, score: entry.score }));
-		}
-		return slice.map(entry => entry.member);
-	} catch (error) {
-		this.log('error', '获取有序集合范围成员失败:', error);
-		return [];
-	}
-};
-
-/**
- * @description 获取有序集合中的成员数量
- * @param {String} key 键
- * @return {Promise<Number>} 成员数量
- */
-MongoDB.prototype.zcard = async function (key) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			return 0;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		if (!item || !Array.isArray(item.value)) {
-			return 0;
-		}
-
-		return item.value.length;
-	} catch (error) {
-		this.log('error', '有序集合成员数量失败:', error);
-		return 0;
-	}
-};
-
-/**
- * @description 增加有序集合成员的分数
- * @param {String} key 键
- * @param {Number} increment 增量
- * @param {String} member 成员
- * @return {Promise<Number>} 增加后的分数
- */
-MongoDB.prototype.zincrby = async function (key, increment, member) {
-	try {
-		if (typeof key !== 'string' || !key) {
-			return null;
-		}
-
-		await this._ensureConnected();
-		const item = await this.db.collection(this.table).findOne({ key });
-
-		let sortedSet = item && Array.isArray(item.value) ? item.value : [];
-		const memberStr = JSON.stringify(member);
-		const existingIndex = sortedSet.findIndex(entry => JSON.stringify(entry.member) === memberStr);
-
-		const currentScore = existingIndex >= 0 ? sortedSet[existingIndex].score : 0;
-		const newScore = currentScore + Number(increment);
-
-		if (existingIndex >= 0) {
-			sortedSet[existingIndex].score = newScore;
-		} else {
-			sortedSet.push({ score: newScore, member });
-		}
-
-		sortedSet.sort((a, b) => a.score - b.score);
-		await this.set(key, sortedSet);
-
-		return newScore;
-	} catch (error) {
-		this.log('error', '增加有序集合成员分数失败:', error);
-		return null;
-	}
-};
-
-// ==================== Redis 兼容 API - 键管理 ====================
-
-/**
- * @description 获取所有键名
- * @param {String} [pattern='*'] 键名匹配模式，支持*通配符
- * @return {Promise<Array>} 所有键名数组
- */
-MongoDB.prototype.keys = async function (pattern = '*') {
-	try {
-		this.emit('keys:before', { pattern });
-
-		if (typeof pattern !== 'string') {
-			throw new TypeError('pattern必须是有效的字符串');
-		}
-
-		await this._ensureConnected();
-		let query = {};
-		if (pattern !== '*') {
-			const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.');
-			query.key = { $regex: new RegExp(`^${regexPattern}$`) };
-		}
-
-		const results = await this.db.collection(this.table).find(query, {
-			projection: { key: 1 }
-		}).toArray();
-
-		const result = results.map(item => item.key);
-		this.emit('keys:after', { pattern, result });
-		return result;
-	} catch (error) {
-		this.log('error', '获取键列表失败:', error);
-		return [];
-	}
-};
-
-/**
- * @description 获取键的数量
- * @return {Promise<Number>} 键的数量
- */
-MongoDB.prototype.dbsize = async function () {
-	try {
-		await this._ensureConnected();
-		return await this.db.collection(this.table).countDocuments({});
-	} catch (error) {
-		this.log('error', '获取键数量失败:', error);
-		return 0;
-	}
-};
-
-/**
- * @description 清空所有数据库键
- * @return {Promise<Boolean>} 操作结果
- */
-MongoDB.prototype.flushdb = async function () {
-	try {
-		const ctx = { cancel: false };
-		this.emit('clear:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		await this._ensureConnected();
-		await this.db.collection(this.table).deleteMany({});
-
-		this.emit('clear:after', { success: true });
-		return true;
-	} catch (error) {
-		this.log('error', 'Failed to flushdb:', error);
-		return false;
-	}
-};
-
-/**
- * @description 清空所有数据或匹配模式的缓存（flushdb 扩展）
- * @param {String} [pattern] 可选的键匹配模式
- * @return {Promise<Boolean>} 是否成功
- */
-MongoDB.prototype.clear = async function (pattern) {
-	try {
-		const ctx = { pattern, cancel: false };
-		this.emit('clear:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		await this._ensureConnected();
-
-		if (pattern) {
-			const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
-			await this.db.collection(this.table).deleteMany({
-				key: { $regex: new RegExp(`^${regexPattern}$`) }
-			});
-		} else {
-			await this.db.collection(this.table).deleteMany({});
-		}
-
-		this.emit('clear:after', { pattern, success: true });
-		return true;
-	} catch (error) {
-		this.emit('clear:error', { pattern, error });
-		this.log('error', '清空缓存失败:', error);
-		return false;
-	}
-};
-
-/**
- * @description 清空所有过期的数据
- * @return {Promise<Boolean>} 是否成功
- */
-MongoDB.prototype.clearExpire = async function () {
-	try {
-		this.emit('clearExpire:before', {});
-		await this._ensureConnected();
-		await this.db.collection(this.table).deleteMany({
-			expire_at: { $exists: true, $lt: new Date() }
-		});
-		this.emit('clearExpire:after', { result: true });
-		return true;
-	} catch (error) {
-		this.emit('clearExpire:error', { error });
-		this.log('error', '清空过期数据失败:', error);
-		return false;
-	}
-};
-
-// ==================== Redis 兼容 API - 发布订阅 ====================
-
-/**
- * @description 消息订阅
- * @param {String} channel 订阅的频道
- * @param {Function} func 操作回调函数
- * @return {Promise<Boolean>} 订阅结果
- */
-MongoDB.prototype.subscribe = async function (channel, func) {
-	if (!channel || typeof channel !== 'string') {
-		throw new TypeError('channel必须是非空字符串');
-	}
-	if (typeof func !== 'function') {
-		throw new TypeError('func必须是函数');
-	}
-
-	try {
-		this._channels[channel] = func;
-		return true;
-	} catch (err) {
-		this.log('error', `订阅频道 ${channel} 失败:`, err);
-		return false;
-	}
-};
-
-/**
- * @description 取消订阅
- * @param {String} channel 订阅的频道
- * @return {Promise<Boolean>} 取消订阅结果
- */
-MongoDB.prototype.unsubscribe = async function (channel) {
-	if (!channel || typeof channel !== 'string') {
-		throw new TypeError('channel必须是非空字符串');
-	}
-
-	try {
-		delete this._channels[channel];
-		return true;
-	} catch (err) {
-		this.log('error', `取消订阅频道 ${channel} 失败:`, err);
-		return false;
-	}
-};
-
-/**
- * @description 发布消息
- * @param {String} channel 频道
- * @param {String} message 消息
- * @return {Promise<Number>} 接收消息的订阅者数量
- */
-MongoDB.prototype.publish = async function (channel, message) {
-	if (!channel || typeof channel !== 'string') {
-		throw new TypeError('channel必须是非空字符串');
-	}
-	if (message === undefined || message === null) {
-		throw new TypeError('message不能为undefined或null');
-	}
-
-	try {
-		const func = this._channels[channel];
-		if (func) {
-			try {
-				func(message);
-			} catch (err) {
-				this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
-			}
-			return 1;
-		}
-		return 0;
-	} catch (err) {
-		this.log('error', `发布消息到频道 ${channel} 失败:`, err);
-		return 0;
-	}
-};
-
-/**
- * @description 订阅消息处理, 如果没有订阅函数，则其他的订阅消息会进入该函数
- * @param {String} channel 频道
- * @param {String} message 消息
- */
-MongoDB.prototype.main = async function (channel, message) {
-	this.log('debug', `收到未处理的消息 [${channel}]:`, message);
-};
-
-/**
- * @description 消息通知
- * @param {String} channel 频道
- * @param {String} message 消息
- */
-MongoDB.prototype.message = function (channel, message) {
-	var func = this._channels[channel];
-	if (func) {
-		try {
-			func(message);
-		} catch (err) {
-			this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
-		}
-	} else {
-		this.main(channel, message);
-	}
-};
-
-// ==================== 连接池管理 ====================
-
-/**
- * 确保连接池对象存在
- */
-if (!$.pool) {
-	$.pool = {};
-}
-if (!$.pool.mongoDB) {
-	$.pool.mongoDB = {};
-}
-
-/**
- * @description MongoDB管理器，用于创建缓存
- * @param {String} scope 作用域
- * @param {Object} config 配置参数
- * @return {Object} 返回一个MongoDB类实例
- */
-function mongodbAdmin(scope, config) {
-	if (!scope) {
-		scope = 'sys';
-	}
-	var obj = $.pool.mongoDB[scope];
-	if (!obj) {
-		const dbConfig = {
-			host: 'localhost',
-			port: 27017,
-			database: scope,
-			...(typeof config === 'object' && config ? config : {})
-		};
-		$.pool.mongoDB[scope] = new MongoDB(dbConfig);
-		obj = $.pool.mongoDB[scope];
-	}
-	return obj;
-}
+let admin = new Admin();
+admin.setClass(MongoDB);
 
 module.exports = {
 	MongoDB,
-	mongodbAdmin
-};
+	admin,
+	mongodbAdmin(scope, config) {
+		if (!scope) {
+			scope = 'os';
+		}
+		return admin.get(scope, config);
+	}
+};