koatty_cacheable 2.0.0 → 2.0.2

package/dist/index.js

@@ -1,143 +1,101 @@
 /*!
 * @Author: richen
-* @Date: 2025-06-23 01:59:54
+* @Date: 2026-01-28 11:25:40
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
 'use strict';
 
-var koatty_logger = require('koatty_logger');
 var koatty_lib = require('koatty_lib');
+var koatty_logger = require('koatty_logger');
 var koatty_store = require('koatty_store');
 var koatty_container = require('koatty_container');
 
+/*
+ * @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
 };
+// Promise to track initialization in progress
+let initPromise = null;
 /**
  * get instances of storeCache
  *
  * @export
- * @param {Application} app
+ * @param {StoreOptions} options
  * @returns {*}  {CacheStore}
  */
-async function GetCacheStore(app) {
+async function GetCacheStore(options) {
+    // Return existing store if available
     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. `);
+    // If initialization is in progress, wait for it
+    if (initPromise) {
+        return initPromise;
     }
-    await storeCache.store.client.getConnection();
-    return storeCache.store;
-}
-
-/*
- * @Author: richen
- * @Date: 2020-07-06 19:53:43
- * @LastEditTime: 2025-06-23 15:53:46
- * @Description:
- * @Copyright (c) - <richenlin(at)gmail.com>
- */
-class CacheManager {
-    static instance;
-    cacheStore = null;
-    defaultTimeout = 300;
-    defaultDelayedDoubleDeletion = true;
-    static getInstance() {
-        if (!CacheManager.instance) {
-            CacheManager.instance = new CacheManager();
+    if (koatty_lib.Helper.isEmpty(options)) {
+        if (!storeCache.store) {
+            koatty_logger.DefaultLogger.Warn(`CacheStore not initialized. Please call KoattyCached() first with proper options in your application startup.`);
         }
-        return CacheManager.instance;
-    }
-    setCacheStore(store) {
-        this.cacheStore = store;
-    }
-    getCacheStore() {
-        return this.cacheStore;
-    }
-    setDefaultConfig(timeout, delayedDoubleDeletion) {
-        if (timeout !== undefined)
-            this.defaultTimeout = timeout;
-        if (delayedDoubleDeletion !== undefined)
-            this.defaultDelayedDoubleDeletion = delayedDoubleDeletion;
-    }
-    getDefaultTimeout() {
-        return this.defaultTimeout;
-    }
-    getDefaultDelayedDoubleDeletion() {
-        return this.defaultDelayedDoubleDeletion;
+        return storeCache.store || null;
     }
+    // Start initialization and track it
+    initPromise = (async () => {
+        try {
+            storeCache.store = koatty_store.CacheStore.getInstance(options);
+            if (!koatty_lib.Helper.isFunction(storeCache.store.getConnection)) {
+                throw Error(`CacheStore connection failed. `);
+            }
+            await storeCache.store.client.getConnection();
+            return storeCache.store;
+        }
+        finally {
+            // Clear init promise after completion
+            initPromise = null;
+        }
+    })();
+    return initPromise;
 }
-
-/**
- * @Description: Cache injector, unified processing of all cache decorators
- * @Usage:
- * @Author: richen
- * @Date: 2025-01-10 14:00:00
- * @LastEditTime: 2025-01-10 14:00:00
- * @License: BSD (3-Clause)
- * @Copyright (c): <richenlin(at)gmail.com>
- */
-// import { Helper } from 'koatty_lib';
-// Create logger instance
-const logger$1 = new koatty_logger.Logger();
 /**
- * Cache injector - initialize global cache manager and store
- * @param options Cache options
- * @param app Koatty application instance
+ * Close cache store connection for cleanup (mainly for testing)
  */
-async function injectCache(options, app) {
-    try {
-        logger$1.Debug('Initializing cache system...');
-        // Get cache store instance
-        const store = await GetCacheStore(app);
-        if (!store) {
-            logger$1.Warn('Cache store unavailable, cache system disabled');
-            return;
+async function CloseCacheStore() {
+    if (storeCache.store) {
+        try {
+            if (storeCache.store.client) {
+                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
         }
-        // Initialize global cache manager
-        const cacheManager = CacheManager.getInstance();
-        cacheManager.setCacheStore(store);
-        // Set default configuration
-        cacheManager.setDefaultConfig(options.cacheTimeout || 300, options.delayedDoubleDeletion !== undefined ? options.delayedDoubleDeletion : true);
-        logger$1.Info(`Cache system initialized successfully with timeout: ${options.cacheTimeout || 300}s`);
-    }
-    catch (error) {
-        logger$1.Error('Cache system initialization failed:', error);
     }
-}
-/**
- * Close cache store connection
- * @param app Koatty application instance
- */
-async function closeCacheStore(_app) {
+    // Clear the CacheStore singleton instance
     try {
-        logger$1.Debug('Closing cache store connection...');
-        // Reset global cache manager
-        const cacheManager = CacheManager.getInstance();
-        const store = cacheManager.getCacheStore();
-        await store?.close();
-        cacheManager.setCacheStore(null);
-        logger$1.Info('Cache store connection closed');
+        await koatty_store.CacheStore.clearAllInstances();
     }
-    catch (error) {
-        logger$1.Error('Error closing cache store connection:', error);
+    catch {
+        // Ignore cleanup errors
     }
+    // Always clear the cache
+    storeCache.store = null;
+    initPromise = null;
 }
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
@@ -163,8 +121,11 @@ function getArgs(func) {
         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();
+                // Remove multi-line comments /* ... */ and single-line comments //
+                const param = a.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").trim();
+                // Extract parameter name (before : or = or end of string)
+                const match = param.match(/^(\w+)/);
+                return match ? match[1] : "";
             }).filter(function (ae) {
                 // Filter out empty strings
                 return ae;
@@ -230,17 +191,6 @@ async function asyncDelayedExecution(fn, ms) {
  * @Description:
  * @Copyright (c) - <richenlin(at)gmail.com>
  */
-// Create logger instance
-const logger = new koatty_logger.Logger();
-// Define cache decorator types
-exports.DecoratorType = void 0;
-(function (DecoratorType) {
-    DecoratorType["CACHE_EVICT"] = "CACHE_EVICT";
-    DecoratorType["CACHE_ABLE"] = "CACHE_ABLE";
-})(exports.DecoratorType || (exports.DecoratorType = {}));
-// IOC container key constant
-const COMPONENT_CACHE = "COMPONENT_CACHE";
-const CACHE_METADATA_KEY = "CACHE_METADATA_KEY";
 /**
  * Decorate this method to support caching.
  * The cache method returns a value to ensure that the next time
@@ -259,79 +209,70 @@ const CACHE_METADATA_KEY = "CACHE_METADATA_KEY";
  * Use the 'id' parameters of the method as cache subkeys, the cache expiration time 30s
  * @returns {MethodDecorator}
  */
-function CacheAble(cacheNameOrOpt, opt = {}) {
-    // Handle overloaded parameters
-    let cacheName;
-    let options;
-    if (typeof cacheNameOrOpt === 'string') {
-        cacheName = cacheNameOrOpt;
-        options = opt;
-    }
-    else {
-        options = cacheNameOrOpt || {};
-        cacheName = options.cacheName;
-    }
+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.");
         }
-        // Generate cache name if not provided
-        const finalCacheName = cacheName || `${target.constructor.name}:${String(methodName)}`;
-        // Get original method
-        const originalMethod = descriptor.value;
-        if (!koatty_lib.Helper.isFunction(originalMethod)) {
-            throw new Error(`CacheAble decorator can only be applied to methods`);
-        }
-        // Create wrapped method
-        descriptor.value = function (...args) {
-            const cacheManager = CacheManager.getInstance();
-            const store = cacheManager.getCacheStore();
-            // If cache store is not available, execute original method directly
-            if (!store) {
-                logger.Debug(`Cache store not available for ${finalCacheName}, executing original method`);
-                return originalMethod.apply(this, args);
+        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 || []);
+        // Validate parameters
+        const invalidParams = [];
+        (mergedOpt.params || []).forEach((param, index) => {
+            if (paramIndexes[index] === -1) {
+                invalidParams.push(param);
             }
-            // Get method parameter list
-            const funcParams = getArgs(originalMethod);
-            // Get cache parameter positions
-            const paramIndexes = getParamIndex(funcParams, options.params || []);
-            return (async () => {
-                try {
-                    // Generate cache key
-                    const key = generateCacheKey(finalCacheName, paramIndexes, options.params || [], args);
-                    // Try to get data from cache 
-                    const cached = await store.get(key).catch((e) => {
-                        logger.Debug("Cache get error:" + e.message);
-                        return null;
+        });
+        if (invalidParams.length > 0) {
+            koatty_logger.DefaultLogger.Warn(`CacheAble: Parameter(s) [${invalidParams.join(", ")}] not found in method ${String(methodName)}. These parameters will be ignored.`);
+        }
+        descriptor = {
+            configurable,
+            enumerable,
+            writable: true,
+            async value(...props) {
+                const store = await GetCacheStore().catch((e) => {
+                    koatty_logger.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) => {
+                        koatty_logger.DefaultLogger.error("Cache get error:" + e.message);
                     });
-                    if (!koatty_lib.Helper.isEmpty(cached)) {
-                        logger.Debug(`Cache hit for key: ${key}`);
+                    if (!koatty_lib.Helper.isEmpty(res)) {
                         try {
-                            return JSON.parse(cached);
+                            return JSON.parse(res);
                         }
-                        catch {
-                            // If parse fails, return as string (for simple values)
-                            return cached;
+                        catch (e) {
+                            const error = e;
+                            koatty_logger.DefaultLogger.error("Cache JSON parse error:" + error.message);
+                            // 如果解析失败，删除损坏的缓存，重新执行方法
+                            store.del(key).catch((err) => {
+                                koatty_logger.DefaultLogger.error("Cache del error after parse failure:" + err.message);
+                            });
                         }
                     }
-                    logger.Debug(`Cache miss for key: ${key}`);
-                    // Execute original method
-                    const result = await originalMethod.apply(this, args);
-                    // Use decorator timeout if specified, otherwise use global default
-                    const timeout = options.timeout || cacheManager.getDefaultTimeout();
-                    // Asynchronously set cache
-                    store.set(key, koatty_lib.Helper.isJSONObj(result) ? JSON.stringify(result) : result, timeout).catch((e) => {
-                        logger.Debug("Cache set error:" + e.message);
+                    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;
                 }
-                catch (error) {
-                    logger.Debug(`CacheAble wrapper error: ${error.message}`);
-                    // If cache operation fails, execute original method directly
-                    return originalMethod.apply(this, args);
+                else {
+                    // tslint:disable-next-line: no-invalid-this
+                    return value.apply(this, props);
                 }
-            })();
+            }
         };
         return descriptor;
     };
@@ -352,119 +293,91 @@ function CacheAble(cacheNameOrOpt, opt = {}) {
  *  and clear the cache after the method executed
  * @returns
  */
-function CacheEvict(cacheNameOrOpt, opt = {}) {
-    // Handle overloaded parameters
-    let cacheName;
-    let options;
-    if (typeof cacheNameOrOpt === 'string') {
-        cacheName = cacheNameOrOpt;
-        options = opt;
-    }
-    else {
-        options = cacheNameOrOpt || {};
-        cacheName = options.cacheName;
-    }
+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.");
         }
-        // Save class to IOC container for tracking
-        koatty_container.IOCContainer.saveClass("COMPONENT", target, COMPONENT_CACHE);
-        // Generate cache name if not provided
-        const finalCacheName = cacheName || `${target.constructor.name}:${String(methodName)}`;
-        // Get original method
-        const originalMethod = descriptor.value;
-        if (!koatty_lib.Helper.isFunction(originalMethod)) {
-            throw new Error(`CacheEvict decorator can only be applied to methods`);
-        }
-        // Create wrapped method
-        descriptor.value = function (...args) {
-            const cacheManager = CacheManager.getInstance();
-            const store = cacheManager.getCacheStore();
-            // If cache store is not available, execute original method directly
-            if (!store) {
-                logger.Debug(`Cache store not available for ${finalCacheName}, executing original method`);
-                return originalMethod.apply(this, args);
+        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 || []);
+        // Validate parameters
+        const invalidParams = [];
+        (opt.params || []).forEach((param, index) => {
+            if (paramIndexes[index] === -1) {
+                invalidParams.push(param);
             }
-            // Get method parameter list
-            const funcParams = getArgs(originalMethod);
-            // Get cache parameter positions
-            const paramIndexes = getParamIndex(funcParams, options.params || []);
-            return (async () => {
-                try {
-                    // Generate cache key
-                    const key = generateCacheKey(finalCacheName, paramIndexes, options.params || [], args);
-                    // Execute original method
-                    const result = await originalMethod.apply(this, args);
-                    // Immediately clear cache
+        });
+        if (invalidParams.length > 0) {
+            koatty_logger.DefaultLogger.Warn(`CacheEvict: Parameter(s) [${invalidParams.join(", ")}] not found in method ${String(methodName)}. These parameters will be ignored.`);
+        }
+        descriptor = {
+            configurable,
+            enumerable,
+            writable: true,
+            async value(...props) {
+                const store = await GetCacheStore().catch((e) => {
+                    koatty_logger.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) => {
-                        logger.Debug("Cache delete error:" + e.message);
+                        koatty_logger.DefaultLogger.error("Cache delete error:" + e.message);
                     });
-                    // Use decorator setting if specified, otherwise use global default
-                    const enableDelayedDeletion = options.delayedDoubleDeletion !== undefined
-                        ? options.delayedDoubleDeletion
-                        : cacheManager.getDefaultDelayedDoubleDeletion();
-                    // Delayed double deletion strategy
-                    if (enableDelayedDeletion !== false) {
-                        const delayTime = 5000;
+                    if (opt.delayedDoubleDeletion) {
+                        const delayTime = opt.delayTime || 5000;
                         asyncDelayedExecution(() => {
                             store.del(key).catch((e) => {
-                                logger.Debug("Cache double delete error:" + e.message);
+                                koatty_logger.DefaultLogger.error("Cache double delete error:" + e.message);
                             });
                         }, delayTime);
                     }
                     return result;
                 }
-                catch (error) {
-                    logger.Debug(`CacheEvict wrapper error: ${error.message}`);
-                    // If cache operation fails, execute original method directly
-                    return originalMethod.apply(this, args);
+                else {
+                    // If store is not available, execute method directly
+                    return value.apply(this, props);
                 }
-            })();
+            }
         };
         return descriptor;
     };
 }
 
-/*
- * @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>
- */
 /**
  * defaultOptions
  */
 const defaultOptions = {
-    cacheTimeout: 300,
-    delayedDoubleDeletion: true,
-    redisConfig: {
-        host: "localhost",
-        port: 6379,
-        password: "",
-        db: 0,
-        keyPrefix: "redlock:"
-    }
+    type: "memory",
+    db: 0,
+    timeout: 30
 };
 /**
- * @param options - The options for the scheduled job
+ * @param options - The options for the cached options
  * @param app - The Koatty application instance
  */
-async function KoattyCache(options, app) {
+async function KoattyCached(options, app) {
     options = { ...defaultOptions, ...options };
-    // inject cache decorator
-    await injectCache(options, app);
-    // Register cleanup on app stop
-    app.on('appStop', async () => {
-        await closeCacheStore();
+    app.once("appReady", async function () {
+        // 初始化缓存存储
+        await GetCacheStore(options);
+    });
+    app.on("appStop", async function () {
+        // 关闭缓存存储
+        await CloseCacheStore();
     });
 }
 
-exports.CACHE_METADATA_KEY = CACHE_METADATA_KEY;
 exports.CacheAble = CacheAble;
 exports.CacheEvict = CacheEvict;
-exports.KoattyCache = KoattyCache;
+exports.CloseCacheStore = CloseCacheStore;
+exports.GetCacheStore = GetCacheStore;
+exports.KoattyCached = KoattyCached;