@tramvai/tinkoff-request-http-client-adapter 0.9.176 → 0.9.181

package/lib/agent/createAgent.browser.browser.js

@@ -0,0 +1,3 @@
+const createAgent = () => { };
+
+export { createAgent };

package/lib/agent/createAgent.es.js

@@ -0,0 +1,14 @@
+import http from 'http';
+import https from 'https';
+
+const createAgent = (options = {
+    keepAlive: true,
+    scheduling: 'lifo',
+}) => {
+    return {
+        http: new http.Agent(options),
+        https: new https.Agent(options),
+    };
+};
+
+export { createAgent };

package/lib/agent/createAgent.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var http = require('http');
+var https = require('https');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
+
+const createAgent = (options = {
+    keepAlive: true,
+    scheduling: 'lifo',
+}) => {
+    return {
+        http: new http__default["default"].Agent(options),
+        https: new https__default["default"].Agent(options),
+    };
+};
+
+exports.createAgent = createAgent;

package/lib/createAdapter.browser.js

@@ -0,0 +1,10 @@
+import { createTinkoffRequest } from './createTinkoffRequest.browser.js';
+import { HttpClientAdapter } from './httpClientAdapter.browser.js';
+
+function createAdapter(options) {
+    const makeRequest = createTinkoffRequest(options);
+    const httpClientAdapter = new HttpClientAdapter({ options, makeRequest });
+    return httpClientAdapter;
+}
+
+export { createAdapter };

package/lib/createAdapter.es.js

@@ -0,0 +1,10 @@
+import { createTinkoffRequest } from './createTinkoffRequest.es.js';
+import { HttpClientAdapter } from './httpClientAdapter.es.js';
+
+function createAdapter(options) {
+    const makeRequest = createTinkoffRequest(options);
+    const httpClientAdapter = new HttpClientAdapter({ options, makeRequest });
+    return httpClientAdapter;
+}
+
+export { createAdapter };

package/lib/createAdapter.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createTinkoffRequest = require('./createTinkoffRequest.js');
+var httpClientAdapter = require('./httpClientAdapter.js');
+
+function createAdapter(options) {
+    const makeRequest = createTinkoffRequest.createTinkoffRequest(options);
+    const httpClientAdapter$1 = new httpClientAdapter.HttpClientAdapter({ options, makeRequest });
+    return httpClientAdapter$1;
+}
+
+exports.createAdapter = createAdapter;

package/lib/createTinkoffRequest.browser.js

