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

package/{audit → dist/audit}/index.d.ts

@@ -2,9 +2,10 @@ export * from './entities';
 export * from './enums';
 export * from './interfaces';
 export * from './dto';
-export { AuditEntity, AuditField, getEntityAuditConfig, getFieldAuditConfig, getFieldLabel, getFieldValueLabel, ENTITY_AUDIT_OPTIONS, FIELD_AUDIT_OPTIONS, } from './decorators/entity-audit.decorator';
+export { AuditEntity, AuditField, getEntityAuditConfig, getFieldAuditConfig, getFieldLabel, getFieldValueLabel, getEntityLabel, ENTITY_AUDIT_OPTIONS, FIELD_AUDIT_OPTIONS, } from './decorators/entity-audit.decorator';
 export { AuditController, AuditMethod, CONTROLLER_AUDIT_OPTIONS, METHOD_AUDIT_OPTIONS, } from './decorators/audit-controller.decorator';
 export { AuditLog, getAuditOperationConfig, hasAuditOperation, AUDIT_OPERATION_OPTIONS, } from './decorators/audit-operation.decorator';
+export { AuditAction, AuditActionOptions, AuditActionMetadata, AUDIT_ACTION_METADATA, } from './decorators/audit-action.decorator';
 export * from './services';
 export * from './subscribers';
 export * from './interceptors';

package/{audit → dist/audit}/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUDIT_OPERATION_OPTIONS = exports.hasAuditOperation = exports.getAuditOperationConfig = exports.AuditLog = exports.METHOD_AUDIT_OPTIONS = exports.CONTROLLER_AUDIT_OPTIONS = exports.AuditMethod = exports.AuditController = exports.FIELD_AUDIT_OPTIONS = exports.ENTITY_AUDIT_OPTIONS = exports.getFieldValueLabel = exports.getFieldLabel = exports.getFieldAuditConfig = exports.getEntityAuditConfig = exports.AuditField = exports.AuditEntity = void 0;
+exports.AUDIT_ACTION_METADATA = exports.AuditAction = exports.AUDIT_OPERATION_OPTIONS = exports.hasAuditOperation = exports.getAuditOperationConfig = exports.AuditLog = exports.METHOD_AUDIT_OPTIONS = exports.CONTROLLER_AUDIT_OPTIONS = exports.AuditMethod = exports.AuditController = exports.FIELD_AUDIT_OPTIONS = exports.ENTITY_AUDIT_OPTIONS = exports.getEntityLabel = exports.getFieldValueLabel = exports.getFieldLabel = exports.getFieldAuditConfig = exports.getEntityAuditConfig = exports.AuditField = exports.AuditEntity = void 0;
 // Entities
 __exportStar(require("./entities"), exports);
 // Enums
@@ -31,6 +31,7 @@ Object.defineProperty(exports, "getEntityAuditConfig", { enumerable: true, get:
 Object.defineProperty(exports, "getFieldAuditConfig", { enumerable: true, get: function () { return entity_audit_decorator_1.getFieldAuditConfig; } });
 Object.defineProperty(exports, "getFieldLabel", { enumerable: true, get: function () { return entity_audit_decorator_1.getFieldLabel; } });
 Object.defineProperty(exports, "getFieldValueLabel", { enumerable: true, get: function () { return entity_audit_decorator_1.getFieldValueLabel; } });
+Object.defineProperty(exports, "getEntityLabel", { enumerable: true, get: function () { return entity_audit_decorator_1.getEntityLabel; } });
 Object.defineProperty(exports, "ENTITY_AUDIT_OPTIONS", { enumerable: true, get: function () { return entity_audit_decorator_1.ENTITY_AUDIT_OPTIONS; } });
 Object.defineProperty(exports, "FIELD_AUDIT_OPTIONS", { enumerable: true, get: function () { return entity_audit_decorator_1.FIELD_AUDIT_OPTIONS; } });
 var audit_controller_decorator_1 = require("./decorators/audit-controller.decorator");
@@ -43,6 +44,9 @@ Object.defineProperty(exports, "AuditLog", { enumerable: true, get: function ()
 Object.defineProperty(exports, "getAuditOperationConfig", { enumerable: true, get: function () { return audit_operation_decorator_1.getAuditOperationConfig; } });
 Object.defineProperty(exports, "hasAuditOperation", { enumerable: true, get: function () { return audit_operation_decorator_1.hasAuditOperation; } });
 Object.defineProperty(exports, "AUDIT_OPERATION_OPTIONS", { enumerable: true, get: function () { return audit_operation_decorator_1.AUDIT_OPERATION_OPTIONS; } });
+var audit_action_decorator_1 = require("./decorators/audit-action.decorator");
+Object.defineProperty(exports, "AuditAction", { enumerable: true, get: function () { return audit_action_decorator_1.AuditAction; } });
+Object.defineProperty(exports, "AUDIT_ACTION_METADATA", { enumerable: true, get: function () { return audit_action_decorator_1.AUDIT_ACTION_METADATA; } });
 // Services
 __exportStar(require("./services"), exports);
 // Subscribers

package/dist/audit/interceptors/audit-action.interceptor.d.ts

@@ -0,0 +1,38 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { Repository } from 'typeorm';
+import { AuditContextService } from '../services/audit-context.service';
+import { OperationDescriptionService } from '../services/operation-description.service';
+import { AuditActionSummaryEntity } from '../entities';
+/**
+ * 审计动作拦截器
+ * 在请求开始时创建审计动作上下文，在请求结束时生成汇总记录
+ */
+export declare class AuditActionInterceptor implements NestInterceptor {
+    private readonly reflector;
+    private readonly contextService;
+    private readonly summaryRepository;
+    private readonly descriptionService?;
+    constructor(reflector: Reflector, contextService: AuditContextService, summaryRepository: Repository<AuditActionSummaryEntity>, descriptionService?: OperationDescriptionService);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    /**
+     * 生成审计汇总记录
+     */
+    private generateSummary;
+    /**
+     * 生成操作描述文本
+     * 优先从 OperationDescriptionService 获取多语言模板
+     * 如果没有，则使用默认格式
+     */
+    private generateDescription;
+    /**
+     * 替换模板中的占位符
+     * 支持格式：{key} 或 {key:format}
+     */
+    private replaceTemplatePlaceholders;
+    /**
+     * 格式化值为字符串
+     */
+    private formatValue;
+}

package/dist/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/dist/audit/interceptors/index.d.ts

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

package/{audit → dist/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 → dist/audit}/interfaces/audit.interfaces.d.ts

@@ -146,16 +146,21 @@ export interface EntityAuditConfig {
     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;
-    /**
-     * @deprecated 使用 maskFields 代替
-     * 敏感字段列表（别名，用于兼容旧版本）
-     */
-    sensitiveFields?: string[];
 }
 /**
  * 操作级别审计配置

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

@@ -0,0 +1,141 @@
+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;
+    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;
+}