mm_cachebase 1.6.0 → 1.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "mm_cachebase",
-    "version": "1.6.0",
-    "description": "一个轻量级的本地缓存类库，提供与Redis兼容的API接口，支持过期时间设置、哈希表操作、数值操作、字符串操作等功能，以及完整的事件通知系统。",
+    "version": "1.8.0",
+    "description": "一个轻量级的本地缓存类库，提供与Redis兼容的API接口，支持过期时间设置、哈希表操作、数值操作、字符串操作等功能，以及完整的事件通知系统和多文件持久化功能。",
     "main": "index.js",
     "scripts": {
         "test": "node test.js"
@@ -27,7 +27,10 @@
         "ttl",
         "expire",
         "incr",
-        "decr"
+        "decr",
+        "persistence",
+        "persist",
+        "scope"
     ],
     "author": "邱文武",
     "license": "MIT",

package/simple_test.js

@@ -0,0 +1,70 @@
+const { CacheBase } = require('./index');
+const fs = require('fs');
+const path = require('path');
+
+async function simpleTest() {
+  console.log('====== 简单持久化测试 ======');
+  
+  const cacheDir = './test_simple_cache';
+  const cacheFile = path.join(cacheDir, 'simple_cache.json');
+  
+  // 清理之前的测试文件
+  if (fs.existsSync(cacheFile)) {
+    fs.unlinkSync(cacheFile);
+    console.log('已清理旧测试文件');
+  }
+  
+  // 步骤1: 创建缓存并设置数据
+  console.log('\n步骤1: 创建缓存并设置数据');
+  const cache = new CacheBase({
+    persist: true,
+    scope: 'simple',
+    dir: cacheDir
+  });
+  
+  // 直接设置数据
+  console.log('设置数据...');
+  cache.data['test_key'] = { value: 'test_value', expire: 0 };
+  cache.list = ['test_key'];
+  console.log('当前data:', cache.data);
+  console.log('当前list:', cache.list);
+  
+  // 步骤2: 手动保存
+  console.log('\n步骤2: 手动保存数据');
+  await cache.save();
+  
+  // 检查文件是否存在且有内容
+  if (fs.existsSync(cacheFile)) {
+    const content = fs.readFileSync(cacheFile, 'utf8');
+    console.log('保存的文件内容:');
+    console.log(content);
+  } else {
+    console.log('错误: 文件未创建');
+  }
+  
+  // 步骤3: 销毁缓存
+  console.log('\n步骤3: 销毁缓存');
+  await cache.dispose();
+  
+  // 步骤4: 创建新缓存，应该加载数据
+  console.log('\n步骤4: 创建新缓存，尝试加载数据');
+  const newCache = new CacheBase({
+    persist: true,
+    scope: 'simple',
+    dir: cacheDir
+  });
+  
+  // 等待一点时间让_loadData完成
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // 检查是否加载了数据
+  console.log('加载后的data:', newCache.data);
+  console.log('加载后的list:', newCache.list);
+  console.log('test_key值:', newCache.data.test_key ? newCache.data.test_key.value : 'undefined');
+  
+  // 清理
+  await newCache.dispose();
+  console.log('\n测试完成！');
+}
+
+simpleTest().catch(console.error);

package/test.js

