@less-is-more/less-js 1.5.0-1 → 1.5.0-3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@less-is-more/less-js",
-  "version": "1.5.0-1",
+  "version": "1.5.0-3",
   "description": "Fast develop kit for nodejs",
   "main": "src/index.js",
   "scripts": {

package/src/cache.js

@@ -40,10 +40,10 @@ module.exports = class Cache {
    * @param {*} args 直接传arguments，用于拼接缓存key
    * @param {function} fn 没有缓存的实现
    * @param {boolean} zip 是否压缩
-   * @param {boolean} nas 是否使用Nas缓存
+   * @param {boolean} useNas 是否使用Nas缓存
    * @returns 优先返回对象
    */
-  static async auto(keyPrefix, timeSecond, args, fn, zip = false, nas = false) {
+  static async auto(keyPrefix, timeSecond, args, fn, zip = false, useNas = false) {
     let fullKey = keyPrefix;
     for (let i = 0; i < args.length; i++) {
       fullKey += ":" + args[i].toString();
@@ -52,7 +52,7 @@ module.exports = class Cache {
     let savedData = Cache._getLocal(fullKey);
     let hasLocal = false;
     if (Param.isBlank(savedData)) {
-      if (nas) {
+      if (useNas) {
         savedData = Nas.get(fullKey);
       } else {
         savedData = await Redis.exec("get", fullKey);
@@ -82,7 +82,7 @@ module.exports = class Cache {
           if (Cache._needZip(redisContent, zip)) {
             redisContent = Cache._zip(redisContent);
           }
-          if (nas) {
+          if (useNas) {
             Nas.set(fullKey, result, timeSecond);
           } else {
             await Redis.exec("setex", fullKey, timeSecond + "", redisContent);

package/src/nas.js

@@ -8,20 +8,23 @@ const os = require("os");
  * 适用于多服务器共享NAS存储
  */
 class Nas {
-  constructor(cacheDir = null) {
+  static _getCacheDir() {
+    let cacheDir = null;
+
     // 如果提供了缓存目录参数，则使用该目录，否则使用默认目录
     const defaultCacheDir = path.join(os.tmpdir(), "cache");
-    this.cacheDir =
+    cacheDir =
       cacheDir || (fs.existsSync("/cache") ? "/cache" : defaultCacheDir);
 
     // 确保缓存目录存在
     try {
-      if (!fs.existsSync(this.cacheDir)) {
-        fs.mkdirSync(this.cacheDir, { recursive: true });
+      if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
       }
     } catch (e) {
-      console.error("创建缓存目录失败:", this.cacheDir, e);
+      console.error("创建缓存目录失败:", cacheDir, e);
     }
+    return cacheDir;
   }
 
   /**
@@ -29,8 +32,8 @@ class Nas {
    * @param {string} key - 缓存键
    * @returns {any} 缓存值，如果过期或不存在则返回null
    */
-  get(key) {
-    return this.loadFromDisk(key);
+  static get(key) {
+    return Nas._loadFromDisk(key);
   }
 
   /**
@@ -39,8 +42,8 @@ class Nas {
    * @param {any} defaultValue - 默认值
    * @returns {any} 缓存值或默认值
    */
-  getOrDefault(key, defaultValue) {
-    const value = this.get(key);
+  static getOrDefault(key, defaultValue) {
+    const value = Nas.get(key);
     return value !== null ? value : defaultValue;
   }
 
@@ -50,9 +53,9 @@ class Nas {
    * @param {any} value - 缓存值
    * @param {number} timeout - 超时时间（秒），-1表示永不过期
    */
-  set(key, value, timeout = -1) {
+  static set(key, value, timeout = -1) {
     const expireTime = timeout === -1 ? -1 : Date.now() + timeout * 1000;
-    this.saveToDisk(key, value, expireTime);
+    Nas._saveToDisk(key, value, expireTime);
   }
 
   /**
@@ -60,24 +63,16 @@ class Nas {
    * @param {string} key - 缓存键
    * @returns {boolean} 是否存在且未过期
    */
-  exists(key) {
-    return this.get(key) !== null;
-  }
-
-  /**
-   * 获取缓存目录路径
-   * @returns {string} 缓存目录路径
-   */
-  getCacheDir() {
-    return this.cacheDir;
+  static exists(key) {
+    return Nas.get(key) !== null;
   }
 
   /**
    * 删除指定的缓存项
    * @param {string} key - 缓存键
    */
-  del(key) {
-    this.deleteCacheFile(key);
+  static del(key) {
+    Nas._deleteCacheFile(key);
   }
 
   /**
@@ -85,8 +80,8 @@ class Nas {
    * @param {string} key - 缓存键
    * @returns {any} 缓存值，如果过期或不存在则返回null
    */
-  loadFromDisk(key) {
-    const filePath = this.getFilePath(key);
+  static _loadFromDisk(key) {
+    const filePath = Nas._getFilePath(key);
 
     try {
       if (!fs.existsSync(filePath)) {
@@ -109,7 +104,7 @@ class Nas {
             return Buffer.from(value, "base64").toString("utf8");
           } else {
             // 文件已过期，删除文件
-            this.deleteCacheFile(key);
+            Nas._deleteCacheFile(key);
             return null;
           }
         }
@@ -127,10 +122,10 @@ class Nas {
    * @param {any} value - 缓存值
    * @param {number} expireTime - 过期时间戳，-1表示永不过期
    */
-  saveToDisk(key, value, expireTime) {
+  static _saveToDisk(key, value, expireTime) {
     // 将值转换为字符串，如果是对象则转换为JSON字符串
     const content = Buffer.from(value, "utf8").toString("base64");
-    const filePath = this.getFilePath(key);
+    const filePath = Nas._getFilePath(key);
 
     try {
       // 写入过期时间戳和值，用换行符分隔
@@ -145,8 +140,8 @@ class Nas {
    * 删除缓存文件
    * @param {string} key - 缓存键
    */
-  deleteCacheFile(key) {
-    const filePath = this.getFilePath(key);
+  static _deleteCacheFile(key) {
+    const filePath = Nas._getFilePath(key);
     try {
       if (fs.existsSync(filePath)) {
         fs.unlinkSync(filePath);
@@ -161,25 +156,23 @@ class Nas {
    * @param {string} key - 缓存键
    * @returns {string} 文件路径
    */
-  getFilePath(key) {
+  static _getFilePath(key) {
     // 为键生成安全的文件名
     const safeKey = key.replace(/[^a-zA-Z0-9-_.]/g, "_");
-    return path.join(this.cacheDir, `${safeKey}.cache`);
+    return path.join(Nas._getCacheDir(), `${safeKey}.cache`);
   }
 
   /**
    * 清空所有缓存
    */
-  flushAll() {
+  static flushAll() {
     try {
-      if (
-        fs.existsSync(this.cacheDir) &&
-        fs.statSync(this.cacheDir).isDirectory()
-      ) {
-        const files = fs.readdirSync(this.cacheDir);
+      const cacheDir = Nas._getCacheDir();
+      if (fs.existsSync(cacheDir) && fs.statSync(cacheDir).isDirectory()) {
+        const files = fs.readdirSync(cacheDir);
         for (const file of files) {
           if (file.endsWith(".cache")) {
-            const filePath = path.join(this.cacheDir, file);
+            const filePath = path.join(cacheDir, file);
             fs.unlinkSync(filePath);
           }
         }
@@ -194,11 +187,11 @@ class Nas {
    * @param {string} key - 缓存键
    * @param {number} second - 过期时间（秒）
    */
-  expire(key, second) {
-    const currentValue = this.get(key);
+  static expire(key, second) {
+    const currentValue = Nas.get(key);
     if (currentValue !== null) {
       const expireTime = Date.now() + second * 1000;
-      this.saveToDisk(key, currentValue, expireTime);
+      Nas._saveToDisk(key, currentValue, expireTime);
     }
   }
 
@@ -207,10 +200,10 @@ class Nas {
    * @param {string} key - 缓存键
    * @param {number} expireTime - 过期时间戳（毫秒）
    */
-  expireAt(key, expireTime) {
-    const currentValue = this.get(key);
+  static expireAt(key, expireTime) {
+    const currentValue = Nas.get(key);
     if (currentValue !== null) {
-      this.saveToDisk(key, currentValue, expireTime);
+      Nas._saveToDisk(key, currentValue, expireTime);
     }
   }
 
@@ -219,8 +212,8 @@ class Nas {
    * @param {string} key - 缓存键
    * @returns {number} 剩余生存时间（秒），如果不存在或已过期则返回-1
    */
-  ttl(key) {
-    const filePath = this.getFilePath(key);
+  static ttl(key) {
+    const filePath = Nas._getFilePath(key);
 
     try {
       if (!fs.existsSync(filePath)) {
@@ -242,7 +235,7 @@ class Nas {
             return Math.max(0, remainingTime); // 确保返回非负值
           } else {
             // 文件已过期，删除文件
-            this.deleteCacheFile(key);
+            Nas._deleteCacheFile(key);
             return -1;
           }
         }

package/test/test-nas.js

@@ -2,100 +2,98 @@ const Nas = require("../src/nas");
 const assert = require("assert");
 
 describe("Nas Class Tests", function () {
-  let nas = new Nas();
-
   it("should set and get a string value", function () {
-    nas.set("testKey", "testValue");
-    const value = nas.get("testKey");
+    Nas.set("testKey", "testValue");
+    const value = Nas.get("testKey");
     assert.equal(value, "testValue");
   });
 
   it("should handle expiration correctly", function (done) {
-    nas.set("expiringKey", "expiringValue", 1); // 1秒后过期
+    Nas.set("expiringKey", "expiringValue", 1); // 1秒后过期
 
     setTimeout(() => {
-      const expiredValue = nas.get("expiringKey");
+      const expiredValue = Nas.get("expiringKey");
       assert.equal(expiredValue, null);
       done();
     }, 1100);
   });
 
   it("should return null for expired keys", function () {
-    nas.set("shortLivedKey", "value", 0.5); // 0.5秒后过期
+    Nas.set("shortLivedKey", "value", 0.5); // 0.5秒后过期
     setTimeout(() => {
-      const value = nas.get("shortLivedKey");
+      const value = Nas.get("shortLivedKey");
       assert.equal(value, null);
     }, 1000);
   });
 
   it("should check if key exists", function () {
-    nas.set("existKey", "value");
-    assert(nas.exists("existKey"));
-    assert(nas.exists("nonExistKey") == false);
+    Nas.set("existKey", "value");
+    assert(Nas.exists("existKey"));
+    assert(Nas.exists("nonExistKey") == false);
   });
 
   it("should delete a key", function () {
-    nas.set("deleteKey", "value");
-    assert(nas.exists("deleteKey"));
-    nas.del("deleteKey");
-    assert(nas.exists("deleteKey") == false);
+    Nas.set("deleteKey", "value");
+    assert(Nas.exists("deleteKey"));
+    Nas.del("deleteKey");
+    assert(Nas.exists("deleteKey") == false);
   });
 
   it("should return default value when key does not exist", function () {
-    const defaultValue = nas.getOrDefault("nonExistingKey", "default");
+    const defaultValue = Nas.getOrDefault("nonExistingKey", "default");
     assert.equal(defaultValue, "default");
   });
 
   it("should return actual value when key exists with getOrDefault", function () {
-    nas.set("existingKey", "actualValue");
-    const value = nas.getOrDefault("existingKey", "defaultValue");
+    Nas.set("existingKey", "actualValue");
+    const value = Nas.getOrDefault("existingKey", "defaultValue");
     assert.equal(value, "actualValue");
   });
 
   it("should handle expiration with expire method", function (done) {
-    nas.set("expireTest", "value", 10); // 设置10秒后过期
-    const initialTtl = nas.ttl("expireTest");
+    Nas.set("expireTest", "value", 10); // 设置10秒后过期
+    const initialTtl = Nas.ttl("expireTest");
     assert(initialTtl > 5); // 初始TTL应该大于5秒
 
-    nas.expire("expireTest", 1); // 重新设置为1秒后过期
-    const updatedTtl = nas.ttl("expireTest");
+    Nas.expire("expireTest", 1); // 重新设置为1秒后过期
+    const updatedTtl = Nas.ttl("expireTest");
     assert(updatedTtl <= 1); // TTL应该小于等于1秒
 
     setTimeout(() => {
-      const expiredTtl = nas.ttl("expireTest");
+      const expiredTtl = Nas.ttl("expireTest");
       assert.equal(expiredTtl, -1); // 已过期，返回-1
       done();
     }, 1100);
   });
 
   it("should handle expiration with expireAt method", function (done) {
-    nas.set("expireAtTest", "value");
+    Nas.set("expireAtTest", "value");
     const futureTime = Date.now() + 1000; // 1秒后
-    nas.expireAt("expireAtTest", futureTime);
+    Nas.expireAt("expireAtTest", futureTime);
 
     setTimeout(() => {
-      const expiredAtValue = nas.get("expireAtTest");
+      const expiredAtValue = Nas.get("expireAtTest");
       assert(expiredAtValue == null); // 已过期，应该返回null
       done();
     }, 1100);
   });
 
   it("should flush all cache entries", function () {
-    nas.set("flushTest1", "value1");
-    nas.set("flushTest2", "value2");
+    Nas.set("flushTest1", "value1");
+    Nas.set("flushTest2", "value2");
 
-    assert.isTrue(nas.exists("flushTest1"));
-    assert.isTrue(nas.exists("flushTest2"));
+    assert.isTrue(Nas.exists("flushTest1"));
+    assert.isTrue(Nas.exists("flushTest2"));
 
-    nas.flushAll();
+    Nas.flushAll();
 
-    assert.isFalse(nas.exists("flushTest1"));
-    assert.isFalse(nas.exists("flushTest2"));
+    assert.isFalse(Nas.exists("flushTest1"));
+    assert.isFalse(Nas.exists("flushTest2"));
   });
 
   it("should handle non-expiring keys (timeout = -1)", function () {
-    nas.set("permanentKey", "permanentValue", -1);
-    const value = nas.get("permanentKey");
+    Nas.set("permanentKey", "permanentValue", -1);
+    const value = Nas.get("permanentKey");
     assert.equal(value, "permanentValue");
   });
 });