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

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);

package/audit/subscribers/index.d.ts

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

package/audit/subscribers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entity-audit.subscriber"), exports);

package/common/abstract.entity.js

@@ -43,7 +43,7 @@ class AbstractEntity extends AbstractBaseEntity {
 }
 exports.AbstractEntity = AbstractEntity;
 __decorate([
-    (0, typeorm_1.PrimaryGeneratedColumn)('increment'),
+    (0, typeorm_1.PrimaryColumn)(),
     (0, decorators_1.NumberFieldOptional)({ swagger: false }),
     __metadata("design:type", Number)
 ], AbstractEntity.prototype, "id", void 0);

package/http-client/examples/advanced-usage.example.js

@@ -22,6 +22,7 @@ exports.PaymentHttpService = exports.GitHubHttpService = void 0;
 const common_1 = require("@nestjs/common");
 const decorators_1 = require("../decorators");
 const http_client_service_1 = require("../services/http-client.service");
+const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
 let GitHubHttpService = class GitHubHttpService {
     constructor(httpClient) {
         this.httpClient = httpClient;
@@ -187,15 +188,22 @@ exports.GitHubHttpService = GitHubHttpService = __decorate([
         cache: {
             enabled: true,
             defaultTtl: 300000,
+            cacheableMethods: ['GET', 'HEAD'],
+            cacheableStatusCodes: [200, 304],
             options: {
-                layers: ['memory', 'redis'],
+                layers: [cache_options_interface_1.CacheLayer.MEMORY, cache_options_interface_1.CacheLayer.REDIS],
             },
         },
         logging: {
             enabled: true,
+            logRequests: true,
+            logResponses: true,
+            logErrors: true,
             logHeaders: true,
             logBody: true,
+            maxBodyLength: 1000,
             sanitizeHeaders: ['authorization'],
+            logLevel: 'info',
         },
     }),
     (0, common_1.Injectable)(),
@@ -309,9 +317,14 @@ exports.PaymentHttpService = PaymentHttpService = __decorate([
         },
         logging: {
             enabled: true,
+            logRequests: true,
+            logResponses: true,
+            logErrors: true,
             logHeaders: false,
             logBody: false,
+            maxBodyLength: 1000,
             sanitizeHeaders: ['authorization', 'x-api-key', 'x-client-secret'],
+            logLevel: 'info',
         },
     }),
     (0, common_1.Injectable)(),

package/http-client/examples/auth-with-waiting-lock.example.d.ts

@@ -0,0 +1,17 @@
+import { HttpClientService } from '../services/http-client.service';
+import { HttpLogQueryService } from '../services/http-log-query.service';
+import { HttpReplayService } from '../services/http-replay.service';
+export declare class AuthWithWaitingLockExample {
+    private readonly httpClient;
+    private readonly logQueryService;
+    private readonly replayService;
+    private readonly logger;
+    constructor(httpClient: HttpClientService, logQueryService: HttpLogQueryService, replayService: HttpReplayService);
+    basicAuthWithLock(): Promise<any>;
+    batchAuthWithLock(): Promise<any[]>;
+    generateCurlFromLogs(): Promise<void>;
+    demonstrateRequestReplay(): Promise<void>;
+    batchReplayAndCompare(): Promise<void>;
+    comprehensiveDemo(): Promise<void>;
+    runAllExamples(): Promise<void>;
+}