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

package/audit/entities/operation-template.entity.d.ts

@@ -0,0 +1,11 @@
+import { AbstractUuidPrimaryEntity } from '../../common/abstract.entity';
+import { AuditOperation } from '../enums';
+export declare class OperationTemplateEntity extends AbstractUuidPrimaryEntity {
+    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>>>;
+}

package/audit/entities/operation-template.entity.js

@@ -0,0 +1,65 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationTemplateEntity = void 0;
+const typeorm_1 = require("typeorm");
+const abstract_entity_1 = require("../../common/abstract.entity");
+const enums_1 = require("../enums");
+let OperationTemplateEntity = class OperationTemplateEntity extends abstract_entity_1.AbstractUuidPrimaryEntity {
+};
+exports.OperationTemplateEntity = OperationTemplateEntity;
+__decorate([
+    (0, typeorm_1.Column)({ unique: true, comment: '模板键，唯一标识' }),
+    __metadata("design:type", String)
+], OperationTemplateEntity.prototype, "key", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ comment: '实体类名，* 表示通用模板' }),
+    __metadata("design:type", String)
+], OperationTemplateEntity.prototype, "entityName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: enums_1.AuditOperation, comment: '操作类型' }),
+    __metadata("design:type", String)
+], OperationTemplateEntity.prototype, "operation", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'json',
+        comment: '多语言操作名称模板 { zh: "创建用户", en: "Create User" }',
+    }),
+    __metadata("design:type", Object)
+], OperationTemplateEntity.prototype, "nameTemplates", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'json',
+        comment: '多语言操作描述模板 { zh: "创建了用户 {name}", en: "Created user {name}" }',
+    }),
+    __metadata("design:type", Object)
+], OperationTemplateEntity.prototype, "descriptionTemplates", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'json',
+        nullable: true,
+        comment: '字段标签映射 { name: { zh: "姓名", en: "Name" } }',
+    }),
+    __metadata("design:type", Object)
+], OperationTemplateEntity.prototype, "fieldLabels", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'json',
+        nullable: true,
+        comment: '值显示映射 { status: { active: { zh: "激活", en: "Active" } } }',
+    }),
+    __metadata("design:type", Object)
+], OperationTemplateEntity.prototype, "valueDisplays", void 0);
+exports.OperationTemplateEntity = OperationTemplateEntity = __decorate([
+    (0, typeorm_1.Entity)('operation_template'),
+    (0, typeorm_1.Index)('idx_template_key', ['key'], { unique: true }),
+    (0, typeorm_1.Index)('idx_entity_operation', ['entityName', 'operation'])
+], OperationTemplateEntity);

package/audit/enums/audit.enums.d.ts

@@ -0,0 +1,42 @@
+export declare enum OperationType {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete"
+}
+export declare enum AuditOperation {
+    CREATE = "CREATE",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    RESTORE = "RESTORE"
+}
+export declare enum TransactionStatus {
+    PENDING = "pending",
+    COMMITTED = "committed",
+    ROLLED_BACK = "rolled_back"
+}
+export declare enum RecoveryStrategy {
+    ENTITY_ONLY = "ENTITY_ONLY",
+    TRANSACTION_RESTORE = "TRANSACTION_RESTORE",
+    DEPENDENCY_GRAPH = "DEPENDENCY_GRAPH"
+}
+export declare enum RecordStrategy {
+    FULL = "FULL",
+    DIFF_ONLY = "DIFF_ONLY",
+    DISABLED = "DISABLED"
+}
+export declare enum MaskingStrategy {
+    NONE = "NONE",
+    HASH = "HASH",
+    MASK = "MASK",
+    PARTIAL = "PARTIAL"
+}
+export declare enum RollbackActionType {
+    ENTITY = "entity",
+    FILE = "file",
+    CUSTOM = "custom"
+}
+export declare enum ChangeType {
+    ADDED = "added",
+    REMOVED = "removed",
+    MODIFIED = "modified"
+}

