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

package/audit/services/multi-database.service.js

@@ -0,0 +1,59 @@
+"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.MultiDatabaseService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const core_1 = require("@nestjs/core");
+let MultiDatabaseService = class MultiDatabaseService {
+    constructor(moduleRef, config) {
+        this.moduleRef = moduleRef;
+        this.config = config;
+    }
+    getDataSource() {
+        return __awaiter(this, arguments, void 0, function* (connectionName = 'default') {
+            try {
+                const dataSource = this.moduleRef.get((0, typeorm_1.getDataSourceToken)(connectionName), { strict: false });
+                return dataSource;
+            }
+            catch (error) {
+                throw new Error(`Failed to get DataSource for connection: ${connectionName}`);
+            }
+        });
+    }
+    getMonitoredConnections() {
+        var _a, _b;
+        return ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.connections) === null || _b === void 0 ? void 0 : _b.monitored) || ['default'];
+    }
+    getAuditConnection() {
+        var _a, _b;
+        return ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.connections) === null || _b === void 0 ? void 0 : _b.audit) || 'default';
+    }
+};
+exports.MultiDatabaseService = MultiDatabaseService;
+exports.MultiDatabaseService = MultiDatabaseService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)('AUDIT_CONFIG')),
+    __metadata("design:paramtypes", [core_1.ModuleRef, Object])
+], MultiDatabaseService);

package/audit/services/operation-description.service.d.ts

@@ -0,0 +1,21 @@
+import { Repository } from 'typeorm';
+import { OperationTemplateEntity, EntityTransactionEntity, EntityAuditLogEntity, ManualOperationLogEntity } from '../entities';
+import { ChangeDetail, TransactionDescription } from '../interfaces';
+export declare class OperationDescriptionService {
+    private readonly templateRepository;
+    private readonly transactionRepository;
+    private readonly auditLogRepository;
+    private readonly manualOperationRepository;
+    private templateCache;
+    constructor(templateRepository: Repository<OperationTemplateEntity>, transactionRepository: Repository<EntityTransactionEntity>, auditLogRepository: Repository<EntityAuditLogEntity>, manualOperationRepository: Repository<ManualOperationLogEntity>);
+    generateOperationName(templateKey: string, language?: string): Promise<string>;
+    generateDescription(templateKey: string, descriptionParams: Record<string, any>, language?: string): Promise<string>;
+    generateChangeDetails(changeDetails: ChangeDetail[], language?: string): Promise<any[]>;
+    getTransactionDescription(transactionId: string, language?: string): Promise<TransactionDescription>;
+    batchGetTransactionDescriptions(transactionIds: string[], language?: string): Promise<Record<string, TransactionDescription>>;
+    private fillTemplate;
+    private formatDisplayValue;
+    private getOperationTemplate;
+    clearTemplateCache(): void;
+    preloadTemplates(templateKeys: string[]): Promise<void>;
+}

package/audit/services/operation-description.service.js

