koatty_cacheable 1.4.3 → 1.6.0

package/dist/index.js

@@ -1,241 +1,274 @@
 /*!
 * @Author: richen
-* @Date: 2024-01-17 22:08:01
+* @Date: 2024-11-07 16:06:44
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
 'use strict';
 
+var koatty_container = require('koatty_container');
 var koatty_lib = require('koatty_lib');
 var koatty_logger = require('koatty_logger');
 var koatty_store = require('koatty_store');
-var koatty_container = require('koatty_container');
 
-/*
- * @Author: richen
- * @Date: 2020-07-06 19:53:43
- * @LastEditTime: 2024-01-17 21:54:53
- * @Description:
- * @Copyright (c) - <richenlin(at)gmail.com>
- */
-const longKey = 128;
-// storeCache
-const storeCache = {
-    store: null
-};
-/**
- * get instances of storeCache
- *
- * @export
- * @param {Application} app
- * @returns {*}  {CacheStore}
- */
-async function GetCacheStore(app) {
-    var _a, _b;
-    if (storeCache.store && storeCache.store.getConnection) {
-        return storeCache.store;
-    }
-    const opt = (_b = (_a = app.config("CacheStore")) !== null && _a !== void 0 ? _a : app.config("CacheStore", "db")) !== null && _b !== void 0 ? _b : {};
-    if (koatty_lib.Helper.isEmpty(opt)) {
-        koatty_logger.DefaultLogger.Warn(`Missing CacheStore server configuration. Please write a configuration item with the key name 'CacheStore' in the db.ts file.`);
-    }
-    storeCache.store = koatty_store.CacheStore.getInstance(opt);
-    if (!koatty_lib.Helper.isFunction(storeCache.store.getConnection)) {
-        throw Error(`CacheStore connection failed. `);
-    }
-    await storeCache.store.client.getConnection();
-    return storeCache.store;
-}
-/**
- * initiation CacheStore connection and client.
- *
- */
-async function InitCacheStore() {
-    if (storeCache.store !== null) {
-        return;
-    }
-    const app = koatty_container.IOCContainer.getApp();
-    app && app.once("appReady", async function () {
-        await GetCacheStore(app);
-    });
-}
-/**
- * Decorate this method to support caching. Redis server config from db.ts.
- * The cache method returns a value to ensure that the next time the method is executed with the same parameters,
- * the results can be obtained directly from the cache without the need to execute the method again.
- *
- * @export
- * @param {string} cacheName cache name
- * @param {CacheAbleOpt} [opt] cache options
- * e.g:
- * {
- *  params: ["id"],
- *  timeout: 30
- * }
- * Use the 'id' parameters of the method as cache subkeys, the cache expiration time 30s
- * @returns {MethodDecorator}
- */
-function CacheAble(cacheName, opt = {
-    params: [],
-    timeout: 300,
-}) {
-    return (target, methodName, descriptor) => {
-        const componentType = koatty_container.IOCContainer.getType(target);
-        if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
-            throw Error("This decorator only used in the service、component class.");
-        }
-        const { value, configurable, enumerable } = descriptor;
-        opt = {
-            ...{
-                params: [],
-                timeout: 300,
-            }, ...opt
-        };
-        // 获取定义的参数位置
-        const paramIndexes = getParamIndex(opt.params);
-        descriptor = {
-            configurable,
-            enumerable,
-            writable: true,
-            async value(...props) {
-                let cacheFlag = true;
-                const store = await GetCacheStore(this.app).catch(() => {
-                    cacheFlag = false;
-                    koatty_logger.DefaultLogger.Error("Get cache store instance failed.");
-                    return null;
-                });
-                if (cacheFlag) {
-                    // tslint:disable-next-line: one-variable-per-declaration
-                    let key = cacheName;
-                    if (props && props.length > 0) {
-                        for (const item of paramIndexes) {
-                            if (props[item] !== undefined) {
-                                const value = koatty_lib.Helper.toString(props[item]);
-                                key += `:${opt.params[item]}:${value}`;
-                            }
-                        }
-                        // 防止key超长
-                        if (key.length > longKey) {
-                            key = koatty_lib.Helper.murmurHash(key);
-                        }
-                    }
-                    let res = await store.get(key).catch(() => null);
-                    if (!koatty_lib.Helper.isEmpty(res)) {
-                        return JSON.parse(res);
-                    }
-                    // tslint:disable-next-line: no-invalid-this
-                    res = await value.apply(this, props);
-                    // prevent cache penetration
-                    if (koatty_lib.Helper.isTrueEmpty(res)) {
-                        res = "";
-                    }
-                    // async set store
-                    store.set(key, JSON.stringify(res), opt.timeout).catch(() => null);
-                    return res;
-                }
-                else {
-                    // tslint:disable-next-line: no-invalid-this
-                    return value.apply(this, props);
-                }
-            }
-        };
-        // bind app_ready hook event 
-        InitCacheStore();
-        return descriptor;
-    };
-}
-/**
- * Decorating the execution of this method will trigger a cache clear operation. Redis server config from db.ts.
- *
- * @export
- * @param {string} cacheName cacheName cache name
- * @param {CacheEvictOpt} [opt] cache options
- * e.g:
- * {
- *  params: ["id"],
- *  eventTime: "Before"
- * }
- * Use the 'id' parameters of the method as cache subkeys, and clear the cache before the method executed
- * @returns
- */
-function CacheEvict(cacheName, opt = {
-    eventTime: "Before",
-}) {
-    return (target, methodName, descriptor) => {
-        const componentType = koatty_container.IOCContainer.getType(target);
-        if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
-            throw Error("This decorator only used in the service、component class.");
-        }
-        const { value, configurable, enumerable } = descriptor;
-        // 获取定义的参数位置
-        opt = {
-            ...{
-                eventTime: "Before",
-            }, ...opt
-        };
-        const paramIndexes = getParamIndex(opt.params);
-        descriptor = {
-            configurable,
-            enumerable,
-            writable: true,
-            async value(...props) {
-                let cacheFlag = true;
-                const store = await GetCacheStore(this.app).catch(() => {
-                    cacheFlag = false;
-                    koatty_logger.DefaultLogger.Error("Get cache store instance failed.");
-                    return null;
-                });
-                if (cacheFlag) {
-                    let key = cacheName;
-                    if (props && props.length > 0) {
-                        for (const item of paramIndexes) {
-                            if (props[item] !== undefined) {
-                                const value = koatty_lib.Helper.toString(props[item]);
-                                key += `:${opt.params[item]}:${value}`;
-                            }
-                        }
-                        // 防止key超长
-                        if (key.length > longKey) {
-                            key = koatty_lib.Helper.murmurHash(key);
-                        }
-                    }
-                    if (opt.eventTime === "Before") {
-                        await store.del(key).catch(() => null);
-                        // tslint:disable-next-line: no-invalid-this
-                        return value.apply(this, props);
-                    }
-                    else {
-                        // tslint:disable-next-line: no-invalid-this
-                        const res = await value.apply(this, props);
-                        store.del(key).catch(() => null);
-                        return res;
-                    }
-                }
-                else {
-                    // tslint:disable-next-line: no-invalid-this
-                    return value.apply(this, props);
-                }
-            }
-        };
-        // bind app_ready hook event 
-        InitCacheStore();
-        return descriptor;
-    };
-}
-/**
- * @description:
- * @param {string[]} params
- * @return {*}
- */
-function getParamIndex(params) {
-    const res = [];
-    for (let i = 0; i < params.length; i++) {
-        if (params.includes(params[i])) {
-            res.push(i);
-        }
-    }
-    return res;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2024-11-07 13:54:24
+ * @LastEditTime: 2024-11-07 15:25:36
+ * @License: BSD (3-Clause)
+ * @Copyright (c): <richenlin(at)gmail.com>
+ */
+// storeCache
+const storeCache = {
+    store: null
+};
+/**
+ * get instances of storeCache
+ *
+ * @export
+ * @param {Application} app
+ * @returns {*}  {CacheStore}
+ */
+async function GetCacheStore(app) {
+    if (storeCache.store && storeCache.store.getConnection) {
+        return storeCache.store;
+    }
+    let opt = {
+        type: "memory",
+        db: 0,
+        timeout: 30
+    };
+    if (app && koatty_lib.Helper.isFunction(app.config)) {
+        opt = app.config("CacheStore") || app.config("CacheStore", "db");
+        if (koatty_lib.Helper.isEmpty(opt)) {
+            koatty_logger.DefaultLogger.Warn(`Missing CacheStore server configuration. Please write a configuration item with the key name 'CacheStore' in the db.ts file.`);
+        }
+    }
+    storeCache.store = koatty_store.CacheStore.getInstance(opt);
+    if (!koatty_lib.Helper.isFunction(storeCache.store.getConnection)) {
+        throw Error(`CacheStore connection failed. `);
+    }
+    await storeCache.store.client.getConnection();
+    return storeCache.store;
+}
+/**
+ * initiation CacheStore connection and client.
+ *
+ */
+async function InitCacheStore() {
+    if (storeCache.store) {
+        return;
+    }
+    const app = koatty_container.IOCContainer.getApp();
+    app?.once("appReady", async () => {
+        await GetCacheStore(app);
+    });
+}
+/**
+ * @description:
+ * @param {*} func
+ * @return {*}
+ */
+function getArgs(func) {
+    // 首先匹配函数括弧里的参数
+    const args = func.toString().match(/.*?\(([^)]*)\)/);
+    if (args.length > 1) {
+        // 分解参数成数组
+        return args[1].split(",").map(function (a) {
+            // 去空格和内联注释
+            return a.replace(/\/\*.*\*\//, "").trim();
+        }).filter(function (ae) {
+            // 确保没有undefineds
+            return ae;
+        });
+    }
+    return [];
+}
+/**
+ * @description:
+ * @param {string[]} funcParams
+ * @param {string[]} params
+ * @return {*}
+ */
+function getParamIndex(funcParams, params) {
+    return params.map(param => funcParams.indexOf(param));
+}
+/**
+ *
+ * @param ms
+ * @returns
+ */
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * async delayed execution func
+ * @param fn
+ * @param ms
+ * @returns
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function asyncDelayedExecution(fn, ms) {
+    await delay(ms); // delay ms second
+    return fn();
+}
+
+/*
+ * @Author: richen
+ * @Date: 2020-07-06 19:53:43
+ * @LastEditTime: 2024-11-07 15:53:46
+ * @Description:
+ * @Copyright (c) - <richenlin(at)gmail.com>
+ */
+const longKey = 128;
+/**
+ * Decorate this method to support caching.
+ * The cache method returns a value to ensure that the next time
+ * the method is executed with the same parameters, the results can be obtained
+ * directly from the cache without the need to execute the method again.
+ * CacheStore server config defined in db.ts.
+ *
+ * @export
+ * @param {string} cacheName cache name
+ * @param {CacheAbleOpt} [opt] cache options
+ * e.g:
+ * {
+ *  params: ["id"],
+ *  timeout: 30
+ * }
+ * Use the 'id' parameters of the method as cache subkeys, the cache expiration time 30s
+ * @returns {MethodDecorator}
+ */
+function CacheAble(cacheName, opt = {
+    params: [],
+    timeout: 300,
+}) {
+    return (target, methodName, descriptor) => {
+        const componentType = koatty_container.IOCContainer.getType(target);
+        if (!["SERVICE", "COMPONENT"].includes(componentType)) {
+            throw Error("This decorator only used in the service、component class.");
+        }
+        const { value, configurable, enumerable } = descriptor;
+        const mergedOpt = { ...{ params: [], timeout: 300 }, ...opt };
+        // Get the parameter list of the method
+        const funcParams = getArgs(target[methodName]);
+        // Get the defined parameter location
+        const paramIndexes = getParamIndex(funcParams, opt.params);
+        descriptor = {
+            configurable,
+            enumerable,
+            writable: true,
+            async value(...props) {
+                const store = await GetCacheStore(this.app).catch((e) => {
+                    koatty_logger.DefaultLogger.Error("Get cache store instance failed." + e.message);
+                    return null;
+                });
+                if (store) {
+                    let key = cacheName;
+                    for (const item of paramIndexes) {
+                        if (props[item] !== undefined) {
+                            key += `:${mergedOpt.params[item]}:${koatty_lib.Helper.toString(props[item])}`;
+                        }
+                    }
+                    key = key.length > longKey ? koatty_lib.Helper.murmurHash(key) : key;
+                    const res = await store.get(key).catch((e) => {
+                        koatty_logger.DefaultLogger.error("Cache get error:" + e.message);
+                    });
+                    if (!koatty_lib.Helper.isEmpty(res)) {
+                        return JSON.parse(res);
+                    }
+                    const result = await value.apply(this, props);
+                    // async refresh store
+                    store.set(key, koatty_lib.Helper.isJSONObj(result) ? JSON.stringify(result) : result, mergedOpt.timeout).catch((e) => {
+                        koatty_logger.DefaultLogger.error("Cache set error:" + e.message);
+                    });
+                    return result;
+                }
+                else {
+                    // tslint:disable-next-line: no-invalid-this
+                    return value.apply(this, props);
+                }
+            }
+        };
+        // bind app_ready hook event 
+        InitCacheStore();
+        return descriptor;
+    };
+}
+/**
+ * Decorating the execution of this method will trigger a cache clear operation.
+ * CacheStore server config defined in db.ts.
+ *
+ * @export
+ * @param {string} cacheName cacheName cache name
+ * @param {CacheEvictOpt} [opt] cache options
+ * e.g:
+ * {
+ *  params: ["id"],
+ *  delayedDoubleDeletion: true
+ * }
+ * Use the 'id' parameters of the method as cache subkeys,
+ *  and clear the cache after the method executed
+ * @returns
+ */
+function CacheEvict(cacheName, opt = {
+    delayedDoubleDeletion: true,
+}) {
+    return (target, methodName, descriptor) => {
+        const componentType = koatty_container.IOCContainer.getType(target);
+        if (!["SERVICE", "COMPONENT"].includes(componentType)) {
+            throw Error("This decorator only used in the service、component class.");
+        }
+        const { value, configurable, enumerable } = descriptor;
+        opt = { ...{ delayedDoubleDeletion: true, }, ...opt };
+        // Get the parameter list of the method
+        const funcParams = getArgs(target[methodName]);
+        // Get the defined parameter location
+        const paramIndexes = getParamIndex(funcParams, opt.params);
+        descriptor = {
+            configurable,
+            enumerable,
+            writable: true,
+            async value(...props) {
+                const store = await GetCacheStore(this.app).catch((e) => {
+                    koatty_logger.DefaultLogger.Error("Get cache store instance failed." + e.message);
+                    return null;
+                });
+                if (store) {
+                    let key = cacheName;
+                    for (const item of paramIndexes) {
+                        if (props[item] !== undefined) {
+                            key += `:${opt.params[item]}:${koatty_lib.Helper.toString(props[item])}`;
+                        }
+                    }
+                    key = key.length > longKey ? koatty_lib.Helper.murmurHash(key) : key;
+                    const result = await value.apply(this, props);
+                    store.del(key).catch((e) => {
+                        koatty_logger.DefaultLogger.Error("Cache delete error:" + e.message);
+                    });
+                    if (opt.delayedDoubleDeletion) {
+                        asyncDelayedExecution(() => {
+                            store.del(key).catch((e) => {
+                                koatty_logger.DefaultLogger.error("Cache double delete error:" + e.message);
+                            });
+                        }, 5000);
+                        return result;
+                    }
+                    else {
+                        // tslint:disable-next-line: no-invalid-this
+                        return value.apply(this, props);
+                    }
+                }
+            }
+        };
+        // bind app_ready hook event 
+        InitCacheStore();
+        return descriptor;
+    };
 }
 
 exports.CacheAble = CacheAble;