@tramvai/module-http-client 2.20.1 → 2.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-http-client",
-  "version": "2.20.1",
+  "version": "2.22.0",
   "initialVersion": "0.58.99",
   "description": "",
   "main": "lib/index.js",
@@ -11,7 +11,9 @@
     "./lib/index.es.js": "./lib/index.browser.js"
   },
   "files": [
-    "lib"
+    "lib",
+    "tests.js",
+    "tests.d.ts"
   ],
   "sideEffects": false,
   "repository": {
@@ -25,10 +27,10 @@
   },
   "dependencies": {
     "@tramvai/http-client": "0.2.2",
-    "@tramvai/tinkoff-request-http-client-adapter": "0.9.52",
-    "@tramvai/tokens-http-client": "2.20.1",
-    "@tramvai/tokens-common": "2.20.1",
-    "@tramvai/tokens-server": "2.20.1"
+    "@tramvai/tinkoff-request-http-client-adapter": "0.9.55",
+    "@tramvai/tokens-http-client": "2.22.0",
+    "@tramvai/tokens-common": "2.22.0",
+    "@tramvai/tokens-server": "2.22.0"
   },
   "devDependencies": {
     "@tinkoff/request-core": "^0.9.2",
@@ -36,11 +38,11 @@
   },
   "peerDependencies": {
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/core": "2.20.1",
-    "@tramvai/module-common": "2.20.1",
-    "@tramvai/papi": "2.20.1",
-    "@tramvai/test-helpers": "2.20.1",
-    "@tramvai/test-mocks": "2.20.1",
+    "@tramvai/core": "2.22.0",
+    "@tramvai/module-common": "2.22.0",
+    "@tramvai/papi": "2.22.0",
+    "@tramvai/test-helpers": "2.22.0",
+    "@tramvai/test-mocks": "2.22.0",
     "@tinkoff/dippy": "0.8.2",
     "node-fetch": "^2.6.1",
     "tslib": "^2.0.3"

package/tests.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="jest" />
+import { getDiWrapper } from "@tramvai/test-helpers";
+import { createMockEnvManager } from "@tramvai/test-mocks";
+type Options = Parameters<typeof getDiWrapper>[0] & {
+    env?: Parameters<typeof createMockEnvManager>[0];
+};
+declare const testApi: (options: Options) => {
+    di: import("@tinkoff/dippy").Container;
+    fetchMock: jest.Mock<any, unknown[]>;
+    mockJsonResponse: (body: Record<string, any>, init?: ResponseInit) => Promise<void>;
+    clearCaches: () => void;
+};
+export { testApi };

package/tests.js

@@ -0,0 +1,357 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fetch = require('node-fetch');
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+var testHelpers = require('@tramvai/test-helpers');
+var testMocks = require('@tramvai/test-mocks');
+var dippy = require('@tinkoff/dippy');
+var tokensHttpClient = require('@tramvai/tokens-http-client');
+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 httpClient = require('@tramvai/http-client');
+var papi = require('@tramvai/papi');
+var moduleCommon = require('@tramvai/module-common');
+
+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 flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+var pick__default = /*#__PURE__*/_interopDefaultLegacy(pick);
+var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
+
+const fillHeaderIp = ({ requestManager, }) => {
+    if (!requestManager) {
+        return identity__default["default"];
+    }
+    return (params) => {
+        return {
+            ...params,
+            headers: {
+                ...params.headers,
+                'X-real-ip': requestManager.getClientIp(),
+            },
+        };
+    };
+};
+const fillHeaders = ({ requestManager, headersList, }) => {
+    if (!requestManager) {
+        return identity__default["default"];
+    }
+    const headerNames = flatten__default["default"](headersList !== null && headersList !== void 0 ? headersList : []);
+    return (params) => {
+        return {
+            ...params,
+            headers: {
+                ...params.headers,
+                ...pick__default["default"](headerNames, requestManager.getHeaders()),
+            },
+        };
+    };
+};
+
+const createUserAgent = ({ appInfo, envManager, }) => {
+    const { appName } = appInfo;
+    const appVersion = envManager.get('APP_VERSION');
+    const appRelease = envManager.get('APP_RELEASE');
+    const userAgent = [
+        'tramvai',
+        appName,
+        appVersion && `version ${appVersion}`,
+        appRelease && `release ${appRelease}`,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return userAgent;
+};
+
+const environmentDependentOptions = typeof window === 'undefined'
+    ? {
+        defaultTimeout: 2000,
+    }
+    : {
+        defaultTimeout: 30000,
+    };
+const httpClientFactory = ({ logger, envManager, appInfo, requestManager, headersList, createCache, makeRequestRegistry, agent, querySerializer, disableCircuitBreaker = false, defaultOptions, commandLineExecutionContext, }) => {
+    return (options) => {
+        var _a;
+        if (!options.name) {
+            throw Error(`You need to pass a unique field "name" for the HTTP client instance`);
+        }
+        const forceDisableCache = envManager.get('HTTP_CLIENT_CACHE_DISABLED');
+        const forceDisabledCircuitBreaker = envManager.get('HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED');
+        const adapterOptions = tinkoffRequestHttpClientAdapter.mergeOptions(tinkoffRequestHttpClientAdapter.mergeOptions({
+            logger,
+            agent,
+            querySerializer,
+            method: 'GET',
+            createCache: createCache
+                ? (cacheOptions) => createCache('memory', cacheOptions)
+                : undefined,
+            modifyRequest: compose__default["default"](fillHeaderIp({ requestManager }), fillHeaders({ requestManager, headersList })),
+            circuitBreakerOptions: {
+                failureThreshold: 75,
+                minimumFailureCount: 10,
+            },
+            signal: (_a = commandLineExecutionContext === null || commandLineExecutionContext === void 0 ? void 0 : commandLineExecutionContext()) === null || _a === void 0 ? void 0 : _a.abortSignal,
+            ...environmentDependentOptions,
+        }, defaultOptions !== null && defaultOptions !== void 0 ? defaultOptions : {}), options);
+        // по умолчанию, на сервере, библиотека https://github.com/node-fetch/node-fetch
+        // отправляет заголовок "User-Agent" вида "node-fetch".
+        // для улучшения логов сервисов, в которые делают запросы tramvai приложения,
+        // заменяем "User-Agent" на кастомный, содержащий название и версию приложения
+        if (typeof window === 'undefined') {
+            adapterOptions.headers = {
+                'User-Agent': createUserAgent({ appInfo, envManager }),
+                ...adapterOptions.headers,
+            };
+        }
+        if (!isNil__default["default"](forceDisableCache)) {
+            adapterOptions.disableCache = !!forceDisableCache;
+        }
+        if (disableCircuitBreaker) {
+            adapterOptions.enableCircuitBreaker = false;
+        }
+        // environment variable in priority over disableCircuitBreaker
+        if (!isNil__default["default"](forceDisabledCircuitBreaker)) {
+            adapterOptions.enableCircuitBreaker = !forceDisabledCircuitBreaker;
+        }
+        // кэшируем инстанс @tinkoff/request
+        if (!makeRequestRegistry.has(adapterOptions.name)) {
+            makeRequestRegistry.set(adapterOptions.name, tinkoffRequestHttpClientAdapter.createTinkoffRequest(adapterOptions));
+        }
+        const makeRequest = makeRequestRegistry.get(adapterOptions.name);
+        const httpClientAdapter = new tinkoffRequestHttpClientAdapter.HttpClientAdapter({
+            options: adapterOptions,
+            makeRequest,
+        });
+        return httpClientAdapter;
+    };
+};
+
+class PapiService extends httpClient.BaseHttpClient {
+    constructor({ papi, di }) {
+        super();
+        this.papi = flatten__default["default"](papi || []);
+        this.di = di;
+    }
+    async request({ path, query, body }) {
+        var _a;
+        const papiRoute = find__default["default"]((papi$1) => papi.getPapiParameters(papi$1).path === `/${path}`, this.papi);
+        if (!papiRoute) {
+            throw new Error(`papi handler '${path}' not found`);
+        }
+        const papi$1 = papi.getPapiParameters(papiRoute);
+        let rootDeps = {};
+        if (papi$1.rootDeps) {
+            rootDeps = this.di.getOfDeps(papi$1.rootDeps);
+            rootDeps = papi$1.mapRootDeps ? papi$1.mapRootDeps(rootDeps) : rootDeps;
+        }
+        const childDI = dippy.createChildContainer(this.di);
+        const req = { headers: { host: 'localhost' }, cookies: {}, query, body };
+        const res = {};
+        childDI.register({
+            provide: moduleCommon.REQUEST,
+            useValue: req,
+        });
+        childDI.register({
+            provide: moduleCommon.RESPONSE,
+            useValue: res,
+        });
+        const payload = await papi.getPapiParameters(papiRoute).handler({
+            ...rootDeps,
+            ...childDI.getOfDeps((_a = papi$1.deps) !== null && _a !== void 0 ? _a : {}),
+            req,
+            res,
+        });
+        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, multi: 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,
+                },
+                commandLineExecutionContext: {
+                    token: tokensCommon.COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
+                    optional: true,
+                },
+            },
+        }),
+        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 },
+            ],
+        }),
+        /**
+         * хранилище для экземпляров @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'],
+        }),
+    ],
+})(class HttpClientModule {
+});
+
+jest.mock('node-fetch');
+const { Response } = jest.requireActual('node-fetch');
+const testApi = (options) => {
+    const caches = [];
+    const { modules = [], providers = [], env } = options;
+    const { di } = testHelpers.getDiWrapper({
+        di: options.di,
+        modules: [HttpClientModule, ...modules],
+        providers: [
+            core.provide({
+                provide: tokensCommon.ENV_MANAGER_TOKEN,
+                useValue: testMocks.createMockEnvManager(env),
+            }),
+            core.provide({
+                provide: tokensCommon.LOGGER_TOKEN,
+                useValue: testMocks.createMockLogger(),
+            }),
+            core.provide({
+                provide: core.APP_INFO_TOKEN,
+                useValue: testMocks.createMockAppInfo(),
+            }),
+            core.provide({
+                provide: tokensCommon.REQUEST_MANAGER_TOKEN,
+                useValue: testMocks.createMockRequestManager(),
+            }),
+            core.provide({
+                provide: tokensCommon.CREATE_CACHE_TOKEN,
+                useValue: () => {
+                    const cache = testMocks.createMockCache();
+                    caches.push(cache);
+                    return cache;
+                },
+            }),
+            ...providers,
+        ],
+    });
+    const fetchMock = fetch__default["default"];
+    const clearCaches = () => {
+        caches.forEach((cache) => cache.clear());
+    };
+    return {
+        di,
+        fetchMock,
+        mockJsonResponse: async (body, init = {}) => {
+            clearCaches();
+            const { headers = {} } = init;
+            fetchMock.mockImplementation(() => Promise.resolve(new Response(JSON.stringify(body), {
+                status: 200,
+                ...init,
+                headers: {
+                    'content-type': 'application/json',
+                    ...headers,
+                },
+            })));
+        },
+        clearCaches,
+    };
+};
+
+exports.testApi = testApi;