midway-fatcms 0.0.16 → 0.0.17

package/dist/service/base/bizmemcache/BizMemCacheService.d.ts

@@ -0,0 +1,16 @@
+import { IScheduleService } from '../../../interface';
+import { BaseService } from "../../../service/base/BaseService";
+export declare class BizMemCacheService extends BaseService implements IScheduleService {
+    private curdProService;
+    runBySchedule(): Promise<void>;
+    private reloadIfRedisChanged;
+    private loadSysMenuCacheObj;
+    private loadDataDictItemCacheObj;
+    private loadSysConfigObj;
+    private loadWorkbenchCachedObj;
+    private loadSysAppCacheObj;
+    private loadSysAppPageCacheObj;
+    private loadSysAnyApiCacheObj;
+    private loadSysProxyApiCacheObj;
+    private loadCrudMethodCacheObj;
+}

package/dist/service/base/bizmemcache/BizMemCacheService.js

@@ -0,0 +1,239 @@
+"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.BizMemCacheService = void 0;
+const _ = require("lodash");
+const core_1 = require("@midwayjs/core");
+const SystemTables_1 = require("../../../models/SystemTables");
+const global_config_1 = require("../../../libs/global-config/global-config");
+const BaseService_1 = require("../../../service/base/BaseService");
+const CurdProService_1 = require("../../curd/CurdProService");
+const keys_1 = require("../../../libs/crud-pro/models/keys");
+const MixinUtils_1 = require("../../../libs/crud-pro/utils/MixinUtils");
+const BizMemCacheStore_1 = require("./BizMemCacheStore");
+const BizMemCacheTypes_1 = require("./BizMemCacheTypes");
+const functions_1 = require("../../../libs/utils/functions");
+const CrudProCachedCfgService_1 = require("../../../libs/crud-pro/services/CrudProCachedCfgService");
+let BizMemCacheService = class BizMemCacheService extends BaseService_1.BaseService {
+    async runBySchedule() {
+        await this.reloadIfRedisChanged('workbenchCachedObj', () => this.loadWorkbenchCachedObj());
+        await this.reloadIfRedisChanged('sysConfgCacheObj', () => this.loadSysConfigObj());
+        await this.reloadIfRedisChanged('dataDictItemCacheObj', () => this.loadDataDictItemCacheObj());
+        await this.reloadIfRedisChanged('sysMenuCacheObj', () => this.loadSysMenuCacheObj());
+        await this.reloadIfRedisChanged('sysAppCacheObj', () => this.loadSysAppCacheObj());
+        await this.reloadIfRedisChanged('sysAppPageCacheObj', () => this.loadSysAppPageCacheObj());
+        await this.reloadIfRedisChanged('sysAnyApiCacheObj', () => this.loadSysAnyApiCacheObj());
+        await this.reloadIfRedisChanged('sysProxyApiCacheObj', () => this.loadSysProxyApiCacheObj());
+        await this.reloadIfRedisChanged('crudMethodCacheObj', () => this.loadCrudMethodCacheObj());
+    }
+    async reloadIfRedisChanged(key, loader) {
+        const redisTime = Number(await this.redisService.get(BizMemCacheStore_1.bizMemCacheStore.getRedisKey(key))) || 0;
+        if (redisTime !== BizMemCacheStore_1.bizMemCacheStore.getLastTime(key)) {
+            await loader();
+            BizMemCacheStore_1.bizMemCacheStore.setLastTime(key, redisTime);
+        }
+    }
+    async loadSysMenuCacheObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res1 = await this.curdProService.executeCrudByCfg({
+            condition: { deleted_at: 0, status: 1 },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_menus,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            maxLimit: 10 * 10000
+        });
+        const rows = res1.getResRows();
+        const cacheObj = {
+            sysMenuList: rows,
+            sysMenuCodeMap: _.keyBy(rows, 'menu_code')
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setSysMenu(cacheObj);
+    }
+    async loadDataDictItemCacheObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res1 = await this.curdProService.executeCrudByCfg({
+            columns: ['dict_code', 'label', 'value', 'style', 'code'],
+            condition: { deleted_at: 0, status: 1 },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_data_dict_item,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            maxLimit: 10 * 10000
+        });
+        const rows = res1.getResRows();
+        const dictCodeMap = _.groupBy(rows, 'dict_code');
+        const cacheObj = {
+            dictCodeMap: dictCodeMap
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setDataDictItem(cacheObj);
+    }
+    async loadSysConfigObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res1 = await this.curdProService.executeCrudByCfg({
+            condition: { deleted_at: 0, status: 1 },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_configs,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        const sysConfigCodeMap = {};
+        const rows = res1.getResRows();
+        if (Array.isArray(rows) && rows.length > 0) {
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const { config_code } = row;
+                sysConfigCodeMap[config_code] = row;
+            }
+        }
+        const cacheObj = {
+            sysConfigList: rows,
+            sysConfigCodeMap: sysConfigCodeMap
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setSysConfig(cacheObj);
+    }
+    async loadWorkbenchCachedObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const reqJson = { condition: { deleted_at: 0 }, pageSize: 1000, limit: 1000 };
+        const res = await this.curdProService.executeCrudByCfg(reqJson, {
+            sqlTable: SystemTables_1.SystemTables.sys_workbench,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        const listData = res.getResRows();
+        const domainMap1 = MixinUtils_1.MixinUtils.toMap(listData, (e) => e.workbench_domain); // 主域名。其他两个域名。
+        const domainMap2 = MixinUtils_1.MixinUtils.toMap(listData, (e) => e.workbench_domain2);
+        const domainMap3 = MixinUtils_1.MixinUtils.toMap(listData, (e) => e.workbench_domain3);
+        const domainMap = { ...domainMap1, ...domainMap2, ...domainMap3 };
+        const cacheObj = {
+            workbenchList: listData,
+            workbenchDomainMap: domainMap
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setWorkbench(cacheObj);
+    }
+    async loadSysAppCacheObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res = await this.curdProService.executeCrudByCfg({
+            condition: { deleted_at: 0 },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_app,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            maxLimit: 10 * 10000,
+        });
+        const rows = res.getResRows();
+        const cacheObj = {
+            sysAppList: rows,
+            sysAppCodeMap: _.keyBy(rows, 'app_code'),
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setSysApp(cacheObj);
+    }
+    async loadSysAppPageCacheObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res = await this.curdProService.executeCrudByCfg({
+            condition: { deleted_at: 0 },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_app_page,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            maxLimit: 10 * 10000,
+        });
+        const rows = res.getResRows();
+        const sysAppPageMap = {};
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const cacheKey = (0, BizMemCacheTypes_1.buildSysAppPageCacheKey)(row.workbench_code, row.page_path);
+            sysAppPageMap[cacheKey] = row;
+        }
+        const cacheObj = {
+            sysAppPageList: rows,
+            sysAppPageMap,
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setSysAppPage(cacheObj);
+    }
+    async loadSysAnyApiCacheObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res = await this.curdProService.executeCrudByCfg({
+            condition: { deleted_at: 0 },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_anyapi,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            maxLimit: 10 * 10000,
+        });
+        const rows = res.getResRows();
+        const sysAnyApiMethodMap = {};
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const obj = { ...row };
+            obj.parsedOthers = (0, functions_1.parseJsonObject)(obj.others);
+            sysAnyApiMethodMap[row.method] = obj;
+        }
+        const cacheObj = {
+            sysAnyApiList: rows,
+            sysAnyApiMethodMap,
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setSysAnyApi(cacheObj);
+    }
+    async loadSysProxyApiCacheObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res = await this.curdProService.executeCrudByCfg({
+            condition: { deleted_at: 0 },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_proxyapi,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            maxLimit: 10 * 10000,
+        });
+        const rows = res.getResRows();
+        const cacheObj = {
+            sysProxyApiList: rows,
+            routeTrieMap: null,
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setSysProxyApi(cacheObj);
+    }
+    async loadCrudMethodCacheObj() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const res = await this.curdProService.executeCrudByCfg({
+            condition: { deleted_at: 0 },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_crud_methods,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+            maxLimit: 10 * 10000,
+        });
+        const rows = res.getResRows();
+        const crudMethodList = rows.map(row => (0, CrudProCachedCfgService_1.parseCrudMethodInfo)(row));
+        const cacheObj = {
+            crudMethodList,
+            crudMethodMap: _.keyBy(crudMethodList, 'method'),
+        };
+        BizMemCacheStore_1.bizMemCacheStore.setCrudMethod(cacheObj);
+        (0, CrudProCachedCfgService_1.setMethodCache)(crudMethodList);
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], BizMemCacheService.prototype, "curdProService", void 0);
+BizMemCacheService = __decorate([
+    (0, core_1.Provide)()
+], BizMemCacheService);
+exports.BizMemCacheService = BizMemCacheService;

