midway-fatcms 0.0.2 → 0.0.3

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

@@ -1,26 +1,26 @@
-import { Context } from '@midwayjs/koa';
-import { CacheNameEnum, ICacheService } from '../../../models/bizmodels';
-import { RedisService } from '@midwayjs/redis';
-import { IScheduleService } from "../../../interface";
-interface IGetJsonObjectCacheParam {
-    cacheName: CacheNameEnum;
-    cacheKey: string;
-    refreshCache?: boolean;
-    scheduleRefresh?: boolean;
-    getter: () => Promise<any>;
-}
-interface IRemoveItemCacheParam {
-    cacheName: CacheNameEnum;
-    cacheKey: string;
-}
-export declare class CacheServiceFactory implements IScheduleService {
-    protected ctx: Context;
-    private fatcmsCache;
-    protected redisService: RedisService;
-    runBySchedule(): Promise<void>;
-    private getCacheService;
-    getCacheServiceByName(cacheName: CacheNameEnum): ICacheService;
-    getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any>;
-    removeItemCache(param: IRemoveItemCacheParam): Promise<any>;
-}
-export {};
+import { Context } from '@midwayjs/koa';
+import { CacheNameEnum, ICacheService } from '../../../models/bizmodels';
+import { RedisService } from '@midwayjs/redis';
+import { IScheduleService } from "../../../interface";
+interface IGetJsonObjectCacheParam {
+    cacheName: CacheNameEnum;
+    cacheKey: string;
+    refreshCache?: boolean;
+    scheduleRefresh?: boolean;
+    getter: () => Promise<any>;
+}
+interface IRemoveItemCacheParam {
+    cacheName: CacheNameEnum;
+    cacheKey: string;
+}
+export declare class CacheServiceFactory implements IScheduleService {
+    protected ctx: Context;
+    private fatcmsCache;
+    protected redisService: RedisService;
+    runBySchedule(): Promise<void>;
+    private getCacheService;
+    getCacheServiceByName(cacheName: CacheNameEnum): ICacheService;
+    getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any>;
+    removeItemCache(param: IRemoveItemCacheParam): Promise<any>;
+}
+export {};

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

@@ -1,122 +1,122 @@
-"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 CtxCache_1 = require("./CtxCache");
-const RedisCache_1 = require("./RedisCache");
-const DiskCache_1 = require("./DiskCache");
-const MemoryCache_1 = require("./MemoryCache");
-const NoneCache_1 = require("./NoneCache");
-const defaultCacheConfig = {
-    cacheLevel: SystemEntities_1.CacheLevelEnum.MEMORY,
-    cacheSecond: 60 * 60 * 24 * 7
-};
-const isScheduleBusyTag = { busy: false };
-const SCHEDULE_REFRESH_TASK_MAP = new Map;
-let CacheServiceFactory = class CacheServiceFactory {
-    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;
-        }
-    }
-    getCacheService(cacheLevelEnum, cacheName, cacheSecond) {
-        switch (cacheLevelEnum) {
-            case SystemEntities_1.CacheLevelEnum.CONTEXT:
-                return new CtxCache_1.CtxCache(this.ctx, cacheName);
-            case SystemEntities_1.CacheLevelEnum.REDIS:
-                return new RedisCache_1.RedisCache(this.ctx, cacheName, this.redisService, cacheSecond);
-            case SystemEntities_1.CacheLevelEnum.DISK:
-                return new DiskCache_1.DiskCache(this.ctx, cacheName, this.fatcmsCache, cacheSecond);
-            case SystemEntities_1.CacheLevelEnum.MEMORY:
-                return new MemoryCache_1.MemoryCache(this.ctx, cacheName, cacheSecond);
-            case SystemEntities_1.CacheLevelEnum.NONE:
-                return new NoneCache_1.NoneCache(this.ctx, cacheName);
-            default:
-                return new NoneCache_1.NoneCache(this.ctx, cacheName);
-        }
-    }
-    getCacheServiceByName(cacheName) {
-        var _a;
-        const cacheConfig = (((_a = this.fatcmsCache) === null || _a === void 0 ? void 0 : _a.cacheConfig) || {});
-        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);
-    }
-    async getJsonObjectCache(param) {
-        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;
-    }
-    async removeItemCache(param) {
-        const { cacheName, cacheKey } = param;
-        const cacheService = this.getCacheServiceByName(cacheName);
-        return await cacheService.removeItem(cacheKey);
-    }
-};
-__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;
+"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 CtxCache_1 = require("./CtxCache");
+const RedisCache_1 = require("./RedisCache");
+const DiskCache_1 = require("./DiskCache");
+const MemoryCache_1 = require("./MemoryCache");
+const NoneCache_1 = require("./NoneCache");
+const defaultCacheConfig = {
+    cacheLevel: SystemEntities_1.CacheLevelEnum.MEMORY,
+    cacheSecond: 60 * 60 * 24 * 7
+};
+const isScheduleBusyTag = { busy: false };
+const SCHEDULE_REFRESH_TASK_MAP = new Map;
+let CacheServiceFactory = class CacheServiceFactory {
+    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;
+        }
+    }
+    getCacheService(cacheLevelEnum, cacheName, cacheSecond) {
+        switch (cacheLevelEnum) {
+            case SystemEntities_1.CacheLevelEnum.CONTEXT:
+                return new CtxCache_1.CtxCache(this.ctx, cacheName);
+            case SystemEntities_1.CacheLevelEnum.REDIS:
+                return new RedisCache_1.RedisCache(this.ctx, cacheName, this.redisService, cacheSecond);
+            case SystemEntities_1.CacheLevelEnum.DISK:
+                return new DiskCache_1.DiskCache(this.ctx, cacheName, this.fatcmsCache, cacheSecond);
+            case SystemEntities_1.CacheLevelEnum.MEMORY:
+                return new MemoryCache_1.MemoryCache(this.ctx, cacheName, cacheSecond);
+            case SystemEntities_1.CacheLevelEnum.NONE:
+                return new NoneCache_1.NoneCache(this.ctx, cacheName);
+            default:
+                return new NoneCache_1.NoneCache(this.ctx, cacheName);
+        }
+    }
+    getCacheServiceByName(cacheName) {
+        var _a;
+        const cacheConfig = (((_a = this.fatcmsCache) === null || _a === void 0 ? void 0 : _a.cacheConfig) || {});
+        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);
+    }
+    async getJsonObjectCache(param) {
+        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;
+    }
+    async removeItemCache(param) {
+        const { cacheName, cacheKey } = param;
+        const cacheService = this.getCacheServiceByName(cacheName);
+        return await cacheService.removeItem(cacheKey);
+    }
+};
+__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/CtxCache.d.ts

