midway-fatcms 0.0.1-beta.64 → 0.0.1-beta.66

package/dist/libs/utils/AsymmetricCrypto.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsymmetricCrypto = void 0;
+function getCrypto() {
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+        // 浏览器环境或Node.js 19+的global.crypto
+        return crypto;
+    }
+    else if (typeof global !== 'undefined') {
+        // Node.js环境
+        if (global.crypto && global.crypto.subtle) {
+            // Node.js 19+
+            return global.crypto;
+        }
+        // @ts-ignore
+        else if (global.crypto && global.crypto.webcrypto && global.crypto.webcrypto.subtle) {
+            // Node.js 16+
+            // @ts-ignore
+            return global.crypto.webcrypto;
+        }
+        else {
+            // Node.js 16-18，使用crypto.webcrypto
+            const nodeCrypto = require('crypto');
+            if (nodeCrypto.webcrypto && nodeCrypto.webcrypto.subtle) {
+                return nodeCrypto.webcrypto;
+            }
+            throw new Error('Node.js版本低于16或缺少webcrypto支持');
+        }
+    }
+    throw new Error('当前环境不支持Web Crypto API');
+}
+class AsymmetricCrypto {
+    /**
+     * 生成RSA密钥对并返回字符串格式的公钥和私钥
+     * @param {number} modulusLength - 密钥长度，默认2048
+     * @returns {Promise<{publicKey: string, privateKey: string}>} PEM格式的密钥字符串
+     */
+    static async generateKeyPair(modulusLength = 2048) {
+        const crypto = getCrypto();
+        try {
+            // 生成密钥对
+            const keyPair = await crypto.subtle.generateKey({
+                name: "RSA-OAEP",
+                modulusLength,
+                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                hash: "SHA-256",
+            }, true, // 是否可导出
+            ["encrypt", "decrypt"]);
+            // 导出公钥为PEM格式字符串
+            const publicKeyDer = await crypto.subtle.exportKey("spki", keyPair.publicKey);
+            const publicKeyPem = this.derToPem(publicKeyDer, 'PUBLIC');
+            // 导出私钥为PEM格式字符串
+            const privateKeyDer = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
+            const privateKeyPem = this.derToPem(privateKeyDer, 'PRIVATE');
+            return {
+                publicKey: publicKeyPem,
+                privateKey: privateKeyPem
+            };
+        }
+        catch (error) {
+            throw new Error(`生成密钥对失败: ${error.message}`);
+        }
+    }
+    /**
+     * 使用公钥加密字符串
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @param {string} data - 要加密的字符串数据
+     * @returns {Promise<string>} Base64编码的加密字符串
+     */
+    static async encrypt(publicKeyPem, data) {
+        const crypto = getCrypto();
+        try {
+            // 导入公钥
+            const publicKey = await this.importPublicKey(publicKeyPem);
+            // 转换数据为Uint8Array
+            const encoder = new TextEncoder();
+            const dataBuffer = encoder.encode(data);
+            // 检查数据长度（RSA-OAEP有最大长度限制）
+            const maxLength = this.getMaxEncryptLength(publicKeyPem);
+            if (dataBuffer.length > maxLength) {
+                throw new Error(`数据过长，最大支持${maxLength}字节，当前${dataBuffer.length}字节`);
+            }
+            // 加密数据
+            const encrypted = await crypto.subtle.encrypt({
+                name: "RSA-OAEP"
+            }, publicKey, dataBuffer);
+            // 转换为Base64字符串
+            return this.arrayBufferToBase64(encrypted);
+        }
+        catch (error) {
+            throw new Error(`加密失败: ${error.message}`);
+        }
+    }
+    /**
+     * 使用私钥解密字符串
+     * @param {string} privateKeyPem - PEM格式的私钥字符串
+     * @param {string} encryptedData - Base64编码的加密字符串
+     * @returns {Promise<string>} 解密后的原始字符串
+     */
+    static async decrypt(privateKeyPem, encryptedData) {
+        const crypto = getCrypto();
+        try {
+            // 导入私钥
+            const privateKey = await this.importPrivateKey(privateKeyPem);
+            // 转换Base64字符串为ArrayBuffer
+            const encryptedBuffer = this.base64ToArrayBuffer(encryptedData);
+            // 解密数据
+            const decrypted = await crypto.subtle.decrypt({
+                name: "RSA-OAEP"
+            }, privateKey, encryptedBuffer);
+            // 转换回字符串
+            const decoder = new TextDecoder();
+            return decoder.decode(decrypted);
+        }
+        catch (error) {
+            throw new Error(`解密失败: ${error.message}`);
+        }
+    }
+    /**
+     * 导入PEM格式的公钥字符串为CryptoKey对象
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @returns {Promise<CryptoKey>}
+     */
+    static async importPublicKey(publicKeyPem) {
+        const crypto = getCrypto();
+        try {
+            // PEM转DER
+            const der = this.pemToDer(publicKeyPem);
+            // 导入密钥
+            return await crypto.subtle.importKey("spki", der, {
+                name: "RSA-OAEP",
+                hash: "SHA-256"
+            }, true, ["encrypt"]);
+        }
+        catch (error) {
+            throw new Error(`导入公钥失败: ${error.message}`);
+        }
+    }
+    /**
+     * 导入PEM格式的私钥字符串为CryptoKey对象
+     * @param {string} privateKeyPem - PEM格式的私钥字符串
+     * @returns {Promise<CryptoKey>}
+     */
+    static async importPrivateKey(privateKeyPem) {
+        const crypto = getCrypto();
+        try {
+            // PEM转DER
+            const der = this.pemToDer(privateKeyPem);
+            // 导入密钥
+            return await crypto.subtle.importKey("pkcs8", der, {
+                name: "RSA-OAEP",
+                hash: "SHA-256"
+            }, true, ["decrypt"]);
+        }
+        catch (error) {
+            throw new Error(`导入私钥失败: ${error.message}`);
+        }
+    }
+    /**
+     * 获取公钥支持的最大加密长度（字节数）
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @returns {number} 最大加密字节数
+     */
+    static getMaxEncryptLength(publicKeyPem) {
+        // 简单估算最大加密长度
+        // RSA-OAEP最大加密长度 = modulusLength/8 - 2*hashLength/8 - 2
+        // 这里通过PEM字符串长度来估算密钥长度
+        // 提取Base64内容
+        const base64Data = publicKeyPem
+            .replace(/-----BEGIN PUBLIC KEY-----/, '')
+            .replace(/-----END PUBLIC KEY-----/, '')
+            .replace(/\s+/g, '');
+        // Base64解码获取DER长度
+        const derLength = atob(base64Data).length;
+        // 典型长度对应关系：
+        if (derLength <= 294) { // 2048位密钥DER长度约294字节
+            return 190; // 2048位：190字节
+        }
+        else if (derLength <= 422) { // 3072位密钥DER长度约422字节
+            return 318; // 3072位：318字节
+        }
+        else { // 4096位
+            return 446; // 4096位：446字节
+        }
+    }
+    /**
+     * 将DER格式转换为PEM格式字符串
+     * @param {ArrayBuffer} der - DER格式的密钥数据
+     * @param {string} type - 密钥类型 ('PUBLIC' 或 'PRIVATE')
+     * @returns {string} PEM格式的密钥字符串
+     */
+    static derToPem(der, type) {
+        const base64 = this.arrayBufferToBase64(der);
+        // 将Base64字符串分割为64字符一行
+        const wrapped = base64.match(/.{1,64}/g).join('\n');
+        if (type === 'PUBLIC') {
+            return `-----BEGIN PUBLIC KEY-----\n${wrapped}\n-----END PUBLIC KEY-----`;
+        }
+        else {
+            return `-----BEGIN PRIVATE KEY-----\n${wrapped}\n-----END PRIVATE KEY-----`;
+        }
+    }
+    /**
+     * 将PEM格式字符串转换为DER格式
+     * @param {string} pem - PEM格式的密钥字符串
+     * @returns {ArrayBuffer} DER格式的密钥数据
+     */
+    static pemToDer(pem) {
+        // 移除PEM头部、尾部和所有空白字符
+        const base64 = pem
+            .replace(/-----BEGIN (?:PUBLIC|PRIVATE) KEY-----/, '')
+            .replace(/-----END (?:PUBLIC|PRIVATE) KEY-----/, '')
+            .replace(/\s+/g, '');
+        return this.base64ToArrayBuffer(base64);
+    }
+    /**
+     * ArrayBuffer转Base64字符串
+     * @param {ArrayBuffer} buffer
+     * @returns {string}
+     */
+    static arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Base64字符串转ArrayBuffer
+     * @param {string} base64
+     * @returns {ArrayBuffer}
+     */
+    static base64ToArrayBuffer(base64) {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    /**
+     * 验证PEM格式的密钥字符串
+     * @param {string} pem - PEM格式的密钥字符串
+     * @param {'PUBLIC'|'PRIVATE'} expectedType - 期望的密钥类型
+     * @returns {boolean} 是否为有效的PEM格式
+     */
+    static validatePemFormat(pem, expectedType) {
+        if (typeof pem !== 'string')
+            return false;
+        const publicKeyPattern = /^-----BEGIN PUBLIC KEY-----\n([A-Za-z0-9+/=\n]+)\n-----END PUBLIC KEY-----$/;
+        const privateKeyPattern = /^-----BEGIN PRIVATE KEY-----\n([A-Za-z0-9+/=\n]+)\n-----END PRIVATE KEY-----$/;
+        if (expectedType === 'PUBLIC') {
+            return publicKeyPattern.test(pem);
+        }
+        else {
+            return privateKeyPattern.test(pem);
+        }
+    }
+}
+exports.AsymmetricCrypto = AsymmetricCrypto;

package/dist/libs/utils/format-url.d.ts

@@ -0,0 +1,2 @@
+declare function formatHost(host: string): string;
+export { formatHost, };

package/dist/libs/utils/format-url.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHost = void 0;
+function formatHost(host) {
+    if (host.endsWith(':80')) {
+        host = host.slice(0, -3);
+    }
+    if (host.endsWith(':443')) {
+        host = host.slice(0, -4);
+    }
+    return host;
+}
+exports.formatHost = formatHost;

package/dist/libs/utils/render-utils.d.ts

@@ -1,19 +1,28 @@
 import { Context } from '@midwayjs/koa';
+import { ISessionInfo } from '../../models/userSession';
+interface IFileElement {
+    fileUrl: string;
+    fileType?: string;
+    isModule?: boolean;
+}
 interface IRenderUtilsProps {
     ctx: Context;
     package_assets: any;
     workbenchInfo: any;
-    userInfo?: any;
+    userInfo?: ISessionInfo;
     appInfo?: any;
     fatcmscsrftoken: string;
 }
 declare class RenderUtils {
-    private readonly ctx;
-    private readonly fileList;
-    private readonly workbenchInfo;
-    private readonly userInfo;
-    private readonly appInfo;
-    private readonly fatcmscsrftoken;
+    readonly ctx: Context;
+    readonly fileList: IFileElement[];
+    readonly workbenchInfo: any;
+    readonly userInfo: ISessionInfo;
+    readonly appInfo: any;
+    readonly cookieInfo: any;
+    readonly fatcmscsrftoken: string;
+    readonly isMobileUserAgent: boolean;
+    readonly isMobileByQuery: boolean;
     constructor(props: IRenderUtilsProps);
     renderCsrfToken(): string;
     renderUserInfo(): string;

package/dist/libs/utils/render-utils.js

@@ -37,14 +37,34 @@ function parseCookie(cookieStr) {
     }
     return cookies;
 }
+function isMobileUserAgent(userAgent = '') {
+    // 空值处理
+    if (!userAgent)
+        return false;
+    // 转为小写统一匹配
+    const ua = userAgent.toLowerCase();
+    // 【核心】移动端关键词（覆盖主流系统）
+    const mobileKeywords = /android|iphone|ipod|ios|mobile|blackberry|iemobile|opera mini|windows phone|harmonyos/i;
+    // 【排除项】平板/PC关键词（避免误判）
+    const excludeKeywords = /ipad|tablet|playbook|kindle|pc|windows nt|macintosh|linux x86_64/i;
+    // 判断规则：包含移动端关键词 + 不包含排除项关键词
+    const isMatchMobile = mobileKeywords.test(ua);
+    const isExclude = excludeKeywords.test(ua);
+    return isMatchMobile && !isExclude;
+}
 class RenderUtils {
     constructor(props) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         this.ctx = props.ctx;
+        const query = ((_a = props.ctx) === null || _a === void 0 ? void 0 : _a.query) || {};
+        const headers = ((_b = props.ctx) === null || _b === void 0 ? void 0 : _b.headers) || {};
         this.workbenchInfo = props.workbenchInfo || {};
         this.userInfo = props.userInfo || {};
         this.appInfo = props.appInfo || {};
         this.fatcmscsrftoken = props.fatcmscsrftoken;
+        this.cookieInfo = parseCookie(headers === null || headers === void 0 ? void 0 : headers.cookie);
+        this.isMobileUserAgent = isMobileUserAgent(headers['user-agent'] || '');
+        this.isMobileByQuery = `${query['__is_mobile_request__']}` === 'true';
         const packageAssets = (0, functions_1.parseJsonObject)(props.package_assets) || {};
         const fileList = _.get(packageAssets, 'data.fileList');
         if (Array.isArray(fileList)) {
@@ -58,8 +78,8 @@ class RenderUtils {
             console.info(time +
                 ' 解析fileList为空==>' +
                 JSON.stringify({
-                    workbench_code: (_a = this.workbenchInfo) === null || _a === void 0 ? void 0 : _a.workbench_code,
-                    app_code: (_b = this.appInfo) === null || _b === void 0 ? void 0 : _b.app_code,
+                    workbench_code: (_c = this.workbenchInfo) === null || _c === void 0 ? void 0 : _c.workbench_code,
+                    app_code: (_d = this.appInfo) === null || _d === void 0 ? void 0 : _d.app_code,
                 }));
         }
     }
@@ -67,7 +87,9 @@ class RenderUtils {
         return `<script>window.__fatcmscsrftoken = "${this.fatcmscsrftoken}";</script>`;
     }
     renderUserInfo() {
-        return `<script>window.__user_info = ${JSON.stringify(this.userInfo)}  </script>`;
+        const userInfoClone = { ...this.userInfo };
+        delete userInfoClone.privateKey;
+        return `<script>window.__user_info = ${JSON.stringify(userInfoClone)}  </script>`;
     }
     renderWorkbenchInfo() {
         const infoPick = _.pick(this.workbenchInfo, ['id', 'workbench_code', 'workbench_name', 'workbench_domain', 'workbench_desc', 'config_type', 'config_content']);
@@ -78,9 +100,8 @@ class RenderUtils {
         return `<script>window.__app_info = ${JSON.stringify(infoPick)}</script>`;
     }
     renderCookieInfo(keys) {
-        var _a;
         try {
-            const cookies = parseCookie((_a = this.ctx.headers) === null || _a === void 0 ? void 0 : _a.cookie);
+            const cookies = this.cookieInfo;
             const cookieObj = {};
             if (typeof keys === 'string') {
                 const keyArr = keys.split(',');

package/dist/middleware/global.middleware.js

@@ -18,6 +18,7 @@ const fatcms_request_1 = require("../libs/utils/fatcms-request");
 const contextLogger_1 = require("../models/contextLogger");
 const node_stream_1 = require("node:stream");
 const VisitStatService_1 = require("../service/VisitStatService");
+const WorkbenchInfoTools_1 = require("../models/WorkbenchInfoTools");
 function isFunction(fun) {
     return typeof fun === 'function';
 }
@@ -230,6 +231,12 @@ let GlobalMiddleware = class GlobalMiddleware {
                 const isSuperAdmin = checkIsSuperAdmin(ctx, sessionInfo);
                 ctx.userSession = new userSession_1.UserSessionInfo(sessionInfo, isSuperAdmin);
                 ctx.workbenchInfo = await workbenchService.getCurrentHostWorkbenchInfo();
+                ctx.workbenchInfoTools = new WorkbenchInfoTools_1.WorkbenchInfoTools(ctx.workbenchInfo);
+                // 校验是否支持该路径
+                const isSupportTheNodePath = workbenchService.isSupportTheNodePathByWorkbenchInfo(ctx.workbenchInfo, ctx.path);
+                if (!isSupportTheNodePath) {
+                    return common_dto_1.CommonResult.errorRes('非法访问！此站点不支持该路径！', 'NOT_SUPPORT_PATH');
+                }
                 // 数据埋点
                 await trackRequest(ctx);
                 const res0 = await next();

package/dist/models/SystemEntities.d.ts

@@ -103,3 +103,37 @@ export interface IWorkbenchEntity {
     workbench_type: number;
     package_assets?: string;
 }
+export declare enum CacheLevelEnum {
+    NONE = "NONE",
+    CONTEXT = "CONTEXT",
+    MEMORY = "MEMORY",
+    REDIS = "REDIS",
+    DISK = "DISK"
+}
+export declare enum CacheNameEnum {
+    CurdMixByDict = "CurdMixByDict",
+    CurdMixByLinkToCustom = "CurdMixByLinkToCustom",
+    CurdMixBySysConfig = "CurdMixBySysConfig",
+    CurdMixByWorkbench = "CurdMixByWorkbench",
+    GetParsedCrudStdAppInfo = "GetParsedCrudStdAppInfo",
+    GetWorkbenchMenu = "GetWorkbenchMenu",
+    GetNavPageInfo = "GetNavPageInfo",
+    GetEnumInfoByCode = "GetEnumInfoByCode",
+    UserSessionBySessionId = "UserSessionBySessionId",
+    UserSessionByAsyncTaskId = "UserSessionByAsyncTaskId"
+}
+export interface IWorkbenchConfig {
+    nodeApiWhiteEnable?: boolean;
+    nodeApiWhiteList?: string[];
+    nodeApiWhitePrefix?: string[];
+    crudStdAppInfoCacheLevel?: CacheLevelEnum;
+    crudStdAppInfoCacheSecond?: number;
+    publicApiNavPageInfoCacheLevel?: CacheLevelEnum;
+    publicApiNavPageInfoCacheSecond?: number;
+    publicApiMenuCacheLevel?: CacheLevelEnum;
+    publicApiMenuCacheSecond?: number;
+    queryEnumInfoCacheLevel?: CacheLevelEnum;
+    queryEnumInfoCacheSecond?: number;
+    curdMixByCommonCacheLevel?: CacheLevelEnum;
+    curdMixByCommonCacheSecond?: number;
+}

package/dist/models/SystemEntities.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProxyUserContextEnum = void 0;
+exports.CacheNameEnum = exports.CacheLevelEnum = exports.ProxyUserContextEnum = void 0;
 var ProxyUserContextEnum;
 (function (ProxyUserContextEnum) {
     ProxyUserContextEnum[ProxyUserContextEnum["NO_PASS"] = 0] = "NO_PASS";
     ProxyUserContextEnum[ProxyUserContextEnum["BASIC_INFO"] = 1] = "BASIC_INFO";
     ProxyUserContextEnum[ProxyUserContextEnum["SESSION_INFO"] = 2] = "SESSION_INFO";
 })(ProxyUserContextEnum = exports.ProxyUserContextEnum || (exports.ProxyUserContextEnum = {}));
+var CacheLevelEnum;
+(function (CacheLevelEnum) {
+    CacheLevelEnum["NONE"] = "NONE";
+    CacheLevelEnum["CONTEXT"] = "CONTEXT";
+    CacheLevelEnum["MEMORY"] = "MEMORY";
+    CacheLevelEnum["REDIS"] = "REDIS";
+    CacheLevelEnum["DISK"] = "DISK";
+})(CacheLevelEnum = exports.CacheLevelEnum || (exports.CacheLevelEnum = {}));
+var CacheNameEnum;
+(function (CacheNameEnum) {
+    CacheNameEnum["CurdMixByDict"] = "CurdMixByDict";
+    CacheNameEnum["CurdMixByLinkToCustom"] = "CurdMixByLinkToCustom";
+    CacheNameEnum["CurdMixBySysConfig"] = "CurdMixBySysConfig";
+    CacheNameEnum["CurdMixByWorkbench"] = "CurdMixByWorkbench";
+    CacheNameEnum["GetParsedCrudStdAppInfo"] = "GetParsedCrudStdAppInfo";
+    CacheNameEnum["GetWorkbenchMenu"] = "GetWorkbenchMenu";
+    CacheNameEnum["GetNavPageInfo"] = "GetNavPageInfo";
+    CacheNameEnum["GetEnumInfoByCode"] = "GetEnumInfoByCode";
+    CacheNameEnum["UserSessionBySessionId"] = "UserSessionBySessionId";
+    CacheNameEnum["UserSessionByAsyncTaskId"] = "UserSessionByAsyncTaskId";
+})(CacheNameEnum = exports.CacheNameEnum || (exports.CacheNameEnum = {}));

package/dist/models/WorkbenchInfoTools.d.ts

@@ -0,0 +1,7 @@
+import { IWorkbenchConfig, IWorkbenchEntity } from "./SystemEntities";
+export declare class WorkbenchInfoTools {
+    private readonly workbenchInfo;
+    private parsedConfigContent;
+    constructor(workbenchInfo: IWorkbenchEntity);
+    getWorkbenchConfig(): IWorkbenchConfig;
+}

package/dist/models/WorkbenchInfoTools.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbenchInfoTools = void 0;
+const functions_1 = require("../libs/utils/functions");
+class WorkbenchInfoTools {
+    constructor(workbenchInfo) {
+        this.workbenchInfo = workbenchInfo;
+        this.parsedConfigContent = null;
+    }
+    getWorkbenchConfig() {
+        var _a;
+        if (this.parsedConfigContent) {
+            return this.parsedConfigContent;
+        }
+        const configObj = (0, functions_1.parseJsonObject)((_a = this.workbenchInfo) === null || _a === void 0 ? void 0 : _a.config_content);
+        this.parsedConfigContent = configObj || {};
+        return this.parsedConfigContent;
+    }
+}
+exports.WorkbenchInfoTools = WorkbenchInfoTools;

package/dist/models/bizmodels.d.ts

@@ -102,3 +102,12 @@ export interface IStdCrudExportInputParams {
     primaryKey: any;
     pageSize: number;
 }
+export interface ICacheServiceBase {
+    getJsonObject(key: string): Promise<any>;
+    setJsonObject(key: string, obj: any, cacheSecond?: number): Promise<any>;
+    removeItem(key: string): Promise<any>;
+}
+export interface IfatcmsCacheConfig {
+    diskCacheDir: string;
+    keyPrefix: string;
+}

package/dist/models/contextLogger.d.ts

@@ -11,8 +11,10 @@ declare class ContextLogger implements ILoggerContext {
     private readonly ctx;
     private readonly app;
     private readonly logList;
+    private currentTime;
     constructor(ctx: Context);
     getLogList(): any;
+    private getDiffTime;
     debug(msg: any, ...args: any[]): void;
     error(msg: any, ...args: any[]): void;
     info(msg: any, ...args: any[]): void;

package/dist/models/contextLogger.js

@@ -49,10 +49,16 @@ class ContextLogger {
         this.app = ctx.app;
         this.ctx = ctx;
         this.logList = [];
+        this.currentTime = Date.now();
     }
     getLogList() {
         return this.logList;
     }
+    getDiffTime() {
+        const diffTime = Date.now() - this.currentTime;
+        this.currentTime = Date.now();
+        return diffTime;
+    }
     debug(msg, ...args) {
         this.getLogger().debug(msg, ...args);
         this.appendLogList('debug', msg, ...args);
@@ -80,7 +86,8 @@ class ContextLogger {
         }
         const time = moment().format('YYYY-MM-DD HH:mm:ss.SSS');
         const caller = getCallerInfo();
-        this.logList.push({ level, msg, args, caller, time });
+        const diffTime = this.getDiffTime();
+        this.logList.push({ level, msg, args, caller, time, diffTime });
     }
     getLogger() {
         const logger = this.app.getLogger('logger');

package/dist/models/userSession.d.ts

@@ -17,6 +17,8 @@ interface ISessionInfo {
     accountId: string;
     workbenchCode: string;
     accountType: string;
+    publicKey: string;
+    privateKey: string;
     bizExt?: any;
 }
 interface IConsumerUserInfo {

package/dist/models/userSession.js

@@ -28,6 +28,8 @@ function createEmptySessionInfo(superAdmin) {
         accountId: '',
         workbenchCode: '',
         accountType: '',
+        publicKey: '',
+        privateKey: '',
     };
 }
 class UserSessionInfo {

package/dist/schedule/anonymousContext.js

@@ -14,6 +14,8 @@ const anonymousUserInfo = {
     accountId: '',
     workbenchCode: '',
     accountType: userSession_1.SYS_ACCOUNT_TYPE,
+    publicKey: '',
+    privateKey: '',
 };
 const anonymousWorkbenchInfo = {
     id: 0,

package/dist/service/AuthService.js

@@ -23,6 +23,7 @@ const common_dto_1 = require("../libs/utils/common-dto");
 const fatcms_request_1 = require("../libs/utils/fatcms-request");
 const exceptions_1 = require("../libs/crud-pro/exceptions");
 const global_config_1 = require("../libs/global-config/global-config");
+const AsymmetricCrypto_1 = require("../libs/utils/AsymmetricCrypto");
 let AuthService = class AuthService {
     /**
      * 明文密码转unsaltedPwd密码
@@ -80,6 +81,7 @@ let AuthService = class AuthService {
             roleCodes = await this.queryUserRoleCodeList(accountId);
             functionCodes = await this.queryFunctionCodeList(roleCodes);
         }
+        const { publicKey, privateKey } = await AsymmetricCrypto_1.AsymmetricCrypto.generateKeyPair();
         const sessionInfo = {
             nickName: consumerUserInfo.nickName,
             avatar: consumerUserInfo.avatar,
@@ -90,6 +92,8 @@ let AuthService = class AuthService {
             accountId: consumerUserInfo.accountId,
             workbenchCode: consumerUserInfo.workbenchCode,
             accountType: consumerUserInfo.accountType,
+            publicKey,
+            privateKey,
         };
         await this.userSessionService.saveUserSession(sessionInfo);
         return {
@@ -116,6 +120,7 @@ let AuthService = class AuthService {
         const sessionId = (0, functions_1.createUniqueId)();
         const roleCodes = await this.queryUserRoleCodeList(accountId);
         const functionCodes = await this.queryFunctionCodeList(roleCodes);
+        const { publicKey, privateKey } = await AsymmetricCrypto_1.AsymmetricCrypto.generateKeyPair();
         const sessionInfo = {
             nickName: userAccount.nick_name,
             avatar: userAccount.avatar,
@@ -127,6 +132,8 @@ let AuthService = class AuthService {
             workbenchCode,
             accountType: userSession_1.SYS_ACCOUNT_TYPE,
             bizExt: {},
+            publicKey,
+            privateKey,
         };
         if (bizExt && typeof bizExt === 'object') {
             sessionInfo.bizExt = bizExt;

package/dist/service/EnumInfoService.d.ts

@@ -14,7 +14,7 @@ export declare class EnumInfoService {
     ctx: Context;
     private curdProService;
     private curdMixByLinkToCustomService;
-    private redisCacheService;
+    private cacheServiceFactory;
     queryEnumInfo(codeList: IQueryEnumInfo[], refreshCache: boolean): Promise<IQueryEnumResult[]>;
     /**
      * code形如：fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name