@@ -0,0 +1,213 @@
+"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.OperationDescriptionService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const entities_1 = require("../entities");
+let OperationDescriptionService = class OperationDescriptionService {
+    constructor(templateRepository, transactionRepository, auditLogRepository, manualOperationRepository) {
+        this.templateRepository = templateRepository;
+        this.transactionRepository = transactionRepository;
+        this.auditLogRepository = auditLogRepository;
+        this.manualOperationRepository = manualOperationRepository;
+        this.templateCache = new Map();
+    }
+    generateOperationName(templateKey_1) {
+        return __awaiter(this, arguments, void 0, function* (templateKey, language = 'zh') {
+            const template = yield this.getOperationTemplate(templateKey);
+            if (!template) {
+                return templateKey;
+            }
+            return template.nameTemplates[language] || template.nameTemplates['zh'] || templateKey;
+        });
+    }
+    generateDescription(templateKey_1, descriptionParams_1) {
+        return __awaiter(this, arguments, void 0, function* (templateKey, descriptionParams, language = 'zh') {
+            const template = yield this.getOperationTemplate(templateKey);
+            if (!template) {
+                return templateKey;
+            }
+            const templateStr = template.descriptionTemplates[language] || template.descriptionTemplates['zh'] || templateKey;
+            return this.fillTemplate(templateStr, descriptionParams);
+        });
+    }
+    generateChangeDetails(changeDetails_1) {
+        return __awaiter(this, arguments, void 0, function* (changeDetails, language = 'zh') {
+            return changeDetails.map((detail) => {
+                var _a, _b, _c;
+                return ({
+                    fieldName: detail.fieldName,
+                    fieldLabel: ((_a = detail.fieldLabels) === null || _a === void 0 ? void 0 : _a[language]) || detail.fieldName,
+                    oldValue: this.formatDisplayValue(detail.oldValue, (_b = detail.displayOldValue) === null || _b === void 0 ? void 0 : _b[language]),
+                    newValue: this.formatDisplayValue(detail.newValue, (_c = detail.displayNewValue) === null || _c === void 0 ? void 0 : _c[language]),
+                    changeType: detail.changeType,
+                });
+            });
+        });
+    }
+    getTransactionDescription(transactionId_1) {
+        return __awaiter(this, arguments, void 0, function* (transactionId, language = 'zh') {
+            const transaction = yield this.transactionRepository.findOne({
+                where: { id: transactionId },
+            });
+            if (!transaction) {
+                throw new Error(`Transaction ${transactionId} not found`);
+            }
+            const auditLogs = yield this.auditLogRepository.find({
+                where: { requestId: transactionId },
+                order: { createdAt: 'ASC' },
+            });
+            const manualOperations = yield this.manualOperationRepository.find({
+                where: { transactionId },
+                order: { createdAt: 'ASC' },
+            });
+            let operationName;
+            let description;
+            if (transaction.operationTemplateKey) {
+                operationName = yield this.generateOperationName(transaction.operationTemplateKey, language);
+                description = yield this.generateDescription(transaction.operationTemplateKey, transaction.descriptionParams || {}, language);
+            }
+            else {
+                const firstLog = auditLogs[0];
+                if (firstLog && firstLog.operationTemplateKey) {
+                    operationName = yield this.generateOperationName(firstLog.operationTemplateKey, language);
+                    description = yield this.generateDescription(firstLog.operationTemplateKey, firstLog.descriptionParams || {}, language);
+                }
+                else {
+                    operationName = 'Unknown Operation';
+                    description = transaction.description || 'Unknown operation';
+                }
+            }
+            const changes = [];
+            for (const log of auditLogs) {
+                const changeDescription = log.operationTemplateKey
+                    ? yield this.generateDescription(log.operationTemplateKey, log.descriptionParams || {}, language)
+                    : log.description || '';
+                const changeDetails = log.changeDetails
+                    ? yield this.generateChangeDetails(log.changeDetails, language)
+                    : [];
+                changes.push({
+                    entityName: log.entityType,
+                    entityId: log.entityId,
+                    operation: log.operation,
+                    description: changeDescription,
+                    details: changeDetails,
+                    createdAt: log.createdAt,
+                });
+            }
+            for (const manualOp of manualOperations) {
+                const opName = yield this.generateOperationName(manualOp.operationTemplateKey, language);
+                const opDescription = yield this.generateDescription(manualOp.operationTemplateKey, manualOp.descriptionParams, language);
+                changes.push({
+                    type: 'manual',
+                    description: `${opName}: ${opDescription}`,
+                    details: manualOp.descriptionParams,
+                    createdAt: manualOp.createdAt,
+                });
+            }
+            changes.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            return {
+                operationName,
+                description,
+                changes,
+            };
+        });
+    }
+    batchGetTransactionDescriptions(transactionIds_1) {
+        return __awaiter(this, arguments, void 0, function* (transactionIds, language = 'zh') {
+            const results = {};
+            for (const transactionId of transactionIds) {
+                try {
+                    results[transactionId] = yield this.getTransactionDescription(transactionId, language);
+                }
+                catch (error) {
+                    console.error(`Failed to get description for transaction ${transactionId}:`, error);
+                }
+            }
+            return results;
+        });
+    }
+    fillTemplate(template, params) {
+        if (!template)
+            return '';
+        let result = template;
+        for (const [key, value] of Object.entries(params || {})) {
+            const placeholder = `{${key}}`;
+            if (result.includes(placeholder)) {
+                result = result.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), String(value || ''));
+            }
+        }
+        return result;
+    }
+    formatDisplayValue(value, displayValue) {
+        if (displayValue !== undefined) {
+            return displayValue;
+        }
+        if (value === null || value === undefined) {
+            return '';
+        }
+        return String(value);
+    }
+    getOperationTemplate(templateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.templateCache.has(templateKey)) {
+                return this.templateCache.get(templateKey);
+            }
+            const template = yield this.templateRepository.findOne({
+                where: { key: templateKey },
+            });
+            if (template) {
+                this.templateCache.set(templateKey, template);
+            }
+            return template;
+        });
+    }
+    clearTemplateCache() {
+        this.templateCache.clear();
+    }
+    preloadTemplates(templateKeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const templates = yield this.templateRepository
+                .createQueryBuilder('template')
+                .where('template.key IN (:...keys)', { keys: templateKeys })
+                .getMany();
+            for (const template of templates) {
+                this.templateCache.set(template.key, template);
+            }
+        });
+    }
+};
+exports.OperationDescriptionService = OperationDescriptionService;
+exports.OperationDescriptionService = OperationDescriptionService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(entities_1.OperationTemplateEntity)),
+    __param(1, (0, typeorm_1.InjectRepository)(entities_1.EntityTransactionEntity)),
+    __param(2, (0, typeorm_1.InjectRepository)(entities_1.EntityAuditLogEntity)),
+    __param(3, (0, typeorm_1.InjectRepository)(entities_1.ManualOperationLogEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository])
+], OperationDescriptionService);

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

