koatty_cacheable 1.3.2 → 1.3.7

package/dist/index.js

@@ -1,244 +1,199 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheEvict = exports.CacheAble = exports.GetCacheStore = void 0;
-const tslib_1 = require("tslib");
-/*
- * @Author: richen
- * @Date: 2020-07-06 19:53:43
- * @LastEditTime: 2021-07-07 11:11:05
- * @Description:
- * @Copyright (c) - <richenlin(at)gmail.com>
- */
-const helper = (0, tslib_1.__importStar)(require("koatty_lib"));
-const koatty_logger_1 = require("koatty_logger");
-const koatty_store_1 = require("koatty_store");
-const koatty_container_1 = require("koatty_container");
-// cacheStore
-const cacheStore = {
-    store: null
-};
-/**
- * get instances of cacheStore
- *
- * @export
- * @returns {*}
- */
-async function GetCacheStore(app) {
-    var _a;
-    if (cacheStore.store && cacheStore.store.getConnection) {
-        return cacheStore.store;
-    }
-    const opt = (_a = app.config("CacheStore", "db")) !== null && _a !== void 0 ? _a : {};
-    if (helper.isEmpty(opt)) {
-        koatty_logger_1.DefaultLogger.Warn(`Missing CacheStore server configuration. Please write a configuration item with the key name 'CacheStore' in the db.ts file.`);
-    }
-    cacheStore.store = koatty_store_1.Store.getInstance(opt);
-    if (!helper.isFunction(cacheStore.store.getConnection)) {
-        throw Error(`CacheStore connection failed. `);
-    }
-    return cacheStore.store;
-}
-exports.GetCacheStore = GetCacheStore;
-/**
- * initiation CacheStore connection and client.
- *
- * @param {Application} app
- * @returns {*}  {Promise<CacheStore>}
- */
-async function InitCacheStore(app) {
-    return 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 {(number | number[])} [paramKey] The index of the arguments.
- * @param {number} [timeout=3600] cache timeout
- * @returns {MethodDecorator}
- */
-function CacheAble(cacheName, paramKey, timeout = 3600) {
-    return (target, methodName, descriptor) => {
-        const componentType = koatty_container_1.IOCContainer.getType(target);
-        if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
-            throw Error("This decorator only used in the service、component class.");
-        }
-        let identifier = koatty_container_1.IOCContainer.getIdentifier(target);
-        identifier = identifier || (target.constructor ? (target.constructor.name || "") : "");
-        const { value, configurable, enumerable } = descriptor;
-        descriptor = {
-            configurable,
-            enumerable,
-            writable: true,
-            async value(...props) {
-                let cacheFlag = true;
-                const store = await GetCacheStore(this.app).catch(() => {
-                    cacheFlag = false;
-                    koatty_logger_1.DefaultLogger.Error("Get cache store instance failed.");
-                    return null;
+/*!
+* @Author: richen
+* @Date: 2022-05-27 11:35:38
+* @License: BSD (3-Clause)
+* @Copyright (c) - <richenlin(at)gmail.com>
+* @HomePage: https://koatty.org/
+*/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helper = require('koatty_lib');
+var koatty_logger = require('koatty_logger');
+var koatty_store = require('koatty_store');
+var koatty_container = require('koatty_container');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
                 });
-                if (cacheFlag) {
-                    // tslint:disable-next-line: one-variable-per-declaration
-                    let key = "", res;
-                    if (helper.isArray(paramKey)) {
-                        paramKey.map((it) => {
-                            if (!helper.isTrueEmpty(props[it])) {
-                                if (typeof props[it] === "object") {
-                                    key = `${key}${helper.murmurHash(JSON.stringify(props[it]))}`;
-                                }
-                                else {
-                                    key = `${key}${props[it] || ''}`;
-                                }
-                            }
-                        });
-                    }
-                    else if (helper.isNumber(paramKey)) {
-                        if (typeof props[paramKey] === "object") {
-                            key = helper.murmurHash(JSON.stringify(props[paramKey]));
-                        }
-                        else {
-                            key = props[paramKey] || "";
-                        }
-                    }
-                    else {
-                        key = `${identifier}:${methodName}`;
-                    }
-                    if (!helper.isTrueEmpty(key)) {
-                        res = await store.get(`${cacheName}:${key}`).catch(() => null);
-                    }
-                    else {
-                        res = await store.get(cacheName).catch(() => null);
-                    }
-                    try {
-                        res = JSON.parse(res || "");
-                    }
-                    catch (e) {
-                        res = null;
-                    }
-                    if (helper.isEmpty(res)) {
-                        // tslint:disable-next-line: no-invalid-this
-                        res = await value.apply(this, props);
-                        // prevent cache penetration
-                        if (helper.isEmpty(res)) {
-                            res = "";
-                            timeout = 60;
-                        }
-                        if (!helper.isTrueEmpty(key)) {
-                            store.set(`${cacheName}:${key}`, JSON.stringify(res), timeout).catch(() => null);
-                        }
-                        else {
-                            store.set(cacheName, JSON.stringify(res), timeout).catch(() => null);
-                        }
-                    }
-                    return res;
-                }
-                else {
-                    // tslint:disable-next-line: no-invalid-this
-                    return value.apply(this, props);
-                }
             }
-        };
-        // bind app_ready hook event 
-        bindSchedulerLockInit();
-        return descriptor;
-    };
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
 }