package/audit/enums/audit.enums.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeType = exports.RollbackActionType = exports.MaskingStrategy = exports.RecordStrategy = exports.RecoveryStrategy = exports.TransactionStatus = exports.AuditOperation = exports.OperationType = void 0;
+var OperationType;
+(function (OperationType) {
+    OperationType["CREATE"] = "create";
+    OperationType["UPDATE"] = "update";
+    OperationType["DELETE"] = "delete";
+})(OperationType || (exports.OperationType = OperationType = {}));
+var AuditOperation;
+(function (AuditOperation) {
+    AuditOperation["CREATE"] = "CREATE";
+    AuditOperation["UPDATE"] = "UPDATE";
+    AuditOperation["DELETE"] = "DELETE";
+    AuditOperation["RESTORE"] = "RESTORE";
+})(AuditOperation || (exports.AuditOperation = AuditOperation = {}));
+var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["PENDING"] = "pending";
+    TransactionStatus["COMMITTED"] = "committed";
+    TransactionStatus["ROLLED_BACK"] = "rolled_back";
+})(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
+var RecoveryStrategy;
+(function (RecoveryStrategy) {
+    RecoveryStrategy["ENTITY_ONLY"] = "ENTITY_ONLY";
+    RecoveryStrategy["TRANSACTION_RESTORE"] = "TRANSACTION_RESTORE";
+    RecoveryStrategy["DEPENDENCY_GRAPH"] = "DEPENDENCY_GRAPH";
+})(RecoveryStrategy || (exports.RecoveryStrategy = RecoveryStrategy = {}));
+var RecordStrategy;
+(function (RecordStrategy) {
+    RecordStrategy["FULL"] = "FULL";
+    RecordStrategy["DIFF_ONLY"] = "DIFF_ONLY";
+    RecordStrategy["DISABLED"] = "DISABLED";
+})(RecordStrategy || (exports.RecordStrategy = RecordStrategy = {}));
+var MaskingStrategy;
+(function (MaskingStrategy) {
+    MaskingStrategy["NONE"] = "NONE";
+    MaskingStrategy["HASH"] = "HASH";
+    MaskingStrategy["MASK"] = "MASK";
+    MaskingStrategy["PARTIAL"] = "PARTIAL";
+})(MaskingStrategy || (exports.MaskingStrategy = MaskingStrategy = {}));
+var RollbackActionType;
+(function (RollbackActionType) {
+    RollbackActionType["ENTITY"] = "entity";
+    RollbackActionType["FILE"] = "file";
+    RollbackActionType["CUSTOM"] = "custom";
+})(RollbackActionType || (exports.RollbackActionType = RollbackActionType = {}));
+var ChangeType;
+(function (ChangeType) {
+    ChangeType["ADDED"] = "added";
+    ChangeType["REMOVED"] = "removed";
+    ChangeType["MODIFIED"] = "modified";
+})(ChangeType || (exports.ChangeType = ChangeType = {}));

package/audit/enums/index.d.ts

@@ -0,0 +1 @@
+export * from './audit.enums';

package/audit/enums/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./audit.enums"), exports);

package/audit/index.d.ts

@@ -0,0 +1,12 @@
+export * from './entities';
+export * from './enums';
+export * from './interfaces';
+export * from './dto';
+export { AuditEntity, EntityAudit, AuditField, getEntityAuditConfig, getFieldAuditConfig, getFieldLabel, getFieldValueLabel, 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, LogOperation, AuditOperation, getAuditOperationConfig, hasAuditOperation, AUDIT_OPERATION_OPTIONS, } from './decorators/audit-operation.decorator';
+export * from './services';
+export * from './subscribers';
+export * from './interceptors';
+export * from './controllers';
+export * from './audit.module';

package/audit/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.AuditOperation = exports.LogOperation = 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.EntityAudit = exports.AuditEntity = void 0;
+__exportStar(require("./entities"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./dto"), exports);
+var entity_audit_decorator_1 = require("./decorators/entity-audit.decorator");
+Object.defineProperty(exports, "AuditEntity", { enumerable: true, get: function () { return entity_audit_decorator_1.AuditEntity; } });
+Object.defineProperty(exports, "EntityAudit", { enumerable: true, get: function () { return entity_audit_decorator_1.EntityAudit; } });
+Object.defineProperty(exports, "AuditField", { enumerable: true, get: function () { return entity_audit_decorator_1.AuditField; } });
+Object.defineProperty(exports, "getEntityAuditConfig", { enumerable: true, get: function () { return entity_audit_decorator_1.getEntityAuditConfig; } });
+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, "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");
+Object.defineProperty(exports, "AuditController", { enumerable: true, get: function () { return audit_controller_decorator_1.AuditController; } });
+Object.defineProperty(exports, "AuditMethod", { enumerable: true, get: function () { return audit_controller_decorator_1.AuditMethod; } });
+Object.defineProperty(exports, "CONTROLLER_AUDIT_OPTIONS", { enumerable: true, get: function () { return audit_controller_decorator_1.CONTROLLER_AUDIT_OPTIONS; } });
+Object.defineProperty(exports, "METHOD_AUDIT_OPTIONS", { enumerable: true, get: function () { return audit_controller_decorator_1.METHOD_AUDIT_OPTIONS; } });
+var audit_operation_decorator_1 = require("./decorators/audit-operation.decorator");
+Object.defineProperty(exports, "AuditLog", { enumerable: true, get: function () { return audit_operation_decorator_1.AuditLog; } });
+Object.defineProperty(exports, "LogOperation", { enumerable: true, get: function () { return audit_operation_decorator_1.LogOperation; } });
+Object.defineProperty(exports, "AuditOperation", { enumerable: true, get: function () { return audit_operation_decorator_1.AuditOperation; } });
+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; } });
+__exportStar(require("./services"), exports);
+__exportStar(require("./subscribers"), exports);
+__exportStar(require("./interceptors"), exports);
+__exportStar(require("./controllers"), exports);
+__exportStar(require("./audit.module"), exports);

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

