@tramvai/module-http-client 1.94.1 → 1.94.2

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';
@@ -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,
+                tinkoffRequestRegistry: 'tinkoffRequestRegistry',
+                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: '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;
+            },
+            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';
@@ -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,
+                tinkoffRequestRegistry: 'tinkoffRequestRegistry',
+                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: '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;
+            },
+            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');
@@ -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,
+                tinkoffRequestRegistry: 'tinkoffRequestRegistry',
+                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: '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;
+            },
+            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.94.2",
   "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.328",
+    "@tramvai/tokens-http-client": "1.94.2",
+    "@tramvai/tokens-common": "1.94.2",
+    "@tramvai/tokens-server": "1.94.2"
   },
   "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.94.2",
+    "@tramvai/module-common": "1.94.2",
+    "@tramvai/papi": "1.94.2",
+    "@tramvai/test-helpers": "1.94.2",
+    "@tramvai/test-mocks": "1.94.2",
     "@tinkoff/dippy": "0.7.39",
     "node-fetch": "^2.6.1",
     "tslib": "^2.0.3"