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

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

@@ -0,0 +1,215 @@
+"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());
+    });
+};
+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 = class AuditActionInterceptor {
+    constructor(reflector, contextService, summaryRepository, descriptionService) {
+        this.reflector = reflector;
+        this.contextService = contextService;
+        this.summaryRepository = summaryRepository;
+        this.descriptionService = descriptionService;
+    }
+    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) {
+                console.error('Failed to generate audit action summary:', err);
+            }
+            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 = __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

@@ -1,12 +1,28 @@
 import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
 import { Observable } from 'rxjs';
 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>;
+    /**
+     * 设置请求上下文
+     */
     private setRequestContext;
+    /**
+     * 处理错误
+     */
     private handleError;
+    /**
+     * 检查是否启用了审计
+     */
     private isAuditEnabled;
+    /**
+     * 生成请求ID
+     */
     private generateRequestId;
 }

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");
@@ -24,24 +25,35 @@ const operators_1 = require("rxjs/operators");
 const crypto_1 = require("crypto");
 const audit_context_service_1 = require("../services/audit-context.service");
 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();
         const handler = context.getHandler();
         const controller = context.getClass();
+        // 检查是否启用了审计
         if (!this.isAuditEnabled(controller, handler)) {
             return next.handle();
         }
+        // 设置请求上下文
         this.setRequestContext(request);
         return next.handle().pipe((0, operators_1.tap)(() => {
+            // 在响应后执行的操作
         }), (0, operators_1.catchError)((error) => __awaiter(this, void 0, void 0, function* () {
+            // 处理错误情况
             yield this.handleError(error, request);
             throw error;
         })));
     }
+    /**
+     * 设置请求上下文
+     */
     setRequestContext(request) {
         var _a, _b, _c;
         const user = request.user || {};
@@ -55,25 +67,40 @@ let AuditInterceptor = class AuditInterceptor {
         };
         this.contextService.setContext(auditContext);
     }
+    /**
+     * 处理错误
+     */
     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}`);
+            }
         });
     }
+    /**
+     * 检查是否启用了审计
+     */
     isAuditEnabled(controller, handler) {
         try {
+            // 检查控制器级别设置
             const controllerMetadata = Reflect.getMetadata(decorators_1.CONTROLLER_AUDIT_OPTIONS, controller);
             if (controllerMetadata && controllerMetadata.enabled === false) {
                 return false;
             }
+            // 检查方法级别设置
             const handlerMetadata = Reflect.getMetadata(decorators_1.METHOD_AUDIT_OPTIONS, handler);
             if (handlerMetadata && handlerMetadata.enabled === false) {
                 return false;
@@ -81,15 +108,18 @@ let AuditInterceptor = class AuditInterceptor {
             return true;
         }
         catch (error) {
-            return true;
+            return true; // 默认启用
         }
     }
+    /**
+     * 生成请求ID
+     */
     generateRequestId() {
         return (0, crypto_1.randomBytes)(16).toString('hex');
     }
 };
 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,7 @@
-import { AuditOperation, MaskingStrategy, RecordStrategy } from '../enums/audit.enums';
+import { AuditOperation, MaskingStrategy, RecordStrategy, ChangeType } from '../enums/audit.enums';
+/**
+ * 审计上下文
+ */
 export interface AuditContext {
     userId?: string;
     username?: string;
@@ -9,16 +12,25 @@ export interface AuditContext {
     transactionId?: string;
     metadata?: Record<string, any>;
 }
+/**
+ * 审计策略接口
+ */
 export interface IAuditStrategy {
     shouldRecord(entityType: string, operation: AuditOperation): boolean;
     getRecordStrategy(entityType: string, operation: AuditOperation): RecordStrategy;
     getFieldFilter(entityType: string): IFieldFilter;
 }
+/**
+ * 字段过滤器接口
+ */
 export interface IFieldFilter {
     shouldIncludeField(fieldName: string, path: string[]): boolean;
     shouldMaskField(fieldName: string, path: string[]): boolean;
     getMaskingStrategy(fieldName: string, path: string[]): MaskingStrategy;
 }
+/**
+ * 实体差异
+ */
 export interface EntityDifference {
     changes: Array<{
         path: string[];
@@ -32,6 +44,9 @@ export interface EntityDifference {
         changed: number;
     };
 }
+/**
+ * 恢复选项
+ */
 export interface RestoreOptions {
     force?: boolean;
     dryRun?: boolean;
@@ -40,6 +55,9 @@ export interface RestoreOptions {
     skipDependencies?: boolean;
     connectionName?: string;
 }
+/**
+ * 恢复结果
+ */
 export interface RestoreResult {
     success: boolean;
     message?: string;
@@ -54,6 +72,9 @@ export interface RestoreResult {
         entityId: string;
     }>;
 }
+/**
+ * 预检查结果
+ */
 export interface PreCheckResult {
     canRestore: boolean;
     conflicts: Array<{
@@ -64,6 +85,9 @@ export interface PreCheckResult {
     }>;
     warnings: string[];
 }
+/**
+ * 批量操作结果
+ */
 export interface BatchOperationResult {
     total: number;
     success: number;
@@ -74,6 +98,9 @@ export interface BatchOperationResult {
     }>;
     results: any[];
 }
+/**
+ * 审计配置
+ */
 export interface AuditConfig {
     enabled?: boolean;
     defaultStrategy?: RecordStrategy;
@@ -86,34 +113,177 @@ export interface AuditConfig {
     entities?: Record<string, EntityAuditConfig>;
     operations?: Record<string, OperationAuditConfig>;
     security?: {
-        hashChainEnabled?: boolean;
-        hashAlgorithm?: string;
         masking?: {
             defaultStrategy?: MaskingStrategy;
             strategies?: Record<string, MaskingStrategy>;
         };
     };
 }
+/**
+ * 实体级别审计配置
+ */
+/**
+ * 实体审计配置
+ *
+ * @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;
 }
+/**
+ * 操作级别审计配置
+ */
 export interface OperationAuditConfig {
     enabled?: boolean;
     strategy?: RecordStrategy;
 }
+/**
+ * 字段显示选项
+ */
 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;
 }
+/**
+ * 控制器审计选项
+ */
 export interface ControllerAuditOptions {
     enabled?: boolean;
     operations?: AuditOperation[];
 }
+/**
+ * 方法审计选项
+ */
 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;
+    }>;
+}