@midwayjs/cache-manager 3.14.0 → 3.14.4-beta.1

package/dist/base/cacheManager.d.ts

@@ -0,0 +1,16 @@
+/**
+ * fork from https://github.com/node-cache-manager/node-cache-manager/tree/master
+ * reason: Support node.js v18 version below and add some features
+ * for example: add methodWrap
+ */
+import { Cache, Config, FactoryConfig, FactoryStore, MemoryCache, MemoryConfig, MemoryStore, MultiCache, Store } from './types';
+export declare function caching(name: 'memory', args?: MemoryConfig): Promise<MemoryCache>;
+export declare function caching<S extends Store>(store: S): Promise<Cache<S>>;
+export declare function caching<S extends Store, T extends object = never>(factory: FactoryStore<S, T>, args?: FactoryConfig<T>): Promise<Cache<S>>;
+export declare function createCache(store: MemoryStore, args?: MemoryConfig): MemoryCache;
+export declare function createCache(store: Store, args?: Config): Cache<Store>;
+/**
+ * Module that lets you specify a hierarchy of caches.
+ */
+export declare function multiCaching<Caches extends Cache[]>(caches: Caches): MultiCache;
+//# sourceMappingURL=cacheManager.d.ts.map

package/dist/base/cacheManager.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * fork from https://github.com/node-cache-manager/node-cache-manager/tree/master
+ * reason: Support node.js v18 version below and add some features
+ * for example: add methodWrap
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiCaching = exports.createCache = exports.caching = void 0;
+const prmoiseCoalesce_1 = require("./prmoiseCoalesce");
+const store_1 = require("./store");
+/**
+ * Generic caching interface that wraps any caching library with a compatible interface.
+ */
+async function caching(factory, args) {
+    if (factory === 'memory') {
+        const store = (0, store_1.memoryStore)(args);
+        return createCache(store, args);
+    }
+    if (typeof factory === 'function') {
+        const store = await factory(args);
+        return createCache(store, args);
+    }
+    return createCache(factory, args);
+}
+exports.caching = caching;
+/**
+ * Create cache instance by store (non-async).
+ */
+function createCache(store, args) {
+    return {
+        /**
+         * Wraps a function in cache. I.e., the first time the function is run,
+         * its results are stored in cache so subsequent calls retrieve from cache
+         * instead of calling the function.
+    
+         * @example
+         * const result = await cache.wrap('key', () => Promise.resolve(1));
+         *
+         */
+        wrap: async (key, fn, ttl) => {
+            return (0, prmoiseCoalesce_1.coalesceAsync)(key, async () => {
+                const value = await store.get(key);
+                if (value === undefined) {
+                    const result = await fn();
+                    const cacheTTL = typeof ttl === 'function' ? ttl(result) : ttl;
+                    await store.set(key, result, cacheTTL);
+                    return result;
+                }
+                else if (args === null || args === void 0 ? void 0 : args.refreshThreshold) {
+                    const cacheTTL = typeof ttl === 'function' ? ttl(value) : ttl;
+                    const remainingTtl = await store.ttl(key);
+                    if (remainingTtl !== -1 && remainingTtl < args.refreshThreshold) {
+                        (0, prmoiseCoalesce_1.coalesceAsync)(`+++${key}`, fn).then(result => store.set(key, result, cacheTTL));
+                    }
+                }
+                return value;
+            });
+        },
+        store: store,
+        del: (key) => store.del(key),
+        get: (key) => store.get(key),
+        set: (key, value, ttl) => store.set(key, value, ttl),
+        reset: () => store.reset(),
+        /**
+         * cache function with args
+         */
+        methodWrap: async (key, fn, fnArgs, ttl) => {
+            return (0, prmoiseCoalesce_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 (args === null || args === void 0 ? void 0 : args.refreshThreshold) {
+                    const cacheTTL = typeof ttl === 'function' ? ttl(value) : ttl;
+                    const remainingTtl = await store.ttl(key);
+                    if (remainingTtl !== -1 && remainingTtl < args.refreshThreshold) {
+                        // fn(...fnArgs).then(result => store.set(key, result, cacheTTL));
+                        (0, prmoiseCoalesce_1.coalesceAsync)(`+++${key}`, () => fn(...fnArgs)).then(result => store.set(key, result, cacheTTL));
+                    }
+                }
+                return value;
+            });
+        },
+    };
+}
+exports.createCache = createCache;
+/**
+ * Module that lets you specify a hierarchy of caches.
+ */
+function multiCaching(caches) {
+    const get = async (key) => {
+        for (const cache of caches) {
+            try {
+                const val = await cache.get(key);
+                if (val !== undefined)
+                    return val;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+    };
+    const set = async (key, data, ttl) => {
+        await Promise.all(caches.map(cache => cache.set(key, data, ttl)));
+    };
+    return {
+        get,
+        set,
+        del: async (key) => {
+            await Promise.all(caches.map(cache => cache.del(key)));
+        },
+        async wrap(key, fn, 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();
+                const cacheTTL = typeof ttl === 'function' ? ttl(result) : ttl;
+                await 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].wrap(key, fn, ttl).then(); // call wrap for store for internal refreshThreshold logic, see: src/caching.ts caching.wrap
+            }
+            return value;
+        },
+        reset: async () => {
+            await Promise.all(caches.map(x => x.reset()));
+        },
+        mget: async (...keys) => {
+            const values = new Array(keys.length).fill(undefined);
+            for (const cache of caches) {
+                if (values.every(x => x !== undefined))
+                    break;
+                try {
+                    const val = await cache.store.mget(...keys);
+                    val.forEach((v, i) => {
+                        if (values[i] === undefined && v !== undefined)
+                            values[i] = v;
+                    });
+                }
+                catch (e) {
+                    // ignore
+                }
+            }
+            return values;
+        },
+        mset: async (args, ttl) => {
+            await Promise.all(caches.map(cache => cache.store.mset(args, ttl)));
+        },
+        mdel: async (...keys) => {
+            await Promise.all(caches.map(cache => cache.store.mdel(...keys)));
+        },
+        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 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;
+        },
+    };
+}
+exports.multiCaching = multiCaching;
+//# sourceMappingURL=cacheManager.js.map

