koatty_cacheable 1.5.0 → 1.6.1

package/dist/index.mjs

@@ -1,259 +1,316 @@
 /*!
 * @Author: richen
-* @Date: 2024-04-01 15:47:40
+* @Date: 2025-06-09 13:04:37
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
+import { IOCContainer } from 'koatty_container';
 import { Helper } from 'koatty_lib';
 import { DefaultLogger } from 'koatty_logger';
 import { CacheStore } from 'koatty_store';
-import { IOCContainer } from 'koatty_container';
 
-/*
- * @Author: richen
- * @Date: 2020-07-06 19:53:43
- * @LastEditTime: 2024-04-01 15:44:15
- * @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 (Helper.isEmpty(opt)) {
-        DefaultLogger.Warn(`Missing CacheStore server configuration. Please write a configuration item with the key name 'CacheStore' in the db.ts file.`);
-    }
-    storeCache.store = CacheStore.getInstance(opt);
-    if (!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 = IOCContainer.getApp();
-    app && app.once("appReady", async function () {
-        await GetCacheStore(app);
-    });
-}
-/**
- * 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 = 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;
-                    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 = Helper.toString(props[item]);
-                                key += `:${opt.params[item]}:${value}`;
-                            }
-                        }
-                        // 防止key超长
-                        if (key.length > longKey) {
-                            key = Helper.murmurHash(key);
-                        }
-                    }
-                    let res = await store.get(key).catch(() => null);
-                    if (!Helper.isEmpty(res)) {
-                        return JSON.parse(res);
-                    }
-                    // tslint:disable-next-line: no-invalid-this
-                    res = await value.apply(this, props);
-                    // prevent cache penetration
-                    if (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.
- * 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 = 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;
-                    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 = Helper.toString(props[item]);
-                                key += `:${opt.params[item]}:${value}`;
-                            }
-                        }
-                        // 防止key超长
-                        if (key.length > longKey) {
-                            key = Helper.murmurHash(key);
-                        }
-                    }
-                    // tslint:disable-next-line: no-invalid-this
-                    const res = await value.apply(this, props);
-                    store.del(key).catch(() => null);
-                    if (opt.delayedDoubleDeletion) {
-                        asyncDelayedExecution(2000, () => {
-                            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;
-}
-/**
- *
- * @param ms
- * @returns
- */
-function delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-/**
- * async delayed execution func
- * @param ms
- * @param fn
- * @returns
- */
-async function asyncDelayedExecution(ms, fn) {
-    await delay(ms); // delay ms second
-    return fn();
+/* 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>
+ */
+const longKey = 128;
+/**
+ * Extract parameter names from function signature
+ * @param func The function to extract parameters from
+ * @returns Array of parameter names
+ */
+function getArgs(func) {
+    try {
+        // Match function parameters in parentheses
+        const args = func.toString().match(/.*?\(([^)]*)\)/);
+        if (args && args.length > 1) {
+            // Split parameters into array and clean them
+            return args[1].split(",").map(function (a) {
+                // Remove inline comments and whitespace
+                return a.replace(/\/\*.*\*\//, "").trim();
+            }).filter(function (ae) {
+                // Filter out empty strings
+                return ae;
+            });
+        }
+        return [];
+    }
+    catch (error) {
+        // Return empty array if parsing fails
+        return [];
+    }
+}
+/**
+ * Get parameter indexes based on parameter names
+ * @param funcParams Function parameter names
+ * @param params Target parameter names to find indexes for
+ * @returns Array of parameter indexes (-1 if not found)
+ */
+function getParamIndex(funcParams, params) {
+    return params.map(param => funcParams.indexOf(param));
+}
+/**
+ * Generate cache key based on cache name and parameters
+ * @param cacheName base cache name
+ * @param paramIndexes parameter indexes
+ * @param paramNames parameter names
+ * @param props method arguments
+ * @returns generated cache key
+ */
+function generateCacheKey(cacheName, paramIndexes, paramNames, props) {
+    let key = cacheName;
+    for (let i = 0; i < paramIndexes.length; i++) {
+        const paramIndex = paramIndexes[i];
+        if (paramIndex >= 0 && props[paramIndex] !== undefined) {
+            key += `:${paramNames[i]}:${Helper.toString(props[paramIndex])}`;
+        }
+    }
+    return key.length > longKey ? Helper.murmurHash(key) : key;
+}
+/**
+ * Create a delay promise
+ * @param ms Delay time in milliseconds
+ * @returns Promise that resolves after the specified delay
+ */
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Execute a function after a specified delay
+ * @param fn Function to execute
+ * @param ms Delay time in milliseconds
+ * @returns Promise that resolves with the function result
+ */
+async function asyncDelayedExecution(fn, ms) {
+    await delay(ms);
+    return fn();
+}
+
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2024-11-07 16:00:02
+ * @LastEditTime: 2024-11-07 16:00:05
+ * @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 && Helper.isFunction(app.config)) {
+        opt = app.config("CacheStore") || app.config("CacheStore", "db");
+        if (Helper.isEmpty(opt)) {
+            DefaultLogger.Warn(`Missing CacheStore server configuration. Please write a configuration item with the key name 'CacheStore' in the db.ts file.`);
+        }
+    }
+    storeCache.store = CacheStore.getInstance(opt);
+    if (!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 = IOCContainer.getApp();
+    app?.once("appReady", async () => {
+        await GetCacheStore(app);
+    });
+}
+/**
+ * Close cache store connection for cleanup (mainly for testing)
+ */
+async function CloseCacheStore() {
+    if (storeCache.store && storeCache.store.client) {
+        try {
+            const client = storeCache.store.client;
+            if (typeof client.quit === 'function') {
+                await client.quit();
+            }
+            else if (typeof client.close === 'function') {
+                await client.close();
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        finally {
+            storeCache.store = null;
+        }
+    }
+}
+
+/*
+ * @Author: richen
+ * @Date: 2020-07-06 19:53:43
+ * @LastEditTime: 2024-11-07 15:53:46
+ * @Description:
+ * @Copyright (c) - <richenlin(at)gmail.com>
+ */
+/**
+ * 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 = 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, mergedOpt.params || []);
+        descriptor = {
+            configurable,
+            enumerable,
+            writable: true,
+            async value(...props) {
+                const store = await GetCacheStore(this.app).catch((e) => {
+                    DefaultLogger.error("Get cache store instance failed." + e.message);
+                    return null;
+                });
+                if (store) {
+                    const key = generateCacheKey(cacheName, paramIndexes, mergedOpt.params, props);
+                    const res = await store.get(key).catch((e) => {
+                        DefaultLogger.error("Cache get error:" + e.message);
+                    });
+                    if (!Helper.isEmpty(res)) {
+                        return JSON.parse(res);
+                    }
+                    const result = await value.apply(this, props);
+                    // async refresh store
+                    store.set(key, Helper.isJSONObj(result) ? JSON.stringify(result) : result, mergedOpt.timeout).catch((e) => {
+                        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 = 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) => {
+                    DefaultLogger.error("Get cache store instance failed." + e.message);
+                    return null;
+                });
+                if (store) {
+                    const key = generateCacheKey(cacheName, paramIndexes, opt.params || [], props);
+                    const result = await value.apply(this, props);
+                    store.del(key).catch((e) => {
+                        DefaultLogger.error("Cache delete error:" + e.message);
+                    });
+                    if (opt.delayedDoubleDeletion) {
+                        const delayTime = 5000;
+                        asyncDelayedExecution(() => {
+                            store.del(key).catch((e) => {
+                                DefaultLogger.error("Cache double delete error:" + e.message);
+                            });
+                        }, delayTime);
+                    }
+                    return result;
+                }
+                else {
+                    // If store is not available, execute method directly
+                    return value.apply(this, props);
+                }
+            }
+        };
+        // bind app_ready hook event 
+        InitCacheStore();
+        return descriptor;
+    };
 }
 
-export { CacheAble, CacheEvict, GetCacheStore };
+export { CacheAble, CacheEvict, CloseCacheStore, GetCacheStore, InitCacheStore };