@@ -1,18 +1,18 @@
-import { ICacheService } from '../../../models/bizmodels';
-import { CacheNameEnum } from "../../../models/bizmodels";
-import { Context } from '@midwayjs/koa';
-export declare class CtxCache implements ICacheService {
-    private ctx;
-    private cacheName;
-    constructor(ctx: Context, cacheName: CacheNameEnum);
-    private getCacheMap;
-    getJsonObject(key: string): Promise<any>;
-    /**
-     * 设置缓存对象
-     * @param key
-     * @param obj
-     * @returns
-     */
-    setJsonObject(key: string, obj: any): Promise<any>;
-    removeItem(key: string): Promise<any>;
-}
+import { ICacheService } from '../../../models/bizmodels';
+import { CacheNameEnum } from "../../../models/bizmodels";
+import { Context } from '@midwayjs/koa';
+export declare class CtxCache implements ICacheService {
+    private ctx;
+    private cacheName;
+    constructor(ctx: Context, cacheName: CacheNameEnum);
+    private getCacheMap;
+    getJsonObject(key: string): Promise<any>;
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @returns
+     */
+    setJsonObject(key: string, obj: any): Promise<any>;
+    removeItem(key: string): Promise<any>;
+}

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

@@ -1,37 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CtxCache = void 0;
-class CtxCache {
-    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
-     * @returns
-     */
-    async setJsonObject(key, obj) {
-        const cacheMap = this.getCacheMap();
-        cacheMap.set(key, obj);
-    }
-    async removeItem(key) {
-        const cacheMap = this.getCacheMap();
-        cacheMap.delete(key);
-    }
-}
-exports.CtxCache = CtxCache;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CtxCache = void 0;
+class CtxCache {
+    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
+     * @returns
+     */
+    async setJsonObject(key, obj) {
+        const cacheMap = this.getCacheMap();
+        cacheMap.set(key, obj);
+    }
+    async removeItem(key) {
+        const cacheMap = this.getCacheMap();
+        cacheMap.delete(key);
+    }
+}
+exports.CtxCache = CtxCache;

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

