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

package/http-client/examples/multi-api-configuration.example.js

@@ -0,0 +1,353 @@
+"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.ExampleController = exports.ApiManagementService = exports.CustomApiService = exports.WeChatApiService = exports.StripeApiService = exports.GitHubApiService = void 0;
+const common_1 = require("@nestjs/common");
+const api_client_registry_service_1 = require("../services/api-client-registry.service");
+let GitHubApiService = class GitHubApiService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+        this.initializeClients();
+    }
+    get github() {
+        return this.apiRegistry.getClient('github');
+    }
+    initializeClients() {
+        this.apiRegistry.createClient({
+            name: 'github',
+            baseURL: 'https://api.github.com',
+            auth: {
+                type: api_client_registry_service_1.AuthType.BEARER_TOKEN,
+                config: {
+                    token: process.env.GITHUB_TOKEN,
+                },
+            },
+            responseTransformer: {
+                dataPath: 'data',
+                success: (response) => response.data,
+                error: (error) => {
+                    var _a, _b;
+                    if ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) {
+                        throw new Error(`GitHub API Error: ${error.response.data.message}`);
+                    }
+                    throw error;
+                },
+            },
+            retry: {
+                enabled: true,
+                retries: 3,
+                retryCondition: (error) => {
+                    var _a, _b;
+                    return (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 403 || ((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 429);
+                },
+            },
+            responseTimeWarningThreshold: 2000,
+            tags: ['github', 'vcs'],
+        });
+    }
+};
+exports.GitHubApiService = GitHubApiService;
+exports.GitHubApiService = GitHubApiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], GitHubApiService);
+let StripeApiService = class StripeApiService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+        this.initializeClients();
+    }
+    get stripe() {
+        return this.apiRegistry.getClient('stripe');
+    }
+    initializeClients() {
+        this.apiRegistry.createClient({
+            name: 'stripe',
+            baseURL: 'https://api.stripe.com/v1',
+            auth: {
+                type: api_client_registry_service_1.AuthType.BASIC_AUTH,
+                config: {
+                    username: process.env.STRIPE_SECRET_KEY || '',
+                    password: '',
+                },
+            },
+            defaultHeaders: {
+                'Stripe-Version': '2023-10-16',
+            },
+            responseTransformer: {
+                dataPath: 'data',
+                error: (error) => {
+                    var _a, _b, _c;
+                    if ((_c = (_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.message) {
+                        throw new Error(`Stripe API Error: ${error.response.data.error.message}`);
+                    }
+                    throw error;
+                },
+            },
+            responseTimeWarningThreshold: 3000,
+            tags: ['stripe', 'payment'],
+        });
+    }
+};
+exports.StripeApiService = StripeApiService;
+exports.StripeApiService = StripeApiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], StripeApiService);
+let WeChatApiService = class WeChatApiService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+        this.initializeClients();
+    }
+    get wechat() {
+        return this.apiRegistry.getClient('wechat');
+    }
+    initializeClients() {
+        this.apiRegistry.createClient({
+            name: 'wechat',
+            baseURL: 'https://api.weixin.qq.com',
+            auth: {
+                type: api_client_registry_service_1.AuthType.NONE,
+            },
+            responseTransformer: {
+                success: (response) => {
+                    if (response.data.errcode !== 0) {
+                        throw new Error(`WeChat API Error (${response.data.errcode}): ${response.data.errmsg}`);
+                    }
+                    return response.data.data;
+                },
+            },
+            tags: ['wechat', 'social'],
+            environments: {
+                development: {
+                    baseURL: 'https://api.tunnel.com/wechat',
+                },
+            },
+        });
+    }
+};
+exports.WeChatApiService = WeChatApiService;
+exports.WeChatApiService = WeChatApiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], WeChatApiService);
+let CustomApiService = class CustomApiService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+        this.initializeClients();
+    }
+    get customApi() {
+        return this.apiRegistry.getClient('custom-api');
+    }
+    initializeClients() {
+        this.apiRegistry.createClient({
+            name: 'custom-api',
+            baseURL: process.env.CUSTOM_API_URL,
+            auth: {
+                type: api_client_registry_service_1.AuthType.CUSTOM,
+                config: {
+                    authenticator(config) {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            const token = yield this.getValidToken();
+                            config.headers = Object.assign(Object.assign({}, config.headers), { Authorization: `Bearer ${token}`, 'X-Timestamp': Date.now().toString(), 'X-Signature': this.generateSignature(config) });
+                            return config;
+                        });
+                    },
+                    refresher(config, error) {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            var _a;
+                            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                                const newToken = yield this.refreshToken();
+                                config.headers['Authorization'] = `Bearer ${newToken}`;
+                                return config;
+                            }
+                            throw error;
+                        });
+                    },
+                },
+            },
+            responseTransformer: {
+                success: (response) => {
+                    const result = response.data;
+                    if (result.success === false) {
+                        throw new Error(result.message || 'API request failed');
+                    }
+                    return {
+                        data: result.data || result,
+                        code: result.code || 0,
+                        message: result.message || 'Success',
+                        pagination: result.pagination,
+                        requestId: result.requestId,
+                    };
+                },
+                error: (error) => {
+                    var _a;
+                    if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                        const errorData = error.response.data;
+                        const customError = new Error(errorData.message || 'API request failed');
+                        customError.code = errorData.code;
+                        customError.details = errorData.details;
+                        throw customError;
+                    }
+                    throw error;
+                },
+            },
+            defaultHeaders: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            retry: {
+                enabled: true,
+                retries: 2,
+                retryCondition: (error) => {
+                    if (!error.response)
+                        return true;
+                    return error.response.status >= 500;
+                },
+            },
+            tags: ['custom', 'business'],
+        });
+    }
+    getValidToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'mock-jwt-token';
+        });
+    }
+    refreshToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'refreshed-jwt-token';
+        });
+    }
+    generateSignature(config) {
+        return 'mock-signature';
+    }
+};
+exports.CustomApiService = CustomApiService;
+exports.CustomApiService = CustomApiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], CustomApiService);
+let ApiManagementService = class ApiManagementService {
+    constructor(apiRegistry) {
+        this.apiRegistry = apiRegistry;
+    }
+    createDynamicClient(name, config) {
+        return this.apiRegistry.createClient(Object.assign({ name, baseURL: config.baseURL || '' }, config));
+    }
+    getAllStats() {
+        return this.apiRegistry.getAllStats();
+    }
+    resetAllStats() {
+        this.apiRegistry.resetAllStats();
+    }
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiRegistry.healthCheck();
+        });
+    }
+    createMultipleClients(configs) {
+        this.apiRegistry.createClients(configs);
+    }
+    listClients() {
+        return this.apiRegistry.listClients();
+    }
+};
+exports.ApiManagementService = ApiManagementService;
+exports.ApiManagementService = ApiManagementService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_client_registry_service_1.ApiClientRegistryService])
+], ApiManagementService);
+let ExampleController = class ExampleController {
+    constructor(githubApi, stripeApi, wechatApi, customApi, apiManagement) {
+        this.githubApi = githubApi;
+        this.stripeApi = stripeApi;
+        this.wechatApi = wechatApi;
+        this.customApi = customApi;
+        this.apiManagement = apiManagement;
+    }
+    getGitHubUser(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const github = this.githubApi.github();
+            return github.get(`/users/${username}`);
+        });
+    }
+    createStripePayment(amount, currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stripe = this.stripeApi.stripe();
+            return stripe.post('/charges', {
+                amount,
+                currency,
+                source: 'tok_visa',
+            });
+        });
+    }
+    sendWeChatMessage(openid, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wechat = this.wechatApi.wechat();
+            return wechat.post('/cgi-bin/message/custom/send', {
+                touser: openid,
+                msgtype: 'text',
+                text: {
+                    content,
+                },
+            });
+        });
+    }
+    getCustomData(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const custom = this.customApi.customApi();
+            return custom.get(`/data/${id}`);
+        });
+    }
+    callDynamicApi(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.apiManagement.createDynamicClient('dynamic', {
+                baseURL: url,
+                auth: {
+                    type: api_client_registry_service_1.AuthType.API_KEY,
+                    config: {
+                        key: process.env.DYNAMIC_API_KEY,
+                        location: 'header',
+                        name: 'X-API-Key',
+                    },
+                },
+            });
+            return client.get('/');
+        });
+    }
+    getApiHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiManagement.healthCheck();
+        });
+    }
+    getApiStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiManagement.getAllStats();
+        });
+    }
+};
+exports.ExampleController = ExampleController;
+exports.ExampleController = ExampleController = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [GitHubApiService,
+        StripeApiService,
+        WeChatApiService,
+        CustomApiService,
+        ApiManagementService])
+], ExampleController);

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