@@ -0,0 +1,22 @@
+import { Repository } from 'typeorm';
+import { EntityTransactionEntity } from '../entities';
+import { AuditOperation } from '../enums';
+import { AuditContextService } from './audit-context.service';
+import { EntityAuditService } from './entity-audit.service';
+import { MultiDatabaseService } from './multi-database.service';
+export declare class TransactionAuditService {
+    private readonly transactionRepository;
+    private readonly contextService;
+    private readonly auditService;
+    private readonly multiDbService;
+    constructor(transactionRepository: Repository<EntityTransactionEntity>, contextService: AuditContextService, auditService: EntityAuditService, multiDbService: MultiDatabaseService);
+    beginTransaction(description: string): Promise<string>;
+    commitTransaction(transactionId: string): Promise<void>;
+    rollbackTransaction(transactionId: string): Promise<void>;
+    addEntityToTransaction(transactionId: string, entityType: string, entityId: string, operation: AuditOperation): Promise<void>;
+    private performRollback;
+    private groupEntitiesByConnection;
+    private rollbackEntitiesInConnection;
+    private rollbackSingleEntity;
+    private getLatestAuditLog;
+}

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

@@ -0,0 +1,201 @@
+"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.TransactionAuditService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const entities_1 = require("../entities");
+const enums_1 = require("../enums");
+const audit_context_service_1 = require("./audit-context.service");
+const entity_audit_service_1 = require("./entity-audit.service");
+const multi_database_service_1 = require("./multi-database.service");
+let TransactionAuditService = class TransactionAuditService {
+    constructor(transactionRepository, contextService, auditService, multiDbService) {
+        this.transactionRepository = transactionRepository;
+        this.contextService = contextService;
+        this.auditService = auditService;
+        this.multiDbService = multiDbService;
+    }
+    beginTransaction(description) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.contextService.getCurrentContext();
+            const transaction = this.transactionRepository.create({
+                description,
+                status: enums_1.TransactionStatus.PENDING,
+                entities: [],
+                userId: context.userId,
+                username: context.username,
+            });
+            const savedTransaction = yield this.transactionRepository.save(transaction);
+            this.contextService.setContext({
+                transactionId: savedTransaction.id,
+            });
+            return savedTransaction.id;
+        });
+    }
+    commitTransaction(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transaction = yield this.transactionRepository.findOne({
+                where: { id: transactionId },
+            });
+            if (!transaction) {
+                throw new Error(`Transaction not found: ${transactionId}`);
+            }
+            transaction.status = enums_1.TransactionStatus.COMMITTED;
+            yield this.transactionRepository.save(transaction);
+        });
+    }
+    rollbackTransaction(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transaction = yield this.transactionRepository.findOne({
+                where: { id: transactionId },
+            });
+            if (!transaction) {
+                throw new Error(`Transaction not found: ${transactionId}`);
+            }
+            yield this.performRollback(transaction);
+            transaction.status = enums_1.TransactionStatus.ROLLED_BACK;
+            yield this.transactionRepository.save(transaction);
+        });
+    }
+    addEntityToTransaction(transactionId, entityType, entityId, operation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transaction = yield this.transactionRepository.findOne({
+                where: { id: transactionId },
+            });
+            if (!transaction) {
+                throw new Error(`Transaction not found: ${transactionId}`);
+            }
+            transaction.entities.push({
+                entityType,
+                entityId,
+                operation,
+            });
+            yield this.transactionRepository.save(transaction);
+        });
+    }
+    performRollback(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reversedEntities = [...transaction.entities].reverse();
+            const entitiesByConnection = yield this.groupEntitiesByConnection(reversedEntities);
+            for (const [connectionName, entities] of Object.entries(entitiesByConnection)) {
+                yield this.rollbackEntitiesInConnection(connectionName, entities);
+            }
+        });
+    }
+    groupEntitiesByConnection(entities) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const grouped = {};
+            const monitoredConnections = this.multiDbService.getMonitoredConnections();
+            for (const entity of entities) {
+                let connectionFound = false;
+                for (const connectionName of monitoredConnections) {
+                    try {
+                        const dataSource = yield this.multiDbService.getDataSource(connectionName);
+                        const metadata = dataSource.getMetadata(entity.entityType);
+                        if (metadata) {
+                            if (!grouped[connectionName]) {
+                                grouped[connectionName] = [];
+                            }
+                            grouped[connectionName].push(entity);
+                            connectionFound = true;
+                            break;
+                        }
+                    }
+                    catch (error) {
+                        continue;
+                    }
+                }
+                if (!connectionFound) {
+                    const defaultConnection = 'default';
+                    if (!grouped[defaultConnection]) {
+                        grouped[defaultConnection] = [];
+                    }
+                    grouped[defaultConnection].push(entity);
+                }
+            }
+            return grouped;
+        });
+    }
+    rollbackEntitiesInConnection(connectionName, entities) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataSource = yield this.multiDbService.getDataSource(connectionName);
+            yield dataSource.transaction((manager) => __awaiter(this, void 0, void 0, function* () {
+                for (const entity of entities) {
+                    try {
+                        yield this.rollbackSingleEntity(manager, entity, connectionName);
+                    }
+                    catch (error) {
+                        console.error(`Failed to rollback entity ${entity.entityType}:${entity.entityId} in connection ${connectionName}:`, error);
+                        throw error;
+                    }
+                }
+            }));
+        });
+    }
+    rollbackSingleEntity(manager, entity, connectionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const repository = manager.getRepository(entity.entityType);
+            switch (entity.operation) {
+                case enums_1.AuditOperation.CREATE:
+                    yield repository.delete({ id: entity.entityId });
+                    break;
+                case enums_1.AuditOperation.UPDATE:
+                    const auditLog = yield this.getLatestAuditLog(entity.entityType, entity.entityId);
+                    if (auditLog && auditLog.oldValue) {
+                        yield repository.update({ id: entity.entityId }, auditLog.oldValue);
+                    }
+                    break;
+                case enums_1.AuditOperation.DELETE:
+                    const deletedAuditLog = yield this.getLatestAuditLog(entity.entityType, entity.entityId);
+                    if (deletedAuditLog && deletedAuditLog.oldValue) {
+                        yield repository.save(deletedAuditLog.oldValue);
+                    }
+                    break;
+                case enums_1.AuditOperation.RESTORE:
+                    const restoreAuditLog = yield this.getLatestAuditLog(entity.entityType, entity.entityId);
+                    if (restoreAuditLog && restoreAuditLog.oldValue) {
+                        yield repository.update({ id: entity.entityId }, restoreAuditLog.oldValue);
+                    }
+                    break;
+                default:
+                    console.warn(`Unknown operation type: ${entity.operation}`);
+            }
+        });
+    }
+    getLatestAuditLog(entityType, entityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    }
+};
+exports.TransactionAuditService = TransactionAuditService;
+exports.TransactionAuditService = TransactionAuditService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(entities_1.EntityTransactionEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        audit_context_service_1.AuditContextService,
+        entity_audit_service_1.EntityAuditService,
+        multi_database_service_1.MultiDatabaseService])
+], TransactionAuditService);

