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

package/audit/services/manual-audit-log.service.js

@@ -0,0 +1,184 @@
+"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());
+    });
+};
+var ManualAuditLogService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManualAuditLogService = 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 audit_context_service_1 = require("./audit-context.service");
+const enums_1 = require("../enums");
+const crypto_1 = require("crypto");
+let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogService {
+    constructor(manualLogRepository, transactionRepository, contextService, dataSource) {
+        this.manualLogRepository = manualLogRepository;
+        this.transactionRepository = transactionRepository;
+        this.contextService = contextService;
+        this.dataSource = dataSource;
+        ManualAuditLogService_1.instance = this;
+    }
+    static log(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ManualAuditLogService_1.instance) {
+                throw new Error('ManualAuditLogService is not initialized. Make sure AuditModule is imported.');
+            }
+            return ManualAuditLogService_1.instance.logOperation(options);
+        });
+    }
+    logOperation(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { templateKey, description, descriptionTemplate, descriptionParams, userId, username, requestIp, rollbackActions, transactionId, autoCreateTransaction = true, } = options;
+            if (!templateKey && !description && !descriptionTemplate) {
+                throw new Error('ManualAuditLogService.log() requires one of: templateKey, description, or descriptionTemplate');
+            }
+            const modeCount = [templateKey, description, descriptionTemplate].filter(Boolean).length;
+            if (modeCount > 1) {
+                throw new Error('ManualAuditLogService.log() accepts only one mode: use either templateKey, description, or descriptionTemplate');
+            }
+            const context = yield this.contextService.getCurrentContext();
+            const finalUserId = userId || context.userId || 'system';
+            const finalUsername = username || context.username || 'system';
+            const finalRequestIp = requestIp || context.requestIp || 'unknown';
+            let finalTransactionId = transactionId || context.transactionId;
+            if (!finalTransactionId && autoCreateTransaction) {
+                finalTransactionId = yield this.createTransaction(finalUserId, finalUsername);
+            }
+            const manualLog = this.manualLogRepository.create({
+                transactionId: finalTransactionId,
+                operationTemplateKey: templateKey || null,
+                descriptionParams: descriptionParams || null,
+                directDescription: description || null,
+                inlineTemplate: descriptionTemplate || null,
+                userId: finalUserId,
+                username: finalUsername,
+                requestIp: finalRequestIp,
+                rollbackActions: rollbackActions || [],
+            });
+            return this.manualLogRepository.save(manualLog);
+        });
+    }
+    static beginTransaction(userId, username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ManualAuditLogService_1.instance) {
+                throw new Error('ManualAuditLogService is not initialized');
+            }
+            return ManualAuditLogService_1.instance.createTransaction(userId, username);
+        });
+    }
+    static commitTransaction(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ManualAuditLogService_1.instance) {
+                throw new Error('ManualAuditLogService is not initialized');
+            }
+            yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.COMMITTED);
+        });
+    }
+    static rollbackTransaction(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ManualAuditLogService_1.instance) {
+                throw new Error('ManualAuditLogService is not initialized');
+            }
+            yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.ROLLED_BACK);
+        });
+    }
+    createTransaction(userId, username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.contextService.getCurrentContext();
+            const transaction = this.transactionRepository.create({
+                description: 'Manual operation transaction',
+                userId: userId || context.userId || 'system',
+                username: username || context.username || 'system',
+                requestIp: context.requestIp || 'unknown',
+                status: enums_1.TransactionStatus.PENDING,
+                entities: [],
+            });
+            const saved = yield this.transactionRepository.save(transaction);
+            return saved.id;
+        });
+    }
+    updateTransactionStatus(transactionId, status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transactionRepository.update({ id: transactionId }, { status });
+        });
+    }
+    generateTransactionId() {
+        return `txn-${Date.now()}-${(0, crypto_1.randomBytes)(8).toString('hex')}`;
+    }
+    static logBatch(operations, sharedTransactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ManualAuditLogService_1.instance) {
+                throw new Error('ManualAuditLogService is not initialized');
+            }
+            const transactionId = sharedTransactionId ||
+                (yield ManualAuditLogService_1.instance.createTransaction());
+            const results = [];
+            for (const operation of operations) {
+                const result = yield ManualAuditLogService_1.instance.logOperation(Object.assign(Object.assign({}, operation), { transactionId, autoCreateTransaction: false }));
+                results.push(result);
+            }
+            if (!sharedTransactionId) {
+                yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.COMMITTED);
+            }
+            return results;
+        });
+    }
+    static findLogs(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ManualAuditLogService_1.instance) {
+                throw new Error('ManualAuditLogService is not initialized');
+            }
+            const { templateKey, userId, transactionId, startTime, endTime, limit = 100 } = options;
+            const query = ManualAuditLogService_1.instance.manualLogRepository
+                .createQueryBuilder('log')
+                .orderBy('log.createdAt', 'DESC')
+                .take(limit);
+            if (templateKey) {
+                query.andWhere('log.operationTemplateKey = :templateKey', { templateKey });
+            }
+            if (userId) {
+                query.andWhere('log.userId = :userId', { userId });
+            }
+            if (transactionId) {
+                query.andWhere('log.transactionId = :transactionId', { transactionId });
+            }
+            if (startTime) {
+                query.andWhere('log.createdAt >= :startTime', { startTime });
+            }
+            if (endTime) {
+                query.andWhere('log.createdAt <= :endTime', { endTime });
+            }
+            return query.getMany();
+        });
+    }
+};
+exports.ManualAuditLogService = ManualAuditLogService;
+exports.ManualAuditLogService = ManualAuditLogService = ManualAuditLogService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(entities_1.ManualOperationLogEntity, 'audit')),
+    __param(1, (0, typeorm_1.InjectRepository)(entities_1.EntityTransactionEntity, 'audit')),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        audit_context_service_1.AuditContextService,
+        typeorm_2.DataSource])
+], ManualAuditLogService);

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;
+}

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;
+}