mm_mongodb 1.4.6 → 1.4.8

package/package.json

@@ -1,14 +1,13 @@
 {
     "name": "mm_mongodb",
-    "version": "1.4.6",
+    "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_cache, mongodb_cache_admin } = require('./cache.js');
+const { MongoDB, mongoDB_admin } = require('./index.js');
 
-async function test2() {
-	var mb = mongodb_cache_admin("sys");
-	mb.setConfig();
-	// mb.open();
-	console.log(mb);
-}
-test2();
 
 /* 调用示例 */
 async function test() {
 	console.log("测试开始");
 	// 实例化构造函数，传入服务器地址和数据库名
-	var mb = new Mongodb_cache("localhost", "mm");
+	var mb = new MongoDB("localhost");
 	mb.setConfig();
 
 	await mb.open();
@@ -27,17 +20,19 @@ async function test() {
 	mb.table = "mm_table";
 
 console.log("查询", mb.conn);
-	var ret = await mb.get('李四');
-	console.log("查询李四",ret);
+	// 直接使用find方法查询数据
+	var ret = await mb.find({ name: '李四' });
+	console.log("查询李四", ret);
 
-	ret = await mb.get('张三');
-	console.log("查询张三",ret);
+	ret = await mb.find({ name: '张三' });
+	console.log("查询张三", ret);
 
 	// 选择要操作的表
 	mb.table = 'mm_table';
 
 	// 添加一条数据
-	ret = await mb.add("张三", {
+	ret = await mb.addObj({
+		name: "张三",
 		age: 21,
 		sex: true
 	});
@@ -45,13 +40,19 @@ console.log("查询", mb.conn);
 	
 	
 	// 修改一条数据
-	ret = await mb.add("李四", {
+	ret = await mb.addObj({
+		name: "李四",
 		age: 24,
 		sex: false
 	});
-	console.log("修改一条数据", ret);
-	
+	console.log("添加一条数据", ret);
+
+	// 查询
+	ret = await mb.find({ name: "张三" });
+	console.log("查询张三", ret);
+
+	// 关闭连接
+	await mb.close();
 	console.log("测试完成");
 }
-
-test();
+test();

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

@@ -0,0 +1,135 @@
+// 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();