@@ -0,0 +1,12 @@
+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;
+    private generateRequestId;
+}

package/audit/interceptors/audit.interceptor.js

@@ -0,0 +1,95 @@
+"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 __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.AuditInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+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;
+    }
+    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 || {};
+        const auditContext = {
+            userId: user.uid || 'anonymous',
+            username: user.username || 'anonymous',
+            requestId: request.id || ((_a = request.headers) === null || _a === void 0 ? void 0 : _a['x-request-id']) || this.generateRequestId(),
+            requestIp: request.ip || ((_b = request.connection) === null || _b === void 0 ? void 0 : _b.remoteAddress),
+            userAgent: (_c = request.headers) === null || _c === void 0 ? void 0 : _c['user-agent'],
+            timestamp: new Date(),
+        };
+        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,
+                    },
+                },
+            });
+        });
+    }
+    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;
+            }
+            return true;
+        }
+        catch (error) {
+            return true;
+        }
+    }
+    generateRequestId() {
+        return (0, crypto_1.randomBytes)(16).toString('hex');
+    }
+};
+exports.AuditInterceptor = AuditInterceptor;
+exports.AuditInterceptor = AuditInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [audit_context_service_1.AuditContextService])
+], AuditInterceptor);

package/audit/interceptors/index.d.ts

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

package/audit/interceptors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./audit.interceptor"), exports);

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

@@ -0,0 +1,180 @@
+import { AuditOperation, MaskingStrategy, RecordStrategy, RollbackActionType, ChangeType } from '../enums/audit.enums';
+export interface AuditContext {
+    userId?: string;
+    username?: string;
+    requestId?: string;
+    requestIp?: string;
+    userAgent?: string;
+    timestamp?: Date;
+    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[];
+        type: 'ADD' | 'REMOVE' | 'CHANGE';
+        oldValue: any;
+        newValue: any;
+    }>;
+    summary: {
+        added: number;
+        removed: number;
+        changed: number;
+    };
+}
+export interface RestoreOptions {
+    force?: boolean;
+    dryRun?: boolean;
+    excludeFields?: string[];
+    includeFields?: string[];
+    skipDependencies?: boolean;
+    connectionName?: string;
+}
+export interface RestoreResult {
+    success: boolean;
+    message?: string;
+    conflicts?: Array<{
+        field: string;
+        reason: string;
+        currentValue: any;
+        targetValue: any;
+    }>;
+    restoredEntities?: Array<{
+        entityType: string;
+        entityId: string;
+    }>;
+}
+export interface PreCheckResult {
+    canRestore: boolean;
+    conflicts: Array<{
+        field: string;
+        reason: string;
+        currentValue: any;
+        targetValue: any;
+    }>;
+    warnings: string[];
+}
+export interface BatchOperationResult {
+    total: number;
+    success: number;
+    failed: number;
+    errors: Array<{
+        index: number;
+        error: string;
+    }>;
+    results: any[];
+}
+export interface AuditConfig {
+    enabled?: boolean;
+    defaultStrategy?: RecordStrategy;
+    maxDiffDepth?: number;
+    maxDiffFields?: number;
+    connections?: {
+        audit?: string;
+        monitored?: string[];
+    };
+    entities?: Record<string, EntityAuditConfig>;
+    operations?: Record<string, OperationAuditConfig>;
+    security?: {
+        hashChainEnabled?: boolean;
+        hashAlgorithm?: string;
+        masking?: {
+            defaultStrategy?: MaskingStrategy;
+            strategies?: Record<string, MaskingStrategy>;
+        };
+    };
+}
+export interface EntityAuditConfig {
+    enabled?: boolean;
+    strategy?: RecordStrategy;
+    includeFields?: string[];
+    excludeFields?: string[];
+    maskFields?: string[];
+    templateKey?: string;
+    sensitiveFields?: string[];
+}
+export interface OperationAuditConfig {
+    enabled?: boolean;
+    strategy?: RecordStrategy;
+}
+export interface FieldDisplayOptions {
+    label?: string | Record<string, string>;
+    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 RollbackAction {
+    type: RollbackActionType;
+    action: string;
+    params: Record<string, any>;
+    order: number;
+    handler?: string;
+}
+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;
+    rollbackActions?: RollbackAction[];
+}
+export interface AuditOperationOptions {
+    templateKey: string;
+    descriptionParams?: (args: any[], result: any, context: any) => Record<string, any>;
+    rollbackActions?: (args: any[], result: any, context: any) => RollbackAction[];
+    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/interfaces/audit.interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/audit/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './audit.interfaces';

package/audit/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./audit.interfaces"), exports);

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,55 @@
+"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 __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.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',
+            username: 'system',
+            requestId: '',
+            requestIp: '',
+            userAgent: '',
+            timestamp: new Date(),
+        };
+    }
+};
+exports.AuditContextService = AuditContextService;
+exports.AuditContextService = AuditContextService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [nestjs_cls_1.ClsService])
+], AuditContextService);