midway-fatcms 0.0.16 → 0.0.17

package/src/service/base/bizmemcache/BizMemCacheStore.ts

@@ -0,0 +1,158 @@
+
+import { RedisService } from '@midwayjs/redis';
+import {
+  BizMemCacheKey,
+  BIZ_MEM_CACHE_REDIS_KEYS,
+  IBizMemCacheData,
+  ICrudMethodCacheObj,
+  IDataDictItemCacheObj,
+  ISysAnyApiCacheObj,
+  ISysAppCacheObj,
+  ISysAppPageCacheObj,
+  ISysConfgCacheObj,
+  ISysMenuCacheObj,
+  ISysProxyApiCacheObj,
+  IWorkbenchCachedObj,
+} from './BizMemCacheTypes';
+
+function createEmptyData(): IBizMemCacheData {
+  return {
+    workbenchCachedObj: null,
+    sysConfgCacheObj: null,
+    sysMenuCacheObj: null,
+    dataDictItemCacheObj: null,
+    sysAppCacheObj: null,
+    sysAppPageCacheObj: null,
+    sysAnyApiCacheObj: null,
+    sysProxyApiCacheObj: null,
+    crudMethodCacheObj: null,
+  };
+}
+
+function createEmptyLastTime(): Record<BizMemCacheKey, number> {
+  return {
+    workbenchCachedObj: 0,
+    sysConfgCacheObj: 0,
+    sysMenuCacheObj: 0,
+    dataDictItemCacheObj: 0,
+    sysAppCacheObj: 0,
+    sysAppPageCacheObj: 0,
+    sysAnyApiCacheObj: 0,
+    sysProxyApiCacheObj: 0,
+    crudMethodCacheObj: 0,
+  };
+}
+
+class BizMemCacheStoreInner {
+  private data: IBizMemCacheData = createEmptyData();
+  private lastTime: Record<BizMemCacheKey, number> = createEmptyLastTime();
+
+  getWorkbench(): IWorkbenchCachedObj | null {
+    return this.data.workbenchCachedObj;
+  }
+
+  setWorkbench(obj: IWorkbenchCachedObj): void {
+    this.data.workbenchCachedObj = obj;
+  }
+
+  getSysConfig(): ISysConfgCacheObj | null {
+    return this.data.sysConfgCacheObj;
+  }
+
+  setSysConfig(obj: ISysConfgCacheObj): void {
+    this.data.sysConfgCacheObj = obj;
+  }
+
+  getSysMenu(): ISysMenuCacheObj | null {
+    return this.data.sysMenuCacheObj;
+  }
+
+  setSysMenu(obj: ISysMenuCacheObj): void {
+    this.data.sysMenuCacheObj = obj;
+  }
+
+  getDataDictItem(): IDataDictItemCacheObj | null {
+    return this.data.dataDictItemCacheObj;
+  }
+
+  setDataDictItem(obj: IDataDictItemCacheObj): void {
+    this.data.dataDictItemCacheObj = obj;
+  }
+
+  getSysApp(): ISysAppCacheObj | null {
+    return this.data.sysAppCacheObj;
+  }
+
+  setSysApp(obj: ISysAppCacheObj): void {
+    this.data.sysAppCacheObj = obj;
+  }
+
+  getSysAppPage(): ISysAppPageCacheObj | null {
+    return this.data.sysAppPageCacheObj;
+  }
+
+  setSysAppPage(obj: ISysAppPageCacheObj): void {
+    this.data.sysAppPageCacheObj = obj;
+  }
+
+  getSysAnyApi(): ISysAnyApiCacheObj | null {
+    return this.data.sysAnyApiCacheObj;
+  }
+
+  setSysAnyApi(obj: ISysAnyApiCacheObj): void {
+    this.data.sysAnyApiCacheObj = obj;
+  }
+
+  getSysProxyApi(): ISysProxyApiCacheObj | null {
+    return this.data.sysProxyApiCacheObj;
+  }
+
+  setSysProxyApi(obj: ISysProxyApiCacheObj): void {
+    this.data.sysProxyApiCacheObj = obj;
+  }
+
+  getCrudMethod(): ICrudMethodCacheObj | null {
+    return this.data.crudMethodCacheObj;
+  }
+
+  setCrudMethod(obj: ICrudMethodCacheObj): void {
+    this.data.crudMethodCacheObj = obj;
+  }
+
+  getRedisKey(key: BizMemCacheKey): string {
+    return BIZ_MEM_CACHE_REDIS_KEYS[key];
+  }
+
+  getAllKeys(): BizMemCacheKey[] {
+    return Object.keys(BIZ_MEM_CACHE_REDIS_KEYS) as BizMemCacheKey[];
+  }
+
+  isKeyValid(key: string): key is BizMemCacheKey {
+    return Object.prototype.hasOwnProperty.call(BIZ_MEM_CACHE_REDIS_KEYS, key);
+  }
+
+  getLastTime(key: BizMemCacheKey): number {
+    return this.lastTime[key];
+  }
+
+  setLastTime(key: BizMemCacheKey, time: number): void {
+    this.lastTime[key] = time;
+  }
+
+  getLastTimeSnapshot(): Readonly<Record<BizMemCacheKey, number>> {
+    return { ...this.lastTime };
+  }
+
+  async markDirty(key: BizMemCacheKey, redis: RedisService): Promise<void> {
+    await redis.set(this.getRedisKey(key), Date.now());
+  }
+
+  async markAllDirty(redis: RedisService): Promise<void> {
+    const now = Date.now();
+    for (const key of this.getAllKeys()) {
+      await redis.set(this.getRedisKey(key), now);
+    }
+  }
+}
+
+export const bizMemCacheStore = new BizMemCacheStoreInner();

