mm_cache 1.4.5 → 1.4.6

package/index.js

@@ -70,7 +70,7 @@ class Cache extends Base {
 		// 作用域
 		this.scope;
 		// 当前连接库
-		this.db = null;
+		this._client = null;
 		// 初始化配置
 		this.setConfig(config);
 		// 注意：不再在构造函数中直接调用异步的connect()
@@ -83,11 +83,23 @@ class Cache extends Base {
  * @param {Object} config 配置
  */
 Cache.prototype.setConfig = function (config) {
+	// 确保this.config存在
+	if (!this.config) {
+		this.config = {};
+	}
+	
 	if (config) {
+		// 使用$.push合并配置
 		$.push(this.config, config);
 	}
+	
+	// 确保way属性存在
+	if (!this.config.way) {
+		this.config.way = 'memory'; // 默认缓存方式
+	}
+	
 	if (this.config.scope) {
-		this.scope = scope;
+		this.scope = this.config.scope;
 	} else {
 		this.scope = $.val.scope + '';
 	}
@@ -116,14 +128,14 @@ Cache.prototype.connect = async function () {
 					const {
 						redisAdmin
 					} = require('mm_redis');
-					this.db = redisAdmin(this.config.scope, this.config.redis);
-					if (!this.db.connected) {
-						await this.db.open();
+					this._client = redisAdmin(this.config.scope, this.config.redis);
+					if (!this._client.connected) {
+						await this._client.open();
 					}
 				} catch (e) {
 					$.log.warn('[Cache] [connect] Cache模块加载失败，回退到memory:', e.message);
 					this.config.way = 'memory';
-					await this.connect(); // 递归调用，使用memory
+					await this._clientect(); // 递归调用，使用memory
 					return false;
 				}
 				break;
@@ -133,14 +145,14 @@ Cache.prototype.connect = async function () {
 					const {
 						mongodbAdmin
 					} = require('mm_mongodb');
-					this.db = mongodbAdmin(this.config.scope, this.config.mongodb);
-					if (!this.db.connected) {
-						await this.db.open();
+					this._client = mongodbAdmin(this.config.scope, this.config.mongodb);
+					if (!this._client.connected) {
+						await this._client.open();
 					}
 				} catch (e) {
 					$.log.warn('[Cache] [connect] MongoDB模块加载失败，回退到memory:', e.message);
 					this.config.way = 'memory';
-					await this.connect(); // 递归调用，使用cachebase memory
+					await this._clientect(); // 递归调用，使用cachebase memory
 					return false;
 				}
 				break;
@@ -150,7 +162,7 @@ Cache.prototype.connect = async function () {
 					const {
 						cachebaseAdmin
 					} = require('mm_cachebase');
-					this.db = cachebaseAdmin(this.config.scope, this.config.cachebase);
+					this._client = cachebaseAdmin(this.config.scope, this.config.cachebase);
 				} catch (e) {
 					$.log.error('[Cache] [connect] CacheBase模块加载失败，无法初始化缓存:', e.message);
 					return false;
@@ -162,7 +174,7 @@ Cache.prototype.connect = async function () {
 					const {
 						cachebaseAdmin
 					} = require('mm_cachebase');
-					this.db = cachebaseAdmin('default');
+					this._client = cachebaseAdmin('default');
 				} catch (e) {
 					$.log.error('[Cache] [connect] CacheBase模块加载失败，无法初始化缓存:', e.message);
 					return false;
@@ -191,7 +203,7 @@ Cache.prototype.switchCache = async function (way, config) {
 		if (config) {
 			this.config[way] = Object.assign(this.config[way], config);
 		}
-		return await this.connect();
+		return await this._clientect();
 	}
 	return false;
 };
@@ -217,8 +229,8 @@ Cache.prototype.has = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	// 优先使用has方法，如果不存在则使用exists
-	if (this.db && typeof this.db.has === 'function') {
-		return await this.db.has(scopeKey);
+	if (this._client && typeof this._client.has === 'function') {
+		return await this._client.has(scopeKey);
 	} else {
 		return await this._safeCall('exists', [scopeKey]);
 	}
@@ -231,18 +243,18 @@ Cache.prototype.has = async function (key) {
  * @return {Promise<any>} 方法返回值
  */
 Cache.prototype._safeCall = async function (method, args = []) {
-	if (!this.db) {
+	if (!this._client) {
 		// 如果未连接，自动尝试连接
-		await this.connect();
-		if (!this.db) {
+		await this._clientect();
+		if (!this._client) {
 			$.log.error('[Cache] [_safeCall] 数据库未初始化');
 			return null;
 		}
 	}
 
 	// 如果方法存在，直接调用
-	if (typeof this.db[method] === 'function') {
-		return await this.db[method](...args);
+	if (typeof this._client[method] === 'function') {
+		return await this._client[method](...args);
 	}
 
 	// 降级处理：仅为确实不存在的方法提供内置实现
@@ -250,7 +262,7 @@ Cache.prototype._safeCall = async function (method, args = []) {
 		case 'strlen': {
 			const key = args[0];
 			// 获取值并计算长度
-			const value = await this.db.get(key);
+			const value = await this._client.get(key);
 			if (value === null || value === undefined) {
 				return 0;
 			}
@@ -261,14 +273,14 @@ Cache.prototype._safeCall = async function (method, args = []) {
 			const [oldKey, newKey] = args;
 			try {
 				// 获取原键值
-				const value = await this.db.get(oldKey);
+				const value = await this._client.get(oldKey);
 				if (value === null || value === undefined) {
 					return false;
 				}
 				// 设置新键
-				await this.db.set(newKey, value);
+				await this._client.set(newKey, value);
 				// 删除原键
-				await this.db.del(oldKey);
+				await this._client.del(oldKey);
 				return 'OK';
 			} catch (error) {
 				$.log.error(`[Cache] [_safeCall] rename操作失败:`, error);
@@ -278,7 +290,7 @@ Cache.prototype._safeCall = async function (method, args = []) {
 		case 'type': {
 			const key = args[0];
 			// 获取值并判断类型
-			const value = await this.db.get(key);
+			const value = await this._client.get(key);
 			if (value === null || value === undefined) {
 				return 'none';
 			}
@@ -405,7 +417,7 @@ Cache.prototype.mget = function () {
 			const promises = scopeKeys.map(async (key) => {
 				try {
 					// 直接使用db.get方法获取单个键的值
-					return await this.db.get(key);
+					return await this._client.get(key);
 				} catch (error) {
 					return null;
 				}
@@ -429,8 +441,8 @@ Cache.prototype.incr = async function (key, step = 1) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	// 优先使用incr方法，如果不存在则使用addInt
-	if (this.db && typeof this.db.incr === 'function') {
-		return await this.db.incr(scopeKey, step);
+	if (this._client && typeof this._client.incr === 'function') {
+		return await this._client.incr(scopeKey, step);
 	} else {
 		return await this._safeCall('addInt', [scopeKey, step]);
 	}
@@ -818,8 +830,8 @@ Cache.prototype.clearExpire = async function () {
  * @return {Promise<Boolean>} 是否关闭成功
  */
 Cache.prototype.dispose = async function () {
-	if (this.db && typeof this.db.dispose === 'function') {
-		return await this.db.dispose();
+	if (this._client && typeof this._client.dispose === 'function') {
+		return await this._client.dispose();
 	}
 	return true;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_cache",
-    "version": "1.4.5",
+    "version": "1.4.6",
     "description": "一个统一的缓存操作框架，为多种缓存方式（Redis、MongoDB、CacheBase、Memory）提供统一的API接口，实现无缝切换和兼容",
     "main": "index.js",
     "scripts": {
@@ -30,7 +30,7 @@
     },
     "homepage": "https://gitee.com/qiuwenwu/mm_cache#readme",
     "dependencies": {
-        "mm_cachebase": "^1.9.3",
+        "mm_cachebase": "^1.9.6",
         "mm_mongodb": "^1.5.5",
         "mm_redis": "^2.1.1"
     }

package/test.js

@@ -59,6 +59,16 @@ function isMethodUnsupported(errorMessage, methodName) {
 async function recordTestResult(cache, methodName, testFunction) {
     const cacheWay = cache.getCacheWay();
     
+    // 确保方法结果对象存在
+    if (!testStats.methodResults[methodName]) {
+        testStats.methodResults[methodName] = {
+            total: 0,
+            passed: 0,
+            unsupported: 0,
+            cacheWays: {}
+        };
+    }
+    
     // 初始化方法的缓存方式结果
     if (!testStats.methodResults[methodName].cacheWays[cacheWay]) {
         testStats.methodResults[methodName].cacheWays[cacheWay] = {
@@ -108,6 +118,11 @@ async function recordTestResult(cache, methodName, testFunction) {
         
         return false;
     } finally {
+        // 确保缓存方式结果对象存在
+        if (!testStats.results[cacheWay]) {
+            testStats.results[cacheWay] = { total: 0, passed: 0, unsupported: 0 };
+        }
+        
         // 增加总数计数
         testStats.results[cacheWay].total++;
         testStats.methodResults[methodName].total++;
@@ -452,7 +467,10 @@ async function testCacheWay(cacheWay) {
     $.log.debug(`[Cache] ==============================`);
     
     // 直接使用指定的缓存方式创建Cache实例
-    const cache = new Cache({ way: cacheWay }, `test_${cacheWay}`);
+    const cache = new Cache({ 
+        way: cacheWay,
+        scope: `test_${cacheWay}`
+    });
     const connected = await cache.connect();
     
     if (connected) {