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

package/common/dto/dto-extensions.js

@@ -33,22 +33,23 @@ typeorm_1.SelectQueryBuilder.prototype.toDtoPage = function (pageOptionsDto, dto
         const page = pageOptionsDto.page || 1;
         const pageSize = pageOptionsDto.pageSize || 10;
         const skip = (page - 1) * pageSize;
-        const totalItems = yield this.getCount();
+        const total = yield this.getCount();
         const entities = yield this.skip(skip).take(pageSize).getMany();
-        if (entities.length > 0) {
+        const count = entities.length;
+        if (count) {
             console.log('Raw entity sample:', JSON.stringify(entities[0], null, 2));
         }
         const data = yield entities.toDto(dtoClass, context);
         if (data.length > 0) {
             console.log('Converted DTO sample:', JSON.stringify(data[0], null, 2));
         }
-        const itemCount = totalItems;
-        const pageCount = Math.ceil(itemCount / pageSize);
+        const pageCount = Math.ceil(total / pageSize);
         const hasPreviousPage = page > 1;
         const hasNextPage = page < pageCount;
         return {
             data,
-            itemCount,
+            count,
+            total,
             page,
             pageCount,
             hasPreviousPage,

package/common/utils.d.ts

@@ -1,3 +1,4 @@
 export declare function generateHash(password: string): string;
 export declare function validateHash(password: string | undefined, hash: string | undefined): Promise<boolean>;
 export declare function getVariableName<TResult>(getVar: () => TResult): string;
+export declare function generateRequestId(): string;

package/common/utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateHash = generateHash;
 exports.validateHash = validateHash;
 exports.getVariableName = getVariableName;
+exports.generateRequestId = generateRequestId;
 const bcrypt_1 = require("bcrypt");
 function generateHash(password) {
     return bcrypt_1.default.hashSync(password, 10);
@@ -22,3 +23,8 @@ function getVariableName(getVar) {
     const memberParts = fullMemberName.split('.');
     return memberParts[memberParts.length - 1];
 }
+function generateRequestId() {
+    return Math.random().toString(36).substring(2, 15) +
+        Math.random().toString(36).substring(2, 15) +
+        Date.now().toString(36);
+}

package/http-client/config/http-client.config.d.ts

@@ -0,0 +1,6 @@
+import { HttpClientConfig } from '../interfaces/http-client-config.interface';
+export declare const DEFAULT_HTTP_CLIENT_CONFIG: Partial<HttpClientConfig>;
+export declare const DEVELOPMENT_HTTP_CLIENT_CONFIG: Partial<HttpClientConfig>;
+export declare const PRODUCTION_HTTP_CLIENT_CONFIG: Partial<HttpClientConfig>;
+export declare const TEST_HTTP_CLIENT_CONFIG: Partial<HttpClientConfig>;
+export declare function getHttpClientConfig(env?: string): Partial<HttpClientConfig>;

package/http-client/config/http-client.config.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_HTTP_CLIENT_CONFIG = exports.PRODUCTION_HTTP_CLIENT_CONFIG = exports.DEVELOPMENT_HTTP_CLIENT_CONFIG = exports.DEFAULT_HTTP_CLIENT_CONFIG = void 0;
+exports.getHttpClientConfig = getHttpClientConfig;
+const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
+exports.DEFAULT_HTTP_CLIENT_CONFIG = {
+    timeout: 30000,
+    retry: {
+        enabled: true,
+        retries: 3,
+        retryDelay: (retryCount) => Math.pow(2, retryCount) * 1000,
+        retryCondition: (error) => {
+            if (!error.response)
+                return true;
+            const status = error.response.status;
+            return status >= 500 || status === 429;
+        },
+        shouldResetTimeout: true,
+    },
+    circuitBreaker: {
+        enabled: true,
+        failureThreshold: 5,
+        recoveryTimeoutMs: 60000,
+        monitoringPeriodMs: 10000,
+        minimumThroughputThreshold: 10,
+        countHalfOpenCalls: false,
+    },
+    cache: {
+        enabled: true,
+        defaultTtl: 300000,
+        cacheableMethods: ['GET', 'HEAD'],
+        cacheableStatusCodes: [200, 201, 304],
+        options: {
+            layers: [cache_options_interface_1.CacheLayer.CLS, cache_options_interface_1.CacheLayer.MEMORY, cache_options_interface_1.CacheLayer.REDIS],
+        },
+    },
+    logging: {
+        enabled: true,
+        logRequests: true,
+        logResponses: true,
+        logErrors: true,
+        logHeaders: false,
+        logBody: true,
+        maxBodyLength: 1000,
+        sanitizeHeaders: ['authorization', 'apikey', 'password', 'token', 'cookie'],
+        logLevel: 'info',
+        databaseLogging: {
+            enabled: false,
+            dataSource: 'default',
+            tableName: 'http_logs',
+        },
+    },
+    logCleanup: {
+        enabled: false,
+        retentionDays: 30,
+        maxRecords: 100000,
+        batchSize: 1000,
+        schedule: '0 2 * * *',
+        strategy: 'retention',
+    },
+};
+exports.DEVELOPMENT_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG), { logging: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logging), { enabled: true, logHeaders: true, logBody: true, logLevel: 'debug', databaseLogging: {
+            enabled: true,
+            dataSource: 'default',
+            tableName: 'http_logs',
+        } }), logCleanup: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logCleanup), { enabled: false }) });
+exports.PRODUCTION_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG), { timeout: 60000, retry: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.retry), { retries: 5 }), circuitBreaker: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.circuitBreaker), { failureThreshold: 3, recoveryTimeoutMs: 120000 }), logging: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logging), { enabled: true, logHeaders: false, logBody: false, logLevel: 'warn', databaseLogging: {
+            enabled: true,
+            dataSource: 'default',
+            tableName: 'http_logs',
+        } }), logCleanup: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logCleanup), { enabled: true, retentionDays: 7, maxRecords: 50000, schedule: '0 3 * * *' }) });
+exports.TEST_HTTP_CLIENT_CONFIG = Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG), { timeout: 10000, retry: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.retry), { retries: 1 }), circuitBreaker: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.circuitBreaker), { failureThreshold: 10, recoveryTimeoutMs: 5000 }), logging: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logging), { enabled: false }), logCleanup: Object.assign(Object.assign({}, exports.DEFAULT_HTTP_CLIENT_CONFIG.logCleanup), { enabled: false }) });
+function getHttpClientConfig(env) {
+    switch (env === null || env === void 0 ? void 0 : env.toLowerCase()) {
+        case 'development':
+        case 'dev':
+            return exports.DEVELOPMENT_HTTP_CLIENT_CONFIG;
+        case 'production':
+        case 'prod':
+            return exports.PRODUCTION_HTTP_CLIENT_CONFIG;
+        case 'test':
+        case 'testing':
+            return exports.TEST_HTTP_CLIENT_CONFIG;
+        default:
+            return exports.DEFAULT_HTTP_CLIENT_CONFIG;
+    }
+}

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