@@ -107,7 +107,7 @@ async function testBasicMethods(runner) {
   });
   
   await runner.runTest('keys方法', async () => {
-    await cache.flushdb();
+    await cache.clear();
     await cache.set('key4', 'value4');
     await cache.set('key5', 'value5');
     const keys = await cache.keys();
@@ -139,7 +139,7 @@ async function testBasicMethods(runner) {
   });
   
   await runner.runTest('flushdb/clear方法', async () => {
-    let result = await cache.flushdb();
+    let result = await cache.clear();
     if (result !== 'OK') {
       throw new Error(`flushdb失败，预期: OK, 实际: ${result}`);
     }

package/test_cache/scope1.cache.json

@@ -0,0 +1,5 @@
+{
+    "data": {},
+    "list": [],
+    "timestamp": 1759920414864
+}

package/test_cache/scope2.cache.json

@@ -0,0 +1,5 @@
+{
+    "data": {},
+    "list": [],
+    "timestamp": 1759920414866
+}

package/test_cache/scope3.cache.json

@@ -0,0 +1,5 @@
+{
+    "data": {},
+    "list": [],
+    "timestamp": 1759920414869
+}

package/test_cache/test_scope.cache.json

@@ -0,0 +1,5 @@
+{
+    "data": {},
+    "list": [],
+    "timestamp": 1759920431894
+}

package/test_multi_file_persistence.js

@@ -0,0 +1,160 @@
+const { CacheBase } = require('./index');
+const fs = require('fs');
+const path = require('path');
+
+async function testMultiFilePersistence() {
+  console.log('====== 测试多文件持久化功能 ======');
+  
+  // 测试目录
+  const testDir = './test_cache';
+  
+  // 清理之前的测试文件
+  console.log('清理之前的测试文件...');
+  if (fs.existsSync(testDir)) {
+    const files = fs.readdirSync(testDir);
+    for (const file of files) {
+      if (file.endsWith('.cache.json')) {
+        fs.unlinkSync(path.join(testDir, file));
+        console.log(`删除文件: ${file}`);
+      }
+    }
+  }
+  
+  try {
+    // 创建多个不同scope的缓存实例
+    console.log('\n创建多个缓存实例...');
+    
+    const cache1 = new CacheBase('scope1', {
+      persist: true,
+      dir: testDir
+    });
+    
+    const cache2 = new CacheBase('scope2', {
+      persist: true,
+      dir: testDir
+    });
+    
+    const cache3 = new CacheBase('scope3', {
+      persist: true,
+      dir: testDir
+    });
+    
+    // 为每个实例设置数据
+    console.log('\n为每个实例设置数据...');
+    
+    // scope1 数据
+    await cache1.set('scope1_key1', 'scope1_value1');
+    await cache1.set('scope1_key2', { nested: 'object1' });
+    await cache1.set('scope1_key3', 100);
+    console.log('scope1 设置的数据:');
+    console.log('scope1_key1:', await cache1.get('scope1_key1'));
+    console.log('scope1_key2:', await cache1.get('scope1_key2'));
+    console.log('scope1_key3:', await cache1.get('scope1_key3'));
+    
+    // scope2 数据
+    await cache2.set('scope2_key1', 'scope2_value1');
+    await cache2.set('scope2_key2', { nested: 'object2' });
+    await cache2.set('scope2_key3', 200);
+    console.log('\nscope2 设置的数据:');
+    console.log('scope2_key1:', await cache2.get('scope2_key1'));
+    console.log('scope2_key2:', await cache2.get('scope2_key2'));
+    console.log('scope2_key3:', await cache2.get('scope2_key3'));
+    
+    // scope3 数据
+    await cache3.set('scope3_key1', 'scope3_value1');
+    await cache3.set('scope3_key2', { nested: 'object3' });
+    await cache3.set('scope3_key3', 300);
+    console.log('\nscope3 设置的数据:');
+    console.log('scope3_key1:', await cache3.get('scope3_key1'));
+    console.log('scope3_key2:', await cache3.get('scope3_key2'));
+    console.log('scope3_key3:', await cache3.get('scope3_key3'));
+    
+    // 手动保存数据
+    console.log('\n手动保存所有数据...');
+    await cache1.save();
+    await cache2.save();
+    await cache3.save();
+    
+    // 检查生成的文件
+    console.log('\n检查生成的缓存文件:');
+    const files = fs.readdirSync(testDir);
+    const cacheFiles = files.filter(file => file.endsWith('.cache.json'));
+    console.log('生成的缓存文件:', cacheFiles);
+    
+    // 销毁所有实例
+    console.log('\n销毁所有实例...');
+    await cache1.dispose();
+    await cache2.dispose();
+    await cache3.dispose();
+    
+    // 重新创建实例并验证数据隔离
+    console.log('\n重新创建缓存实例并验证数据隔离...');
+    
+    // 只应该加载自己scope的数据
+    const newCache1 = new CacheBase('scope1', {
+      persist: true,
+      dir: testDir
+    });
+    
+    const newCache2 = new CacheBase('scope2', {
+      persist: true,
+      dir: testDir
+    });
+    
+    const newCache3 = new CacheBase('scope3', {
+      persist: true,
+      dir: testDir
+    });
+    
+    // 验证每个实例只加载了自己scope的数据
+    console.log('\n验证数据隔离:');
+    
+    // 验证scope1只加载了自己的数据
+    const scope1Keys = await newCache1.keys();
+    console.log('scope1 加载的键数量:', scope1Keys.length);
+    console.log('scope1 加载的键:', scope1Keys);
+    
+    // 验证scope2只加载了自己的数据
+    const scope2Keys = await newCache2.keys();
+    console.log('scope2 加载的键数量:', scope2Keys.length);
+    console.log('scope2 加载的键:', scope2Keys);
+    
+    // 验证scope3只加载了自己的数据
+    const scope3Keys = await newCache3.keys();
+    console.log('scope3 加载的键数量:', scope3Keys.length);
+    console.log('scope3 加载的键:', scope3Keys);
+    
+    // 验证数据正确性
+    console.log('\n验证数据正确性:');
+    console.log('scope1_key1:', await newCache1.get('scope1_key1'));
+    console.log('scope2_key1:', await newCache2.get('scope2_key1'));
+    console.log('scope3_key1:', await newCache3.get('scope3_key1'));
+    
+    // 验证数据隔离 - scope1不应该能访问scope2的数据
+    console.log('\n验证数据隔离 - scope1不应访问其他scope数据:');
+    console.log('scope1能否获取scope2_key1:', await newCache1.get('scope2_key1') === undefined ? '✓ 不能 (正确)' : '✗ 能 (错误)');
+    console.log('scope1能否获取scope3_key1:', await newCache1.get('scope3_key1') === undefined ? '✓ 不能 (正确)' : '✗ 能 (错误)');
+    
+    // 清理测试数据
+    console.log('\n清理测试数据...');
+    await newCache1.flushdb();
+    await newCache2.flushdb();
+    await newCache3.flushdb();
+    await newCache1.save();
+    await newCache2.save();
+    await newCache3.save();
+    
+    // 销毁实例
+    await newCache1.dispose();
+    await newCache2.dispose();
+    await newCache3.dispose();
+    
+    console.log('\n多文件持久化测试完成！');
+    
+  } catch (error) {
+    console.error('测试过程中发生错误:', error);
+  }
+}
+
+// 运行测试
+testMultiFilePersistence();

package/test_persistence.js

@@ -0,0 +1,138 @@
+const { CacheBase } = require('./index');
+const fs = require('fs');
+const path = require('path');
+
+async function testPersistence() {
+  console.log('====== 测试数据持久化功能 ======');
+  
+  // 清理之前的测试文件
+  const testDir = './test_cache';
+  const testFilePath = path.join(testDir, 'test_scope.cache.json');
+  if (fs.existsSync(testFilePath)) {
+    fs.unlinkSync(testFilePath);
+    console.log(`清理之前的测试文件: ${testFilePath}`);
+  }
+  
+  // 创建缓存实例，启用持久化
+  // 注意：最新版本的构造函数签名是 (scope, config)
+  const cache = new CacheBase('test_scope', {
+    persist: true,
+    dir: './test_cache',
+    saveInterval: 5000 // 5秒保存一次
+  });
+  
+  try {
+    // 启动定时保存
+    console.log('启动定时保存...');
+    const connected = await cache.connect();
+    console.log(`定时保存启动${connected ? '成功' : '失败'}`);
+    
+    // 设置一些测试数据
+    console.log('\n设置测试数据...');
+    await cache.set('key1', 'value1');
+    await cache.set('key2', { nested: 'object', array: [1, 2, 3], boolean: true });
+    await cache.set('key3', 123);
+    await cache.set('key4', 'expire_value', 30); // 30秒过期
+    
+    // 增加更多测试数据
+    await cache.set('number_key', 42.5);
+    await cache.set('boolean_key', false);
+    await cache.set('array_key', [1, 'two', { three: 3 }]);
+    await cache.set('null_key', null);
+    await cache.set('undefined_key', undefined);
+    await cache.set('empty_string', '');
+    await cache.set('long_string', '这是一个很长的字符串，用于测试不同长度的数据存储。This is a long string for testing data storage with different lengths.');
+    
+    // 使用哈希表功能
+    await cache.hset('hash_key', 'field1', 'hash_value1');
+    await cache.hset('hash_key', 'field2', 100);
+    await cache.hset('hash_key', 'field3', { nested: 'data' });
+    
+    // 设置一些递增递减的值
+    await cache.incr('counter');
+    await cache.incrby('counter_by', 10);
+    await cache.decr('counter_dec');
+    
+    // 检查设置的数据
+    console.log('设置的数据:');
+    console.log('key1:', await cache.get('key1'));
+    console.log('key2:', JSON.stringify(await cache.get('key2')));
+    console.log('key3:', await cache.get('key3'));
+    console.log('key4:', await cache.get('key4'));
+    console.log('新增数据示例:');
+    console.log('array_key:', JSON.stringify(await cache.get('array_key')));
+    console.log('hash_key 字段1:', await cache.hget('hash_key', 'field1'));
+    console.log('counter:', await cache.get('counter'));
+    
+    // 获取键数量
+    const initialKeys = await cache.keys();
+    console.log(`\n初始设置的键数量: ${initialKeys.length}`);
+    console.log('键列表:', initialKeys);
+    
+    // 手动保存数据
+    console.log('\n手动保存数据...');
+    const saved = await cache.save();
+    console.log(`手动保存${saved ? '成功' : '失败'}`);
+    
+    // 销毁当前实例
+    console.log('\n销毁当前实例...');
+    await cache.dispose();
+    console.log('实例已销毁');
+    
+    // 创建新实例，应该能加载之前保存的数据
+    console.log('\n创建新实例，尝试加载数据...');
+    const newCache = new CacheBase('test_scope', {
+      persist: true,
+      dir: './test_cache'
+    });
+    
+    // 检查数据是否被正确加载
+    console.log('\n加载的数据:');
+    console.log('key1:', await newCache.get('key1'));
+    console.log('key2:', JSON.stringify(await newCache.get('key2')));
+    console.log('key3:', await newCache.get('key3'));
+    console.log('key4:', await newCache.get('key4'));
+    
+    // 验证新加的数据是否正确加载
+    console.log('\n验证新加的数据:');
+    console.log('number_key:', await newCache.get('number_key'));
+    console.log('boolean_key:', await newCache.get('boolean_key'));
+    console.log('array_key:', JSON.stringify(await newCache.get('array_key')));
+    console.log('null_key:', await newCache.get('null_key'));
+    console.log('undefined_key:', await newCache.get('undefined_key'));
+    console.log('empty_string:', JSON.stringify(await newCache.get('empty_string')));
+    console.log('long_string 长度:', (await newCache.get('long_string')).length);
+    
+    // 验证哈希表数据
+    console.log('\n验证哈希表数据:');
+    console.log('hash_key 字段1:', await newCache.hget('hash_key', 'field1'));
+    console.log('hash_key 字段2:', await newCache.hget('hash_key', 'field2'));
+    console.log('hash_key 字段3:', JSON.stringify(await newCache.hget('hash_key', 'field3')));
+    
+    // 验证计数数据
+    console.log('\n验证计数数据:');
+    console.log('counter:', await newCache.get('counter'));
+    console.log('counter_by:', await newCache.get('counter_by'));
+    console.log('counter_dec:', await newCache.get('counter_dec'));
+    
+    // 验证键的数量
+    const loadedKeys = await newCache.keys();
+    console.log('\n加载的键数量:', loadedKeys.length);
+    console.log('键列表:', loadedKeys);
+    
+    // 清理测试数据
+    console.log('\n清理测试数据...');
+    await newCache.flushdb();
+    await newCache.save();
+    await newCache.dispose();
+    
+    console.log('\n测试完成！');
+    
+  } catch (error) {
+    console.error('测试过程中发生错误:', error);
+    await cache.dispose().catch(() => {});
+  }
+}
+
+// 运行测试
+testPersistence();