midway-fatcms 0.0.1-beta.76 → 0.0.1-beta.77

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

@@ -1,135 +1,135 @@
-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';
-import {IScheduleService} from "@/interface";
-
-interface IGetJsonObjectCacheParam {
-    cacheName: CacheNameEnum;
-    cacheKey: string;
-    refreshCache?: boolean;
-    scheduleRefresh?: boolean;
-    getter: () => Promise<any>;
-}
-
-interface IRemoveItemCacheParam {
-  cacheName: CacheNameEnum;
-  cacheKey: string;
-}
-
-const defaultCacheConfig: IWorkbenchConfigCacheLevel = {
-  cacheLevel: CacheLevelEnum.MEMORY,
-  cacheSecond: 60 * 60 * 24 * 7
-}
-
-const isScheduleBusyTag = { busy : false };
-
-const SCHEDULE_REFRESH_TASK_MAP = new Map<string, IGetJsonObjectCacheParam>;
-
-
-@Provide()
-export class CacheServiceFactory implements IScheduleService {
-  @Inject()
-  protected ctx: Context;
-
-  @Config('fatcmsCache')
-  private fatcmsCache: IfatcmsCacheConfig;
-
-  @Inject()
-  protected redisService: RedisService;
-
-  public async runBySchedule() {
-
-    if (isScheduleBusyTag.busy) {
-      return;
-    }
-    isScheduleBusyTag.busy = true;
-
-    try {
-      const keys = SCHEDULE_REFRESH_TASK_MAP.keys();
-      for (const key of keys) {
-        const param = SCHEDULE_REFRESH_TASK_MAP.get(key);
-        try {
-          if (param) {
-            const {cacheName, cacheKey, getter} = param;
-            const cacheService = this.getCacheServiceByName(cacheName);
-            if (cacheService) {
-              const obj = await getter();
-              await cacheService.setJsonObject(cacheKey, obj);
-            }
-          }
-        } catch (error) {
-          this.ctx.logger.error(`[CacheServiceFactory]runBySchedule#${param.cacheName}`, error);
-        }
-      }
-    } catch (e) {
-      this.ctx.logger.error(`[CacheServiceFactory]runBySchedule`, e);
-    } finally {
-      isScheduleBusyTag.busy = false;
-    }
-
-  }
-
-  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, scheduleRefresh, getter} = param;
-
-    if (scheduleRefresh === true) {
-      const scheduleKey = `${cacheName}_${cacheKey}`;
-      if (!SCHEDULE_REFRESH_TASK_MAP.has(scheduleKey)) {
-        SCHEDULE_REFRESH_TASK_MAP.set(scheduleKey, 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);
-  }
-
-}
+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';
+import {IScheduleService} from "@/interface";
+
+interface IGetJsonObjectCacheParam {
+    cacheName: CacheNameEnum;
+    cacheKey: string;
+    refreshCache?: boolean;
+    scheduleRefresh?: boolean;
+    getter: () => Promise<any>;
+}
+
+interface IRemoveItemCacheParam {
+  cacheName: CacheNameEnum;
+  cacheKey: string;
+}
+
+const defaultCacheConfig: IWorkbenchConfigCacheLevel = {
+  cacheLevel: CacheLevelEnum.MEMORY,
+  cacheSecond: 60 * 60 * 24 * 7
+}
+
+const isScheduleBusyTag = { busy : false };
+
+const SCHEDULE_REFRESH_TASK_MAP = new Map<string, IGetJsonObjectCacheParam>;
+
+
+@Provide()
+export class CacheServiceFactory implements IScheduleService {
+  @Inject()
+  protected ctx: Context;
+
+  @Config('fatcmsCache')
+  private fatcmsCache: IfatcmsCacheConfig;
+
+  @Inject()
+  protected redisService: RedisService;
+
+  public async runBySchedule() {
+
+    if (isScheduleBusyTag.busy) {
+      return;
+    }
+    isScheduleBusyTag.busy = true;
+
+    try {
+      const keys = SCHEDULE_REFRESH_TASK_MAP.keys();
+      for (const key of keys) {
+        const param = SCHEDULE_REFRESH_TASK_MAP.get(key);
+        try {
+          if (param) {
+            const {cacheName, cacheKey, getter} = param;
+            const cacheService = this.getCacheServiceByName(cacheName);
+            if (cacheService) {
+              const obj = await getter();
+              await cacheService.setJsonObject(cacheKey, obj);
+            }
+          }
+        } catch (error) {
+          this.ctx.logger.error(`[CacheServiceFactory]runBySchedule#${param.cacheName}`, error);
+        }
+      }
+    } catch (e) {
+      this.ctx.logger.error(`[CacheServiceFactory]runBySchedule`, e);
+    } finally {
+      isScheduleBusyTag.busy = false;
+    }
+
+  }
+
+  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, scheduleRefresh, getter} = param;
+
+    if (scheduleRefresh === true) {
+      const scheduleKey = `${cacheName}_${cacheKey}`;
+      if (!SCHEDULE_REFRESH_TASK_MAP.has(scheduleKey)) {
+        SCHEDULE_REFRESH_TASK_MAP.set(scheduleKey, 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

@@ -1,45 +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);
-    }
-}
+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

@@ -1,82 +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;
-        }
-    }
-}
+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

@@ -1,68 +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;
-        }
-    }
-}
+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;
+        }
+    }
+}