koatty_cacheable 1.6.1 → 2.0.0

package/dist/index.js

@@ -1,16 +1,144 @@
 /*!
 * @Author: richen
-* @Date: 2025-06-09 13:04:37
+* @Date: 2025-06-23 01:59:54
 * @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_lib = require('koatty_lib');
 var koatty_store = require('koatty_store');
+var koatty_container = require('koatty_container');
+
+// 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;
+}
+
+/*
+ * @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();
+        }
+        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;
+    }
+}
+
+/**
+ * @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
+ */
+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;
+        }
+        // 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) {
+    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');
+    }
+    catch (error) {
+        logger$1.Error('Error closing cache store connection:', error);
+    }
+}
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /*
@@ -95,84 +223,6 @@ async function asyncDelayedExecution(fn, 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 && 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);
-    });
-}
-/**
- * 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
@@ -180,6 +230,17 @@ async function CloseCacheStore() {
  * @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
@@ -198,53 +259,80 @@ async function CloseCacheStore() {
  * Use the 'id' parameters of the method as cache subkeys, the cache expiration time 30s
  * @returns {MethodDecorator}
  */
-function CacheAble(cacheName, opt = {
-    params: [],
-    timeout: 300,
-}) {
+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;
+    }
     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, mergedOpt.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) {
-                    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);
+        // 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);
+            }
+            // 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 (!koatty_lib.Helper.isEmpty(res)) {
-                        return JSON.parse(res);
+                    if (!koatty_lib.Helper.isEmpty(cached)) {
+                        logger.Debug(`Cache hit for key: ${key}`);
+                        try {
+                            return JSON.parse(cached);
+                        }
+                        catch {
+                            // If parse fails, return as string (for simple values)
+                            return cached;
+                        }
                     }
-                    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);
+                    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);
                     });
                     return result;
                 }
-                else {
-                    // tslint:disable-next-line: no-invalid-this
-                    return value.apply(this, props);
+                catch (error) {
+                    logger.Debug(`CacheAble wrapper error: ${error.message}`);
+                    // If cache operation fails, execute original method directly
+                    return originalMethod.apply(this, args);
                 }
-            }
+            })();
         };
-        // bind app_ready hook event 
-        InitCacheStore();
         return descriptor;
     };
 }
@@ -264,59 +352,119 @@ function CacheAble(cacheName, opt = {
  *  and clear the cache after the method executed
  * @returns
  */
-function CacheEvict(cacheName, opt = {
-    delayedDoubleDeletion: true,
-}) {
+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;
+    }
     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) {
-                    const key = generateCacheKey(cacheName, paramIndexes, opt.params || [], props);
-                    const result = await value.apply(this, props);
+        // 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);
+            }
+            // 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
                     store.del(key).catch((e) => {
-                        koatty_logger.DefaultLogger.error("Cache delete error:" + e.message);
+                        logger.Debug("Cache delete error:" + e.message);
                     });
-                    if (opt.delayedDoubleDeletion) {
+                    // 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;
                         asyncDelayedExecution(() => {
                             store.del(key).catch((e) => {
-                                koatty_logger.DefaultLogger.error("Cache double delete error:" + e.message);
+                                logger.Debug("Cache double delete error:" + e.message);
                             });
                         }, delayTime);
                     }
                     return result;
                 }
-                else {
-                    // If store is not available, execute method directly
-                    return value.apply(this, props);
+                catch (error) {
+                    logger.Debug(`CacheEvict wrapper error: ${error.message}`);
+                    // If cache operation fails, execute original method directly
+                    return originalMethod.apply(this, args);
                 }
-            }
+            })();
         };
-        // bind app_ready hook event 
-        InitCacheStore();
         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:"
+    }
+};
+/**
+ * @param options - The options for the scheduled job
+ * @param app - The Koatty application instance
+ */
+async function KoattyCache(options, app) {
+    options = { ...defaultOptions, ...options };
+    // inject cache decorator
+    await injectCache(options, app);
+    // Register cleanup on app stop
+    app.on('appStop', async () => {
+        await closeCacheStore();
+    });
+}
+
+exports.CACHE_METADATA_KEY = CACHE_METADATA_KEY;
 exports.CacheAble = CacheAble;
 exports.CacheEvict = CacheEvict;
-exports.CloseCacheStore = CloseCacheStore;
-exports.GetCacheStore = GetCacheStore;
-exports.InitCacheStore = InitCacheStore;
+exports.KoattyCache = KoattyCache;