@less-is-more/less-js 1.5.3-0 → 2.0.0-0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@less-is-more/less-js",
-  "version": "1.5.3-0",
+  "version": "2.0.0-0",
   "description": "Fast develop kit for nodejs",
   "main": "src/index.js",
   "scripts": {
@@ -32,7 +32,8 @@
     "redis": "^4.0.1",
     "sequelize": "^6.13.0",
     "uuid": "^9.0.0",
-    "validator": "^13.7.0"
+    "validator": "^13.7.0",
+    "zstd-codec": "^0.1.5"
   },
   "devDependencies": {
     "mocha": "^9.1.3",

package/src/cache.js

@@ -2,17 +2,35 @@ const Redis = require("./redis");
 const Param = require("./param");
 const zlib = require("zlib");
 const Nas = require("./nas");
+const { ZstdCodec } = require("zstd-codec");
 
 module.exports = class Cache {
   static printLog = true;
+  static _zstd = null;
+  static _zstdInitPromise = null;
 
   /*
    * 设置是否打印日志
    * @param {boolean} printLog
-  */
+   */
   static setPrintLog(printLog) {
     Cache.printLog = printLog;
   }
+
+  /**
+   * 初始化 zstd 压缩（首次压缩时自动调用，也可提前调用）
+   */
+  static async initZstd() {
+    if (Cache._zstd) return;
+    if (Cache._zstdInitPromise) return Cache._zstdInitPromise;
+    Cache._zstdInitPromise = new Promise((resolve) => {
+      ZstdCodec.run((zstd) => {
+        Cache._zstd = new zstd.Simple();
+        resolve();
+      });
+    });
+    return Cache._zstdInitPromise;
+  }
   /**
    * 缓存并获取结果（调用方）
    * @param {*} key 缓存关键词，拼接参数
@@ -66,30 +84,32 @@ module.exports = class Cache {
     for (let i = 0; i < args.length; i++) {
       fullKey += ":" + args[i].toString();
     }
-    // 先从本地缓存取
+    // 多参数的不做本地缓存，避免爆内存
+    const canLocalCache = args.length === 0;
+
+    // 先从本地缓存取（本地缓存存的是反序列化后的对象，命中时跳过JSON.parse）
     let savedData = Cache._getLocal(fullKey);
-    let hasLocal = false;
+    let hasLocal = savedData !== null;
+
     if (Param.isBlank(savedData)) {
       if (useNas) {
         savedData = Nas.get(fullKey);
       } else {
         savedData = await Redis.exec("get", fullKey);
       }
-      if (!Param.isBlank(savedData)) {
-        // 本地缓存1分钟
-        Cache._setLocal(fullKey, savedData, 60000);
-      }
-    } else {
-      hasLocal = true;
     }
-    if (savedData == null) {
+
+    if (Param.isBlank(savedData)) {
+      // 无缓存，执行函数获取结果
       let result = await fn();
       if (!Param.isBlank(result)) {
         let saveContent = "";
         // 处理JSON
         if (result instanceof Object) {
           if (result.success === false) {
-            console.log("Do not cache fail result");
+            if (Cache.printLog) {
+              console.log("Do not cache fail result");
+            }
           } else {
             saveContent = JSON.stringify(result);
           }
@@ -97,8 +117,8 @@ module.exports = class Cache {
           saveContent = result.toString();
         }
         if (saveContent != "") {
-          if (Cache._needZip(saveContent, zip)) {
-            saveContent = Cache._zip(saveContent);
+          if (zip) {
+            saveContent = await Cache._zip(saveContent);
           }
           if (useNas) {
             Nas.set(fullKey, saveContent, timeSecond);
@@ -106,54 +126,147 @@ module.exports = class Cache {
             await Redis.exec("setex", fullKey, timeSecond + "", saveContent);
           }
 
-          // 本地缓存1分钟
-          Cache._setLocal(fullKey, saveContent, 60000);
+          // 本地缓存直接存结果对象，下次命中跳过反序列化
+          if (canLocalCache) {
+            Cache._setLocal(fullKey, result, 60000);
+          }
         }
         return result;
       }
     } else {
+      // 有缓存（本地缓存或Nas/Redis）
+      if (hasLocal) {
+        // 本地缓存命中，直接返回已解析的对象，跳过反序列化
+        if (Cache.printLog) {
+          console.log("Found cache local", fullKey);
+        }
+        return savedData;
+      }
       if (Cache.printLog) {
-        console.log("Found cache" + (hasLocal ? " local" : ""), fullKey);
+        console.log("Found cache", fullKey);
       }
-      savedData = Cache._unzip(savedData);
+      savedData = await Cache._unzip(savedData);
+      let result;
       if (typeof savedData === "string") {
         // 优先转成json
         try {
-          return JSON.parse(savedData);
+          result = JSON.parse(savedData);
         } catch (e) {
-          return savedData;
+          result = savedData;
         }
       } else {
-        return savedData;
+        result = savedData;
+      }
+      // 本地缓存存解析后的对象，下次命中跳过反序列化
+      if (canLocalCache) {
+        Cache._setLocal(fullKey, result, 60000);
       }
+      return result;
     }
   }
 
-  static _zip(text) {
-    const zipData = zlib.gzipSync(Buffer.from(text));
-    return zipData.toString("base64");
+  /**
+   * 直接执行并写入缓存（不读取缓存）
+   * @param {string} keyPrefix 缓存前缀
+   * @param {number} timeSecond 缓存时间
+   * @param {*} args 直接传arguments，用于拼接缓存key
+   * @param {function} fn 实现函数
+   * @param {boolean} zip 是否压缩
+   * @param {boolean} useNas 是否使用Nas缓存
+   * @returns 优先返回对象
+   */
+  static async write(
+    keyPrefix,
+    timeSecond,
+    args,
+    fn,
+    zip = false,
+    useNas = false,
+  ) {
+    let fullKey = keyPrefix;
+    for (let i = 0; i < args.length; i++) {
+      fullKey += ":" + args[i].toString();
+    }
+
+    // 直接执行函数获取结果
+    let result = await fn();
+    if (!Param.isBlank(result)) {
+      let saveContent = "";
+      // 处理JSON
+      if (result instanceof Object) {
+        if (result.success === false) {
+          if (Cache.printLog) {
+            console.log("Do not cache fail result");
+          }
+        } else {
+          saveContent = JSON.stringify(result);
+        }
+      } else {
+        saveContent = result.toString();
+      }
+      if (saveContent != "") {
+        if (zip) {
+          saveContent = await Cache._zip(saveContent);
+        }
+        if (useNas) {
+          Nas.set(fullKey, saveContent, timeSecond);
+        } else {
+          await Redis.exec("setex", fullKey, timeSecond + "", saveContent);
+        }
+
+        // 本地缓存直接存结果对象
+        Cache._setLocal(fullKey, result, 60000);
+      }
+      return result;
+    }
+  }
+
+  static async _zip(text) {
+    await Cache.initZstd();
+    const compressed = Cache._zstd.compress(Buffer.from(text));
+    return Buffer.from(compressed).toString("base64");
   }
 
-  static _unzip(content) {
+  static async _unzip(content) {
     if (typeof content === "string") {
-      let text = "";
       const buffer = Buffer.from(content, "base64");
-      // 判断是否gzip
+      // zstd格式检测（魔术字节 0x28 0xB5 0x2F 0xFD）
+      if (
+        buffer.length > 4 &&
+        buffer[0] === 0x28 &&
+        buffer[1] === 0xb5 &&
+        buffer[2] === 0x2f &&
+        buffer[3] === 0xfd
+      ) {
+        await Cache.initZstd();
+        return Buffer.from(Cache._zstd.decompress(buffer)).toString();
+      }
+      // gzip格式检测（魔术字节 0x1F 0x8B）
       if (buffer.length > 2 && buffer[0] === 0x1f && buffer[1] === 0x8b) {
-        text = zlib.gunzipSync(buffer).toString();
-      } else {
-        text = content;
+        return zlib.gunzipSync(buffer).toString();
+      }
+      // 非压缩数据，直接返回原始字符串
+      return content;
+    } else if (Buffer.isBuffer(content)) {
+      if (
+        content.length > 4 &&
+        content[0] === 0x28 &&
+        content[1] === 0xb5 &&
+        content[2] === 0x2f &&
+        content[3] === 0xfd
+      ) {
+        await Cache.initZstd();
+        return Buffer.from(Cache._zstd.decompress(content)).toString();
       }
-      return text;
+      if (content.length > 2 && content[0] === 0x1f && content[1] === 0x8b) {
+        return zlib.gunzipSync(content).toString();
+      }
+      return content.toString();
     } else {
       return content;
     }
   }
 
-  static _needZip(text, zip) {
-    return zip || Buffer.byteLength(text) / 1024 > 1;
-  }
-
   static setWebCache(res, expireSecond) {
     res.setHeader("Cache-Control", "max-age=" + expireSecond);
   }

package/src/nas.js

@@ -8,13 +8,14 @@ const os = require("os");
  * 适用于多服务器共享NAS存储
  */
 class Nas {
+  static _cacheDir = null;
+
   static _getCacheDir() {
-    let cacheDir = null;
+    if (Nas._cacheDir) return Nas._cacheDir;
 
     // 如果提供了缓存目录参数，则使用该目录，否则使用默认目录
     const defaultCacheDir = path.join(os.tmpdir(), "cache");
-    cacheDir =
-      cacheDir || (fs.existsSync("/cache") ? "/cache" : defaultCacheDir);
+    const cacheDir = fs.existsSync("/cache") ? "/cache" : defaultCacheDir;
 
     // 确保缓存目录存在
     try {
@@ -24,6 +25,7 @@ class Nas {
     } catch (e) {
       console.error("创建缓存目录失败:", cacheDir, e);
     }
+    Nas._cacheDir = cacheDir;
     return cacheDir;
   }
 
@@ -90,27 +92,24 @@ class Nas {
       }
 
       // 读取缓存文件
-      let content = fs.readFileSync(filePath, "utf8");
-      const lines = content.split("\n");
+      const content = fs.readFileSync(filePath, "utf8");
 
-      if (lines.length >= 2) {
-        const expireTimeString = lines[0];
-        const value = lines.slice(1).join("\n"); // 处理值中可能包含换行符的情况
+      // 找到第一个换行符，前面为过期时间戳，后面为 base64 编码的值
+      const nlIdx = content.indexOf("\n");
+      if (nlIdx < 0) return null;
 
-        const expireTime = parseInt(expireTimeString);
+      const expireTime = parseInt(content.substring(0, nlIdx));
+      const value = content.substring(nlIdx + 1); // 处理值中可能包含换行符的情况
 
-        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;
+      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;
           }
         }
       }
@@ -137,11 +136,12 @@ class Nas {
     const content = Buffer.from(valueStr, "utf8").toString("base64");
     const filePath = Nas._getFilePath(key);
 
+    // 创建临时文件名，避免写入过程中的并发问题
+    const timestamp = Date.now();
+    const randomSuffix = Math.random().toFixed(4) * 10000;
+    const tempFilePath = `${filePath}.tmp.${timestamp}.${randomSuffix}`;
+
     try {
-      // 创建临时文件名，避免写入过程中的并发问题
-      const timestamp = Date.now();
-      const randomSuffix = Math.random().toFixed(4) * 10000;
-      const tempFilePath = `${filePath}.tmp.${timestamp}.${randomSuffix}`;
       // 写入过期时间戳和值，用换行符分隔
       const fileContent = `${expireTime}\n${content}`;
       fs.writeFileSync(tempFilePath, fileContent, "utf8");
@@ -199,24 +199,20 @@ class Nas {
             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);
+              const content = fs.readFileSync(filePath, "utf8");
+              const nlIdx = content.indexOf("\n");
+              const expireTimeString =
+                nlIdx >= 0 ? content.substring(0, nlIdx) : content;
+              const expireTime = parseInt(expireTimeString);
 
-                  if (
-                    !isNaN(expireTime) &&
-                    expireTime !== -1 &&
-                    // 仅删除过期超过一分钟的文件
-                    Date.now() > expireTime + 60 * 1000
-                  ) {
-                    console.log("删除过期缓存文件:", filePath);
-                    fs.unlinkSync(filePath);
-                  }
-                }
+              if (
+                !isNaN(expireTime) &&
+                expireTime !== -1 &&
+                // 仅删除过期超过一分钟的文件
+                Date.now() > expireTime + 60 * 1000
+              ) {
+                console.log("删除过期缓存文件:", filePath);
+                fs.unlinkSync(filePath);
               }
             } catch (e) {
               console.warn("检查缓存文件过期时间失败:", filePath, e);
@@ -269,21 +265,15 @@ class Nas {
 
       // 读取缓存文件
       const content = fs.readFileSync(filePath, "utf8");
-      const lines = content.split("\n");
-
-      if (lines.length >= 1) {
-        const expireTimeString = lines[0];
-        const expireTime = parseInt(expireTimeString);
+      const nlIdx = content.indexOf("\n");
+      const expireTimeString =
+        nlIdx >= 0 ? content.substring(0, nlIdx) : content;
+      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;
-          }
-        }
+      if (!isNaN(expireTime) && expireTime !== -1 && Date.now() < expireTime) {
+        // 文件未过期，计算剩余时间
+        const remainingTime = Math.floor((expireTime - Date.now()) / 1000);
+        return Math.max(0, remainingTime);
       }
     } catch (e) {
       console.warn("读取缓存文件失败:", filePath, e);

package/src/redis.js

@@ -42,6 +42,13 @@ module.exports = class Redis {
     }
   }
 
+  static async close() {
+    if (this.#client) {
+      await this.#client.quit();
+      this.#client = null;
+    }
+  }
+
   static async exec(name, ...args) {
     let client = await Redis.getInstance();
     args.unshift(name);

package/src/router.js

@@ -8,6 +8,7 @@ const zlib = require("zlib");
 
 module.exports = class Router {
   static #defaultFormat = true;
+  static #runtimeEnv = "test";
 
   /**
    * 根据request路由
@@ -94,6 +95,8 @@ module.exports = class Router {
       }
       const method = controller[methodName];
       if (method) {
+        this._setRuntimeEnv(req.headers);
+
         try {
           // before
           if (targets.before) {
@@ -328,4 +331,22 @@ module.exports = class Router {
 
     return ipv4Regex.test(ip.trim()) || ipv6Regex.test(ip.trim());
   }
+
+  static _setRuntimeEnv(headers) {
+    let host = headers["host"] || headers["Host"];
+    host = host.split(",")[0];
+    if (host.includes("127.0.0.1") || host.includes("localhost")) {
+      this.#runtimeEnv = "test";
+    } else {
+      const match = host.match(/((test|stage)[\d]*)\./);
+      if (match) {
+        this.#runtimeEnv = match[1];
+      } else {
+        this.#runtimeEnv = "prod";
+      }
+    }
+  }
+  static getRuntimeEnv() {
+    return this.#runtimeEnv;
+  }
 };

package/src/service.js

@@ -1,22 +1,17 @@
 const { default: axios } = require("axios");
 const qs = require("qs");
 const Ret = require("./ret");
+const Router = require("./router");
 
 module.exports = class Service {
   static #domain;
-  static #isTest;
-  static #stage;
-  static #urlPrefix;
 
-  static init(domain, isTest = true, isStage = false) {
+  static init(domain) {
     this.#domain = domain;
-    this.#isTest = isTest;
-    this.#stage = isStage;
-    this.#urlPrefix =
-      "http://SERVICE." +
-      (isStage ? "stage" : isTest ? "test" : "prod") +
-      "." +
-      domain;
+  }
+
+  static _getUrlPrefix() {
+    return "http://SERVICE." + Router.getRuntimeEnv() + "." + this.#domain;
   }
 
   static setDelay(async = false, asyncDelaySecond = 0) {
@@ -38,12 +33,12 @@ module.exports = class Service {
     async = false,
     asyncDelaySecond = 0,
   ) {
-    let url = this.#urlPrefix.replace("SERVICE", serviceName) + path;
+    let url = this._getUrlPrefix().replace("SERVICE", serviceName) + path;
     try {
       if (params) {
         url += "?" + qs.stringify(params);
       }
-      let headers = this.setDelay(async, asyncDelaySecond);
+      let headers = Service.setDelay(async, asyncDelaySecond);
       headers["accept-encoding"] = "gzip";
       const result = await axios.get(url, { headers });
       return result.data;
@@ -61,9 +56,9 @@ module.exports = class Service {
     asyncDelaySecond = 0,
     formFormat = true,
   ) {
-    let url = this.#urlPrefix.replace("SERVICE", serviceName) + path;
+    let url = this._getUrlPrefix().replace("SERVICE", serviceName) + path;
     try {
-      let headers = this.setDelay(async, asyncDelaySecond);
+      let headers = Service.setDelay(async, asyncDelaySecond);
       if (!formFormat) {
         headers["Content-Type"] = "application/json";
       }

package/test/test-cache.js

@@ -9,6 +9,10 @@ describe("cache.js", () => {
     Redis.init("127.0.0.1", "default", "KS5UggH4LNyyLBdr");
   });
 
+  after(async () => {
+    await Redis.close();
+  });
+
   describe("get()", () => {
     it("return string", async () => {
       let testFunction = (a, b) => {
@@ -21,7 +25,7 @@ describe("cache.js", () => {
         testFunction,
         testFunction,
         1,
-        2
+        2,
       );
       console.log("result", result);
       assert(result === "3");
@@ -38,7 +42,7 @@ describe("cache.js", () => {
           testFunction,
           testFunction,
           1,
-          2
+          2,
         );
       } catch (e) {
         assert(e.message === "只支持返回值是文本的方法");
@@ -56,7 +60,7 @@ describe("cache.js", () => {
       }
       const result = await test(1, 2);
       console.log("result", result);
-      assert(result === "3");
+      assert(result == "3");
     });
     it("return int", async () => {
       async function test(a, b) {
@@ -108,22 +112,22 @@ describe("cache.js", () => {
       let a = 1,
         b = 2;
       let result = await Cache.auto(
-        "test",
+        "test_base64",
         20,
         [],
         async () => {
           console.log(a + b);
           return a + b + "";
         },
-        true
+        true,
       );
       console.log("result", result);
-      assert(result === "3");
+      assert(result == "3");
     });
 
     it("auto long text base64", async () => {
       let result = await Cache.auto(
-        "test",
+        "test_long_base64",
         20,
         [],
         async () => {
@@ -135,38 +139,128 @@ describe("cache.js", () => {
           console.log(text);
           return text;
         },
-        true
+        true,
       );
       console.log("result", result);
-      assert(result === "3");
-    });
-
-    it("auto long text default zip", async () => {
-      let text = "";
-      // 循环1000次
-      for (let i = 0; i < 2000; i++) {
-        text += "a";
-      }
-      console.log(text);
-      let result = await Cache.auto("test", 20, [], async () => {
-        return text;
-      });
-      console.log("result", result);
-      assert(result === text);
+      assert(result.length === 1000);
     });
 
-    it("local cache", async () => {
+    it("local cache stores parsed object", async () => {
       async function test(a, b) {
-        return await Cache.auto("test3", 20, arguments, () => {
-          console.log(a, b);
+        return await Cache.auto("test_local_obj", 20, arguments, () => {
           return { a, b };
         });
       }
-      const result = await test(1, 2);
-      console.log("cache", Cache.localCache);
-      console.log("result", JSON.stringify(result));
-      const compare = { a: 1, b: 2 };
-      assert(result.a === compare.a);
+      // 第一次调用，写入缓存
+      const result1 = await test(1, 2);
+      assert(result1.a === 1);
+      // 第二次调用，应该命中本地缓存，直接返回对象
+      const result2 = await test(1, 2);
+      assert(result2.a === 1);
+      // 验证本地缓存存的是对象而不是字符串
+      const localKey = "test_local_obj:1:2";
+      const localItem = Cache.localCache[localKey];
+      // 多参数不做本地缓存
+      assert(localItem === undefined);
+    });
+
+    it("local cache only for zero-args", async () => {
+      let callCount = 0;
+      const result1 = await Cache.auto("test_zero_args", 20, [], () => {
+        callCount++;
+        return { count: callCount };
+      });
+      assert(result1.count === 1);
+      // 第二次调用应该命中本地缓存，callCount不增加
+      const result2 = await Cache.auto("test_zero_args", 20, [], () => {
+        callCount++;
+        return { count: callCount };
+      });
+      assert(result2.count === 1);
+      // 验证本地缓存存的是对象
+      const localItem = Cache.localCache["test_zero_args"];
+      assert(localItem !== undefined);
+      assert(typeof localItem.value === "object");
+    });
+  });
+
+  describe("write()", () => {
+    it("write and verify cache", async () => {
+      let callCount = 0;
+      const result = await Cache.write("test_write", 20, [], () => {
+        callCount++;
+        return { count: callCount };
+      });
+      assert(result.count === 1);
+      // write不读取缓存，直接执行fn
+      const result2 = await Cache.write("test_write", 20, [], () => {
+        callCount++;
+        return { count: callCount };
+      });
+      assert(result2.count === 2);
+      // 验证本地缓存存在
+      const localItem = Cache.localCache["test_write"];
+      assert(localItem !== undefined);
+      assert(localItem.value.count === 2);
+    });
+
+    it("write does not cache fail result", async () => {
+      const result = await Cache.write("test_write_fail", 20, [], () => {
+        return new Ret(false);
+      });
+      assert(result.success === false);
+      // 失败结果不应该被本地缓存
+      const localItem = Cache.localCache["test_write_fail"];
+      assert(localItem === undefined);
+    });
+  });
+
+  describe("zstd", () => {
+    it("initZstd", async () => {
+      await Cache.initZstd();
+      assert(Cache._zstd !== null);
+    });
+
+    it("_zip and _unzip with zstd", async () => {
+      const text = '{"success":true,"data":"hello zstd"}';
+      const compressed = await Cache._zip(text);
+      assert(typeof compressed === "string");
+      assert(compressed !== text);
+      // 解压
+      const decompressed = await Cache._unzip(compressed);
+      assert(decompressed === text);
+    });
+
+    it("auto with zstd compression", async () => {
+      const result = await Cache.auto(
+        "test_zstd_auto",
+        20,
+        [],
+        async () => {
+          let text = "";
+          for (let i = 0; i < 500; i++) {
+            text += "zstd test data ";
+          }
+          return text;
+        },
+        true,
+      );
+      assert(typeof result === "string");
+      assert(result.length > 0);
+    });
+
+    it("write with zstd compression", async () => {
+      const result = await Cache.write(
+        "test_zstd_write",
+        20,
+        [],
+        async () => {
+          return { message: "zstd write test", count: 42 };
+        },
+        true,
+      );
+      assert(result.message === "zstd write test");
+      assert(result.count === 42);
     });
   });
 });

package/test/test-router.js

@@ -136,7 +136,7 @@ describe("router.js", () => {
       send: function (data) {
         console.log("send: " + data);
         assert(
-          data === '{"code":1000,"success":false,"message":"请输入发货类型"}'
+          data === '{"code":1000,"success":false,"message":"请输入发货类型"}',
         );
       },
     };
@@ -155,7 +155,7 @@ describe("router.js", () => {
       send: function (data) {
         console.log("send: " + data);
         assert(
-          data === '{"code":1000,"success":false,"message":"请输入发货类型"}'
+          data === '{"code":1000,"success":false,"message":"请输入发货类型"}',
         );
       },
     };
@@ -257,4 +257,124 @@ describe("router.js", () => {
     await Router.route(targets, req, res);
     console.log("end");
   });
+
+  it("runtime env test", async () => {
+    let targets = {
+      "/": {
+        add: function (req, res) {
+          res.send("ok");
+        },
+      },
+    };
+    let req = { path: "/add", headers: { host: "aa.test.example.com" } };
+    let res = {
+      send: function (data) {
+        console.log("send: " + data);
+      },
+    };
+    console.log("start");
+    await Router.route(targets, req, res);
+    console.log("end");
+    assert(Router.getRuntimeEnv() === "test");
+  });
+
+  it("runtime env test2", async () => {
+    let targets = {
+      "/": {
+        add: function (req, res) {
+          res.send("ok");
+        },
+      },
+    };
+    let req = { path: "/add", headers: { host: "aa.test2.example.com" } };
+    let res = {
+      send: function (data) {
+        console.log("send: " + data);
+      },
+    };
+    console.log("start");
+    await Router.route(targets, req, res);
+    console.log("end");
+    assert(Router.getRuntimeEnv() === "test2");
+  });
+
+  it("runtime env stage", async () => {
+    let targets = {
+      "/": {
+        add: function (req, res) {
+          res.send("ok");
+        },
+      },
+    };
+    let req = { path: "/add", headers: { host: "aa.stage.example.com" } };
+    let res = {
+      send: function (data) {
+        console.log("send: " + data);
+      },
+    };
+    console.log("start");
+    await Router.route(targets, req, res);
+    console.log("end");
+    assert(Router.getRuntimeEnv() === "stage");
+  });
+
+  it("runtime env prod", async () => {
+    let targets = {
+      "/": {
+        add: function (req, res) {
+          res.send("ok");
+        },
+      },
+    };
+    let req = { path: "/add", headers: { host: "aa.prod.example.com" } };
+    let res = {
+      send: function (data) {
+        console.log("send: " + data);
+      },
+    };
+    console.log("start");
+    await Router.route(targets, req, res);
+    console.log("end");
+    assert(Router.getRuntimeEnv() === "prod");
+  });
+
+  it("runtime env other", async () => {
+    let targets = {
+      "/": {
+        add: function (req, res) {
+          res.send("ok");
+        },
+      },
+    };
+    let req = { path: "/add", headers: { host: "aa.example.com" } };
+    let res = {
+      send: function (data) {
+        console.log("send: " + data);
+      },
+    };
+    console.log("start");
+    await Router.route(targets, req, res);
+    console.log("end");
+    assert(Router.getRuntimeEnv() === "prod");
+  });
+
+  it("runtime env local", async () => {
+    let targets = {
+      "/": {
+        add: function (req, res) {
+          res.send("ok");
+        },
+      },
+    };
+    let req = { path: "/add", headers: { host: "127.0.0.1" } };
+    let res = {
+      send: function (data) {
+        console.log("send: " + data);
+      },
+    };
+    console.log("start");
+    await Router.route(targets, req, res);
+    console.log("end");
+    assert(Router.getRuntimeEnv() === "test");
+  });
 });

package/test/test-service.js

@@ -11,7 +11,7 @@ describe("service.js", () => {
     it("ok", async () => {
       const result = await Service.get("supplier", "/");
       console.log(result);
-      assert(result.code == 1004);
+      assert(result.code == 1000);
     });
 
     it("async", async () => {
@@ -30,7 +30,7 @@ describe("service.js", () => {
     it("ok", async () => {
       const result = await Service.post("supplier", "/");
       console.log(result);
-      assert(result.code == 1004);
+      assert(result.code == 1000);
     });
 
     it("async", async () => {