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

package/http-client/services/http-replay.service.js

@@ -0,0 +1,266 @@
+"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());
+    });
+};
+var HttpReplayService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpReplayService = void 0;
+const common_1 = require("@nestjs/common");
+const http_client_service_1 = require("./http-client.service");
+const http_log_query_service_1 = require("./http-log-query.service");
+let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
+    constructor(httpClient, logQueryService) {
+        this.httpClient = httpClient;
+        this.logQueryService = logQueryService;
+        this.logger = new common_1.Logger(HttpReplayService_1.name);
+    }
+    replayByLogId(logId_1) {
+        return __awaiter(this, arguments, void 0, function* (logId, options = {}) {
+            const startTime = Date.now();
+            const replayId = this.generateReplayId();
+            try {
+                const originalLog = yield this.logQueryService.findLogById(logId, true);
+                if (!originalLog) {
+                    throw new Error(`Log with ID ${logId} not found`);
+                }
+                const requestConfig = this.buildReplayConfig(originalLog, options);
+                if (options.logReplay !== false) {
+                    this.logger.log(`Starting replay for log ${logId} (replay ID: ${replayId})`);
+                }
+                const response = yield this.executeReplayRequest(requestConfig, options);
+                const endTime = Date.now();
+                const responseTime = endTime - startTime;
+                const result = {
+                    originalLog,
+                    requestConfig,
+                    response,
+                    responseTime,
+                    success: true,
+                    replayTimestamp: new Date().toISOString(),
+                    replayId,
+                };
+                if (options.logReplay !== false) {
+                    this.logger.log(`Replay completed for log ${logId} (replay ID: ${replayId}) in ${responseTime}ms`);
+                }
+                return result;
+            }
+            catch (error) {
+                const endTime = Date.now();
+                const responseTime = endTime - startTime;
+                const result = {
+                    originalLog: {},
+                    requestConfig: {},
+                    response: null,
+                    responseTime,
+                    success: false,
+                    error: error.message,
+                    replayTimestamp: new Date().toISOString(),
+                    replayId,
+                };
+                this.logger.error(`Replay failed for log ${logId} (replay ID: ${replayId}): ${error.message}`, error);
+                return result;
+            }
+        });
+    }
+    replayByRequestId(requestId_1) {
+        return __awaiter(this, arguments, void 0, function* (requestId, options = {}) {
+            const originalLog = yield this.logQueryService.findLogByRequestId(requestId);
+            if (!originalLog) {
+                throw new Error(`Log with requestId ${requestId} not found`);
+            }
+            return this.replayByLogId(originalLog.id, options);
+        });
+    }
+    batchReplay(logIds_1) {
+        return __awaiter(this, arguments, void 0, function* (logIds, options = {}, concurrency = 5) {
+            const startTime = Date.now();
+            this.logger.log(`Starting batch replay for ${logIds.length} logs`);
+            const results = [];
+            const chunks = this.chunkArray(logIds, concurrency);
+            for (const chunk of chunks) {
+                const chunkPromises = chunk.map((logId) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        return yield this.replayByLogId(logId, options);
+                    }
+                    catch (error) {
+                        this.logger.error(`Failed to replay log ${logId}`, error);
+                        return {
+                            originalLog: {},
+                            requestConfig: {},
+                            response: null,
+                            responseTime: 0,
+                            success: false,
+                            error: error.message,
+                            replayTimestamp: new Date().toISOString(),
+                            replayId: this.generateReplayId(),
+                        };
+                    }
+                }));
+                const chunkResults = yield Promise.all(chunkPromises);
+                results.push(...chunkResults);
+            }
+            const successfulRequests = results.filter((r) => r.success).length;
+            const failedRequests = results.length - successfulRequests;
+            const totalResponseTime = results.reduce((sum, r) => sum + r.responseTime, 0);
+            const averageResponseTime = results.length > 0 ? totalResponseTime / results.length : 0;
+            const batchResult = {
+                totalRequests: results.length,
+                successfulRequests,
+                failedRequests,
+                successRate: results.length > 0 ? (successfulRequests / results.length) * 100 : 0,
+                totalResponseTime,
+                averageResponseTime,
+                results,
+            };
+            this.logger.log(`Batch replay completed: ${successfulRequests}/${results.length} successful in ${totalResponseTime}ms`);
+            return batchResult;
+        });
+    }
+    batchReplayByQuery() {
+        return __awaiter(this, arguments, void 0, function* (queryOptions = {}, replayOptions = {}, concurrency = 5) {
+            const limitedQueryOptions = Object.assign(Object.assign({}, queryOptions), { limit: Math.min(queryOptions.limit || 50, 100) });
+            const queryResult = yield this.logQueryService.findLogs(limitedQueryOptions);
+            const logIds = queryResult.logs.map((log) => log.id);
+            if (logIds.length === 0) {
+                this.logger.log('No logs found for replay query');
+                return {
+                    totalRequests: 0,
+                    successfulRequests: 0,
+                    failedRequests: 0,
+                    successRate: 0,
+                    totalResponseTime: 0,
+                    averageResponseTime: 0,
+                    results: [],
+                };
+            }
+            this.logger.log(`Found ${logIds.length} logs for batch replay`);
+            return this.batchReplay(logIds, replayOptions, concurrency);
+        });
+    }
+    replayAndCompare(logId_1) {
+        return __awaiter(this, arguments, void 0, function* (logId, options = {}) {
+            var _a, _b, _c;
+            const originalLog = yield this.logQueryService.findLogById(logId, true);
+            if (!originalLog) {
+                throw new Error(`Log with ID ${logId} not found`);
+            }
+            const replayResult = yield this.replayByLogId(logId, options);
+            const comparison = {
+                statusMatch: originalLog.statusCode === ((_a = replayResult.response) === null || _a === void 0 ? void 0 : _a.status),
+                responseTimeDifference: replayResult.responseTime - originalLog.responseTime,
+                headersMatch: this.compareHeaders(originalLog.responseHeaders || {}, ((_b = replayResult.response) === null || _b === void 0 ? void 0 : _b.headers) || {}),
+                bodyMatch: this.compareBodies(originalLog.responseBody, (_c = replayResult.response) === null || _c === void 0 ? void 0 : _c.data),
+            };
+            return {
+                original: originalLog,
+                replay: replayResult,
+                comparison,
+            };
+        });
+    }
+    buildReplayConfig(log, options) {
+        const config = {
+            method: log.method,
+            url: log.url,
+            headers: Object.assign({}, log.headers),
+            params: Object.assign({}, log.params),
+        };
+        if (log.body) {
+            try {
+                config.data =
+                    typeof log.body === 'string' ? JSON.parse(log.body) : log.body;
+            }
+            catch (_a) {
+                config.data = log.body;
+            }
+        }
+        if (options.overrideHeaders) {
+            config.headers = Object.assign(Object.assign({}, config.headers), options.additionalHeaders);
+        }
+        else if (options.additionalHeaders) {
+            config.headers = Object.assign(Object.assign({}, config.headers), options.additionalHeaders);
+        }
+        if (options.overrideBody && options.additionalHeaders) {
+        }
+        if (options.overrideParams && options.metadata) {
+            config.params = Object.assign(Object.assign({}, config.params), options.metadata);
+        }
+        if (options.timeout) {
+            config.timeout = options.timeout;
+        }
+        config.metadata = Object.assign({ originalLogId: log.id, originalRequestId: log.requestId, replayTimestamp: new Date().toISOString(), replayedBy: 'http-replay-service' }, options.metadata);
+        return config;
+    }
+    executeReplayRequest(config, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.httpClient.request(config);
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    generateReplayId() {
+        return `replay-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+    compareHeaders(original, replay) {
+        const ignoreHeaders = ['date', 'expires', 'last-modified', 'etag'];
+        const originalFiltered = Object.keys(original)
+            .filter((key) => !ignoreHeaders.includes(key.toLowerCase()))
+            .reduce((obj, key) => {
+            obj[key] = original[key];
+            return obj;
+        }, {});
+        const replayFiltered = Object.keys(replay)
+            .filter((key) => !ignoreHeaders.includes(key.toLowerCase()))
+            .reduce((obj, key) => {
+            obj[key] = replay[key];
+            return obj;
+        }, {});
+        return JSON.stringify(originalFiltered) === JSON.stringify(replayFiltered);
+    }
+    compareBodies(original, replay) {
+        if (!original && !replay)
+            return true;
+        if (!original || !replay)
+            return false;
+        try {
+            const originalParsed = typeof original === 'string' ? JSON.parse(original) : original;
+            const replayString = typeof replay === 'string' ? replay : JSON.stringify(replay);
+            const replayParsed = JSON.parse(replayString);
+            return JSON.stringify(originalParsed) === JSON.stringify(replayParsed);
+        }
+        catch (_a) {
+            return original === replay;
+        }
+    }
+};
+exports.HttpReplayService = HttpReplayService;
+exports.HttpReplayService = HttpReplayService = HttpReplayService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService,
+        http_log_query_service_1.HttpLogQueryService])
+], HttpReplayService);

package/http-client/services/log-cleanup.service.js

@@ -23,7 +23,7 @@ exports.HttpLogCleanupService = void 0;
 const common_1 = require("@nestjs/common");
 const schedule_1 = require("@nestjs/schedule");
 const http_log_query_service_1 = require("./http-log-query.service");
-const setup_1 = require("../../setup");
+const schedule_decorator_1 = require("../../setup/schedule.decorator");
 let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupService {
     constructor(logQueryService, config = {}) {
         this.logQueryService = logQueryService;
@@ -257,7 +257,7 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
 };
 exports.HttpLogCleanupService = HttpLogCleanupService;
 __decorate([
-    (0, setup_1.WorkerCronSmart)(schedule_1.CronExpression.EVERY_DAY_AT_2AM),
+    (0, schedule_decorator_1.WorkerCronSmart)(schedule_1.CronExpression.EVERY_DAY_AT_2AM),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)

package/http-client/services/logging.service.js

@@ -23,7 +23,7 @@ exports.HttpLoggingService = void 0;
 const common_1 = require("@nestjs/common");
 const typeorm_1 = require("typeorm");
 const http_log_entity_1 = require("../entities/http-log.entity");
-const request_id_util_1 = require("../../../../http-client/src/utils/request-id.util");
+const request_id_util_1 = require("../utils/request-id.util");
 const context_extractor_util_1 = require("../utils/context-extractor.util");
 const call_stack_extractor_util_1 = require("../utils/call-stack-extractor.util");
 let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {

package/http-client/utils/request-id.util.d.ts

@@ -0,0 +1,4 @@
+export declare function generateRequestId(): string;
+export declare function generateShortRequestId(): string;
+export declare function isValidRequestId(requestId: string): boolean;
+export declare function extractRequestId(headers: Record<string, string>): string | null;

package/http-client/utils/request-id.util.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRequestId = generateRequestId;
+exports.generateShortRequestId = generateShortRequestId;
+exports.isValidRequestId = isValidRequestId;
+exports.extractRequestId = extractRequestId;
+const crypto_1 = require("crypto");
+function generateRequestId() {
+    return (0, crypto_1.randomUUID)();
+}
+function generateShortRequestId() {
+    return Math.random().toString(36).substring(2, 15);
+}
+function isValidRequestId(requestId) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(requestId);
+}
+function extractRequestId(headers) {
+    const requestIdHeaders = [
+        'x-request-id',
+        'x-trace-id',
+        'request-id',
+        'trace-id',
+        'x-correlation-id',
+        'correlation-id',
+    ];
+    for (const header of requestIdHeaders) {
+        const value = headers[header];
+        if (value && isValidRequestId(value)) {
+            return value;
+        }
+    }
+    return null;
+}

package/index.d.ts

@@ -17,3 +17,4 @@ export * from './http-client';
 export * from './vault';
 export * from './setup';
 export * from './health-checker';
+export * from './audit';

package/index.js

@@ -33,3 +33,4 @@ __exportStar(require("./http-client"), exports);
 __exportStar(require("./vault"), exports);
 __exportStar(require("./setup"), exports);
 __exportStar(require("./health-checker"), exports);
+__exportStar(require("./audit"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "3.1.2-8",
+  "version": "4.1.2-9",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",

package/setup/bootstrap.setup.js

@@ -139,7 +139,11 @@ function bootstrapSetup(AppModule, SetupSwagger) {
         app.enableShutdownHooks();
         app.enableVersioning();
         app.enable('trust proxy');
-        app.use(bodyParse.json({ limit: '50mb' }), new nestjs_cls_1.ClsMiddleware({
+        app.set('query parser', 'extended');
+        app.use(bodyParse.urlencoded({
+            extended: true,
+            parameterLimit: 1000,
+        }), bodyParse.json({ limit: '50mb' }), new nestjs_cls_1.ClsMiddleware({
             saveReq: true,
         }).use, (0, __1.RequestIdMiddleware)(), (0, __1.PowerByMiddleware)(), (0, __1.OmniAuthMiddleware)(), compression());
         const reflector = app.get(core_1.Reflector);