@tramvai/module-http-client 6.63.1 → 6.65.0

package/tests.js

@@ -2,34 +2,32 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var fetch = require('node-fetch');
 var testHelpers = require('@tramvai/test-helpers');
 var testMocks = require('@tramvai/test-mocks');
-var dippy = require('@tinkoff/dippy');
 var core = require('@tramvai/core');
 var tokensHttpClient = require('@tramvai/tokens-http-client');
-var tokensCommon = require('@tramvai/tokens-common');
-var isNil = require('@tinkoff/utils/is/nil');
-var compose = require('@tinkoff/utils/function/compose');
-var tinkoffRequestHttpClientAdapter = require('@tramvai/tinkoff-request-http-client-adapter');
-var identity = require('@tinkoff/utils/function/identity');
-var flatten = require('@tinkoff/utils/array/flatten');
-var pick = require('@tinkoff/utils/object/pick');
 var tokensServer = require('@tramvai/tokens-server');
 var find = require('@tinkoff/utils/array/find');
+var flatten = require('@tinkoff/utils/array/flatten');
 var httpClient = require('@tramvai/http-client');
+var dippy = require('@tinkoff/dippy');
 var papi = require('@tramvai/papi');
 var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var identity = require('@tinkoff/utils/function/identity');
+var pick = require('@tinkoff/utils/object/pick');
+var tokensCommon = require('@tramvai/tokens-common');
+var isNil = require('@tinkoff/utils/is/nil');
+var compose = require('@tinkoff/utils/function/compose');
+var tinkoffRequestHttpClientAdapter = require('@tramvai/tinkoff-request-http-client-adapter');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
-var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
-var compose__default = /*#__PURE__*/_interopDefaultLegacy(compose);
-var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
+var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
 var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
 var pick__default = /*#__PURE__*/_interopDefaultLegacy(pick);
