@less-is-more/less-js 1.2.20 → 1.2.24

package/package.json

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

package/src/cache.js

@@ -2,32 +2,78 @@ const Redis = require("./redis");
 const Param = require("./param");
 
 module.exports = class Cache {
-	/**
-	 * 缓存并获取结果
-	 * @param {*} key 缓存关键词，拼接参数
-	 * @param {number} timeSecond 缓存秒数
-	 * @param {object} thisObject this指向的对象
-	 * @param {function} targetMethod 没有缓存时，执行目标。暂时支持返回文本、对象、数组
-	 * @param  {...any} args 没有缓存时，参数
-	 * @returns
-	 */
-	static async get(key, timeSecond, thisObject, targetMethod, ...args) {
-		let fullKey = key;
-		args.forEach((nArg) => (fullKey += ":" + nArg));
-		let savedData = await Redis.exec("get", fullKey);
-		if (savedData == null) {
-			let result = await targetMethod.apply(thisObject, args);
-			if (!Param.isBlank(result)) {
-				if (typeof result === "string") {
-					await Redis.exec("setex", fullKey, timeSecond, result);
-					return result;
-				} else {
-					throw new Error("只支持返回值是文本的方法");
-				}
-			}
-		} else {
-			console.log("Found cache", fullKey);
-			return savedData;
-		}
-	}
+  /**
+   * 缓存并获取结果（调用方）
+   * @param {*} key 缓存关键词，拼接参数
+   * @param {number} timeSecond 缓存秒数
+   * @param {object} thisObject this指向的对象
+   * @param {function} targetMethod 没有缓存时，执行目标。暂时支持返回文本、对象、数组
+   * @param  {...any} args 没有缓存时，参数
+   * @returns
+   */
+  static async get(key, timeSecond, thisObject, targetMethod, ...args) {
+    let fullKey = key;
+    args.forEach((nArg) => (fullKey += ":" + nArg));
+    let savedData = await Redis.exec("get", fullKey);
+    if (savedData == null) {
+      let result = await targetMethod.apply(thisObject, args);
+      if (!Param.isBlank(result)) {
+        if (typeof result === "string") {
+          await Redis.exec("setex", fullKey, timeSecond + "", result);
+          return result;
+        } else {
+          throw new Error("只支持返回值是文本的方法");
+        }
+      }
+    } else {
+      console.log("Found cache", fullKey);
+      return savedData;
+    }
+  }
+
+  /**
+   *
+   * @param {string} keyPrefix 缓存前缀
+   * @param {number} timeSecond 缓存时间
+   * @param {*} args 直接传arguments，用于拼接缓存key
+   * @param {function} fn 没有缓存的实现
+   * @returns 优先返回对象
+   */
+  static async auto(keyPrefix, timeSecond, args, fn) {
+    let fullKey = keyPrefix;
+    for (let i = 0; i < args.length; i++) {
+      fullKey += ":" + args[i].toString();
+    }
+    let savedData = await Redis.exec("get", fullKey);
+    if (savedData == null) {
+      let result = await fn();
+      if (!Param.isBlank(result)) {
+        // 处理JSON
+        if (result instanceof Object) {
+          await Redis.exec(
+            "setex",
+            fullKey,
+            timeSecond + "",
+            JSON.stringify(result)
+          );
+        } else {
+          await Redis.exec(
+            "setex",
+            fullKey,
+            timeSecond + "",
+            result.toString()
+          );
+        }
+        return result;
+      }
+    } else {
+      console.log("Found cache", fullKey);
+      // 优先转成json
+      if (savedData.startsWith("{") || savedData.startsWith("[")) {
+        return JSON.parse(savedData);
+      } else {
+        return savedData;
+      }
+    }
+  }
 };

package/src/redis.js

