@nest-omni/core 4.1.3-10 → 4.1.3-12

package/audit/services/manual-audit-log.service.d.ts

@@ -2,20 +2,21 @@ import { Repository, DataSource } from 'typeorm';
 import { ManualOperationLogEntity, EntityTransactionEntity } from '../entities';
 import { AuditContextService } from './audit-context.service';
 import { ManualLogOptions } from '../interfaces';
+import { AuditTransactionStatus } from '../enums';
 /**
  * 手动审计日志服务
  *
- * 提供全局静态方法，在任意地方手动记录操作日志
+ * 提供标准的依赖注入方式记录操作日志
+ * @deprecated 静态方法已废弃,请使用依赖注入方式
  */
 export declare class ManualAuditLogService {
     private readonly manualLogRepository;
     private readonly transactionRepository;
     private readonly contextService;
     private readonly dataSource;
-    private static instance;
     constructor(manualLogRepository: Repository<ManualOperationLogEntity>, transactionRepository: Repository<EntityTransactionEntity>, contextService: AuditContextService, dataSource: DataSource);
     /**
-     * 全局静态方法：记录操作日志
+     * 记录操作日志
      *
      * @description
      * 支持三种记录模式：
@@ -25,7 +26,7 @@ export declare class ManualAuditLogService {
      *
      * @example
      * // 模式1：模板键模式
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'user.login',
      *   descriptionParams: {
      *     username: 'john.doe',
@@ -35,13 +36,13 @@ export declare class ManualAuditLogService {
      *
      * @example
      * // 模式2：直接描述模式（字符串）
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   description: '用户登录系统',
      * });
      *
      * @example
      * // 模式2：直接描述模式（多语言）
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   description: {
      *     zh: '用户登录系统',
      *     en: 'User logged in',
@@ -50,7 +51,7 @@ export declare class ManualAuditLogService {
      *
      * @example
      * // 模式3：内联模板模式
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   descriptionTemplate: {
      *     zh: '用户 {username} 在 {time} 登录了系统',
      *     en: 'User {username} logged in at {time}',
@@ -61,52 +62,52 @@ export declare class ManualAuditLogService {
      *   },
      * });
      */
-    static log(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
+    log(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
     /**
      * 实例方法：记录操作日志
      */
     logOperation(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
     /**
-     * 静态方法：带事务记录
+     * 开始事务
      *
      * @example
      * ```typescript
-     * const txId = await ManualAuditLogService.beginTransaction('user-123', 'John Doe');
+     * const txId = await this.manualAuditLogService.beginTransaction('user-123', 'John Doe');
      *
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'order.create',
      *   descriptionParams: { orderId: 'order-1' },
      *   transactionId: txId,
      *   autoCreateTransaction: false,
      * });
      *
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'payment.process',
      *   descriptionParams: { paymentId: 'pay-1' },
      *   transactionId: txId,
      *   autoCreateTransaction: false,
      * });
      *
-     * await ManualAuditLogService.commitTransaction(txId);
+     * await this.manualAuditLogService.commitTransaction(txId);
      * ```
      */
-    static beginTransaction(userId?: string, username?: string): Promise<string>;
+    beginTransaction(userId?: string, username?: string): Promise<string>;
     /**
-     * 静态方法：提交事务
+     * 提交事务
      */
-    static commitTransaction(transactionId: string): Promise<void>;
+    commitTransaction(transactionId: string): Promise<void>;
     /**
-     * 静态方法：回滚事务
+     * 回滚事务
      */
-    static rollbackTransaction(transactionId: string): Promise<void>;
+    rollbackTransaction(transactionId: string): Promise<void>;
     /**
      * 创建事务
      */
-    private createTransaction;
+    createTransaction(userId?: string, username?: string): Promise<string>;
     /**
      * 更新事务状态
      */
-    private updateTransactionStatus;
+    updateTransactionStatus(transactionId: string, status: AuditTransactionStatus): Promise<void>;
     /**
      * 生成事务ID
      */
@@ -120,7 +121,7 @@ export declare class ManualAuditLogService {
      * @example
      * ```typescript
      * // 混合使用多种模式
-     * await ManualAuditLogService.logBatch([
+     * await this.manualAuditLogService.logBatch([
      *   {
      *     templateKey: 'product.update',
      *     descriptionParams: { productId: 'p1', field: 'price' },
@@ -138,11 +139,11 @@ export declare class ManualAuditLogService {
      * ]);
      * ```
      */
-    static logBatch(operations: ManualLogOptions[], sharedTransactionId?: string): Promise<ManualOperationLogEntity[]>;
+    logBatch(operations: ManualLogOptions[], sharedTransactionId?: string): Promise<ManualOperationLogEntity[]>;
     /**
      * 查询操作日志
      */
-    static findLogs(options: {
+    findLogs(options: {
         templateKey?: string;
         userId?: string;
         transactionId?: string;

package/audit/services/manual-audit-log.service.js

@@ -20,7 +20,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var ManualAuditLogService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManualAuditLogService = void 0;
 const common_1 = require("@nestjs/common");
@@ -33,19 +32,18 @@ const crypto_1 = require("crypto");
 /**
  * 手动审计日志服务
  *
- * 提供全局静态方法，在任意地方手动记录操作日志
+ * 提供标准的依赖注入方式记录操作日志
+ * @deprecated 静态方法已废弃,请使用依赖注入方式
  */
-let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogService {
+let ManualAuditLogService = class ManualAuditLogService {
     constructor(manualLogRepository, transactionRepository, contextService, dataSource) {
         this.manualLogRepository = manualLogRepository;
         this.transactionRepository = transactionRepository;
         this.contextService = contextService;
         this.dataSource = dataSource;
-        // 设置静态实例
-        ManualAuditLogService_1.instance = this;
     }
     /**
-     * 全局静态方法：记录操作日志
+     * 记录操作日志
      *
      * @description
      * 支持三种记录模式：
@@ -55,7 +53,7 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
      *
      * @example
      * // 模式1：模板键模式
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'user.login',
      *   descriptionParams: {
      *     username: 'john.doe',
@@ -65,13 +63,13 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
      *
      * @example
      * // 模式2：直接描述模式（字符串）
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   description: '用户登录系统',
      * });
      *
      * @example
      * // 模式2：直接描述模式（多语言）
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   description: {
      *     zh: '用户登录系统',
      *     en: 'User logged in',
@@ -80,7 +78,7 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
      *
      * @example
      * // 模式3：内联模板模式
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   descriptionTemplate: {
      *     zh: '用户 {username} 在 {time} 登录了系统',
      *     en: 'User {username} logged in at {time}',
@@ -91,12 +89,9 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
      *   },
      * });
      */
-    static log(options) {
+    log(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized. Make sure AuditModule is imported.');
-            }
-            return ManualAuditLogService_1.instance.logOperation(options);
+            return this.logOperation(options);
         });
     }
     /**
@@ -146,57 +141,48 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
         });
     }
     /**
-     * 静态方法：带事务记录
+     * 开始事务
      *
      * @example
      * ```typescript
-     * const txId = await ManualAuditLogService.beginTransaction('user-123', 'John Doe');
+     * const txId = await this.manualAuditLogService.beginTransaction('user-123', 'John Doe');
      *
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'order.create',
      *   descriptionParams: { orderId: 'order-1' },
      *   transactionId: txId,
      *   autoCreateTransaction: false,
      * });
      *
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'payment.process',
      *   descriptionParams: { paymentId: 'pay-1' },
      *   transactionId: txId,
      *   autoCreateTransaction: false,
      * });
      *
-     * await ManualAuditLogService.commitTransaction(txId);
+     * await this.manualAuditLogService.commitTransaction(txId);
      * ```
      */
-    static beginTransaction(userId, username) {
+    beginTransaction(userId, username) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
-            return ManualAuditLogService_1.instance.createTransaction(userId, username);
+            return this.createTransaction(userId, username);
         });
     }
     /**
-     * 静态方法：提交事务
+     * 提交事务
      */
-    static commitTransaction(transactionId) {
+    commitTransaction(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
-            yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.COMMITTED);
+            yield this.updateTransactionStatus(transactionId, enums_1.AuditTransactionStatus.COMMITTED);
         });
     }
     /**
-     * 静态方法：回滚事务
+     * 回滚事务
      */
-    static rollbackTransaction(transactionId) {
+    rollbackTransaction(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
-            yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.ROLLED_BACK);
+            yield this.updateTransactionStatus(transactionId, enums_1.AuditTransactionStatus.ROLLED_BACK);
         });
     }
     /**
@@ -210,7 +196,7 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
                 userId: userId || context.userId || 'system',
                 username: username || context.username || 'system',
                 requestIp: context.requestIp || 'unknown',
-                status: enums_1.TransactionStatus.PENDING,
+                status: enums_1.AuditTransactionStatus.PENDING,
                 entities: [],
             });
             const saved = yield this.transactionRepository.save(transaction);
@@ -240,7 +226,7 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
      * @example
      * ```typescript
      * // 混合使用多种模式
-     * await ManualAuditLogService.logBatch([
+     * await this.manualAuditLogService.logBatch([
      *   {
      *     templateKey: 'product.update',
      *     descriptionParams: { productId: 'p1', field: 'price' },
@@ -258,22 +244,18 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
      * ]);
      * ```
      */
-    static logBatch(operations, sharedTransactionId) {
+    logBatch(operations, sharedTransactionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
             // 创建共享事务ID
-            const transactionId = sharedTransactionId ||
-                (yield ManualAuditLogService_1.instance.createTransaction());
+            const transactionId = sharedTransactionId || (yield this.createTransaction());
             const results = [];
             for (const operation of operations) {
-                const result = yield ManualAuditLogService_1.instance.logOperation(Object.assign(Object.assign({}, operation), { transactionId, autoCreateTransaction: false }));
+                const result = yield this.logOperation(Object.assign(Object.assign({}, operation), { transactionId, autoCreateTransaction: false }));
                 results.push(result);
             }
             // 自动提交事务（如果是自动创建的）
             if (!sharedTransactionId) {
-                yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.COMMITTED);
+                yield this.updateTransactionStatus(transactionId, enums_1.AuditTransactionStatus.COMMITTED);
             }
             return results;
         });
@@ -281,13 +263,10 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
     /**
      * 查询操作日志
      */
-    static findLogs(options) {
+    findLogs(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
             const { templateKey, userId, transactionId, startTime, endTime, limit = 100 } = options;
-            const query = ManualAuditLogService_1.instance.manualLogRepository
+            const query = this.manualLogRepository
                 .createQueryBuilder('log')
                 .orderBy('log.createdAt', 'DESC')
                 .take(limit);
@@ -311,7 +290,7 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
     }
 };
 exports.ManualAuditLogService = ManualAuditLogService;
-exports.ManualAuditLogService = ManualAuditLogService = ManualAuditLogService_1 = __decorate([
+exports.ManualAuditLogService = ManualAuditLogService = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, typeorm_1.InjectRepository)(entities_1.ManualOperationLogEntity, 'audit')),
     __param(1, (0, typeorm_1.InjectRepository)(entities_1.EntityTransactionEntity, 'audit')),

package/audit/services/operation-description.service.d.ts

@@ -1,6 +1,7 @@
 import { Repository } from 'typeorm';
 import { OperationTemplateEntity, EntityTransactionEntity, EntityAuditLogEntity, ManualOperationLogEntity } from '../entities';
 import { ChangeDetail, TransactionDescription } from '../interfaces';
+import { CacheService } from '../../cache';
 /**
  * 操作描述服务
  * 负责根据模板和参数动态生成多语言描述
@@ -10,8 +11,10 @@ export declare class OperationDescriptionService {
     private readonly transactionRepository;
     private readonly auditLogRepository;
     private readonly manualOperationRepository;
-    private templateCache;
-    constructor(templateRepository: Repository<OperationTemplateEntity>, transactionRepository: Repository<EntityTransactionEntity>, auditLogRepository: Repository<EntityAuditLogEntity>, manualOperationRepository: Repository<ManualOperationLogEntity>);
+    private readonly cacheService;
+    private readonly CACHE_NAMESPACE;
+    private readonly CACHE_TTL;
+    constructor(templateRepository: Repository<OperationTemplateEntity>, transactionRepository: Repository<EntityTransactionEntity>, auditLogRepository: Repository<EntityAuditLogEntity>, manualOperationRepository: Repository<ManualOperationLogEntity>, cacheService: CacheService);
     /**
      * 动态生成操作名称
      * @param templateKey 模板键
@@ -63,11 +66,18 @@ export declare class OperationDescriptionService {
      */
     private formatDisplayValue;
     /**
-     * 获取操作模板（带缓存）
+     * 获取操作模板（使用统一缓存服务）
      * @param templateKey 模板键
      * @returns 操作模板
      */
     private getOperationTemplate;
+    /**
+     * 获取模板字符串（仅返回模板文本，不填充参数）
+     * @param templateKey 模板键
+     * @param language 语言
+     * @returns 模板字符串
+     */
+    getTemplate(templateKey: string, language?: string): Promise<string | null>;
     /**
      * 清除模板缓存
      */

package/audit/services/operation-description.service.js

@@ -26,18 +26,22 @@ const common_1 = require("@nestjs/common");
 const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
 const entities_1 = require("../entities");
+const cache_1 = require("../../cache");
 /**
  * 操作描述服务
  * 负责根据模板和参数动态生成多语言描述
  */
 let OperationDescriptionService = class OperationDescriptionService {
-    constructor(templateRepository, transactionRepository, auditLogRepository, manualOperationRepository) {
+    constructor(templateRepository, transactionRepository, auditLogRepository, manualOperationRepository, cacheService) {
         this.templateRepository = templateRepository;
         this.transactionRepository = transactionRepository;
         this.auditLogRepository = auditLogRepository;
         this.manualOperationRepository = manualOperationRepository;
-        // 模板缓存
-        this.templateCache = new Map();
+        this.cacheService = cacheService;
+        // 缓存命名空间
+        this.CACHE_NAMESPACE = 'audit:template';
+        // 缓存TTL（30分钟）
+        this.CACHE_TTL = 30 * 60 * 1000;
     }
     /**
      * 动态生成操作名称
@@ -182,14 +186,123 @@ let OperationDescriptionService = class OperationDescriptionService {
      */
     batchGetTransactionDescriptions(transactionIds_1) {
         return __awaiter(this, arguments, void 0, function* (transactionIds, language = 'zh') {
+            if (transactionIds.length === 0) {
+                return {};
+            }
+            // 批量查询事务信息
+            const transactions = yield this.transactionRepository
+                .createQueryBuilder('tx')
+                .whereInIds(transactionIds)
+                .getMany();
+            // 批量查询审计日志
+            const auditLogs = yield this.auditLogRepository
+                .createQueryBuilder('log')
+                .where('log.requestId IN (:...transactionIds)', { transactionIds })
+                .orderBy('log.createdAt', 'ASC')
+                .getMany();
+            // 批量查询手动操作记录
+            const manualOperations = yield this.manualOperationRepository
+                .createQueryBuilder('op')
+                .where('op.transactionId IN (:...transactionIds)', { transactionIds })
+                .orderBy('op.createdAt', 'ASC')
+                .getMany();
+            // 收集所有需要的模板键
+            const templateKeys = new Set();
+            transactions.forEach(tx => {
+                if (tx.operationTemplateKey)
+                    templateKeys.add(tx.operationTemplateKey);
+            });
+            auditLogs.forEach(log => {
+                if (log.operationTemplateKey)
+                    templateKeys.add(log.operationTemplateKey);
+            });
+            manualOperations.forEach(op => {
+                if (op.operationTemplateKey)
+                    templateKeys.add(op.operationTemplateKey);
+            });
+            // 批量预加载模板
+            if (templateKeys.size > 0) {
+                yield this.preloadTemplates(Array.from(templateKeys));
+            }
+            // 按事务ID分组
+            const logsByTxId = new Map();
+            const opsByTxId = new Map();
+            auditLogs.forEach(log => {
+                const txId = log.requestId;
+                if (!logsByTxId.has(txId))
+                    logsByTxId.set(txId, []);
+                logsByTxId.get(txId).push(log);
+            });
+            manualOperations.forEach(op => {
+                const txId = op.transactionId;
+                if (!opsByTxId.has(txId))
+                    opsByTxId.set(txId, []);
+                opsByTxId.get(txId).push(op);
+            });
+            // 构建结果
             const results = {};
-            for (const transactionId of transactionIds) {
+            for (const transaction of transactions) {
                 try {
-                    results[transactionId] = yield this.getTransactionDescription(transactionId, language);
+                    const txLogs = logsByTxId.get(transaction.id) || [];
+                    const txOps = opsByTxId.get(transaction.id) || [];
+                    // 生成操作名称和描述
+                    let operationName;
+                    let description;
+                    if (transaction.operationTemplateKey) {
+                        operationName = yield this.generateOperationName(transaction.operationTemplateKey, language);
+                        description = yield this.generateDescription(transaction.operationTemplateKey, transaction.descriptionParams || {}, language);
+                    }
+                    else {
+                        const firstLog = txLogs[0];
+                        if (firstLog && firstLog.operationTemplateKey) {
+                            operationName = yield this.generateOperationName(firstLog.operationTemplateKey, language);
+                            description = yield this.generateDescription(firstLog.operationTemplateKey, firstLog.descriptionParams || {}, language);
+                        }
+                        else {
+                            operationName = 'Unknown Operation';
+                            description = transaction.description || 'Unknown operation';
+                        }
+                    }
+                    // 生成变更详情
+                    const changes = [];
+                    // 添加实体变更
+                    for (const log of txLogs) {
+                        const changeDescription = log.operationTemplateKey
+                            ? yield this.generateDescription(log.operationTemplateKey, log.descriptionParams || {}, language)
+                            : log.description || '';
+                        const changeDetails = log.changeDetails
+                            ? yield this.generateChangeDetails(log.changeDetails, language)
+                            : [];
+                        changes.push({
+                            entityName: log.entityType,
+                            entityId: log.entityId,
+                            operation: log.operation,
+                            description: changeDescription,
+                            details: changeDetails,
+                            createdAt: log.createdAt,
+                        });
+                    }
+                    // 添加手动操作
+                    for (const manualOp of txOps) {
+                        const opName = yield this.generateOperationName(manualOp.operationTemplateKey, language);
+                        const opDescription = yield this.generateDescription(manualOp.operationTemplateKey, manualOp.descriptionParams, language);
+                        changes.push({
+                            type: 'manual',
+                            description: `${opName}: ${opDescription}`,
+                            details: manualOp.descriptionParams,
+                            createdAt: manualOp.createdAt,
+                        });
+                    }
+                    // 按时间排序
+                    changes.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+                    results[transaction.id] = {
+                        operationName,
+                        description,
+                        changes,
+                    };
                 }
                 catch (error) {
-                    // 忽略错误，继续处理其他事务
-                    console.error(`Failed to get description for transaction ${transactionId}:`, error);
+                    console.error(`Failed to get description for transaction ${transaction.id}:`, error);
                 }
             }
             return results;
@@ -230,32 +343,48 @@ let OperationDescriptionService = class OperationDescriptionService {
         return String(value);
     }
     /**
-     * 获取操作模板（带缓存）
+     * 获取操作模板（使用统一缓存服务）
      * @param templateKey 模板键
      * @returns 操作模板
      */
     getOperationTemplate(templateKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            // 检查缓存
-            if (this.templateCache.has(templateKey)) {
-                return this.templateCache.get(templateKey);
-            }
-            // 从数据库查询
-            const template = yield this.templateRepository.findOne({
-                where: { key: templateKey },
+            // 使用统一缓存服务的 getOrSet 方法
+            return this.cacheService.getOrSet(templateKey, () => __awaiter(this, void 0, void 0, function* () {
+                // 从数据库查询
+                const template = yield this.templateRepository.findOne({
+                    where: { key: templateKey },
+                });
+                return template;
+            }), {
+                namespace: this.CACHE_NAMESPACE,
+                ttl: this.CACHE_TTL,
+                // 只使用内存缓存层，避免序列化开销
+                layers: [cache_1.CacheLayer.MEMORY],
             });
-            if (template) {
-                // 缓存模板
-                this.templateCache.set(templateKey, template);
+        });
+    }
+    /**
+     * 获取模板字符串（仅返回模板文本，不填充参数）
+     * @param templateKey 模板键
+     * @param language 语言
+     * @returns 模板字符串
+     */
+    getTemplate(templateKey_1) {
+        return __awaiter(this, arguments, void 0, function* (templateKey, language = 'zh') {
+            const template = yield this.getOperationTemplate(templateKey);
+            if (!template) {
+                return null;
             }
-            return template;
+            return template.descriptionTemplates[language] || template.descriptionTemplates['zh'] || null;
         });
     }
     /**
      * 清除模板缓存
      */
     clearTemplateCache() {
-        this.templateCache.clear();
+        // 使用统一缓存服务清除
+        this.cacheService.deletePattern(`${this.CACHE_NAMESPACE}:*`, [cache_1.CacheLayer.MEMORY]);
     }
     /**
      * 预加载模板到缓存
@@ -267,9 +396,16 @@ let OperationDescriptionService = class OperationDescriptionService {
                 .createQueryBuilder('template')
                 .where('template.key IN (:...keys)', { keys: templateKeys })
                 .getMany();
-            for (const template of templates) {
-                this.templateCache.set(template.key, template);
-            }
+            // 批量设置到缓存
+            const cacheItems = templates.map(template => ({
+                key: template.key,
+                value: template,
+            }));
+            yield this.cacheService.mset(cacheItems, {
+                namespace: this.CACHE_NAMESPACE,
+                ttl: this.CACHE_TTL,
+                layers: [cache_1.CacheLayer.MEMORY],
+            });
         });
     }
 };
@@ -283,5 +419,6 @@ exports.OperationDescriptionService = OperationDescriptionService = __decorate([
     __metadata("design:paramtypes", [typeorm_2.Repository,
         typeorm_2.Repository,
         typeorm_2.Repository,
-        typeorm_2.Repository])
+        typeorm_2.Repository,
+        cache_1.CacheService])
 ], OperationDescriptionService);