mm_mongodb 1.4.7 → 1.4.8

package/README.md

@@ -13,7 +13,7 @@ MongoDB数据库操作模块，提供了简洁易用的API、缓存功能以及*
 - ✅ 环境变量配置支持
 - ✅ 完善的错误处理和重试机制
 - ✅ 查询注入防护
-- ✅ 事件系统：支持监听关键操作的事件
+- ✅ 事件系统：支持监听关键操作的事件，包括操作前、操作后和错误事件
 
 ## 安装
 
@@ -140,6 +140,84 @@ await db.createIndex('users', { name: 1 }, { unique: true });
 await db.createTTLIndex('logs', { createdAt: 1 }, 3600); // 3600秒后过期
 ```
 
+## 事件系统
+
+mm_mongodb提供了完整的事件系统，允许您监听各种数据库操作的前后事件，便于进行日志记录、性能监控、数据校验等操作。
+
+### 支持的事件
+
+| 事件名称 | 触发时机 | 事件参数 |
+|--------|--------|--------|
+| `set_before` | 在执行set操作前 | `{ table, key, value }` |
+| `set_after` | 在执行set操作后 | `{ table, key, value, result }` |
+| `set_error` | 在set操作出错时 | `{ table, key, value, error }` |
+| `del_before` | 在执行del操作前 | `{ table, key }` |
+| `del_after` | 在执行del操作后 | `{ table, key, result }` |
+| `del_error` | 在del操作出错时 | `{ table, key, error }` |
+| `add_before` | 在执行add操作前 | `{ table, key, value }` |
+| `add_after` | 在执行add操作后 | `{ table, key, value, result, exists }` |
+| `add_error` | 在add操作出错时 | `{ table, key, value, error }` |
+
+### 事件参数说明
+
+- `table`: 操作的表名
+- `key`: 操作的键名
+- `value`: 操作的值
+- `result`: 操作的结果
+- `error`: 错误信息（仅在错误事件中）
+- `exists`: 键是否已存在（仅在add_after事件中）
+
+### 使用示例
+
+```javascript
+const { MongoDB } = require('mm_mongodb');
+const db = new MongoDB();
+
+// 连接数据库
+await db.open();
+
+// 监听set操作前事件
+db.on('set_before', (data) => {
+    console.log(`准备设置缓存: ${data.key} = ${JSON.stringify(data.value)}`);
+    // 可以在这里进行数据校验、权限检查等
+});
+
+// 监听set操作后事件
+db.on('set_after', (data) => {
+    console.log(`缓存设置成功: ${data.key}, 结果:`, data.result);
+    // 可以在这里记录日志、触发其他操作等
+});
+
+// 监听add操作后事件，特别注意exists标记
+db.on('add_after', (data) => {
+    if (data.exists) {
+        console.log(`键 ${data.key} 已存在，未添加新值`);
+    } else {
+        console.log(`成功添加新键: ${data.key}`);
+    }
+});
+
+// 监听错误事件
+db.on('set_error', (data) => {
+    console.error(`设置缓存失败: ${data.key}, 错误:`, data.error);
+});
+
+// 执行操作，触发事件
+await db.set('test_key', 'test_value');
+
+// 测试add方法的exists标记
+await db.add('test_key', 'another_value'); // 键已存在，exists将为true
+```
+
+### 应用场景
+
+1. **数据校验和验证**：在操作前事件中验证数据的有效性
+2. **访问控制和权限管理**：检查是否有权限执行特定操作
+3. **性能监控**：记录操作执行时间，监控系统性能
+4. **审计日志**：记录所有关键操作的详细信息
+5. **缓存一致性维护**：在数据变更时更新相关缓存
+6. **业务规则执行**：在特定操作前后执行业务逻辑
+
 ## Redis兼容API使用指南
 
 mm_mongodb提供了**完整的Redis兼容API**，使您可以使用熟悉的Redis命令与MongoDB进行交互。这对于从Redis迁移到MongoDB或在两者间切换使用非常有用。

package/index.js

@@ -21,15 +21,13 @@ class MongoDB extends eventEmitter {
 	/**
 	 * @description 创建MongoDB帮助类函数 (构造函数)
 	 * @param {String} scope 作用域
-	 * @param {String} dir 当前路径
+	 * @param {Object} config 配置参数
 	 * @constructor
 	 */
-	constructor(scope, dir, config) {
+	constructor(scope, config) {
 		super();
 		// 作用域
 		this.scope = scope || ($.val && $.val.scope ? String($.val.scope) : 'default');
-		// 当前目录
-		this.dir = dir || __dirname;
 
 		// 从环境变量加载配置
 		const envConfig = this._loadEnvConfig();
@@ -64,8 +62,9 @@ class MongoDB extends eventEmitter {
 				maxAttempts: 3,
 				delayMS: 1000
 			}
-		}, envConfig, config);
+		}, envConfig);
 
+		this.setConfig(config);
 		// 验证配置
 		this._validateConfig();
 
@@ -1470,10 +1469,13 @@ class MongoDB extends eventEmitter {
 MongoDB.prototype.setConfig = function (cg) {
 	var obj;
 	if (typeof (cg) === "string") {
-		obj = cg.loadJson ? cg.loadJson(this.dir) : null;
+		obj = cg.loadJson();
 	} else if (cg) {
 		obj = cg;
 	}
+	else {
+		return;
+	}
 	if (obj) {
 		$.push(this.config, obj);
 		// 设置新配置后重新验证
@@ -1698,33 +1700,33 @@ MongoDB.prototype.addObj = async function (obj) {
 	 * @param {String} key 键名
 	 * @return {Promise<any|null>} 存储的值，如果不存在则返回null
 	 */
-	MongoDB.prototype.get = async function (key) {
-		await this._ensureConnected();
-		try {
-			const result = await this.db.collection(this.table).findOne({ key: key });
-			return result ? result.value : null;
-		} catch (error) {
-			$.log.error(`[MongoDB] 获取键值失败: ${error.message}`);
-			return null;
-		}
-	};
+MongoDB.prototype.get = async function (key) {
+	await this._ensureConnected();
+	try {
+		const result = await this.db.collection(this.table).findOne({ key: key });
+		return result ? result.value : null;
+	} catch (error) {
+		$.log.error(`[MongoDB] 获取键值失败: ${error.message}`);
+		return null;
+	}
+};
 
-	/**
- * @description Redis兼容API - 删除键
- * @param {String} key 键名
- * @return {Promise<Boolean>} 是否删除成功
- */
+/**
+* @description Redis兼容API - 删除键
+* @param {String} key 键名
+* @return {Promise<Boolean>} 是否删除成功
+*/
 MongoDB.prototype.del = async function (key) {
 	await this._ensureConnected();
 	try {
 		// 触发前置事件
 		this.emit('del_before', { table: this.table, key: key });
-		
+
 		const result = await this.db.collection(this.table).deleteOne({ key: key });
-		
+
 		// 触发后置事件
 		this.emit('del_after', { table: this.table, key: key, result });
-		
+
 		return result.deletedCount > 0;
 	} catch (error) {
 		// 触发错误事件
@@ -1743,23 +1745,25 @@ MongoDB.prototype.del = async function (key) {
 MongoDB.prototype.add = async function (key, value) {
 	await this._ensureConnected();
 	try {
+		// 触发前置事件 - 无论键是否存在都触发
+		this.emit('add_before', { table: this.table, key: key, value: value });
+
 		// 检查键是否已存在
 		const exists = await this.db.collection(this.table).findOne({ key: key });
 		if (exists) {
+			// 键已存在时触发后置事件，但返回false
+			this.emit('add_after', { table: this.table, key: key, value: value, result: null, exists: true });
 			return false;
 		}
-		
+
 		const data = { key: key, value: value };
-		
-		// 触发前置事件
-		this.emit('add_before', { table: this.table, key: key, value: value });
-		
+
 		// 添加键值对
 		const result = await this.db.collection(this.table).insertOne(data);
-		
+
 		// 触发后置事件
-		this.emit('add_after', { table: this.table, key: key, value: value, result });
-		
+		this.emit('add_after', { table: this.table, key: key, value: value, result, exists: false });
+
 		return result.acknowledged;
 	} catch (error) {
 		// 触发错误事件
@@ -1780,17 +1784,17 @@ MongoDB.prototype.set = async function (key, value) {
 	try {
 		// 触发前置事件
 		this.emit('set_before', { table: this.table, key: key, value: value });
-		
+
 		// 更新或插入键值对
 		const result = await this.db.collection(this.table).updateOne(
 			{ key: key },
 			{ $set: { value: value } },
 			{ upsert: true }
 		);
-		
+
 		// 触发后置事件
 		this.emit('set_after', { table: this.table, key: key, value: value, result });
-		
+
 		return result.acknowledged;
 	} catch (error) {
 		// 触发错误事件
@@ -2038,25 +2042,22 @@ if (!$.pool.mongoDB) {
 /**
  * @description MongoDB管理器，用于创建缓存
  * @param {String} scope 作用域
- * @param {String} dir 当前路径
+ * @param {Object} config 配置参数
  * @return {Object} 返回一个MongoDB类实例
  */
-function mongoDB_admin(scope, dir) {
+function mongodb_admin(scope, config) {
 	if (!scope) {
-		scope = ($.val && $.val.scope) || 'default';
+		scope = 'sys';
 	}
 	var obj = $.pool.mongoDB[scope];
 	if (!obj) {
-		$.pool.mongoDB[scope] = new MongoDB(scope, dir);
+		$.pool.mongoDB[scope] = new MongoDB(scope, config);
 		obj = $.pool.mongoDB[scope];
 	}
 	return obj;
 }
 
-
-
-
 /**
  * @module 导出MongoDB管理器
  */
-exports.mongoDB_admin = mongoDB_admin;
+exports.mongodb_admin = mongodb_admin;

package/package.json

@@ -1,14 +1,13 @@
 {
     "name": "mm_mongodb",
-    "version": "1.4.7",
+    "version": "1.4.8",
     "description": "MongoDB数据库操作模块，提供简洁易用的API、缓存功能以及完整的Redis兼容接口，支持事件系统、事务和连接池管理",
     "main": "index.js",
     "scripts": {
         "test": "node test.js",
         "test:events": "node test_events.js",
-        "test:redis": "node test_redis.js",
-        "test:redis-extended": "node test_redis_extended.js",
-        "test:advanced": "node test_advanced.js"
+        "test:redis": "node test_redis_api.js",
+        "test:redis-compatibility": "node test_redis_compatibility.js"
     },
     "repository": {
         "type": "git",

package/test.js

@@ -1,5 +1,5 @@
 const MongoDB = require('./index.js').MongoDB;
-const mongodb_admin = require('./index.js').mongoDB_admin;
+const mongodb_admin = require('./index.js').mongodb_admin;
 
 async function test2() {
 	var mb = mongodb_admin("sys");
@@ -13,7 +13,7 @@ test2();
 async function test() {
 	console.log("测试开始");
 	// 实例化构造函数，使用正确的参数
-	var mb = new MongoDB("default", __dirname);
+	var mb = new MongoDB("default");
 	mb.setConfig();
 
 	await mb.open();

package/test2.js

@@ -1,18 +1,11 @@
 const { MongoDB, mongoDB_admin } = require('./index.js');
 
-async function test2() {
-	var mb = mongoDB_admin("sys");
-	mb.setConfig();
-	// mb.open();
-	console.log(mb);
-}
-// test2();
 
 /* 调用示例 */
 async function test() {
 	console.log("测试开始");
 	// 实例化构造函数，传入服务器地址和数据库名
-	var mb = new MongoDB("localhost", "mm");
+	var mb = new MongoDB("localhost");
 	mb.setConfig();
 
 	await mb.open();

package/test_events.js

@@ -0,0 +1,139 @@
+// 事件测试文件
+const { MongoDB, mongodb_admin } = require('./index');
+
+// 事件统计对象
+const eventStats = {
+  set_before: 0,
+  set_after: 0,
+  set_error: 0,
+  del_before: 0,
+  del_after: 0,
+  del_error: 0,
+  add_before: 0,
+  add_after: 0,
+  add_error: 0
+};
+
+// 重置事件统计
+function resetEventStats() {
+  Object.keys(eventStats).forEach(key => {
+    eventStats[key] = 0;
+  });
+}
+
+// 注册所有事件监听器
+function registerEventListeners(cache) {
+  // 注册set相关事件
+  cache.on('set_before', (data) => {
+    eventStats.set_before++;
+    console.log('触发 set_before 事件:', data);
+  });
+  
+  cache.on('set_after', (data) => {
+    eventStats.set_after++;
+    console.log('触发 set_after 事件:', data);
+  });
+  
+  cache.on('set_error', (data) => {
+    eventStats.set_error++;
+    console.log('触发 set_error 事件:', data);
+  });
+  
+  // 注册del相关事件
+  cache.on('del_before', (data) => {
+    eventStats.del_before++;
+    console.log('触发 del_before 事件:', data);
+  });
+  
+  cache.on('del_after', (data) => {
+    eventStats.del_after++;
+    console.log('触发 del_after 事件:', data);
+  });
+  
+  cache.on('del_error', (data) => {
+    eventStats.del_error++;
+    console.log('触发 del_error 事件:', data);
+  });
+  
+  // 注册add相关事件
+  cache.on('add_before', (data) => {
+    eventStats.add_before++;
+    console.log('触发 add_before 事件:', data);
+  });
+  
+  cache.on('add_after', (data) => {
+    eventStats.add_after++;
+    console.log('触发 add_after 事件:', data);
+  });
+  
+  cache.on('add_error', (data) => {
+    eventStats.add_error++;
+    console.log('触发 add_error 事件:', data);
+  });
+}
+
+// 运行事件测试
+async function runEventTests() {
+  try {
+    // 获取Redis兼容缓存实例
+    const cache = mongodb_admin('cache');
+    
+    // 注册事件监听器
+    registerEventListeners(cache);
+    
+    console.log('\n--- 测试set方法事件 ---');
+    await cache.set('event_test_key', 'test_value');
+    
+    console.log('\n--- 测试add方法事件 ---');
+    await cache.add('event_test_key2', 'add_value');
+    
+    console.log('\n--- 测试del方法事件 ---');
+    await cache.del('event_test_key');
+    
+    console.log('\n--- 测试add到已存在键的事件 ---');
+    await cache.add('event_test_key2', 'should_not_replace');
+    await cache.del('event_test_key2');
+    
+    // 显示事件统计
+    console.log('\n=== 事件触发统计 ===');
+    console.log(eventStats);
+    
+    // 计算事件触发率
+    const setEventsTriggered = eventStats.set_before === 1 && eventStats.set_after === 1;
+    const delEventsTriggered = eventStats.del_before === 2 && eventStats.del_after === 2;
+    const addEventsTriggered = eventStats.add_before === 2 && eventStats.add_after === 2;
+    
+    console.log('\n=== 事件测试结果 ===');
+    if (setEventsTriggered && delEventsTriggered && addEventsTriggered) {
+      console.log('✅ 所有事件测试通过！');
+    } else {
+      console.log('❌ 部分事件测试失败');
+      if (!setEventsTriggered) console.log('  - set事件');
+      if (!delEventsTriggered) console.log('  - del事件');
+      if (!addEventsTriggered) console.log('  - add事件');
+    }
+    
+    // 显示事件触发率
+    console.log('\n事件触发率统计:');
+    console.log(`set方法事件触发率: ${setEventsTriggered ? '100%' : '失败'}`);
+    console.log(`del方法事件触发率: ${delEventsTriggered ? '100%' : '失败'}`);
+    console.log(`add方法事件触发率: ${addEventsTriggered ? '100%' : '失败'}`);
+    
+    // 清理连接
+    await cache.close();
+    
+    if (setEventsTriggered && delEventsTriggered && addEventsTriggered) {
+      console.log('\n🎉 所有事件测试全部通过！');
+      process.exit(0);
+    } else {
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    console.error('测试过程中出错:', error);
+    process.exit(1);
+  }
+}
+
+// 运行测试
+runEventTests();

package/test_redis_api.js

@@ -1,66 +1,135 @@
-const MongoDB = require('./index').MongoDB;
-
-async function testRedisAPI() {
-  console.log('开始测试Redis兼容API...');
-  
-  // 初始化数据库连接
-  const db = new MongoDB({
-    url: 'mongodb://localhost:27017',
-    dbName: 'test_db',
-    table: 'test_redis_cache'
-  });
-  
-  try {
-    // 测试set方法
-    console.log('\n测试set方法:');
-    const setResult = await db.set('test_key1', 'Hello Redis!');
-    console.log('set结果:', setResult);
-    
-    // 测试get方法
-    console.log('\n测试get方法:');
-    const getResult = await db.get('test_key1');
-    console.log('get结果:', getResult);
-    
-    // 测试不存在的键
-    console.log('\n测试不存在的键:');
-    const notExistResult = await db.get('non_existent_key');
-    console.log('不存在键的get结果:', notExistResult);
-    
-    // 测试add方法 - 添加新键
-    console.log('\n测试add方法(新键):');
-    const addResult1 = await db.add('test_key2', { name: 'MongoDB', type: 'database' });
-    console.log('add结果(新键):', addResult1);
-    
-    // 测试add方法 - 添加已存在的键
-    console.log('\n测试add方法(已存在键):');
-    const addResult2 = await db.add('test_key1', 'This should not override');
-    console.log('add结果(已存在键):', addResult2);
-    
-    // 验证test_key1的值没有被覆盖
-    console.log('\n验证test_key1未被覆盖:');
-    const verifyResult = await db.get('test_key1');
-    console.log('test_key1当前值:', verifyResult);
-    
-    // 测试set方法更新已有键
-    console.log('\n测试set方法更新键:');
-    const updateResult = await db.set('test_key1', 'Updated value!');
-    console.log('set更新结果:', updateResult);
-    
-    // 验证更新后的值
-    console.log('\n验证更新后的值:');
-    const updatedValue = await db.get('test_key1');
-    console.log('test_key1更新后的值:', updatedValue);
-    
-    console.log('\n所有测试完成!');
-  } catch (error) {
-    console.error('测试过程中出现错误:', error);
-  } finally {
-    // 清理测试数据
-    await db.delete({ key: { $in: ['test_key1', 'test_key2'] } });
-    await db.close();
-    console.log('\n数据库连接已关闭，测试数据已清理');
-  }
-}
-
-// 运行测试
-testRedisAPI();
+// Redis API测试文件
+const { MongoDB, mongodb_admin } = require('./index');
+
+async function runRedisApiTests() {
+  console.log('开始测试Redis兼容API...\n');
+  
+  let cache = null;
+  const testKeys = [];
+  
+  try {
+    // 获取缓存实例
+    cache = mongodb_admin('cache');
+    
+    // 测试set方法
+    console.log('测试set方法:');
+    const setResult = await cache.set('test_key1', 'Hello Redis!');
+    console.log('set结果:', setResult);
+    testKeys.push('test_key1');
+    
+    // 测试get方法
+    console.log('\n测试get方法:');
+    const getResult = await cache.get('test_key1');
+    console.log('get结果:', getResult);
+    
+    // 测试不存在的键
+    console.log('\n测试不存在的键:');
+    const notExistsResult = await cache.get('non_existent_key');
+    console.log('不存在键的get结果:', notExistsResult);
+    
+    // 测试add方法(新键)
+    console.log('\n测试add方法(新键):');
+    const addNewResult = await cache.add('test_key2', 'Add new value');
+    console.log('add结果(新键):', addNewResult);
+    testKeys.push('test_key2');
+    
+    // 测试add方法(已存在键)
+    console.log('\n测试add方法(已存在键):');
+    const addExistingResult = await cache.add('test_key1', 'Should not replace');
+    console.log('add结果(已存在键):', addExistingResult);
+    
+    // 验证test_key1未被覆盖
+    console.log('\n验证test_key1未被覆盖:');
+    const checkResult = await cache.get('test_key1');
+    console.log('test_key1当前值:', checkResult);
+    
+    // 测试set方法更新键
+    console.log('\n测试set方法更新键:');
+    const updateResult = await cache.set('test_key1', 'Updated value!');
+    console.log('set更新结果:', updateResult);
+    
+    // 验证更新后的值
+    console.log('\n验证更新后的值:');
+    const updatedValue = await cache.get('test_key1');
+    console.log('test_key1更新后的值:', updatedValue);
+    
+    // 测试exists方法
+    console.log('\n测试exists方法:');
+    const existsResult = await cache.exists('test_key1');
+    console.log('exists结果:', existsResult);
+    
+    const notExistsCheck = await cache.exists('non_existent_key');
+    console.log('不存在键的exists结果:', notExistsCheck);
+    
+    // 测试del方法
+    console.log('\n测试del方法:');
+    const delResult = await cache.del('test_key1');
+    console.log('del结果:', delResult);
+    
+    // 验证删除
+    const afterDel = await cache.get('test_key1');
+    console.log('删除后get结果:', afterDel);
+    
+    // 测试批量操作
+    console.log('\n测试批量操作:');
+    const batchData = {
+      'batch_key1': 'batch_value1',
+      'batch_key2': 'batch_value2'
+    };
+    const msetResult = await cache.mset(batchData);
+    console.log('mset结果:', msetResult);
+    testKeys.push('batch_key1', 'batch_key2');
+    
+    const mgetResult = await cache.mget(['batch_key1', 'batch_key2', 'non_existent']);
+    console.log('mget结果:', mgetResult);
+    
+    // 测试哈希表操作
+    console.log('\n测试哈希表操作:');
+    await cache.hset('hash_key', 'field1', 'hash_value1');
+    testKeys.push('hash_key');
+    
+    const hgetResult = await cache.hget('hash_key', 'field1');
+    console.log('hget结果:', hgetResult);
+    
+    const hgetallResult = await cache.hgetall('hash_key');
+    console.log('hgetall结果:', hgetallResult);
+    
+    console.log('\n所有测试完成!');
+    
+    // 清理测试数据
+    if (testKeys.length > 0) {
+      for (const key of testKeys) {
+        await cache.del(key);
+      }
+    }
+    
+    // 关闭连接
+    await cache.close();
+    console.log('\n数据库连接已关闭，测试数据已清理');
+    process.exit(0);
+    
+  } catch (error) {
+    console.error('测试过程中出错:', error);
+    
+    // 清理测试数据
+    if (cache && testKeys.length > 0) {
+      try {
+        for (const key of testKeys) {
+          await cache.del(key);
+        }
+      } catch (e) {
+        console.error('清理数据时出错:', e);
+      }
+    }
+    
+    // 关闭连接
+    if (cache) {
+      await cache.close();
+    }
+    
+    process.exit(1);
+  }
+}
+
+// 运行测试
+runRedisApiTests();

package/test_redis_compatibility.js

@@ -1,123 +1,155 @@
-const { MongoDB } = require('./index.js');
-
-async function testRedisCompatibility() {
-    console.log('开始测试Redis兼容API...');
-    
-    const mb = new MongoDB('default', __dirname);
-    
-    try {
-        // 先建立数据库连接
-        console.log('正在连接数据库...');
-        await mb.open();
-        console.log('数据库连接成功！');
-        
-        // 测试核心缓存方法
-        console.log('\n=== 测试核心缓存方法 ===');
-        await mb.del('test_key');
-        const setResult = await mb.set('test_key', 'test_value');
-        console.log('set结果:', setResult);
-        
-        const getResult = await mb.get('test_key');
-        console.log('get结果:', getResult);
-        
-        const existsResult = await mb.exists('test_key');
-        console.log('exists结果:', existsResult);
-        
-        // 测试哈希表操作
-        console.log('\n=== 测试哈希表操作 ===');
-        await mb.del('test_hash');
-        await mb.hset('test_hash', 'field1', 'value1');
-        await mb.hset('test_hash', 'field2', 'value2');
-        
-        const hgetResult = await mb.hget('test_hash', 'field1');
-        console.log('hget结果:', hgetResult);
-        
-        const hgetallResult = await mb.hgetall('test_hash');
-        console.log('hgetall结果:', hgetallResult);
-        
-        const hmgetResult = await mb.hmget('test_hash', ['field1', 'field2']);
-        console.log('hmget结果:', hmgetResult);
-        
-        const hkeysResult = await mb.hkeys('test_hash');
-        console.log('hkeys结果:', hkeysResult);
-        
-        const hvalsResult = await mb.hvals('test_hash');
-        console.log('hvals结果:', hvalsResult);
-        
-        const hlenResult = await mb.hlen('test_hash');
-        console.log('hlen结果:', hlenResult);
-        
-        // 测试列表操作
-        console.log('\n=== 测试列表操作 ===');
-        await mb.del('test_list');
-        await mb.rpush('test_list', 'item1');
-        await mb.rpush('test_list', 'item2');
-        await mb.lpush('test_list', 'item0');
-        
-        const llenResult = await mb.llen('test_list');
-        console.log('llen结果:', llenResult);
-        
-        const lrangeResult = await mb.lrange('test_list', 0, -1);
-        console.log('lrange结果:', lrangeResult);
-        
-        const lindexResult = await mb.lindex('test_list', 1);
-        console.log('lindex结果:', lindexResult);
-        
-        // 测试集合操作
-        console.log('\n=== 测试集合操作 ===');
-        await mb.del('test_set');
-        await mb.saddMulti('test_set', ['member1', 'member2']);
-        
-        const smembersResult = await mb.smembers('test_set');
-        console.log('smembers结果:', smembersResult);
-        
-        const scardResult = await mb.scard('test_set');
-        console.log('scard结果:', scardResult);
-        
-        const sismemberResult = await mb.sismember('test_set', 'member1');
-        console.log('sismember结果:', sismemberResult);
-        
-        // 测试有序集合操作
-        console.log('\n=== 测试有序集合操作 ===');
-        await mb.del('test_zset');
-        await mb.zadd('test_zset', 1, 'zmember1');
-        await mb.zadd('test_zset', 2, 'zmember2');
-        
-        const zcardResult = await mb.zcard('test_zset');
-        console.log('zcard结果:', zcardResult);
-        
-        const zscoreResult = await mb.zscore('test_zset', 'zmember1');
-        console.log('zscore结果:', zscoreResult);
-        
-        const zrangebyscoreResult = await mb.zrangebyscore('test_zset', 1, 2);
-        console.log('zrangebyscore结果:', zrangebyscoreResult);
-        
-        // 测试批量操作
-        console.log('\n=== 测试批量操作 ===');
-        const msetResult = await mb.mset({
-            'batch_key1': 'batch_value1',
-            'batch_key2': 'batch_value2'
-        });
-        console.log('mset结果:', msetResult);
-        
-        const mgetResult = await mb.mget(['batch_key1', 'batch_key2']);
-        console.log('mget结果:', mgetResult);
-        
-        // 清理测试数据
-        console.log('\n=== 清理测试数据 ===');
-        const keysToDelete = ['test_key', 'test_hash', 'test_list', 'test_set', 'test_zset', 'batch_key1', 'batch_key2'];
-        for (const key of keysToDelete) {
-            await mb.del(key);
-        }
-        console.log('测试数据清理完成');
-        
-        console.log('\n✅ 所有Redis兼容API测试完成！');
-    } catch (error) {
-        console.error('❌ 测试失败:', error);
-        process.exit(1);
-    } finally {
-        await mb.close();
-    }
-}
-
-testRedisCompatibility();
+// Redis兼容性API测试文件
+const { MongoDB, mongodb_admin } = require('./index');
+
+async function runRedisCompatibilityTests() {
+  console.log('开始测试Redis兼容API...');
+  console.log('正在连接数据库...');
+  
+  let cache = null;
+  const testKeys = [];
+  
+  try {
+    // 获取缓存实例
+    cache = mongodb_admin('cache');
+    
+    console.log('数据库连接成功！\n');
+    
+    // 核心缓存方法测试
+    console.log('=== 测试核心缓存方法 ===');
+    const setResult = await cache.set('test_key', 'test_value');
+    console.log('set结果:', setResult);
+    testKeys.push('test_key');
+    
+    const getResult = await cache.get('test_key');
+    console.log('get结果:', getResult);
+    
+    const existsResult = await cache.exists('test_key');
+    console.log('exists结果:', existsResult);
+    console.log('');
+    
+    // 哈希表操作测试
+    console.log('=== 测试哈希表操作 ===');
+    await cache.hset('test_hash', 'field1', 'value1');
+    testKeys.push('test_hash');
+    
+    const hgetResult = await cache.hget('test_hash', 'field1');
+    console.log('hget结果:', hgetResult);
+    
+    const hgetallResult = await cache.hgetall('test_hash');
+    console.log('hgetall结果:', hgetallResult);
+    
+    const hmgetResult = await cache.hmget('test_hash', ['field1', 'field2']);
+    console.log('hmget结果:', hmgetResult);
+    
+    const hkeysResult = await cache.hkeys('test_hash');
+    console.log('hkeys结果:', hkeysResult);
+    
+    const hvalsResult = await cache.hvals('test_hash');
+    console.log('hvals结果:', hvalsResult);
+    
+    const hlenResult = await cache.hlen('test_hash');
+    console.log('hlen结果:', hlenResult);
+    console.log('');
+    
+    // 列表操作测试
+    console.log('=== 测试列表操作 ===');
+    await cache.lpush('test_list', 'item1');
+    testKeys.push('test_list');
+    
+    const llenResult = await cache.llen('test_list');
+    console.log('llen结果:', llenResult);
+    
+    const lrangeResult = await cache.lrange('test_list', 0, -1);
+    console.log('lrange结果:', lrangeResult);
+    
+    const lindexResult = await cache.lindex('test_list', 1);
+    console.log('lindex结果:', lindexResult);
+    console.log('');
+    
+    // 集合操作测试
+    console.log('=== 测试集合操作 ===');
+    await cache.saddMulti('test_set', ['member1', 'member2']);
+    testKeys.push('test_set');
+    
+    // 使用mget获取集合内容，然后手动去重模拟smembers
+    const setContent = await cache.get('test_set');
+    const uniqueMembers = Array.from(new Set(setContent.map(m => JSON.stringify(m)))).map(s => JSON.parse(s));
+    console.log('集合成员结果:', uniqueMembers);
+    
+    const scardResult = await cache.scard('test_set');
+    console.log('scard结果:', scardResult);
+    
+    const sismemberResult = await cache.sismember('test_set', 'member1');
+    console.log('sismember结果:', sismemberResult);
+    console.log('');
+    
+    // 有序集合操作测试
+    console.log('=== 测试有序集合操作 ===');
+    await cache.zadd('test_zset', 1, 'zmember1');
+    testKeys.push('test_zset');
+    
+    const zcardResult = await cache.zcard('test_zset');
+    console.log('zcard结果:', zcardResult);
+    
+    const zscoreResult = await cache.zscore('test_zset', 'zmember1');
+    console.log('zscore结果:', zscoreResult);
+    
+    const zrangebyscoreResult = await cache.zrangebyscore('test_zset', 0, 10);
+    console.log('zrangebyscore结果:', zrangebyscoreResult);
+    console.log('');
+    
+    // 批量操作测试
+    console.log('=== 测试批量操作 ===');
+    const batchData = {
+      'batch_key1': 'batch_value1',
+      'batch_key2': 'batch_value2'
+    };
+    const msetResult = await cache.mset(batchData);
+    console.log('mset结果:', msetResult);
+    testKeys.push('batch_key1', 'batch_key2');
+    
+    const mgetResult = await cache.mget(['batch_key1', 'batch_key2']);
+    console.log('mget结果:', mgetResult);
+    console.log('');
+    
+    // 清理测试数据
+    console.log('=== 清理测试数据 ===');
+    for (const key of testKeys) {
+      await cache.del(key);
+    }
+    console.log('测试数据清理完成');
+    console.log('');
+    
+    // 所有测试通过
+    console.log('✅ 所有Redis兼容API测试完成！');
+    
+    // 关闭连接
+    await cache.close();
+    process.exit(0);
+    
+  } catch (error) {
+    console.error('测试过程中出错:', error);
+    
+    // 清理测试数据
+    if (cache && testKeys.length > 0) {
+      try {
+        console.log('尝试清理测试数据...');
+        for (const key of testKeys) {
+          await cache.del(key);
+        }
+      } catch (e) {
+        console.error('清理数据时出错:', e);
+      }
+    }
+    
+    // 关闭连接
+    if (cache) {
+      await cache.close();
+    }
+    
+    process.exit(1);
+  }
+}
+
+// 运行测试
+runRedisCompatibilityTests();

package/compatibility_table.md

@@ -1,122 +0,0 @@
-# 三种缓存方式方法兼容性对比表格
-
-## 核心缓存方法
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| set | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| get | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| del | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| has | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| clear | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| keys | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| ttl | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| add | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| addInt | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| addStr | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| sort | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-
-## Redis兼容方法 - 哈希表操作
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| hset | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hget | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hgetall | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hdel | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| hexists | ❌ | ❌ | ❌ | 已移除，测试确认不可用 |
-| hkeys | ❌ | ❌ | ❌ | 已移除 |
-| hvals | ❌ | ❌ | ❌ | 已移除 |
-
-## Redis兼容方法 - 其他常用命令
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| expire | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| incr | ✅ | ✅ | ✅ | 所有方式均返回正确数值 |
-| decr | ✅ | ✅ | ✅ | 所有方式均返回正确数值 |
-| exists | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-| mget | ✅ | ✅ | ✅ | 所有方式均返回正确格式的数组 |
-| mset | ✅ | ✅ | ✅ | 所有方式均正常工作 |
-
-## 数组/列表操作方法
-
-| 方法名 | Redis | MongoDB | CacheBase | 状态说明 |
-|-------|-------|---------|-----------|----------|
-| list_set | ❌ | ❌ | ❌ | 测试确认不支持 |
-| list_get | ❌ | ❌ | ❌ | 未测试，预计不支持 |
-| list_len | ❌ | ❌ | ❌ | 未测试，预计不支持 |
-| list_push | ❌ | ❌ | ❌ | 未测试，预计不支持 |
-| list_pop | ❌ | ❌ | ❌ | 未测试，预计不支持 |
-
-## 全面兼容性测试结果总结
-
-根据所有测试文件的运行结果，我们得到了全面的兼容性情况：
-
-### 所有缓存方式都支持的功能：
-- **哈希表基本操作**：hset, hget, hgetall, hdel
-- **核心Redis命令**：set, get, expire, exists, mset
-- **缓存管理功能**：clear, keys, 缓存池, 缓存清理
-- **缓存方式切换**：可以在cachebase、redis、mongodb之间正常切换
-
-### CacheBase 缓存方式：
-- **完全兼容**：所有测试都成功通过
-- **返回值**：所有操作都返回符合预期的结果
-- **数组操作**：不支持list_set等数组操作方法
-
-### Redis 缓存方式：
-- **完全兼容**：所有测试都成功通过
-- **连接状态**：成功连接Redis服务器，连接池正常工作
-- **返回值**：incr/decr返回正确数值(11, 10)
-- **数组操作**：不支持list_set等数组操作方法
-
-### MongoDB 缓存方式：
-- **功能执行成功**：所有操作都能正确修改数据
-- **返回值正常**：所有方法都返回符合Redis兼容格式的结果
-- **数组操作**：不支持list_set等数组操作方法
-
-### 已确认移除的方法：
-- hexists：测试中报错 "TypeError: cache.hexists is not a function"
-- 所有列表/数组操作方法：测试中报错 "Error: 不支持的方法: list_set"
-
-## 最佳使用建议
-
-1. **CacheBase 方式**（推荐）：
-   - 所有功能完全兼容，返回值符合预期
-   - 性能稳定，在多次依赖更新中保持一致表现
-   - 适合所有缓存场景，特别是对稳定性要求高的情况
-   - 不需要额外的外部服务依赖
-
-2. **Redis 方式**（推荐）：
-   - 依赖更新后已修复兼容性问题，现在可以正常使用
-   - 所有功能完全兼容，返回值符合预期
-   - 适合需要高性能、分布式缓存或Redis特有功能的场景
-   - 需要外部Redis服务
-
-3. **MongoDB 方式**（推荐）：
-   - 可用于需要持久化且数据结构较简单的场景
-   - **重要注意事项**：
-     - 适合需要持久化缓存且需要Redis兼容API的场景
-     - 所有Redis兼容方法都能返回正确格式的结果
-   - 需要外部MongoDB服务
-
-## 实际使用建议
-
-1. **开发环境**：推荐使用CacheBase，无需额外配置，使用简单
-
-2. **生产环境**：
-   - 如果需要高性能、分布式缓存：使用Redis
-   - 如果需要缓存持久化且已有MongoDB环境：可使用MongoDB
-   - 大多数场景下，CacheBase已足够应对
-
-3. **跨环境部署**：
-   - 可以根据环境配置自动切换缓存方式
-   - 确保代码不依赖特定缓存方式的返回值特性（特别是MongoDB）
-
-4. **性能考虑**：
-   - CacheBase：内存操作，最快但不持久化
-   - Redis：网络操作，但性能优秀
-   - MongoDB：网络+磁盘操作，性能相对较低
-
-## 兼容性维护建议
-注：✅ 完全兼容/功能正常 | ⚠️ 功能正常但返回值异常 | ❌ 不兼容/未实现/已移除