@@ -0,0 +1,11 @@
+import { DynamicModule } from '@nestjs/common';
+import { HttpClientConfig } from './interfaces/http-client-config.interface';
+export declare class HttpClientModule {
+    static forRoot(config?: HttpClientConfig): DynamicModule;
+    static forRootAsync(config: {
+        useFactory: (...args: any[]) => Promise<HttpClientConfig> | HttpClientConfig;
+        inject?: any[];
+        imports?: any[];
+    }): DynamicModule;
+    private static loadConfigFromEnvironment;
+}

package/http-client/http-client.module.js

@@ -0,0 +1,254 @@
+"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 __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 HttpClientModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientModule = void 0;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const config_1 = require("@nestjs/config");
+const typeorm_1 = require("@nestjs/typeorm");
+const cache_service_1 = require("../cache/cache.service");
+const http_client_service_1 = require("./services/http-client.service");
+const circuit_breaker_service_1 = require("./services/circuit-breaker.service");
+const logging_service_1 = require("./services/logging.service");
+const cache_service_2 = require("./services/cache.service");
+const http_log_query_service_1 = require("./services/http-log-query.service");
+const log_cleanup_service_1 = require("./services/log-cleanup.service");
+const api_client_registry_service_1 = require("./services/api-client-registry.service");
+const entities_1 = require("./entities");
+const cache_options_interface_1 = require("../cache/interfaces/cache-options.interface");
+let HttpClientModule = HttpClientModule_1 = class HttpClientModule {
+    static forRoot(config = {}) {
+        var _a, _b, _c;
+        const baseProviders = [
+            {
+                provide: 'HTTP_CLIENT_CONFIG',
+                useFactory: (configService, cacheService) => {
+                    const envConfig = this.loadConfigFromEnvironment(configService);
+                    return Object.assign(Object.assign({}, config), envConfig);
+                },
+                inject: [config_1.ConfigService, cache_service_1.CacheService],
+            },
+            circuit_breaker_service_1.HttpCircuitBreakerService,
+            logging_service_1.HttpLoggingService,
+            cache_service_2.HttpCacheService,
+            http_log_query_service_1.HttpLogQueryService,
+            log_cleanup_service_1.HttpLogCleanupService,
+            api_client_registry_service_1.ApiClientRegistryService,
+            {
+                provide: http_client_service_1.HttpClientService,
+                useFactory: (circuitBreakerService, loggingService, cacheService, httpConfig) => {
+                    return new http_client_service_1.HttpClientService(circuitBreakerService, loggingService, cacheService, httpConfig);
+                },
+                inject: [
+                    circuit_breaker_service_1.HttpCircuitBreakerService,
+                    logging_service_1.HttpLoggingService,
+                    cache_service_2.HttpCacheService,
+                    'HTTP_CLIENT_CONFIG',
+                ],
+            },
+        ];
+        const baseExports = [
+            http_client_service_1.HttpClientService,
+            circuit_breaker_service_1.HttpCircuitBreakerService,
+            logging_service_1.HttpLoggingService,
+            cache_service_2.HttpCacheService,
+            http_log_query_service_1.HttpLogQueryService,
+            log_cleanup_service_1.HttpLogCleanupService,
+            api_client_registry_service_1.ApiClientRegistryService,
+        ];
+        const dynamicImports = [config_1.ConfigModule];
+        if ((_b = (_a = config.logging) === null || _a === void 0 ? void 0 : _a.databaseLogging) === null || _b === void 0 ? void 0 : _b.enabled) {
+            dynamicImports.push(typeorm_1.TypeOrmModule.forFeature([entities_1.HttpLogEntity]));
+        }
+        if ((_c = config.logCleanup) === null || _c === void 0 ? void 0 : _c.enabled) {
+            dynamicImports.push(schedule_1.ScheduleModule.forRoot());
+        }
+        return {
+            module: HttpClientModule_1,
+            imports: dynamicImports,
+            providers: baseProviders,
+            exports: baseExports,
+        };
+    }
+    static forRootAsync(config) {
+        const baseProviders = [
+            {
+                provide: 'HTTP_CLIENT_CONFIG',
+                useFactory: (...args) => __awaiter(this, void 0, void 0, function* () {
+                    const userConfig = yield config.useFactory(...args);
+                    const envConfig = this.loadConfigFromEnvironment(args[0]);
+                    return Object.assign(Object.assign({}, userConfig), envConfig);
+                }),
+                inject: config.inject || [config_1.ConfigService],
+            },
+            circuit_breaker_service_1.HttpCircuitBreakerService,
+            logging_service_1.HttpLoggingService,
+            cache_service_2.HttpCacheService,
+            http_log_query_service_1.HttpLogQueryService,
+            log_cleanup_service_1.HttpLogCleanupService,
+            api_client_registry_service_1.ApiClientRegistryService,
+            {
+                provide: http_client_service_1.HttpClientService,
+                useFactory: (circuitBreakerService, loggingService, cacheService, httpConfig) => {
+                    return new http_client_service_1.HttpClientService(circuitBreakerService, loggingService, cacheService, httpConfig);
+                },
+                inject: [
+                    circuit_breaker_service_1.HttpCircuitBreakerService,
+                    logging_service_1.HttpLoggingService,
+                    cache_service_2.HttpCacheService,
+                    'HTTP_CLIENT_CONFIG',
+                ],
+            },
+        ];
+        const baseExports = [
+            http_client_service_1.HttpClientService,
+            circuit_breaker_service_1.HttpCircuitBreakerService,
+            logging_service_1.HttpLoggingService,
+            cache_service_2.HttpCacheService,
+            http_log_query_service_1.HttpLogQueryService,
+            log_cleanup_service_1.HttpLogCleanupService,
+            api_client_registry_service_1.ApiClientRegistryService,
+        ];
+        const dynamicImports = [config_1.ConfigModule, ...(config.imports || [])];
+        return {
+            module: HttpClientModule_1,
+            imports: dynamicImports,
+            providers: baseProviders,
+            exports: baseExports,
+        };
+    }
+    static loadConfigFromEnvironment(configService) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return {
+            baseURL: configService.get('HTTP_CLIENT_BASE_URL'),
+            timeout: configService.get('HTTP_CLIENT_TIMEOUT')
+                ? parseInt(configService.get('HTTP_CLIENT_TIMEOUT'))
+                : undefined,
+            retry: {
+                enabled: configService.get('HTTP_CLIENT_RETRY_ENABLED') === 'true',
+                retries: configService.get('HTTP_CLIENT_RETRY_RETRIES')
+                    ? parseInt(configService.get('HTTP_CLIENT_RETRY_RETRIES'))
+                    : undefined,
+                retryDelay: configService.get('HTTP_CLIENT_RETRY_DELAY_STRATEGY') ===
+                    'exponential'
+                    ? (retryCount) => Math.pow(2, retryCount) * 1000
+                    : undefined,
+                retryCondition: configService.get('HTTP_CLIENT_RETRY_CONDITION') ===
+                    'network_only'
+                    ? (error) => !error.response
+                    : undefined,
+                shouldResetTimeout: configService.get('HTTP_CLIENT_RETRY_RESET_TIMEOUT') !==
+                    'false',
+            },
+            circuitBreaker: {
+                enabled: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_ENABLED') ===
+                    'true',
+                failureThreshold: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_FAILURE_THRESHOLD')
+                    ? parseInt(configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_FAILURE_THRESHOLD'))
+                    : 5,
+                recoveryTimeoutMs: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_RECOVERY_TIMEOUT')
+                    ? parseInt(configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_RECOVERY_TIMEOUT'))
+                    : 60000,
+                monitoringPeriodMs: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_MONITORING_PERIOD')
+                    ? parseInt(configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_MONITORING_PERIOD'))
+                    : 10000,
+                minimumThroughputThreshold: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_MINIMUM_THROUGHPUT')
+                    ? parseInt(configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_MINIMUM_THROUGHPUT'))
+                    : 10,
+                countHalfOpenCalls: configService.get('HTTP_CLIENT_CIRCUIT_BREAKER_COUNT_HALF_OPEN') === 'true',
+            },
+            cache: {
+                enabled: configService.get('HTTP_CLIENT_CACHE_ENABLED') !== 'false',
+                defaultTtl: configService.get('HTTP_CLIENT_CACHE_DEFAULT_TTL')
+                    ? parseInt(configService.get('HTTP_CLIENT_CACHE_DEFAULT_TTL'))
+                    : 300000,
+                cacheableMethods: ((_b = (_a = configService
+                    .get('HTTP_CLIENT_CACHEABLE_METHODS')) === null || _a === void 0 ? void 0 : _a.split(',')) === null || _b === void 0 ? void 0 : _b.map((method) => method.trim().toUpperCase())) || [
+                    'GET',
+                    'HEAD',
+                ],
+                cacheableStatusCodes: ((_d = (_c = configService
+                    .get('HTTP_CLIENT_CACHEABLE_STATUS_CODES')) === null || _c === void 0 ? void 0 : _c.split(',')) === null || _d === void 0 ? void 0 : _d.map((code) => parseInt(code.trim()))) || [200, 201, 304],
+                options: {
+                    layers: ((_f = (_e = configService
+                        .get('HTTP_CLIENT_CACHE_LAYERS')) === null || _e === void 0 ? void 0 : _e.split(',')) === null || _f === void 0 ? void 0 : _f.map((layer) => {
+                        const trimmed = layer.trim();
+                        switch (trimmed) {
+                            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;
+                        }
+                    })) || [cache_options_interface_1.CacheLayer.MEMORY],
+                },
+            },
+            logging: {
+                enabled: configService.get('HTTP_CLIENT_LOGGING_ENABLED') !== 'false',
+                logRequests: configService.get('HTTP_CLIENT_LOG_REQUESTS') !== 'false',
+                logResponses: configService.get('HTTP_CLIENT_LOG_RESPONSES') !== 'false',
+                logErrors: configService.get('HTTP_CLIENT_LOG_ERRORS') !== 'false',
+                logHeaders: configService.get('HTTP_CLIENT_LOG_HEADERS') !== 'false',
+                logBody: configService.get('HTTP_CLIENT_LOG_BODY') !== 'false',
+                maxBodyLength: configService.get('HTTP_CLIENT_LOG_MAX_BODY_LENGTH')
+                    ? parseInt(configService.get('HTTP_CLIENT_LOG_MAX_BODY_LENGTH'))
+                    : undefined,
+                sanitizeHeaders: (_g = configService
+                    .get('HTTP_CLIENT_LOG_SANITIZE_HEADERS')) === null || _g === void 0 ? void 0 : _g.split(','),
+                logLevel: configService.get('HTTP_CLIENT_LOG_LEVEL'),
+                databaseLogging: {
+                    enabled: configService.get('HTTP_CLIENT_DB_LOGGING_ENABLED') ===
+                        'true',
+                    dataSource: configService.get('HTTP_CLIENT_DB_LOGGING_DATA_SOURCE') ||
+                        'default',
+                    tableName: configService.get('HTTP_CLIENT_DB_LOGGING_TABLE_NAME') ||
+                        'http_logs',
+                },
+            },
+            proxy: {
+                enabled: configService.get('HTTP_CLIENT_PROXY_ENABLED') === 'true',
+                host: configService.get('HTTP_CLIENT_PROXY_HOST'),
+                port: configService.get('HTTP_CLIENT_PROXY_PORT')
+                    ? parseInt(configService.get('HTTP_CLIENT_PROXY_PORT'))
+                    : undefined,
+                protocol: configService.get('HTTP_CLIENT_PROXY_PROTOCOL'),
+            },
+            logCleanup: {
+                enabled: configService.get('HTTP_CLIENT_LOG_CLEANUP_ENABLED') ===
+                    'true',
+                retentionDays: configService.get('HTTP_CLIENT_LOG_CLEANUP_RETENTION_DAYS')
+                    ? parseInt(configService.get('HTTP_CLIENT_LOG_CLEANUP_RETENTION_DAYS'))
+                    : 30,
+                maxRecords: configService.get('HTTP_CLIENT_LOG_CLEANUP_MAX_RECORDS'),
+                batchSize: configService.get('HTTP_CLIENT_LOG_CLEANUP_BATCH_SIZE')
+                    ? parseInt(configService.get('HTTP_CLIENT_LOG_CLEANUP_BATCH_SIZE'))
+                    : 1000,
+                schedule: configService.get('HTTP_CLIENT_LOG_CLEANUP_SCHEDULE') || '0 2 * * *',
+                strategy: configService.get('HTTP_CLIENT_LOG_CLEANUP_STRATEGY') || 'retention',
+            },
+        };
+    }
+};
+exports.HttpClientModule = HttpClientModule;
+exports.HttpClientModule = HttpClientModule = HttpClientModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], HttpClientModule);

package/http-client/index.d.ts

@@ -0,0 +1,10 @@
+export { HttpClientConfig, RetryConfig, CircuitBreakerConfig, HttpCacheConfig, ProxyConfig, LoggingConfig, InterceptorConfig, ConnectionPoolConfig, HttpContext, HttpInterceptor, HttpMethod, HttpStats, } from './interfaces/http-client-config.interface';
+export * from './interfaces/api-client-config.interface';
+export { HttpLogEntity, RetryRecord } from './entities';
+export * from './decorators';
+export * from './services';
+export * from './utils';
+export * from './errors';
+export * from './config';
+export * from './http-client.module';
+export * from './examples';

package/http-client/index.js

@@ -0,0 +1,27 @@
+"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 });
+exports.HttpLogEntity = void 0;
+__exportStar(require("./interfaces/api-client-config.interface"), exports);
+var entities_1 = require("./entities");
+Object.defineProperty(exports, "HttpLogEntity", { enumerable: true, get: function () { return entities_1.HttpLogEntity; } });
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./http-client.module"), exports);
+__exportStar(require("./examples"), exports);