package/dist/service/base/bizmemcache/BizMemCacheStore.d.ts

@@ -0,0 +1,34 @@
+import { RedisService } from '@midwayjs/redis';
+import { BizMemCacheKey, ICrudMethodCacheObj, IDataDictItemCacheObj, ISysAnyApiCacheObj, ISysAppCacheObj, ISysAppPageCacheObj, ISysConfgCacheObj, ISysMenuCacheObj, ISysProxyApiCacheObj, IWorkbenchCachedObj } from './BizMemCacheTypes';
+declare class BizMemCacheStoreInner {
+    private data;
+    private lastTime;
+    getWorkbench(): IWorkbenchCachedObj | null;
+    setWorkbench(obj: IWorkbenchCachedObj): void;
+    getSysConfig(): ISysConfgCacheObj | null;
+    setSysConfig(obj: ISysConfgCacheObj): void;
+    getSysMenu(): ISysMenuCacheObj | null;
+    setSysMenu(obj: ISysMenuCacheObj): void;
+    getDataDictItem(): IDataDictItemCacheObj | null;
+    setDataDictItem(obj: IDataDictItemCacheObj): void;
+    getSysApp(): ISysAppCacheObj | null;
+    setSysApp(obj: ISysAppCacheObj): void;
+    getSysAppPage(): ISysAppPageCacheObj | null;
+    setSysAppPage(obj: ISysAppPageCacheObj): void;
+    getSysAnyApi(): ISysAnyApiCacheObj | null;
+    setSysAnyApi(obj: ISysAnyApiCacheObj): void;
+    getSysProxyApi(): ISysProxyApiCacheObj | null;
+    setSysProxyApi(obj: ISysProxyApiCacheObj): void;
+    getCrudMethod(): ICrudMethodCacheObj | null;
+    setCrudMethod(obj: ICrudMethodCacheObj): void;
+    getRedisKey(key: BizMemCacheKey): string;
+    getAllKeys(): BizMemCacheKey[];
+    isKeyValid(key: string): key is BizMemCacheKey;
+    getLastTime(key: BizMemCacheKey): number;
+    setLastTime(key: BizMemCacheKey, time: number): void;
+    getLastTimeSnapshot(): Readonly<Record<BizMemCacheKey, number>>;
+    markDirty(key: BizMemCacheKey, redis: RedisService): Promise<void>;
+    markAllDirty(redis: RedisService): Promise<void>;
+}
+export declare const bizMemCacheStore: BizMemCacheStoreInner;
+export {};