package/dist/base/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cacheManager';
+export * from './store';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/base/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./cacheManager"), exports);
+__exportStar(require("./store"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/base/prmoiseCoalesce.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Enqueue a promise for the group identified by `key`.
+ *
+ * All requests received for the same key while a request for that key
+ * is already being executed will wait. Once the running request settles
+ * then all the waiting requests in the group will settle, too.
+ * This minimizes how many times the function itself runs at the same time.
+ * This function resolves or rejects according to the given function argument.
+ */
+export declare function coalesceAsync<T>(
+/**
+ * Any identifier to group requests together.
+ */
+key: string, 
+/**
+ * The function to run.
+ */
+fn: () => T | PromiseLike<T>): Promise<T>;
+//# sourceMappingURL=prmoiseCoalesce.d.ts.map

package/dist/base/prmoiseCoalesce.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coalesceAsync = void 0;
+const callbacks = new Map();
+/**
+ * Enqueue a promise for the group identified by `key`.
+ *
+ * All requests received for the same key while a request for that key
+ * is already being executed will wait. Once the running request settles
+ * then all the waiting requests in the group will settle, too.
+ * This minimizes how many times the function itself runs at the same time.
+ * This function resolves or rejects according to the given function argument.
+ */
+async function coalesceAsync(
+/**
+ * Any identifier to group requests together.
+ */
+key, 
+/**
+ * The function to run.
+ */
+fn) {
+    if (!hasKey(key)) {
+        addKey(key);
+        try {
+            const result = await Promise.resolve(fn());
+            coalesce({ key, result });
+            return result;
+        }
+        catch (error) {
+            coalesce({ key, error });
+            throw error;
+        }
+    }
+    return enqueue(key);
+}
+exports.coalesceAsync = coalesceAsync;
+function hasKey(key) {
+    return callbacks.has(key);
+}
+function addKey(key) {
+    callbacks.set(key, []);
+}
+function removeKey(key) {
+    callbacks.delete(key);
+}
+function addCallbackToKey(key, callback) {
+    const stash = getCallbacksByKey(key);
+    stash.push(callback);
+    callbacks.set(key, stash);
+}
+function getCallbacksByKey(key) {
+    var _a;
+    return (_a = callbacks.get(key)) !== null && _a !== void 0 ? _a : [];
+}
+function enqueue(key) {
+    return new Promise((resolve, reject) => {
+        const callback = { resolve, reject };
+        addCallbackToKey(key, callback);
+    });
+}
+function dequeue(key) {
+    const stash = getCallbacksByKey(key);
+    removeKey(key);
+    return stash;
+}
+function coalesce(options) {
+    const { key, error, result } = options;
+    dequeue(key).forEach(callback => {
+        if (error) {
+            callback.reject(error);
+        }
+        else {
+            callback.resolve(result);
+        }
+    });
+}
+//# sourceMappingURL=prmoiseCoalesce.js.map

package/dist/base/store.d.ts

@@ -0,0 +1,6 @@
+import { MemoryConfig, MemoryStore } from './types';
+/**
+ * Wrapper for lru-cache.
+ */
+export declare function memoryStore(args?: MemoryConfig): MemoryStore;
+//# sourceMappingURL=store.d.ts.map

package/dist/base/store.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryStore = void 0;
+const LRUCache = require("lru-cache");
+const cloneDeep = require("lodash.clonedeep");
+function clone(object) {
+    if (typeof object === 'object' && object !== null) {
+        return cloneDeep(object);
+    }
+    return object;
+}
+/**
+ * Wrapper for lru-cache.
+ */
+function memoryStore(args) {
+    var _a;
+    const shouldCloneBeforeSet = (args === null || args === void 0 ? void 0 : args.shouldCloneBeforeSet) !== false; // clone by default
+    const isCacheable = (_a = args === null || args === void 0 ? void 0 : args.isCacheable) !== null && _a !== void 0 ? _a : (val => val !== undefined);
+    const lruOpts = {
+        ttlAutopurge: true,
+        ...args,
+        max: (args === null || args === void 0 ? void 0 : args.max) || 500,
+        ttl: (args === null || args === void 0 ? void 0 : args.ttl) !== undefined ? args.ttl : 0,
+    };
+    const lruCache = new LRUCache(lruOpts);
+    return {
+        async del(key) {
+            lruCache.delete(key);
+        },
+        get: async (key) => lruCache.get(key),
+        keys: async () => [...lruCache.keys()],
+        mget: async (...args) => args.map(x => lruCache.get(x)),
+        async mset(args, ttl) {
+            const opt = { ttl: ttl !== undefined ? ttl : lruOpts.ttl };
+            for (const [key, value] of args) {
+                if (!isCacheable(value))
+                    throw new Error(`no cacheable value ${JSON.stringify(value)}`);
+                if (shouldCloneBeforeSet)
+                    lruCache.set(key, clone(value), opt);
+                else
+                    lruCache.set(key, value, opt);
+            }
+        },
+        async mdel(...args) {
+            for (const key of args)
+                lruCache.delete(key);
+        },
+        async reset() {
+            lruCache.clear();
+        },
+        ttl: async (key) => lruCache.getRemainingTTL(key),
+        async set(key, value, opt) {
+            if (!isCacheable(value))
+                throw new Error(`no cacheable value ${JSON.stringify(value)}`);
+            if (shouldCloneBeforeSet)
+                value = clone(value);
+            const ttl = opt !== undefined ? opt : lruOpts.ttl;
+            lruCache.set(key, value, { ttl });
+        },
+        get calculatedSize() {
+            return lruCache.calculatedSize;
+        },
+        /**
+         * This method is not available in the caching modules.
+         */
+        get size() {
+            return lruCache.size;
+        },
+        /**
+         * This method is not available in the caching modules.
+         */
+        dump: () => lruCache.dump(),
+        /**
+         * This method is not available in the caching modules.
+         */
+        load: (...args) => lruCache.load(...args),
+    };
+}
+exports.memoryStore = memoryStore;
+//# sourceMappingURL=store.js.map

package/dist/base/types.d.ts

@@ -0,0 +1,51 @@
+import * as LRUCache from 'lru-cache';
+export type MultiCache = Omit<Cache, 'store'> & Pick<Cache['store'], 'mset' | 'mget' | 'mdel'>;
+export type Config = {
+    ttl?: Milliseconds;
+    refreshThreshold?: Milliseconds;
+    isCacheable?: (val: unknown) => boolean;
+};
+export type Milliseconds = number;
+export type Store = {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, data: T, ttl?: Milliseconds): Promise<void>;
+    del(key: string): Promise<void>;
+    reset(): Promise<void>;
+    mset(args: [string, unknown][], ttl?: Milliseconds): Promise<void>;
+    mget(...args: string[]): Promise<unknown[]>;
+    mdel(...args: string[]): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+    ttl(key: string): Promise<number>;
+};
+export type StoreConfig = Config;
+export type FactoryConfig<T> = T & Config;
+export type FactoryStore<S extends Store, T extends object = never> = (config?: FactoryConfig<T>) => S | Promise<S>;
+export type Stores<S extends Store, T extends object> = 'memory' | Store | FactoryStore<S, T>;
+export type CachingConfig<T> = MemoryConfig | StoreConfig | FactoryConfig<T>;
+export type WrapTTL<T> = Milliseconds | ((v: T) => Milliseconds);
+export type Cache<S extends Store = Store> = {
+    set: (key: string, value: unknown, ttl?: Milliseconds) => Promise<void>;
+    get: <T>(key: string) => Promise<T | undefined>;
+    del: (key: string) => Promise<void>;
+    reset: () => Promise<void>;
+    wrap<T>(key: string, fn: () => Promise<T>, ttl?: WrapTTL<T>): Promise<T>;
+    methodWrap<T>(key: string, fn: (...args: any[]) => Promise<T>, fnArgs: any[], ttl?: WrapTTL<T>): Promise<T>;
+    store: S;
+};
+export type LRU = LRUCache<string, any>;
+type Pre = LRUCache.LimitedByTTL;
+type Options = Omit<Pre, 'ttlAutopurge'> & Partial<Pick<Pre, 'ttlAutopurge'>>;
+export type MemoryConfig = {
+    max?: number;
+    sizeCalculation?: (value: unknown, key: string) => number;
+    shouldCloneBeforeSet?: boolean;
+} & Options & Config;
+export type MemoryStore = Store & {
+    get size(): number;
+    dump: LRU['dump'];
+    load: LRU['load'];
+    calculatedSize: LRU['calculatedSize'];
+};
+export type MemoryCache = Cache<MemoryStore>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/base/types.js

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

package/dist/factory.d.ts

@@ -1,13 +1,10 @@
 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;

package/dist/factory.js

@@ -11,8 +11,7 @@ var __metadata = (this && this.__metadata) || function (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");
+const base_1 = require("./base");
 let CachingFactory = class CachingFactory extends core_1.ServiceFactory {
     async init() {
         await this.initClients(this.cacheManagerConfig);
@@ -42,14 +41,13 @@ let CachingFactory = class CachingFactory extends core_1.ServiceFactory {
                     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']));
+                    newFactory.push(await (0, base_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);
+            return await (0, base_1.multiCaching)(newFactory);
         }
         else {
             // single cache
@@ -59,70 +57,9 @@ let CachingFactory = class CachingFactory extends core_1.ServiceFactory {
             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']);
+            return await (0, base_1.caching)(config.store, 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';
     }

package/dist/index.d.ts

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

package/dist/index.js

@@ -21,5 +21,6 @@ Object.defineProperty(exports, "getClassMethodDefaultCacheKey", { enumerable: tr
 __exportStar(require("./interface"), exports);
 __exportStar(require("./factory"), exports);
 __exportStar(require("./decorator/cacheKey"), exports);
-exports.CacheManager = require("cache-manager");
+exports.CacheManager = require("./base");
+__exportStar(require("./store"), exports);
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -1,4 +1,4 @@
-import { Cache, Store, MemoryConfig, FactoryStore, FactoryConfig, MultiCache, WrapTTL } from 'cache-manager';
+import { Cache, Store, MemoryConfig, FactoryStore, FactoryConfig, MultiCache } from './base';
 export type SingleCacheOptions<S extends Store = any, T extends object = any> = {
     store: 'memory';
     options?: MemoryConfig;
@@ -11,11 +11,7 @@ export type SingleCacheOptions<S extends Store = any, T extends object = any> =
 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 MidwayCache = Cache;
+export type MidwayMultiCache = MultiCache;
 export type MidwayUnionCache = MidwayCache | MidwayMultiCache;
 //# sourceMappingURL=interface.d.ts.map

package/dist/store.d.ts

@@ -0,0 +1,7 @@
+import type { Config, Store } from './base';
+import { IMidwayContainer } from '@midwayjs/core';
+export interface RedisStore extends Store {
+    readonly isCacheable: (value: unknown) => boolean;
+}
+export declare function createRedisStore(instanceName: string): (options: Config, container: IMidwayContainer) => Promise<RedisStore>;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRedisStore = void 0;
+const core_1 = require("@midwayjs/core");
+const getVal = (value) => JSON.stringify(value) || '"undefined"';
+function createRedisStore(instanceName) {
+    return async (options, container) => {
+        const { RedisServiceFactory } = (0, core_1.safeRequire)('@midwayjs/redis');
+        const redisServiceFactory = await container.getAsync(RedisServiceFactory);
+        const redisInstance = redisServiceFactory.get(instanceName);
+        return createStore(redisInstance, options);
+    };
+}
+exports.createRedisStore = createRedisStore;
+function createStore(redisCache, options) {
+    const isCacheable = (options === null || options === void 0 ? void 0 : options.isCacheable) || (value => value !== undefined && value !== null);
+    const keys = (pattern) => redisCache.keys(pattern);
+    return {
+        async get(key) {
+            const val = await redisCache.get(key);
+            if (val === undefined || val === null)
+                return undefined;
+            else
+                return JSON.parse(val);
+        },
+        async set(key, value, ttl) {
+            if (!isCacheable(value))
+                throw new core_1.MidwayCommonError(`"${value}" is not a cacheable value`);
+            const t = ttl === undefined ? options === null || options === void 0 ? void 0 : options.ttl : ttl;
+            if (t !== undefined && t !== 0)
+                await redisCache.set(key, getVal(value), 'PX', t);
+            else
+                await redisCache.set(key, getVal(value));
+        },
+        async mset(args, ttl) {
+            const t = ttl === undefined ? options === null || options === void 0 ? void 0 : options.ttl : ttl;
+            if (t !== undefined && t !== 0) {
+                const multi = redisCache.multi();
+                for (const [key, value] of args) {
+                    if (!isCacheable(value))
+                        throw new core_1.MidwayCommonError(`"${getVal(value)}" is not a cacheable value`);
+                    multi.set(key, getVal(value), 'PX', t);
+                }
+                await multi.exec();
+            }
+            else
+                await redisCache.mset(args.flatMap(([key, value]) => {
+                    if (!isCacheable(value))
+                        throw new Error(`"${getVal(value)}" is not a cacheable value`);
+                    return [key, getVal(value)];
+                }));
+        },
+        mget: (...args) => redisCache
+            .mget(args)
+            .then(x => x.map(x => x === null || x === undefined
+            ? undefined
+            : JSON.parse(x))),
+        async mdel(...args) {
+            await redisCache.del(args);
+        },
+        async del(key) {
+            await redisCache.del(key);
+        },
+        ttl: async (key) => redisCache.pttl(key),
+        keys: (pattern = '*') => keys(pattern),
+        reset: () => {
+            throw new core_1.MidwayCommonError('flushdb() is too dangerous, if necessary, please use redisServiceFactory.get(client) to get the instance and call it manually.');
+        },
+        isCacheable,
+    };
+}
+//# sourceMappingURL=store.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/cache-manager",
-  "version": "3.14.0",
+  "version": "3.14.4-beta.1",
   "description": "midway cache manager",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -28,14 +28,13 @@
     "node": ">=12"
   },
   "devDependencies": {
-    "@midwayjs/core": "^3.14.0",
-    "@midwayjs/mock": "^3.14.0",
-    "@midwayjs/redis": "^3.14.0",
+    "@midwayjs/core": "^3.14.3",
+    "@midwayjs/mock": "^3.14.3",
+    "@midwayjs/redis": "^3.14.3",
     "cache-manager-ioredis-yet": "1.2.2"
   },
   "dependencies": {
-    "cache-manager": "5.3.2",
-    "promise-coalesce": "1.1.1"
-  },
-  "gitHead": "67e3a3596ffdb65a413064d30c68f1f7965af282"
+    "lodash.clonedeep": "4.5.0",
+    "lru-cache": "7.18.3"
+  }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2013 - Now midwayjs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.