@midwayjs/cache-manager 3.0.0

package/README.md

@@ -0,0 +1,12 @@
+# midway cache manager
+
+[![Package Quality](http://npm.packagequality.com/shield/midway-core.svg)](http://packagequality.com/#?package=midway-core)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/midwayjs/midway/pulls)
+
+this is a sub package for midway.
+
+Document: [https://midwayjs.org](https://midwayjs.org)
+
+## License
+
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/configuration.d.ts

@@ -0,0 +1,9 @@
+import { ILifeCycle, IMidwayContainer, MidwayDecoratorService } from '@midwayjs/core';
+import { CachingFactory } from './factory';
+export declare function getClassMethodDefaultCacheKey(target: any, methodName: string): string;
+export declare class CacheConfiguration implements ILifeCycle {
+    decoratorService: MidwayDecoratorService;
+    cacheService: CachingFactory;
+    onReady(container: IMidwayContainer): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,67 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheConfiguration = exports.getClassMethodDefaultCacheKey = void 0;
+const core_1 = require("@midwayjs/core");
+const cacheKey_1 = require("./decorator/cacheKey");
+const factory_1 = require("./factory");
+function getClassMethodDefaultCacheKey(target, methodName) {
+    return target.name + '-' + (0, core_1.getProviderUUId)(target) + '-' + methodName;
+}
+exports.getClassMethodDefaultCacheKey = getClassMethodDefaultCacheKey;
+let CacheConfiguration = class CacheConfiguration {
+    async onReady(container) {
+        // init factory and caching instance
+        this.cacheService = await container.getAsync(factory_1.CachingFactory);
+        // register @Caching decorator implementation
+        this.decoratorService.registerMethodHandler(cacheKey_1.CACHE_DECORATOR_KEY, ({ target, propertyName, metadata }) => {
+            if (!metadata.cacheKey) {
+                metadata.cacheKey = getClassMethodDefaultCacheKey(target, propertyName);
+            }
+            return {
+                around: async (joinPoint) => {
+                    const cachingInstance = this.cacheService.get(metadata.cacheInstanceName);
+                    if (typeof metadata.cacheKey === 'function') {
+                        metadata.cacheKey = await metadata.cacheKey({
+                            methodArgs: joinPoint.args,
+                            ctx: joinPoint.target[core_1.REQUEST_OBJ_CTX_KEY],
+                            target: joinPoint.target,
+                        });
+                    }
+                    if (typeof metadata.cacheKey === 'string') {
+                        return cachingInstance.methodWrap(metadata.cacheKey, joinPoint.proceed, joinPoint.args, metadata.ttl);
+                    }
+                    else {
+                        return joinPoint.proceed(...joinPoint.args);
+                    }
+                },
+            };
+        });
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], CacheConfiguration.prototype, "decoratorService", void 0);
+CacheConfiguration = __decorate([
+    (0, core_1.Configuration)({
+        namespace: 'cacheManager',
+        importConfigs: [
+            {
+                default: {
+                    cacheManager: {},
+                },
+            },
+        ],
+    })
+], CacheConfiguration);
+exports.CacheConfiguration = CacheConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/decorator/cacheKey.d.ts

@@ -0,0 +1,9 @@
+import { IMidwayContext } from '@midwayjs/core';
+export declare const CACHE_DECORATOR_KEY = "cache-manager:caching";
+export type CachingDecoratorKeyOptions = string | ((options: {
+    methodArgs: any[];
+    ctx?: IMidwayContext;
+    target: any;
+}) => string);
+export declare function Caching(cacheInstanceName: string, cacheKeyOrTTL?: CachingDecoratorKeyOptions | number, ttl?: number): MethodDecorator;
+//# sourceMappingURL=cacheKey.d.ts.map

package/dist/decorator/cacheKey.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Caching = exports.CACHE_DECORATOR_KEY = void 0;
+const core_1 = require("@midwayjs/core");
+exports.CACHE_DECORATOR_KEY = 'cache-manager:caching';
+function Caching(cacheInstanceName, cacheKeyOrTTL, ttl) {
+    if (typeof cacheKeyOrTTL === 'number') {
+        ttl = cacheKeyOrTTL;
+        cacheKeyOrTTL = undefined;
+    }
+    return (0, core_1.createCustomMethodDecorator)(exports.CACHE_DECORATOR_KEY, {
+        cacheInstanceName,
+        cacheKey: cacheKeyOrTTL,
+        ttl,
+    });
+}
+exports.Caching = Caching;
+//# sourceMappingURL=cacheKey.js.map

package/dist/factory.d.ts

@@ -0,0 +1,15 @@
+import { IMidwayContainer, ServiceFactory, ServiceFactoryConfigOption } from '@midwayjs/core';
+import { CachingConfig } from 'cache-manager';
+import { CacheManagerOptions, MidwayCache, MidwayMultiCache, MidwayUnionCache } from './interface';
+export declare class CachingFactory extends ServiceFactory<MidwayUnionCache> {
+    protected cacheManagerConfig: ServiceFactoryConfigOption<CacheManagerOptions>;
+    protected applicationContext: IMidwayContainer;
+    protected init(): Promise<void>;
+    protected createClient(config: CacheManagerOptions<any>, clientName: string): Promise<void | MidwayUnionCache>;
+    wrapCaching(cacheInstance: MidwayCache, cachingArgs?: CachingConfig<any>): MidwayCache;
+    wrapMultiCaching(cacheInstance: MidwayMultiCache, caches: MidwayCache[]): MidwayMultiCache;
+    getName(): string;
+    getCaching(cacheKey: string): MidwayCache;
+    getMultiCaching(cacheKey: string): MidwayMultiCache;
+}
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.js

@@ -0,0 +1,155 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachingFactory = void 0;
+const core_1 = require("@midwayjs/core");
+const cache_manager_1 = require("cache-manager");
+const promise_coalesce_1 = require("promise-coalesce");
+let CachingFactory = class CachingFactory extends core_1.ServiceFactory {
+    async init() {
+        await this.initClients(this.cacheManagerConfig);
+    }
+    async createClient(config, clientName) {
+        // multi cache
+        if (Array.isArray(config.store)) {
+            const newFactory = [];
+            for (const storeConfig of config.store) {
+                if (typeof storeConfig === 'string') {
+                    if (!this.has(storeConfig)) {
+                        throw new core_1.MidwayCommonError(`cache instance "${storeConfig}" not found in "${clientName}", please check your configuration.`);
+                    }
+                    newFactory.push(this.get(storeConfig));
+                }
+                else if (typeof storeConfig === 'function') {
+                    newFactory.push(await storeConfig());
+                }
+                else if (storeConfig['wrap']) {
+                    // wrap is a caching object method
+                    newFactory.push(storeConfig['wrap']);
+                }
+                else if (typeof storeConfig === 'object') {
+                    if (typeof storeConfig.store === 'function') {
+                        storeConfig.store = await storeConfig.store(storeConfig['options'] || {}, this.applicationContext);
+                    }
+                    if (!storeConfig.store) {
+                        throw new core_1.MidwayCommonError(`cache instance "${clientName}" store is undefined, please check your configuration.`);
+                    }
+                    newFactory.push(await (0, cache_manager_1.caching)(storeConfig.store, storeConfig['options']));
+                }
+                else {
+                    throw new core_1.MidwayCommonError('invalid cache config');
+                }
+            }
+            const cacheInstance = await (0, cache_manager_1.multiCaching)(newFactory);
+            return this.wrapMultiCaching(cacheInstance, newFactory);
+        }
+        else {
+            // single cache
+            if (typeof config.store === 'function') {
+                config.store = await config.store(config['options'] || {}, this.applicationContext);
+            }
+            if (!config.store) {
+                throw new core_1.MidwayCommonError(`cache instance "${clientName}" store is undefined, please check your configuration.`);
+            }
+            const cacheInstance = await (0, cache_manager_1.caching)(config.store, config['options']);
+            return this.wrapCaching(cacheInstance, config['options']);
+        }
+    }
+    wrapCaching(cacheInstance, cachingArgs) {
+        if (cacheInstance.methodWrap) {
+            return cacheInstance;
+        }
+        cacheInstance.methodWrap = async (key, fn, fnArgs, ttl) => {
+            const store = cacheInstance.store;
+            return (0, promise_coalesce_1.coalesceAsync)(key, async () => {
+                const value = await store.get(key);
+                if (value === undefined) {
+                    const result = await fn(...fnArgs);
+                    const cacheTTL = typeof ttl === 'function' ? ttl(result) : ttl;
+                    await store.set(key, result, cacheTTL);
+                    return result;
+                }
+                else if (cachingArgs === null || cachingArgs === void 0 ? void 0 : cachingArgs.refreshThreshold) {
+                    const cacheTTL = typeof ttl === 'function' ? ttl(value) : ttl;
+                    const remainingTtl = await store.ttl(key);
+                    if (remainingTtl !== -1 &&
+                        remainingTtl < cachingArgs.refreshThreshold) {
+                        // fn(...fnArgs).then(result => store.set(key, result, cacheTTL));
+                        (0, promise_coalesce_1.coalesceAsync)(`+++${key}`, () => fn(...fnArgs)).then(result => store.set(key, result, cacheTTL));
+                    }
+                }
+                return value;
+            });
+        };
+        return cacheInstance;
+    }
+    wrapMultiCaching(cacheInstance, caches) {
+        if (cacheInstance.methodWrap) {
+            return cacheInstance;
+        }
+        cacheInstance.methodWrap = async (key, fn, fnArgs, ttl) => {
+            let value;
+            let i = 0;
+            for (; i < caches.length; i++) {
+                try {
+                    value = await caches[i].get(key);
+                    if (value !== undefined)
+                        break;
+                }
+                catch (e) {
+                    // ignore
+                }
+            }
+            if (value === undefined) {
+                const result = await fn(...fnArgs);
+                const cacheTTL = typeof ttl === 'function' ? ttl(result) : ttl;
+                await cacheInstance.set(key, result, cacheTTL);
+                return result;
+            }
+            else {
+                const cacheTTL = typeof ttl === 'function' ? ttl(value) : ttl;
+                Promise.all(caches.slice(0, i).map(cache => cache.set(key, value, cacheTTL))).then();
+                caches[i].methodWrap(key, fn, fnArgs, ttl).then(); // call wrap for store for internal refreshThreshold logic, see: src/caching.ts caching.wrap
+            }
+            return value;
+        };
+        return cacheInstance;
+    }
+    getName() {
+        return 'cache-manager';
+    }
+    getCaching(cacheKey) {
+        return this.get(cacheKey);
+    }
+    getMultiCaching(cacheKey) {
+        return this.get(cacheKey);
+    }
+};
+__decorate([
+    (0, core_1.Config)('cacheManager'),
+    __metadata("design:type", Object)
+], CachingFactory.prototype, "cacheManagerConfig", void 0);
+__decorate([
+    (0, core_1.ApplicationContext)(),
+    __metadata("design:type", Object)
+], CachingFactory.prototype, "applicationContext", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CachingFactory.prototype, "init", null);
+CachingFactory = __decorate([
+    (0, core_1.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], CachingFactory);
+exports.CachingFactory = CachingFactory;
+//# sourceMappingURL=factory.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { CacheConfiguration as Configuration, getClassMethodDefaultCacheKey, } from './configuration';
+export * from './interface';
+export * from './factory';
+export * from './decorator/cacheKey';
+export * as CacheManager from 'cache-manager';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = exports.getClassMethodDefaultCacheKey = exports.Configuration = void 0;
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.CacheConfiguration; } });
+Object.defineProperty(exports, "getClassMethodDefaultCacheKey", { enumerable: true, get: function () { return configuration_1.getClassMethodDefaultCacheKey; } });
+__exportStar(require("./interface"), exports);
+__exportStar(require("./factory"), exports);
+__exportStar(require("./decorator/cacheKey"), exports);
+exports.CacheManager = require("cache-manager");
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,21 @@
+import { Cache, Store, MemoryConfig, FactoryStore, FactoryConfig, MultiCache, WrapTTL } from 'cache-manager';
+export type SingleCacheOptions<S extends Store = any, T extends object = any> = {
+    store: 'memory';
+    options?: MemoryConfig;
+} | {
+    store: S | (() => S | Promise<S>);
+} | {
+    store: FactoryStore<S, T>;
+    options?: FactoryConfig<Parameters<FactoryStore<S, T>>[0]>;
+};
+export type CacheManagerOptions<S extends Store = any, T extends object = any> = SingleCacheOptions<S> | {
+    store: Array<string | Cache | SingleCacheOptions<S, T> | (() => Cache | Promise<Cache>)>;
+};
+export type MidwayCache = Cache & {
+    methodWrap?: <T>(key: string, fn: (...args: any[]) => Promise<T>, fnArgs: any[], ttl?: WrapTTL<T>) => Promise<T>;
+};
+export type MidwayMultiCache = MultiCache & {
+    methodWrap?: <T>(key: string, fn: (...args: any[]) => Promise<T>, fnArgs: any[], ttl?: WrapTTL<T>) => Promise<T>;
+};
+export type MidwayUnionCache = MidwayCache | MidwayMultiCache;
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/index.d.ts

@@ -0,0 +1,9 @@
+import { CacheManagerOptions } from './dist/index';
+
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    cacheManager?: ServiceFactoryConfigOption<CacheManagerOptions>;
+  }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@midwayjs/cache-manager",
+  "version": "3.0.0",
+  "description": "midway cache manager",
+  "main": "dist/index.js",
+  "typings": "index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit"
+  },
+  "author": "",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:midwayjs/midway.git"
+  },
+  "keywords": [
+    "midway",
+    "cache"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "devDependencies": {
+    "@midwayjs/core": "^3.13.5",
+    "@midwayjs/mock": "^3.13.5",
+    "@midwayjs/redis": "^3.13.5",
+    "cache-manager-ioredis-yet": "1.2.2"
+  },
+  "dependencies": {
+    "cache-manager": "5.3.2",
+    "promise-coalesce": "1.1.1"
+  }
+}