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

package/http-client/utils/context-extractor.util.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextExtractor = void 0;
+const providers_1 = require("../../providers");
+class ContextExtractor {
+    static getHttpContext() {
+        try {
+            const requestId = providers_1.ContextProvider.getRequestId();
+            const authUser = providers_1.ContextProvider.getAuthUser();
+            const router = providers_1.ContextProvider.getRouter();
+            return {
+                requestId,
+                userId: authUser === null || authUser === void 0 ? void 0 : authUser.uid,
+                clientIp: router === null || router === void 0 ? void 0 : router.ip,
+                appId: authUser === null || authUser === void 0 ? void 0 : authUser.appId,
+                metadata: {
+                    authUser,
+                    router,
+                },
+                tags: [],
+            };
+        }
+        catch (_a) {
+            return {
+                tags: [],
+            };
+        }
+    }
+    static getRequestId() {
+        try {
+            return providers_1.ContextProvider.getRequestId();
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    static getUserId() {
+        try {
+            const authUser = providers_1.ContextProvider.getAuthUser();
+            return authUser === null || authUser === void 0 ? void 0 : authUser.uid;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    static getClientIp() {
+        try {
+            const router = providers_1.ContextProvider.getRouter();
+            return router === null || router === void 0 ? void 0 : router.ip;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    static getUserAgent() {
+        try {
+            const router = providers_1.ContextProvider.getRouter();
+            return undefined;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    static getServiceName() {
+        try {
+            const authUser = providers_1.ContextProvider.getAuthUser();
+            return authUser === null || authUser === void 0 ? void 0 : authUser.appId;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    static getMetadata() {
+        try {
+            const authUser = providers_1.ContextProvider.getAuthUser();
+            const router = providers_1.ContextProvider.getRouter();
+            return {
+                authUser,
+                router,
+            };
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    static getTags() {
+        try {
+            const context = this.getHttpContext();
+            return (context === null || context === void 0 ? void 0 : context.tags) || [];
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    static addTag(tag) {
+        try {
+            const context = this.getHttpContext();
+            if (context && context.tags) {
+                if (!context.tags.includes(tag)) {
+                    context.tags.push(tag);
+                }
+            }
+        }
+        catch (_a) {
+        }
+    }
+    static getContextSummary() {
+        const context = this.getHttpContext();
+        return {
+            requestId: context.requestId,
+            userId: context.userId,
+            service: context.appId,
+            clientIp: context.clientIp,
+            hasUser: !!context.userId,
+            requestSource: this.getRequestSource().source,
+        };
+    }
+    static getRequestSource() {
+        const context = this.getHttpContext();
+        if (!context.clientIp) {
+            return { source: 'unknown' };
+        }
+        const internalIPs = ['::1', '127.0.0.1', 'localhost'];
+        const isInternal = internalIPs.includes(context.clientIp) ||
+            context.clientIp.startsWith('192.168.') ||
+            context.clientIp.startsWith('10.') ||
+            (context.clientIp.startsWith('172.') &&
+                this.isInternal172IP(context.clientIp));
+        return {
+            source: isInternal ? 'internal' : 'external',
+            ip: context.clientIp,
+            userAgent: context.userAgent,
+            service: context.appId,
+        };
+    }
+    static isInternalRequest() {
+        const requestSource = this.getRequestSource();
+        return requestSource.source === 'internal';
+    }
+    static getSecurityContext() {
+        try {
+            const authUser = providers_1.ContextProvider.getAuthUser();
+            return {
+                isAuthenticated: !!authUser,
+                userId: authUser === null || authUser === void 0 ? void 0 : authUser.uid,
+                tenantId: authUser === null || authUser === void 0 ? void 0 : authUser.tenantId,
+                role: authUser === null || authUser === void 0 ? void 0 : authUser.role,
+                permissions: [],
+                securityLevel: (authUser === null || authUser === void 0 ? void 0 : authUser.admin) ? 'high' : 'medium',
+            };
+        }
+        catch (_a) {
+            return {
+                isAuthenticated: false,
+                permissions: [],
+                securityLevel: 'low',
+            };
+        }
+    }
+    static generateSpanId() {
+        return Math.random().toString(36).substring(2, 15);
+    }
+    static isInternal172IP(ip) {
+        if (!ip.startsWith('172.'))
+            return false;
+        const parts = ip.split('.');
+        if (parts.length !== 4)
+            return false;
+        const secondOctet = parseInt(parts[1]);
+        return secondOctet >= 16 && secondOctet <= 31;
+    }
+}
+exports.ContextExtractor = ContextExtractor;

package/http-client/utils/curl-generator.util.d.ts

@@ -0,0 +1,9 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+export declare class CurlGenerator {
+    static generateCurlCommand(config: AxiosRequestConfig, response?: AxiosResponse): string;
+    static generateSimplifiedCurl(config: AxiosRequestConfig): string;
+    static generateDebugCurl(config: AxiosRequestConfig, response?: AxiosResponse): string;
+    static parseCurlCommand(curlCommand: string): Partial<AxiosRequestConfig>;
+    private static buildUrl;
+    private static sanitizeHeaderValue;
+}

package/http-client/utils/curl-generator.util.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurlGenerator = void 0;
+class CurlGenerator {
+    static generateCurlCommand(config, response) {
+        const parts = ['curl'];
+        if (config.method && config.method.toLowerCase() !== 'get') {
+            parts.push(`-X ${config.method.toUpperCase()}`);
+        }
+        const url = this.buildUrl(config);
+        parts.push(`'${url}'`);
+        if (config.headers) {
+            Object.entries(config.headers).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    parts.push(`-H '${key}: ${value}'`);
+                }
+            });
+        }
+        if (config.data) {
+            const data = typeof config.data === 'string'
+                ? config.data
+                : JSON.stringify(config.data, null, 2);
+            parts.push(`-d '${data}'`);
+        }
+        if (config.data instanceof FormData) {
+            const formDataParts = [];
+            config.data.forEach((value, key) => {
+                if (value instanceof File) {
+                    formDataParts.push(`-F '${key}=@${value.name}'`);
+                }
+                else {
+                    formDataParts.push(`-F '${key}=${value}'`);
+                }
+            });
+            parts.push(...formDataParts);
+        }
+        if (config.params && !url.includes('?')) {
+            const params = new URLSearchParams(config.params).toString();
+            if (params) {
+                parts[parts.length - 1] = parts[parts.length - 1].replace(/'/, `?${params}'`);
+            }
+        }
+        parts.push('-i');
+        parts.push('-s');
+        parts.push('-L');
+        if (response) {
+            parts.push(`# Response: ${response.status} ${response.statusText}`);
+        }
+        return parts.join(' \\\n  ');
+    }
+    static generateSimplifiedCurl(config) {
+        const parts = ['curl'];
+        if (config.method && config.method.toLowerCase() !== 'get') {
+            parts.push(`-X ${config.method.toUpperCase()}`);
+        }
+        parts.push(`'${this.buildUrl(config)}'`);
+        const importantHeaders = [
+            'content-type',
+            'accept',
+            'authorization',
+            'x-api-key',
+        ];
+        if (config.headers) {
+            Object.entries(config.headers)
+                .filter(([key]) => importantHeaders.includes(key.toLowerCase()))
+                .forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    const sanitizedValue = this.sanitizeHeaderValue(key, String(value));
+                    parts.push(`-H '${key}: ${sanitizedValue}'`);
+                }
+            });
+        }
+        if (config.data) {
+            const data = typeof config.data === 'string'
+                ? config.data.substring(0, 200) +
+                    (config.data.length > 200 ? '...' : '')
+                : JSON.stringify(config.data).substring(0, 200) + '...';
+            parts.push(`-d '${data}'`);
+        }
+        return parts.join(' ');
+    }
+    static generateDebugCurl(config, response) {
+        var _a, _b, _c;
+        const curl = this.generateCurlCommand(config, response);
+        const debugInfo = [
+            '# Debug Information:',
+            `# Timestamp: ${new Date().toISOString()}`,
+            `# Request ID: ${((_a = config.headers) === null || _a === void 0 ? void 0 : _a['x-request-id']) || 'N/A'}`,
+            `# User-Agent: ${((_b = config.headers) === null || _b === void 0 ? void 0 : _b['user-agent']) || 'N/A'}`,
+        ];
+        if (response) {
+            debugInfo.push(`# Response Time: ${((_c = response.config.metadata) === null || _c === void 0 ? void 0 : _c.responseTime) || 'N/A'}ms`);
+            debugInfo.push(`# Response Size: ${JSON.stringify(response.data).length} bytes`);
+        }
+        return debugInfo.join('\n') + '\n' + curl;
+    }
+    static parseCurlCommand(curlCommand) {
+        const config = {};
+        try {
+            const methodMatch = curlCommand.match(/-X\s+(\w+)/);
+            if (methodMatch) {
+                config.method = methodMatch[1].toLowerCase();
+            }
+            const urlMatch = curlCommand.match(/curl[^']*'([^']+)'/);
+            if (urlMatch) {
+                config.url = urlMatch[1];
+            }
+            const headerMatches = curlCommand.match(/-H\s+'([^:]+):\s*([^']+)'/g) || [];
+            config.headers = {};
+            headerMatches.forEach((header) => {
+                const headerMatch = header.match(/-H\s+'([^:]+):\s*([^']+)'/);
+                if (headerMatch) {
+                    config.headers[headerMatch[1]] = headerMatch[2];
+                }
+            });
+            const dataMatch = curlCommand.match(/-d\s+'([^']+)'/);
+            if (dataMatch) {
+                try {
+                    config.data = JSON.parse(dataMatch[1]);
+                }
+                catch (_a) {
+                    config.data = dataMatch[1];
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to parse curl command:', error);
+        }
+        return config;
+    }
+    static buildUrl(config) {
+        let url = config.url || '';
+        if (config.baseURL && !url.startsWith('http')) {
+            url = config.baseURL.replace(/\/$/, '') + '/' + url.replace(/^\//, '');
+        }
+        if (config.params) {
+            const searchParams = new URLSearchParams();
+            Object.entries(config.params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    searchParams.append(key, String(value));
+                }
+            });
+            const paramString = searchParams.toString();
+            if (paramString) {
+                url += (url.includes('?') ? '&' : '?') + paramString;
+            }
+        }
+        return url;
+    }
+    static sanitizeHeaderValue(key, value) {
+        const sensitiveKeys = [
+            'authorization',
+            'apikey',
+            'password',
+            'secret',
+            'token',
+            'x-api-key',
+            'x-auth-token',
+            'x-secret-key',
+            'cookie',
+            'set-cookie',
+        ];
+        if (sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive))) {
+            return '[FILTERED]';
+        }
+        return value;
+    }
+}
+exports.CurlGenerator = CurlGenerator;

package/http-client/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './curl-generator.util';
+export * from './retry-recorder.util';
+export * from './context-extractor.util';
+export * from './call-stack-extractor.util';

package/http-client/utils/index.js

@@ -0,0 +1,20 @@
+"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("./curl-generator.util"), exports);
+__exportStar(require("./retry-recorder.util"), exports);
+__exportStar(require("./context-extractor.util"), exports);
+__exportStar(require("./call-stack-extractor.util"), exports);

package/http-client/utils/retry-recorder.util.d.ts

@@ -0,0 +1,30 @@
+import { AxiosError, AxiosRequestConfig } from 'axios';
+import { RetryRecord } from '../entities/http-log.entity';
+export declare class RetryRecorder {
+    private records;
+    static recordRetry(attempt: number, error: AxiosError | any, config: AxiosRequestConfig, delay: number): RetryRecord;
+    static create(): RetryRecorder;
+    private static formatError;
+    private static getRetryReason;
+    private static sanitizeHeaders;
+    addRecord(record: RetryRecord): void;
+    getRecords(): RetryRecord[];
+    getStats(): {
+        totalRetries: number;
+        maxAttempts: number;
+        totalDelay: number;
+        averageDelay: number;
+        reasons: Record<string, number>;
+    };
+    reset(): void;
+    getLastRecord(): RetryRecord | null;
+    hasRetries(): boolean;
+    getRecordByAttempt(attempt: number): RetryRecord | null;
+    getTimeline(): Array<{
+        attempt: number;
+        timestamp: Date;
+        delay: number;
+        reason: string;
+        cumulativeDelay: number;
+    }>;
+}

package/http-client/utils/retry-recorder.util.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryRecorder = void 0;
+class RetryRecorder {
+    constructor() {
+        this.records = [];
+    }
+    static recordRetry(attempt, error, config, delay) {
+        var _a;
+        return {
+            attempt,
+            timestamp: new Date(),
+            reason: this.getRetryReason(error),
+            delay,
+            error: this.formatError(error),
+            requestConfig: {
+                method: ((_a = config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN',
+                url: config.url || '',
+                headers: this.sanitizeHeaders(config.headers || {}),
+            },
+        };
+    }
+    static create() {
+        return new RetryRecorder();
+    }
+    static formatError(error) {
+        var _a;
+        if (!error)
+            return undefined;
+        const formatted = {
+            message: error.message || 'Unknown error',
+        };
+        if (error.code) {
+            formatted.code = error.code;
+        }
+        if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) {
+            formatted.statusCode = error.response.status;
+        }
+        return formatted;
+    }
+    static getRetryReason(error) {
+        if (!error.response) {
+            if (error.code === 'ECONNRESET') {
+                return 'Connection reset';
+            }
+            if (error.code === 'ETIMEDOUT') {
+                return 'Request timeout';
+            }
+            if (error.code === 'ENOTFOUND') {
+                return 'DNS resolution failed';
+            }
+            if (error.code === 'ECONNREFUSED') {
+                return 'Connection refused';
+            }
+            return 'Network error';
+        }
+        const status = error.response.status;
+        if (status >= 500) {
+            return `Server error: ${status}`;
+        }
+        if (status === 429) {
+            return 'Rate limited';
+        }
+        if (status === 408) {
+            return 'Request timeout';
+        }
+        return `HTTP error: ${status}`;
+    }
+    static sanitizeHeaders(headers) {
+        const sanitized = {};
+        const sensitiveKeys = [
+            'authorization',
+            'apikey',
+            'password',
+            'secret',
+            'token',
+            'x-api-key',
+            'x-auth-token',
+            'cookie',
+            'set-cookie',
+        ];
+        Object.entries(headers).forEach(([key, value]) => {
+            if (sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive))) {
+                sanitized[key] = '[FILTERED]';
+            }
+            else {
+                sanitized[key] = value;
+            }
+        });
+        return sanitized;
+    }
+    addRecord(record) {
+        this.records.push(record);
+    }
+    getRecords() {
+        return [...this.records];
+    }
+    getStats() {
+        const totalRetries = this.records.length;
+        const maxAttempts = Math.max(...this.records.map((r) => r.attempt), 0);
+        const totalDelay = this.records.reduce((sum, r) => sum + r.delay, 0);
+        const averageDelay = totalRetries > 0 ? totalDelay / totalRetries : 0;
+        const reasons = {};
+        this.records.forEach((record) => {
+            reasons[record.reason] = (reasons[record.reason] || 0) + 1;
+        });
+        return {
+            totalRetries,
+            maxAttempts,
+            totalDelay,
+            averageDelay,
+            reasons,
+        };
+    }
+    reset() {
+        this.records = [];
+    }
+    getLastRecord() {
+        return this.records.length > 0
+            ? this.records[this.records.length - 1]
+            : null;
+    }
+    hasRetries() {
+        return this.records.length > 0;
+    }
+    getRecordByAttempt(attempt) {
+        return this.records.find((r) => r.attempt === attempt) || null;
+    }
+    getTimeline() {
+        let cumulativeDelay = 0;
+        return this.records.map((record) => {
+            cumulativeDelay += record.delay;
+            return {
+                attempt: record.attempt,
+                timestamp: record.timestamp,
+                delay: record.delay,
+                reason: record.reason,
+                cumulativeDelay,
+            };
+        });
+    }
+}
+exports.RetryRecorder = RetryRecorder;

package/index.d.ts

@@ -13,6 +13,7 @@ export * from './helpers';
 export * from './providers';
 export * from './redis-lock';
 export * from './cache';
+export * from './http-client';
 export * from './vault';
 export * from './setup';
 export * from './health-checker';

package/index.js

@@ -29,6 +29,7 @@ __exportStar(require("./helpers"), exports);
 __exportStar(require("./providers"), exports);
 __exportStar(require("./redis-lock"), exports);
 __exportStar(require("./cache"), exports);
+__exportStar(require("./http-client"), exports);
 __exportStar(require("./vault"), exports);
 __exportStar(require("./setup"), exports);
 __exportStar(require("./health-checker"), exports);

package/package.json

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