midway-fatcms 0.0.1-beta.7 → 0.0.1-beta.71

package/src/service/base/BaseService.ts

@@ -1,74 +1,95 @@
-import { Inject, Provide, App } from '@midwayjs/core';
-import { Context } from '@midwayjs/koa';
-import { RedisService } from '@midwayjs/redis';
-import { OSSService, OSSServiceFactory } from '@midwayjs/oss';
-import * as koa from '@midwayjs/koa';
-import { consoleLogger, ContextLogger, ILoggerContext } from '../../models/contextLogger';
-import { isEnableDebug, isLocalEnv } from '../../libs/utils/fatcms-request';
-
-
-@Provide()
-export class BaseService {
-  @Inject()
-  protected ctx: Context;
-
-  @App()
-  protected app: koa.Application;
-
-  @Inject()
-  protected redisService: RedisService;
-
-  @Inject()
-  protected ossServiceFactory: OSSServiceFactory;
-
-
-  /**
-   * 用户自己上传的文件，使用私有的bucket。
-   * @protected
-   */
-  protected getPrivateOSSService(): OSSService {
-    return this.ossServiceFactory.get<OSSService>('privateBucket');
-  }
-
-  /**
-   * 公共读的bucket，如js文件等使用它
-   * @protected
-   */
-  protected getPublicOSSService(): OSSService {
-    return this.ossServiceFactory.get<OSSService>('publicBucket');
-  }
-
-
-  protected getContextLogger(): ILoggerContext {
-    return this.ctx.contextLogger || consoleLogger;
-  }
-
-  protected getPrefixContextLogger(prefix: string) {
-    const s = this.ctx.contextLogger as ContextLogger;
-    return s.getPrefixContextLogger(prefix);
-  }
-
-  protected logInfo(msg: string, ...args: any) {
-    this.getContextLogger().info(msg, ...args);
-  }
-
-  protected logError(msg: string, ...args: any) {
-    this.getContextLogger().error(msg, ...args);
-  }
-
-  protected logWarn(msg: string, ...args: any) {
-    this.getContextLogger().warn(msg, ...args);
-  }
-
-  protected logDebug(msg: string, ...args: any) {
-    this.getContextLogger().debug(msg, ...args);
-  }
-
-  protected isLocalEnv(): boolean {
-    return isLocalEnv(this.ctx);
-  }
-
-  protected isEnableDebug(): boolean {
-    return isEnableDebug(this.ctx);
-  }
-}
+import { Inject, Provide, App } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { RedisService } from '@midwayjs/redis';
+import { OSSService, OSSServiceFactory } from '@midwayjs/oss';
+import * as koa from '@midwayjs/koa';
+import { consoleLogger, ContextLogger, ILoggerContext } from '@/models/contextLogger';
+import { isEnableDebug, isLocalEnv } from '@/libs/utils/fatcms-request';
+
+@Provide()
+export class BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @App()
+  protected app: koa.Application;
+
+  @Inject()
+  protected redisService: RedisService;
+
+  @Inject()
+  protected ossServiceFactory: OSSServiceFactory;
+
+  /**
+   * 请求级别的内存缓存
+   * @param key
+   * @returns
+   */
+  protected getFromCtxCache(key: string): any {
+    if (!this.ctx.ctxCacheMap) {
+      this.ctx.ctxCacheMap = {};
+    }
+    return this.ctx.ctxCacheMap[key];
+  }
+
+  /**
+   * 请求级别的内存缓存
+   * @param key
+   * @param obj
+   */
+  protected setToCtxCache(key: string, obj: any): void {
+    if (!this.ctx.ctxCacheMap) {
+      this.ctx.ctxCacheMap = {};
+    }
+    this.ctx.ctxCacheMap[key] = obj;
+  }
+
+  /**
+   * 用户自己上传的文件，使用私有的bucket。
+   * @protected
+   */
+  protected getPrivateOSSService(): OSSService {
+    return this.ossServiceFactory.get<OSSService>('privateBucket');
+  }
+
+  /**
+   * 公共读的bucket，如js文件等使用它
+   * @protected
+   */
+  protected getPublicOSSService(): OSSService {
+    return this.ossServiceFactory.get<OSSService>('publicBucket');
+  }
+
+  protected getContextLogger(): ILoggerContext {
+    return this.ctx.contextLogger || consoleLogger;
+  }
+
+  protected getPrefixContextLogger(prefix: string) {
+    const s = this.ctx.contextLogger as ContextLogger;
+    return s.getPrefixContextLogger(prefix);
+  }
+
+  protected logInfo(msg: string, ...args: any) {
+    this.getContextLogger().info(msg, ...args);
+  }
+
+  protected logError(msg: string, ...args: any) {
+    this.getContextLogger().error(msg, ...args);
+  }
+
+  protected logWarn(msg: string, ...args: any) {
+    this.getContextLogger().warn(msg, ...args);
+  }
+
+  protected logDebug(msg: string, ...args: any) {
+    this.getContextLogger().debug(msg, ...args);
+  }
+
+  protected isLocalEnv(): boolean {
+    return isLocalEnv(this.ctx);
+  }
+
+  protected isEnableDebug(): boolean {
+    return isEnableDebug(this.ctx);
+  }
+}

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

