midway-fatcms 0.0.9 → 0.0.11

package/dist/config/config.default.js

@@ -163,11 +163,9 @@ exports.default = (appInfo) => {
         fatcmsUserSessionKeepTimeSecond: 3600 * 24 * 30,
         // 是否启用内置的定时任务
         fatcmsScheduleService: {
-            proxyApiLoadService: 2 * 60 * 1000,
-            workbenchService: 60 * 1000,
+            cacheRefreshHubScheduleService: 10 * 60 * 1000,
             visitStatService: 10 * 60 * 1000,
-            asyncTaskRunnerService: 1000,
-            cacheServiceFactory: 2 * 60 * 1000, // 2分钟重新加载一次,
+            asyncTaskRunnerService: 1000, // 1s可以执行
         },
         // Excel导出文件的临时目录
         fatcmsExportExcelTmpFilePath: (0, path_1.join)((0, os_1.tmpdir)(), 'fatcms-export-excel'),

package/dist/configuration.d.ts

@@ -1,17 +1,23 @@
 import * as koa from '@midwayjs/koa';
+import { RedisService } from '@midwayjs/redis';
 export declare class ContainerLifeCycle {
     app: koa.Application;
+    redisService: RedisService;
     onConfigLoad(): Promise<any>;
     onReady(): Promise<void>;
     /**
-     * 初始化表元数据缓存的 Redis Pub/Sub 广播
+     * 初始化缓存刷新的 Redis Pub/Sub 广播
      *
      * - 发布客户端：复用已有的 RedisService 实例
      * - 订阅客户端：通过 duplicate() 创建独立连接
      *
-     * 集群部署时，任意节点调用 clearTableMetaCacheWithBroadcast()
-     * 会通过 Redis 广播通知所有节点清空本地缓存。
+     * 集群部署时，任意节点调用 refreshCacheWithBroadcast()
+     * 会通过 Redis 广播通知所有节点刷新缓存。
      */
-    private initTableMetaCacheRedis;
+    private initCacheRefreshRedis;
+    /**
+     * 注册各类型缓存的刷新器到 CacheRefreshHub
+     */
+    private registerCacheRefreshers;
     private startScheduleOnReady;
 }

package/dist/configuration.js

@@ -27,8 +27,14 @@ const global_middleware_1 = require("./middleware/global.middleware");
 const forbidden_middleware_1 = require("./middleware/forbidden.middleware");
 const schedule_1 = require("./schedule");
 const crypto_utils_1 = require("./libs/utils/crypto-utils");
-const TableMetaCacheRedisSubscriber_1 = require("./service/TableMetaCacheRedisSubscriber");
+const CacheRefreshRedisSubscriber_1 = require("./service/base/cache-refresh/CacheRefreshRedisSubscriber");
 const redis_1 = require("@midwayjs/redis");
+const CacheRefreshHub_1 = require("./service/base/cache-refresh/CacheRefreshHub");
+const CacheRefreshCategory_1 = require("./models/CacheRefreshCategory");
+const CacheServiceFactory_1 = require("./service/base/cache/CacheServiceFactory");
+const bizmodels_1 = require("./models/bizmodels");
+const ProxyApiLoadService_1 = require("./service/proxyapi/ProxyApiLoadService");
+const CurdProService_1 = require("./service/curd/CurdProService");
 let ContainerLifeCycle = class ContainerLifeCycle {
     async onConfigLoad() {
         const config = this.app.getConfig();
@@ -56,9 +62,13 @@ let ContainerLifeCycle = class ContainerLifeCycle {
          */
         schedule_1.ANONYMOUS_CONTEXT.setApp(this.app);
         /**
-         * 初始化表元数据缓存 Redis 广播
+         * 初始化缓存刷新 Redis 广播
          */
-        await this.initTableMetaCacheRedis();
+        await this.initCacheRefreshRedis();
+        /**
+         * 注册缓存刷新器到 CacheRefreshHub
+         */
+        this.registerCacheRefreshers();
         /**
          * 启动定时任务
          */
@@ -70,25 +80,56 @@ let ContainerLifeCycle = class ContainerLifeCycle {
         // this.app.useFilter([NotFoundFilter, DefaultErrorFilter]);
     }
     /**
-     * 初始化表元数据缓存的 Redis Pub/Sub 广播
+     * 初始化缓存刷新的 Redis Pub/Sub 广播
      *
      * - 发布客户端：复用已有的 RedisService 实例
      * - 订阅客户端：通过 duplicate() 创建独立连接
      *
-     * 集群部署时，任意节点调用 clearTableMetaCacheWithBroadcast()
-     * 会通过 Redis 广播通知所有节点清空本地缓存。
+     * 集群部署时，任意节点调用 refreshCacheWithBroadcast()
+     * 会通过 Redis 广播通知所有节点刷新缓存。
      */
-    async initTableMetaCacheRedis() {
+    async initCacheRefreshRedis() {
         try {
-            const redisService = await this.app.getApplicationContext().getAsync(redis_1.RedisService);
-            (0, TableMetaCacheRedisSubscriber_1.initTableMetaCachePublishClient)(redisService);
-            (0, TableMetaCacheRedisSubscriber_1.initTableMetaCacheSubscriber)(redisService);
+            (0, CacheRefreshRedisSubscriber_1.initCacheRefreshPublishClient)(this.redisService);
+            (0, CacheRefreshRedisSubscriber_1.initCacheRefreshSubscriber)(this.redisService);
         }
         catch (e) {
-            // Redis 未配置或不可用时，降级为单节点模式（仅清空本地缓存）
-            this.app.getLogger().warn('ContainerLifeCycle ==> initTableMetaCacheRedis Redis不可用，降级为单节点模式:', e.message);
+            // Redis 未配置或不可用时，降级为单节点模式（仅刷新本节点缓存）
+            this.app.getLogger().warn('ContainerLifeCycle ==> initCacheRefreshRedis Redis不可用，降级为单节点模式:', e.message);
         }
     }
+    /**
+     * 注册各类型缓存的刷新器到 CacheRefreshHub
+     */
+    registerCacheRefreshers() {
+        // CrudMethodConfig: 清空 CRUD 方法配置缓存（清空后下次请求时懒加载）
+        CacheRefreshHub_1.CacheRefreshHub.register(CacheRefreshCategory_1.CacheRefreshCategory.CrudMethodConfig, async (ctx) => {
+            // clearMethodCache();
+            const cacheServiceFactory = await ctx.requestContext.getAsync(CurdProService_1.CurdProService);
+            await cacheServiceFactory.loadMethodCache(ctx);
+        });
+        // TableMeta: 清空表元数据缓存（清空后下次请求时懒加载）
+        CacheRefreshHub_1.CacheRefreshHub.register(CacheRefreshCategory_1.CacheRefreshCategory.TableMeta, async (ctx) => {
+            // clearTableMetaCache();
+            const cacheServiceFactory = await ctx.requestContext.getAsync(CurdProService_1.CurdProService);
+            await cacheServiceFactory.loadTableMetaCache(ctx);
+        });
+        // CacheService: 主动重加载所有 CacheServiceFactory 管理的业务缓存
+        CacheRefreshHub_1.CacheRefreshHub.register(CacheRefreshCategory_1.CacheRefreshCategory.CacheService, async (ctx) => {
+            const cacheServiceFactory = await ctx.requestContext.getAsync(CacheServiceFactory_1.CacheServiceFactory);
+            await cacheServiceFactory.refreshAllCache(ctx);
+        });
+        // LinkToCustom: 刷新 linkToCustom 关联枚举缓存
+        CacheRefreshHub_1.CacheRefreshHub.register(CacheRefreshCategory_1.CacheRefreshCategory.LinkToCustom, async (ctx) => {
+            const cacheServiceFactory = await ctx.requestContext.getAsync(CacheServiceFactory_1.CacheServiceFactory);
+            await cacheServiceFactory.refreshByCacheName(bizmodels_1.CacheNameEnum.CurdMixByLinkToCustom, ctx);
+        });
+        // ProxyApiRoute: 重建代理API路由树（复用 ProxyApiLoadService.runBySchedule 的逻辑）
+        CacheRefreshHub_1.CacheRefreshHub.register(CacheRefreshCategory_1.CacheRefreshCategory.ProxyApiRoute, async (ctx) => {
+            const proxyApiLoadService = await ctx.requestContext.getAsync(ProxyApiLoadService_1.ProxyApiLoadService);
+            await proxyApiLoadService.refreshRouteTrie();
+        });
+    }
     async startScheduleOnReady() {
         const logger = this.app.getLogger();
         const config = this.app.getConfig();
@@ -118,6 +159,10 @@ __decorate([
     (0, core_1.App)(),
     __metadata("design:type", Object)
 ], ContainerLifeCycle.prototype, "app", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", redis_1.RedisService)
+], ContainerLifeCycle.prototype, "redisService", void 0);
 ContainerLifeCycle = __decorate([
     (0, core_1.Configuration)({
         // namespace: 'fatcms',

package/dist/controller/base/BaseApiController.d.ts

@@ -1,9 +1,10 @@
 import { Context } from '@midwayjs/koa';
 import { CurdMixService } from '../../service/curd/CurdMixService';
-import { IFuncCfgModel, IValidatorCfgItem } from '../../libs/crud-pro/interfaces';
+import { ColumnRelation, IFuncCfgModel, IValidatorCfgItem } from '../../libs/crud-pro/interfaces';
 import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
 import { UserAccountService } from '../../service/UserAccountService';
 import { BaseService } from '../../service/base/BaseService';
+import { ConfigChangelogService } from '../../service/ConfigChangelogService';
 export interface IExecuteSimpleSqlParams {
     updateCfg?: Record<string, IFuncCfgModel>;
     allowCfg?: Record<string, string[]>;
@@ -11,6 +12,7 @@ export interface IExecuteSimpleSqlParams {
     validateCfg?: Record<string, IValidatorCfgItem[]>;
     enableSoftDelete?: boolean;
     columns?: string | string[];
+    columnsRelation?: ColumnRelation[];
 }
 export interface ISecretBodyAnno {
     payload1: string;
@@ -26,6 +28,7 @@ export declare class BaseApiController extends BaseService {
     protected ctx: Context;
     protected curdMixService: CurdMixService;
     protected userAccountService: UserAccountService;
+    protected configChangelogService: ConfigChangelogService;
     /**
      * 检查用户是否在指定时间内重复执行了某个操作
      * @param actionCode 操作编码
@@ -42,6 +45,22 @@ export declare class BaseApiController extends BaseService {
      * @protected
      */
     protected executeSysSimpleSQL(sqlTable: string, sqlSimpleName: KeysOfSimpleSQL, extParams?: IExecuteSimpleSqlParams): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    /**
+     * 判断是否为写操作
+     */
+    private isShouldLogAction;
+    /**
+     * 查询当前记录用于日志快照
+     */
+    private queryCurrentRecordForLog;
+    /**
+     * 异步记录变更日志（不阻塞主流程）
+     */
+    private recordChangelogAsync;
+    /**
+     * 计算两个快照之间变更的字段名列表
+     */
+    private computeChangedFields;
     private addAccountBasicInfoCfgModel;
     private addWorkbenchBasicInfoCfgModel;
     protected decodeBodyBySession<T>(body: any): Promise<any>;

package/dist/controller/base/BaseApiController.js

@@ -23,6 +23,7 @@ const RedisKeys_1 = require("../../models/RedisKeys");
 const aes_128_cbc_1 = require("aes-128-cbc");
 const md5 = require("md5");
 const AsymmetricCrypto_1 = require("../../libs/utils/AsymmetricCrypto");
+const ConfigChangelogService_1 = require("../../service/ConfigChangelogService");
 let BaseApiController = class BaseApiController extends BaseService_1.BaseService {
     /**
      * 检查用户是否在指定时间内重复执行了某个操作
@@ -64,6 +65,7 @@ let BaseApiController = class BaseApiController extends BaseService_1.BaseServic
      * @protected
      */
     async executeSysSimpleSQL(sqlTable, sqlSimpleName, extParams) {
+        var _a, _b, _c, _d;
         const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const body = this.ctx.request.body;
         const req = this.ctx.req;
@@ -83,11 +85,131 @@ let BaseApiController = class BaseApiController extends BaseService_1.BaseServic
         this.addAccountBasicInfoCfgModel(cfgModel);
         //自动关联工作台基本信息
         this.addWorkbenchBasicInfoCfgModel(cfgModel);
-        //sys系统表都是标准的，都有modified_at字段。
+        //sys系统表都是标准的，都有modified_at、modified_by字段。
         if (sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE && body.data) {
             body.data['modified_at'] = moment(Date.now()).format('YYYY-MM-DD HH:mm:ss.SSS');
+            body.data['modified_by'] = ((_a = this.getUserSessionInfo()) === null || _a === void 0 ? void 0 : _a.accountId) || 'anonymous';
         }
-        return await this.curdMixService.executeCrudByCfg(body, cfgModel);
+        //sys系统表都是标准的，都有created_at、created_by字段。
+        if (sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT && body.data) {
+            body.data['created_at'] = moment(Date.now()).format('YYYY-MM-DD HH:mm:ss.SSS');
+            body.data['created_by'] = ((_b = this.getUserSessionInfo()) === null || _b === void 0 ? void 0 : _b.accountId) || 'anonymous';
+        }
+        // ========== 配置变更日志自动记录 ==========
+        let beforeData = null;
+        let recordId = '';
+        const shouldLog = (0, ConfigChangelogService_1.isChangelogTable)(sqlTable) && this.isShouldLogAction(sqlSimpleName);
+        if (shouldLog) {
+            // UPDATE/DELETE 需要condition.id来定位变更记录
+            if (!((_c = body === null || body === void 0 ? void 0 : body.condition) === null || _c === void 0 ? void 0 : _c.id)) {
+                throw new exceptions_1.CommonException(`配置变更日志要求condition.id必传，当前操作: ${sqlSimpleName}，表: ${sqlTable}`);
+            }
+            // UPDATE/DELETE 前查询当前记录作为 before_data
+            try {
+                beforeData = await this.queryCurrentRecordForLog(sqlTable, body);
+                recordId = String((beforeData === null || beforeData === void 0 ? void 0 : beforeData.id) || ((_d = body === null || body === void 0 ? void 0 : body.condition) === null || _d === void 0 ? void 0 : _d.id) || '');
+            }
+            catch (e) {
+                this.logWarn('executeSysSimpleSQL: 查询beforeData失败，跳过日志记录', e);
+            }
+        }
+        // 执行原操作
+        const result = await this.curdMixService.executeCrudByCfg(body, cfgModel);
+        if (shouldLog) {
+            await this.recordChangelogAsync(sqlTable, sqlSimpleName, body, beforeData, recordId, req).catch(e => {
+                this.logError('executeSysSimpleSQL: 异步记录变更日志失败', e);
+            });
+        }
+        return result;
+    }
+    /**
+     * 判断是否为写操作
+     */
+    isShouldLogAction(sqlSimpleName) {
+        return [
+            keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+            keys_1.KeysOfSimpleSQL.SIMPLE_DELETE,
+        ].includes(sqlSimpleName);
+    }
+    /**
+     * 查询当前记录用于日志快照
+     */
+    async queryCurrentRecordForLog(sqlTable, body) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const condition = body.condition || {};
+        if (!condition.id) {
+            return null;
+        }
+        const result = await this.curdMixService.executeCrudByCfg({ condition: { id: condition.id } }, {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        return result.getOneObj() || null;
+    }
+    /**
+     * 异步记录变更日志（不阻塞主流程）
+     */
+    async recordChangelogAsync(sqlTable, sqlSimpleName, body, beforeData, recordId, req) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        let afterData = null;
+        let changedFields;
+        if (sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE) {
+            // UPDATE: 查询更新后的记录
+            const condition = body.condition || {};
+            try {
+                const result = await this.curdMixService.executeCrudByCfg({ condition: { id: condition.id } }, {
+                    sqlTable,
+                    sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+                    sqlDatabase: SystemDbName,
+                    sqlDbType: SystemDbType,
+                });
+                afterData = result.getOneObj() || null;
+            }
+            catch (_) {
+                // 查询失败时忽略
+            }
+            // 计算变更字段
+            if (beforeData && afterData) {
+                changedFields = this.computeChangedFields(beforeData, afterData);
+            }
+        }
+        // DELETE: afterData 为 null
+        const actionMap = {
+            [keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE]: 'UPDATE',
+            [keys_1.KeysOfSimpleSQL.SIMPLE_DELETE]: 'DELETE',
+        };
+        await this.configChangelogService.recordChange({
+            tableName: sqlTable,
+            action: actionMap[sqlSimpleName],
+            recordId,
+            beforeData,
+            afterData,
+            changedFields,
+            requestPath: `${req.method}:${req.url}`,
+        });
+    }
+    /**
+     * 计算两个快照之间变更的字段名列表
+     */
+    computeChangedFields(before, after) {
+        const allKeys = new Set([...Object.keys(before), ...Object.keys(after)]);
+        //modified_at\modified_by\created_at\created_by 字段不参与比较
+        allKeys.delete('modified_at');
+        allKeys.delete('modified_by');
+        allKeys.delete('created_at');
+        allKeys.delete('created_by');
+        const changed = [];
+        for (const key of allKeys) {
+            const beforeVal = before[key];
+            const afterVal = after[key];
+            // 简单比较优先，不等时再用JSON.stringify处理对象差异
+            if (beforeVal !== afterVal && JSON.stringify(beforeVal) !== JSON.stringify(afterVal)) {
+                changed.push(key);
+            }
+        }
+        return changed;
     }
     addAccountBasicInfoCfgModel(cfgModel) {
         let columnsRelation = cfgModel.columnsRelation;
@@ -188,6 +310,10 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", UserAccountService_1.UserAccountService)
 ], BaseApiController.prototype, "userAccountService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", ConfigChangelogService_1.ConfigChangelogService)
+], BaseApiController.prototype, "configChangelogService", void 0);
 BaseApiController = __decorate([
     (0, core_1.Controller)('/api/BaseApiController')
 ], BaseApiController);

package/dist/controller/gateway/AsyncTaskController.d.ts

@@ -6,6 +6,7 @@ import { BaseApiController } from '../base/BaseApiController';
 export declare class AsyncTaskController extends BaseApiController {
     protected ctx: Context;
     private asyncTaskService;
+    private crudStdService;
     getMyTasks(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
     createTask(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
     cancelTask(id: number): Promise<{

package/dist/controller/gateway/AsyncTaskController.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncTaskController = void 0;
 const fs = require("fs");
 const fs2 = require("node:fs/promises");
+const md5 = require("md5");
 const core_1 = require("@midwayjs/core");
 const BaseApiController_1 = require("../base/BaseApiController");
 const AsyncTaskService_1 = require("../../service/asyncTask/AsyncTaskService");
@@ -24,6 +25,8 @@ const SystemTables_1 = require("../../models/SystemTables");
 const exceptions_1 = require("../../libs/crud-pro/exceptions");
 const permission_middleware_1 = require("../../middleware/permission.middleware");
 const functions_1 = require("../../libs/utils/functions");
+const CrudStdService_1 = require("../../service/crudstd/CrudStdService");
+const devops_1 = require("../../models/devops");
 function fixMyTasksCondition(body, ctx) {
     if (!body.condition) {
         throw new exceptions_1.CommonException('参数不正确');
@@ -43,6 +46,27 @@ function fixCancelBodyData(body, id) {
     dataObj.task_status = AsyncTaskModel_1.SysAsyncTaskStatus.CANCELLED;
     body.data = dataObj;
 }
+/**
+ * 验证 STD_CRUD 类型的异步任务权限
+ * 根据 settingKey 配置的权限项进行鉴权
+ */
+async function validateStdCrudTaskPermission(crudStdService, inputParams) {
+    var _a;
+    if (inputParams.appType !== 'STD_CRUD' || !inputParams.settingKey) {
+        return; // 非 STD_CRUD 类型或无 settingKey，无需鉴权
+    }
+    const stdAction = {
+        appCode: inputParams.appCode,
+        settingKey: inputParams.settingKey,
+    };
+    const appInfo = await crudStdService.getParsedCrudStdAppForSettingKey(stdAction);
+    if (!appInfo || appInfo.status !== 1) {
+        throw new devops_1.BizException('应用不存在或已下线：' + inputParams.appCode);
+    }
+    if (!((_a = appInfo.settingKeyActionCfg) === null || _a === void 0 ? void 0 : _a.hasOperationPerm)) {
+        throw new devops_1.BizException('没有操作权限：settingKey=' + inputParams.settingKey);
+    }
+}
 function fixCreateBodyData(body, ctx) {
     if (!body.data) {
         throw new exceptions_1.CommonException('参数不正确');
@@ -57,6 +81,11 @@ function fixCreateBodyData(body, ctx) {
         host: headers.host,
         origin: headers.origin,
     };
+    dataObj.task_uuid = md5(JSON.stringify({
+        input_params: input_params,
+        created_by: sessionInfo.accountId,
+        created_time: Date.now(),
+    }));
     dataObj.task_status = AsyncTaskModel_1.SysAsyncTaskStatus.PENDING;
     dataObj.created_by = sessionInfo.accountId;
     dataObj.created_user_session = JSON.stringify(sessionInfo); // 创建人的session信息。用于执行时的鉴权。
@@ -73,9 +102,14 @@ let AsyncTaskController = class AsyncTaskController extends BaseApiController_1.
     }
     // 创建任务
     async createTask() {
-        //每个用户：5秒内只能创建1次任务
+        var _a;
+        // 每个用户：5秒内只能创建1次任务
         await this.checkUserActionTimeLimit('AsyncTaskController_createTask', 5);
-        fixCreateBodyData(this.ctx.request.body, this.ctx);
+        // 解析 input_params 并进行权限鉴权
+        const body = this.ctx.request.body;
+        const inputParams = (0, functions_1.parseJsonObject)((_a = body.data) === null || _a === void 0 ? void 0 : _a.input_params) || {};
+        await validateStdCrudTaskPermission(this.crudStdService, inputParams);
+        fixCreateBodyData(body, this.ctx);
         const res = await this.executeSysSimpleSQL(SystemTables_1.SystemTables.sys_async_tasks, keys_1.KeysOfSimpleSQL.SIMPLE_INSERT);
         await this.asyncTaskService.startTask();
         return res;
@@ -148,6 +182,10 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", AsyncTaskService_1.AsyncTaskService)
 ], AsyncTaskController.prototype, "asyncTaskService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CrudStdService_1.CrudStdService)
+], AsyncTaskController.prototype, "crudStdService", void 0);
 __decorate([
     (0, core_1.Post)('/getMyTasks'),
     __metadata("design:type", Function),

package/dist/controller/helpers.controller.d.ts

@@ -33,10 +33,11 @@ export declare class HelpersApi {
      */
     cryptoAes128CBC(queryData: any): Promise<CommonResult>;
     /**
-     * 工具函数: 清空表元数据缓存（集群广播）
-     * 清空本节点缓存，并通过 Redis Pub/Sub 广播通知集群中其他节点。
-     * 清空后，下次请求会自动从数据库重新加载（懒加载刷新）。
+     * 工具函数: 刷新缓存（集群广播）
+     * 通过 CacheRefreshHub 在 ANONYMOUS_CONTEXT 中主动重加载缓存，并通过 Redis Pub/Sub 广播通知集群中其他节点。
+     * 可通过 category 参数指定刷新的缓存类型（CacheRefreshCategory），不传则刷新全部。
+     * 可通过 cacheName 参数指定刷新的业务缓存（CacheNameEnum）。
      */
-    clearTableMetaCacheApi(): Promise<CommonResult>;
+    refreshCacheApi(queryData: any): Promise<CommonResult>;
     private checkLocalPermissionEnv;
 }

package/dist/controller/helpers.controller.js

@@ -21,7 +21,9 @@ const functions_1 = require("../libs/utils/functions");
 const crypto_utils_1 = require("../libs/utils/crypto-utils");
 const common_dto_1 = require("../libs/utils/common-dto");
 const SystemPerm_1 = require("../models/SystemPerm");
-const TableMetaCacheRedisSubscriber_1 = require("../service/TableMetaCacheRedisSubscriber");
+const permission_middleware_1 = require("../middleware/permission.middleware");
+const CacheRefreshRedisSubscriber_1 = require("../service/base/cache-refresh/CacheRefreshRedisSubscriber");
+const CacheServiceFactory_1 = require("../service/base/cache/CacheServiceFactory");
 // http://127.0.0.1:7002/ns/api/helpers/getApiScript?prefix=/ns/api/manage
 // http://127.0.0.1:7002/ns/api/helpers/getApiScript
 // http://127.0.0.1:7002/ns/api/helpers/getApiEnv
@@ -126,27 +128,42 @@ let HelpersApi = class HelpersApi {
         });
     }
     /**
-     * 工具函数: 清空表元数据缓存（集群广播）
-     * 清空本节点缓存，并通过 Redis Pub/Sub 广播通知集群中其他节点。
-     * 清空后，下次请求会自动从数据库重新加载（懒加载刷新）。
+     * 工具函数: 刷新缓存（集群广播）
+     * 通过 CacheRefreshHub 在 ANONYMOUS_CONTEXT 中主动重加载缓存，并通过 Redis Pub/Sub 广播通知集群中其他节点。
+     * 可通过 category 参数指定刷新的缓存类型（CacheRefreshCategory），不传则刷新全部。
+     * 可通过 cacheName 参数指定刷新的业务缓存（CacheNameEnum）。
      */
-    async clearTableMetaCacheApi() {
-        const stats = (0, TableMetaCacheRedisSubscriber_1.clearTableMetaCacheWithBroadcast)();
+    async refreshCacheApi(queryData) {
+        const categoryParam = queryData.category;
+        const cacheNameParam = queryData.cacheName;
+        if (cacheNameParam) {
+            // 按 CacheNameEnum 单独刷新业务缓存
+            const cacheName = cacheNameParam;
+            const cacheServiceFactory = await this.ctx.requestContext.getAsync(CacheServiceFactory_1.CacheServiceFactory);
+            await cacheServiceFactory.refreshByCacheName(cacheName, this.ctx);
+            return common_dto_1.CommonResult.successRes({
+                message: `业务缓存 ${cacheName} 已刷新`,
+                cacheName,
+            });
+        }
+        const category = categoryParam ? categoryParam : undefined;
+        await (0, CacheRefreshRedisSubscriber_1.refreshCacheWithBroadcast)(this.ctx, category);
         return common_dto_1.CommonResult.successRes({
-            message: '表元数据缓存已清空（已广播集群）',
-            beforeClear: stats,
+            message: `缓存已刷新${category ? '(' + category + ')' : '(全部)'}（已广播集群）`,
+            category: category || 'ALL',
         });
     }
     checkLocalPermissionEnv() {
         //是否是开发者
         const isDevelopUser = () => {
-            var _a, _b;
+            var _a, _b, _c;
             const isDevOpsWriter = (_a = this.ctx.userSession) === null || _a === void 0 ? void 0 : _a.hasRole(SystemPerm_1.SystemRoleCode.DevOpsWriter);
             const isSuperAdmin = (_b = this.ctx.userSession) === null || _b === void 0 ? void 0 : _b.hasRole(SystemPerm_1.SystemRoleCode.SuperAdmin);
-            if (isSuperAdmin) {
+            const isHelpersTools = (_c = this.ctx.userSession) === null || _c === void 0 ? void 0 : _c.hasPermission(SystemPerm_1.SystemFuncCode.HelpersTools);
+            if (isSuperAdmin || isHelpersTools || isDevOpsWriter) {
                 return true;
             }
-            return isDevOpsWriter;
+            return false;
         };
         // 运行在本地
         const isLocalEnv = () => {
@@ -155,7 +172,7 @@ let HelpersApi = class HelpersApi {
             return env === 'local' && (host.startsWith('127.0.0.1') || host.startsWith('localhost:') || host === 'localhost');
         };
         if (!isLocalEnv() && !isDevelopUser()) {
-            throw new exceptions_1.CommonException(exceptions_1.Exceptions.NO_AUTH, '此测试函数，仅只有本地环境可以调用');
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.NO_AUTH, '此测试函数，仅限本地环境或开发者调用');
         }
     }
 };
@@ -195,11 +212,12 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], HelpersApi.prototype, "cryptoAes128CBC", null);
 __decorate([
-    (0, core_1.Get)('/clearTableMetaCache'),
+    (0, core_1.Get)('/refreshCache', { middleware: [(0, permission_middleware_1.checkPermission)(SystemPerm_1.SystemFuncCode.HelpersCacheRefresh)] }),
+    __param(0, (0, core_1.Query)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], HelpersApi.prototype, "clearTableMetaCacheApi", null);
+], HelpersApi.prototype, "refreshCacheApi", null);
 HelpersApi = __decorate([
     (0, core_1.Controller)('/ns/api/helpers')
 ], HelpersApi);

package/dist/controller/home.controller.d.ts

@@ -1,9 +1,12 @@
 import { Context } from '@midwayjs/koa';
 import { BaseApiController } from './base/BaseApiController';
 import { WorkbenchService } from '../service/WorkbenchService';
+import { ISessionInfo } from '../models/userSession';
 export declare class HomeController extends BaseApiController {
     protected ctx: Context;
     protected workbenchService: WorkbenchService;
+    private authService;
     home(): Promise<string>;
+    protected getUserAndRefreshSessionInfo(): Promise<ISessionInfo>;
     robots(): Promise<string>;
 }

package/dist/controller/home.controller.js

@@ -15,6 +15,7 @@ const BaseApiController_1 = require("./base/BaseApiController");
 const WorkbenchService_1 = require("../service/WorkbenchService");
 const render_utils_1 = require("../libs/utils/render-utils");
 const crypto_utils_1 = require("../libs/utils/crypto-utils");
+const AuthService_1 = require("../service/AuthService");
 let HomeController = class HomeController extends BaseApiController_1.BaseApiController {
     async home() {
         const host = this.ctx.request.host;
@@ -30,7 +31,7 @@ let HomeController = class HomeController extends BaseApiController_1.BaseApiCon
             return this.ctx.render('404_workbench', infos);
         }
         const html_content = workbenchInfo.html_content || '未配置HTML模版';
-        const userInfo = this.getUserSessionInfo();
+        const userInfo = await this.getUserAndRefreshSessionInfo();
         // 形如(不带域名)：/ns/app/abc-app-path?aa=2332
         const urlcsrftoken = await crypto_utils_1.privateAES.time_encrypt_utf8_base64(JSON.stringify({
             url: this.ctx.req.url,
@@ -48,6 +49,13 @@ let HomeController = class HomeController extends BaseApiController_1.BaseApiCon
         const query = this.ctx.query || {};
         return this.ctx.renderString(html_content, { workbenchInfo, userInfo, utils, query }, { viewEngine: 'ejs' });
     }
+    async getUserAndRefreshSessionInfo() {
+        const userSessionInfo = await this.getUserSessionInfo();
+        if (!userSessionInfo) {
+            return null;
+        }
+        return await this.authService.refreshSession(userSessionInfo);
+    }
     async robots() {
         return `User-agent: * \nDisallow: /ns/api/manage/`;
     }
@@ -60,6 +68,10 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", WorkbenchService_1.WorkbenchService)
 ], HomeController.prototype, "workbenchService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", AuthService_1.AuthService)
+], HomeController.prototype, "authService", void 0);
 __decorate([
     (0, core_1.Get)('/*'),
     __metadata("design:type", Function),

package/dist/controller/manage/AccountRoleManageApi.d.ts

@@ -0,0 +1,10 @@
+import { Context } from '@midwayjs/koa';
+import { BaseApiController } from '../base/BaseApiController';
+export declare class AccountRoleManageApi extends BaseApiController {
+    protected ctx: Context;
+    getAccountRoleList(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    getAccountRoleOne(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    createAccountRole(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    updateAccountRole(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    deleteAccountRole(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+}