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

package/src/service/EnumInfoService.ts

@@ -5,10 +5,10 @@ import { CurdProService } from './curd/CurdProService';
 import { RelatedType } from './curd/CurdMixUtils';
 import { SystemTables } from '@/models/SystemTables';
 import { parseConfigContentToEnumInfo, IEnumInfo } from '@/libs/utils/parseConfig';
-import { RedisCacheService } from './base/RedisCacheService';
 import { CurdMixByLinkToCustomService } from './curd/CurdMixByLinkToCustomService';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { RedisKeys } from '@/models/RedisKeys';
+import { CacheServiceFactory } from './base/cache/CacheServiceFactory';
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
 
 interface IQueryEnumInfo {
   type: RelatedType;
@@ -24,6 +24,10 @@ function filterEmpty(e: IEnumInfo): boolean {
   return e.label && typeof e.value !== 'undefined';
 }
 
+const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
+
+
 @Provide()
 export class EnumInfoService {
   @Inject()
@@ -35,33 +39,42 @@ export class EnumInfoService {
   private curdMixByLinkToCustomService: CurdMixByLinkToCustomService;
 
   @Inject()
-  private redisCacheService: RedisCacheService;
+  private cacheServiceFactory: CacheServiceFactory;
 
   async queryEnumInfo(codeList: IQueryEnumInfo[], refreshCache: boolean): Promise<IQueryEnumResult[]> {
-    const expireSecond = 2 * 60;
+    const { queryEnumInfoCacheLevel, queryEnumInfoCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig() || {};
+
+    const getEnumInfoByCode = async (type: RelatedType, code: string) => {
+      if (type === 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: CacheNameEnum.GetEnumInfoByCode,
+        getter: async () => {
+          if (type === RelatedType.sysCfgEnum) {
+            return await this.queryEnumInfoBySysCfgEnum(code);
+          } else if (type === 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.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 === RelatedType.sysCfgEnum) {
-          values = await this.queryEnumInfoBySysCfgEnum(code);
-          await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
-        } else if (type === RelatedType.dict) {
-          values = await this.queryEnumInfoItemByDict(code);
-          await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
-        } else if (type === 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;
   }
 

package/src/service/UserSessionService.ts

@@ -2,13 +2,14 @@ import { Config, Inject, Provide } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
 import { parseJsonObject } from '@/libs/utils/functions';
 import { ISessionInfo, SESSION_ID_KEY, sessionCookieCfg } from '@/models/userSession';
-import { RedisCacheService } from './base/RedisCacheService';
-import { RedisKeys } from '@/models/RedisKeys';
 import { HEADER_KEY_RUN_BY_ASYNC_TASK_ID } from '@/models/AsyncTaskModel';
 import { CurdProService } from './curd/CurdProService';
 import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { SystemTables } from '@/models/SystemTables';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { CacheServiceFactory } from './base/cache/CacheServiceFactory';
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import { ICacheServiceBase } from '@/models/bizmodels';
 
 function pickUserAvatar(avatar: any): string {
   if (!avatar) {
@@ -37,11 +38,7 @@ function pickUserAvatar(avatar: any): string {
   return null;
 }
 
-const SESSION_KEEP_TIME_SECOND: number = 3600 * 24 * 30;
-
-const toCacheKey = (sessionId: string): string => {
-  return `${RedisKeys.USER_SESSION_PREFIX}${sessionId}`;
-};
+const SESSION_KEEP_TIME_SECOND: number = 3600 * 24 * 7;
 
 @Provide()
 export class UserSessionService {
@@ -49,7 +46,7 @@ export class UserSessionService {
   private ctx: Context;
 
   @Inject()
-  private redisCacheService: RedisCacheService;
+  private cacheServiceFactory: CacheServiceFactory;
 
   @Inject()
   private curdProService: CurdProService;
@@ -68,6 +65,15 @@ export class UserSessionService {
     return SESSION_KEEP_TIME_SECOND;
   }
 
+
+  /**
+   * 获取用户会话缓存服务
+   * @returns
+   */
+  private getUserSessionCacheService(): ICacheServiceBase {
+    return this.cacheServiceFactory.getCacheService(CacheLevelEnum.REDIS, CacheNameEnum.UserSessionBySessionId);
+  }
+
   /**
    * 保存用户会话信息。
    * 用户登录后，在业务的项目中，可以调用此函数，更新bizExt字段
@@ -77,7 +83,8 @@ export 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);
   }
 
   /**
@@ -85,7 +92,8 @@ export class UserSessionService {
    * @param sessionId
    */
   public async removeUserSession(sessionId: string) {
-    return await this.redisCacheService.removeItem(toCacheKey(sessionId));
+    const userSessionCache = this.getUserSessionCacheService();
+    return await userSessionCache.removeItem(sessionId);
   }
 
   /**
@@ -97,7 +105,8 @@ export class UserSessionService {
     if (!sessionId) {
       return null;
     }
-    return await this.redisCacheService.getJsonObject(toCacheKey(sessionId));
+    const userSessionCache = this.getUserSessionCacheService();
+    return await userSessionCache.getJsonObject(sessionId);
   }
 
   /**
@@ -105,7 +114,7 @@ export class UserSessionService {
    * @param asyncTaskId
    */
   private async getCurrentUserSessionByAsyncTaskId(asyncTaskId: string): Promise<ISessionInfo> {
-    const taskSessionCacheKey = `${RedisKeys.USER_SESSION_ASYNC_TASK_ID_PREFIX}${asyncTaskId}`;
+    const taskSessionCacheKey = `${asyncTaskId}`;
 
     const loadSessionInfo = async (): Promise<ISessionInfo> => {
       const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
@@ -124,7 +133,6 @@ export class UserSessionService {
           sqlDbType: SystemDbType,
         }
       );
-
       const asyncTaskObj = asyncTaskRes.getOneObj();
       if (!asyncTaskObj) {
         return null;
@@ -132,11 +140,14 @@ export class UserSessionService {
       return 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: CacheLevelEnum.REDIS,
+      cacheName: CacheNameEnum.UserSessionByAsyncTaskId,
+      cacheKey: taskSessionCacheKey,
+      cacheSecond: 3600,
+      getter: loadSessionInfo,
+    });
+
     return sessionInfo1;
   }
 

package/src/service/WorkbenchService.ts

@@ -7,12 +7,13 @@ import { BaseService } from './base/BaseService';
 import { CurdProService } from './curd/CurdProService';
 import { CommonException } from '@/libs/crud-pro/exceptions';
 import { parseJsonObject } from '@/libs/utils/functions';
-import { IWorkbenchEntity } from '@/models/SystemEntities';
+import { IWorkbenchConfig, IWorkbenchEntity } from '@/models/SystemEntities';
 import { IScheduleService } from '@/interface';
 import { getDebugWorkbenchCode } from '@/libs/utils/fatcms-request';
 import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 import { HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE } from '@/models/AsyncTaskModel';
+import { formatHost } from '@/libs/utils/format-url';
 //
 // const lruCache = new LRUCache<string, any>({
 //   max: 500,
@@ -170,10 +171,12 @@ export class WorkbenchService extends BaseService implements IScheduleService {
    * @returns
    */
   private getCurrentHost(): string {
-    const host = this.ctx.request.host;
+    let host = this.ctx.request.host;
     if (!host) {
       throw new CommonException('GET_CURRENT_HOST_ERROR', '获取当前域名失败');
     }
+
+    host = formatHost(host);
     return host;
   }
 
@@ -217,4 +220,41 @@ export class WorkbenchService extends BaseService implements IScheduleService {
     }
     return true;
   }
+
+
+
+  public isSupportTheNodePathByWorkbenchInfo(workbenchInfo: IWorkbenchEntity, path: string): boolean {
+
+    // 非node api路径，直接返回true
+    if(!path.startsWith('/ns/')) {
+      return true;
+    }
+
+    const configObj: IWorkbenchConfig = parseJsonObject(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;
+
+  }
+
+
+
+
+
 }

package/src/service/base/cache/CacheServiceFactory.ts

@@ -0,0 +1,66 @@
+import { Inject, Provide, Config } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { ICacheServiceBase, IfatcmsCacheConfig } from '@/models/bizmodels';
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import { RedisService } from '@midwayjs/redis';
+import { FatcmsBaseCtxCache } from './FatcmsBaseCtxCache';
+import { FatcmsBaseRedisCache } from './FatcmsBaseRedisCache';
+import { FatcmsBaseDiskCache } from './FatcmsBaseDiskCache';
+import { FatcmsBaseMemoryCache } from './FatcmsBaseMemoryCache';
+import { FatcmsBaseNoneCache } from './FatcmsBaseNoneCache';
+
+interface IGetJsonObjectCacheParam {
+    cacheLevel: CacheLevelEnum;
+    cacheName: CacheNameEnum;
+    cacheKey: string;
+    cacheSecond: number;
+    refreshCache?: boolean;
+    getter: () => Promise<any>;
+}
+
+@Provide()
+export class CacheServiceFactory {
+    @Inject()
+    protected ctx: Context;
+
+    @Config('fatcmsCache')
+    private fatcmsCache: IfatcmsCacheConfig;
+
+    @Inject()
+    protected redisService: RedisService;
+
+    public getCacheService(cacheLevelEnum: CacheLevelEnum, cacheName: CacheNameEnum): ICacheServiceBase {
+        switch (cacheLevelEnum) {
+            case CacheLevelEnum.CONTEXT:
+                return new FatcmsBaseCtxCache(this.ctx, cacheName);
+            case CacheLevelEnum.REDIS:
+                return new FatcmsBaseRedisCache(this.ctx, cacheName, this.redisService);
+            case CacheLevelEnum.DISK:
+                return new FatcmsBaseDiskCache(this.ctx, cacheName, this.fatcmsCache);
+            case CacheLevelEnum.MEMORY:
+                return new FatcmsBaseMemoryCache(this.ctx, cacheName);
+            default:
+                return new FatcmsBaseNoneCache(this.ctx, cacheName);
+        }
+    }
+
+    public async getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any> {
+        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;
+    }
+
+}

package/src/service/base/cache/FatcmsBaseCtxCache.ts

@@ -0,0 +1,47 @@
+import { ICacheServiceBase } from '@/models/bizmodels';
+import { CacheNameEnum } from '@/models/SystemEntities';
+import { Context } from '@midwayjs/koa';
+
+
+
+export class FatcmsBaseCtxCache implements ICacheServiceBase {
+    private ctx: Context;
+    private cacheName: CacheNameEnum;
+
+    constructor(ctx: Context, cacheName: CacheNameEnum) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+
+    private getCacheMap(): Map<string, any> {
+        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: string): Promise<any> {
+        const cacheMap = this.getCacheMap();
+        return cacheMap.get(key);
+    }
+
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+        const cacheMap = this.getCacheMap();
+        cacheMap.set(key, obj);
+    }
+
+    async removeItem(key: string): Promise<any> {
+        const cacheMap = this.getCacheMap();
+        cacheMap.delete(key);
+    }
+}

package/src/service/base/cache/FatcmsBaseDiskCache.ts

@@ -0,0 +1,87 @@
+import { Context } from '@midwayjs/koa';
+import * as md5 from 'md5';
+import * as fs from 'fs/promises';
+import * as fs2 from 'fs';
+import * as path from 'path';
+import { parseJsonObject } from '../../../libs/utils/functions';
+import { ICacheServiceBase, IfatcmsCacheConfig } from '@/models/bizmodels';
+
+
+export class FatcmsBaseDiskCache implements ICacheServiceBase {
+    protected ctx: Context;
+    protected cacheName: string;
+    private fatcmsCache: IfatcmsCacheConfig;
+
+    constructor(ctx: Context, cacheName: string, fatcmsCache: IfatcmsCacheConfig) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+        this.fatcmsCache = fatcmsCache;
+    }
+
+
+    /**
+     * 获取缓存文件路径
+     * @param key
+     * @returns
+     */
+    private async getCacheFilePath(key: string, checkDirExist: boolean = true): Promise<string> {
+        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: string): Promise<any> {
+        const cacheFilePath = await this.getCacheFilePath(key, false);
+        try {
+            const str = await fs.readFile(cacheFilePath, 'utf8');
+            const data = 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: string, obj: any, expireSecond?: number): Promise<any> {
+        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: string): Promise<any> {
+        const cacheFilePath = await this.getCacheFilePath(key);
+        try {
+            await fs.unlink(cacheFilePath);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/service/base/cache/FatcmsBaseMemoryCache.ts

@@ -0,0 +1,74 @@
+import { Context } from '@midwayjs/koa';
+import { LRUCache } from 'lru-cache';
+import { ICacheServiceBase } from '@/models/bizmodels';
+
+
+
+const LRU_CACHE_MAP = new Map<string, LRUCache<string, any>>();
+
+
+export class FatcmsBaseMemoryCache implements ICacheServiceBase {
+    protected ctx: Context;
+    protected cacheName: string;
+
+    constructor(ctx: Context, cacheName: string) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+    }
+
+    private getLruCache(): LRUCache<string, any> {
+        if (!LRU_CACHE_MAP.has(this.cacheName)) {
+            const lruCache = new LRUCache<string, any>({
+                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: string): Promise<any> {
+        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: string, obj: any, expireSecond?: number): Promise<any> {
+        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: string): Promise<any> {
+        try {
+            const lruCache = this.getLruCache();
+            lruCache.delete(key);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/service/base/cache/FatcmsBaseNoneCache.ts

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

package/src/service/base/cache/FatcmsBaseRedisCache.ts

@@ -0,0 +1,48 @@
+import { Context } from '@midwayjs/koa';
+import { RedisService } from '@midwayjs/redis';
+import { parseJsonObject } from '../../../libs/utils/functions';
+import { ICacheServiceBase } from '@/models/bizmodels';
+
+
+export class FatcmsBaseRedisCache implements ICacheServiceBase {
+  protected ctx: Context;
+  protected cacheName: string;
+  protected redisService: RedisService;
+
+  constructor(ctx: Context, cacheName: string, redisService: RedisService) {
+    this.ctx = ctx;
+    this.cacheName = cacheName;
+    this.redisService = redisService;
+  }
+
+  private getCacheKey(key: string): string {
+    return `${this.cacheName}${key}`;
+  }
+
+  async getJsonObject(key: string): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    const str = await this.redisService.get(cacheKey);
+    return parseJsonObject(str);
+  }
+
+  /**
+   * 设置缓存对象
+   * @param key
+   * @param obj
+   * @param expireSecond 过期时间，单位秒
+   * @returns
+   */
+  async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    if (!expireSecond) {
+      expireSecond = 60;
+    }
+    const str = JSON.stringify(obj);
+    return this.redisService.set(cacheKey, str, 'EX', expireSecond);
+  }
+
+  async removeItem(key: string): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    return await this.redisService.del(cacheKey);
+  }
+}