midway-fatcms 0.0.1-beta.64 → 0.0.1-beta.66

package/dist/service/EnumInfoService.js

@@ -16,40 +16,46 @@ const CurdProService_1 = require("./curd/CurdProService");
 const CurdMixUtils_1 = require("./curd/CurdMixUtils");
 const SystemTables_1 = require("../models/SystemTables");
 const parseConfig_1 = require("../libs/utils/parseConfig");
-const RedisCacheService_1 = require("./base/RedisCacheService");
 const CurdMixByLinkToCustomService_1 = require("./curd/CurdMixByLinkToCustomService");
 const global_config_1 = require("../libs/global-config/global-config");
-const RedisKeys_1 = require("../models/RedisKeys");
+const CacheServiceFactory_1 = require("./base/cache/CacheServiceFactory");
+const SystemEntities_1 = require("../models/SystemEntities");
 function filterEmpty(e) {
     return e.label && typeof e.value !== 'undefined';
 }
+const DEFAULT_CACHE_LEVEL = SystemEntities_1.CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
 let EnumInfoService = class EnumInfoService {
     async queryEnumInfo(codeList, refreshCache) {
-        const expireSecond = 2 * 60;
+        const { queryEnumInfoCacheLevel, queryEnumInfoCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig() || {};
+        const getEnumInfoByCode = async (type, code) => {
+            if (type === CurdMixUtils_1.RelatedType.linkToCustom) {
+                return await this.queryEnumInfoByLinkToCustom(code);
+            }
+            const cacheKey = `${type}@@${code}`;
+            const emums = refreshCache ? null : await this.cacheServiceFactory.getJsonObjectCache({
+                cacheLevel: queryEnumInfoCacheLevel || DEFAULT_CACHE_LEVEL,
+                cacheSecond: queryEnumInfoCacheSecond || DEFAULT_CACHE_SECOND,
+                cacheKey,
+                refreshCache,
+                cacheName: SystemEntities_1.CacheNameEnum.GetEnumInfoByCode,
+                getter: async () => {
+                    if (type === CurdMixUtils_1.RelatedType.sysCfgEnum) {
+                        return await this.queryEnumInfoBySysCfgEnum(code);
+                    }
+                    else if (type === CurdMixUtils_1.RelatedType.dict) {
+                        return await this.queryEnumInfoItemByDict(code);
+                    }
+                    return [];
+                },
+            });
+            return emums;
+        };
         const result = [];
         for (let i = 0; i < codeList.length; i++) {
             const { code, type } = codeList[i];
-            const cacheKey = `${RedisKeys_1.RedisKeys.QUERY_ENUM_INFO_PREFIX}${type}@@${code}`;
-            const emums = refreshCache ? null : await this.redisCacheService.getJsonObject(cacheKey);
-            if (!Array.isArray(emums) || emums.length === 0) {
-                let values;
-                if (type === CurdMixUtils_1.RelatedType.sysCfgEnum) {
-                    values = await this.queryEnumInfoBySysCfgEnum(code);
-                    await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
-                }
-                else if (type === CurdMixUtils_1.RelatedType.dict) {
-                    values = await this.queryEnumInfoItemByDict(code);
-                    await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
-                }
-                else if (type === CurdMixUtils_1.RelatedType.linkToCustom) {
-                    values = await this.queryEnumInfoByLinkToCustom(code);
-                    // await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
-                }
-                result.push({ type, code, values });
-            }
-            else {
-                result.push({ type, code, values: emums });
-            }
+            const emums = await getEnumInfoByCode(type, code);
+            result.push({ type, code, values: emums });
         }
         return result;
     }
@@ -119,8 +125,8 @@ __decorate([
 ], EnumInfoService.prototype, "curdMixByLinkToCustomService", void 0);
 __decorate([
     (0, core_1.Inject)(),
-    __metadata("design:type", RedisCacheService_1.RedisCacheService)
-], EnumInfoService.prototype, "redisCacheService", void 0);
+    __metadata("design:type", CacheServiceFactory_1.CacheServiceFactory)
+], EnumInfoService.prototype, "cacheServiceFactory", void 0);
 EnumInfoService = __decorate([
     (0, core_1.Provide)()
 ], EnumInfoService);

package/dist/service/UserSessionService.d.ts