@@ -33,7 +33,8 @@ module.exports = class Redis {
 
   static async exec(name, ...args) {
     let client = await Redis.getInstance();
-    return await client[name].bind(client).apply(undefined, args);
+    args.unshift(name);
+    return await client.sendCommand(args);
   }
 
   static formatKey(name, params = {}) {

package/src/ret.js

@@ -6,53 +6,64 @@ module.exports = class Ret {
   static CODE_SYSTEM = 1004;
 
   constructor(success, message, code) {
-    this.#instance.success = success;
+    this.success = success;
     if (message) {
-      this.#instance.message = message;
+      this.message = message;
     }
     if (code) {
-      this.#instance.code = code;
+      this.code = code;
     }
   }
 
-  #instance = {};
   ok() {
-    this.#instance.success = true;
+    this.success = true;
     return this;
   }
+  isOk() {
+    return this.success;
+  }
   fail() {
-    this.#instance.success = false;
+    this.success = false;
     return this;
   }
+  isFail() {
+    return !this.success;
+  }
   setMessage(message) {
-    this.#instance.message = message;
+    this.message = message;
     return this;
   }
+  getMessage() {
+    return this.message;
+  }
   setCode(code) {
-    this.#instance.code = code;
+    this.code = code;
     return this;
   }
   setData(data) {
-    this.#instance.data = data;
+    this.data = data;
     return this;
   }
+  getData() {
+    return this.data;
+  }
   toString() {
-    return JSON.stringify(this.#instance);
+    return JSON.stringify(this);
   }
   getJson() {
-    return this.#instance;
+    return this;
   }
   toJson() {
-    return this.#instance;
+    return this;
   }
 
   filter(props = []) {
     if (props.length > 0) {
-      const data = this.#instance.data;
+      const data = this.data;
       if (data instanceof Array) {
-        this.#instance.data = this._filterArray(data, props);
+        this.data = this._filterArray(data, props);
       } else {
-        this.#instance.data = this._filterObject(data, props);
+        this.data = this._filterObject(data, props);
       }
     }
     return this;

package/test/test-cache.js

@@ -3,45 +3,94 @@ const Cache = require("../src/cache.js");
 const Redis = require("../src/redis.js");
 
 describe("cache.js", () => {
-	before(() => {
-		console.log("init");
-		Redis.init("127.0.0.1", "default", "KS5UggH4LNyyLBdr");
-	});
+  before(() => {
+    console.log("init");
+    Redis.init("127.0.0.1", "default", "KS5UggH4LNyyLBdr");
+  });
 
-	describe("get()", () => {
-		it("return string", async () => {
-			let testFunction = (a, b) => {
-				console.log(a + b);
-				return a + b + "";
-			};
-			let result = await Cache.get(
-				"test",
-				20,
-				testFunction,
-				testFunction,
-				1,
-				2
-			);
-			console.log("result", result);
-			assert(result === "3");
-		});
-		it("return object", async () => {
-			let testFunction = (a, b) => {
-				console.log(a + b);
-				return { r: a + b };
-			};
-			try {
-				let result = await Cache.get(
-					"test2",
-					20,
-					testFunction,
-					testFunction,
-					1,
-					2
-				);
-			} catch (e) {
-				assert(e.message === "只支持返回值是文本的方法");
-			}
-		});
-	});
+  describe("get()", () => {
+    it("return string", async () => {
+      let testFunction = (a, b) => {
+        console.log(a + b);
+        return a + b + "";
+      };
+      let result = await Cache.get(
+        "test",
+        20,
+        testFunction,
+        testFunction,
+        1,
+        2
+      );
+      console.log("result", result);
+      assert(result === "3");
+    });
+    it("return object", async () => {
+      let testFunction = (a, b) => {
+        console.log(a + b);
+        return { r: a + b };
+      };
+      try {
+        let result = await Cache.get(
+          "test2",
+          20,
+          testFunction,
+          testFunction,
+          1,
+          2
+        );
+      } catch (e) {
+        assert(e.message === "只支持返回值是文本的方法");
+      }
+    });
+  });
+
+  describe("auto()", () => {
+    it("return string", async () => {
+      async function test(a, b) {
+        return await Cache.auto("test", 20, arguments, () => {
+          console.log(a + b);
+          return a + b + "";
+        });
+      }
+      const result = await test(1, 2);
+      console.log("result", result);
+      assert(result === "3");
+    });
+    it("return int", async () => {
+      async function test(a, b) {
+        let r = await Cache.auto("test2", 20, arguments, () => {
+          console.log(a + b);
+          return a + b;
+        });
+        return r;
+      }
+      const result = await test(1, 2);
+      console.log("result", result);
+      assert(result == 3);
+    });
+    it("return object", async () => {
+      async function test(a, b) {
+        return await Cache.auto("test3", 20, arguments, () => {
+          console.log(a, b);
+          return { a, b };
+        });
+      }
+      const result = await test(1, 2);
+      console.log("result", JSON.stringify(result));
+      const compare = { a: 1, b: 2 };
+      assert(result.a === compare.a);
+    });
+    it("return array", async () => {
+      async function test(a, b) {
+        return await Cache.auto("test4", 20, arguments, () => {
+          console.log(a, b);
+          return [{ a, b }];
+        });
+      }
+      const result = await test(1, 2);
+      console.log("result", JSON.stringify(result));
+      assert(result.length === 1);
+    });
+  });
 });

package/test/test-redis.js

@@ -2,42 +2,53 @@ const assert = require("assert");
 const Redis = require("../src/redis.js");
 
 describe("redis.js", () => {
-	before(() => {
-		console.log("init");
-		Redis.init("127.0.0.1", "default", "KS5UggH4LNyyLBdr");
-	});
-	describe("getInstance()", () => {
-		it("connect", async () => {
-			try {
-				let result = await Redis.exec("get", "test");
-				console.log(result);
-				console.log("Connection has been established successfully.");
-				assert.ok(true);
-			} catch (error) {
-				console.error("Unable to connect to the redis:", error);
-				assert.ok(false);
-			}
-		});
-		it("set", async () => {
-			try {
-				await Redis.exec("set", "test", "OK");
-				let reply = await Redis.exec("get", "test");
-				console.log(reply);
-				assert.ok(true);
-			} catch (error) {
-				assert.ok(false);
-			}
-		});
-	});
-	describe("formatKey()", () => {
-		it("no params", async () => {
-			let result = await Redis.formatKey("order", {});
-			assert(result == "order");
-		});
-		it("has params", async () => {
-			let result = await Redis.formatKey("order", { code: "123" });
-			console.log(result);
-			assert(result == "order:code:123");
-		});
-	});
+  before(() => {
+    console.log("init");
+    Redis.init("127.0.0.1", "default", "KS5UggH4LNyyLBdr");
+  });
+  describe("getInstance()", () => {
+    it("connect", async () => {
+      try {
+        let result = await Redis.exec("get", "test");
+        console.log(result);
+        console.log("Connection has been established successfully.");
+        assert.ok(true);
+      } catch (error) {
+        console.error("Unable to connect to the redis:", error);
+        assert.ok(false);
+      }
+    });
+    it("set", async () => {
+      try {
+        await Redis.exec("set", "test", "OK");
+        let reply = await Redis.exec("get", "test");
+        console.log(reply);
+        assert.ok(true);
+      } catch (error) {
+        assert.ok(false);
+      }
+    });
+    it("set ex", async () => {
+      try {
+        await Redis.exec("setex", "test", "100", "OK");
+        let reply = await Redis.exec("get", "test");
+        console.log(reply);
+        assert.ok(true);
+      } catch (error) {
+        console.log(error);
+        assert.ok(false);
+      }
+    });
+  });
+  describe("formatKey()", () => {
+    it("no params", async () => {
+      let result = await Redis.formatKey("order", {});
+      assert(result == "order");
+    });
+    it("has params", async () => {
+      let result = await Redis.formatKey("order", { code: "123" });
+      console.log(result);
+      assert(result == "order:code:123");
+    });
+  });
 });

package/test/test-ret.js

@@ -5,6 +5,7 @@ describe("ret.js", () => {
   describe("new()", () => {
     it("ok", () => {
       let ret = new Ret(true).setData({ name: "good" });
+      console.log(ret)
       assert(ret.getJson().data.name, "good");
     });
     it("mutli params", () => {