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

package/audit/index.js

@@ -14,13 +14,23 @@ 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 });
+// Entities
 __exportStar(require("./entities"), exports);
+// Enums
 __exportStar(require("./enums"), exports);
+// Interfaces
 __exportStar(require("./interfaces"), exports);
+// DTO
 __exportStar(require("./dto"), exports);
+// Decorators
 __exportStar(require("./decorators"), exports);
+// Services
 __exportStar(require("./services"), exports);
+// Subscribers
 __exportStar(require("./subscribers"), exports);
+// Interceptors
 __exportStar(require("./interceptors"), exports);
+// Controllers
 __exportStar(require("./controllers"), exports);
+// Module
 __exportStar(require("./audit.module"), exports);

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

@@ -1,12 +1,27 @@
 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;
     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

@@ -24,6 +24,9 @@ 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 {
     constructor(contextService) {
         this.contextService = contextService;
@@ -32,16 +35,23 @@ let AuditInterceptor = class AuditInterceptor {
         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,8 +65,12 @@ let AuditInterceptor = class AuditInterceptor {
         };
         this.contextService.setContext(auditContext);
     }
+    /**
+     * 处理错误
+     */
     handleError(error, request) {
         return __awaiter(this, void 0, void 0, function* () {
+            // 记录错误信息到上下文
             this.contextService.setContext({
                 metadata: {
                     error: {
@@ -68,12 +82,17 @@ let AuditInterceptor = class AuditInterceptor {
             });
         });
     }
+    /**
+     * 检查是否启用了审计
+     */
     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,9 +100,12 @@ let AuditInterceptor = class AuditInterceptor {
             return true;
         }
         catch (error) {
-            return true;
+            return true; // 默认启用
         }
     }
+    /**
+     * 生成请求ID
+     */
     generateRequestId() {
         return (0, crypto_1.randomBytes)(16).toString('hex');
     }

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

@@ -1,4 +1,7 @@
 import { AuditOperation, MaskingStrategy, RecordStrategy } 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;
@@ -94,6 +121,9 @@ export interface AuditConfig {
         };
     };
 }
+/**
+ * 实体级别审计配置
+ */
 export interface EntityAuditConfig {
     enabled?: boolean;
     strategy?: RecordStrategy;
@@ -101,19 +131,31 @@ export interface EntityAuditConfig {
     excludeFields?: string[];
     maskFields?: string[];
 }
+/**
+ * 操作级别审计配置
+ */
 export interface OperationAuditConfig {
     enabled?: boolean;
     strategy?: RecordStrategy;
 }
+/**
+ * 字段显示选项
+ */
 export interface FieldDisplayOptions {
     displayName?: string;
     sensitive?: boolean;
     formatter?: (value: any) => string;
 }
+/**
+ * 控制器审计选项
+ */
 export interface ControllerAuditOptions {
     enabled?: boolean;
     operations?: AuditOperation[];
 }
+/**
+ * 方法审计选项
+ */
 export interface MethodAuditOptions {
     enabled?: boolean;
 }

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

@@ -1,10 +1,25 @@
 import { ClsService } from 'nestjs-cls';
 import { AuditContext } from '../interfaces';
+/**
+ * 审计上下文服务
+ */
 export declare class AuditContextService {
     private readonly cls;
     constructor(cls: ClsService);
+    /**
+     * 获取当前上下文
+     */
     getCurrentContext(): Promise<AuditContext>;
+    /**
+     * 设置上下文
+     */
     setContext(context: Partial<AuditContext>): void;
+    /**
+     * 清除上下文
+     */
     clearContext(): void;
+    /**
+     * 获取默认上下文
+     */
     private getDefaultContext;
 }

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

@@ -21,22 +21,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuditContextService = void 0;
 const common_1 = require("@nestjs/common");
 const nestjs_cls_1 = require("nestjs-cls");
+/**
+ * 审计上下文服务
+ */
 let AuditContextService = class AuditContextService {
     constructor(cls) {
         this.cls = cls;
     }
+    /**
+     * 获取当前上下文
+     */
     getCurrentContext() {
         return __awaiter(this, void 0, void 0, function* () {
             return this.cls.get('auditContext') || this.getDefaultContext();
         });
     }
+    /**
+     * 设置上下文
+     */
     setContext(context) {
         const currentContext = this.cls.get('auditContext') || this.getDefaultContext();
         this.cls.set('auditContext', Object.assign(Object.assign({}, currentContext), context));
     }
+    /**
+     * 清除上下文
+     */
     clearContext() {
         this.cls.set('auditContext', undefined);
     }
+    /**
+     * 获取默认上下文
+     */
     getDefaultContext() {
         return {
             userId: 'system',

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

@@ -1,5 +1,8 @@
 import { IAuditStrategy, IFieldFilter, AuditConfig } from '../interfaces';
 import { AuditOperation, RecordStrategy, MaskingStrategy } from '../enums';
+/**
+ * 默认字段过滤器
+ */
 export declare class DefaultFieldFilter implements IFieldFilter {
     private readonly includeFields?;
     private readonly excludeFields?;
@@ -10,6 +13,9 @@ export declare class DefaultFieldFilter implements IFieldFilter {
     getMaskingStrategy(fieldName: string, path: string[]): MaskingStrategy;
     private matchPattern;
 }
+/**
+ * 默认审计策略
+ */
 export declare class DefaultAuditStrategy implements IAuditStrategy {
     private readonly config?;
     constructor(config?: AuditConfig);

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

@@ -15,6 +15,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultAuditStrategy = exports.DefaultFieldFilter = void 0;
 const common_1 = require("@nestjs/common");
 const enums_1 = require("../enums");
+/**
+ * 默认字段过滤器
+ */
 class DefaultFieldFilter {
     constructor(includeFields, excludeFields, maskFields) {
         this.includeFields = includeFields;
@@ -23,9 +26,11 @@ class DefaultFieldFilter {
     }
     shouldIncludeField(fieldName, path) {
         const fullPath = [...path, fieldName].join('.');
+        // 如果指定了包含字段，则只记录这些字段
         if (this.includeFields && this.includeFields.length > 0) {
             return this.includeFields.some((pattern) => this.matchPattern(fullPath, pattern));
         }
+        // 如果指定了排除字段，则排除这些字段
         if (this.excludeFields && this.excludeFields.length > 0) {
             return !this.excludeFields.some((pattern) => this.matchPattern(fullPath, pattern));
         }
@@ -40,6 +45,7 @@ class DefaultFieldFilter {
         return enums_1.MaskingStrategy.MASK;
     }
     matchPattern(path, pattern) {
+        // 支持通配符匹配，如 user.address.*
         if (pattern.endsWith('*')) {
             return path.startsWith(pattern.slice(0, -1));
         }
@@ -47,18 +53,24 @@ class DefaultFieldFilter {
     }
 }
 exports.DefaultFieldFilter = DefaultFieldFilter;
+/**
+ * 默认审计策略
+ */
 let DefaultAuditStrategy = class DefaultAuditStrategy {
     constructor(config) {
         this.config = config;
     }
     shouldRecord(entityType, operation) {
         var _a, _b, _c, _d, _e;
+        // 检查全局配置
         const globalEnabled = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.enabled) !== false;
         if (!globalEnabled)
             return false;
+        // 检查实体级别配置
         const entityConfig = (_c = (_b = this.config) === null || _b === void 0 ? void 0 : _b.entities) === null || _c === void 0 ? void 0 : _c[entityType];
         if (entityConfig && entityConfig.enabled === false)
             return false;
+        // 检查操作级别配置
         const operationConfig = (_e = (_d = this.config) === null || _d === void 0 ? void 0 : _d.operations) === null || _e === void 0 ? void 0 : _e[operation];
         if (operationConfig && operationConfig.enabled === false)
             return false;
@@ -66,6 +78,7 @@ let DefaultAuditStrategy = class DefaultAuditStrategy {
     }
     getRecordStrategy(entityType, operation) {
         var _a, _b, _c, _d, _e, _f, _g;
+        // 优先级: 实体级别 > 操作级别 > 全局默认
         const entityStrategy = (_c = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.entities) === null || _b === void 0 ? void 0 : _b[entityType]) === null || _c === void 0 ? void 0 : _c.strategy;
         if (entityStrategy)
             return entityStrategy;

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

@@ -6,6 +6,9 @@ import { AuditContextService } from './audit-context.service';
 import { MultiDatabaseService } from './multi-database.service';
 import { PageDto } from '../../common/dto';
 import { AuditLogQueryDto } from '../dto';
+/**
+ * 实体审计服务
+ */
 export declare class EntityAuditService {
     private readonly auditLogRepository;
     private readonly transactionRepository;
@@ -16,22 +19,76 @@ export declare class EntityAuditService {
     private readonly config?;
     private readonly auditConnectionName;
     constructor(auditLogRepository: Repository<EntityAuditLogEntity>, transactionRepository: Repository<EntityTransactionEntity>, entityManager: EntityManager, contextService: AuditContextService, multiDbService: MultiDatabaseService, auditStrategy?: IAuditStrategy, config?: AuditConfig, auditConnectionName?: string);
+    /**
+     * 记录实体变更
+     */
     logEntityChange(entityType: string, entityId: string, operation: AuditOperation, oldValue: Record<string, any>, newValue: Record<string, any>, metadata?: Record<string, any>): Promise<EntityAuditLogEntity | null>;
+    /**
+     * 查询审计日志
+     */
     getAuditLogs(query: AuditLogQueryDto): Promise<PageDto<EntityAuditLogEntity>>;
+    /**
+     * 比较实体差异
+     */
     compareEntities(entityType: string, entityId: string, fromLogId?: string, toLogId?: string): Promise<EntityDifference>;
+    /**
+     * 预检查恢复操作
+     */
     preCheckRestore(entityType: string, entityId: string, auditLogId: string): Promise<PreCheckResult>;
+    /**
+     * 恢复实体
+     */
     restoreEntity(entityType: string, entityId: string, auditLogId: string, options?: RestoreOptions): Promise<RestoreResult>;
+    /**
+     * 计算变更字段
+     */
     private calculateChangedFields;
+    /**
+     * 计算变更字段路径
+     */
     private calculateChangedFieldPaths;
+    /**
+     * 深度比较对象
+     */
     private deepEqual;
+    /**
+     * 深度差异比较
+     */
     private deepDiff;
+    /**
+     * 比较快照数据
+     */
     private compareSnapshotData;
+    /**
+     * 过滤和脱敏字段
+     */
     private filterAndMaskFields;
+    /**
+     * 应用脱敏策略
+     */
     private applyMasking;
+    /**
+     * 哈希值
+     */
     private hashValue;
+    /**
+     * 掩码值
+     */
     private maskValue;
+    /**
+     * 部分掩码值
+     */
     private partialMaskValue;
+    /**
+     * 生成哈希链
+     */
     private generateHashChain;
+    /**
+     * 生成描述
+     */
     private generateDescription;
+    /**
+     * 检测冲突
+     */
     private detectConflicts;
 }