mm_cache 1.4.1 → 1.4.3

package/README.md

@@ -1,260 +1,260 @@
-# mm_cache
-
-## 项目信息
-
-- **当前版本**: 1.4.1
-- **更新日期**: 2024-12-23
-- **仓库地址**: [https://gitee.com/qiuwenwu/mm_cache](https://gitee.com/qiuwenwu/mm_cache)
-- **Node.js版本要求**: >=14.0.0，推荐16.0.0及以上
-
-## 简介
-
-mm_cache是一个统一的缓存操作框架，为多种缓存方式（Redis、MongoDB、CacheBase、Memory）提供统一的API接口，实现无缝切换和兼容。本模块作为上层抽象，整合了多种缓存实现，让开发者可以使用统一的方式操作不同的缓存系统。
-
-## 特点
-
-- **统一API接口**：为Redis、MongoDB、CacheBase、Memory提供完全一致的接口
-- **无缝切换**：支持在不同缓存实现之间快速切换，无需修改业务代码
-- **完整的方法支持**：包括核心缓存方法、原子操作、字符串操作、批量操作、过期时间操作、键操作、哈希表操作、数组/列表操作等
-- **高兼容性**：所有缓存方式支持相同的参数格式和返回值类型
-- **灵活配置**：支持多种配置方式，适应不同的应用场景
-- **一致性保证**：确保不同缓存实现的行为一致性，特别是在原子操作和过期时间处理方面
-
-## 安装
-
-```bash
-npm install mm_cache
-```
-
-## 使用方法
-
-### 基础用法
-
-```javascript
-const { Cache } = require('mm_cache');
-
-// 初始化Redis缓存
-const redisCache = new Cache({
-  cache_way: 'redis',
-  redis: {
-    host: '127.0.0.1',
-    port: 6379,
-    password: 'your_password',
-    db: 0
-  }
-});
-
-// 初始化MongoDB缓存
-const mongodbCache = new Cache({
-  cache_way: 'mongodb',
-  mongodb: {
-    url: 'mongodb://localhost:27017',
-    database: 'cache_db',
-    collection: 'cache_collection'
-  }
-});
-
-// 初始化CacheBase缓存
-const cacheBaseCache = new Cache({
-  cache_way: 'cachebase',
-  cachebase: {
-    enabled: true,
-    cache_dir: './cache'
-  }
-});
-
-// 初始化Memory缓存
-const memoryCache = new Cache({
-  cache_way: 'memory'
-});
-
-// 使用统一的API操作不同的缓存
-async function testCache(cache) {
-  // 设置缓存
-  await cache.set('key', 'value');
-  
-  // 获取缓存
-  const value = await cache.get('key');
-  console.log(value); // 'value'
-  
-  // 删除缓存
-  await cache.del('key');
-  
-  // 检查缓存是否存在
-  const exists = await cache.has('key');
-  console.log(exists); // false
-}
-
-// 使用Redis缓存
-await testCache(redisCache);
-
-// 使用MongoDB缓存（无需修改代码）
-await testCache(mongodbCache);
-
-// 使用CacheBase缓存（无需修改代码）
-await testCache(cacheBaseCache);
-
-// 使用Memory缓存（无需修改代码）
-await testCache(memoryCache);
-```
-
-### 高级用法
-
-#### 设置过期时间
-
-```javascript
-// 设置缓存并设置过期时间为60秒
-await cache.set('key', 'value', 60);
-
-// 为已存在的键设置过期时间
-await cache.expire('key', 60);
-
-// 移除过期时间
-await cache.persist('key');
-
-// 获取剩余过期时间
-const ttl = await cache.ttl('key');
-console.log(ttl); // 剩余过期时间（秒），-1表示无过期时间，-2表示键不存在
-```
-
-#### 原子操作
-
-```javascript
-// 原子递增
-const newValue = await cache.incr('counter');
-console.log(newValue); // 1, 2, 3...
-
-// 增加指定整数值
-const result = await cache.incrby('counter', 10);
-
-// 增加指定浮点数值
-const floatResult = await cache.incrbyfloat('counter', 0.5);
-
-// 减少指定整数值
-const decrResult = await cache.decrby('counter', 5);
-```
-
-#### 哈希表操作
-
-```javascript
-// 设置哈希表字段
-await cache.hset('user:1', 'name', '张三');
-await cache.hset('user:1', 'age', 25);
-
-// 获取哈希表字段
-const name = await cache.hget('user:1', 'name');
-console.log(name); // '张三'
-
-// 获取所有哈希表字段
-const user = await cache.hgetall('user:1');
-console.log(user); // { name: '张三', age: '25' }
-
-// 批量设置哈希表字段
-await cache.hmset('user:2', {
-  name: '李四',
-  age: 30,
-  email: 'lisi@example.com'
-});
-
-// 批量获取哈希表字段
-const values = await cache.hmget('user:2', ['name', 'age']);
-console.log(values); // ['李四', '30']
-
-// 删除哈希表字段
-await cache.hdel('user:1', 'age');
-
-// 获取哈希表字段数量
-const count = await cache.hlen('user:1');
-console.log(count); // 1
-```
-
-#### 数组/列表操作
-
-```javascript
-// 设置列表
-await cache.setForList('users', ['张三', '李四', '王五']);
-
-// 向列表添加元素
-await cache.addForList('users', '赵六');
-
-// 检查元素是否在列表中
-const exists = await cache.hasForList('users', '李四');
-console.log(exists); // true
-
-// 获取列表元素（支持分页）
-const users = await cache.getForList('users', 0, 2);
-console.log(users); // ['张三', '李四', '王五']
-
-// 清空列表
-await cache.clearForList('users');
-```
-
-## 方法兼容性
-
-mm_cache确保所有支持的缓存方式（Redis、MongoDB、CacheBase、Memory）都实现了相同的API接口，具体兼容性情况请参考项目中的`compatibility_table.md`文件。
-
-## 配置说明
-
-### 全局配置选项
-
-```javascript
-const cache = new Cache({
-  // 缓存方式: redis, mongodb, cachebase, memory
-  cache_way: 'redis',
-  
-  // Redis配置
-  redis: {
-    host: '127.0.0.1',
-    port: 6379,
-    password: 'your_password',
-    db: 0
-  },
-  
-  // MongoDB配置
-  mongodb: {
-    url: 'mongodb://localhost:27017',
-    database: 'cache_db',
-    collection: 'cache_collection'
-  },
-  
-  // CacheBase配置
-  cachebase: {
-    enabled: true,
-    cache_dir: './cache',
-    file_ext: '.cache.json',
-    memory_limit: 5000,
-    save_interval: 5000,
-    file_mode: 384
-  }
-});
-```
-
-## 贡献指南
-
-1. **Fork项目**：在Gitee上Fork本项目到您的账户
-2. **创建分支**：在您的仓库中创建功能分支
-3. **提交修改**：提交您的代码修改和详细的提交信息
-4. **运行测试**：确保所有测试通过
-5. **发起PR**：向原项目提交Pull Request，描述您的修改内容和目的
-
-## 问题反馈
-
-如有任何问题或建议，请通过以下方式联系我们：
-
-- **Gitee Issues**: [https://gitee.com/qiuwenwu/mm_cache/issues](https://gitee.com/qiuwenwu/mm_cache/issues)
-- **NPM**: [https://www.npmjs.com/package/mm_cache](https://www.npmjs.com/package/mm_cache)
-
-## 鸣谢
-
-感谢以下项目和工具对本模块的支持：
-
-- [Node.js](https://nodejs.org/)
-- [Redis](https://redis.io/)
-- [MongoDB](https://www.mongodb.com/)
-- [mm_cachebase](https://www.npmjs.com/package/mm_cachebase)
-- [mm_mongodb](https://www.npmjs.com/package/mm_mongodb)
-- [mm_redis](https://www.npmjs.com/package/mm_redis)
-
-## 许可证
-
+# mm_cache
+
+## 项目信息
+
+- **当前版本**: 1.4.2
+- **更新日期**: 2025-11-17
+- **仓库地址**: [https://gitee.com/qiuwenwu/mm_cache](https://gitee.com/qiuwenwu/mm_cache)
+- **Node.js版本要求**: >=14.0.0，推荐16.0.0及以上
+
+## 简介
+
+mm_cache是一个统一的缓存操作框架，为多种缓存方式（Redis、MongoDB、CacheBase、Memory）提供统一的API接口，实现无缝切换和兼容。本模块作为上层抽象，整合了多种缓存实现，让开发者可以使用统一的方式操作不同的缓存系统。
+
+## 特点
+
+- **统一API接口**：为Redis、MongoDB、CacheBase、Memory提供完全一致的接口
+- **无缝切换**：支持在不同缓存实现之间快速切换，无需修改业务代码
+- **完整的方法支持**：包括核心缓存方法、原子操作、字符串操作、批量操作、过期时间操作、键操作、哈希表操作、数组/列表操作等
+- **高兼容性**：所有缓存方式支持相同的参数格式和返回值类型
+- **灵活配置**：支持多种配置方式，适应不同的应用场景
+- **一致性保证**：确保不同缓存实现的行为一致性，特别是在原子操作和过期时间处理方面
+
+## 安装
+
+```bash
+npm install mm_cache
+```
+
+## 使用方法
+
+### 基础用法
+
+```javascript
+const { Cache } = require('mm_cache');
+
+// 初始化Redis缓存
+const redisCache = new Cache({
+  way: 'redis',
+  redis: {
+    host: '127.0.0.1',
+    port: 6379,
+    password: 'your_password',
+    db: 0
+  }
+});
+
+// 初始化MongoDB缓存
+const mongodbCache = new Cache({
+  way: 'mongodb',
+  mongodb: {
+    url: 'mongodb://localhost:27017',
+    database: 'cache_db',
+    collection: 'cache_collection'
+  }
+});
+
+// 初始化CacheBase缓存
+const cacheBaseCache = new Cache({
+  way: 'cachebase',
+  cachebase: {
+    enabled: true,
+    cache_dir: './cache'
+  }
+});
+
+// 初始化Memory缓存
+const memoryCache = new Cache({
+  way: 'memory'
+});
+
+// 使用统一的API操作不同的缓存
+async function testCache(cache) {
+  // 设置缓存
+  await cache.set('key', 'value');
+  
+  // 获取缓存
+  const value = await cache.get('key');
+  $.log.debug(value); // 'value'
+  
+  // 删除缓存
+  await cache.del('key');
+  
+  // 检查缓存是否存在
+  const exists = await cache.has('key');
+  $.log.debug(exists); // false
+}
+
+// 使用Redis缓存
+await testCache(redisCache);
+
+// 使用MongoDB缓存（无需修改代码）
+await testCache(mongodbCache);
+
+// 使用CacheBase缓存（无需修改代码）
+await testCache(cacheBaseCache);
+
+// 使用Memory缓存（无需修改代码）
+await testCache(memoryCache);
+```
+
+### 高级用法
+
+#### 设置过期时间
+
+```javascript
+// 设置缓存并设置过期时间为60秒
+await cache.set('key', 'value', 60);
+
+// 为已存在的键设置过期时间
+await cache.expire('key', 60);
+
+// 移除过期时间
+await cache.persist('key');
+
+// 获取剩余过期时间
+const ttl = await cache.ttl('key');
+$.log.debug(ttl); // 剩余过期时间（秒），-1表示无过期时间，-2表示键不存在
+```
+
+#### 原子操作
+
+```javascript
+// 原子递增
+const newValue = await cache.incr('counter');
+$.log.debug(newValue); // 1, 2, 3...
+
+// 增加指定整数值
+const result = await cache.incrby('counter', 10);
+
+// 增加指定浮点数值
+const floatResult = await cache.incrbyfloat('counter', 0.5);
+
+// 减少指定整数值
+const decrResult = await cache.decrby('counter', 5);
+```
+
+#### 哈希表操作
+
+```javascript
+// 设置哈希表字段
+await cache.hset('user:1', 'name', '张三');
+await cache.hset('user:1', 'age', 25);
+
+// 获取哈希表字段
+const name = await cache.hget('user:1', 'name');
+$.log.debug(name); // '张三'
+
+// 获取所有哈希表字段
+const user = await cache.hgetall('user:1');
+$.log.debug(user); // { name: '张三', age: '25' }
+
+// 批量设置哈希表字段
+await cache.hmset('user:2', {
+  name: '李四',
+  age: 30,
+  email: 'lisi@example.com'
+});
+
+// 批量获取哈希表字段
+const values = await cache.hmget('user:2', ['name', 'age']);
+$.log.debug(values); // ['李四', '30']
+
+// 删除哈希表字段
+await cache.hdel('user:1', 'age');
+
+// 获取哈希表字段数量
+const count = await cache.hlen('user:1');
+$.log.debug(count); // 1
+```
+
+#### 数组/列表操作
+
+```javascript
+// 设置列表
+await cache.setForList('users', ['张三', '李四', '王五']);
+
+// 向列表添加元素
+await cache.addForList('users', '赵六');
+
+// 检查元素是否在列表中
+const exists = await cache.hasForList('users', '李四');
+$.log.debug(exists); // true
+
+// 获取列表元素（支持分页）
+const users = await cache.getForList('users', 0, 2);
+$.log.debug(users); // ['张三', '李四', '王五']
+
+// 清空列表
+await cache.clearForList('users');
+```
+
+## 方法兼容性
+
+mm_cache确保所有支持的缓存方式（Redis、MongoDB、CacheBase、Memory）都实现了相同的API接口，具体兼容性情况请参考项目中的`compatibility_table.md`文件。
+
+## 配置说明
+
+### 全局配置选项
+
+```javascript
+const cache = new Cache({
+  // 缓存方式: redis, mongodb, cachebase, memory
+  way: 'redis',
+  
+  // Redis配置
+  redis: {
+    host: '127.0.0.1',
+    port: 6379,
+    password: 'your_password',
+    db: 0
+  },
+  
+  // MongoDB配置
+  mongodb: {
+    url: 'mongodb://localhost:27017',
+    database: 'cache_db',
+    collection: 'cache_collection'
+  },
+  
+  // CacheBase配置
+  cachebase: {
+    enabled: true,
+    cache_dir: './cache',
+    file_ext: '.cache.json',
+    memory_limit: 5000,
+    save_interval: 5000,
+    file_mode: 384
+  }
+});
+```
+
+## 贡献指南
+
+1. **Fork项目**：在Gitee上Fork本项目到您的账户
+2. **创建分支**：在您的仓库中创建功能分支
+3. **提交修改**：提交您的代码修改和详细的提交信息
+4. **运行测试**：确保所有测试通过
+5. **发起PR**：向原项目提交Pull Request，描述您的修改内容和目的
+
+## 问题反馈
+
+如有任何问题或建议，请通过以下方式联系我们：
+
+- **Gitee Issues**: [https://gitee.com/qiuwenwu/mm_cache/issues](https://gitee.com/qiuwenwu/mm_cache/issues)
+- **NPM**: [https://www.npmjs.com/package/mm_cache](https://www.npmjs.com/package/mm_cache)
+
+## 鸣谢
+
+感谢以下项目和工具对本模块的支持：
+
+- [Node.js](https://nodejs.org/)
+- [Redis](https://redis.io/)
+- [MongoDB](https://www.mongodb.com/)
+- [mm_cachebase](https://www.npmjs.com/package/mm_cachebase)
+- [mm_mongodb](https://www.npmjs.com/package/mm_mongodb)
+- [mm_redis](https://www.npmjs.com/package/mm_redis)
+
+## 许可证
+
 本项目使用ISC许可证 - 详情请查看 [LICENSE](LICENSE) 文件

package/compatibility_table.md

@@ -42,8 +42,8 @@
 
 | 方法名 | Redis | MongoDB | CacheBase | Memory | 状态说明 |
 |-------|-------|---------|-----------|--------|----------|
-| expire | ✅ | ✅ | ⚠️ | ⚠️ | 所有方式功能实现效果相同，参数类型和返回值一致 |
-| persist | ✅ | ✅ | ⚠️ | ⚠️ | 所有方式均正常工作 |
+| expire | ✅ | ✅ | ✅ | ✅ | 所有方式功能实现效果相同，参数类型和返回值一致 |
+| persist | ✅ | ✅ | ✅ | ✅ | 所有方式均正常工作 |
 
 ## 键操作方法
 

package/index.js

@@ -4,12 +4,12 @@
  * @version 1.2
  */
 const EventEmitter = require('events');
-require('mm_logs');
+const { Base } = require('mm_expand');
 
-/**
+/** 
  * @class 缓存类
  */
-class Cache extends EventEmitter {
+class Cache extends Base {
 	/**
 	 * @description 创建Cache帮助类函数 (构造函数)
 	 * @param {String} scope 作用域
@@ -57,27 +57,15 @@ class Cache extends EventEmitter {
 				// 数据库名
 				database: "mm",
 				// 用户名
-				user: "admin",
+				user: "",
 				// 密码
 				password: "",
-				// 连接选项
-				options: {
-					// 使用MongoDB驱动推荐的配置
-					// 连接池配置
-					minPoolSize: 5,
-					maxPoolSize: 20,
-					// 连接超时时间
-					connectTimeoutMS: 10000,
-					// 服务器选择超时
-					serverSelectionTimeoutMS: 5000,
-					// 重试策略
-					retryWrites: true
-				},
-				// 重试配置
-				retry: {
-					maxAttempts: 3,
-					delayMS: 1000
-				}
+				// 连接选项 (MongoDB驱动7.x版本支持的参数)
+				min_pool_size: 10,
+				max_pool_size: 100,
+				connect_timeout_ms: 10000,
+				server_selection_timeout_ms: 5000,
+				retry_writes: true
 			}
 		};
 		// 作用域
@@ -100,9 +88,9 @@ class Cache extends EventEmitter {
  * @description 设置配置
  * @param {Object} config 配置
  */
-Cache.prototype.setConfig = function(config) {
+Cache.prototype.setConfig = function (config) {
 	if (config) {
-		Object.assign(this.config, config);
+		$.push(this.config, config);
 	}
 };
 
@@ -110,7 +98,7 @@ Cache.prototype.setConfig = function(config) {
  * @description 获取当前缓存方式
  * @return {String} 缓存方式
  */
-Cache.prototype.getCacheWay = function() {
+Cache.prototype.getCacheWay = function () {
 	return this.config.way;
 };
 
@@ -118,7 +106,7 @@ Cache.prototype.getCacheWay = function() {
  * @description 连接缓存数据库
  * @return {Promise<Boolean>} 是否连接成功
  */
-Cache.prototype.connect = async function() {
+Cache.prototype.connect = async function () {
 	// 关闭现有连接
 	this.dispose();
 
@@ -127,9 +115,9 @@ Cache.prototype.connect = async function() {
 			case 'redis': {
 				try {
 					const {
-						redis_admin
+						redisAdmin
 					} = require('mm_redis');
-					this.db = redis_admin(this.config.scope, this.config.redis);
+					this.db = redisAdmin(this.config.scope, this.config.redis);
 					if (!this.db.connected) {
 						await this.db.open();
 					}
@@ -144,9 +132,9 @@ Cache.prototype.connect = async function() {
 			case 'mongodb': {
 				try {
 					const {
-						mongodb_admin
+						mongodbAdmin
 					} = require('mm_mongodb');
-					this.db = mongodb_admin(this.config.scope, this.config.mongodb);
+					this.db = mongodbAdmin(this.config.scope, this.config.mongodb);
 					if (!this.db.connected) {
 						await this.db.open();
 					}
@@ -161,9 +149,9 @@ Cache.prototype.connect = async function() {
 			case 'cachebase':
 				try {
 					const {
-						cachebase_admin
+						cachebaseAdmin
 					} = require('mm_cachebase');
-					this.db = cachebase_admin(this.config.scope, this.config.cachebase);
+					this.db = cachebaseAdmin(this.config.scope, this.config.cachebase);
 				} catch (e) {
 					$.log.error('[Cache] [connect] CacheBase模块加载失败，无法初始化缓存:', e.message);
 					return false;
@@ -173,9 +161,9 @@ Cache.prototype.connect = async function() {
 			default: {
 				try {
 					const {
-						cachebase_admin
+						cachebaseAdmin
 					} = require('mm_cachebase');
-					this.db = cachebase_admin('default');
+					this.db = cachebaseAdmin('default');
 				} catch (e) {
 					$.log.error('[Cache] [connect] CacheBase模块加载失败，无法初始化缓存:', e.message);
 					return false;
@@ -198,7 +186,7 @@ Cache.prototype.connect = async function() {
  * @param {Object} config 可选配置
  * @return {Promise<Boolean>} 是否成功
  */
-Cache.prototype.switchCache = async function(way, config) {
+Cache.prototype.switchCache = async function (way, config) {
 	if (['cachebase', 'redis', 'mongodb', 'memory'].includes(way)) {
 		this.config.way = way;
 		if (config) {
@@ -214,7 +202,7 @@ Cache.prototype.switchCache = async function(way, config) {
  * @param {String} pattern 匹配模式
  * @return {Promise<Array>} 键名数组
  */
-Cache.prototype.keys = async function(pattern) {
+Cache.prototype.keys = async function (pattern) {
 	// 添加作用域前缀
 	const scopePattern = pattern ? `${this.scope}:${pattern}` : `${this.scope}:*`;
 	// 直接调用底层keys方法
@@ -226,7 +214,7 @@ Cache.prototype.keys = async function(pattern) {
  * @param {String} key 键名
  * @return {Promise<Boolean>} 是否存在
  */
-Cache.prototype.has = async function(key) {
+Cache.prototype.has = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	// 优先使用has方法，如果不存在则使用exists
@@ -243,7 +231,7 @@ Cache.prototype.has = async function(key) {
  * @param {Array} args 参数数组
  * @return {Promise<any>} 方法返回值
  */
-Cache.prototype._safeCall = async function(method, args = []) {
+Cache.prototype._safeCall = async function (method, args = []) {
 	if (!this.db) {
 		// 如果未连接，自动尝试连接
 		await this.connect();
@@ -258,7 +246,7 @@ Cache.prototype._safeCall = async function(method, args = []) {
 		return await this.db[method](...args);
 	}
 
-	// 降级处理：为常用方法提供内置实现
+	// 降级处理：仅为确实不存在的方法提供内置实现
 	switch (method) {
 		case 'strlen': {
 			const key = args[0];
@@ -306,39 +294,6 @@ Cache.prototype._safeCall = async function(method, args = []) {
 			}
 			return 'string';
 		}
-		case 'incrby': {
-			const [key, value] = args;
-			// 降级为addInt方法
-			return await this.db.addInt(key, value);
-		}
-		case 'decrby': {
-			const [key, value] = args;
-			// 降级为addInt方法，使用负值
-			return await this.db.addInt(key, -value);
-		}
-		case 'incrbyfloat': {
-			const [key, value] = args;
-			// 降级为addFloat方法
-			return await this.db.addFloat(key, value);
-		}
-		case 'mget': {
-			// 直接使用参数数组，不做额外处理
-			try {
-				// 并行获取多个键的值
-				const promises = args.map(async (key) => {
-					try {
-						return await this.db.get(key);
-					} catch (error) {
-						$.log.error(`[Cache] [_safeCall] mget获取键[${key}]失败:`, error);
-						return null;
-					}
-				});
-				return await Promise.all(promises);
-			} catch (error) {
-				$.log.error(`[Cache] [_safeCall] mget操作失败:`, error);
-				return [];
-			}
-		}
 		default:
 			// 如果方法不存在且没有降级实现，返回null
 			$.log.warn(`[Cache] [_safeCall] 不支持的方法: ${method}`);
@@ -353,7 +308,7 @@ Cache.prototype._safeCall = async function(method, args = []) {
  * @param {Number} seconds 秒
  * @return {Promise<Boolean>} 操作结果
  */
-Cache.prototype.add = async function(key, value, expire) {
+Cache.prototype.add = async function (key, value, expire) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	// 直接调用底层存储的原生add方法
@@ -367,7 +322,7 @@ Cache.prototype.add = async function(key, value, expire) {
  * @param {Number} expire 过期时间(秒)，默认不设置过期时间
  * @return {Promise<Boolean>} 是否设置成功
  */
-Cache.prototype.set = async function(key, value, expire) {
+Cache.prototype.set = async function (key, value, expire) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('set', [scopeKey, value, expire]);
@@ -378,7 +333,7 @@ Cache.prototype.set = async function(key, value, expire) {
  * @param {String} key 键名
  * @return {Promise<Any>} 缓存值
  */
-Cache.prototype.get = async function(key) {
+Cache.prototype.get = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('get', [scopeKey]);
@@ -389,7 +344,7 @@ Cache.prototype.get = async function(key) {
  * @param {String} key 键名
  * @return {Promise<Boolean>} 是否删除成功
  */
-Cache.prototype.del = async function(key) {
+Cache.prototype.del = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('del', [scopeKey]);
@@ -400,7 +355,7 @@ Cache.prototype.del = async function(key) {
  * @param {String} key 键名
  * @return {Promise<Boolean>} 是否存在
  */
-Cache.prototype.exists = async function(key) {
+Cache.prototype.exists = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('exists', [scopeKey]);
@@ -412,7 +367,7 @@ Cache.prototype.exists = async function(key) {
  * @param {Number} seconds 过期时间(秒)
  * @return {Promise<Boolean>} 是否设置成功
  */
-Cache.prototype.expire = async function(key, seconds) {
+Cache.prototype.expire = async function (key, seconds) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('expire', [scopeKey, seconds]);
@@ -424,10 +379,15 @@ Cache.prototype.expire = async function(key, seconds) {
  * @param {Number} seconds 过期时间(秒)，默认不设置过期时间
  * @return {Promise<Number>} 过期时间(秒)，-1表示永不过期，-2表示键不存在
  */
-Cache.prototype.ttl = async function(key, seconds) {
+Cache.prototype.ttl = async function (key, seconds) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
-	return await this._safeCall('ttl', [scopeKey, seconds]);
+	// 仅在seconds参数存在时才传递给底层方法
+	if (seconds !== undefined) {
+		return await this._safeCall('ttl', [scopeKey, seconds]);
+	} else {
+		return await this._safeCall('ttl', [scopeKey]);
+	}
 };
 
 /**
@@ -435,7 +395,7 @@ Cache.prototype.ttl = async function(key, seconds) {
  * @param {...String} keys 键名列表
  * @return {Array} 值数组，与键的顺序一致
  */
-Cache.prototype.mget = function() {
+Cache.prototype.mget = function () {
 	// 确保返回一个函数，满足测试脚本的检查
 	return async (...keys) => {
 		try {
@@ -466,7 +426,7 @@ Cache.prototype.mget = function() {
  * @param {Number} step 步长，默认1
  * @return {Promise<Number>} 递增后的值
  */
-Cache.prototype.incr = async function(key, step = 1) {
+Cache.prototype.incr = async function (key, step = 1) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	// 优先使用incr方法，如果不存在则使用addInt
@@ -483,7 +443,7 @@ Cache.prototype.incr = async function(key, step = 1) {
  * @param {Number} step 步长，默认1
  * @return {Promise<Number>} 递增后的值
  */
-Cache.prototype.addInt = async function(key, step = 1) {
+Cache.prototype.addInt = async function (key, step = 1) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('addInt', [scopeKey, step]);
@@ -495,7 +455,7 @@ Cache.prototype.addInt = async function(key, step = 1) {
  * @param {String} value 要追加的字符串
  * @return {Promise<Number>} 追加后的字符串长度
  */
-Cache.prototype.addStr = async function(key, value) {
+Cache.prototype.addStr = async function (key, value) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('addStr', [scopeKey, value]);
@@ -507,7 +467,7 @@ Cache.prototype.addStr = async function(key, value) {
  * @param {Number} step 步长，默认1.0
  * @return {Promise<Number>} 递增后的值
  */
-Cache.prototype.addFloat = async function(key, step = 1.0) {
+Cache.prototype.addFloat = async function (key, step = 1.0) {
 	// 确保step是数字类型
 	step = parseFloat(step) || 1.0;
 	// 添加作用域前缀
@@ -522,7 +482,7 @@ Cache.prototype.addFloat = async function(key, step = 1.0) {
  * @param {Object} options 配置选项
  * @return {Promise<Number>} 增加后的值
  */
-Cache.prototype.incrby = async function(key, value, options) {
+Cache.prototype.incrby = async function (key, value, options) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('incrby', [scopeKey, value], options);
@@ -535,7 +495,7 @@ Cache.prototype.incrby = async function(key, value, options) {
  * @param {Object} options 配置选项
  * @return {Promise<Number>} 减少后的值
  */
-Cache.prototype.decrby = async function(key, value, options) {
+Cache.prototype.decrby = async function (key, value, options) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('decrby', [scopeKey, value], options);
@@ -548,7 +508,7 @@ Cache.prototype.decrby = async function(key, value, options) {
  * @param {Object} options 配置选项
  * @return {Promise<Number>} 增加后的值
  */
-Cache.prototype.incrbyfloat = async function(key, value, options) {
+Cache.prototype.incrbyfloat = async function (key, value, options) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('incrbyfloat', [scopeKey, value], options);
@@ -559,7 +519,7 @@ Cache.prototype.incrbyfloat = async function(key, value, options) {
  * @param {Array} keyValues 键值对数组，格式: [key1, value1, key2, value2, ...]
  * @return {Promise<Boolean>} 是否设置成功
  */
-Cache.prototype.mset = async function(...keyValues) {
+Cache.prototype.mset = async function (...keyValues) {
 	// 添加作用域前缀到所有键名
 	const scopeKeyValues = [];
 	for (let i = 0; i < keyValues.length; i += 2) {
@@ -574,7 +534,7 @@ Cache.prototype.mset = async function(...keyValues) {
  * @param {Array} keys 键名数组
  * @return {Promise<Array>} 缓存值数组
  */
-Cache.prototype.mget = async function(...keys) {
+Cache.prototype.mget = async function (...keys) {
 	// 处理参数：如果第一个参数是数组，则使用该数组；否则使用所有参数作为数组
 	let keysToUse = keys;
 	if (keys.length === 1 && Array.isArray(keys[0])) {
@@ -593,7 +553,7 @@ Cache.prototype.mget = async function(...keys) {
  * @param {Any} value 字段值
  * @return {Promise<Number>} 1表示新字段，0表示更新已有字段
  */
-Cache.prototype.hset = async function(key, field, value) {
+Cache.prototype.hset = async function (key, field, value) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('hset', [scopeKey, field, value]);
@@ -605,7 +565,7 @@ Cache.prototype.hset = async function(key, field, value) {
  * @param {String} field 字段名
  * @return {Promise<Any>} 字段值
  */
-Cache.prototype.hget = async function(key, field) {
+Cache.prototype.hget = async function (key, field) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('hget', [scopeKey, field]);
@@ -616,7 +576,7 @@ Cache.prototype.hget = async function(key, field) {
  * @param {String} key 键名
  * @return {Promise<Object>} 所有字段和值
  */
-Cache.prototype.hgetall = async function(key) {
+Cache.prototype.hgetall = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('hgetall', [scopeKey]);
@@ -628,7 +588,7 @@ Cache.prototype.hgetall = async function(key) {
  * @param {String} field 字段名
  * @return {Promise<Number>} 删除的字段数量
  */
-Cache.prototype.hdel = async function(key, field) {
+Cache.prototype.hdel = async function (key, field) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('hdel', [scopeKey, field]);
@@ -640,7 +600,7 @@ Cache.prototype.hdel = async function(key, field) {
  * @param {Array} fieldValues 字段值对数组，格式: [field1, value1, field2, value2, ...]
  * @return {Promise<Number>} 设置的字段数量
  */
-Cache.prototype.hmset = async function(key, ...fieldValues) {
+Cache.prototype.hmset = async function (key, ...fieldValues) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('hmset', [scopeKey, ...fieldValues]);
@@ -652,7 +612,7 @@ Cache.prototype.hmset = async function(key, ...fieldValues) {
  * @param {Array} fields 字段名数组
  * @return {Promise<Array>} 字段值数组
  */
-Cache.prototype.hmget = async function(key, ...fields) {
+Cache.prototype.hmget = async function (key, ...fields) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('hmget', [scopeKey, ...fields]);
@@ -663,7 +623,7 @@ Cache.prototype.hmget = async function(key, ...fields) {
  * @param {String} key 键名
  * @return {Promise<Number>} 字段数量
  */
-Cache.prototype.hlen = async function(key) {
+Cache.prototype.hlen = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('hlen', [scopeKey]);
@@ -674,7 +634,7 @@ Cache.prototype.hlen = async function(key) {
  * @param {String} key 键名
  * @return {Promise<Number>} 字符串长度
  */
-Cache.prototype.strlen = async function(key) {
+Cache.prototype.strlen = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('strlen', [scopeKey]);
@@ -686,7 +646,7 @@ Cache.prototype.strlen = async function(key) {
  * @param {Array} members 成员数组
  * @return {Promise<Number>} 新增的成员数量
  */
-Cache.prototype.sadd = async function(key, ...members) {
+Cache.prototype.sadd = async function (key, ...members) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('sadd', [scopeKey, ...members]);
@@ -698,7 +658,7 @@ Cache.prototype.sadd = async function(key, ...members) {
  * @param {Array} members 成员数组
  * @return {Promise<Number>} 删除的成员数量
  */
-Cache.prototype.srem = async function(key, ...members) {
+Cache.prototype.srem = async function (key, ...members) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('srem', [scopeKey, ...members]);
@@ -710,7 +670,7 @@ Cache.prototype.srem = async function(key, ...members) {
  * @param {String} member 成员
  * @return {Promise<Boolean>} 是否存在
  */
-Cache.prototype.sismember = async function(key, member) {
+Cache.prototype.sismember = async function (key, member) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('sismember', [scopeKey, member]);
@@ -721,7 +681,7 @@ Cache.prototype.sismember = async function(key, member) {
  * @param {String} key 键名
  * @return {Promise<Array>} 成员数组
  */
-Cache.prototype.smembers = async function(key) {
+Cache.prototype.smembers = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('smembers', [scopeKey]);
@@ -733,7 +693,7 @@ Cache.prototype.smembers = async function(key) {
  * @param {Number} milliseconds 过期时间(毫秒)
  * @return {Promise<Boolean>} 是否设置成功
  */
-Cache.prototype.pexpire = async function(key, milliseconds) {
+Cache.prototype.pexpire = async function (key, milliseconds) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('pexpire', [scopeKey, milliseconds]);
@@ -744,7 +704,7 @@ Cache.prototype.pexpire = async function(key, milliseconds) {
  * @param {String} key 键名
  * @return {Promise<Boolean>} 是否移除成功
  */
-Cache.prototype.persist = async function(key) {
+Cache.prototype.persist = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('persist', [scopeKey]);
@@ -756,7 +716,7 @@ Cache.prototype.persist = async function(key) {
  * @param {String} newKey 新键名
  * @return {Promise<Boolean>} 是否重命名成功
  */
-Cache.prototype.rename = async function(oldKey, newKey) {
+Cache.prototype.rename = async function (oldKey, newKey) {
 	// 添加作用域前缀
 	const scopeOldKey = `${this.scope}:${oldKey}`;
 	const scopeNewKey = `${this.scope}:${newKey}`;
@@ -768,7 +728,7 @@ Cache.prototype.rename = async function(oldKey, newKey) {
  * @param {String} key 键名
  * @return {Promise<String>} 类型(none|string|list|set|zset|hash)
  */
-Cache.prototype.type = async function(key) {
+Cache.prototype.type = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('type', [scopeKey]);
@@ -781,7 +741,7 @@ Cache.prototype.type = async function(key) {
  * @param {Number} expire 过期时间（秒）
  * @return {Promise<Boolean>} 是否成功
  */
-Cache.prototype.setForList = async function(key, value, expire) {
+Cache.prototype.setForList = async function (key, value, expire) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('setForList', [scopeKey, value, expire]);
@@ -793,7 +753,7 @@ Cache.prototype.setForList = async function(key, value, expire) {
  * @param {*} value 要添加的元素
  * @return {Promise<Boolean>} 是否成功
  */
-Cache.prototype.addForList = async function(key, value) {
+Cache.prototype.addForList = async function (key, value) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('addForList', [scopeKey, value]);
@@ -805,7 +765,7 @@ Cache.prototype.addForList = async function(key, value) {
  * @param {*} value 要检查的元素
  * @return {Promise<Boolean>} 是否包含
  */
-Cache.prototype.hasForList = async function(key, value) {
+Cache.prototype.hasForList = async function (key, value) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('hasForList', [scopeKey, value]);
@@ -818,7 +778,7 @@ Cache.prototype.hasForList = async function(key, value) {
  * @param {Number} stop 结束索引，默认-1（表示到末尾）
  * @return {Promise<Array>} 元素数组
  */
-Cache.prototype.getForList = async function(key, start = 0, stop = -1) {
+Cache.prototype.getForList = async function (key, start = 0, stop = -1) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('getForList', [scopeKey, start, stop]);
@@ -829,7 +789,7 @@ Cache.prototype.getForList = async function(key, start = 0, stop = -1) {
  * @param {String} key 键名
  * @return {Promise<Boolean>} 是否成功
  */
-Cache.prototype.clearForList = async function(key) {
+Cache.prototype.clearForList = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = `${this.scope}:${key}`;
 	return await this._safeCall('clearForList', [scopeKey]);
@@ -840,7 +800,7 @@ Cache.prototype.clearForList = async function(key) {
  * @param {String} key 匹配模式
  * @return {Promise<Boolean>} 是否清理成功
  */
-Cache.prototype.clear = async function(key) {
+Cache.prototype.clear = async function (key) {
 	// 添加作用域前缀
 	const scopeKey = key ? `${this.scope}:${key}` : `${this.scope}:*`;
 	return await this._safeCall('clear', [scopeKey]);
@@ -850,7 +810,7 @@ Cache.prototype.clear = async function(key) {
  * @description 清理过期缓存
  * @return {Promise<Boolean>} 是否清理成功
  */
-Cache.prototype.clearExpire = async function() {
+Cache.prototype.clearExpire = async function () {
 	return await this._safeCall('clearExpire', []);
 };
 
@@ -858,7 +818,7 @@ Cache.prototype.clearExpire = async function() {
  * @description 关闭数据库连接
  * @return {Promise<Boolean>} 是否关闭成功
  */
-Cache.prototype.dispose = async function() {
+Cache.prototype.dispose = async function () {
 	if (this.db && typeof this.db.dispose === 'function') {
 		return await this.db.dispose();
 	}

package/package.json

@@ -1,14 +1,14 @@
 {
     "name": "mm_cache",
-    "version": "1.4.1",
-    "description": "这是超级美眉cache帮助函数模块，一个简单的内存+硬盘缓存",
+    "version": "1.4.3",
+    "description": "一个统一的缓存操作框架，为多种缓存方式（Redis、MongoDB、CacheBase、Memory）提供统一的API接口，实现无缝切换和兼容",
     "main": "index.js",
     "scripts": {
         "test": "node test.js"
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/qiuwenwu/mm_cache.git"
+        "url": "git+https://gitee.com/qiuwenwu/mm_cache.git"
     },
     "keywords": [
         "cache",
@@ -26,12 +26,12 @@
     "author": "邱文武",
     "license": "ISC",
     "bugs": {
-        "url": "https://github.com/qiuwenwu/mm_cache/issues"
+        "url": "https://gitee.com/qiuwenwu/mm_cache/issues"
     },
-    "homepage": "https://github.com/qiuwenwu/mm_cache#readme",
+    "homepage": "https://gitee.com/qiuwenwu/mm_cache#readme",
     "dependencies": {
-        "mm_cachebase": "^1.8.7",
-        "mm_mongodb": "^1.4.9",
-        "mm_redis": "^1.9.9"
+        "mm_cachebase": "^1.9.1",
+        "mm_mongodb": "^1.5.3",
+        "mm_redis": "^2.0.9"
     }
-}
+}

package/test.js

@@ -87,8 +87,8 @@ async function recordTestResult(cache, methodName, testFunction) {
         // 对关键方法失败时输出详细信息
         const criticalMethods = ['hdel', 'hmset', 'hmget', 'hlen', 'addForList', 'expire'];
         if (criticalMethods.includes(methodName)) {
-            console.error(`[Cache] ${cacheWay}.${methodName} 测试失败: ${error.message}`);
-            console.error(error.stack);
+            $.log.error(`[Cache] ${cacheWay}.${methodName} 测试失败: ${error.message}`);
+            $.log.error(error.stack);
         }
         
         // 检查是否是"不支持的方法"错误
@@ -448,19 +448,19 @@ function getUnsupportedReason(method) {
 
 // 测试单个缓存方式的所有方法
 async function testCacheWay(cacheWay) {
-    console.log(`\n[Cache] ==============================`);
-    console.log(`[Cache] 开始测试缓存方式: ${cacheWay}`);
-    console.log(`[Cache] ==============================`);
+    $.log.debug(`\n[Cache] ==============================`);
+    $.log.debug(`[Cache] 开始测试缓存方式: ${cacheWay}`);
+    $.log.debug(`[Cache] ==============================`);
     
     // 直接使用指定的缓存方式创建Cache实例
     const cache = new Cache(`test_${cacheWay}`, { way: cacheWay });
     const connected = await cache.connect();
     
     if (connected) {
-        console.log(`[Cache] 成功连接到缓存方式: ${cacheWay}`);
-        console.log(`[Cache] 当前实际缓存方式: ${cache.getCacheWay()}`);
+        $.log.debug(`[Cache] 成功连接到缓存方式: ${cacheWay}`);
+        $.log.debug(`[Cache] 当前实际缓存方式: ${cache.getCacheWay()}`);
     } else {
-        console.log(`[Cache] 无法连接到缓存方式: ${cacheWay}`);
+        $.log.debug(`[Cache] 无法连接到缓存方式: ${cacheWay}`);
         return false;
     }