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

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

@@ -0,0 +1,626 @@
+"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.EntityAuditService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const crypto_1 = require("crypto");
+const entities_1 = require("../entities");
+const enums_1 = require("../enums");
+const audit_context_service_1 = require("./audit-context.service");
+const audit_strategy_service_1 = require("./audit-strategy.service");
+const multi_database_service_1 = require("./multi-database.service");
+const dto_1 = require("../../common/dto");
+let EntityAuditService = class EntityAuditService {
+    constructor(auditLogRepository, transactionRepository, manualOperationRepository, entityManager, contextService, multiDbService, auditStrategy = new audit_strategy_service_1.DefaultAuditStrategy(), config, auditConnectionName) {
+        this.auditLogRepository = auditLogRepository;
+        this.transactionRepository = transactionRepository;
+        this.manualOperationRepository = manualOperationRepository;
+        this.entityManager = entityManager;
+        this.contextService = contextService;
+        this.multiDbService = multiDbService;
+        this.auditStrategy = auditStrategy;
+        this.config = config;
+        this.auditConnectionName = auditConnectionName || 'default';
+    }
+    logEntityChange(entityType_1, entityId_1, operation_1, oldValue_1, newValue_1) {
+        return __awaiter(this, arguments, void 0, function* (entityType, entityId, operation, oldValue, newValue, metadata = {}) {
+            var _a, _b;
+            if (!this.auditStrategy.shouldRecord(entityType, operation)) {
+                return null;
+            }
+            const recordStrategy = this.auditStrategy.getRecordStrategy(entityType, operation);
+            if (recordStrategy === enums_1.RecordStrategy.DISABLED) {
+                return null;
+            }
+            const fieldFilter = this.auditStrategy.getFieldFilter(entityType);
+            const filteredOldValue = this.filterAndMaskFields(oldValue, fieldFilter);
+            const filteredNewValue = this.filterAndMaskFields(newValue, fieldFilter);
+            const changedFields = this.calculateChangedFields(filteredOldValue, filteredNewValue);
+            const changedFieldPaths = this.calculateChangedFieldPaths(filteredOldValue, filteredNewValue);
+            const context = yield this.contextService.getCurrentContext();
+            const auditLog = this.auditLogRepository.create({
+                entityType,
+                entityId,
+                operation,
+                oldValue: filteredOldValue,
+                newValue: filteredNewValue,
+                changedFields,
+                changedFieldPaths: changedFieldPaths.join(','),
+                userId: context.userId || metadata.userId,
+                username: context.username || metadata.username,
+                requestId: context.requestId || metadata.requestId,
+                requestIp: context.requestIp || metadata.requestIp,
+                userAgent: context.userAgent || metadata.userAgent,
+                description: this.generateDescription(operation, entityType, entityId, changedFields),
+                hashChain: ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.security) === null || _b === void 0 ? void 0 : _b.hashChainEnabled)
+                    ? yield this.generateHashChain(entityType, entityId, filteredNewValue)
+                    : undefined,
+            });
+            const savedLog = yield this.auditLogRepository.save(auditLog);
+            return savedLog;
+        });
+    }
+    getAuditLogs(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const page = query.page || 1;
+            const limit = query.limit || 20;
+            const sortBy = query.sortBy || 'createdAt';
+            const sortOrder = query.sortOrder || 'DESC';
+            const queryBuilder = this.auditLogRepository.createQueryBuilder('log');
+            if (query.entityType) {
+                queryBuilder.andWhere('log.entityType = :entityType', { entityType: query.entityType });
+            }
+            if (query.entityId) {
+                queryBuilder.andWhere('log.entityId = :entityId', { entityId: query.entityId });
+            }
+            if (query.operation) {
+                queryBuilder.andWhere('log.operation = :operation', { operation: query.operation });
+            }
+            if (query.userId) {
+                queryBuilder.andWhere('log.userId = :userId', { userId: query.userId });
+            }
+            if (query.startDate && query.endDate) {
+                queryBuilder.andWhere('log.createdAt BETWEEN :startDate AND :endDate', {
+                    startDate: query.startDate,
+                    endDate: query.endDate,
+                });
+            }
+            if (query.search) {
+                queryBuilder.andWhere('(log.description LIKE :search OR log.changedFieldPaths LIKE :search)', {
+                    search: `%${query.search}%`,
+                });
+            }
+            queryBuilder.orderBy(`log.${sortBy}`, sortOrder);
+            const skip = (page - 1) * limit;
+            queryBuilder.skip(skip).take(limit);
+            const [data, total] = yield queryBuilder.getManyAndCount();
+            const pageOptionsDto = new dto_1.PageOptionsDto();
+            Object.assign(pageOptionsDto, { page, pageSize: limit });
+            const pageMetaDto = new dto_1.PageMetaDto({
+                pageOptionsDto,
+                itemCount: total,
+            });
+            return new dto_1.PageDto(data, pageMetaDto);
+        });
+    }
+    compareEntities(entityType, entityId, fromLogId, toLogId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let fromData = {};
+            let toData = {};
+            if (fromLogId) {
+                const fromLog = yield this.auditLogRepository.findOne({ where: { id: fromLogId } });
+                fromData = (fromLog === null || fromLog === void 0 ? void 0 : fromLog.newValue) || {};
+            }
+            if (toLogId) {
+                const toLog = yield this.auditLogRepository.findOne({ where: { id: toLogId } });
+                toData = (toLog === null || toLog === void 0 ? void 0 : toLog.newValue) || {};
+            }
+            else {
+                const latestLog = yield this.auditLogRepository.findOne({
+                    where: { entityType, entityId },
+                    order: { createdAt: 'DESC' },
+                });
+                toData = (latestLog === null || latestLog === void 0 ? void 0 : latestLog.newValue) || {};
+            }
+            return this.compareSnapshotData(fromData, toData);
+        });
+    }
+    preCheckRestore(entityType, entityId, auditLogId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const auditLog = yield this.auditLogRepository.findOne({ where: { id: auditLogId } });
+            if (!auditLog) {
+                return {
+                    canRestore: false,
+                    conflicts: [
+                        {
+                            field: 'auditLog',
+                            reason: '审计日志不存在',
+                            currentValue: null,
+                            targetValue: null,
+                        },
+                    ],
+                    warnings: [],
+                };
+            }
+            const repository = this.entityManager.getRepository(entityType);
+            const currentEntity = yield repository.findOne({ where: { id: entityId } });
+            if (!currentEntity) {
+                return {
+                    canRestore: false,
+                    conflicts: [
+                        {
+                            field: 'entity',
+                            reason: '实体不存在',
+                            currentValue: null,
+                            targetValue: auditLog.oldValue,
+                        },
+                    ],
+                    warnings: [],
+                };
+            }
+            const conflicts = this.detectConflicts(currentEntity, auditLog.oldValue);
+            return {
+                canRestore: conflicts.length === 0,
+                conflicts,
+                warnings: conflicts.length > 0 ? ['存在字段冲突，可能需要强制恢复'] : [],
+            };
+        });
+    }
+    restoreEntity(entityType_1, entityId_1, auditLogId_1) {
+        return __awaiter(this, arguments, void 0, function* (entityType, entityId, auditLogId, options = {}) {
+            const auditLog = yield this.auditLogRepository.findOne({ where: { id: auditLogId } });
+            if (!auditLog) {
+                return {
+                    success: false,
+                    message: '审计日志不存在',
+                };
+            }
+            const preCheckResult = yield this.preCheckRestore(entityType, entityId, auditLogId);
+            if (!preCheckResult.canRestore && !options.force) {
+                return {
+                    success: false,
+                    conflicts: preCheckResult.conflicts,
+                    message: '恢复操作存在冲突，请使用强制恢复或解决冲突后重试',
+                };
+            }
+            try {
+                const connectionName = options.connectionName || 'default';
+                const dataSource = yield this.multiDbService.getDataSource(connectionName);
+                const repository = dataSource.getRepository(entityType);
+                const restoreData = Object.assign({}, auditLog.oldValue);
+                if (options.includeFields && options.includeFields.length > 0) {
+                    Object.keys(restoreData).forEach((key) => {
+                        if (!options.includeFields.includes(key)) {
+                            delete restoreData[key];
+                        }
+                    });
+                }
+                if (options.excludeFields && options.excludeFields.length > 0) {
+                    options.excludeFields.forEach((field) => {
+                        delete restoreData[field];
+                    });
+                }
+                if (!options.dryRun) {
+                    yield repository.update({ id: entityId }, restoreData);
+                    yield this.logEntityChange(entityType, entityId, enums_1.AuditOperation.RESTORE, auditLog.newValue, restoreData);
+                }
+                return {
+                    success: true,
+                    message: options.dryRun ? '预演成功' : '恢复成功',
+                    restoredEntities: [{ entityType, entityId }],
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: `恢复失败: ${error.message}`,
+                };
+            }
+        });
+    }
+    calculateChangedFields(oldValue, newValue) {
+        const changedFields = [];
+        const allFields = new Set([...Object.keys(oldValue || {}), ...Object.keys(newValue || {})]);
+        for (const field of allFields) {
+            const oldVal = oldValue === null || oldValue === void 0 ? void 0 : oldValue[field];
+            const newVal = newValue === null || newValue === void 0 ? void 0 : newValue[field];
+            if (!this.deepEqual(oldVal, newVal)) {
+                changedFields.push(field);
+            }
+        }
+        return changedFields;
+    }
+    calculateChangedFieldPaths(oldValue, newValue) {
+        const changedPaths = [];
+        const diff = this.deepDiff(oldValue, newValue);
+        for (const change of diff) {
+            changedPaths.push(change.path.join('.'));
+        }
+        return changedPaths;
+    }
+    deepEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a == null || b == null)
+            return false;
+        if (typeof a !== typeof b)
+            return false;
+        if (typeof a !== 'object')
+            return a === b;
+        if (Array.isArray(a) !== Array.isArray(b))
+            return false;
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const key of keysA) {
+            if (!keysB.includes(key))
+                return false;
+            if (!this.deepEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    deepDiff(oldObj, newObj, path = []) {
+        var _a;
+        const changes = [];
+        const maxDepth = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.maxDiffDepth) || 5;
+        if (path.length > maxDepth) {
+            return changes;
+        }
+        if (typeof oldObj !== 'object' || oldObj === null) {
+            if (oldObj !== newObj) {
+                changes.push({
+                    path,
+                    type: 'CHANGE',
+                    oldValue: oldObj,
+                    newValue: newObj,
+                });
+            }
+            return changes;
+        }
+        if (Array.isArray(oldObj)) {
+            if (!Array.isArray(newObj)) {
+                changes.push({
+                    path,
+                    type: 'CHANGE',
+                    oldValue: oldObj,
+                    newValue: newObj,
+                });
+                return changes;
+            }
+            if (oldObj.length !== newObj.length) {
+                changes.push({
+                    path,
+                    type: 'CHANGE',
+                    oldValue: oldObj,
+                    newValue: newObj,
+                });
+                return changes;
+            }
+            for (let i = 0; i < oldObj.length; i++) {
+                changes.push(...this.deepDiff(oldObj[i], newObj[i], [...path, i.toString()]));
+            }
+            return changes;
+        }
+        const allKeys = new Set([...Object.keys(oldObj), ...Object.keys(newObj)]);
+        for (const key of allKeys) {
+            const oldVal = oldObj[key];
+            const newVal = newObj[key];
+            if (!(key in oldObj)) {
+                changes.push({
+                    path: [...path, key],
+                    type: 'ADD',
+                    oldValue: undefined,
+                    newValue: newVal,
+                });
+            }
+            else if (!(key in newObj)) {
+                changes.push({
+                    path: [...path, key],
+                    type: 'REMOVE',
+                    oldValue: oldVal,
+                    newValue: undefined,
+                });
+            }
+            else {
+                changes.push(...this.deepDiff(oldVal, newVal, [...path, key]));
+            }
+        }
+        return changes;
+    }
+    compareSnapshotData(fromData, toData) {
+        const changes = this.deepDiff(fromData, toData);
+        return {
+            changes,
+            summary: {
+                added: changes.filter((c) => c.type === 'ADD').length,
+                removed: changes.filter((c) => c.type === 'REMOVE').length,
+                changed: changes.filter((c) => c.type === 'CHANGE').length,
+            },
+        };
+    }
+    filterAndMaskFields(data, fieldFilter, path = []) {
+        if (typeof data !== 'object' || data === null) {
+            return data;
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(data)) {
+            const currentPath = [...path, key];
+            if (!fieldFilter.shouldIncludeField(key, currentPath)) {
+                continue;
+            }
+            if (fieldFilter.shouldMaskField(key, currentPath)) {
+                const maskingStrategy = fieldFilter.getMaskingStrategy(key, currentPath);
+                result[key] = this.applyMasking(value, maskingStrategy);
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = this.filterAndMaskFields(value, fieldFilter, currentPath);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    applyMasking(value, strategy) {
+        if (value == null)
+            return value;
+        switch (strategy) {
+            case enums_1.MaskingStrategy.NONE:
+                return value;
+            case enums_1.MaskingStrategy.HASH:
+                return this.hashValue(value);
+            case enums_1.MaskingStrategy.MASK:
+                return this.maskValue(value);
+            case enums_1.MaskingStrategy.PARTIAL:
+                return this.partialMaskValue(value);
+            default:
+                return '***MASKED***';
+        }
+    }
+    hashValue(value) {
+        const strValue = String(value);
+        return (0, crypto_1.createHash)('sha256').update(strValue).digest('hex');
+    }
+    maskValue(value) {
+        const strValue = String(value);
+        return '*'.repeat(strValue.length);
+    }
+    partialMaskValue(value) {
+        const strValue = String(value);
+        if (strValue.length <= 4) {
+            return '*'.repeat(strValue.length);
+        }
+        return (strValue.substring(0, 2) +
+            '*'.repeat(strValue.length - 4) +
+            strValue.substring(strValue.length - 2));
+    }
+    generateHashChain(entityType, entityId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const lastLog = yield this.auditLogRepository.findOne({
+                where: { entityType, entityId },
+                order: { createdAt: 'DESC' },
+            });
+            const previousHash = ((_a = lastLog === null || lastLog === void 0 ? void 0 : lastLog.hashChain) === null || _a === void 0 ? void 0 : _a.currentHash) || '';
+            const currentData = JSON.stringify(data);
+            const hashAlgorithm = ((_c = (_b = this.config) === null || _b === void 0 ? void 0 : _b.security) === null || _c === void 0 ? void 0 : _c.hashAlgorithm) || 'sha256';
+            const currentHash = (0, crypto_1.createHash)(hashAlgorithm).update(currentData + previousHash).digest('hex');
+            return {
+                previousHash,
+                currentHash,
+                algorithm: hashAlgorithm,
+            };
+        });
+    }
+    generateDescription(operation, entityType, entityId, changedFields) {
+        const operationText = {
+            [enums_1.AuditOperation.CREATE]: '创建',
+            [enums_1.AuditOperation.UPDATE]: '更新',
+            [enums_1.AuditOperation.DELETE]: '删除',
+            [enums_1.AuditOperation.RESTORE]: '恢复',
+        };
+        const text = operationText[operation] || operation;
+        if (operation === enums_1.AuditOperation.UPDATE && changedFields.length > 0) {
+            return `${text} ${entityType}(${entityId}), 变更字段: ${changedFields.join(', ')}`;
+        }
+        return `${text} ${entityType}(${entityId})`;
+    }
+    detectConflicts(currentEntity, targetValue) {
+        const conflicts = [];
+        for (const [key, targetVal] of Object.entries(targetValue)) {
+            const currentVal = currentEntity[key];
+            if (!this.deepEqual(currentVal, targetVal)) {
+                conflicts.push({
+                    field: key,
+                    reason: '字段值已被修改',
+                    currentValue: currentVal,
+                    targetValue: targetVal,
+                });
+            }
+        }
+        return conflicts;
+    }
+    logEntityChangeWithTemplate(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            if (!this.auditStrategy.shouldRecord(data.entityType, data.operation)) {
+                return null;
+            }
+            const recordStrategy = this.auditStrategy.getRecordStrategy(data.entityType, data.operation);
+            if (recordStrategy === enums_1.RecordStrategy.DISABLED) {
+                return null;
+            }
+            const fieldFilter = this.auditStrategy.getFieldFilter(data.entityType);
+            const filteredOldValue = this.filterAndMaskFields(data.oldValue || {}, fieldFilter);
+            const filteredNewValue = this.filterAndMaskFields(data.newValue || {}, fieldFilter);
+            const changedFields = data.changedFields || this.calculateChangedFields(filteredOldValue, filteredNewValue);
+            const changedFieldPaths = this.calculateChangedFieldPaths(filteredOldValue, filteredNewValue);
+            const context = yield this.contextService.getCurrentContext();
+            const operationTemplateKey = data.operationTemplateKey || `${data.entityType}.${data.operation}`;
+            const descriptionParams = data.descriptionParams || Object.assign(Object.assign(Object.assign({}, filteredOldValue), filteredNewValue), { changedFields, changedFieldsCount: changedFields.length });
+            const auditLog = this.auditLogRepository.create({
+                entityType: data.entityType,
+                entityId: data.entityId,
+                operation: data.operation,
+                oldValue: filteredOldValue,
+                newValue: filteredNewValue,
+                changedFields,
+                changedFieldPaths: changedFieldPaths.join(','),
+                userId: context.userId || ((_a = data.metadata) === null || _a === void 0 ? void 0 : _a.userId),
+                username: context.username || ((_b = data.metadata) === null || _b === void 0 ? void 0 : _b.username),
+                requestId: context.requestId || ((_c = data.metadata) === null || _c === void 0 ? void 0 : _c.requestId),
+                requestIp: context.requestIp || ((_d = data.metadata) === null || _d === void 0 ? void 0 : _d.requestIp),
+                userAgent: context.userAgent || ((_e = data.metadata) === null || _e === void 0 ? void 0 : _e.userAgent),
+                description: this.generateDescription(data.operation, data.entityType, data.entityId, changedFields),
+                hashChain: ((_g = (_f = this.config) === null || _f === void 0 ? void 0 : _f.security) === null || _g === void 0 ? void 0 : _g.hashChainEnabled)
+                    ? yield this.generateHashChain(data.entityType, data.entityId, filteredNewValue)
+                    : undefined,
+                operationTemplateKey,
+                descriptionParams,
+                changeDetails: data.changeDetails,
+                rollbackActions: data.rollbackActions,
+            });
+            const savedLog = yield this.auditLogRepository.save(auditLog);
+            return savedLog;
+        });
+    }
+    logManualOperation(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.contextService.getCurrentContext();
+            const manualLog = this.manualOperationRepository.create({
+                transactionId: data.transactionId,
+                operationTemplateKey: data.operationTemplateKey,
+                descriptionParams: data.descriptionParams,
+                userId: data.userId || context.userId,
+                username: data.username || context.username,
+                requestIp: data.requestIp || context.requestIp,
+                rollbackActions: data.rollbackActions || [],
+            });
+            return yield this.manualOperationRepository.save(manualLog);
+        });
+    }
+    withTransaction(fn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const context = yield this.contextService.getCurrentContext();
+            const transaction = this.transactionRepository.create({
+                description: ((_a = options === null || options === void 0 ? void 0 : options.descriptionParams) === null || _a === void 0 ? void 0 : _a.description) || 'Transaction',
+                status: 'PENDING',
+                entities: [],
+                userId: (options === null || options === void 0 ? void 0 : options.userId) || context.userId,
+                username: (options === null || options === void 0 ? void 0 : options.username) || context.username,
+                requestIp: (options === null || options === void 0 ? void 0 : options.requestIp) || context.requestIp,
+                operationTemplateKey: options === null || options === void 0 ? void 0 : options.operationTemplateKey,
+                descriptionParams: options === null || options === void 0 ? void 0 : options.descriptionParams,
+                metadata: options === null || options === void 0 ? void 0 : options.metadata,
+            });
+            const savedTransaction = yield this.transactionRepository.save(transaction);
+            const transactionId = savedTransaction.id;
+            try {
+                yield this.contextService.setContext(Object.assign(Object.assign({}, context), { transactionId }));
+                const result = yield fn(transactionId);
+                yield this.transactionRepository.update(transactionId, {
+                    status: 'COMMITTED',
+                    completedAt: new Date(),
+                });
+                return result;
+            }
+            catch (error) {
+                yield this.transactionRepository.update(transactionId, {
+                    status: 'ROLLED_BACK',
+                    completedAt: new Date(),
+                });
+                throw error;
+            }
+        });
+    }
+    getCurrentTransactionId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.contextService.getCurrentContext();
+            return context.transactionId || null;
+        });
+    }
+    setCurrentTransactionId(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.contextService.getCurrentContext();
+            yield this.contextService.setContext(Object.assign(Object.assign({}, context), { transactionId }));
+        });
+    }
+    beginTransaction(userId, userName, ip, operationTemplateKey, descriptionParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.contextService.getCurrentContext();
+            const transaction = this.transactionRepository.create({
+                description: (descriptionParams === null || descriptionParams === void 0 ? void 0 : descriptionParams.description) || 'Transaction',
+                status: 'pending',
+                entities: [],
+                userId: userId || context.userId,
+                username: userName || context.username,
+                requestIp: ip || context.requestIp,
+                operationTemplateKey,
+                descriptionParams,
+            });
+            const savedTransaction = yield this.transactionRepository.save(transaction);
+            return savedTransaction.id;
+        });
+    }
+    commitTransaction(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transactionRepository.update(transactionId, {
+                status: 'committed',
+                completedAt: new Date(),
+            });
+        });
+    }
+    rollbackTransaction(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transactionRepository.update(transactionId, {
+                status: 'rolled_back',
+                completedAt: new Date(),
+            });
+        });
+    }
+};
+exports.EntityAuditService = EntityAuditService;
+exports.EntityAuditService = EntityAuditService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(entities_1.EntityAuditLogEntity)),
+    __param(1, (0, typeorm_1.InjectRepository)(entities_1.EntityTransactionEntity)),
+    __param(2, (0, typeorm_1.InjectRepository)(entities_1.ManualOperationLogEntity)),
+    __param(3, (0, common_1.Inject)('AUDIT_ENTITY_MANAGER')),
+    __param(6, (0, common_1.Optional)()),
+    __param(6, (0, common_1.Inject)('AUDIT_STRATEGY')),
+    __param(7, (0, common_1.Optional)()),
+    __param(7, (0, common_1.Inject)('AUDIT_CONFIG')),
+    __param(8, (0, common_1.Optional)()),
+    __param(8, (0, common_1.Inject)('AUDIT_CONNECTION_NAME')),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.EntityManager,
+        audit_context_service_1.AuditContextService,
+        multi_database_service_1.MultiDatabaseService, Object, Object, String])
+], EntityAuditService);

package/audit/services/index.d.ts

@@ -0,0 +1,6 @@
+export * from './audit-context.service';
+export * from './audit-strategy.service';
+export * from './entity-audit.service';
+export * from './transaction-audit.service';
+export * from './multi-database.service';
+export * from './operation-description.service';

package/audit/services/index.js

@@ -0,0 +1,22 @@
+"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-context.service"), exports);
+__exportStar(require("./audit-strategy.service"), exports);
+__exportStar(require("./entity-audit.service"), exports);
+__exportStar(require("./transaction-audit.service"), exports);
+__exportStar(require("./multi-database.service"), exports);
+__exportStar(require("./operation-description.service"), exports);

package/audit/services/multi-database.service.d.ts

@@ -0,0 +1,10 @@
+import { DataSource } from 'typeorm';
+import { ModuleRef } from '@nestjs/core';
+export declare class MultiDatabaseService {
+    private readonly moduleRef;
+    private readonly config?;
+    constructor(moduleRef: ModuleRef, config?: any);
+    getDataSource(connectionName?: string): Promise<DataSource>;
+    getMonitoredConnections(): string[];
+    getAuditConnection(): string;
+}