@tramvai/module-http-client 1.94.1 → 1.95.0

package/lib/httpClient/httpClientFactory.d.ts

@@ -2,14 +2,14 @@ import type { MakeRequest } from '@tinkoff/request-core';
 import type { APP_INFO_TOKEN } from '@tramvai/core';
 import type { API_CLIENT_PASS_HEADERS, HTTP_CLIENT_AGENT, HTTP_CLIENT_FACTORY, DISABLE_CIRCUIT_BREAKER } from '@tramvai/tokens-http-client';
 import type { LOGGER_TOKEN, CREATE_CACHE_TOKEN, ENV_MANAGER_TOKEN, REQUEST_MANAGER_TOKEN } from '@tramvai/tokens-common';
-export declare const httpClientFactory: ({ logger, envManager, appInfo, requestManager, headersList, createCache, tinkoffRequestRegistry, agent, disableCircuitBreaker, }: {
+export declare const httpClientFactory: ({ logger, envManager, appInfo, requestManager, headersList, createCache, makeRequestRegistry, agent, disableCircuitBreaker, }: {
     logger: typeof LOGGER_TOKEN;
     envManager: typeof ENV_MANAGER_TOKEN;
     appInfo: typeof APP_INFO_TOKEN;
     requestManager?: typeof REQUEST_MANAGER_TOKEN;
     headersList?: typeof API_CLIENT_PASS_HEADERS;
     createCache?: typeof CREATE_CACHE_TOKEN;
-    tinkoffRequestRegistry: Map<string, MakeRequest>;
+    makeRequestRegistry: Map<string, MakeRequest>;
     agent?: typeof HTTP_CLIENT_AGENT;
     disableCircuitBreaker: typeof DISABLE_CIRCUIT_BREAKER;
 }) => typeof HTTP_CLIENT_FACTORY;

package/lib/httpClientModule.d.ts

@@ -1,2 +1,3 @@
-export declare class HttpClientModule {
-}
+export declare const HttpClientModule: import("@tramvai/core").ModuleType<{
+    new (): {};
+}>;

package/lib/index.browser.js

@@ -1,4 +1,3 @@
-import { __decorate } from 'tslib';
 import { createToken } from '@tinkoff/dippy';
 import { Module, provide, Scope, APP_INFO_TOKEN } from '@tramvai/core';
 import { PAPI_SERVICE, HTTP_CLIENT_FACTORY, API_CLIENT_PASS_HEADERS, HTTP_CLIENT_AGENT, DISABLE_CIRCUIT_BREAKER, HTTP_CLIENT } from '@tramvai/tokens-http-client';
@@ -56,7 +55,7 @@ const environmentDependentOptions = typeof window === 'undefined'
     : {
         defaultTimeout: 30000,
     };
-const httpClientFactory = ({ logger, envManager, appInfo, requestManager, headersList, createCache, tinkoffRequestRegistry, agent, disableCircuitBreaker = false, }) => {
+const httpClientFactory = ({ logger, envManager, appInfo, requestManager, headersList, createCache, makeRequestRegistry, agent, disableCircuitBreaker = false, }) => {
     return (options) => {
         if (!options.name) {
             throw Error(`Необходимо передать уникальное поле "name" для экземпляра HTTP клиента!`);
@@ -99,13 +98,13 @@ const httpClientFactory = ({ logger, envManager, appInfo, requestManager, header
             adapterOptions.enableCircuitBreaker = !forceDisabledCircuitBreaker;
         }
         // кэшируем инстанс @tinkoff/request
-        if (!tinkoffRequestRegistry.has(adapterOptions.name)) {
-            tinkoffRequestRegistry.set(adapterOptions.name, createTinkoffRequest(adapterOptions));
+        if (!makeRequestRegistry.has(adapterOptions.name)) {
+            makeRequestRegistry.set(adapterOptions.name, createTinkoffRequest(adapterOptions));
         }
-        const tinkoffRequest = tinkoffRequestRegistry.get(adapterOptions.name);
+        const makeRequest = makeRequestRegistry.get(adapterOptions.name);
         const httpClientAdapter = new HttpClientAdapter({
             options: adapterOptions,
-            tinkoffRequest,
+            makeRequest,
         });
         return httpClientAdapter;
     };
@@ -133,120 +132,114 @@ class PapiService extends ApiService {
     }
 }
 
-let PapiClientModule = class PapiClientModule {
-};
-PapiClientModule = __decorate([
-    Module({
-        providers: [
-            provide({
-                provide: PAPI_SERVICE,
-                scope: Scope.SINGLETON,
-                useClass: PapiService,
-                deps: {
-                    httpClientFactory: HTTP_CLIENT_FACTORY,
-                    baseUrl: SERVER_MODULE_PAPI_PUBLIC_URL,
-                },
-            }),
-        ],
-    })
-], PapiClientModule);
+const PapiClientModule = /* @__PURE__ */ Module({
+    providers: [
+        provide({
+            provide: PAPI_SERVICE,
+            scope: Scope.SINGLETON,
+            useClass: PapiService,
+            deps: {
+                httpClientFactory: HTTP_CLIENT_FACTORY,
+                baseUrl: SERVER_MODULE_PAPI_PUBLIC_URL,
+            },
+        }),
+    ],
+})(class PapiClientModule {
+});
 
 const createCacheToken = createToken('httpClient createCache');
-let HttpClientModule = class HttpClientModule {
-};
-HttpClientModule = __decorate([
-    Module({
-        imports: [PapiClientModule],
-        providers: [
-            provide({
-                provide: HTTP_CLIENT_FACTORY,
-                useFactory: httpClientFactory,
-                deps: {
-                    logger: LOGGER_TOKEN,
-                    envManager: ENV_MANAGER_TOKEN,
-                    appInfo: APP_INFO_TOKEN,
-                    createCache: createCacheToken,
-                    tinkoffRequestRegistry: 'tinkoffRequestRegistry',
-                    requestManager: {
-                        token: REQUEST_MANAGER_TOKEN,
-                        optional: true,
-                    },
-                    headersList: {
-                        token: API_CLIENT_PASS_HEADERS,
-                        optional: true,
-                    },
-                    agent: {
-                        token: HTTP_CLIENT_AGENT,
-                        optional: true,
-                    },
-                    disableCircuitBreaker: {
-                        token: DISABLE_CIRCUIT_BREAKER,
-                        optional: true,
-                    },
-                },
-            }),
-            provide({
-                provide: HTTP_CLIENT,
-                useFactory: ({ factory }) => {
-                    return factory({
-                        name: 'http-client',
-                        disableCache: true,
-                    });
+const HttpClientModule = /* @__PURE__ */ Module({
+    imports: [PapiClientModule],
+    providers: [
+        provide({
+            provide: HTTP_CLIENT_FACTORY,
+            useFactory: httpClientFactory,
+            deps: {
+                logger: LOGGER_TOKEN,
+                envManager: ENV_MANAGER_TOKEN,
+                appInfo: APP_INFO_TOKEN,
+                createCache: createCacheToken,
+                makeRequestRegistry: 'makeRequestRegistry',
+                requestManager: {
+                    token: REQUEST_MANAGER_TOKEN,
+                    optional: true,
                 },
-                deps: {
-                    factory: HTTP_CLIENT_FACTORY,
+                headersList: {
+                    token: API_CLIENT_PASS_HEADERS,
+                    optional: true,
                 },
-            }),
-            provide({
-                provide: ENV_USED_TOKEN,
-                useValue: [
-                    { key: 'HTTP_CLIENT_CACHE_DISABLED', optional: true, dehydrate: false },
-                    { key: 'HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED', optional: true, dehydrate: false },
-                ],
-                multi: true,
-            }),
-            /**
-             * хранилище для экземпляров @tinkoff/request
-             *
-             * требуется хранить экземпляры в единственном виде,
-             * т.к. многие плагины @tinkoff/request после инициализации имеют состояние
-             * (cache, circuit breaker), и не будут корректно работать на сервере,
-             * если создавать новые экземпляры на Scope.REQUEST
-             */
-            provide({
-                provide: 'tinkoffRequestRegistry',
-                scope: Scope.SINGLETON,
-                useFactory: () => new Map(),
-            }),
-            /**
-             * `CREATE_CACHE_TOKEN` имеет проверку, если токен используется провайдером,
-             * который имеет Scope.SINGLETON, то инстанс кэша сохраняется в общее хранилище,
-             * и доступен для очистки через `/papi/clear-cache`.
-             * Scope.REQUEST игнорируется, т.к. это верная утечка памяти,
-             * инстансов кэши было бы неограниченное количество.
-             *
-             * HTTP клиенты создаются со Scope.REQUEST, но инстансы @tinkoff/request
-             * (и соответственно кэшей) создаются только один раз, благодаря `tinkoffRequestRegistry`.
-             * это гарантирует отсутствие утечек памяти, поэтому мы обходим проверку
-             * на Scope.SINGLETON c помощью обертки `createCacheToken`
-             */
-            provide({
-                provide: createCacheToken,
-                scope: Scope.SINGLETON,
-                useFactory: ({ createCache }) => {
-                    return createCache;
+                agent: {
+                    token: HTTP_CLIENT_AGENT,
+                    optional: true,
                 },
-                deps: {
-                    createCache: CREATE_CACHE_TOKEN,
+                disableCircuitBreaker: {
+                    token: DISABLE_CIRCUIT_BREAKER,
+                    optional: true,
                 },
-            }),
-            provide({
-                provide: API_CLIENT_PASS_HEADERS,
-                multi: true,
-                useValue: ['x-request-id'],
-            }),
-        ],
-    })
-], HttpClientModule);
+            },
+        }),
+        provide({
+            provide: HTTP_CLIENT,
+            useFactory: ({ factory }) => {
+                return factory({
+                    name: 'http-client',
+                    disableCache: true,
+                });
+            },
+            deps: {
+                factory: HTTP_CLIENT_FACTORY,
+            },
+        }),
+        provide({
+            provide: ENV_USED_TOKEN,
+            useValue: [
+                { key: 'HTTP_CLIENT_CACHE_DISABLED', optional: true, dehydrate: false },
+                { key: 'HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED', optional: true, dehydrate: false },
+            ],
+            multi: true,
+        }),
+        /**
+         * хранилище для экземпляров @tinkoff/request
+         *
+         * требуется хранить экземпляры в единственном виде,
+         * т.к. многие плагины @tinkoff/request после инициализации имеют состояние
+         * (cache, circuit breaker), и не будут корректно работать на сервере,
+         * если создавать новые экземпляры на Scope.REQUEST
+         */
+        provide({
+            provide: 'makeRequestRegistry',
+            scope: Scope.SINGLETON,
+            useFactory: () => new Map(),
+        }),
+        /**
+         * `CREATE_CACHE_TOKEN` имеет проверку, если токен используется провайдером,
+         * который имеет Scope.SINGLETON, то инстанс кэша сохраняется в общее хранилище,
+         * и доступен для очистки через `/papi/clear-cache`.
+         * Scope.REQUEST игнорируется, т.к. это верная утечка памяти,
+         * инстансов кэши было бы неограниченное количество.
+         *
+         * HTTP клиенты создаются со Scope.REQUEST, но инстансы @tinkoff/request
+         * (и соответственно кэшей) создаются только один раз, благодаря `makeRequestRegistry`.
+         * это гарантирует отсутствие утечек памяти, поэтому мы обходим проверку
+         * на Scope.SINGLETON c помощью обертки `createCacheToken`
+         */
+        provide({
+            provide: createCacheToken,
+            scope: Scope.SINGLETON,
+            useFactory: ({ createCache }) => {
+                return createCache;
+            },
+            deps: {
+                createCache: CREATE_CACHE_TOKEN,
+            },
+        }),
+        provide({
+            provide: API_CLIENT_PASS_HEADERS,
+            multi: true,
+            useValue: ['x-request-id'],
+        }),
+    ],
+})(class HttpClientModule {
+});
 
 export { HttpClientModule, PapiService, fillHeaderIp, fillHeaders, formatError, httpClientFactory };

package/lib/index.es.js

@@ -1,4 +1,3 @@
-import { __decorate } from 'tslib';
 import { createChildContainer, createToken } from '@tinkoff/dippy';
 import { Module, provide, Scope, DI_TOKEN, APP_INFO_TOKEN } from '@tramvai/core';
 import { PAPI_SERVICE, HTTP_CLIENT_FACTORY, API_CLIENT_PASS_HEADERS, HTTP_CLIENT_AGENT, DISABLE_CIRCUIT_BREAKER, HTTP_CLIENT } from '@tramvai/tokens-http-client';
@@ -86,7 +85,7 @@ const environmentDependentOptions = typeof window === 'undefined'
     : {
         defaultTimeout: 30000,
     };
-const httpClientFactory = ({ logger, envManager, appInfo, requestManager, headersList, createCache, tinkoffRequestRegistry, agent, disableCircuitBreaker = false, }) => {
+const httpClientFactory = ({ logger, envManager, appInfo, requestManager, headersList, createCache, makeRequestRegistry, agent, disableCircuitBreaker = false, }) => {
     return (options) => {
         if (!options.name) {
             throw Error(`Необходимо передать уникальное поле "name" для экземпляра HTTP клиента!`);
@@ -129,13 +128,13 @@ const httpClientFactory = ({ logger, envManager, appInfo, requestManager, header
             adapterOptions.enableCircuitBreaker = !forceDisabledCircuitBreaker;
         }
         // кэшируем инстанс @tinkoff/request
-        if (!tinkoffRequestRegistry.has(adapterOptions.name)) {
-            tinkoffRequestRegistry.set(adapterOptions.name, createTinkoffRequest(adapterOptions));
+        if (!makeRequestRegistry.has(adapterOptions.name)) {
+            makeRequestRegistry.set(adapterOptions.name, createTinkoffRequest(adapterOptions));
         }
-        const tinkoffRequest = tinkoffRequestRegistry.get(adapterOptions.name);
+        const makeRequest = makeRequestRegistry.get(adapterOptions.name);
         const httpClientAdapter = new HttpClientAdapter({
             options: adapterOptions,
-            tinkoffRequest,
+            makeRequest,
         });
         return httpClientAdapter;
     };
@@ -180,120 +179,114 @@ class PapiService extends BaseHttpClient {
     }
 }
 
-let PapiClientModule = class PapiClientModule {
-};
-PapiClientModule = __decorate([
-    Module({
-        providers: [
-            provide({
-                provide: PAPI_SERVICE,
-                scope: Scope.SINGLETON,
-                useClass: PapiService,
-                deps: {
-                    di: DI_TOKEN,
-                    papi: { token: SERVER_MODULE_PAPI_PUBLIC_ROUTE, optional: true, multi: true },
-                },
-            }),
-        ],
-    })
-], PapiClientModule);
+const PapiClientModule = /* @__PURE__ */ Module({
+    providers: [
+        provide({
+            provide: PAPI_SERVICE,
+            scope: Scope.SINGLETON,
+            useClass: PapiService,
+            deps: {
+                di: DI_TOKEN,
+                papi: { token: SERVER_MODULE_PAPI_PUBLIC_ROUTE, optional: true, multi: true },
+            },
+        }),
+    ],
+})(class PapiClientModule {
+});
 
 const createCacheToken = createToken('httpClient createCache');
-let HttpClientModule = class HttpClientModule {
-};
-HttpClientModule = __decorate([
-    Module({
-        imports: [PapiClientModule],
-        providers: [
-            provide({
-                provide: HTTP_CLIENT_FACTORY,
-                useFactory: httpClientFactory,
-                deps: {
-                    logger: LOGGER_TOKEN,
-                    envManager: ENV_MANAGER_TOKEN,
-                    appInfo: APP_INFO_TOKEN,
-                    createCache: createCacheToken,
-                    tinkoffRequestRegistry: 'tinkoffRequestRegistry',
-                    requestManager: {
-                        token: REQUEST_MANAGER_TOKEN,
-                        optional: true,
-                    },
-                    headersList: {
-                        token: API_CLIENT_PASS_HEADERS,
-                        optional: true,
-                    },
-                    agent: {
-                        token: HTTP_CLIENT_AGENT,
-                        optional: true,
-                    },
-                    disableCircuitBreaker: {
-                        token: DISABLE_CIRCUIT_BREAKER,
-                        optional: true,
-                    },
-                },
-            }),
-            provide({
-                provide: HTTP_CLIENT,
-                useFactory: ({ factory }) => {
-                    return factory({
-                        name: 'http-client',
-                        disableCache: true,
-                    });
+const HttpClientModule = /* @__PURE__ */ Module({
+    imports: [PapiClientModule],
+    providers: [
+        provide({
+            provide: HTTP_CLIENT_FACTORY,
+            useFactory: httpClientFactory,
+            deps: {
+                logger: LOGGER_TOKEN,
+                envManager: ENV_MANAGER_TOKEN,
+                appInfo: APP_INFO_TOKEN,
+                createCache: createCacheToken,
+                makeRequestRegistry: 'makeRequestRegistry',
+                requestManager: {
+                    token: REQUEST_MANAGER_TOKEN,
+                    optional: true,
                 },
-                deps: {
-                    factory: HTTP_CLIENT_FACTORY,
+                headersList: {
+                    token: API_CLIENT_PASS_HEADERS,
+                    optional: true,
                 },
-            }),
-            provide({
-                provide: ENV_USED_TOKEN,
-                useValue: [
-                    { key: 'HTTP_CLIENT_CACHE_DISABLED', optional: true, dehydrate: false },
-                    { key: 'HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED', optional: true, dehydrate: false },
-                ],
-                multi: true,
-            }),
-            /**
-             * хранилище для экземпляров @tinkoff/request
-             *
-             * требуется хранить экземпляры в единственном виде,
-             * т.к. многие плагины @tinkoff/request после инициализации имеют состояние
-             * (cache, circuit breaker), и не будут корректно работать на сервере,
-             * если создавать новые экземпляры на Scope.REQUEST
-             */
-            provide({
-                provide: 'tinkoffRequestRegistry',
-                scope: Scope.SINGLETON,
-                useFactory: () => new Map(),
-            }),
-            /**
-             * `CREATE_CACHE_TOKEN` имеет проверку, если токен используется провайдером,
-             * который имеет Scope.SINGLETON, то инстанс кэша сохраняется в общее хранилище,
-             * и доступен для очистки через `/papi/clear-cache`.
-             * Scope.REQUEST игнорируется, т.к. это верная утечка памяти,
-             * инстансов кэши было бы неограниченное количество.
-             *
-             * HTTP клиенты создаются со Scope.REQUEST, но инстансы @tinkoff/request
-             * (и соответственно кэшей) создаются только один раз, благодаря `tinkoffRequestRegistry`.
-             * это гарантирует отсутствие утечек памяти, поэтому мы обходим проверку
-             * на Scope.SINGLETON c помощью обертки `createCacheToken`
-             */
-            provide({
-                provide: createCacheToken,
-                scope: Scope.SINGLETON,
-                useFactory: ({ createCache }) => {
-                    return createCache;
+                agent: {
+                    token: HTTP_CLIENT_AGENT,
+                    optional: true,
                 },
-                deps: {
-                    createCache: CREATE_CACHE_TOKEN,
+                disableCircuitBreaker: {
+                    token: DISABLE_CIRCUIT_BREAKER,
+                    optional: true,
                 },
-            }),
-            provide({
-                provide: API_CLIENT_PASS_HEADERS,
-                multi: true,
-                useValue: ['x-request-id'],
-            }),
-        ],
-    })
-], HttpClientModule);
+            },
+        }),
+        provide({
+            provide: HTTP_CLIENT,
+            useFactory: ({ factory }) => {
+                return factory({
+                    name: 'http-client',
+                    disableCache: true,
+                });
+            },
+            deps: {
+                factory: HTTP_CLIENT_FACTORY,
+            },
+        }),
+        provide({
+            provide: ENV_USED_TOKEN,
+            useValue: [
+                { key: 'HTTP_CLIENT_CACHE_DISABLED', optional: true, dehydrate: false },
+                { key: 'HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED', optional: true, dehydrate: false },
+            ],
+            multi: true,
+        }),
+        /**
+         * хранилище для экземпляров @tinkoff/request
+         *
+         * требуется хранить экземпляры в единственном виде,
+         * т.к. многие плагины @tinkoff/request после инициализации имеют состояние
+         * (cache, circuit breaker), и не будут корректно работать на сервере,
+         * если создавать новые экземпляры на Scope.REQUEST
+         */
+        provide({
+            provide: 'makeRequestRegistry',
+            scope: Scope.SINGLETON,
+            useFactory: () => new Map(),
+        }),
+        /**
+         * `CREATE_CACHE_TOKEN` имеет проверку, если токен используется провайдером,
+         * который имеет Scope.SINGLETON, то инстанс кэша сохраняется в общее хранилище,
+         * и доступен для очистки через `/papi/clear-cache`.
+         * Scope.REQUEST игнорируется, т.к. это верная утечка памяти,
+         * инстансов кэши было бы неограниченное количество.
+         *
+         * HTTP клиенты создаются со Scope.REQUEST, но инстансы @tinkoff/request
+         * (и соответственно кэшей) создаются только один раз, благодаря `makeRequestRegistry`.
+         * это гарантирует отсутствие утечек памяти, поэтому мы обходим проверку
+         * на Scope.SINGLETON c помощью обертки `createCacheToken`
+         */
+        provide({
+            provide: createCacheToken,
+            scope: Scope.SINGLETON,
+            useFactory: ({ createCache }) => {
+                return createCache;
+            },
+            deps: {
+                createCache: CREATE_CACHE_TOKEN,
+            },
+        }),
+        provide({
+            provide: API_CLIENT_PASS_HEADERS,
+            multi: true,
+            useValue: ['x-request-id'],
+        }),
+    ],
+})(class HttpClientModule {
+});
 
 export { HttpClientModule, PapiService, fillHeaderIp, fillHeaders, formatError, httpClientFactory };

package/lib/index.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
 var dippy = require('@tinkoff/dippy');
 var core = require('@tramvai/core');
 var tokensHttpClient = require('@tramvai/tokens-http-client');
@@ -97,7 +96,7 @@ const environmentDependentOptions = typeof window === 'undefined'
     : {
         defaultTimeout: 30000,
     };
-const httpClientFactory = ({ logger, envManager, appInfo, requestManager, headersList, createCache, tinkoffRequestRegistry, agent, disableCircuitBreaker = false, }) => {
+const httpClientFactory = ({ logger, envManager, appInfo, requestManager, headersList, createCache, makeRequestRegistry, agent, disableCircuitBreaker = false, }) => {
     return (options) => {
         if (!options.name) {
             throw Error(`Необходимо передать уникальное поле "name" для экземпляра HTTP клиента!`);
@@ -140,13 +139,13 @@ const httpClientFactory = ({ logger, envManager, appInfo, requestManager, header
             adapterOptions.enableCircuitBreaker = !forceDisabledCircuitBreaker;
         }
         // кэшируем инстанс @tinkoff/request
-        if (!tinkoffRequestRegistry.has(adapterOptions.name)) {
-            tinkoffRequestRegistry.set(adapterOptions.name, tinkoffRequestHttpClientAdapter.createTinkoffRequest(adapterOptions));
+        if (!makeRequestRegistry.has(adapterOptions.name)) {
+            makeRequestRegistry.set(adapterOptions.name, tinkoffRequestHttpClientAdapter.createTinkoffRequest(adapterOptions));
         }
-        const tinkoffRequest = tinkoffRequestRegistry.get(adapterOptions.name);
+        const makeRequest = makeRequestRegistry.get(adapterOptions.name);
         const httpClientAdapter = new tinkoffRequestHttpClientAdapter.HttpClientAdapter({
             options: adapterOptions,
-            tinkoffRequest,
+            makeRequest,
         });
         return httpClientAdapter;
     };
@@ -191,122 +190,117 @@ class PapiService extends httpClient.BaseHttpClient {
     }
 }
 
-let PapiClientModule = class PapiClientModule {
-};
-PapiClientModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                provide: tokensHttpClient.PAPI_SERVICE,
-                scope: core.Scope.SINGLETON,
-                useClass: PapiService,
-                deps: {
-                    di: core.DI_TOKEN,
-                    papi: { token: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE, optional: true, multi: true },
-                },
-            }),
-        ],
-    })
-], PapiClientModule);
+const PapiClientModule = /* @__PURE__ */ core.Module({
+    providers: [
+        core.provide({
+            provide: tokensHttpClient.PAPI_SERVICE,
+            scope: core.Scope.SINGLETON,
+            useClass: PapiService,
+            deps: {
+                di: core.DI_TOKEN,
+                papi: { token: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE, optional: true, multi: true },
+            },
+        }),
+    ],
+})(class PapiClientModule {
+});
 
 const createCacheToken = dippy.createToken('httpClient createCache');
-exports.HttpClientModule = class HttpClientModule {
-};
-exports.HttpClientModule = tslib.__decorate([
-    core.Module({
-        imports: [PapiClientModule],
-        providers: [
-            core.provide({
-                provide: tokensHttpClient.HTTP_CLIENT_FACTORY,
-                useFactory: httpClientFactory,
-                deps: {
-                    logger: tokensCommon.LOGGER_TOKEN,
-                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
-                    appInfo: core.APP_INFO_TOKEN,
-                    createCache: createCacheToken,
-                    tinkoffRequestRegistry: 'tinkoffRequestRegistry',
-                    requestManager: {
-                        token: tokensCommon.REQUEST_MANAGER_TOKEN,
-                        optional: true,
-                    },
-                    headersList: {
-                        token: tokensHttpClient.API_CLIENT_PASS_HEADERS,
-                        optional: true,
-                    },
-                    agent: {
-                        token: tokensHttpClient.HTTP_CLIENT_AGENT,
-                        optional: true,
-                    },
-                    disableCircuitBreaker: {
-                        token: tokensHttpClient.DISABLE_CIRCUIT_BREAKER,
-                        optional: true,
-                    },
-                },
-            }),
-            core.provide({
-                provide: tokensHttpClient.HTTP_CLIENT,
-                useFactory: ({ factory }) => {
-                    return factory({
-                        name: 'http-client',
-                        disableCache: true,
-                    });
+const HttpClientModule = /* @__PURE__ */ core.Module({
+    imports: [PapiClientModule],
+    providers: [
+        core.provide({
+            provide: tokensHttpClient.HTTP_CLIENT_FACTORY,
+            useFactory: httpClientFactory,
+            deps: {
+                logger: tokensCommon.LOGGER_TOKEN,
+                envManager: tokensCommon.ENV_MANAGER_TOKEN,
+                appInfo: core.APP_INFO_TOKEN,
+                createCache: createCacheToken,
+                makeRequestRegistry: 'makeRequestRegistry',
+                requestManager: {
+                    token: tokensCommon.REQUEST_MANAGER_TOKEN,
+                    optional: true,
                 },
-                deps: {
-                    factory: tokensHttpClient.HTTP_CLIENT_FACTORY,
+                headersList: {
+                    token: tokensHttpClient.API_CLIENT_PASS_HEADERS,
+                    optional: true,
                 },
-            }),
-            core.provide({
-                provide: tokensCommon.ENV_USED_TOKEN,
-                useValue: [
-                    { key: 'HTTP_CLIENT_CACHE_DISABLED', optional: true, dehydrate: false },
-                    { key: 'HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED', optional: true, dehydrate: false },
-                ],
-                multi: true,
-            }),
-            /**
-             * хранилище для экземпляров @tinkoff/request
-             *
-             * требуется хранить экземпляры в единственном виде,
-             * т.к. многие плагины @tinkoff/request после инициализации имеют состояние
-             * (cache, circuit breaker), и не будут корректно работать на сервере,
-             * если создавать новые экземпляры на Scope.REQUEST
-             */
-            core.provide({
-                provide: 'tinkoffRequestRegistry',
-                scope: core.Scope.SINGLETON,
-                useFactory: () => new Map(),
-            }),
-            /**
-             * `CREATE_CACHE_TOKEN` имеет проверку, если токен используется провайдером,
-             * который имеет Scope.SINGLETON, то инстанс кэша сохраняется в общее хранилище,
-             * и доступен для очистки через `/papi/clear-cache`.
-             * Scope.REQUEST игнорируется, т.к. это верная утечка памяти,
-             * инстансов кэши было бы неограниченное количество.
-             *
-             * HTTP клиенты создаются со Scope.REQUEST, но инстансы @tinkoff/request
-             * (и соответственно кэшей) создаются только один раз, благодаря `tinkoffRequestRegistry`.
-             * это гарантирует отсутствие утечек памяти, поэтому мы обходим проверку
-             * на Scope.SINGLETON c помощью обертки `createCacheToken`
-             */
-            core.provide({
-                provide: createCacheToken,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ createCache }) => {
-                    return createCache;
+                agent: {
+                    token: tokensHttpClient.HTTP_CLIENT_AGENT,
+                    optional: true,
                 },
-                deps: {
-                    createCache: tokensCommon.CREATE_CACHE_TOKEN,
+                disableCircuitBreaker: {
+                    token: tokensHttpClient.DISABLE_CIRCUIT_BREAKER,
+                    optional: true,
                 },
-            }),
-            core.provide({
-                provide: tokensHttpClient.API_CLIENT_PASS_HEADERS,
-                multi: true,
-                useValue: ['x-request-id'],
-            }),
-        ],
-    })
-], exports.HttpClientModule);
+            },
+        }),
+        core.provide({
+            provide: tokensHttpClient.HTTP_CLIENT,
+            useFactory: ({ factory }) => {
+                return factory({
+                    name: 'http-client',
+                    disableCache: true,
+                });
+            },
+            deps: {
+                factory: tokensHttpClient.HTTP_CLIENT_FACTORY,
+            },
+        }),
+        core.provide({
+            provide: tokensCommon.ENV_USED_TOKEN,
+            useValue: [
+                { key: 'HTTP_CLIENT_CACHE_DISABLED', optional: true, dehydrate: false },
+                { key: 'HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED', optional: true, dehydrate: false },
+            ],
+            multi: true,
+        }),
+        /**
+         * хранилище для экземпляров @tinkoff/request
+         *
+         * требуется хранить экземпляры в единственном виде,
+         * т.к. многие плагины @tinkoff/request после инициализации имеют состояние
+         * (cache, circuit breaker), и не будут корректно работать на сервере,
+         * если создавать новые экземпляры на Scope.REQUEST
+         */
+        core.provide({
+            provide: 'makeRequestRegistry',
+            scope: core.Scope.SINGLETON,
+            useFactory: () => new Map(),
+        }),
+        /**
+         * `CREATE_CACHE_TOKEN` имеет проверку, если токен используется провайдером,
+         * который имеет Scope.SINGLETON, то инстанс кэша сохраняется в общее хранилище,
+         * и доступен для очистки через `/papi/clear-cache`.
+         * Scope.REQUEST игнорируется, т.к. это верная утечка памяти,
+         * инстансов кэши было бы неограниченное количество.
+         *
+         * HTTP клиенты создаются со Scope.REQUEST, но инстансы @tinkoff/request
+         * (и соответственно кэшей) создаются только один раз, благодаря `makeRequestRegistry`.
+         * это гарантирует отсутствие утечек памяти, поэтому мы обходим проверку
+         * на Scope.SINGLETON c помощью обертки `createCacheToken`
+         */
+        core.provide({
+            provide: createCacheToken,
+            scope: core.Scope.SINGLETON,
+            useFactory: ({ createCache }) => {
+                return createCache;
+            },
+            deps: {
+                createCache: tokensCommon.CREATE_CACHE_TOKEN,
+            },
+        }),
+        core.provide({
+            provide: tokensHttpClient.API_CLIENT_PASS_HEADERS,
+            multi: true,
+            useValue: ['x-request-id'],
+        }),
+    ],
+})(class HttpClientModule {
+});
 
+exports.HttpClientModule = HttpClientModule;
 exports.PapiService = PapiService;
 exports.fillHeaderIp = fillHeaderIp;
 exports.fillHeaders = fillHeaders;

package/lib/papiClientModule.browser.d.ts

@@ -1,4 +1,5 @@
 import { PapiService } from './papi/papiService.browser';
 export { PapiService };
-export declare class PapiClientModule {
-}
+export declare const PapiClientModule: import("@tramvai/core").ModuleType<{
+    new (): {};
+}>;

package/lib/papiClientModule.d.ts

@@ -1,4 +1,5 @@
 import { PapiService } from './papi/papiService';
 export { PapiService };
-export declare class PapiClientModule {
-}
+export declare const PapiClientModule: import("@tramvai/core").ModuleType<{
+    new (): {};
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-http-client",
-  "version": "1.94.1",
+  "version": "1.95.0",
   "initialVersion": "0.58.99",
   "description": "",
   "main": "lib/index.js",
@@ -25,21 +25,21 @@
   },
   "dependencies": {
     "@tramvai/http-client": "0.1.25",
-    "@tramvai/tinkoff-request-http-client-adapter": "0.8.327",
-    "@tramvai/tokens-http-client": "1.94.1",
-    "@tramvai/tokens-common": "1.94.1",
-    "@tramvai/tokens-server": "1.94.1"
+    "@tramvai/tinkoff-request-http-client-adapter": "0.8.332",
+    "@tramvai/tokens-http-client": "1.95.0",
+    "@tramvai/tokens-common": "1.95.0",
+    "@tramvai/tokens-server": "1.95.0"
   },
   "devDependencies": {
     "@tinkoff/request-core": "^0.8.9"
   },
   "peerDependencies": {
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/core": "1.94.1",
-    "@tramvai/module-common": "1.94.1",
-    "@tramvai/papi": "1.94.1",
-    "@tramvai/test-helpers": "1.94.1",
-    "@tramvai/test-mocks": "1.94.1",
+    "@tramvai/core": "1.95.0",
+    "@tramvai/module-common": "1.95.0",
+    "@tramvai/papi": "1.95.0",
+    "@tramvai/test-helpers": "1.95.0",
+    "@tramvai/test-mocks": "1.95.0",
     "@tinkoff/dippy": "0.7.39",
     "node-fetch": "^2.6.1",
     "tslib": "^2.0.3"