package/dist/service/base/bizmemcache/BizMemCacheStore.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bizMemCacheStore = void 0;
+const BizMemCacheTypes_1 = require("./BizMemCacheTypes");
+function createEmptyData() {
+    return {
+        workbenchCachedObj: null,
+        sysConfgCacheObj: null,
+        sysMenuCacheObj: null,
+        dataDictItemCacheObj: null,
+        sysAppCacheObj: null,
+        sysAppPageCacheObj: null,
+        sysAnyApiCacheObj: null,
+        sysProxyApiCacheObj: null,
+        crudMethodCacheObj: null,
+    };
+}
+function createEmptyLastTime() {
+    return {
+        workbenchCachedObj: 0,
+        sysConfgCacheObj: 0,
+        sysMenuCacheObj: 0,
+        dataDictItemCacheObj: 0,
+        sysAppCacheObj: 0,
+        sysAppPageCacheObj: 0,
+        sysAnyApiCacheObj: 0,
+        sysProxyApiCacheObj: 0,
+        crudMethodCacheObj: 0,
+    };
+}
+class BizMemCacheStoreInner {
+    constructor() {
+        this.data = createEmptyData();
+        this.lastTime = createEmptyLastTime();
+    }
+    getWorkbench() {
+        return this.data.workbenchCachedObj;
+    }
+    setWorkbench(obj) {
+        this.data.workbenchCachedObj = obj;
+    }
+    getSysConfig() {
+        return this.data.sysConfgCacheObj;
+    }
+    setSysConfig(obj) {
+        this.data.sysConfgCacheObj = obj;
+    }
+    getSysMenu() {
+        return this.data.sysMenuCacheObj;
+    }
+    setSysMenu(obj) {
+        this.data.sysMenuCacheObj = obj;
+    }
+    getDataDictItem() {
+        return this.data.dataDictItemCacheObj;
+    }
+    setDataDictItem(obj) {
+        this.data.dataDictItemCacheObj = obj;
+    }
+    getSysApp() {
+        return this.data.sysAppCacheObj;
+    }
+    setSysApp(obj) {
+        this.data.sysAppCacheObj = obj;
+    }
+    getSysAppPage() {
+        return this.data.sysAppPageCacheObj;
+    }
+    setSysAppPage(obj) {
+        this.data.sysAppPageCacheObj = obj;
+    }
+    getSysAnyApi() {
+        return this.data.sysAnyApiCacheObj;
+    }
+    setSysAnyApi(obj) {
+        this.data.sysAnyApiCacheObj = obj;
+    }
+    getSysProxyApi() {
+        return this.data.sysProxyApiCacheObj;
+    }
+    setSysProxyApi(obj) {
+        this.data.sysProxyApiCacheObj = obj;
+    }
+    getCrudMethod() {
+        return this.data.crudMethodCacheObj;
+    }
+    setCrudMethod(obj) {
+        this.data.crudMethodCacheObj = obj;
+    }
+    getRedisKey(key) {
+        return BizMemCacheTypes_1.BIZ_MEM_CACHE_REDIS_KEYS[key];
+    }
+    getAllKeys() {
+        return Object.keys(BizMemCacheTypes_1.BIZ_MEM_CACHE_REDIS_KEYS);
+    }
+    isKeyValid(key) {
+        return Object.prototype.hasOwnProperty.call(BizMemCacheTypes_1.BIZ_MEM_CACHE_REDIS_KEYS, key);
+    }
+    getLastTime(key) {
+        return this.lastTime[key];
+    }
+    setLastTime(key, time) {
+        this.lastTime[key] = time;
+    }
+    getLastTimeSnapshot() {
+        return { ...this.lastTime };
+    }
+    async markDirty(key, redis) {
+        await redis.set(this.getRedisKey(key), Date.now());
+    }
+    async markAllDirty(redis) {
+        const now = Date.now();
+        for (const key of this.getAllKeys()) {
+            await redis.set(this.getRedisKey(key), now);
+        }
+    }
+}
+exports.bizMemCacheStore = new BizMemCacheStoreInner();

