@nest-omni/core 4.1.3-1 → 4.1.3-11

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

@@ -26,33 +26,57 @@ const common_1 = require("@nestjs/common");
 const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
 const entities_1 = require("../entities");
+/**
+ * 操作描述服务
+ * 负责根据模板和参数动态生成多语言描述
+ */
 let OperationDescriptionService = class OperationDescriptionService {
     constructor(templateRepository, transactionRepository, auditLogRepository, manualOperationRepository) {
         this.templateRepository = templateRepository;
         this.transactionRepository = transactionRepository;
         this.auditLogRepository = auditLogRepository;
         this.manualOperationRepository = manualOperationRepository;
+        // 模板缓存
         this.templateCache = new Map();
     }
+    /**
+     * 动态生成操作名称
+     * @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 +91,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 +124,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 +135,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 +154,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 +165,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,6 +174,12 @@ let OperationDescriptionService = class OperationDescriptionService {
             };
         });
     }
+    /**
+     * 批量获取事务描述
+     * @param transactionIds 事务ID列表
+     * @param language 语言
+     * @returns 事务描述映射
+     */
     batchGetTransactionDescriptions(transactionIds_1) {
         return __awaiter(this, arguments, void 0, function* (transactionIds, language = 'zh') {
             const results = {};
@@ -143,16 +188,24 @@ let OperationDescriptionService = class OperationDescriptionService {
                     results[transactionId] = yield this.getTransactionDescription(transactionId, language);
                 }
                 catch (error) {
+                    // 忽略错误，继续处理其他事务
                     console.error(`Failed to get description for transaction ${transactionId}:`, 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 +214,12 @@ let OperationDescriptionService = class OperationDescriptionService {
         }
         return result;
     }
+    /**
+     * 格式化显示值
+     * @param value 原始值
+     * @param displayValue 显示值
+     * @returns 格式化后的值
+     */
     formatDisplayValue(value, displayValue) {
         if (displayValue !== undefined) {
             return displayValue;
@@ -170,23 +229,38 @@ 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 },
             });
             if (template) {
+                // 缓存模板
                 this.templateCache.set(templateKey, template);
             }
             return template;
         });
     }
+    /**
+     * 清除模板缓存
+     */
     clearTemplateCache() {
         this.templateCache.clear();
     }
+    /**
+     * 预加载模板到缓存
+     * @param templateKeys 模板键列表
+     */
     preloadTemplates(templateKeys) {
         return __awaiter(this, void 0, void 0, function* () {
             const templates = yield this.templateRepository

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,9 @@ 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");
+/**
+ * 事务审计服务
+ */
 let TransactionAuditService = class TransactionAuditService {
     constructor(transactionRepository, contextService, auditService, multiDbService) {
         this.transactionRepository = transactionRepository;
@@ -37,6 +40,9 @@ 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();
@@ -48,12 +54,16 @@ let TransactionAuditService = class TransactionAuditService {
                 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({
@@ -66,6 +76,9 @@ let TransactionAuditService = class TransactionAuditService {
             yield this.transactionRepository.save(transaction);
         });
     }
+    /**
+     * 回滚事务（支持多数据库）
+     */
     rollbackTransaction(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
             const transaction = yield this.transactionRepository.findOne({
@@ -74,11 +87,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;
             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,19 +112,30 @@ 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) {
@@ -124,9 +152,11 @@ let TransactionAuditService = class TransactionAuditService {
                         }
                     }
                     catch (error) {
+                        // 继续尝试下一个连接
                         continue;
                     }
                 }
+                // 如果没有找到连接，使用默认连接
                 if (!connectionFound) {
                     const defaultConnection = 'default';
                     if (!grouped[defaultConnection]) {
@@ -138,9 +168,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);
+            // 使用事务执行回滚
             yield dataSource.transaction((manager) => __awaiter(this, void 0, void 0, function* () {
                 for (const entity of entities) {
                     try {
@@ -154,26 +188,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 +226,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,28 @@ 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;
     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 isAuditEnabled;
 }

package/audit/subscribers/entity-audit.subscriber.js

@@ -26,6 +26,9 @@ const audit_context_service_1 = require("../services/audit-context.service");
 const audit_strategy_service_1 = require("../services/audit-strategy.service");
 const enums_1 = require("../enums");
 const decorators_1 = require("../decorators");
+/**
+ * 实体审计订阅者
+ */
 let EntityAuditSubscriber = class EntityAuditSubscriber {
     constructor(entityAuditService, contextService, auditStrategy, dataSource) {
         this.entityAuditService = entityAuditService;
@@ -33,6 +36,9 @@ let EntityAuditSubscriber = class EntityAuditSubscriber {
         this.auditStrategy = auditStrategy;
         dataSource.subscribers.push(this);
     }
+    /**
+     * 在实体插入后记录审计日志
+     */
     afterInsert(event) {
         return __awaiter(this, void 0, void 0, function* () {
             const entity = event.entity;
@@ -40,14 +46,18 @@ let EntityAuditSubscriber = class EntityAuditSubscriber {
                 return;
             const entityType = entity.constructor.name;
             const entityId = entity.id;
+            // 检查是否启用了审计
             if (!this.isAuditEnabled(entity)) {
                 return;
             }
+            // 检查策略
             if (!this.auditStrategy.shouldRecord(entityType, enums_1.AuditOperation.CREATE)) {
                 return;
             }
             try {
+                // 获取上下文信息
                 const context = yield this.contextService.getCurrentContext();
+                // 记录审计日志
                 yield this.entityAuditService.logEntityChange(entityType, entityId, enums_1.AuditOperation.CREATE, {}, entity, {
                     requestId: context.requestId,
                     requestIp: context.requestIp,
@@ -59,6 +69,9 @@ let EntityAuditSubscriber = class EntityAuditSubscriber {
             }
         });
     }
+    /**
+     * 在实体更新后记录审计日志
+     */
     afterUpdate(event) {
         return __awaiter(this, void 0, void 0, function* () {
             const entity = event.entity;
@@ -67,14 +80,18 @@ let EntityAuditSubscriber = class EntityAuditSubscriber {
                 return;
             const entityType = entity.constructor.name;
             const entityId = entity.id;
+            // 检查是否启用了审计
             if (!this.isAuditEnabled(entity)) {
                 return;
             }
+            // 检查策略
             if (!this.auditStrategy.shouldRecord(entityType, enums_1.AuditOperation.UPDATE)) {
                 return;
             }
             try {
+                // 获取上下文信息
                 const context = yield this.contextService.getCurrentContext();
+                // 记录审计日志
                 yield this.entityAuditService.logEntityChange(entityType, entityId, enums_1.AuditOperation.UPDATE, databaseEntity || {}, entity, {
                     requestId: context.requestId,
                     requestIp: context.requestIp,
@@ -86,6 +103,9 @@ let EntityAuditSubscriber = class EntityAuditSubscriber {
             }
         });
     }
+    /**
+     * 在实体删除前记录审计日志
+     */
     beforeRemove(event) {
         return __awaiter(this, void 0, void 0, function* () {
             const entity = event.entity;
@@ -93,14 +113,18 @@ let EntityAuditSubscriber = class EntityAuditSubscriber {
                 return;
             const entityType = entity.constructor.name;
             const entityId = entity.id;
+            // 检查是否启用了审计
             if (!this.isAuditEnabled(entity)) {
                 return;
             }
+            // 检查策略
             if (!this.auditStrategy.shouldRecord(entityType, enums_1.AuditOperation.DELETE)) {
                 return;
             }
             try {
+                // 获取上下文信息
                 const context = yield this.contextService.getCurrentContext();
+                // 记录审计日志
                 yield this.entityAuditService.logEntityChange(entityType, entityId, enums_1.AuditOperation.DELETE, entity, {}, {
                     requestId: context.requestId,
                     requestIp: context.requestIp,
@@ -112,8 +136,12 @@ let EntityAuditSubscriber = class EntityAuditSubscriber {
             }
         });
     }
+    /**
+     * 检查是否启用了审计
+     */
     isAuditEnabled(entity) {
         try {
+            // 检查装饰器
             const auditOptions = Reflect.getMetadata(decorators_1.ENTITY_AUDIT_OPTIONS, entity.constructor);
             if (auditOptions && auditOptions.enabled === false) {
                 return false;
@@ -121,7 +149,7 @@ let EntityAuditSubscriber = class EntityAuditSubscriber {
             return true;
         }
         catch (error) {
-            return true;
+            return true; // 默认启用
         }
     }
 };