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

package/package.json

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

package/src/cache.js

@@ -1,6 +1,7 @@
 const Redis = require("./redis");
 const Param = require("./param");
 const zlib = require("zlib");
+const Nas = require("./nas");
 
 module.exports = class Cache {
   /**
@@ -39,9 +40,17 @@ module.exports = class Cache {
    * @param {*} args 直接传arguments，用于拼接缓存key
    * @param {function} fn 没有缓存的实现
    * @param {boolean} zip 是否压缩
+   * @param {boolean} useNas 是否使用Nas缓存
    * @returns 优先返回对象
    */
-  static async auto(keyPrefix, timeSecond, args, fn, zip = 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();
@@ -50,7 +59,11 @@ module.exports = class Cache {
     let savedData = Cache._getLocal(fullKey);
     let hasLocal = false;
     if (Param.isBlank(savedData)) {
-      savedData = await Redis.exec("get", fullKey);
+      if (useNas) {
+        savedData = Nas.get(fullKey);
+      } else {
+        savedData = await Redis.exec("get", fullKey);
+      }
       if (!Param.isBlank(savedData)) {
         // 本地缓存1分钟
         Cache._setLocal(fullKey, savedData, 60000);
@@ -61,24 +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 (useNas) {
+            Nas.set(fullKey, saveContent, timeSecond);
+          } else {
+            await Redis.exec("setex", fullKey, timeSecond + "", saveContent);
           }
-          await Redis.exec("setex", fullKey, timeSecond + "", redisContent);
+
           // 本地缓存1分钟
-          Cache._setLocal(fullKey, redisContent, 60000);
+          Cache._setLocal(fullKey, saveContent, 60000);
         }
         return result;
       }
@@ -86,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/index.js

@@ -9,6 +9,7 @@ var Service = require("./service.js");
 var Oss = require("./oss.js");
 var GroupMessage = require("./group-message.js");
 var JsonKit = require("./json-kit.js");
+var Nas = require("./nas.js");
 module.exports = {
   Ret,
   Router,
@@ -21,4 +22,5 @@ module.exports = {
   Oss,
   GroupMessage,
   JsonKit,
+  Nas,
 };

package/src/nas.js

@@ -0,0 +1,293 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+/**
+ * 本地硬盘缓存实现类
+ * 提供类似Redis的缓存功能，支持超时时间
+ * 适用于多服务器共享NAS存储
+ */
+class Nas {
+  static _getCacheDir() {
+    let cacheDir = null;
+
+    // 如果提供了缓存目录参数，则使用该目录，否则使用默认目录
+    const defaultCacheDir = path.join(os.tmpdir(), "cache");
+    cacheDir =
+      cacheDir || (fs.existsSync("/cache") ? "/cache" : defaultCacheDir);
+
+    // 确保缓存目录存在
+    try {
+      if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+      }
+    } catch (e) {
+      console.error("创建缓存目录失败:", cacheDir, e);
+    }
+    return cacheDir;
+  }
+
+  /**
+   * 获取缓存值
+   * @param {string} key - 缓存键
+   * @returns {any} 缓存值，如果过期或不存在则返回null
+   */
+  static get(key) {
+    return Nas._loadFromDisk(key);
+  }
+
+  /**
+   * 获取缓存值，如果不存在则返回默认值
+   * @param {string} key - 缓存键
+   * @param {any} defaultValue - 默认值
+   * @returns {any} 缓存值或默认值
+   */
+  static getOrDefault(key, defaultValue) {
+    const value = Nas.get(key);
+    return value !== null ? value : defaultValue;
+  }
+
+  /**
+   * 设置缓存值
+   * @param {string} key - 缓存键
+   * @param {any} value - 缓存值
+   * @param {number} timeout - 超时时间（秒），-1表示永不过期
+   */
+  static set(key, value, timeout = -1) {
+    const expireTime = timeout === -1 ? -1 : Date.now() + timeout * 1000;
+    Nas._saveToDisk(key, value, expireTime);
+  }
+
+  /**
+   * 检查缓存是否存在且未过期
+   * @param {string} key - 缓存键
+   * @returns {boolean} 是否存在且未过期
+   */
+  static exists(key) {
+    return Nas.get(key) !== null;
+  }
+
+  /**
+   * 删除指定的缓存项
+   * @param {string} key - 缓存键
+   */
+  static del(key) {
+    Nas._deleteCacheFile(key);
+  }
+
+  /**
+   * 从硬盘加载缓存值
+   * @param {string} key - 缓存键
+   * @returns {any} 缓存值，如果过期或不存在则返回null
+   */
+  static _loadFromDisk(key) {
+    const filePath = Nas._getFilePath(key);
+
+    try {
+      if (!fs.existsSync(filePath)) {
+        return null;
+      }
+
+      // 读取缓存文件
+      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) {
+        const expireTimeString = lines[0];
+        const value = lines.slice(1).join("\n"); // 处理值中可能包含换行符的情况
+
+        const expireTime = parseInt(expireTimeString);
+
+        if (!isNaN(expireTime)) {
+          if (expireTime === -1 || Date.now() < expireTime) {
+            // 文件未过期，返回值
+            let valueStr = Buffer.from(value, "base64").toString("utf8");
+            try {
+              return JSON.parse(valueStr);
+            } catch (e) {
+              // 如果解析JSON失败，则返回原始字符串
+              return valueStr;
+            }
+          } else {
+            return null;
+          }
+        }
+      }
+    } catch (e) {
+      console.warn("读取缓存文件失败:", filePath, e);
+    }
+
+    return null;
+  }
+
+  /**
+   * 保存缓存值到硬盘
+   * @param {string} key - 缓存键
+   * @param {any} value - 缓存值
+   * @param {number} expireTime - 过期时间戳，-1表示永不过期
+   */
+  static _saveToDisk(key, value, expireTime) {
+    // 将值转换为字符串，如果是对象则转换为JSON字符串
+    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(tempFilePath, fileContent, "utf8");
+      // 原子性地替换原文件
+      fs.renameSync(tempFilePath, filePath);
+    } catch (e) {
+      console.error("保存缓存文件失败:", filePath, e);
+      // 如果临时文件创建失败，清理临时文件
+      try {
+        fs.unlinkSync(filePath + ".tmp");
+      } catch (cleanupError) {
+        // 忽略清理错误
+      }
+    }
+  }
+
+  /**
+   * 删除缓存文件
+   * @param {string} key - 缓存键
+   */
+  static _deleteCacheFile(key) {
+    const filePath = Nas._getFilePath(key);
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    } catch (e) {
+      console.warn("删除缓存文件失败:", filePath, e);
+    }
+  }
+
+  /**
+   * 获取缓存文件路径
+   * @param {string} key - 缓存键
+   * @returns {string} 文件路径
+   */
+  static _getFilePath(key) {
+    // 为键生成安全的文件名
+    const safeKey = key.replace(/[^a-zA-Z0-9-_.]/g, "_");
+    return path.join(Nas._getCacheDir(), `${safeKey}.cache`);
+  }
+
+  /**
+   * 清空所有过期缓存
+   */
+  static flushAll() {
+    try {
+      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(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);
+            }
+          }
+        }
+      }
+    } catch (e) {
+      console.error("清空缓存失败", e);
+    }
+  }
+
+  /**
+   * 设置指定键的过期时间
+   * @param {string} key - 缓存键
+   * @param {number} second - 过期时间（秒）
+   */
+  static expire(key, second) {
+    const currentValue = Nas.get(key);
+    if (currentValue !== null) {
+      const expireTime = Date.now() + second * 1000;
+      Nas._saveToDisk(key, currentValue, expireTime);
+    }
+  }
+
+  /**
+   * 设置指定键的过期时间戳
+   * @param {string} key - 缓存键
+   * @param {number} expireTime - 过期时间戳（毫秒）
+   */
+  static expireAt(key, expireTime) {
+    const currentValue = Nas.get(key);
+    if (currentValue !== null) {
+      Nas._saveToDisk(key, currentValue, expireTime);
+    }
+  }
+
+  /**
+   * 获取指定键的剩余生存时间
+   * @param {string} key - 缓存键
+   * @returns {number} 剩余生存时间（秒），如果不存在或已过期则返回-1
+   */
+  static ttl(key) {
+    const filePath = Nas._getFilePath(key);
+
+    try {
+      if (!fs.existsSync(filePath)) {
+        return -1;
+      }
+
+      // 读取缓存文件
+      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)) {
+          if (Date.now() < expireTime) {
+            // 文件未过期，计算剩余时间
+            const remainingTime = Math.floor((expireTime - Date.now()) / 1000);
+            return Math.max(0, remainingTime); // 确保返回非负值
+          } else {
+            return -1;
+          }
+        }
+      }
+    } catch (e) {
+      console.warn("读取缓存文件失败:", filePath, e);
+    }
+
+    return -1;
+  }
+}
+
+module.exports = Nas;

