@nest-omni/core 4.1.3-2 → 4.1.3-22

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

@@ -26,33 +26,61 @@ 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;
     }
+    /**
+     * 动态生成操作名称
+     * @param templateKey 模板键
+     * @param language 语言
+     * @returns 操作名称
+     */
     generateOperationName(templateKey_1) {
         return __awaiter(this, arguments, void 0, function* (templateKey, language = 'zh') {
             const template = yield this.getOperationTemplate(templateKey);
             if (!template) {
-                return templateKey;
+                return templateKey; // 如果没有模板，返回模板键
             }
             return template.nameTemplates[language] || template.nameTemplates['zh'] || templateKey;
         });
     }
+    /**
+     * 动态生成操作描述
+     * @param templateKey 模板键
+     * @param descriptionParams 描述参数
+     * @param language 语言
+     * @returns 描述文本
+     */
     generateDescription(templateKey_1, descriptionParams_1) {
         return __awaiter(this, arguments, void 0, function* (templateKey, descriptionParams, language = 'zh') {
             const template = yield this.getOperationTemplate(templateKey);
             if (!template) {
-                return templateKey;
+                return templateKey; // 如果没有模板，返回模板键
             }
             const templateStr = template.descriptionTemplates[language] || template.descriptionTemplates['zh'] || templateKey;
             return this.fillTemplate(templateStr, descriptionParams);
         });
     }
+    /**
+     * 动态生成变更详情
+     * @param changeDetails 变更详情列表
+     * @param language 语言
+     * @returns 格式化的变更详情
+     */
     generateChangeDetails(changeDetails_1) {
         return __awaiter(this, arguments, void 0, function* (changeDetails, language = 'zh') {
             return changeDetails.map((detail) => {
@@ -67,22 +95,32 @@ let OperationDescriptionService = class OperationDescriptionService {
             });
         });
     }
+    /**
+     * 获取事务描述（包含所有变更）
+     * @param transactionId 事务ID
+     * @param language 语言
+     * @returns 事务描述对象
+     */
     getTransactionDescription(transactionId_1) {
         return __awaiter(this, arguments, void 0, function* (transactionId, language = 'zh') {
+            // 获取事务信息
             const transaction = yield this.transactionRepository.findOne({
                 where: { id: transactionId },
             });
             if (!transaction) {
                 throw new Error(`Transaction ${transactionId} not found`);
             }
+            // 获取事务的审计日志
             const auditLogs = yield this.auditLogRepository.find({
                 where: { requestId: transactionId },
                 order: { createdAt: 'ASC' },
             });
+            // 获取事务的手动操作记录
             const manualOperations = yield this.manualOperationRepository.find({
                 where: { transactionId },
                 order: { createdAt: 'ASC' },
             });
+            // 生成操作名称和描述
             let operationName;
             let description;
             if (transaction.operationTemplateKey) {
@@ -90,6 +128,7 @@ let OperationDescriptionService = class OperationDescriptionService {
                 description = yield this.generateDescription(transaction.operationTemplateKey, transaction.descriptionParams || {}, language);
             }
             else {
+                // 如果没有事务级别的模板，使用第一个变更的模板
                 const firstLog = auditLogs[0];
                 if (firstLog && firstLog.operationTemplateKey) {
                     operationName = yield this.generateOperationName(firstLog.operationTemplateKey, language);
@@ -100,7 +139,9 @@ let OperationDescriptionService = class OperationDescriptionService {
                     description = transaction.description || 'Unknown operation';
                 }
             }
+            // 生成变更详情
             const changes = [];
+            // 添加实体变更
             for (const log of auditLogs) {
                 const changeDescription = log.operationTemplateKey
                     ? yield this.generateDescription(log.operationTemplateKey, log.descriptionParams || {}, language)
@@ -117,6 +158,7 @@ let OperationDescriptionService = class OperationDescriptionService {
                     createdAt: log.createdAt,
                 });
             }
+            // 添加手动操作
             for (const manualOp of manualOperations) {
                 const opName = yield this.generateOperationName(manualOp.operationTemplateKey, language);
                 const opDescription = yield this.generateDescription(manualOp.operationTemplateKey, manualOp.descriptionParams, language);
@@ -127,6 +169,7 @@ let OperationDescriptionService = class OperationDescriptionService {
                     createdAt: manualOp.createdAt,
                 });
             }
+            // 按时间排序
             changes.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
             return {
                 operationName,
@@ -135,24 +178,147 @@ let OperationDescriptionService = class OperationDescriptionService {
             };
         });
     }
+    /**
+     * 批量获取事务描述
+     * @param transactionIds 事务ID列表
+     * @param language 语言
+     * @returns 事务描述映射
+     */
     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;
         });
     }