@@ -0,0 +1,86 @@
+import { Inject, Provide, Config } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import {CacheNameEnum, ICacheService, IfatcmsCacheConfig, IWorkbenchConfigCacheLevel} from '@/models/bizmodels';
+import { CacheLevelEnum,  } from '@/models/SystemEntities';
+import { RedisService } from '@midwayjs/redis';
+import { CtxCache } from './CtxCache';
+import { RedisCache } from './RedisCache';
+import { DiskCache } from './DiskCache';
+import { MemoryCache } from './MemoryCache';
+import { NoneCache } from './NoneCache';
+
+interface IGetJsonObjectCacheParam {
+    cacheName: CacheNameEnum;
+    cacheKey: string;
+    refreshCache?: boolean;
+    getter: () => Promise<any>;
+}
+
+interface IRemoveItemCacheParam {
+  cacheName: CacheNameEnum;
+  cacheKey: string;
+}
+
+const defaultCacheConfig: IWorkbenchConfigCacheLevel = {
+  cacheLevel: CacheLevelEnum.MEMORY,
+  cacheSecond: 60 * 60 * 24 * 7
+}
+
+@Provide()
+export class CacheServiceFactory {
+  @Inject()
+  protected ctx: Context;
+
+  @Config('fatcmsCache')
+  private fatcmsCache: IfatcmsCacheConfig;
+
+  @Inject()
+  protected redisService: RedisService;
+
+  private getCacheService(cacheLevelEnum: CacheLevelEnum, cacheName: CacheNameEnum, cacheSecond: number): ICacheService {
+    switch (cacheLevelEnum) {
+      case CacheLevelEnum.CONTEXT:
+        return new CtxCache(this.ctx, cacheName);
+      case CacheLevelEnum.REDIS:
+        return new RedisCache(this.ctx, cacheName, this.redisService, cacheSecond);
+      case CacheLevelEnum.DISK:
+        return new DiskCache(this.ctx, cacheName, this.fatcmsCache, cacheSecond);
+      case CacheLevelEnum.MEMORY:
+        return new MemoryCache(this.ctx, cacheName, cacheSecond);
+      case CacheLevelEnum.NONE:
+        return new NoneCache(this.ctx, cacheName);
+      default:
+        return new NoneCache(this.ctx, cacheName);
+    }
+  }
+
+
+  public getCacheServiceByName(cacheName: CacheNameEnum): ICacheService {
+    const cacheConfig: Record<CacheNameEnum, IWorkbenchConfigCacheLevel> = (this.fatcmsCache?.cacheConfig || {}) as any;
+    if (cacheConfig[cacheName]) {
+      const { cacheLevel, cacheSecond } = Object.assign({}, defaultCacheConfig, cacheConfig[cacheName]) ;
+      return this.getCacheService(cacheLevel, cacheName, cacheSecond);
+    }
+    const { cacheLevel, cacheSecond } = defaultCacheConfig;
+    return this.getCacheService(cacheLevel, cacheName, cacheSecond);
+  }
+
+
+  public async getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any> {
+    const {cacheName, cacheKey, refreshCache, getter} = param;
+    const cacheService = this.getCacheServiceByName(cacheName);
+    let obj = await cacheService.getJsonObject(cacheKey);
+    if (!obj || refreshCache === true) {
+      obj = await getter();
+      await cacheService.setJsonObject(cacheKey, obj);
+    }
+    return obj;
+  }
+
+  public async removeItemCache(param: IRemoveItemCacheParam): Promise<any> {
+    const {cacheName, cacheKey } = param;
+    const cacheService = this.getCacheServiceByName(cacheName);
+    return await cacheService.removeItem(cacheKey);
+  }
+
+}

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