-exports.CacheAble = CacheAble;
-/**
- * bind scheduler lock init event
- *
- */
-const bindSchedulerLockInit = function () {
-    const app = koatty_container_1.IOCContainer.getApp();
-    app && app.once("appStart", async function () {
-        await InitCacheStore(app);
-    });
-};
-/**
- * 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 {(number | number[])} [paramKey] The index of the arguments.
- * @param {eventTimes} [eventTime="Before"]
- * @returns
- */
-function CacheEvict(cacheName, paramKey, eventTime = "Before") {
-    return (target, methodName, descriptor) => {
-        const componentType = koatty_container_1.IOCContainer.getType(target);
-        if (componentType !== "SERVICE" && componentType !== "COMPONENT") {
-            throw Error("This decorator only used in the service、component class.");
-        }
-        const identifier = koatty_container_1.IOCContainer.getIdentifier(target);
-        const { value, configurable, enumerable } = descriptor;
-        descriptor = {
-            configurable,
-            enumerable,
-            writable: true,
-            async value(...props) {
-                let cacheFlag = true;
-                const store = await GetCacheStore(this.app).catch(() => {
-                    cacheFlag = false;
-                    koatty_logger_1.DefaultLogger.Error("Get cache store instance failed.");
-                    return null;
-                });
-                if (cacheFlag) {
-                    let key = "";
-                    if (helper.isArray(paramKey)) {
-                        paramKey.map((it) => {
-                            if (!helper.isTrueEmpty(props[it])) {
-                                if (typeof props[it] === "object") {
-                                    key = `${key}${helper.murmurHash(JSON.stringify(props[it]))}`;
-                                }
-                                else {
-                                    key = `${key}${props[it] || ''}`;
-                                }
-                            }
-                        });
-                    }
-                    else if (helper.isNumber(paramKey)) {
-                        if (typeof props[paramKey] === "object") {
-                            key = helper.murmurHash(JSON.stringify(props[paramKey]));
-                        }
-                        else {
-                            key = props[paramKey] || "";
-                        }
-                    }
-                    else {
-                        key = `${identifier}:${methodName}`;
-                    }
-                    if (eventTime === "Before") {
-                        if (!helper.isTrueEmpty(key)) {
-                            await store.del(`${cacheName}:${key}`).catch(() => null);
-                        }
-                        else {
-                            await store.del(cacheName).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);
-                        if (!helper.isTrueEmpty(key)) {
-                            await store.del(`${cacheName}:${key}`).catch(() => null);
-                        }
-                        else {
-                            await store.del(cacheName).catch(() => null);
-                        }
-                        return res;
-                    }
-                }
-                else {
-                    // tslint:disable-next-line: no-invalid-this
-                    return value.apply(this, props);
-                }
-            }
-        };
-        return descriptor;
-    };
+
+var helper__namespace = /*#__PURE__*/_interopNamespace(helper);
+
+/*
+ * @Author: richen
+ * @Date: 2020-07-06 19:53:43
+ * @LastEditTime: 2021-12-02 16:20:52
+ * @Description:
+ * @Copyright (c) - <richenlin(at)gmail.com>
+ */
+// cacheStore
+const cacheStore = {
+    store: null
+};
+/**
+ * get instances of cacheStore
+ *
+ * @export
+ * @param {Application} app
+ * @returns {*}  {CacheStore}
+ */
+async function GetCacheStore(app) {
+    var _a;
+    if (cacheStore.store && cacheStore.store.getConnection) {
+        return cacheStore.store;
+    }
+    const opt = (_a = app.config("CacheStore", "db")) !== null && _a !== void 0 ? _a : {};
+    if (helper__namespace.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.`);
+    }
+    cacheStore.store = koatty_store.Store.getInstance(opt);
+    if (!helper__namespace.isFunction(cacheStore.store.getConnection)) {
+        throw Error(`CacheStore connection failed. `);
+    }
+    return cacheStore.store;
+}
+/**
+ * initiation CacheStore connection and client.
+ *
+ */
+async function InitCacheStore() {
+    const app = koatty_container.IOCContainer.getApp();
+    app && app.once("appStart", 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 {number} [timeout=3600] cache timeout
+ * @returns {MethodDecorator}
+ */
+function CacheAble(cacheName, timeout = 3600) {
+    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.");
+        }
+        let identifier = koatty_container.IOCContainer.getIdentifier(target);
+        identifier = identifier || (target.constructor ? (target.constructor.name || "") : "");
+        const { value, configurable, enumerable } = descriptor;
+        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 = "", res;
+                    if (props && props.length > 0) {
+                        key = `${identifier}:${methodName}:${helper__namespace.murmurHash(JSON.stringify(props))}`;
+                    }
+                    else {
+                        key = `${identifier}:${methodName}`;
+                    }
+                    res = await store.hget(cacheName, key).catch(() => null);
+                    if (!helper__namespace.isEmpty(res)) {
+                        return JSON.parse(res);
+                    }
+                    // tslint:disable-next-line: no-invalid-this
+                    res = await value.apply(this, props);
+                    // prevent cache penetration
+                    if (helper__namespace.isEmpty(res)) {
+                        res = "";
+                        timeout = 60;
+                    }
+                    // async set store
+                    store.hset(cacheName, key, JSON.stringify(res), 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 {eventTimes} [eventTime="Before"]
+ * @returns
+ */
+function CacheEvict(cacheName, 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.");
+        }
+        koatty_container.IOCContainer.getIdentifier(target);
+        const { value, configurable, enumerable } = descriptor;
+        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) {
+                    if (eventTime === "Before") {
+                        await store.del(cacheName).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(cacheName).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;
+    };
 }
+
+exports.CacheAble = CacheAble;
 exports.CacheEvict = CacheEvict;
-//# sourceMappingURL=index.js.map
+exports.GetCacheStore = GetCacheStore;

package/dist/index.mjs

@@ -0,0 +1,173 @@
+/*!
+* @Author: richen
+* @Date: 2022-05-27 11:35:38
+* @License: BSD (3-Clause)
+* @Copyright (c) - <richenlin(at)gmail.com>
+* @HomePage: https://koatty.org/
+*/
+import * as helper from 'koatty_lib';
+import { DefaultLogger } from 'koatty_logger';
+import { Store } from 'koatty_store';
+import { IOCContainer } from 'koatty_container';
+
+/*
+ * @Author: richen
+ * @Date: 2020-07-06 19:53:43
+ * @LastEditTime: 2021-12-02 16:20:52
+ * @Description:
+ * @Copyright (c) - <richenlin(at)gmail.com>
+ */
+// cacheStore
+const cacheStore = {
+    store: null
+};
+/**
+ * get instances of cacheStore
+ *
+ * @export
+ * @param {Application} app
+ * @returns {*}  {CacheStore}
+ */
+async function GetCacheStore(app) {
+    var _a;
+    if (cacheStore.store && cacheStore.store.getConnection) {
+        return cacheStore.store;
+    }
+    const opt = (_a = app.config("CacheStore", "db")) !== null && _a !== void 0 ? _a : {};
+    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.`);
+    }
+    cacheStore.store = Store.getInstance(opt);
+    if (!helper.isFunction(cacheStore.store.getConnection)) {
+        throw Error(`CacheStore connection failed. `);
+    }
+    return cacheStore.store;
+}
+/**
+ * initiation CacheStore connection and client.
+ *
+ */
+async function InitCacheStore() {
+    const app = IOCContainer.getApp();
+    app && app.once("appStart", 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 {number} [timeout=3600] cache timeout
+ * @returns {MethodDecorator}
+ */
+function CacheAble(cacheName, timeout = 3600) {
+    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.");
+        }
+        let identifier = IOCContainer.getIdentifier(target);
+        identifier = identifier || (target.constructor ? (target.constructor.name || "") : "");
+        const { value, configurable, enumerable } = descriptor;
+        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 = "", res;
+                    if (props && props.length > 0) {
+                        key = `${identifier}:${methodName}:${helper.murmurHash(JSON.stringify(props))}`;
+                    }
+                    else {
+                        key = `${identifier}:${methodName}`;
+                    }
+                    res = await store.hget(cacheName, 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.isEmpty(res)) {
+                        res = "";
+                        timeout = 60;
+                    }
+                    // async set store
+                    store.hset(cacheName, key, JSON.stringify(res), 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 {eventTimes} [eventTime="Before"]
+ * @returns
+ */
+function CacheEvict(cacheName, eventTime = "Before") {
+    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.");
+        }
+        IOCContainer.getIdentifier(target);
+        const { value, configurable, enumerable } = descriptor;
+        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) {
+                    if (eventTime === "Before") {
+                        await store.del(cacheName).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(cacheName).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;
+    };
+}
+
+export { CacheAble, CacheEvict, GetCacheStore };