koatty_cacheable 1.3.6 → 1.3.8

package/.rollup.config.js

@@ -0,0 +1,63 @@
+/*
+ * @Description: 
+ * @Usage: 
+ * @Author: richen
+ * @Date: 2021-12-17 10:20:44
+ * @LastEditTime: 2021-12-18 11:58:46
+ */
+import json from "@rollup/plugin-json";
+import typescript from 'rollup-plugin-typescript2';
+// import babel from '@rollup/plugin-babel';
+
+export default [
+    {
+        input: './src/index.ts',
+        output: [{
+            format: 'cjs',
+            file: './dist/index.js',
+            banner: require('./scripts/copyright')
+        }],
+        plugins: [
+            // babel({
+            //     babelHelpers: "runtime",
+            //     configFile: './babel.config.js',
+            //     exclude: 'node_modules/**',
+            // }),
+            json(),
+            typescript({
+                tsconfigOverride: {
+                    compilerOptions: {
+                        declaration: false,
+                        declarationMap: false,
+                        module: "ESNext"
+                    }
+                }
+            })
+        ]
+    },
+    {
+        input: './src/index.ts',
+        output: [{
+            format: 'es',
+            file: './dist/index.mjs',
+            banner: require('./scripts/copyright')
+        }],
+        plugins: [
+            // babel({
+            //     babelHelpers: "runtime",
+            //     configFile: './babel.config.js',
+            //     exclude: 'node_modules/**',
+            // }),
+            json(),
+            typescript({
+                tsconfigOverride: {
+                    compilerOptions: {
+                        declaration: false,
+                        declarationMap: false,
+                        module: "ESNext"
+                    }
+                }
+            })
+        ]
+    }
+]

package/CHANGELOG.md

@@ -2,8 +2,6 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
-### [1.3.6](https://github.com/thinkkoa/koatty_cacheable/compare/v1.3.4...v1.3.6) (2021-12-02)
+### [1.3.8](https://github.com/thinkkoa/koatty_cacheable/compare/v1.3.6...v1.3.8) (2023-01-13)
 
-### [1.3.4](https://github.com/thinkkoa/koatty_cacheable/compare/v1.3.2...v1.3.4) (2021-11-23)
-
-### [1.3.2](https://github.com/thinkkoa/koatty_cacheable/compare/v1.2.12...v1.3.2) (2021-11-20)
+### [1.3.7](https://github.com/thinkkoa/koatty_cacheable/compare/v1.3.6...v1.3.7) (2022-05-27)

package/dist/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, Koatty
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/README.md

@@ -0,0 +1,57 @@
+# koatty_cacheable
+Cacheable for koatty.
+
+Koatty框架的 CacheAble, Cacheable, CacheEvict 支持库
+
+
+# Usage
+
+db.ts in koatty project:
+
+```js
+export default {
+    ...
+
+    "CacheStore": {
+        type: "memory", // redis or memory, memory is default
+        // key_prefix: "koatty",
+        // host: '127.0.0.1',
+        // port: 6379,
+        // name: "",
+        // username: "",
+        // password: "",
+        // db: 0,
+        // timeout: 30,
+        // pool_size: 10,
+        // conn_timeout: 30
+    },
+
+    ...
+};
+
+```
+
+used in service: 
+
+```js
+import { CacheAble, CacheEvict, GetCacheStore } from "koatty_cacheable";
+
+export class TestService {
+
+    @CacheAble("testCache") // auto cached
+    getTest(){
+        //todo
+    }
+
+    @CacheEvict("testCache") // auto clear cache
+    setTest(){
+        //todo
+    }
+
+    test(){
+        const store = GetCacheStore(this.app);
+        store.set(key, value);
+    }
+}
+
+```

package/dist/index.d.ts

@@ -1,34 +1,47 @@
-import { CacheStore } from "koatty_store";
-import { Application } from 'koatty_container';
-/**
- * get instances of cacheStore
- *
- * @export
- * @param {Application} app
- * @returns {*}  {CacheStore}
- */
-export declare function GetCacheStore(app: Application): Promise<CacheStore>;
-/**
- * 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}
- */
-export declare function CacheAble(cacheName: string, timeout?: number): MethodDecorator;
-/**
- *
- */
-export declare type eventTimes = "Before" | "After";
-/**
- * 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
- */
-export declare function CacheEvict(cacheName: string, eventTime?: eventTimes): (target: any, methodName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/*!
+* @Author: richen
+* @Date: 2023-01-13 14:17:21
+* @License: BSD (3-Clause)
+* @Copyright (c) - <richenlin(at)gmail.com>
+* @HomePage: https://koatty.org/
+*/
+import { Application } from 'koatty_container';
+import { CacheStore } from 'koatty_store';
+
+/**
+ * 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}
+ */
+export declare function CacheAble(cacheName: string, timeout?: number): MethodDecorator;
+
+/**
+ * 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
+ */
+export declare function CacheEvict(cacheName: string, eventTime?: eventTimes): (target: any, methodName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+/**
+ *
+ */
+export declare type eventTimes = "Before" | "After";
+
+/**
+ * get instances of cacheStore
+ *
+ * @export
+ * @param {Application} app
+ * @returns {*}  {CacheStore}
+ */
+export declare function GetCacheStore(app: Application): Promise<CacheStore>;
+
+export { }

package/dist/index.js

@@ -1,171 +1,196 @@
-"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-12-02 16:20:52
- * @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
- * @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)) {
-        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.
- *
- */
-async function InitCacheStore() {
-    const app = koatty_container_1.IOCContainer.getApp();
-    app && app.once("appStart", async function () {
-        await GetCacheStore(app);
+/*!
+* @Author: richen
+* @Date: 2023-01-13 14:17:07
+* @License: BSD (3-Clause)
+* @Copyright (c) - <richenlin(at)gmail.com>
+* @HomePage: https://koatty.org/
+*/
+'use strict';
+
+var helper = require('koatty_lib');
+var koatty_logger = require('koatty_logger');
+var koatty_store = require('koatty_store');
+var koatty_container = require('koatty_container');
+
+function _interopNamespaceDefault(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]; }
+        });
+      }
     });
+  }
+  n.default = e;
+  return Object.freeze(n);
 }
-/**
- * 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_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;
-                });
-                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;
-    };
+
+var helper__namespace = /*#__PURE__*/_interopNamespaceDefault(helper);
+
+/*
+ * @Author: richen
+ * @Date: 2020-07-06 19:53:43
+ * @LastEditTime: 2023-01-13 14:16:02
+ * @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;
-/**
- * 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_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) {
-                    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.CacheEvict = CacheEvict;
-//# sourceMappingURL=index.js.map
+exports.GetCacheStore = GetCacheStore;