@@ -1,7 +1,7 @@
 import { ISessionInfo } from '../models/userSession';
 export declare class UserSessionService {
     private ctx;
-    private redisCacheService;
+    private cacheServiceFactory;
     private curdProService;
     private fatcmsUserSessionKeepTimeSecond;
     /**
@@ -9,6 +9,11 @@ export declare class UserSessionService {
      * @returns
      */
     private getSessionKeepTimeSecond;
+    /**
+     * 获取用户会话缓存服务
+     * @returns
+     */
+    private getUserSessionCacheService;
     /**
      * 保存用户会话信息。
      * 用户登录后，在业务的项目中，可以调用此函数，更新bizExt字段

package/dist/service/UserSessionService.js

@@ -13,13 +13,13 @@ exports.UserSessionService = void 0;
 const core_1 = require("@midwayjs/core");
 const functions_1 = require("../libs/utils/functions");
 const userSession_1 = require("../models/userSession");
-const RedisCacheService_1 = require("./base/RedisCacheService");
-const RedisKeys_1 = require("../models/RedisKeys");
 const AsyncTaskModel_1 = require("../models/AsyncTaskModel");
 const CurdProService_1 = require("./curd/CurdProService");
 const keys_1 = require("../libs/crud-pro/models/keys");
 const SystemTables_1 = require("../models/SystemTables");
 const global_config_1 = require("../libs/global-config/global-config");
+const CacheServiceFactory_1 = require("./base/cache/CacheServiceFactory");
+const SystemEntities_1 = require("../models/SystemEntities");
 function pickUserAvatar(avatar) {
     if (!avatar) {
         return null;
@@ -45,10 +45,7 @@ function pickUserAvatar(avatar) {
     }
     return null;
 }
-const SESSION_KEEP_TIME_SECOND = 3600 * 24 * 30;
-const toCacheKey = (sessionId) => {
-    return `${RedisKeys_1.RedisKeys.USER_SESSION_PREFIX}${sessionId}`;
-};
+const SESSION_KEEP_TIME_SECOND = 3600 * 24 * 7;
 let UserSessionService = class UserSessionService {
     /**
      * 获取用户会话保持时间: 单位秒
@@ -60,6 +57,13 @@ let UserSessionService = class UserSessionService {
         }
         return SESSION_KEEP_TIME_SECOND;
     }
+    /**
+     * 获取用户会话缓存服务
+     * @returns
+     */
+    getUserSessionCacheService() {
+        return this.cacheServiceFactory.getCacheService(SystemEntities_1.CacheLevelEnum.REDIS, SystemEntities_1.CacheNameEnum.UserSessionBySessionId);
+    }
     /**
      * 保存用户会话信息。
      * 用户登录后，在业务的项目中，可以调用此函数，更新bizExt字段
@@ -69,14 +73,16 @@ let UserSessionService = class UserSessionService {
         sessionInfo.avatar = pickUserAvatar(sessionInfo.avatar);
         const sessionId = sessionInfo.sessionId;
         const keepTime = this.getSessionKeepTimeSecond();
-        await this.redisCacheService.setJsonObject(toCacheKey(sessionId), sessionInfo, keepTime);
+        const userSessionCache = this.getUserSessionCacheService();
+        await userSessionCache.setJsonObject(sessionId, sessionInfo, keepTime);
     }
     /**
      * 移除Session
      * @param sessionId
      */
     async removeUserSession(sessionId) {
-        return await this.redisCacheService.removeItem(toCacheKey(sessionId));
+        const userSessionCache = this.getUserSessionCacheService();
+        return await userSessionCache.removeItem(sessionId);
     }
     /**
      * 获取用户会话信息
@@ -87,14 +93,15 @@ let UserSessionService = class UserSessionService {
         if (!sessionId) {
             return null;
         }
-        return await this.redisCacheService.getJsonObject(toCacheKey(sessionId));
+        const userSessionCache = this.getUserSessionCacheService();
+        return await userSessionCache.getJsonObject(sessionId);
     }
     /**
      * 从异步任务队列中获取当时用户的Session信息
      * @param asyncTaskId
      */
     async getCurrentUserSessionByAsyncTaskId(asyncTaskId) {
-        const taskSessionCacheKey = `${RedisKeys_1.RedisKeys.USER_SESSION_ASYNC_TASK_ID_PREFIX}${asyncTaskId}`;
+        const taskSessionCacheKey = `${asyncTaskId}`;
         const loadSessionInfo = async () => {
             const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
             const asyncTaskRes = await this.curdProService.executeCrudByCfg({
@@ -114,11 +121,13 @@ let UserSessionService = class UserSessionService {
             }
             return (0, functions_1.parseJsonObject)(asyncTaskObj.created_user_session);
         };
-        let sessionInfo1 = await this.redisCacheService.getJsonObject(taskSessionCacheKey);
-        if (!sessionInfo1) {
-            sessionInfo1 = await loadSessionInfo();
-            await this.redisCacheService.setJsonObject(taskSessionCacheKey, sessionInfo1, 3600); // 只缓存一小时即可
-        }
+        const sessionInfo1 = await this.cacheServiceFactory.getJsonObjectCache({
+            cacheLevel: SystemEntities_1.CacheLevelEnum.REDIS,
+            cacheName: SystemEntities_1.CacheNameEnum.UserSessionByAsyncTaskId,
+            cacheKey: taskSessionCacheKey,
+            cacheSecond: 3600,
+            getter: loadSessionInfo,
+        });
         return sessionInfo1;
     }
     /**
@@ -141,8 +150,8 @@ __decorate([
 ], UserSessionService.prototype, "ctx", void 0);
 __decorate([
     (0, core_1.Inject)(),
-    __metadata("design:type", RedisCacheService_1.RedisCacheService)
-], UserSessionService.prototype, "redisCacheService", void 0);
+    __metadata("design:type", CacheServiceFactory_1.CacheServiceFactory)
+], UserSessionService.prototype, "cacheServiceFactory", void 0);
 __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", CurdProService_1.CurdProService)

package/dist/service/WorkbenchService.d.ts

@@ -50,4 +50,5 @@ export declare class WorkbenchService extends BaseService implements IScheduleSe
     private getCurrentHost;
     isSupportCurrentWorkbench(workbench_code_array: string | string[]): Promise<boolean>;
     isSupportCurrentHostForForMiddleware(): Promise<string | boolean>;
+    isSupportTheNodePathByWorkbenchInfo(workbenchInfo: IWorkbenchEntity, path: string): boolean;
 }

package/dist/service/WorkbenchService.js

@@ -22,6 +22,7 @@ const fatcms_request_1 = require("../libs/utils/fatcms-request");
 const MixinUtils_1 = require("../libs/crud-pro/utils/MixinUtils");
 const global_config_1 = require("../libs/global-config/global-config");
 const AsyncTaskModel_1 = require("../models/AsyncTaskModel");
+const format_url_1 = require("../libs/utils/format-url");
 //
 // const lruCache = new LRUCache<string, any>({
 //   max: 500,
@@ -153,10 +154,11 @@ let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService
      * @returns
      */
     getCurrentHost() {
-        const host = this.ctx.request.host;
+        let host = this.ctx.request.host;
         if (!host) {
             throw new exceptions_1.CommonException('GET_CURRENT_HOST_ERROR', '获取当前域名失败');
         }
+        host = (0, format_url_1.formatHost)(host);
         return host;
     }
     async isSupportCurrentWorkbench(workbench_code_array) {
@@ -192,6 +194,30 @@ let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService
         }
         return true;
     }
+    isSupportTheNodePathByWorkbenchInfo(workbenchInfo, path) {
+        // 非node api路径，直接返回true
+        if (!path.startsWith('/ns/')) {
+            return true;
+        }
+        const configObj = (0, functions_1.parseJsonObject)(workbenchInfo === null || workbenchInfo === void 0 ? void 0 : workbenchInfo.config_content);
+        // 为开启校验开关。开关为true时，才校验。
+        if (!configObj || !configObj.nodeApiWhiteEnable) {
+            return true;
+        }
+        let isOkByList = false;
+        const { nodeApiWhiteList, nodeApiWhitePrefix } = configObj;
+        if (Array.isArray(nodeApiWhiteList) && nodeApiWhiteList.length > 0) {
+            isOkByList = nodeApiWhiteList.includes(path);
+        }
+        if (isOkByList) {
+            return true;
+        }
+        let isOkByPrefix = false;
+        if (Array.isArray(nodeApiWhitePrefix) && nodeApiWhitePrefix.length > 0) {
+            isOkByPrefix = nodeApiWhitePrefix.some((prefix) => path.startsWith(prefix));
+        }
+        return isOkByPrefix;
+    }
 };
 __decorate([
     (0, core_1.Inject)(),

package/dist/service/base/cache/CacheServiceFactory.d.ts

@@ -0,0 +1,20 @@
+import { Context } from '@midwayjs/koa';
+import { ICacheServiceBase } from '../../../models/bizmodels';
+import { CacheLevelEnum, CacheNameEnum } from '../../../models/SystemEntities';
+import { RedisService } from '@midwayjs/redis';
+interface IGetJsonObjectCacheParam {
+    cacheLevel: CacheLevelEnum;
+    cacheName: CacheNameEnum;
+    cacheKey: string;
+    cacheSecond: number;
+    refreshCache?: boolean;
+    getter: () => Promise<any>;
+}
+export declare class CacheServiceFactory {
+    protected ctx: Context;
+    private fatcmsCache;
+    protected redisService: RedisService;
+    getCacheService(cacheLevelEnum: CacheLevelEnum, cacheName: CacheNameEnum): ICacheServiceBase;
+    getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any>;
+}
+export {};

package/dist/service/base/cache/CacheServiceFactory.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.CacheServiceFactory = void 0;
+const core_1 = require("@midwayjs/core");
+const SystemEntities_1 = require("../../../models/SystemEntities");
+const redis_1 = require("@midwayjs/redis");
+const FatcmsBaseCtxCache_1 = require("./FatcmsBaseCtxCache");
+const FatcmsBaseRedisCache_1 = require("./FatcmsBaseRedisCache");
+const FatcmsBaseDiskCache_1 = require("./FatcmsBaseDiskCache");
+const FatcmsBaseMemoryCache_1 = require("./FatcmsBaseMemoryCache");
+const FatcmsBaseNoneCache_1 = require("./FatcmsBaseNoneCache");
+let CacheServiceFactory = class CacheServiceFactory {
+    getCacheService(cacheLevelEnum, cacheName) {
+        switch (cacheLevelEnum) {
+            case SystemEntities_1.CacheLevelEnum.CONTEXT:
+                return new FatcmsBaseCtxCache_1.FatcmsBaseCtxCache(this.ctx, cacheName);
+            case SystemEntities_1.CacheLevelEnum.REDIS:
+                return new FatcmsBaseRedisCache_1.FatcmsBaseRedisCache(this.ctx, cacheName, this.redisService);
+            case SystemEntities_1.CacheLevelEnum.DISK:
+                return new FatcmsBaseDiskCache_1.FatcmsBaseDiskCache(this.ctx, cacheName, this.fatcmsCache);
+            case SystemEntities_1.CacheLevelEnum.MEMORY:
+                return new FatcmsBaseMemoryCache_1.FatcmsBaseMemoryCache(this.ctx, cacheName);
+            default:
+                return new FatcmsBaseNoneCache_1.FatcmsBaseNoneCache(this.ctx, cacheName);
+        }
+    }
+    async getJsonObjectCache(param) {
+        let { cacheLevel, cacheName, cacheKey, cacheSecond, refreshCache, getter } = param;
+        if (!cacheSecond || typeof cacheSecond !== 'number') {
+            console.error('[CacheServiceFactory#getJsonObjectCache] cacheSecond is not number, use default value 60, ' + JSON.stringify(param));
+            cacheSecond = 60;
+        }
+        const realCacheKey = this.fatcmsCache.keyPrefix + cacheKey;
+        const cacheService = this.getCacheService(cacheLevel, cacheName);
+        let obj = cacheService.getJsonObject(realCacheKey);
+        if (!obj || refreshCache === true) {
+            obj = await getter();
+            cacheService.setJsonObject(realCacheKey, obj, cacheSecond);
+        }
+        return obj;
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], CacheServiceFactory.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Config)('fatcmsCache'),
+    __metadata("design:type", Object)
+], CacheServiceFactory.prototype, "fatcmsCache", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", redis_1.RedisService)
+], CacheServiceFactory.prototype, "redisService", void 0);
+CacheServiceFactory = __decorate([
+    (0, core_1.Provide)()
+], CacheServiceFactory);
+exports.CacheServiceFactory = CacheServiceFactory;

