@nest-omni/core 4.1.3-3 → 4.1.3-31

package/audit/interceptors/audit-action.interceptor.js

@@ -0,0 +1,217 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var AuditActionInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditActionInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const audit_context_service_1 = require("../services/audit-context.service");
+const operation_description_service_1 = require("../services/operation-description.service");
+const entities_1 = require("../entities");
+const audit_action_decorator_1 = require("../decorators/audit-action.decorator");
+/**
+ * 审计动作拦截器
+ * 在请求开始时创建审计动作上下文，在请求结束时生成汇总记录
+ */
+let AuditActionInterceptor = AuditActionInterceptor_1 = class AuditActionInterceptor {
+    constructor(reflector, contextService, summaryRepository, descriptionService) {
+        this.reflector = reflector;
+        this.contextService = contextService;
+        this.summaryRepository = summaryRepository;
+        this.descriptionService = descriptionService;
+        this.logger = new common_1.Logger(AuditActionInterceptor_1.name);
+    }
+    intercept(context, next) {
+        // 获取装饰器元数据
+        const metadata = this.reflector.get(audit_action_decorator_1.AUDIT_ACTION_METADATA, context.getHandler());
+        // 如果没有 @AuditAction 装饰器或已禁用，直接放行
+        if (!metadata || metadata.options.enabled === false) {
+            return next.handle();
+        }
+        const request = context.switchToHttp().getRequest();
+        const actionId = this.contextService.generateActionId();
+        const startTime = new Date();
+        // 创建审计动作上下文
+        const actionContext = {
+            actionId,
+            actionName: metadata.actionName,
+            operationTemplateKey: metadata.options.templateKey,
+            paramsBuilder: metadata.options.paramsBuilder,
+            startTime,
+            entityChanges: [],
+            detailedChanges: [],
+            req: request,
+        };
+        // 设置到 CLS
+        this.contextService.setActionContext(actionContext);
+        return next.handle().pipe((0, operators_1.tap)((result) => __awaiter(this, void 0, void 0, function* () {
+            // 请求成功，记录结果
+            actionContext.result = result;
+            yield this.generateSummary(actionContext, metadata, false);
+        })), (0, operators_1.catchError)((error) => __awaiter(this, void 0, void 0, function* () {
+            // 请求失败，记录错误
+            actionContext.error = error;
+            yield this.generateSummary(actionContext, metadata, true, error);
+            return (0, rxjs_1.throwError)(() => error);
+        })));
+    }
+    /**
+     * 生成审计汇总记录
+     */
+    generateSummary(actionContext, metadata, hasError, error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const duration = Date.now() - actionContext.startTime.getTime();
+                const auditContext = yield this.contextService.getCurrentContext();
+                // 构建描述参数
+                let descriptionParams = {};
+                if (metadata.options.paramsBuilder) {
+                    const paramsContext = this.contextService.buildParamsContext();
+                    if (paramsContext) {
+                        descriptionParams = metadata.options.paramsBuilder(paramsContext);
+                    }
+                }
+                // 生成描述文本
+                const description = yield this.generateDescription(actionContext.operationTemplateKey, actionContext.actionName, descriptionParams, !hasError);
+                // 统计实体类型和操作
+                const entityTypes = Array.from(new Set(actionContext.detailedChanges.map((c) => c.entityType)));
+                const operationStats = {};
+                actionContext.detailedChanges.forEach((change) => {
+                    const op = change.operation;
+                    operationStats[op] = (operationStats[op] || 0) + 1;
+                });
+                // 创建汇总记录
+                const summary = this.summaryRepository.create({
+                    id: actionContext.actionId,
+                    actionName: actionContext.actionName,
+                    operationTemplateKey: actionContext.operationTemplateKey,
+                    descriptionParams,
+                    description,
+                    requestId: auditContext.requestId || '',
+                    userId: auditContext.userId || '',
+                    username: auditContext.username || '',
+                    requestIp: auditContext.requestIp || '',
+                    userAgent: auditContext.userAgent || '',
+                    entityChangesCount: actionContext.detailedChanges.length,
+                    entityTypes,
+                    operationStats,
+                    success: !hasError,
+                    errorMessage: error === null || error === void 0 ? void 0 : error.message,
+                    duration,
+                    metadata: metadata.options.metadata,
+                });
+                yield this.summaryRepository.save(summary);
+            }
+            catch (err) {
+                this.logger.error(`Failed to generate audit action summary: ${err.message}`, err.stack);
+            }
+            finally {
+                // 清除审计动作上下文
+                this.contextService.clearActionContext();
+            }
+        });
+    }
+    /**
+     * 生成操作描述文本
+     * 优先从 OperationDescriptionService 获取多语言模板
+     * 如果没有，则使用默认格式
+     */
+    generateDescription(templateKey, actionName, params, success) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let template;
+            // 1. 尝试从模板服务获取模板
+            if (templateKey && this.descriptionService) {
+                try {
+                    template = yield this.descriptionService.getTemplate(templateKey);
+                }
+                catch (error) {
+                    // 如果获取模板失败，继续使用默认逻辑
+                }
+            }
+            // 2. 如果没有模板，使用默认格式
+            if (!template) {
+                template = success
+                    ? `执行操作: ${actionName}`
+                    : `执行操作失败: ${actionName}`;
+            }
+            // 3. 执行模板替换
+            return this.replaceTemplatePlaceholders(template, params);
+        });
+    }
+    /**
+     * 替换模板中的占位符
+     * 支持格式：{key} 或 {key:format}
+     */
+    replaceTemplatePlaceholders(template, params) {
+        let result = template;
+        // 遍历所有参数，替换占位符
+        Object.entries(params).forEach(([key, value]) => {
+            const placeholder = `{${key}}`;
+            const valueStr = this.formatValue(value);
+            // 替换所有匹配的占位符
+            const regex = new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g');
+            result = result.replace(regex, valueStr);
+        });
+        // 清理未替换的占位符
+        result = result.replace(/\{[^}]+\}/g, '');
+        return result;
+    }
+    /**
+     * 格式化值为字符串
+     */
+    formatValue(value) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (Array.isArray(value)) {
+            // 处理数组
+            if (value.length === 0) {
+                return '';
+            }
+            // 如果是对象数组，序列化
+            if (typeof value[0] === 'object') {
+                return JSON.stringify(value);
+            }
+            // 否则用顿号连接
+            return value.join('、');
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    }
+};
+exports.AuditActionInterceptor = AuditActionInterceptor;
+exports.AuditActionInterceptor = AuditActionInterceptor = AuditActionInterceptor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Inject)((0, typeorm_1.getRepositoryToken)(entities_1.AuditActionSummaryEntity))),
+    __param(3, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [core_1.Reflector,
+        audit_context_service_1.AuditContextService,
+        typeorm_2.Repository,
+        operation_description_service_1.OperationDescriptionService])
+], AuditActionInterceptor);