+    /**
+     * 填充模板
+     * @param template 模板字符串
+     * @param params 参数
+     * @returns 填充后的字符串
+     */
     fillTemplate(template, params) {
         if (!template)
             return '';
         let result = template;
+        // 替换参数 {key} -> value
         for (const [key, value] of Object.entries(params || {})) {
             const placeholder = `{${key}}`;
             if (result.includes(placeholder)) {
@@ -161,6 +327,12 @@ let OperationDescriptionService = class OperationDescriptionService {
         }
         return result;
     }
+    /**
+     * 格式化显示值
+     * @param value 原始值
+     * @param displayValue 显示值
+     * @returns 格式化后的值
+     */
     formatDisplayValue(value, displayValue) {
         if (displayValue !== undefined) {
             return displayValue;
@@ -170,32 +342,70 @@ 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]);
     }
+    /**
+     * 预加载模板到缓存
+     * @param templateKeys 模板键列表
+     */
     preloadTemplates(templateKeys) {
         return __awaiter(this, void 0, void 0, function* () {
             const templates = yield this.templateRepository
                 .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],
+            });
         });
     }
 };
@@ -209,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);

package/audit/services/transaction-audit.service.d.ts

@@ -4,19 +4,49 @@ import { AuditOperation } from '../enums';
 import { AuditContextService } from './audit-context.service';
 import { EntityAuditService } from './entity-audit.service';
 import { MultiDatabaseService } from './multi-database.service';
+/**
+ * 事务审计服务
+ */
 export declare class TransactionAuditService {
     private readonly transactionRepository;
     private readonly contextService;
     private readonly auditService;
     private readonly multiDbService;
     constructor(transactionRepository: Repository<EntityTransactionEntity>, contextService: AuditContextService, auditService: EntityAuditService, multiDbService: MultiDatabaseService);
+    /**
+     * 开始事务
+     */
     beginTransaction(description: string): Promise<string>;
+    /**
+     * 提交事务
+     */
     commitTransaction(transactionId: string): Promise<void>;
+    /**
+     * 回滚事务（支持多数据库）
+     */
     rollbackTransaction(transactionId: string): Promise<void>;
+    /**
+     * 添加实体到事务
+     */
     addEntityToTransaction(transactionId: string, entityType: string, entityId: string, operation: AuditOperation): Promise<void>;
+    /**
+     * 执行回滚（支持多数据库）
+     */
     private performRollback;
+    /**
+     * 按数据库连接分组实体
+     */
     private groupEntitiesByConnection;
+    /**
+     * 在指定连接中回滚实体
+     */
     private rollbackEntitiesInConnection;
+    /**
+     * 回滚单个实体
+     */
     private rollbackSingleEntity;
+    /**
+     * 获取最新的审计日志
+     */
     private getLatestAuditLog;
 }

package/audit/services/transaction-audit.service.js

@@ -30,6 +30,10 @@ const enums_1 = require("../enums");
 const audit_context_service_1 = require("./audit-context.service");
 const entity_audit_service_1 = require("./entity-audit.service");
 const multi_database_service_1 = require("./multi-database.service");