@@ -0,0 +1,108 @@
+import either from '@tinkoff/utils/function/either';
+import request from '@tinkoff/request-core';
+import logPlugin from '@tinkoff/request-plugin-log';
+import deduplicateCache from '@tinkoff/request-plugin-cache-deduplicate';
+import memoryCache from '@tinkoff/request-plugin-cache-memory';
+import validate from '@tinkoff/request-plugin-validate';
+import http, { isServerError, isNetworkFail } from '@tinkoff/request-plugin-protocol-http';
+import transformUrl from '@tinkoff/request-plugin-transform-url';
+import circuitBreaker from '@tinkoff/request-plugin-circuit-breaker';
+import retry from '@tinkoff/request-plugin-retry';
+import { createAgent } from './agent/createAgent.browser.browser.js';
+
+const defaultAgent = createAgent();
+function createTinkoffRequest(options) {
+    const { logger, name, disableCache, enableCircuitBreaker, createCache, cacheTime = 30000, defaultTimeout, validator, errorValidator, errorModificator, circuitBreakerOptions = {}, getCacheKey, lruOptions = { max: 1000, maxAge: cacheTime }, agent, querySerializer, retryOptions, ...defaults } = options;
+    const log = logger && logger(`${name}:initialization`);
+    const plugins = [];
+    plugins.push({
+        init: (context, next) => {
+            next({
+                request: {
+                    timeout: defaultTimeout,
+                    ...context.getRequest(),
+                },
+            });
+        },
+    });
+    plugins.push(transformUrl({
+        baseUrl: defaults.baseUrl,
+        transform: ({ baseUrl, path, url }) => {
+            // если пользователь передал `url`, не модифицируем его, ожидается что это абсолютный URI
+            if (url) {
+                if (process.env.NODE_ENV === 'development') {
+                    if (url.indexOf('http') !== 0 && url.indexOf('//') !== 0) {
+                        log === null || log === void 0 ? void 0 : log.error(`url запроса должен содержать протокол и хост! текущее значение: ${url}`);
+                    }
+                }
+                return url;
+            }
+            if (baseUrl && path) {
+                const baseUrlHasTrailSlash = baseUrl.slice(-1) === '/';
+                const pathHasLeadSlash = path.slice(0, 1) === '/';
+                const needSlash = !baseUrlHasTrailSlash;
+                if (pathHasLeadSlash) {
+                    // eslint-disable-next-line no-param-reassign
+                    path = path.substring(1);
+                }
+                return `${baseUrl}${needSlash ? '/' : ''}${path}`;
+            }
+            if (process.env.NODE_ENV === 'development') {
+                if (!baseUrl && !path) {
+                    log === null || log === void 0 ? void 0 : log.error(`запрос должен содержать url, или baseUrl с полным путем запроса, или baseUrl вместе с path!`);
+                }
+            }
+            return baseUrl || path || '';
+        },
+    }));
+    plugins.push(logPlugin({
+        logger,
+        name,
+        showQueryFields: true,
+        showPayloadFields: true,
+    }));
+    plugins.push(memoryCache({
+        shouldExecute: !disableCache,
+        lruOptions,
+        allowStale: true,
+        getCacheKey,
+        memoryConstructor: createCache,
+    }));
+    plugins.push(deduplicateCache(getCacheKey ? { getCacheKey } : undefined));
+    if (enableCircuitBreaker) {
+        plugins.push(circuitBreaker({
+            isSystemError: either(isServerError, isNetworkFail),
+            ...circuitBreakerOptions,
+        }));
+    }
+    plugins.push({
+        error: (context, next) => {
+            const state = context.getState();
+            const error = errorModificator === null || errorModificator === void 0 ? void 0 : errorModificator(state);
+            if (error) {
+                return next({
+                    error,
+                });
+            }
+            return next();
+        },
+    });
+    if (validator || errorValidator) {
+        plugins.push(validate({
+            validator,
+            errorValidator,
+            allowFallback: true,
+        }));
+    }
+    plugins.push(http({
+        agent: agent || defaultAgent,
+        querySerializer: querySerializer || undefined,
+    }));
+    if (retryOptions) {
+        plugins.push(retry(retryOptions));
+    }
+    const makeRequest = request(plugins);
+    return makeRequest;
+}
+
+export { createTinkoffRequest };

package/lib/createTinkoffRequest.es.js

@@ -0,0 +1,108 @@
+import either from '@tinkoff/utils/function/either';
+import request from '@tinkoff/request-core';
+import logPlugin from '@tinkoff/request-plugin-log';
+import deduplicateCache from '@tinkoff/request-plugin-cache-deduplicate';
+import memoryCache from '@tinkoff/request-plugin-cache-memory';
+import validate from '@tinkoff/request-plugin-validate';
+import http, { isServerError, isNetworkFail } from '@tinkoff/request-plugin-protocol-http';
+import transformUrl from '@tinkoff/request-plugin-transform-url';
+import circuitBreaker from '@tinkoff/request-plugin-circuit-breaker';
+import retry from '@tinkoff/request-plugin-retry';
+import { createAgent } from './agent/createAgent.es.js';
+
+const defaultAgent = createAgent();
+function createTinkoffRequest(options) {
+    const { logger, name, disableCache, enableCircuitBreaker, createCache, cacheTime = 30000, defaultTimeout, validator, errorValidator, errorModificator, circuitBreakerOptions = {}, getCacheKey, lruOptions = { max: 1000, maxAge: cacheTime }, agent, querySerializer, retryOptions, ...defaults } = options;
+    const log = logger && logger(`${name}:initialization`);
+    const plugins = [];
+    plugins.push({
+        init: (context, next) => {
+            next({
+                request: {
+                    timeout: defaultTimeout,
+                    ...context.getRequest(),
+                },
+            });
+        },
+    });
+    plugins.push(transformUrl({
+        baseUrl: defaults.baseUrl,
+        transform: ({ baseUrl, path, url }) => {
+            // если пользователь передал `url`, не модифицируем его, ожидается что это абсолютный URI
+            if (url) {
+                if (process.env.NODE_ENV === 'development') {
+                    if (url.indexOf('http') !== 0 && url.indexOf('//') !== 0) {
+                        log === null || log === void 0 ? void 0 : log.error(`url запроса должен содержать протокол и хост! текущее значение: ${url}`);
+                    }
+                }
+                return url;
+            }
+            if (baseUrl && path) {
+                const baseUrlHasTrailSlash = baseUrl.slice(-1) === '/';
+                const pathHasLeadSlash = path.slice(0, 1) === '/';
+                const needSlash = !baseUrlHasTrailSlash;
+                if (pathHasLeadSlash) {
+                    // eslint-disable-next-line no-param-reassign
+                    path = path.substring(1);
+                }
+                return `${baseUrl}${needSlash ? '/' : ''}${path}`;
+            }
+            if (process.env.NODE_ENV === 'development') {
+                if (!baseUrl && !path) {
+                    log === null || log === void 0 ? void 0 : log.error(`запрос должен содержать url, или baseUrl с полным путем запроса, или baseUrl вместе с path!`);
+                }
+            }
+            return baseUrl || path || '';
+        },
+    }));
+    plugins.push(logPlugin({
+        logger,
+        name,
+        showQueryFields: true,
+        showPayloadFields: true,
+    }));
+    plugins.push(memoryCache({
+        shouldExecute: !disableCache,
+        lruOptions,
+        allowStale: true,
+        getCacheKey,
+        memoryConstructor: createCache,
+    }));
+    plugins.push(deduplicateCache(getCacheKey ? { getCacheKey } : undefined));
+    if (enableCircuitBreaker) {
+        plugins.push(circuitBreaker({
+            isSystemError: either(isServerError, isNetworkFail),
+            ...circuitBreakerOptions,
+        }));
+    }
+    plugins.push({
+        error: (context, next) => {
+            const state = context.getState();
+            const error = errorModificator === null || errorModificator === void 0 ? void 0 : errorModificator(state);
+            if (error) {
+                return next({
+                    error,
+                });
+            }
+            return next();
+        },
+    });
+    if (validator || errorValidator) {
+        plugins.push(validate({
+            validator,
+            errorValidator,
+            allowFallback: true,
+        }));
+    }
+    plugins.push(http({
+        agent: agent || defaultAgent,
+        querySerializer: querySerializer || undefined,
+    }));
+    if (retryOptions) {
+        plugins.push(retry(retryOptions));
+    }
+    const makeRequest = request(plugins);
+    return makeRequest;
+}
+
+export { createTinkoffRequest };