@@ -1,19 +1,19 @@
-import { Context } from '@midwayjs/koa';
-import { ICacheService, IfatcmsCacheConfig } from '../../../models/bizmodels';
-export declare class DiskCache implements ICacheService {
-    protected ctx: Context;
-    protected cacheName: string;
-    private fatcmsCache;
-    private cacheSecond;
-    constructor(ctx: Context, cacheName: string, fatcmsCache: IfatcmsCacheConfig, cacheSecond: number);
-    /**
-     * 获取缓存文件路径
-     * @param key
-     * @param checkDirExist
-     * @private
-     */
-    private getCacheFilePath;
-    getJsonObject(key: string): Promise<any>;
-    setJsonObject(key: string, obj: any, cacheSecond0?: number): Promise<any>;
-    removeItem(key: string): Promise<any>;
-}
+import { Context } from '@midwayjs/koa';
+import { ICacheService, IfatcmsCacheConfig } from '../../../models/bizmodels';
+export declare class DiskCache implements ICacheService {
+    protected ctx: Context;
+    protected cacheName: string;
+    private fatcmsCache;
+    private cacheSecond;
+    constructor(ctx: Context, cacheName: string, fatcmsCache: IfatcmsCacheConfig, cacheSecond: number);
+    /**
+     * 获取缓存文件路径
+     * @param key
+     * @param checkDirExist
+     * @private
+     */
+    private getCacheFilePath;
+    getJsonObject(key: string): Promise<any>;
+    setJsonObject(key: string, obj: any, cacheSecond0?: number): Promise<any>;
+    removeItem(key: string): Promise<any>;
+}

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

@@ -1,81 +1,81 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiskCache = 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 DiskCache {
-    constructor(ctx, cacheName, fatcmsCache, cacheSecond) {
-        this.ctx = ctx;
-        this.cacheName = cacheName;
-        this.fatcmsCache = fatcmsCache;
-        this.cacheSecond = cacheSecond;
-    }
-    /**
-     * 获取缓存文件路径
-     * @param key
-     * @param checkDirExist
-     * @private
-     */
-    async getCacheFilePath(key, checkDirExist = true) {
-        const cacheDir0 = this.fatcmsCache.diskCacheDir;
-        const cacheDir = path.join(cacheDir0, this.cacheName);
-        if (checkDirExist) {
-            let isDirExist = false;
-            try {
-                await fs2.promises.access(cacheDir);
-                isDirExist = true;
-            }
-            catch (_a) {
-                isDirExist = 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;
-        }
-    }
-    async setJsonObject(key, obj, cacheSecond0) {
-        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) {
-        const cacheFilePath = await this.getCacheFilePath(key);
-        try {
-            await fs.unlink(cacheFilePath);
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}
-exports.DiskCache = DiskCache;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskCache = 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 DiskCache {
+    constructor(ctx, cacheName, fatcmsCache, cacheSecond) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+        this.fatcmsCache = fatcmsCache;
+        this.cacheSecond = cacheSecond;
+    }
+    /**
+     * 获取缓存文件路径
+     * @param key
+     * @param checkDirExist
+     * @private
+     */
+    async getCacheFilePath(key, checkDirExist = true) {
+        const cacheDir0 = this.fatcmsCache.diskCacheDir;
+        const cacheDir = path.join(cacheDir0, this.cacheName);
+        if (checkDirExist) {
+            let isDirExist = false;
+            try {
+                await fs2.promises.access(cacheDir);
+                isDirExist = true;
+            }
+            catch (_a) {
+                isDirExist = 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;
+        }
+    }
+    async setJsonObject(key, obj, cacheSecond0) {
+        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) {
+        const cacheFilePath = await this.getCacheFilePath(key);
+        try {
+            await fs.unlink(cacheFilePath);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+exports.DiskCache = DiskCache;

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

@@ -1,12 +1,12 @@
-import { Context } from '@midwayjs/koa';
-import { ICacheService } from '../../../models/bizmodels';
-export declare class MemoryCache implements ICacheService {
-    protected ctx: Context;
-    protected cacheName: string;
-    protected cacheSecond: number;
-    constructor(ctx: Context, cacheName: string, cacheSecond: number);
-    private getLruCache;
-    getJsonObject(key: string): Promise<any>;
-    setJsonObject(key: string, obj: any, cacheSecond0: number): Promise<any>;
-    removeItem(key: string): Promise<any>;
-}
+import { Context } from '@midwayjs/koa';
+import { ICacheService } from '../../../models/bizmodels';
+export declare class MemoryCache implements ICacheService {
+    protected ctx: Context;
+    protected cacheName: string;
+    protected cacheSecond: number;
+    constructor(ctx: Context, cacheName: string, cacheSecond: number);
+    private getLruCache;
+    getJsonObject(key: string): Promise<any>;
+    setJsonObject(key: string, obj: any, cacheSecond0: number): Promise<any>;
+    removeItem(key: string): Promise<any>;
+}