@midwayjs/cache-manager 3.14.0 → 3.14.3

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * from './interface';
 export * from './factory';
 export * from './decorator/cacheKey';
 export * as CacheManager from 'cache-manager';
+export * from './store';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -22,4 +22,5 @@ __exportStar(require("./interface"), exports);
 __exportStar(require("./factory"), exports);
 __exportStar(require("./decorator/cacheKey"), exports);
 exports.CacheManager = require("cache-manager");
+__exportStar(require("./store"), exports);
 //# sourceMappingURL=index.js.map

package/dist/store.d.ts

@@ -0,0 +1,7 @@
+import type { Config, Store } from 'cache-manager';
+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.3",
   "description": "midway cache manager",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -28,14 +28,14 @@
     "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"
+  "gitHead": "7517e708722bbf9ba69d9406e73fa2597e485d24"
 }