@nest-omni/core 3.1.2-8 → 3.1.2-9

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

@@ -0,0 +1,19 @@
+import { IAuditStrategy, IFieldFilter, AuditConfig } from '../interfaces';
+import { AuditOperation, RecordStrategy, MaskingStrategy } from '../enums';
+export declare class DefaultFieldFilter implements IFieldFilter {
+    private readonly includeFields?;
+    private readonly excludeFields?;
+    private readonly maskFields?;
+    constructor(includeFields?: string[], excludeFields?: string[], maskFields?: string[]);
+    shouldIncludeField(fieldName: string, path: string[]): boolean;
+    shouldMaskField(fieldName: string, path: string[]): boolean;
+    getMaskingStrategy(fieldName: string, path: string[]): MaskingStrategy;
+    private matchPattern;
+}
+export declare class DefaultAuditStrategy implements IAuditStrategy {
+    private readonly config?;
+    constructor(config?: AuditConfig);
+    shouldRecord(entityType: string, operation: AuditOperation): boolean;
+    getRecordStrategy(entityType: string, operation: AuditOperation): RecordStrategy;
+    getFieldFilter(entityType: string): IFieldFilter;
+}

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

@@ -0,0 +1,89 @@
+"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); }
+};
+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;
+        this.excludeFields = excludeFields;
+        this.maskFields = maskFields;
+    }
+    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));
+        }
+        return true;
+    }
+    shouldMaskField(fieldName, path) {
+        var _a;
+        const fullPath = [...path, fieldName].join('.');
+        return ((_a = this.maskFields) === null || _a === void 0 ? void 0 : _a.some((pattern) => this.matchPattern(fullPath, pattern))) || false;
+    }
+    getMaskingStrategy(fieldName, path) {
+        return enums_1.MaskingStrategy.MASK;
+    }
+    matchPattern(path, pattern) {
+        if (pattern.endsWith('*')) {
+            return path.startsWith(pattern.slice(0, -1));
+        }
+        return path === pattern;
+    }
+}
+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;
+        return true;
+    }
+    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;
+        const operationStrategy = (_f = (_e = (_d = this.config) === null || _d === void 0 ? void 0 : _d.operations) === null || _e === void 0 ? void 0 : _e[operation]) === null || _f === void 0 ? void 0 : _f.strategy;
+        if (operationStrategy)
+            return operationStrategy;
+        return ((_g = this.config) === null || _g === void 0 ? void 0 : _g.defaultStrategy) || enums_1.RecordStrategy.FULL;
+    }
+    getFieldFilter(entityType) {
+        var _a, _b;
+        const entityConfig = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.entities) === null || _b === void 0 ? void 0 : _b[entityType];
+        return new DefaultFieldFilter(entityConfig === null || entityConfig === void 0 ? void 0 : entityConfig.includeFields, entityConfig === null || entityConfig === void 0 ? void 0 : entityConfig.excludeFields, entityConfig === null || entityConfig === void 0 ? void 0 : entityConfig.maskFields);
+    }
+};
+exports.DefaultAuditStrategy = DefaultAuditStrategy;
+exports.DefaultAuditStrategy = DefaultAuditStrategy = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)('AUDIT_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], DefaultAuditStrategy);

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

@@ -0,0 +1,65 @@
+import { Repository, EntityManager } from 'typeorm';
+import { EntityAuditLogEntity, EntityTransactionEntity, ManualOperationLogEntity } from '../entities';
+import { AuditOperation } from '../enums';
+import { AuditConfig, IAuditStrategy, EntityDifference, RestoreOptions, RestoreResult, PreCheckResult, ManualOperationData, ChangeDetail, RollbackAction } from '../interfaces';
+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;
+    private readonly manualOperationRepository;
+    private readonly entityManager;
+    private readonly contextService;
+    private readonly multiDbService;
+    private readonly auditStrategy;
+    private readonly config?;
+    private readonly auditConnectionName;
+    constructor(auditLogRepository: Repository<EntityAuditLogEntity>, transactionRepository: Repository<EntityTransactionEntity>, manualOperationRepository: Repository<ManualOperationLogEntity>, 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;
+    logEntityChangeWithTemplate(data: {
+        entityType: string;
+        entityId: string;
+        operation: AuditOperation;
+        oldValue?: Record<string, any>;
+        newValue?: Record<string, any>;
+        changedFields?: string[];
+        operationTemplateKey?: string;
+        descriptionParams?: Record<string, any>;
+        changeDetails?: ChangeDetail[];
+        rollbackActions?: RollbackAction[];
+        metadata?: Record<string, any>;
+    }): Promise<EntityAuditLogEntity | null>;
+    logManualOperation(data: ManualOperationData): Promise<ManualOperationLogEntity>;
+    withTransaction<T>(fn: (transactionId: string) => Promise<T>, options?: {
+        userId?: string;
+        username?: string;
+        requestIp?: string;
+        operationTemplateKey?: string;
+        descriptionParams?: Record<string, any>;
+        metadata?: Record<string, any>;
+    }): Promise<T>;
+    getCurrentTransactionId(): Promise<string | null>;
+    setCurrentTransactionId(transactionId: string | null): Promise<void>;
+    beginTransaction(userId?: string, userName?: string, ip?: string, operationTemplateKey?: string, descriptionParams?: Record<string, any>): Promise<string>;
+    commitTransaction(transactionId: string): Promise<void>;
+    rollbackTransaction(transactionId: string): Promise<void>;
+}