package/test/test-nas.js

@@ -0,0 +1,122 @@
+const Nas = require("../src/nas");
+const assert = require("assert");
+
+describe("Nas Class Tests", function () {
+  it("should set and get a string value", function () {
+    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秒后过期
+
+    setTimeout(() => {
+      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秒后过期
+    setTimeout(() => {
+      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);
+  });
+
+  it("should delete a key", function () {
+    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");
+    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");
+    assert.equal(value, "actualValue");
+  });
+
+  it("should handle expiration with expire method", function (done) {
+    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");
+    assert(updatedTtl <= 1); // TTL应该小于等于1秒
+
+    setTimeout(() => {
+      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");
+    const futureTime = Date.now() + 1000; // 1秒后
+    Nas.expireAt("expireAtTest", futureTime);
+
+    setTimeout(() => {
+      const expiredAtValue = Nas.get("expireAtTest");
+      assert(expiredAtValue == null); // 已过期，应该返回null
+      done();
+    }, 1100);
+  });
+
+  it("should flush only expired cache entries", function (done) {
+    // 设置一个永不过期的键
+    Nas.set("permanentKey", "permanentValue", -1);
+    // 设置一个会过期的键
+    Nas.set("expiringKey", "expiringValue", 0.5); // 0.5秒后过期
+
+    setTimeout(() => {
+      // 此时expiringKey已经过期，但是permanentKey仍然有效
+      Nas.flushAll(); // 应该只清除过期的键
+
+      // 永不过期的键应该仍然存在
+      assert(Nas.get("permanentKey") == "permanentValue");
+      // 过期的键应该已经被清除
+      assert(Nas.get("expiringKey") == null);
+      assert(Nas.exists("expiringKey") == false);
+
+      // 清理测试数据
+      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");
+    assert.equal(value, "permanentValue");
+  });
+});