@@ -0,0 +1 @@
+export * from './http-client.config';

package/http-client/config/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("./http-client.config"), exports);

package/http-client/decorators/http-client.decorators.d.ts

@@ -0,0 +1,72 @@
+import 'reflect-metadata';
+import { CircuitBreakerConfig, HttpCacheConfig, HttpClientConfig, RetryConfig } from '../interfaces/http-client-config.interface';
+export declare const HTTP_CLIENT_OPTIONS_KEY = "http_client_options";
+export declare const RETRY_OPTIONS_KEY = "http_retry_options";
+export declare const CIRCUIT_BREAKER_OPTIONS_KEY = "http_circuit_breaker_options";
+export declare const CACHE_OPTIONS_KEY = "http_cache_options";
+export declare const LOGGING_OPTIONS_KEY = "http_logging_options";
+export declare const TIMEOUT_OPTIONS_KEY = "http_timeout_options";
+export declare const PROXY_OPTIONS_KEY = "http_proxy_options";
+export declare const CALL_INFO_KEY = "http_call_info";
+export declare const HttpClient: (options?: HttpClientConfig) => (target: any) => void;
+export declare const HttpRetry: (options?: {
+    retries?: number;
+    retryDelay?: (retryCount: number) => number;
+    retryCondition?: (error: any) => boolean;
+    shouldResetTimeout?: boolean;
+    onRetry?: (retryCount: number, error: any, requestConfig: any) => void;
+}) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const HttpCircuitBreaker: (options?: {
+    failureThreshold?: number;
+    recoveryTimeoutMs?: number;
+    monitoringPeriodMs?: number;
+    minimumThroughputThreshold?: number;
+}) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const HttpCacheable: (options?: {
+    ttl?: number;
+    key?: string | ((...args: any[]) => string);
+    layers?: Array<"cls" | "memory" | "redis">;
+    condition?: (...args: any[]) => boolean | Promise<boolean>;
+    unless?: string | ((result: any, args: any[]) => boolean);
+    namespace?: string;
+}) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const HttpLogRequest: (options?: {
+    logHeaders?: boolean;
+    logBody?: boolean;
+    sanitizeHeaders?: string[];
+    databaseLog?: boolean;
+    logLevel?: "debug" | "info" | "warn" | "error";
+    serviceClass?: string;
+    methodName?: string;
+    operationName?: string;
+}) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const HttpTimeout: (timeoutMs: number) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const HttpUseProxy: (options: {
+    host: string;
+    port: number;
+    protocol?: "http" | "https";
+    auth?: {
+        username: string;
+        password: string;
+    };
+}) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare class HttpDecoratorUtils {
+    static getRetryOptions(target: any, propertyKey: string): RetryConfig | undefined;
+    static getCircuitBreakerOptions(target: any, propertyKey: string): CircuitBreakerConfig | undefined;
+    static getCacheOptions(target: any, propertyKey: string): HttpCacheConfig | undefined;
+    static getLoggingOptions(target: any, propertyKey: string): any;
+    static getTimeoutOptions(target: any, propertyKey: string): number | undefined;
+    static getProxyOptions(target: any, propertyKey: string): any;
+    static getHttpClientOptions(target: any): HttpClientConfig;
+    static getCallInfoOptions(target: any, propertyKey: string): any;
+    static getAllDecoratorConfigs(target: any, propertyKey: string): {
+        retry?: RetryConfig;
+        circuitBreaker?: CircuitBreakerConfig;
+        cache?: HttpCacheConfig;
+        logging?: any;
+        timeout?: number;
+        proxy?: any;
+        httpClient?: HttpClientConfig;
+        callInfo?: any;
+    };
+}