package/audit/interceptors/audit.interceptor.d.ts

@@ -6,6 +6,7 @@ import { AuditContextService } from '../services/audit-context.service';
  */
 export declare class AuditInterceptor implements NestInterceptor {
     private readonly contextService;
+    private readonly logger;
     constructor(contextService: AuditContextService);
     intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
     /**

package/audit/interceptors/audit.interceptor.js

@@ -17,6 +17,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var AuditInterceptor_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuditInterceptor = void 0;
 const common_1 = require("@nestjs/common");
@@ -27,9 +28,10 @@ const decorators_1 = require("../decorators");
 /**
  * 审计拦截器
  */
-let AuditInterceptor = class AuditInterceptor {
+let AuditInterceptor = AuditInterceptor_1 = class AuditInterceptor {
     constructor(contextService) {
         this.contextService = contextService;
+        this.logger = new common_1.Logger(AuditInterceptor_1.name);
     }
     intercept(context, next) {
         const request = context.switchToHttp().getRequest();
@@ -70,16 +72,22 @@ let AuditInterceptor = class AuditInterceptor {
      */
     handleError(error, request) {
         return __awaiter(this, void 0, void 0, function* () {
-            // 记录错误信息到上下文
-            this.contextService.setContext({
-                metadata: {
-                    error: {
-                        message: error.message,
-                        stack: error.stack,
-                        status: error.status,
+            try {
+                // 记录错误信息到上下文
+                this.contextService.setContext({
+                    metadata: {
+                        error: {
+                            message: error.message,
+                            stack: error.stack,
+                            status: error.status,
+                        },
                     },
-                },
-            });
+                });
+            }
+            catch (contextError) {
+                // 不影响请求处理，只记录日志
+                this.logger.warn(`Failed to set error context: ${contextError.message}`);
+            }
         });
     }
     /**
@@ -111,7 +119,7 @@ let AuditInterceptor = class AuditInterceptor {
     }
 };
 exports.AuditInterceptor = AuditInterceptor;
-exports.AuditInterceptor = AuditInterceptor = __decorate([
+exports.AuditInterceptor = AuditInterceptor = AuditInterceptor_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [audit_context_service_1.AuditContextService])
 ], AuditInterceptor);

package/audit/interceptors/index.d.ts

@@ -1 +1,2 @@
 export * from './audit.interceptor';
+export * from './audit-action.interceptor';

package/audit/interceptors/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./audit.interceptor"), exports);
+__exportStar(require("./audit-action.interceptor"), exports);

package/audit/interfaces/audit.interfaces.d.ts

@@ -1,4 +1,4 @@
-import { AuditOperation, MaskingStrategy, RecordStrategy } from '../enums/audit.enums';
+import { AuditOperation, MaskingStrategy, RecordStrategy, ChangeType } from '../enums/audit.enums';
 /**
  * 审计上下文
  */
@@ -113,8 +113,6 @@ export interface AuditConfig {
     entities?: Record<string, EntityAuditConfig>;
     operations?: Record<string, OperationAuditConfig>;
     security?: {
-        hashChainEnabled?: boolean;
-        hashAlgorithm?: string;
         masking?: {
             defaultStrategy?: MaskingStrategy;
             strategies?: Record<string, MaskingStrategy>;
@@ -124,12 +122,43 @@ export interface AuditConfig {
 /**
  * 实体级别审计配置
  */
+/**
+ * 实体审计配置
+ *
+ * @description
+ * 支持基础审计配置
+ *
+ * @example
+ * ```typescript
+ * @EntityAudit({
+ *   enabled: true,
+ *   excludeFields: ['password'],
+ *   maskFields: ['email', 'phone'],
+ *   templateKey: 'user',
+ * })
+ * ```
+ */
 export interface EntityAuditConfig {
     enabled?: boolean;
     strategy?: RecordStrategy;
     includeFields?: string[];
     excludeFields?: string[];
     maskFields?: string[];
+    /**
+     * 实体标签（支持多语言）
+     * @example
+     * // 单语言
+     * label: '订单'
+     *
+     * // 多语言
+     * label: { zh: '订单', en: 'Order', ja: '注文' }
+     */
+    label?: string | Record<string, string>;
+    /**
+     * 操作模板键前缀
+     * @example 'user' -> 生成 'user.create', 'user.update', 'user.delete'
+     */
+    templateKey?: string;
 }
 /**
  * 操作级别审计配置
@@ -142,7 +171,25 @@ export interface OperationAuditConfig {
  * 字段显示选项
  */
 export interface FieldDisplayOptions {
-    displayName?: string;
+    /**
+     * 字段标签（支持多语言）
+     * @example
+     * // 单语言
+     * label: '姓名'
+     *
+     * // 多语言
+     * label: { zh: '姓名', en: 'Name' }
+     */
+    label?: string | Record<string, string>;
+    /**
+     * 字段值的多语言标签映射
+     * @example
+     * valueLabels: {
+     *   active: { zh: '激活', en: 'Active' },
+     *   inactive: { zh: '未激活', en: 'Inactive' }
+     * }
+     */
+    valueLabels?: Record<string, Record<string, string>>;
     sensitive?: boolean;
     formatter?: (value: any) => string;
 }
@@ -159,3 +206,84 @@ export interface ControllerAuditOptions {
 export interface MethodAuditOptions {
     enabled?: boolean;
 }
+/**
+ * 变更详情
+ */
+export interface ChangeDetail {
+    fieldName: string;
+    fieldLabels?: Record<string, string>;
+    oldValue: any;
+    newValue: any;
+    displayOldValue?: Record<string, string>;
+    displayNewValue?: Record<string, string>;
+    changeType: ChangeType;
+}
+/**
+ * 操作模板配置（用于数据库存储）
+ */
+export interface OperationTemplateData {
+    key: string;
+    entityName: string;
+    operation: AuditOperation;
+    nameTemplates: Record<string, string>;
+    descriptionTemplates: Record<string, string>;
+    fieldLabels?: Record<string, Record<string, string>>;
+    valueDisplays?: Record<string, Record<string, Record<string, string>>>;
+}
+/**
+ * 手动操作日志数据
+ */
+export interface ManualOperationData {
+    transactionId: string;
+    operationTemplateKey: string;
+    descriptionParams: Record<string, any>;
+    userId?: string;
+    username?: string;
+    requestIp?: string;
+}
+/**
+ * 手动日志记录选项（支持三种模式）
+ */
+export interface ManualLogOptions {
+    templateKey?: string;
+    descriptionParams?: Record<string, any>;
+    description?: string | Record<string, string>;
+    descriptionTemplate?: Record<string, string>;
+    userId?: string;
+    username?: string;
+    requestIp?: string;
+    transactionId?: string;
+    autoCreateTransaction?: boolean;
+}
+/**
+ * 方法审计选项（支持模板）
+ */
+export interface AuditOperationOptions {
+    templateKey: string;
+    descriptionParams?: (args: any[], result: any, context: any) => Record<string, any>;
+    autoTransaction?: boolean;
+}
+/**
+ * 增强的实体审计配置（支持多语言）
+ */
+export interface EnhancedEntityAuditConfig extends EntityAuditConfig {
+    templateKey?: string;
+    fieldLabels?: Record<string, Record<string, string>>;
+    valueDisplays?: Record<string, Record<string, Record<string, string>>>;
+}
+/**
+ * 事务描述结果
+ */
+export interface TransactionDescription {
+    operationName: string;
+    description: string;
+    changes: Array<{
+        entityName?: string;
+        entityId?: string;
+        operation?: AuditOperation;
+        type?: string;
+        description: string;
+        details: any;
+        createdAt: Date;
+    }>;
+}

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

@@ -0,0 +1,142 @@
+import { AuditContextService } from './audit-context.service';
+import { EntityAuditService } from './entity-audit.service';
+import { AuditOperation } from '../enums';
+/**
+ * 审计动作选项
+ */
+export interface AuditActionOptions {
+    /**
+     * 动作名称，如 'createOrder', 'updateUser'
+     */
+    actionName: string;
+    /**
+     * 操作模板键（可选）
+     * @example 'order.create'
+     */
+    operationTemplateKey?: string;
+    /**
+     * 描述参数，用于模板填充
+     * @example { productCount: 3, receiver: '张三', totalAmount: 299.99 }
+     */
+    descriptionParams?: Record<string, any>;
+    /**
+     * 自定义元数据
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * 审计动作结果
+ */
+export interface AuditActionResult {
+    actionId: string;
+    actionName: string;
+    entityChanges: Array<{
+        entityType: string;
+        entityId: string;
+        operation: string;
+        sequence: number;
+    }>;
+    duration: number;
+    success: boolean;
+    error?: Error;
+}
+/**
+ * 审计动作服务
+ * 提供声明式的审计动作管理，自动关联同一业务操作的所有实体变化
+ */
+export declare class AuditActionService {
+    private readonly contextService;
+    private readonly auditService;
+    private readonly logger;
+    constructor(contextService: AuditContextService, auditService: EntityAuditService);
+    /**
+     * 在审计动作上下文中执行操作
+     * 自动关联该动作内的所有实体变化
+     *
+     * @example
+     * ```typescript
+     * const result = await auditActionService.executeAction(
+     *   {
+     *     actionName: 'createOrder',
+     *     operationTemplateKey: 'order.create',
+     *     descriptionParams: {
+     *       productCount: orderItems.length,
+     *       receiver: order.receiverName,
+     *       totalAmount: order.totalAmount,
+     *       address: order.shippingAddress,
+     *     },
+     *   },
+     *   async () => {
+     *     // 1. 创建订单
+     *     const order = await this.orderRepository.save(newOrder);
+     *
+     *     // 2. 创建订单项
+     *     await this.orderItemRepository.save(orderItems);
+     *
+     *     // 3. 扣减库存
+     *     await this.inventoryService.deduct(orderItems);
+     *
+     *     // 4. 创建物流信息
+     *     await this.shippingService.create(order.id);
+     *
+     *     return order;
+     *   }
+     * );
+     *
+     * // 结果中包含所有实体变化：
+     * // result.entityChanges = [
+     * //   { entityType: 'Order', entityId: '1', operation: 'CREATE', sequence: 1 },
+     * //   { entityType: 'OrderItem', entityId: '1', operation: 'CREATE', sequence: 2 },
+     * //   { entityType: 'OrderItem', entityId: '2', operation: 'CREATE', sequence: 3 },
+     * //   { entityType: 'Inventory', entityId: '1', operation: 'UPDATE', sequence: 4 },
+     * //   { entityType: 'Shipping', entityId: '1', operation: 'CREATE', sequence: 5 },
+     * // ]
+     * ```
+     */
+    executeAction<T>(options: AuditActionOptions, operation: () => Promise<T>): Promise<AuditActionResult>;
+    /**
+     * 记录审计动作汇总日志
+     */
+    private recordActionSummary;
+    /**
+     * 获取审计动作的所有实体变化
+     */
+    getActionAuditLogs(actionId: string): Promise<{
+        actionId: string;
+        logs: import("..").EntityAuditLogEntity[];
+        summary: {
+            totalChanges: number;
+            operations: {
+                [k: string]: number;
+            };
+            entities: {
+                [k: string]: number;
+            };
+        };
+    }>;
+    /**
+     * 获取请求内的所有审计动作
+     */
+    getRequestActions(requestId: string): Promise<{
+        requestId: string;
+        actions: {
+            actionId: string;
+            actionName: string;
+            entityChanges: {
+                entityType: string;
+                entityId: string;
+                operation: AuditOperation;
+                sequence: number;
+                timestamp: Date;
+            }[];
+            logs: import("..").EntityAuditLogEntity[];
+        }[];
+        noActionLogs: import("..").EntityAuditLogEntity[];
+        summary: {
+            totalActions: number;
+            totalChanges: number;
+        };
+    }>;
+    private groupByOperation;
+    private groupByEntity;
+}