package/dist/service/base/cache/FatcmsBaseCtxCache.d.ts

@@ -0,0 +1,19 @@
+import { ICacheServiceBase } from '../../../models/bizmodels';
+import { CacheNameEnum } from '../../../models/SystemEntities';
+import { Context } from '@midwayjs/koa';
+export declare class FatcmsBaseCtxCache implements ICacheServiceBase {
+    private ctx;
+    private cacheName;
+    constructor(ctx: Context, cacheName: CacheNameEnum);
+    private getCacheMap;
+    getJsonObject(key: string): Promise<any>;
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any>;
+    removeItem(key: string): Promise<any>;
+}

package/dist/service/base/cache/FatcmsBaseCtxCache.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FatcmsBaseCtxCache = void 0;
+class FatcmsBaseCtxCache {
+    constructor(ctx, cacheName) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+    getCacheMap() {
+        if (!this.ctx.baseCtxCacheMap) {
+            this.ctx.baseCtxCacheMap = new Map();
+        }
+        if (!this.ctx.baseCtxCacheMap.has(this.cacheName)) {
+            this.ctx.baseCtxCacheMap.set(this.cacheName, new Map());
+        }
+        return this.ctx.baseCtxCacheMap.get(this.cacheName);
+    }
+    async getJsonObject(key) {
+        const cacheMap = this.getCacheMap();
+        return cacheMap.get(key);
+    }
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    async setJsonObject(key, obj, expireSecond) {
+        const cacheMap = this.getCacheMap();
+        cacheMap.set(key, obj);
+    }
+    async removeItem(key) {
+        const cacheMap = this.getCacheMap();
+        cacheMap.delete(key);
+    }
+}
+exports.FatcmsBaseCtxCache = FatcmsBaseCtxCache;

