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

package/package.json

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

package/src/cache.js

@@ -40,10 +40,17 @@ 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 +59,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);
@@ -67,29 +74,29 @@ module.exports = class Cache {
     if (savedData == null) {
       let result = await fn();
       if (!Param.isBlank(result)) {
-        let redisContent = "";
+        let saveContent = "";
         // 处理JSON
         if (result instanceof Object) {
           if (result.success === false) {
             console.log("Do not cache fail result");
           } else {
-            redisContent = JSON.stringify(result);
+            saveContent = JSON.stringify(result);
           }
         } else {
-          redisContent = result.toString();
+          saveContent = result.toString();
         }
-        if (redisContent != "") {
-          if (Cache._needZip(redisContent, zip)) {
-            redisContent = Cache._zip(redisContent);
+        if (saveContent != "") {
+          if (Cache._needZip(saveContent, zip)) {
+            saveContent = Cache._zip(saveContent);
           }
-          if (nas) {
-            Nas.set(fullKey, result, timeSecond);
+          if (useNas) {
+            Nas.set(fullKey, saveContent, timeSecond);
           } else {
-            await Redis.exec("setex", fullKey, timeSecond + "", redisContent);
+            await Redis.exec("setex", fullKey, timeSecond + "", saveContent);
           }
 
           // 本地缓存1分钟
-          Cache._setLocal(fullKey, redisContent, 60000);
+          Cache._setLocal(fullKey, saveContent, 60000);
         }
         return result;
       }
@@ -97,9 +104,9 @@ module.exports = class Cache {
       console.log("Found cache" + (hasLocal ? " local" : ""), fullKey);
       savedData = Cache._unzip(savedData);
       // 优先转成json
-      if (savedData.startsWith("{") || savedData.startsWith("[")) {
+      try {
         return JSON.parse(savedData);
-      } else {
+      } catch (e) {
         return savedData;
       }
     }

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)) {
@@ -94,7 +89,13 @@ class Nas {
       }
 
       // 读取缓存文件
-      const content = fs.readFileSync(filePath, "utf8");
+      let content;
+      try {
+        content = fs.readFileSync(filePath, "utf8");
+      } catch (e) {
+        console.warn("读取缓存文件失败:", filePath, e);
+        return null;
+      }
       const lines = content.split("\n");
 
       if (lines.length >= 2) {
@@ -106,10 +107,14 @@ class Nas {
         if (!isNaN(expireTime)) {
           if (expireTime === -1 || Date.now() < expireTime) {
             // 文件未过期，返回值
-            return Buffer.from(value, "base64").toString("utf8");
+            let valueStr = Buffer.from(value, "base64").toString("utf8");
+            try {
+              return JSON.parse(valueStr);
+            } catch (e) {
+              // 如果解析JSON失败，则返回原始字符串
+              return valueStr;
+            }
           } else {
-            // 文件已过期，删除文件
-            this.deleteCacheFile(key);
             return null;
           }
         }
@@ -127,17 +132,28 @@ 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 valueStr = typeof value === "object" ? JSON.stringify(value) : value;
+    const content = Buffer.from(valueStr, "utf8").toString("base64");
+    const filePath = Nas._getFilePath(key);
 
     try {
+      // 创建临时文件名，避免写入过程中的并发问题
+      const tempFilePath = filePath + ".tmp";
       // 写入过期时间戳和值，用换行符分隔
       const fileContent = `${expireTime}\n${content}`;
-      fs.writeFileSync(filePath, fileContent, "utf8");
+      fs.writeFileSync(tempFilePath, fileContent, "utf8");
+      // 原子性地替换原文件
+      fs.renameSync(tempFilePath, filePath);
     } catch (e) {
       console.error("保存缓存文件失败:", filePath, e);
+      // 如果临时文件创建失败，清理临时文件
+      try {
+        fs.unlinkSync(filePath + ".tmp");
+      } catch (cleanupError) {
+        // 忽略清理错误
+      }
     }
   }
 
@@ -145,8 +161,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,26 +177,47 @@ 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);
-            fs.unlinkSync(filePath);
+            const filePath = path.join(cacheDir, file);
+            // 检查文件是否过期超过一分钟，如果超过则删除
+            try {
+              if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, "utf8");
+                const lines = content.split("\n");
+
+                if (lines.length >= 1) {
+                  const expireTimeString = lines[0];
+                  const expireTime = parseInt(expireTimeString);
+
+                  if (
+                    !isNaN(expireTime) &&
+                    expireTime !== -1 &&
+                    // 仅删除过期超过一分钟的文件
+                    Date.now() > expireTime + 60 * 1000
+                  ) {
+                    console.log("删除过期缓存文件:", filePath);
+                    fs.unlinkSync(filePath);
+                  }
+                }
+              }
+            } catch (e) {
+              console.warn("检查缓存文件过期时间失败:", filePath, e);
+            }
           }
         }
       }
@@ -194,11 +231,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 +244,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 +256,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)) {
@@ -241,8 +278,6 @@ class Nas {
             const remainingTime = Math.floor((expireTime - Date.now()) / 1000);
             return Math.max(0, remainingTime); // 确保返回非负值
           } else {
-            // 文件已过期，删除文件
-            this.deleteCacheFile(key);
             return -1;
           }
         }

package/test/test-nas.js

@@ -2,100 +2,121 @@ 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 set and get a string object", function () {
+    const target = [
+      {
+        id: 128910,
+        supplierCode: "9c6d1ab7ff7a440eba1516b164c06632",
+        status: 1,
+        city: "",
+      },
+    ];
+    Nas.set("testObject", target);
+    const value = Nas.get("testObject");
+    assert.deepStrictEqual(value, target);
+  });
+
   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");
+  it("should flush only expired cache entries", function (done) {
+    // 设置一个永不过期的键
+    Nas.set("permanentKey", "permanentValue", -1);
+    // 设置一个会过期的键
+    Nas.set("expiringKey", "expiringValue", 0.5); // 0.5秒后过期
 
-    assert.isTrue(nas.exists("flushTest1"));
-    assert.isTrue(nas.exists("flushTest2"));
+    setTimeout(() => {
+      // 此时expiringKey已经过期，但是permanentKey仍然有效
+      Nas.flushAll(); // 应该只清除过期的键
 
-    nas.flushAll();
+      // 永不过期的键应该仍然存在
+      assert(Nas.get("permanentKey") == "permanentValue");
+      // 过期的键应该已经被清除
+      assert(Nas.get("expiringKey") == null);
+      assert(Nas.exists("expiringKey") == false);
 
-    assert.isFalse(nas.exists("flushTest1"));
-    assert.isFalse(nas.exists("flushTest2"));
+      // 清理测试数据
+      Nas.del("permanentKey");
+      done();
+    }, 1000); // 等待expiringKey过期后再测试
   });
 
   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");
   });
 });