package/http-client/decorators/http-client.decorators.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpDecoratorUtils = exports.HttpUseProxy = exports.HttpTimeout = exports.HttpLogRequest = exports.HttpCacheable = exports.HttpCircuitBreaker = exports.HttpRetry = exports.HttpClient = exports.CALL_INFO_KEY = exports.PROXY_OPTIONS_KEY = exports.TIMEOUT_OPTIONS_KEY = exports.LOGGING_OPTIONS_KEY = exports.CACHE_OPTIONS_KEY = exports.CIRCUIT_BREAKER_OPTIONS_KEY = exports.RETRY_OPTIONS_KEY = exports.HTTP_CLIENT_OPTIONS_KEY = void 0;
+require("reflect-metadata");
+const common_1 = require("@nestjs/common");
+const cache_options_interface_1 = require("../../cache/interfaces/cache-options.interface");
+const call_stack_extractor_util_1 = require("../utils/call-stack-extractor.util");
+exports.HTTP_CLIENT_OPTIONS_KEY = 'http_client_options';
+exports.RETRY_OPTIONS_KEY = 'http_retry_options';
+exports.CIRCUIT_BREAKER_OPTIONS_KEY = 'http_circuit_breaker_options';
+exports.CACHE_OPTIONS_KEY = 'http_cache_options';
+exports.LOGGING_OPTIONS_KEY = 'http_logging_options';
+exports.TIMEOUT_OPTIONS_KEY = 'http_timeout_options';
+exports.PROXY_OPTIONS_KEY = 'http_proxy_options';
+exports.CALL_INFO_KEY = 'http_call_info';
+const HttpClient = (options = {}) => {
+    return (target) => {
+        (0, common_1.SetMetadata)(exports.HTTP_CLIENT_OPTIONS_KEY, options)(target);
+    };
+};
+exports.HttpClient = HttpClient;
+const HttpRetry = (options = {}) => {
+    return (target, propertyKey, descriptor) => {
+        const retryOptions = {
+            enabled: true,
+            retries: options.retries || 3,
+            retryDelay: options.retryDelay || ((retryCount) => Math.pow(2, retryCount) * 1000),
+            retryCondition: options.retryCondition ||
+                ((error) => {
+                    if (!error.response)
+                        return true;
+                    const status = error.response.status;
+                    return status >= 500 || status === 429;
+                }),
+            shouldResetTimeout: options.shouldResetTimeout !== false,
+            onRetry: options.onRetry,
+        };
+        (0, common_1.SetMetadata)(`${exports.RETRY_OPTIONS_KEY}_${propertyKey}`, retryOptions)(descriptor.value);
+        return descriptor;
+    };
+};
+exports.HttpRetry = HttpRetry;
+const HttpCircuitBreaker = (options = {}) => {
+    return (target, propertyKey, descriptor) => {
+        const circuitBreakerOptions = {
+            enabled: true,
+            failureThreshold: options.failureThreshold || 5,
+            recoveryTimeoutMs: options.recoveryTimeoutMs || 60000,
+            monitoringPeriodMs: options.monitoringPeriodMs || 10000,
+            minimumThroughputThreshold: options.minimumThroughputThreshold || 10,
+            countHalfOpenCalls: true,
+        };
+        (0, common_1.SetMetadata)(`${exports.CIRCUIT_BREAKER_OPTIONS_KEY}_${propertyKey}`, circuitBreakerOptions)(descriptor.value);
+        return descriptor;
+    };
+};
+exports.HttpCircuitBreaker = HttpCircuitBreaker;
+const HttpCacheable = (options = {}) => {
+    return (target, propertyKey, descriptor) => {
+        var _a;
+        const cacheOptions = {
+            enabled: true,
+            defaultTtl: options.ttl || 300000,
+            keyGenerator: typeof options.key === 'function'
+                ? (config) => options.key(config.url, config.method, config.data, config.params)
+                : options.key
+                    ? () => options.key
+                    : undefined,
+            options: {
+                layers: (_a = options.layers) === null || _a === void 0 ? void 0 : _a.map((layer) => {
+                    switch (layer) {
+                        case 'cls':
+                            return cache_options_interface_1.CacheLayer.CLS;
+                        case 'memory':
+                            return cache_options_interface_1.CacheLayer.MEMORY;
+                        case 'redis':
+                            return cache_options_interface_1.CacheLayer.REDIS;
+                        default:
+                            return cache_options_interface_1.CacheLayer.MEMORY;
+                    }
+                }),
+                condition: options.condition,
+                prefix: options.namespace,
+            },
+            cacheableMethods: ['get'],
+            cacheableStatusCodes: [200, 201, 202, 204, 301, 302, 304],
+        };
+        if (options.unless) {
+            const originalMethod = descriptor.value;
+            descriptor.value = function (...args) {
+                const result = originalMethod.apply(this, args);
+                if (typeof options.unless === 'string') {
+                    if (evalInContext(options.unless, { result, args })) {
+                        return result;
+                    }
+                }
+                else if (typeof options.unless === 'function') {
+                    if (options.unless(result, args)) {
+                        return result;
+                    }
+                }
+                (0, common_1.SetMetadata)(`${exports.CACHE_OPTIONS_KEY}_${propertyKey}`, cacheOptions)(originalMethod);
+                return result;
+            };
+        }
+        else {
+            (0, common_1.SetMetadata)(`${exports.CACHE_OPTIONS_KEY}_${propertyKey}`, cacheOptions)(descriptor.value);
+        }
+        return descriptor;
+    };
+};
+exports.HttpCacheable = HttpCacheable;
+const HttpLogRequest = (options = {}) => {
+    return (target, propertyKey, descriptor) => {
+        var _a, _b, _c;
+        const loggingOptions = {
+            logHeaders: (_a = options.logHeaders) !== null && _a !== void 0 ? _a : true,
+            logBody: (_b = options.logBody) !== null && _b !== void 0 ? _b : true,
+            sanitizeHeaders: options.sanitizeHeaders || [
+                'authorization',
+                'apikey',
+                'password',
+                'token',
+                'x-api-key',
+                'cookie',
+                'set-cookie',
+            ],
+            databaseLog: (_c = options.databaseLog) !== null && _c !== void 0 ? _c : false,
+            logLevel: options.logLevel || 'info',
+        };
+        const decoratorInfo = call_stack_extractor_util_1.CallStackExtractor.extractFromDecorator(target, propertyKey);
+        const callInfo = {
+            serviceClass: options.serviceClass || decoratorInfo.serviceClass,
+            methodName: options.methodName || decoratorInfo.methodName,
+            operationName: options.operationName || decoratorInfo.operationName,
+        };
+        (0, common_1.SetMetadata)(`${exports.LOGGING_OPTIONS_KEY}_${propertyKey}`, loggingOptions)(descriptor.value);
+        (0, common_1.SetMetadata)(`${exports.CALL_INFO_KEY}_${propertyKey}`, callInfo)(descriptor.value);
+        return descriptor;
+    };
+};
+exports.HttpLogRequest = HttpLogRequest;
+const HttpTimeout = (timeoutMs) => {
+    return (target, propertyKey, descriptor) => {
+        (0, common_1.SetMetadata)(`${exports.TIMEOUT_OPTIONS_KEY}_${propertyKey}`, timeoutMs)(descriptor.value);
+        return descriptor;
+    };
+};
+exports.HttpTimeout = HttpTimeout;
+const HttpUseProxy = (options) => {
+    return (target, propertyKey, descriptor) => {
+        (0, common_1.SetMetadata)(`${exports.PROXY_OPTIONS_KEY}_${propertyKey}`, options)(descriptor.value);
+        return descriptor;
+    };
+};
+exports.HttpUseProxy = HttpUseProxy;
+class HttpDecoratorUtils {
+    static getRetryOptions(target, propertyKey) {
+        return Reflect.getMetadata(`${exports.RETRY_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
+    }
+    static getCircuitBreakerOptions(target, propertyKey) {
+        return Reflect.getMetadata(`${exports.CIRCUIT_BREAKER_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
+    }
+    static getCacheOptions(target, propertyKey) {
+        return Reflect.getMetadata(`${exports.CACHE_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
+    }
+    static getLoggingOptions(target, propertyKey) {
+        return Reflect.getMetadata(`${exports.LOGGING_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
+    }
+    static getTimeoutOptions(target, propertyKey) {
+        return Reflect.getMetadata(`${exports.TIMEOUT_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
+    }
+    static getProxyOptions(target, propertyKey) {
+        return Reflect.getMetadata(`${exports.PROXY_OPTIONS_KEY}_${propertyKey}`, target[propertyKey]);
+    }
+    static getHttpClientOptions(target) {
+        return Reflect.getMetadata(exports.HTTP_CLIENT_OPTIONS_KEY, target) || {};
+    }
+    static getCallInfoOptions(target, propertyKey) {
+        return Reflect.getMetadata(`${exports.CALL_INFO_KEY}_${propertyKey}`, target[propertyKey]);
+    }
+    static getAllDecoratorConfigs(target, propertyKey) {
+        return {
+            retry: this.getRetryOptions(target, propertyKey),
+            circuitBreaker: this.getCircuitBreakerOptions(target, propertyKey),
+            cache: this.getCacheOptions(target, propertyKey),
+            logging: this.getLoggingOptions(target, propertyKey),
+            timeout: this.getTimeoutOptions(target, propertyKey),
+            proxy: this.getProxyOptions(target, propertyKey),
+            httpClient: this.getHttpClientOptions(target),
+            callInfo: this.getCallInfoOptions(target, propertyKey),
+        };
+    }
+}
+exports.HttpDecoratorUtils = HttpDecoratorUtils;
+function evalInContext(expression, context) {
+    try {
+        const func = new Function(...Object.keys(context), `return ${expression}`);
+        return func(...Object.values(context));
+    }
+    catch (error) {
+        return false;
+    }
+}

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

@@ -0,0 +1 @@
+export * from './http-client.decorators';

package/http-client/decorators/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("./http-client.decorators"), exports);

package/http-client/entities/http-log.entity.d.ts

@@ -0,0 +1,98 @@
+import { AbstractUuidPrimaryEntity } from '../../common';
+export declare class HttpLogEntity extends AbstractUuidPrimaryEntity {
+    requestId?: string;
+    userId?: string;
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: string;
+    params?: Record<string, any>;
+    statusCode?: number;
+    responseTime: number;
+    attemptCount: number;
+    success: boolean;
+    errorMessage?: string;
+    errorStack?: string;
+    errorCode?: string;
+    responseHeaders?: Record<string, string>;
+    responseBody?: string;
+    responseSize?: number;
+    requestSize?: number;
+    serviceName?: string;
+    operationName?: string;
+    clientIp?: string;
+    source?: string;
+    tags?: string[];
+    metadata?: Record<string, any>;
+    retryRecords?: RetryRecord[];
+    cacheHit?: boolean;
+    circuitBreakerState?: string;
+}
+export interface RetryRecord {
+    attempt: number;
+    timestamp: Date;
+    reason: string;
+    delay: number;
+    error?: {
+        message: string;
+        code?: string;
+        statusCode?: number;
+    };
+    requestConfig?: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+    };
+}
+export interface HttpLogQueryOptions {
+    requestId?: string;
+    userId?: string;
+    method?: string | string[];
+    url?: string;
+    statusCode?: number | number[];
+    success?: boolean;
+    serviceName?: string;
+    operationName?: string;
+    clientIp?: string;
+    source?: string;
+    tags?: string[];
+    errorCode?: string;
+    minResponseTime?: number;
+    maxResponseTime?: number;
+    startDate?: Date;
+    endDate?: Date;
+    keyword?: string;
+    page?: number;
+    limit?: number;
+    sortBy?: 'createdAt' | 'responseTime' | 'statusCode' | 'url';
+    sortOrder?: 'ASC' | 'DESC';
+    includeDetails?: boolean;
+}
+export interface HttpLogStats {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    successRate: number;
+    averageResponseTime: number;
+    minResponseTime: number;
+    maxResponseTime: number;
+    p50ResponseTime: number;
+    p95ResponseTime: number;
+    p99ResponseTime: number;
+    requestsByMethod: Record<string, number>;
+    requestsByStatus: Record<string, number>;
+    requestsByService: Record<string, number>;
+    requestsBySource: Record<string, number>;
+    errorsByCode: Record<string, number>;
+    retryStats: {
+        totalRetries: number;
+        averageRetries: number;
+        maxRetries: number;
+        retryRate: number;
+    };
+    cacheStats: {
+        cacheHits: number;
+        cacheMisses: number;
+        cacheHitRate: number;
+    };
+}