@@ -0,0 +1,45 @@
+import { ICacheService } from '@/models/bizmodels';
+import { CacheNameEnum} from "@/models/bizmodels";
+import { Context } from '@midwayjs/koa';
+
+
+
+export class CtxCache implements ICacheService {
+    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
+     * @returns
+     */
+    async setJsonObject(key: string, obj: any): 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/DiskCache.ts

@@ -0,0 +1,82 @@
+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 { ICacheService, IfatcmsCacheConfig } from '@/models/bizmodels';
+
+
+export class DiskCache implements ICacheService {
+    protected ctx: Context;
+    protected cacheName: string;
+    private fatcmsCache: IfatcmsCacheConfig;
+    private cacheSecond: number;
+    constructor(ctx: Context, cacheName: string, fatcmsCache: IfatcmsCacheConfig,cacheSecond: number) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+        this.fatcmsCache = fatcmsCache;
+        this.cacheSecond = cacheSecond;
+    }
+
+
+  /**
+   * 获取缓存文件路径
+   * @param key
+   * @param checkDirExist
+   * @private
+   */
+    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;
+        }
+    }
+
+
+    async setJsonObject(key: string, obj: any, cacheSecond0?: number): Promise<any> {
+      const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
+
+        const str = JSON.stringify({
+            data: obj,
+            key,
+            expireAt: Date.now() + cacheSecond * 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/MemoryCache.ts

@@ -0,0 +1,68 @@
+import { Context } from '@midwayjs/koa';
+import { LRUCache } from 'lru-cache';
+import { ICacheService } from '@/models/bizmodels';
+
+
+
+const LRU_CACHE_MAP = new Map<string, LRUCache<string, any>>();
+
+
+export class MemoryCache implements ICacheService {
+    protected ctx: Context;
+    protected cacheName: string;
+    protected cacheSecond: number;
+
+    constructor(ctx: Context, cacheName: string, cacheSecond:number) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+        this.cacheSecond = cacheSecond;
+    }
+
+    private getLruCache(): LRUCache<string, any> {
+        if (!LRU_CACHE_MAP.has(this.cacheName)) {
+            const lruCache = new LRUCache<string, any>({
+                max: 2000,
+                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;
+        }
+    }
+
+
+    async setJsonObject(key: string, obj: any, cacheSecond0: number): Promise<any> {
+        const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
+        const lruCache = this.getLruCache();
+        const saveObj = {
+            data: obj,
+            key,
+            expireAt: Date.now() + cacheSecond * 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/NoneCache.ts

@@ -0,0 +1,24 @@
+import { ICacheService } from '@/models/bizmodels';
+import { Context } from '@midwayjs/koa';
+
+export class NoneCache implements ICacheService {
+    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/RedisCache.ts

@@ -0,0 +1,41 @@
+import { Context } from '@midwayjs/koa';
+import { RedisService } from '@midwayjs/redis';
+import { parseJsonObject } from '@/libs/utils/functions';
+import { ICacheService } from '@/models/bizmodels';
+
+export class RedisCache implements ICacheService {
+  protected ctx: Context;
+  protected cacheName: string;
+  protected redisService: RedisService;
+  protected cacheSecond: number;
+
+  constructor(ctx: Context, cacheName: string, redisService: RedisService, cacheSecond: number) {
+    this.ctx = ctx;
+    this.cacheName = cacheName;
+    this.redisService = redisService;
+    this.cacheSecond = cacheSecond;
+  }
+
+  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);
+  }
+
+
+  async setJsonObject(key: string, obj: any, cacheSecond0?: number): Promise<any> {
+    const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
+    const cacheKey = this.getCacheKey(key);
+    const str = JSON.stringify(obj);
+    return this.redisService.set(cacheKey, str, 'EX', cacheSecond);
+  }
+
+  async removeItem(key: string): Promise<any> {
+    const cacheKey = this.getCacheKey(key);
+    return this.redisService.del(cacheKey);
+  }
+}

package/src/service/crudstd/CrudStdActionService.ts

@@ -1,27 +1,27 @@
-import { Inject, Provide } from '@midwayjs/core';
-import { Context } from '@midwayjs/koa';
-import * as _ from 'lodash';
-import { CurdMixService } from '../curd/CurdMixService';
-import { IRequestModel } from '../../libs/crud-pro/interfaces';
-import { ICrudStdAppInfo } from '../../models/bizmodels';
-import { BaseService } from '../base/BaseService';
-
-interface IHandleStdActionByReq {
-  actionsMap: any;
-  appInfo: ICrudStdAppInfo;
-  params: IRequestModel;
-  actionCfg: any;
-}
-
-@Provide()
-export class CrudStdActionService extends BaseService {
-  @Inject()
-  protected ctx: Context;
-
-  @Inject()
-  protected curdMixService: CurdMixService;
-
-  public async handleStdActionByReq({ appInfo, params, actionCfg }: IHandleStdActionByReq) {
-    return null;
-  }
-}
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { CurdMixService } from '../curd/CurdMixService';
+import { IRequestModel } from '../../libs/crud-pro/interfaces';
+import { ICrudStdAppInfo } from '../../models/bizmodels';
+import { BaseService } from '../base/BaseService';
+
+interface IHandleStdActionByReq {
+  actionsMap: any;
+  appInfo: ICrudStdAppInfo;
+  params: IRequestModel;
+  actionCfg: any;
+}
+
+@Provide()
+export class CrudStdActionService extends BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  protected curdMixService: CurdMixService;
+
+  public async handleStdActionByReq({ appInfo, params, actionCfg }: IHandleStdActionByReq) {
+    return null;
+  }
+}