package/src/service/base/bizmemcache/BizMemCacheTypes.ts

@@ -0,0 +1,76 @@
+
+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 function buildSysAppPageCacheKey(workbench_code: string, page_path: string): string {
+  return `${workbench_code}#${page_path}`;
+}
+
+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 const 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',
+} as const;
+
+export type BizMemCacheKey = keyof typeof BIZ_MEM_CACHE_REDIS_KEYS;

package/src/service/base/cache-refresh/CacheRefreshHub.ts

@@ -4,32 +4,14 @@ import { CrudMonitor } from '@/libs/crud-pro/utils/CrudMonitor';
 
 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。
- */
 class CacheRefreshHubInner {
 
   private readonly refreshers = new Map<CacheRefreshCategory, CacheRefresher>();
 
-  /**
-   * 注册缓存刷新器
-   */
   register(category: CacheRefreshCategory, refresher: CacheRefresher): void {
     this.refreshers.set(category, refresher);
   }
 
-  /**
-   * 刷新指定类型的缓存（主动重加载）
-   * @param category 缓存类型，'*' 刷新全部
-   */
   async refresh(category: CacheRefreshCategory | '*', ctx: koa.IMidwayKoaContext): Promise<void> {
     const categories = category === '*' ? ALL_CACHE_REFRESH_CATEGORIES : [category];
     for (const cat of categories) {
@@ -45,13 +27,9 @@ class CacheRefreshHubInner {
     }
   }
 
-  /**
-   * 定时任务入口，刷新全部缓存
-   */
   async runBySchedule(ctx: koa.IMidwayKoaContext): Promise<void> {
     await this.refresh('*', ctx);
   }
 }
 
-/** 全局唯一实例 */
 export const CacheRefreshHub = new CacheRefreshHubInner();

package/src/service/base/cache-refresh/CacheRefreshHubScheduleService.ts

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

package/src/service/curd/CurdMixByDictService.ts

@@ -1,16 +1,11 @@
 import * as _ from 'lodash';
 import { Inject, Provide } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { CurdProService } from './CurdProService';
 import { HandleExecuteContextType, IExecuteContextHandler } from '@/libs/crud-pro/models/ExecuteContext';
 import { CrudMixUtils, RelatedType } from './CurdMixUtils';
-import { SystemTables } from '@/models/SystemTables';
-import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { MultiKeyMap } from '@/libs/crud-pro/utils/MultiKeyMap';
 import { ColumnRelation } from '@/libs/crud-pro/interfaces';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
-import { CacheNameEnum } from "@/models/bizmodels";
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore'
 
 const TMP_CTX_KEY = _.uniqueId('CurdMixByDictService');
 const dictMixUtils = new CrudMixUtils(RelatedType.dict);
@@ -21,22 +16,6 @@ export class CurdMixByDictService implements IExecuteContextHandler {
   @Inject()
   ctx: Context;
 
-  @Inject()
-  private curdProService: CurdProService;
-
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
-  private async getFromCache(code: string): Promise<any[]> {
-    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByDict);
-    return cacheService.getJsonObject(code);
-  }
-
-  private async setToCache(code: string, value: any[]): Promise<any> {
-    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByDict);
-    return cacheService.setJsonObject(code, value);
-  }
-
   async handleExecuteContextPrepare(executeContext: HandleExecuteContextType): Promise<void> {
     const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
     if (!codes || codes.length === 0) {
@@ -46,51 +25,21 @@ export class CurdMixByDictService implements IExecuteContextHandler {
     executeContext[TMP_CTX_KEY] = new MultiKeyMap(rows, 'dict_code', 'value');
   }
 
-  private async getDictItemRows(codes: string[]) {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    const noCacheCodes: string[] = [];
-
-    // 从缓存里面取
-    let cachedRows = [];
-    for (let i = 0; i < codes.length; i++) {
-      const code = codes[i];
-      const rows1: any[] = await this.getFromCache(code);
-      // const rows1 = [];
-      if (rows1 && rows1.length > 0) {
-        cachedRows = cachedRows.concat(rows1);
-      } else {
-        noCacheCodes.push(code);
-      }
-    }
 
-    // 从数据库里面取
+  private async getDictItemRows(codes: string[]) {
+    const dictCodeMap = bizMemCacheStore.getDataDictItem()?.dictCodeMap || {};
     let selectedRows = [];
-    if (noCacheCodes.length > 0) {
-      const res1 = await this.curdProService.executeCrudByCfg(
-        {
-          columns: ['dict_code', 'label', 'value', 'style', 'code'],
-          condition: { dict_code: { $in: noCacheCodes }, deleted_at: 0, status: 1 },
-        },
-        {
-          sqlTable: SystemTables.sys_data_dict_item,
-          sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
-          sqlDatabase: SystemDbName,
-          sqlDbType: SystemDbType,
-        }
-      );
-      selectedRows = res1.getResRows();
-
-      //放到缓存里
-      for (let i = 0; i < noCacheCodes.length; i++) {
-        const noCacheCode = noCacheCodes[i];
-        const rows1 = selectedRows.filter(e => e.dict_code === noCacheCode);
-        await this.setToCache(noCacheCode, rows1);
+    for (let index = 0; index < codes.length; index++) {
+      const dict_code = codes[index];
+      const itemRows = dictCodeMap[dict_code];
+      if(Array.isArray(itemRows)) {
+        selectedRows = selectedRows.concat(itemRows);
       }
     }
-
-    return cachedRows.concat(selectedRows);
+    return selectedRows;
   }
 
+
   async handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void> {
     const multiKeyMap = executeContext[TMP_CTX_KEY] as MultiKeyMap;
     if (!multiKeyMap || multiKeyMap.isEmpty()) {

package/src/service/curd/CurdMixBySysConfigService.ts

@@ -1,17 +1,12 @@
 import { Inject, Provide } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { CurdProService } from './CurdProService';
 import { HandleExecuteContextType, IExecuteContextHandler } from '@/libs/crud-pro/models/ExecuteContext';
 import { CrudMixUtils, RelatedType } from './CurdMixUtils';
 import * as _ from 'lodash';
-import { SystemTables } from '@/models/SystemTables';
-import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { MultiKeyMap } from '@/libs/crud-pro/utils/MultiKeyMap';
 import { ColumnRelation } from '@/libs/crud-pro/interfaces';
 import { parseConfigContentToEnumInfo } from '@/libs/utils/parseConfig';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
-import { CacheNameEnum } from "@/models/bizmodels";
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore'
 
 const dictMixUtils = new CrudMixUtils(RelatedType.sysCfgEnum);
 
@@ -23,62 +18,14 @@ export class CurdMixBySysConfigService implements IExecuteContextHandler {
   @Inject()
   ctx: Context;
 
-  @Inject()
-  protected curdProService: CurdProService;
-
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
-
-  private async getFromCache(code: string): Promise<any> {
-    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.GetSysConfigOne);
-    return cacheService.getJsonObject(code);
-  }
-
-  private async setToCache(code: string, value: any): Promise<any> {
-    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.GetSysConfigOne);
-    return cacheService.setJsonObject(code, value);
-  }
-
-
-  private async queryConfigRowsUseCache(codes: string[]): Promise<any[]> {
 
-    const resultRowMap = {} as Record<string, any>;
-    for (let i = 0; i < codes.length; i++) {
-      const code = codes[i];
-      const row = await this.getFromCache(code);
-      if (row) {
-        resultRowMap[code] = row;
-      }
-    }
-
-    const notCachedCodes = codes.filter((code) => !resultRowMap[code]);
-    if (notCachedCodes.length === 0) {
-      return Object.values(resultRowMap);
-    }
-
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    const res1 = await this.curdProService.executeCrudByCfg(
-      {
-        condition: { config_code: { $in: notCachedCodes }, deleted_at: 0, status: 1 },
-      },
-      {
-        sqlTable: SystemTables.sys_configs,
-        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
-        sqlDatabase: SystemDbName,
-        sqlDbType: SystemDbType,
-      }
-    );
-    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;
-        await this.setToCache(config_code, row);
-        resultRowMap[config_code] = row;
-      }
-    }
-    return Object.values(resultRowMap)
+  private queryConfigRowsUseCache(codes: string[]): any[] {
+    const codeSet = new Set(codes);
+    const sysConfigList = bizMemCacheStore.getSysConfig()?.sysConfigList || [];
+    return sysConfigList.filter((row) => {
+      const { config_code } = row;
+      return codeSet.has(config_code);
+    });
   }
 
   async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
@@ -88,7 +35,7 @@ export class CurdMixBySysConfigService implements IExecuteContextHandler {
     }
 
     const multiKeyMap = new MultiKeyMap();
-    const rows = await this.queryConfigRowsUseCache(codes);
+    const rows = this.queryConfigRowsUseCache(codes);
 
     for (let i = 0; i < rows.length; i++) {
       const row = rows[i];

package/src/service/curd/CurdMixByWorkbenchService.ts

@@ -4,13 +4,9 @@ import * as _ from 'lodash';
 import { CurdProService } from './CurdProService';
 import { HandleExecuteContextType, IExecuteContextHandler } from '@/libs/crud-pro/models/ExecuteContext';
 import { CrudMixUtils, RelatedType } from './CurdMixUtils';
-import { SystemTables } from '@/models/SystemTables';
-import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { ColumnRelation } from '@/libs/crud-pro/interfaces';
 import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
-import { CacheNameEnum } from "@/models/bizmodels";
+import { bizMemCacheStore } from '@/service/base/bizmemcache/BizMemCacheStore'
 
 const workbenchMixUtils = new CrudMixUtils(RelatedType.workbenchBasic);
 
@@ -25,33 +21,12 @@ export class CurdMixByWorkbenchService implements IExecuteContextHandler {
   @Inject()
   protected curdProService: CurdProService;
 
-  @Inject()
-  private cacheServiceFactory: CacheServiceFactory;
-
   private async loadWorkbenchListMap(): Promise<Map<string, any>> {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-    return await this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: CacheNameEnum.CurdMixByWorkbench,
-      cacheName: CacheNameEnum.CurdMixByWorkbench,
-      refreshCache: false,
-      getter: async (ctx) => {
-        const service: CurdMixByWorkbenchService = await ctx.requestContext.getAsync(CurdMixByWorkbenchService);
-        const reqJson = {
-          columns: 'workbench_code,workbench_name,workbench_domain',
-          condition: { deleted_at: 0, status: 1 },
-        };
-        const res = await service.curdProService.executeCrudByCfg(reqJson, {
-          sqlTable: SystemTables.sys_workbench,
-          sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
-          sqlDatabase: SystemDbName,
-          sqlDbType: SystemDbType,
-        });
-        const workbenchList = res.getResRows();
-        return MixinUtils.toNewMap(workbenchList, (obj: any) => obj.workbench_code);
-      },
-    });
+     const workbenchList = bizMemCacheStore.getWorkbench()?.workbenchList || [];
+     return MixinUtils.toNewMap(workbenchList, (obj: any) => obj.workbench_code);
   }
 
+
   async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
     const relations = workbenchMixUtils.pickColumnRelations(executeContext);
     if (!relations || relations.length === 0) {
@@ -61,12 +36,12 @@ export class CurdMixByWorkbenchService implements IExecuteContextHandler {
   }
 
   async handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void> {
-    const userInfoMap = executeContext[TMP_CTX_KEY] as Map<string, any>;
-    if (!userInfoMap || userInfoMap.size === 0) {
+    const workbenchInfoMap = executeContext[TMP_CTX_KEY] as Map<string, any>;
+    if (!workbenchInfoMap || workbenchInfoMap.size === 0) {
       return;
     }
     workbenchMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
-      workbenchMixUtils.copyColumnRelationToRowNoRelatedCode(row, userInfoMap, columnRelation);
+      workbenchMixUtils.copyColumnRelationToRowNoRelatedCode(row, workbenchInfoMap, columnRelation);
     });
   }
 }

package/src/service/curd/CurdProService.ts

@@ -21,7 +21,6 @@ import { ShardingBase, ShardingByTimeCrud, ShardingByHashCrud, ShardingByKeyCrud
 import { fixCfgModel } from './fixCfgModel';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 import { fixSoftDelete } from "@/libs/crud-pro-quick/fixSoftDelete";
-import { clearMethodCache } from '@/libs/crud-pro/services/CrudProCachedCfgService';
 
 /**
  * getQuickCrud 参数接口
@@ -433,11 +432,6 @@ export class CurdProService extends BaseService {
   }
 
 
-  public async loadMethodCache(ctx?: any): Promise<void> {
-    clearMethodCache();
-  }
-
-
   public async loadTableMetaCache(ctx?: any): Promise<void> {
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
     await this.getAllTableInfos({