+const transaction_1 = require("@nest-omni/transaction");
+/**
+ * 事务审计服务
+ */
 let TransactionAuditService = class TransactionAuditService {
     constructor(transactionRepository, contextService, auditService, multiDbService) {
         this.transactionRepository = transactionRepository;
@@ -37,23 +41,30 @@ let TransactionAuditService = class TransactionAuditService {
         this.auditService = auditService;
         this.multiDbService = multiDbService;
     }
+    /**
+     * 开始事务
+     */
     beginTransaction(description) {
         return __awaiter(this, void 0, void 0, function* () {
             const context = yield this.contextService.getCurrentContext();
             const transaction = this.transactionRepository.create({
                 description,
-                status: enums_1.TransactionStatus.PENDING,
+                status: enums_1.AuditTransactionStatus.PENDING,
                 entities: [],
                 userId: context.userId,
                 username: context.username,
             });
             const savedTransaction = yield this.transactionRepository.save(transaction);
+            // 设置事务ID到上下文
             this.contextService.setContext({
                 transactionId: savedTransaction.id,
             });
             return savedTransaction.id;
         });
     }
+    /**
+     * 提交事务
+     */
     commitTransaction(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
             const transaction = yield this.transactionRepository.findOne({
@@ -62,10 +73,13 @@ let TransactionAuditService = class TransactionAuditService {
             if (!transaction) {
                 throw new Error(`Transaction not found: ${transactionId}`);
             }
-            transaction.status = enums_1.TransactionStatus.COMMITTED;
+            transaction.status = enums_1.AuditTransactionStatus.COMMITTED;
             yield this.transactionRepository.save(transaction);
         });
     }
+    /**
+     * 回滚事务（支持多数据库）
+     */
     rollbackTransaction(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
             const transaction = yield this.transactionRepository.findOne({
@@ -74,11 +88,15 @@ let TransactionAuditService = class TransactionAuditService {
             if (!transaction) {
                 throw new Error(`Transaction not found: ${transactionId}`);
             }
+            // 执行回滚操作
             yield this.performRollback(transaction);
-            transaction.status = enums_1.TransactionStatus.ROLLED_BACK;
+            transaction.status = enums_1.AuditTransactionStatus.ROLLED_BACK;
             yield this.transactionRepository.save(transaction);
         });
     }
+    /**
+     * 添加实体到事务
+     */
     addEntityToTransaction(transactionId, entityType, entityId, operation) {
         return __awaiter(this, void 0, void 0, function* () {
             const transaction = yield this.transactionRepository.findOne({
@@ -95,24 +113,35 @@ let TransactionAuditService = class TransactionAuditService {
             yield this.transactionRepository.save(transaction);
         });
     }
+    /**
+     * 执行回滚（支持多数据库）
+     */
     performRollback(transaction) {
         return __awaiter(this, void 0, void 0, function* () {
+            // 按相反顺序回滚实体
             const reversedEntities = [...transaction.entities].reverse();
+            // 按数据库连接分组
             const entitiesByConnection = yield this.groupEntitiesByConnection(reversedEntities);
+            // 对每个数据库连接执行回滚
             for (const [connectionName, entities] of Object.entries(entitiesByConnection)) {
                 yield this.rollbackEntitiesInConnection(connectionName, entities);
             }
         });
     }
+    /**
+     * 按数据库连接分组实体
+     */
     groupEntitiesByConnection(entities) {
         return __awaiter(this, void 0, void 0, function* () {
             const grouped = {};
+            // 获取所有监听的连接
             const monitoredConnections = this.multiDbService.getMonitoredConnections();
+            // 尝试确定每个实体属于哪个连接
             for (const entity of entities) {
                 let connectionFound = false;
                 for (const connectionName of monitoredConnections) {
                     try {
-                        const dataSource = yield this.multiDbService.getDataSource(connectionName);
+                        const dataSource = (0, transaction_1.getDataSource)(connectionName);
                         const metadata = dataSource.getMetadata(entity.entityType);
                         if (metadata) {
                             if (!grouped[connectionName]) {
@@ -124,9 +153,11 @@ let TransactionAuditService = class TransactionAuditService {
                         }
                     }
                     catch (error) {
+                        // 继续尝试下一个连接
                         continue;
                     }
                 }
+                // 如果没有找到连接，使用默认连接
                 if (!connectionFound) {
                     const defaultConnection = 'default';
                     if (!grouped[defaultConnection]) {
@@ -138,9 +169,13 @@ let TransactionAuditService = class TransactionAuditService {
             return grouped;
         });
     }
+    /**
+     * 在指定连接中回滚实体
+     */
     rollbackEntitiesInConnection(connectionName, entities) {
         return __awaiter(this, void 0, void 0, function* () {
-            const dataSource = yield this.multiDbService.getDataSource(connectionName);
+            const dataSource = (0, transaction_1.getDataSource)(connectionName);
+            // 使用事务执行回滚
             yield dataSource.transaction((manager) => __awaiter(this, void 0, void 0, function* () {
                 for (const entity of entities) {
                     try {
@@ -154,26 +189,34 @@ let TransactionAuditService = class TransactionAuditService {
             }));
         });
     }
+    /**
+     * 回滚单个实体
+     */
     rollbackSingleEntity(manager, entity, connectionName) {
         return __awaiter(this, void 0, void 0, function* () {
             const repository = manager.getRepository(entity.entityType);
             switch (entity.operation) {
                 case enums_1.AuditOperation.CREATE:
+                    // 创建操作回滚：删除实体
                     yield repository.delete({ id: entity.entityId });
                     break;
                 case enums_1.AuditOperation.UPDATE:
+                    // 更新操作回滚：恢复到之前的值
+                    // 需要从审计日志中获取之前的值
                     const auditLog = yield this.getLatestAuditLog(entity.entityType, entity.entityId);
                     if (auditLog && auditLog.oldValue) {
                         yield repository.update({ id: entity.entityId }, auditLog.oldValue);
                     }
                     break;
                 case enums_1.AuditOperation.DELETE:
+                    // 删除操作回滚：恢复实体
                     const deletedAuditLog = yield this.getLatestAuditLog(entity.entityType, entity.entityId);
                     if (deletedAuditLog && deletedAuditLog.oldValue) {
                         yield repository.save(deletedAuditLog.oldValue);
                     }
                     break;
                 case enums_1.AuditOperation.RESTORE:
+                    // 恢复操作回滚：撤销恢复
                     const restoreAuditLog = yield this.getLatestAuditLog(entity.entityType, entity.entityId);
                     if (restoreAuditLog && restoreAuditLog.oldValue) {
                         yield repository.update({ id: entity.entityId }, restoreAuditLog.oldValue);
@@ -184,8 +227,13 @@ let TransactionAuditService = class TransactionAuditService {
             }
         });
     }
+    /**
+     * 获取最新的审计日志
+     */
     getLatestAuditLog(entityType, entityId) {
         return __awaiter(this, void 0, void 0, function* () {
+            // 这里需要从审计服务获取
+            // 由于循环依赖，这里简化实现
             return null;
         });
     }

package/audit/subscribers/entity-audit.subscriber.d.ts

@@ -2,13 +2,33 @@ import { EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent, DataS
 import { EntityAuditService } from '../services/entity-audit.service';
 import { AuditContextService } from '../services/audit-context.service';
 import { DefaultAuditStrategy } from '../services/audit-strategy.service';
+/**
+ * 实体审计订阅者
+ */
 export declare class EntityAuditSubscriber implements EntitySubscriberInterface<any> {
     private readonly entityAuditService;
     private readonly contextService;
     private readonly auditStrategy;
+    private readonly logger;
     constructor(entityAuditService: EntityAuditService, contextService: AuditContextService, auditStrategy: DefaultAuditStrategy, dataSource: DataSource);
+    /**
+     * 在实体插入后记录审计日志
+     */
     afterInsert(event: InsertEvent<any>): Promise<void>;
+    /**
+     * 在实体更新后记录审计日志
+     */
     afterUpdate(event: UpdateEvent<any>): Promise<void>;
+    /**
+     * 在实体删除前记录审计日志
+     */
     beforeRemove(event: RemoveEvent<any>): Promise<void>;
+    /**
+     * 计算变更字段
+     */
+    private calculateChangedFields;
+    /**
+     * 检查是否启用了审计
+     */
     private isAuditEnabled;
 }