package/dist/service/base/cache/FatcmsBaseDiskCache.d.ts

@@ -0,0 +1,24 @@
+import { Context } from '@midwayjs/koa';
+import { ICacheServiceBase, IfatcmsCacheConfig } from '../../../models/bizmodels';
+export declare class FatcmsBaseDiskCache implements ICacheServiceBase {
+    protected ctx: Context;
+    protected cacheName: string;
+    private fatcmsCache;
+    constructor(ctx: Context, cacheName: string, fatcmsCache: IfatcmsCacheConfig);
+    /**
+     * 获取缓存文件路径
+     * @param key
+     * @returns
+     */
+    private getCacheFilePath;
+    getJsonObject(key: string): Promise<any>;
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any>;
+    removeItem(key: string): Promise<any>;
+}

package/dist/service/base/cache/FatcmsBaseDiskCache.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FatcmsBaseDiskCache = void 0;
+const md5 = require("md5");
+const fs = require("fs/promises");
+const fs2 = require("fs");
+const path = require("path");
+const functions_1 = require("../../../libs/utils/functions");
+class FatcmsBaseDiskCache {
+    constructor(ctx, cacheName, fatcmsCache) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+        this.fatcmsCache = fatcmsCache;
+    }
+    /**
+     * 获取缓存文件路径
+     * @param key
+     * @returns
+     */
+    async getCacheFilePath(key, checkDirExist = true) {
+        const cacheDir0 = this.fatcmsCache.diskCacheDir;
+        const cacheDir = path.join(cacheDir0, this.cacheName);
+        if (checkDirExist) {
+            const isDirExist = await fs2.promises.access(cacheDir).then(() => true, () => false);
+            if (!isDirExist) {
+                await fs2.promises.mkdir(cacheDir, { recursive: true });
+            }
+        }
+        return path.join(cacheDir, `${md5(key)}.json`);
+    }
+    async getJsonObject(key) {
+        const cacheFilePath = await this.getCacheFilePath(key, false);
+        try {
+            const str = await fs.readFile(cacheFilePath, 'utf8');
+            const data = (0, functions_1.parseJsonObject)(str);
+            if (data && data.key === key && data.expireAt > Date.now()) {
+                return data.data;
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    async setJsonObject(key, obj, expireSecond) {
+        if (!expireSecond) {
+            expireSecond = 60;
+        }
+        const str = JSON.stringify({
+            data: obj,
+            key,
+            expireAt: Date.now() + expireSecond * 1000,
+        });
+        const cacheFilePath = await this.getCacheFilePath(key);
+        try {
+            await fs.writeFile(cacheFilePath, str, 'utf8');
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async removeItem(key) {
+        const cacheFilePath = await this.getCacheFilePath(key);
+        try {
+            await fs.unlink(cacheFilePath);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+exports.FatcmsBaseDiskCache = FatcmsBaseDiskCache;

package/dist/service/base/cache/FatcmsBaseMemoryCache.d.ts

@@ -0,0 +1,18 @@
+import { Context } from '@midwayjs/koa';
+import { ICacheServiceBase } from '../../../models/bizmodels';
+export declare class FatcmsBaseMemoryCache implements ICacheServiceBase {
+    protected ctx: Context;
+    protected cacheName: string;
+    constructor(ctx: Context, cacheName: string);
+    private getLruCache;
+    getJsonObject(key: string): Promise<any>;
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any>;
+    removeItem(key: string): Promise<any>;
+}

package/dist/service/base/cache/FatcmsBaseMemoryCache.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FatcmsBaseMemoryCache = void 0;
+const lru_cache_1 = require("lru-cache");
+const LRU_CACHE_MAP = new Map();
+class FatcmsBaseMemoryCache {
+    constructor(ctx, cacheName) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+    getLruCache() {
+        if (!LRU_CACHE_MAP.has(this.cacheName)) {
+            const lruCache = new lru_cache_1.LRUCache({
+                max: 500,
+                ttl: 1000 * 60 * 60 * 24,
+                ttlAutopurge: true,
+            });
+            LRU_CACHE_MAP.set(this.cacheName, lruCache);
+        }
+        return LRU_CACHE_MAP.get(this.cacheName);
+    }
+    async getJsonObject(key) {
+        try {
+            const lruCache = this.getLruCache();
+            const saveObj = lruCache.get(key);
+            if (saveObj && saveObj.key === key && saveObj.expireAt > Date.now()) {
+                return saveObj.data;
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    async setJsonObject(key, obj, expireSecond) {
+        const lruCache = this.getLruCache();
+        if (!expireSecond) {
+            expireSecond = 60;
+        }
+        const saveObj = {
+            data: obj,
+            key,
+            expireAt: Date.now() + expireSecond * 1000,
+        };
+        lruCache.set(key, saveObj);
+        return true;
+    }
+    async removeItem(key) {
+        try {
+            const lruCache = this.getLruCache();
+            lruCache.delete(key);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+exports.FatcmsBaseMemoryCache = FatcmsBaseMemoryCache;

package/dist/service/base/cache/FatcmsBaseNoneCache.d.ts

@@ -0,0 +1,10 @@
+import { ICacheServiceBase } from '../../../models/bizmodels';
+import { Context } from '@midwayjs/koa';
+export declare class FatcmsBaseNoneCache implements ICacheServiceBase {
+    protected ctx: Context;
+    protected cacheName: string;
+    constructor(ctx: Context, cacheName: string);
+    getJsonObject(key: string): Promise<any>;
+    setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any>;
+    removeItem(key: string): Promise<any>;
+}

package/dist/service/base/cache/FatcmsBaseNoneCache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FatcmsBaseNoneCache = void 0;
+class FatcmsBaseNoneCache {
+    constructor(ctx, cacheName) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+    async getJsonObject(key) {
+        return null;
+    }
+    async setJsonObject(key, obj, expireSecond) {
+        return true;
+    }
+    async removeItem(key) {
+        return true;
+    }
+}
+exports.FatcmsBaseNoneCache = FatcmsBaseNoneCache;

package/dist/service/base/{RedisCacheService.d.ts → cache/FatcmsBaseRedisCache.d.ts}

@@ -1,12 +1,12 @@
 import { Context } from '@midwayjs/koa';
 import { RedisService } from '@midwayjs/redis';
-import { OSSServiceFactory } from '@midwayjs/oss';
-import * as koa from '@midwayjs/koa';
-export declare class RedisCacheService {
+import { ICacheServiceBase } from '../../../models/bizmodels';
+export declare class FatcmsBaseRedisCache implements ICacheServiceBase {
     protected ctx: Context;
-    protected app: koa.Application;
+    protected cacheName: string;
     protected redisService: RedisService;
-    protected ossServiceFactory: OSSServiceFactory;
+    constructor(ctx: Context, cacheName: string, redisService: RedisService);
+    private getCacheKey;
     getJsonObject(key: string): Promise<any>;
     /**
      * 设置缓存对象
@@ -15,6 +15,6 @@ export declare class RedisCacheService {
      * @param expireSecond 过期时间，单位秒
      * @returns
      */
-    setJsonObject(key: string, obj: any, expireSecond: number): Promise<any>;
+    setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any>;
     removeItem(key: string): Promise<any>;
 }