package/dist/service/base/bizmemcache/BizMemCacheTypes.d.ts

@@ -0,0 +1,60 @@
+import { IWorkbenchEntity } from '../../../models/SystemEntities';
+export interface IWorkbenchCachedObj {
+    workbenchList: IWorkbenchEntity[];
+    workbenchDomainMap: Record<string, IWorkbenchEntity>;
+}
+export interface ISysMenuCacheObj {
+    sysMenuList: any[];
+    sysMenuCodeMap: Record<string, any>;
+}
+export interface ISysConfgCacheObj {
+    sysConfigList: any[];
+    sysConfigCodeMap: Record<string, any>;
+}
+export interface IDataDictItemCacheObj {
+    dictCodeMap: Record<string, any[]>;
+}
+export interface ISysAppCacheObj {
+    sysAppList: any[];
+    sysAppCodeMap: Record<string, any>;
+}
+export interface ISysAppPageCacheObj {
+    sysAppPageList: any[];
+    sysAppPageMap: Record<string, any>;
+}
+export declare function buildSysAppPageCacheKey(workbench_code: string, page_path: string): string;
+export interface ISysAnyApiCacheObj {
+    sysAnyApiList: any[];
+    sysAnyApiMethodMap: Record<string, any>;
+}
+export interface ISysProxyApiCacheObj {
+    sysProxyApiList: any[];
+    routeTrieMap: Record<string, any> | null;
+}
+export interface ICrudMethodCacheObj {
+    crudMethodList: any[];
+    crudMethodMap: Record<string, any>;
+}
+export interface IBizMemCacheData {
+    workbenchCachedObj: IWorkbenchCachedObj;
+    sysConfgCacheObj: ISysConfgCacheObj;
+    sysMenuCacheObj: ISysMenuCacheObj;
+    dataDictItemCacheObj: IDataDictItemCacheObj;
+    sysAppCacheObj: ISysAppCacheObj;
+    sysAppPageCacheObj: ISysAppPageCacheObj;
+    sysAnyApiCacheObj: ISysAnyApiCacheObj;
+    sysProxyApiCacheObj: ISysProxyApiCacheObj;
+    crudMethodCacheObj: ICrudMethodCacheObj;
+}
+export declare const BIZ_MEM_CACHE_REDIS_KEYS: {
+    readonly workbenchCachedObj: "BIZ_MEM_CACHE_KEY:workbenchCachedObj";
+    readonly sysConfgCacheObj: "BIZ_MEM_CACHE_KEY:sysConfgCacheObj";
+    readonly sysMenuCacheObj: "BIZ_MEM_CACHE_KEY:sysMenuCacheObj";
+    readonly dataDictItemCacheObj: "BIZ_MEM_CACHE_KEY:dataDictItemCacheObj";
+    readonly sysAppCacheObj: "BIZ_MEM_CACHE_KEY:sysAppCacheObj";
+    readonly sysAppPageCacheObj: "BIZ_MEM_CACHE_KEY:sysAppPageCacheObj";
+    readonly sysAnyApiCacheObj: "BIZ_MEM_CACHE_KEY:sysAnyApiCacheObj";
+    readonly sysProxyApiCacheObj: "BIZ_MEM_CACHE_KEY:sysProxyApiCacheObj";
+    readonly crudMethodCacheObj: "BIZ_MEM_CACHE_KEY:crudMethodCacheObj";
+};
+export declare type BizMemCacheKey = keyof typeof BIZ_MEM_CACHE_REDIS_KEYS;