-var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
+var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
+var compose__default = /*#__PURE__*/_interopDefaultLegacy(compose);
 
 const fillHeaderIp = ({ requestManager, }) => {
     if (!requestManager) {
@@ -68,6 +66,57 @@ const comparePathWithPattern = (path, pattern) => new RegExp(`^${pattern.replace
 
 const getPathParams = (path, pattern) => path.match(new RegExp(`^${pattern.replace(/:(\w+)/g, '(?<$1>[^\\/]+)')}$`))?.groups ?? {};
 
+class PapiService extends httpClient.BaseHttpClient {
+    constructor({ papi, di }) {
+        super();
+        this.papi = flatten__default["default"](papi || []);
+        this.di = di;
+    }
+    async request({ path, query, body, headers, }) {
+        const pathWithLeadingSlash = path?.startsWith('/') ? path : `/${path}`;
+        const papiRoute = find__default["default"]((papi$1) => comparePathWithPattern(pathWithLeadingSlash, papi.getPapiParameters(papi$1).path), this.papi ?? []);
+        if (!papiRoute) {
+            throw new Error(`papi handler '${path}' not found`);
+        }
+        const req = {
+            headers: { ...headers, host: 'localhost' },
+            cookies: {},
+            query,
+            body,
+            params: getPathParams(pathWithLeadingSlash, papi.getPapiParameters(papiRoute).path),
+        };
+        const res = {};
+        const childDi = dippy.createChildContainer(this.di, [
+            {
+                provide: tokensServerPrivate.FASTIFY_REQUEST,
+                useValue: req,
+            },
+            {
+                provide: tokensServerPrivate.FASTIFY_RESPONSE,
+                useValue: res,
+            },
+        ]);
+        const papiExecutor = childDi.get(tokensServerPrivate.PAPI_EXECUTOR);
+        const payload = await papiExecutor(papiRoute);
+        return { payload, status: 200, headers: {} };
+    }
+}
+
+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 },
+            },
+        }),
+    ],
+})(class PapiClientModule {
+});
+
 const createUserAgent = ({ appInfo, envManager, }) => {
     const { appName } = appInfo;
     const appVersion = envManager.get('APP_VERSION');
@@ -84,7 +133,7 @@ const createUserAgent = ({ appInfo, envManager, }) => {
 };
 
 /**
- * `node-fetch` sends "User-Agent: node-fetch" header
+ * nodejs sends "User-Agent: node" header
  * on the server by default. For logging purpose, we are
  * replacing "User-Agent" value with custom one, containing
  * both application name and version.
@@ -128,7 +177,6 @@ const httpClientFactory = ({ logger, envManager, appInfo, requestManager, header
                 failureThreshold: 75,
                 minimumFailureCount: 10,
             },
-            // TODO: remove any after [resolving](https://github.com/southpolesteve/node-abort-controller/issues/31)
             signal: commandLineExecutionContext?.()?.abortSignal,
             ...environmentDependentOptions,
         }, defaultOptions ? tinkoffRequestHttpClientAdapter.mergeOptions(defaultOptions, interceptors) : interceptors), options);
@@ -162,164 +210,156 @@ const httpClientFactory = ({ logger, envManager, appInfo, requestManager, header
     };
 };
 
-class PapiService extends httpClient.BaseHttpClient {
-    constructor({ papi, di }) {
-        super();
-        this.papi = flatten__default["default"](papi || []);
-        this.di = di;
-    }
-    async request({ path, query, body, headers, }) {
-        const pathWithLeadingSlash = path?.startsWith('/') ? path : `/${path}`;
-        const papiRoute = find__default["default"]((papi$1) => comparePathWithPattern(pathWithLeadingSlash, papi.getPapiParameters(papi$1).path), this.papi ?? []);
-        if (!papiRoute) {
-            throw new Error(`papi handler '${path}' not found`);
-        }
-        const req = {
-            headers: { ...headers, host: 'localhost' },
-            cookies: {},
-            query,
-            body,
-            params: getPathParams(pathWithLeadingSlash, papi.getPapiParameters(papiRoute).path),
-        };
-        const res = {};
-        const childDi = dippy.createChildContainer(this.di, [
-            {
-                provide: tokensServerPrivate.FASTIFY_REQUEST,
-                useValue: req,
-            },
-            {
-                provide: tokensServerPrivate.FASTIFY_RESPONSE,
-                useValue: res,
+const createCacheToken = dippy.createToken('httpClient createCache');
+const 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,
             },
-        ]);
-        const papiExecutor = childDi.get(tokensServerPrivate.PAPI_EXECUTOR);
-        const payload = await papiExecutor(papiRoute);
-        return { payload, status: 200, headers: {} };
-    }
-}
-
-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 },
+            headersList: {
+                token: tokensHttpClient.API_CLIENT_PASS_HEADERS,
+                optional: true,
             },
-        }),
-    ],
-})(class PapiClientModule {
-});
-
-const createCacheToken = dippy.createToken('httpClient createCache');
-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,
-                },
-                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,
-                },
-                defaultOptions: {
-                    token: tokensHttpClient.DEFAULT_HTTP_CLIENT_FACTORY_OPTIONS,
-                    optional: true,
-                },
-                defaultInterceptors: {
-                    token: tokensHttpClient.DEFAULT_HTTP_CLIENT_INTERCEPTORS,
-                    optional: true,
-                },
-                commandLineExecutionContext: {
-                    token: tokensCommon.COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
-                    optional: true,
-                },
+            agent: {
+                token: tokensHttpClient.HTTP_CLIENT_AGENT,
+                optional: true,
             },
-        }),
-        core.provide({
-            provide: tokensHttpClient.HTTP_CLIENT,
-            useFactory: ({ factory }) => {
-                return factory({
-                    name: 'http-client',
-                    enableCircuitBreaker: false,
-                });
+            disableCircuitBreaker: {
+                token: tokensHttpClient.DISABLE_CIRCUIT_BREAKER,
+                optional: true,
             },
-            deps: {
-                factory: tokensHttpClient.HTTP_CLIENT_FACTORY,
+            defaultOptions: {
+                token: tokensHttpClient.DEFAULT_HTTP_CLIENT_FACTORY_OPTIONS,
+                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 },
-            ],
-        }),
-        /**
-         * хранилище для экземпляров @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;
+            defaultInterceptors: {
+                token: tokensHttpClient.DEFAULT_HTTP_CLIENT_INTERCEPTORS,
+                optional: true,
             },
-            deps: {
-                createCache: tokensCommon.CREATE_CACHE_TOKEN,
+            commandLineExecutionContext: {
+                token: tokensCommon.COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
+                optional: true,
             },
-        }),
-        core.provide({
-            provide: tokensHttpClient.API_CLIENT_PASS_HEADERS,
-            useValue: ['x-request-id'],
-        }),
+        },
+    }),
+    core.provide({
+        provide: tokensHttpClient.HTTP_CLIENT,
+        useFactory: ({ factory }) => {
+            return factory({
+                name: 'http-client',
+                enableCircuitBreaker: false,
+            });
+        },
+        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 },
+        ],
+    }),
+    /**
+     * хранилище для экземпляров @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,
+        useValue: ['x-request-id'],
+    }),
+];
+
+const HttpClientModule = /* @__PURE__ */ core.declareModule({
+    name: 'HttpClientModule',
+    imports: [PapiClientModule],
+    providers: [
+        ...providers,
+        // we can't separate this module to browser and server files through "browser"
+        // package.json field, because jest not supports this field resolving out of the box
+        // and many unit tests rely on jsdom environment and fails because of resolving to server version
+        // TODO: separate jest preset for jsdom unit tests with custom resolver to support "browser" field
+        // @see https://github.com/marko-js/jest/blob/main/src/preset/browser/jest-preset.ts
+        ...(typeof window === 'undefined'
+            ? [
+                core.provide({
+                    provide: core.commandLineListTokens.init,
+                    useFactory: ({ agent }) => {
+                        return () => {
+                            const { setGlobalDispatcher } = require('undici');
+                            setGlobalDispatcher(agent.http);
+                        };
+                    },
+                    deps: {
+                        agent: tokensHttpClient.HTTP_CLIENT_AGENT,
+                    },
+                }),
+                core.provide({
+                    provide: tokensHttpClient.HTTP_CLIENT_AGENT,
+                    useFactory: ({ options, interceptors }) => {
+                        const { Agent } = require('undici');
+                        const agent = new Agent(options).compose(...(interceptors ?? []));
+                        return {
+                            http: agent,
+                            https: agent,
+                        };
+                    },
+                    deps: {
+                        options: tokensHttpClient.HTTP_CLIENT_AGENT_OPTIONS,
+                        interceptors: core.optional(tokensHttpClient.HTTP_CLIENT_AGENT_INTERCEPTORS),
+                    },
+                }),
+                core.provide({
+                    provide: tokensHttpClient.HTTP_CLIENT_AGENT_OPTIONS,
+                    useValue: {},
+                }),
+            ]
+            : []),
     ],
-})(class HttpClientModule {
 });
 
-jest.mock('node-fetch');
-const { Response } = jest.requireActual('node-fetch');
+const fetch = jest.spyOn(require('undici'), 'fetch');
 const testApi = (options) => {
     const caches = [];
     const { modules = [], providers = [], env } = options;
@@ -337,19 +377,17 @@ const testApi = (options) => {
         ],
         providers: [...providers],
     });
-    const fetchMock = fetch__default["default"];
+    const fetchMock = fetch;
     const clearCaches = () => {
         caches.forEach((cache) => cache.clear());
     };
     return {
         di,
         fetchMock,
-        mockJsonResponse: async (body, init = {}) => {
+        mockJsonResponse: async (body, { status, headers } = {}) => {
             clearCaches();
-            const { headers = {} } = init;
             fetchMock.mockImplementation(() => Promise.resolve(new Response(JSON.stringify(body), {
-                status: 200,
-                ...init,
+                status: status ?? 200,
                 headers: {
                     'content-type': 'application/json',
                     ...headers,