package/lib/createTinkoffRequest.js

@@ -0,0 +1,125 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var either = require('@tinkoff/utils/function/either');
+var request = require('@tinkoff/request-core');
+var logPlugin = require('@tinkoff/request-plugin-log');
+var deduplicateCache = require('@tinkoff/request-plugin-cache-deduplicate');
+var memoryCache = require('@tinkoff/request-plugin-cache-memory');
+var validate = require('@tinkoff/request-plugin-validate');
+var http = require('@tinkoff/request-plugin-protocol-http');
+var transformUrl = require('@tinkoff/request-plugin-transform-url');
+var circuitBreaker = require('@tinkoff/request-plugin-circuit-breaker');
+var retry = require('@tinkoff/request-plugin-retry');
+var createAgent = require('./agent/createAgent.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var either__default = /*#__PURE__*/_interopDefaultLegacy(either);
+var request__default = /*#__PURE__*/_interopDefaultLegacy(request);
+var logPlugin__default = /*#__PURE__*/_interopDefaultLegacy(logPlugin);
+var deduplicateCache__default = /*#__PURE__*/_interopDefaultLegacy(deduplicateCache);
+var memoryCache__default = /*#__PURE__*/_interopDefaultLegacy(memoryCache);
+var validate__default = /*#__PURE__*/_interopDefaultLegacy(validate);
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var transformUrl__default = /*#__PURE__*/_interopDefaultLegacy(transformUrl);
+var circuitBreaker__default = /*#__PURE__*/_interopDefaultLegacy(circuitBreaker);
+var retry__default = /*#__PURE__*/_interopDefaultLegacy(retry);
+
+const defaultAgent = createAgent.createAgent();
+function createTinkoffRequest(options) {
+    const { logger, name, disableCache, enableCircuitBreaker, createCache, cacheTime = 30000, defaultTimeout, validator, errorValidator, errorModificator, circuitBreakerOptions = {}, getCacheKey, lruOptions = { max: 1000, maxAge: cacheTime }, agent, querySerializer, retryOptions, ...defaults } = options;
+    const log = logger && logger(`${name}:initialization`);
+    const plugins = [];
+    plugins.push({
+        init: (context, next) => {
+            next({
+                request: {
+                    timeout: defaultTimeout,
+                    ...context.getRequest(),
+                },
+            });
+        },
+    });
+    plugins.push(transformUrl__default["default"]({
+        baseUrl: defaults.baseUrl,
+        transform: ({ baseUrl, path, url }) => {
+            // если пользователь передал `url`, не модифицируем его, ожидается что это абсолютный URI
+            if (url) {
+                if (process.env.NODE_ENV === 'development') {
+                    if (url.indexOf('http') !== 0 && url.indexOf('//') !== 0) {
+                        log === null || log === void 0 ? void 0 : log.error(`url запроса должен содержать протокол и хост! текущее значение: ${url}`);
+                    }
+                }
+                return url;
+            }
+            if (baseUrl && path) {
+                const baseUrlHasTrailSlash = baseUrl.slice(-1) === '/';
+                const pathHasLeadSlash = path.slice(0, 1) === '/';
+                const needSlash = !baseUrlHasTrailSlash;
+                if (pathHasLeadSlash) {
+                    // eslint-disable-next-line no-param-reassign
+                    path = path.substring(1);
+                }
+                return `${baseUrl}${needSlash ? '/' : ''}${path}`;
+            }
+            if (process.env.NODE_ENV === 'development') {
+                if (!baseUrl && !path) {
+                    log === null || log === void 0 ? void 0 : log.error(`запрос должен содержать url, или baseUrl с полным путем запроса, или baseUrl вместе с path!`);
+                }
+            }
+            return baseUrl || path || '';
+        },
+    }));
+    plugins.push(logPlugin__default["default"]({
+        logger,
+        name,
+        showQueryFields: true,
+        showPayloadFields: true,
+    }));
+    plugins.push(memoryCache__default["default"]({
+        shouldExecute: !disableCache,
+        lruOptions,
+        allowStale: true,
+        getCacheKey,
+        memoryConstructor: createCache,
+    }));
+    plugins.push(deduplicateCache__default["default"](getCacheKey ? { getCacheKey } : undefined));
+    if (enableCircuitBreaker) {
+        plugins.push(circuitBreaker__default["default"]({
+            isSystemError: either__default["default"](http.isServerError, http.isNetworkFail),
+            ...circuitBreakerOptions,
+        }));
+    }
+    plugins.push({
+        error: (context, next) => {
+            const state = context.getState();
+            const error = errorModificator === null || errorModificator === void 0 ? void 0 : errorModificator(state);
+            if (error) {
+                return next({
+                    error,
+                });
+            }
+            return next();
+        },
+    });
+    if (validator || errorValidator) {
+        plugins.push(validate__default["default"]({
+            validator,
+            errorValidator,
+            allowFallback: true,
+        }));
+    }
+    plugins.push(http__default["default"]({
+        agent: agent || defaultAgent,
+        querySerializer: querySerializer || undefined,
+    }));
+    if (retryOptions) {
+        plugins.push(retry__default["default"](retryOptions));
+    }
+    const makeRequest = request__default["default"](plugins);
+    return makeRequest;
+}
+
+exports.createTinkoffRequest = createTinkoffRequest;

package/lib/httpClientAdapter.browser.js

@@ -0,0 +1,60 @@
+import { getStatus, getHeaders } from '@tinkoff/request-plugin-protocol-http';
+import { BaseHttpClient } from '@tramvai/http-client';
+import { mergeOptions } from './mergeOptions.browser.js';
+
+class HttpClientAdapter extends BaseHttpClient {
+    constructor({ options, makeRequest, }) {
+        super();
+        this.options = options;
+        this.makeRequest = makeRequest;
+    }
+    async request(req) {
+        // применяем дефолтные опции до вызова modifyRequest на объекте запроса
+        const optionsWithDefaults = mergeOptions(this.options, req);
+        const { modifyRequest, modifyResponse, modifyError, ...reqWithDefaults } = optionsWithDefaults;
+        const { method, body, requestType, ...adaptedReq } = modifyRequest
+            ? modifyRequest(reqWithDefaults)
+            : reqWithDefaults;
+        if (method) {
+            adaptedReq.httpMethod = method;
+        }
+        if (body) {
+            adaptedReq.payload = body;
+        }
+        if (requestType) {
+            adaptedReq.type = requestType;
+        }
+        const res = this.makeRequest(adaptedReq);
+        try {
+            const payload = await res;
+            const status = getStatus(res);
+            const headers = getHeaders(res);
+            const resToModify = {
+                payload,
+                status,
+                headers,
+            };
+            return modifyResponse ? modifyResponse(resToModify) : resToModify;
+        }
+        catch (error) {
+            const meta = res.getExternalMeta();
+            const status = getStatus(res);
+            const headers = getHeaders(res);
+            // Useful for logging
+            const errorWithMeta = Object.assign(error, {
+                __meta: meta,
+                status,
+                headers,
+            });
+            throw modifyError ? modifyError(errorWithMeta, adaptedReq) : errorWithMeta;
+        }
+    }
+    fork(forkOptions = {}, mergeOptionsConfig = {}) {
+        return new HttpClientAdapter({
+            options: mergeOptions(this.options, forkOptions, mergeOptionsConfig),
+            makeRequest: this.makeRequest,
+        });
+    }
+}
+
+export { HttpClientAdapter };

package/lib/httpClientAdapter.es.js

@@ -0,0 +1,60 @@
+import { getStatus, getHeaders } from '@tinkoff/request-plugin-protocol-http';
+import { BaseHttpClient } from '@tramvai/http-client';
+import { mergeOptions } from './mergeOptions.es.js';
+
+class HttpClientAdapter extends BaseHttpClient {
+    constructor({ options, makeRequest, }) {
+        super();
+        this.options = options;
+        this.makeRequest = makeRequest;
+    }
+    async request(req) {
+        // применяем дефолтные опции до вызова modifyRequest на объекте запроса
+        const optionsWithDefaults = mergeOptions(this.options, req);
+        const { modifyRequest, modifyResponse, modifyError, ...reqWithDefaults } = optionsWithDefaults;
+        const { method, body, requestType, ...adaptedReq } = modifyRequest
+            ? modifyRequest(reqWithDefaults)
+            : reqWithDefaults;
+        if (method) {
+            adaptedReq.httpMethod = method;
+        }
+        if (body) {
+            adaptedReq.payload = body;
+        }
+        if (requestType) {
+            adaptedReq.type = requestType;
+        }
+        const res = this.makeRequest(adaptedReq);
+        try {
+            const payload = await res;
+            const status = getStatus(res);
+            const headers = getHeaders(res);
+            const resToModify = {
+                payload,
+                status,
+                headers,
+            };
+            return modifyResponse ? modifyResponse(resToModify) : resToModify;
+        }
+        catch (error) {
+            const meta = res.getExternalMeta();
+            const status = getStatus(res);
+            const headers = getHeaders(res);
+            // Useful for logging
+            const errorWithMeta = Object.assign(error, {
+                __meta: meta,
+                status,
+                headers,
+            });
+            throw modifyError ? modifyError(errorWithMeta, adaptedReq) : errorWithMeta;
+        }
+    }
+    fork(forkOptions = {}, mergeOptionsConfig = {}) {
+        return new HttpClientAdapter({
+            options: mergeOptions(this.options, forkOptions, mergeOptionsConfig),
+            makeRequest: this.makeRequest,
+        });
+    }
+}
+
+export { HttpClientAdapter };

package/lib/httpClientAdapter.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var http = require('@tinkoff/request-plugin-protocol-http');
+var httpClient = require('@tramvai/http-client');
+var mergeOptions = require('./mergeOptions.js');
+
+class HttpClientAdapter extends httpClient.BaseHttpClient {
+    constructor({ options, makeRequest, }) {
+        super();
+        this.options = options;
+        this.makeRequest = makeRequest;
+    }
+    async request(req) {
+        // применяем дефолтные опции до вызова modifyRequest на объекте запроса
+        const optionsWithDefaults = mergeOptions.mergeOptions(this.options, req);
+        const { modifyRequest, modifyResponse, modifyError, ...reqWithDefaults } = optionsWithDefaults;
+        const { method, body, requestType, ...adaptedReq } = modifyRequest
+            ? modifyRequest(reqWithDefaults)
+            : reqWithDefaults;
+        if (method) {
+            adaptedReq.httpMethod = method;
+        }
+        if (body) {
+            adaptedReq.payload = body;
+        }
+        if (requestType) {
+            adaptedReq.type = requestType;
+        }
+        const res = this.makeRequest(adaptedReq);
+        try {
+            const payload = await res;
+            const status = http.getStatus(res);
+            const headers = http.getHeaders(res);
+            const resToModify = {
+                payload,
+                status,
+                headers,
+            };
+            return modifyResponse ? modifyResponse(resToModify) : resToModify;
+        }
+        catch (error) {
+            const meta = res.getExternalMeta();
+            const status = http.getStatus(res);
+            const headers = http.getHeaders(res);
+            // Useful for logging
+            const errorWithMeta = Object.assign(error, {
+                __meta: meta,
+                status,
+                headers,
+            });
+            throw modifyError ? modifyError(errorWithMeta, adaptedReq) : errorWithMeta;
+        }
+    }
+    fork(forkOptions = {}, mergeOptionsConfig = {}) {
+        return new HttpClientAdapter({
+            options: mergeOptions.mergeOptions(this.options, forkOptions, mergeOptionsConfig),
+            makeRequest: this.makeRequest,
+        });
+    }
+}
+
+exports.HttpClientAdapter = HttpClientAdapter;