package/dist/service/base/bizmemcache/BizMemCacheTypes.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BIZ_MEM_CACHE_REDIS_KEYS = exports.buildSysAppPageCacheKey = void 0;
+function buildSysAppPageCacheKey(workbench_code, page_path) {
+    return `${workbench_code}#${page_path}`;
+}
+exports.buildSysAppPageCacheKey = buildSysAppPageCacheKey;
+exports.BIZ_MEM_CACHE_REDIS_KEYS = {
+    workbenchCachedObj: 'BIZ_MEM_CACHE_KEY:workbenchCachedObj',
+    sysConfgCacheObj: 'BIZ_MEM_CACHE_KEY:sysConfgCacheObj',
+    sysMenuCacheObj: 'BIZ_MEM_CACHE_KEY:sysMenuCacheObj',
+    dataDictItemCacheObj: 'BIZ_MEM_CACHE_KEY:dataDictItemCacheObj',
+    sysAppCacheObj: 'BIZ_MEM_CACHE_KEY:sysAppCacheObj',
+    sysAppPageCacheObj: 'BIZ_MEM_CACHE_KEY:sysAppPageCacheObj',
+    sysAnyApiCacheObj: 'BIZ_MEM_CACHE_KEY:sysAnyApiCacheObj',
+    sysProxyApiCacheObj: 'BIZ_MEM_CACHE_KEY:sysProxyApiCacheObj',
+    crudMethodCacheObj: 'BIZ_MEM_CACHE_KEY:crudMethodCacheObj',
+};

package/dist/service/base/cache-refresh/CacheRefreshHub.d.ts

@@ -1,33 +1,11 @@
 import { CacheRefreshCategory } from '../../../models/CacheRefreshCategory';
 import * as koa from '@midwayjs/koa';
 declare type CacheRefresher = (ctx: koa.IMidwayKoaContext) => Promise<any>;
-/**
- * 统一缓存刷新中心
- *
- * 负责 非 HTTP 中间件场景 的缓存刷新，包括：
- * 1. 定时刷新：CacheRefreshHubScheduleService 实现 IScheduleService，10分钟自动调度
- * 2. Redis Pub/Sub 集群广播：CacheRefreshRedisSubscriber 收到广播后调用
- * 3. API 主动刷新：helpers.controller /refreshCache 接口调用
- *
- * 注意：manage 增删改触发的缓存刷新由 refreshCache() 中间件直接调用 CacheServiceFactory 完成，
- * 不经过 CacheRefreshHub。
- */
 declare class CacheRefreshHubInner {
     private readonly refreshers;
-    /**
-     * 注册缓存刷新器
-     */
     register(category: CacheRefreshCategory, refresher: CacheRefresher): void;
-    /**
-     * 刷新指定类型的缓存（主动重加载）
-     * @param category 缓存类型，'*' 刷新全部
-     */
     refresh(category: CacheRefreshCategory | '*', ctx: koa.IMidwayKoaContext): Promise<void>;
-    /**
-     * 定时任务入口，刷新全部缓存
-     */
     runBySchedule(ctx: koa.IMidwayKoaContext): Promise<void>;
 }