package/audit/subscribers/entity-audit.subscriber.d.ts

@@ -0,0 +1,14 @@
+import { EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent, DataSource } from 'typeorm';
+import { EntityAuditService } from '../services/entity-audit.service';
+import { AuditContextService } from '../services/audit-context.service';
+import { DefaultAuditStrategy } from '../services/audit-strategy.service';
+export declare class EntityAuditSubscriber implements EntitySubscriberInterface<any> {
+    private readonly entityAuditService;
+    private readonly contextService;
+    private readonly auditStrategy;
+    constructor(entityAuditService: EntityAuditService, contextService: AuditContextService, auditStrategy: DefaultAuditStrategy, dataSource: DataSource);
+    afterInsert(event: InsertEvent<any>): Promise<void>;
+    afterUpdate(event: UpdateEvent<any>): Promise<void>;
+    beforeRemove(event: RemoveEvent<any>): Promise<void>;
+    private isAuditEnabled;
+}

package/audit/subscribers/entity-audit.subscriber.js

@@ -0,0 +1,136 @@
+"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.EntityAuditSubscriber = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const entity_audit_service_1 = require("../services/entity-audit.service");
+const audit_context_service_1 = require("../services/audit-context.service");
+const audit_strategy_service_1 = require("../services/audit-strategy.service");
+const enums_1 = require("../enums");
+const decorators_1 = require("../decorators");
+let EntityAuditSubscriber = class EntityAuditSubscriber {
+    constructor(entityAuditService, contextService, auditStrategy, dataSource) {
+        this.entityAuditService = entityAuditService;
+        this.contextService = contextService;
+        this.auditStrategy = auditStrategy;
+        dataSource.subscribers.push(this);
+    }
+    afterInsert(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entity = event.entity;
+            if (!entity)
+                return;
+            const entityType = entity.constructor.name;
+            const entityId = entity.id;
+            if (!this.isAuditEnabled(entity)) {
+                return;
+            }
+            if (!this.auditStrategy.shouldRecord(entityType, enums_1.AuditOperation.CREATE)) {
+                return;
+            }
+            try {
+                const context = yield this.contextService.getCurrentContext();
+                yield this.entityAuditService.logEntityChange(entityType, entityId, enums_1.AuditOperation.CREATE, {}, entity, {
+                    requestId: context.requestId,
+                    requestIp: context.requestIp,
+                    userAgent: context.userAgent,
+                });
+            }
+            catch (error) {
+                console.error('Failed to log audit for insert:', error);
+            }
+        });
+    }
+    afterUpdate(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entity = event.entity;
+            const databaseEntity = event.databaseEntity;
+            if (!entity)
+                return;
+            const entityType = entity.constructor.name;
+            const entityId = entity.id;
+            if (!this.isAuditEnabled(entity)) {
+                return;
+            }
+            if (!this.auditStrategy.shouldRecord(entityType, enums_1.AuditOperation.UPDATE)) {
+                return;
+            }
+            try {
+                const context = yield this.contextService.getCurrentContext();
+                yield this.entityAuditService.logEntityChange(entityType, entityId, enums_1.AuditOperation.UPDATE, databaseEntity || {}, entity, {
+                    requestId: context.requestId,
+                    requestIp: context.requestIp,
+                    userAgent: context.userAgent,
+                });
+            }
+            catch (error) {
+                console.error('Failed to log audit for update:', error);
+            }
+        });
+    }
+    beforeRemove(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entity = event.entity;
+            if (!entity)
+                return;
+            const entityType = entity.constructor.name;
+            const entityId = entity.id;
+            if (!this.isAuditEnabled(entity)) {
+                return;
+            }
+            if (!this.auditStrategy.shouldRecord(entityType, enums_1.AuditOperation.DELETE)) {
+                return;
+            }
+            try {
+                const context = yield this.contextService.getCurrentContext();
+                yield this.entityAuditService.logEntityChange(entityType, entityId, enums_1.AuditOperation.DELETE, entity, {}, {
+                    requestId: context.requestId,
+                    requestIp: context.requestIp,
+                    userAgent: context.userAgent,
+                });
+            }
+            catch (error) {
+                console.error('Failed to log audit for delete:', error);
+            }
+        });
+    }
+    isAuditEnabled(entity) {
+        try {
+            const auditOptions = Reflect.getMetadata(decorators_1.ENTITY_AUDIT_OPTIONS, entity.constructor);
+            if (auditOptions && auditOptions.enabled === false) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return true;
+        }
+    }
+};
+exports.EntityAuditSubscriber = EntityAuditSubscriber;
+exports.EntityAuditSubscriber = EntityAuditSubscriber = __decorate([
+    (0, common_1.Injectable)(),
+    (0, typeorm_1.EventSubscriber)(),
+    __metadata("design:paramtypes", [entity_audit_service_1.EntityAuditService,
+        audit_context_service_1.AuditContextService,
+        audit_strategy_service_1.DefaultAuditStrategy,
+        typeorm_1.DataSource])
+], EntityAuditSubscriber);