-/** 全局唯一实例 */
 export declare const CacheRefreshHub: CacheRefreshHubInner;
 export {};

package/dist/service/base/cache-refresh/CacheRefreshHub.js

@@ -3,31 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheRefreshHub = void 0;
 const CacheRefreshCategory_1 = require("../../../models/CacheRefreshCategory");
 const CrudMonitor_1 = require("../../../libs/crud-pro/utils/CrudMonitor");
-/**
- * 统一缓存刷新中心
- *
- * 负责 非 HTTP 中间件场景 的缓存刷新，包括：
- * 1. 定时刷新：CacheRefreshHubScheduleService 实现 IScheduleService，10分钟自动调度
- * 2. Redis Pub/Sub 集群广播：CacheRefreshRedisSubscriber 收到广播后调用
- * 3. API 主动刷新：helpers.controller /refreshCache 接口调用
- *
- * 注意：manage 增删改触发的缓存刷新由 refreshCache() 中间件直接调用 CacheServiceFactory 完成，
- * 不经过 CacheRefreshHub。
- */
 class CacheRefreshHubInner {
     constructor() {
         this.refreshers = new Map();
     }
-    /**
-     * 注册缓存刷新器
-     */
     register(category, refresher) {
         this.refreshers.set(category, refresher);
     }
-    /**
-     * 刷新指定类型的缓存（主动重加载）
-     * @param category 缓存类型，'*' 刷新全部
-     */
     async refresh(category, ctx) {
         const categories = category === '*' ? CacheRefreshCategory_1.ALL_CACHE_REFRESH_CATEGORIES : [category];
         for (const cat of categories) {
@@ -43,12 +25,8 @@ class CacheRefreshHubInner {
             }
         }
     }
-    /**
-     * 定时任务入口，刷新全部缓存
-     */
     async runBySchedule(ctx) {
         await this.refresh('*', ctx);
     }
 }
-/** 全局唯一实例 */
 exports.CacheRefreshHub = new CacheRefreshHubInner();

package/dist/service/base/cache-refresh/CacheRefreshHubScheduleService.d.ts

@@ -1,11 +1,5 @@
 import * as koa from '@midwayjs/koa';
 import { IScheduleService } from '../../../interface';
-/**
- * CacheRefreshHub 的定时调度适配器
- *
- * 实现 IScheduleService 接口，使 CacheRefreshHub 能被 runSchedule.ts 调度。
- * 注册到 scheduleNames.ts 中的 cacheRefreshHub 定时任务。
- */
 export declare class CacheRefreshHubScheduleService implements IScheduleService {
     runBySchedule(ctx: koa.IMidwayKoaContext): Promise<void>;
 }

package/dist/service/base/cache-refresh/CacheRefreshHubScheduleService.js

@@ -9,12 +9,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheRefreshHubScheduleService = void 0;
 const core_1 = require("@midwayjs/core");
 const CacheRefreshHub_1 = require("../../../service/base/cache-refresh/CacheRefreshHub");
-/**
- * CacheRefreshHub 的定时调度适配器
- *
- * 实现 IScheduleService 接口，使 CacheRefreshHub 能被 runSchedule.ts 调度。
- * 注册到 scheduleNames.ts 中的 cacheRefreshHub 定时任务。
- */
 let CacheRefreshHubScheduleService = class CacheRefreshHubScheduleService {
     async runBySchedule(ctx) {
         await CacheRefreshHub_1.CacheRefreshHub.refresh('*', ctx);

package/dist/service/curd/CurdMixByDictService.d.ts

@@ -2,10 +2,6 @@ import { Context } from '@midwayjs/koa';
 import { HandleExecuteContextType, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
 export declare class CurdMixByDictService implements IExecuteContextHandler {
     ctx: Context;
-    private curdProService;
-    private cacheServiceFactory;
-    private getFromCache;
-    private setToCache;
     handleExecuteContextPrepare(executeContext: HandleExecuteContextType): Promise<void>;
     private getDictItemRows;
     handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void>;