@tramvai/module-http-proxy-agent 1.55.0

package/README.md

@@ -0,0 +1,46 @@
+# HttpProxyAgent
+
+Enable support for http_proxy, https_proxy and no_proxy env variables
+
+## Installation
+
+You need to install `@tramvai/module-http-proxy-agent`
+
+```bash
+yarn add @tramvai/module-http-proxy-agent
+```
+
+And connect in the project
+
+```tsx
+import { createApp } from '@tramvai/core';
+import { HttpProxyAgentModule } from '@tramvai/module-http-proxy-agent';
+
+createApp({
+  name: 'tincoin',
+  modules: [ HttpProxyAgentModule ],
+});
+```
+
+## Environment variables
+
+- `HTTP_PROXY` - proxy url for HTTP requests
+- `http_proxy` - see `HTTP_PROXY`
+
+- `HTTPS_PROXY` - proxy url for HTTPS requests
+- `https_proxy` - see `HTTPS_PROXY`
+
+- `NO_PROXY` - list of urls patterns for which proxying is disabled
+- `no_proxy` - see `NO_PROXY`
+
+## Explanation
+
+`HttpProxyAgentModule` mokeypatch standard NodeJS [https.Agent](https://nodejs.org/dist/latest-v16.x/docs/api/https.html#class-httpsagent) for supporting connections via forwarding proxy, if some of mentioned above env variables are presented.
+
+Some `NO_PROXY` env specification and examples [available here](https://about.gitlab.com/blog/2021/01/27/we-need-to-talk-no-proxy/#standardizing-no_proxy)
+
+Source code forked from [node-keepalive-proxy-agent](https://github.com/mknj/node-keepalive-proxy-agent)
+
+## Limitations
+
+`HttpProxyAgentModule` [support only HTTPS requests](https://github.com/mknj/node-keepalive-proxy-agent/issues/28)

package/lib/add-proxy-to-https-agent/add-proxy-to-https-agent.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import type { AgentOptions } from 'https';
+import type { Socket } from 'net';
+import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
+declare type Proxy = {
+    hostname: string;
+    port: number;
+    auth?: string;
+};
+export interface HttpsProxyAgentOptions extends AgentOptions {
+    proxy?: Proxy;
+    logger: ReturnType<typeof LOGGER_TOKEN>;
+}
+export interface ConnectOptions {
+    protocol: string;
+    host: string;
+    port: number;
+    hostname: string;
+    search: string;
+    query: string;
+    pathname: string;
+    path: string;
+    href: string;
+    method: string;
+    headers: Record<string, string[]>;
+    socket: Socket;
+}
+/**
+ * Fork of https://github.com/mknj/node-keepalive-proxy-agent with monkeypatching and no_proxy support
+ */
+export declare const addProxyToHttpsAgent: ({ logger }: {
+    logger: ReturnType<typeof LOGGER_TOKEN>;
+}) => void;
+export {};

package/lib/add-proxy-to-https-agent/match-no-proxy.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Support specification proposal from https://about.gitlab.com/blog/2021/01/27/we-need-to-talk-no-proxy/#the-lowest-common-denominator
+ */
+export declare const matchNoProxy: ({ noProxy, hostname, }: {
+    noProxy: string;
+    hostname: string;
+}) => boolean;

package/lib/browser.d.ts

@@ -0,0 +1,2 @@
+export declare class HttpProxyAgentModule {
+}

package/lib/browser.js

@@ -0,0 +1,13 @@
+import { __decorate } from 'tslib';
+import { Module } from '@tramvai/core';
+
+let HttpProxyAgentModule = class HttpProxyAgentModule {
+};
+HttpProxyAgentModule = __decorate([
+    Module({
+        imports: [],
+        providers: [],
+    })
+], HttpProxyAgentModule);
+
+export { HttpProxyAgentModule };

package/lib/server.d.ts

@@ -0,0 +1,2 @@
+export declare class HttpProxyAgentModule {
+}

package/lib/server.es.js

@@ -0,0 +1,168 @@
+import { __decorate } from 'tslib';
+import { Module, commandLineListTokens } from '@tramvai/core';
+import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import https from 'https';
+import net from 'net';
+import url from 'url';
+
+const httpProxyEnabled = () => {
+    const { http_proxy, HTTP_PROXY, https_proxy, HTTPS_PROXY, no_proxy, NO_PROXY } = process.env;
+    return !!(http_proxy || HTTP_PROXY || https_proxy || HTTPS_PROXY || no_proxy || NO_PROXY);
+};
+const getHttpsProxy = () => {
+    const { https_proxy, HTTPS_PROXY } = process.env;
+    return https_proxy || HTTPS_PROXY || '';
+};
+const getNoProxy = () => {
+    const { no_proxy, NO_PROXY } = process.env;
+    return no_proxy || NO_PROXY || '';
+};
+
+const RULES_SEPARATOR = ',';
+const HOST_PORT_SEPARATOR = ':';
+const WILDCARD = '*';
+/**
+ * Support specification proposal from https://about.gitlab.com/blog/2021/01/27/we-need-to-talk-no-proxy/#the-lowest-common-denominator
+ */
+const matchNoProxy = ({ noProxy, hostname, }) => {
+    const rules = noProxy.split(RULES_SEPARATOR).filter(Boolean);
+    for (const rule of rules) {
+        // @todo: respect port when matching
+        const [ruleHost, _rulePort] = rule.split(HOST_PORT_SEPARATOR);
+        // Wildcard (*) match all hosts
+        if (ruleHost === WILDCARD) {
+            return true;
+        }
+        // Strip leading dots (.) and wildcard with dot (*.) for backward compatibility
+        const ruleHostWithoutLeadingDot = ruleHost.replace(/^\*?\./, '');
+        const matchRegex = new RegExp(`${ruleHostWithoutLeadingDot}$`);
+        /**
+         * @example
+         * 'localhost'.match(/localhost$/)
+         * 'api.test.com'.match(/test.com$/)
+         */
+        if (hostname.match(matchRegex)) {
+            return true;
+        }
+    }
+    return false;
+};
+
+/* eslint-disable no-param-reassign */
+/**
+ * Fork of https://github.com/mknj/node-keepalive-proxy-agent with monkeypatching and no_proxy support
+ */
+const addProxyToHttpsAgent = ({ logger }) => {
+    const httpsProxyEnv = getHttpsProxy();
+    const noProxyEnv = getNoProxy();
+    const noProxyMatchResults = {};
+    if (!httpsProxyEnv) {
+        return;
+    }
+    const parsedProxy = new url.URL(httpsProxyEnv);
+    const proxy = { hostname: parsedProxy.hostname, port: parsedProxy.port };
+    logger.debug({
+        event: 'parsed proxy',
+        proxy,
+    });
+    // @ts-expect-error
+    const originalCreateConnection = https.Agent.prototype.createConnection;
+    // @ts-expect-error
+    https.Agent.prototype.createConnection = createConnection;
+    function createConnection(options, cb) {
+        const { hostname, href, method, headers } = options;
+        const connectionMustBeProxied = !noProxyEnv || !matchNoProxyWithCache({ hostname });
+        if (connectionMustBeProxied) {
+            logger.debug({
+                event: 'proxy connection',
+                connection: {
+                    href,
+                    method,
+                    headers,
+                },
+            });
+            createConnectionHttpsAfterHttp.call(this, options, cb);
+        }
+        else {
+            cb(null, originalCreateConnection.call(this, options));
+        }
+    }
+    function createConnectionHttpsAfterHttp(options, cb) {
+        const proxySocket = net.connect(+proxy.port, proxy.hostname);
+        const errorListener = (error) => {
+            proxySocket.destroy();
+            cb(error);
+        };
+        proxySocket.once('error', errorListener);
+        let response = '';
+        const dataListener = (data) => {
+            response += data.toString();
+            if (!response.endsWith('\r\n\r\n')) {
+                // response not completed yet
+                return;
+            }
+            proxySocket.removeListener('error', errorListener);
+            proxySocket.removeListener('data', dataListener);
+            const m = response.match(/^HTTP\/1.\d (\d*)/);
+            if (m == null || m[1] == null) {
+                proxySocket.destroy();
+                return cb(new Error(response.trim()));
+            }
+            if (m[1] !== '200') {
+                proxySocket.destroy();
+                return cb(new Error(m[0]));
+            }
+            // tell super function to use our proxy socket
+            options.socket = proxySocket;
+            cb(null, originalCreateConnection.call(this, options));
+        };
+        proxySocket.on('data', dataListener);
+        let host = options.hostname;
+        if (!host) {
+            host = options.host;
+        }
+        // https://datatracker.ietf.org/doc/html/rfc7231#section-4.3.6
+        let cmd = `CONNECT ${host}:${options.port} HTTP/1.1\r\n`;
+        cmd += `Host: ${host}:${options.port}\r\n`;
+        cmd += '\r\n';
+        proxySocket.write(cmd);
+    }
+    function matchNoProxyWithCache({ hostname }) {
+        if (hostname in noProxyMatchResults) {
+            return noProxyMatchResults[hostname];
+        }
+        const noProxy = noProxyEnv;
+        const result = matchNoProxy({ noProxy, hostname });
+        noProxyMatchResults[hostname] = result;
+        return result;
+    }
+};
+/* eslint-enable no-param-reassign */
+
+let HttpProxyAgentModule = class HttpProxyAgentModule {
+};
+HttpProxyAgentModule = __decorate([
+    Module({
+        imports: [],
+        providers: [
+            httpProxyEnabled() && {
+                provide: commandLineListTokens.init,
+                multi: true,
+                useFactory: ({ loggerFactory }) => function addHttpsProxy() {
+                    const logger = loggerFactory('http-proxy-agent');
+                    logger.debug({
+                        event: 'proxy agent enabled',
+                        proxyEnv: getHttpsProxy(),
+                        noProxyEnv: getNoProxy(),
+                    });
+                    addProxyToHttpsAgent({ logger });
+                },
+                deps: {
+                    loggerFactory: LOGGER_TOKEN,
+                },
+            },
+        ].filter(Boolean),
+    })
+], HttpProxyAgentModule);
+
+export { HttpProxyAgentModule };

package/lib/server.js

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+var https = require('https');
+var net = require('net');
+var url = require('url');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
+var net__default = /*#__PURE__*/_interopDefaultLegacy(net);
+var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
+
+const httpProxyEnabled = () => {
+    const { http_proxy, HTTP_PROXY, https_proxy, HTTPS_PROXY, no_proxy, NO_PROXY } = process.env;
+    return !!(http_proxy || HTTP_PROXY || https_proxy || HTTPS_PROXY || no_proxy || NO_PROXY);
+};
+const getHttpsProxy = () => {
+    const { https_proxy, HTTPS_PROXY } = process.env;
+    return https_proxy || HTTPS_PROXY || '';
+};
+const getNoProxy = () => {
+    const { no_proxy, NO_PROXY } = process.env;
+    return no_proxy || NO_PROXY || '';
+};
+
+const RULES_SEPARATOR = ',';
+const HOST_PORT_SEPARATOR = ':';
+const WILDCARD = '*';
+/**
+ * Support specification proposal from https://about.gitlab.com/blog/2021/01/27/we-need-to-talk-no-proxy/#the-lowest-common-denominator
+ */
+const matchNoProxy = ({ noProxy, hostname, }) => {
+    const rules = noProxy.split(RULES_SEPARATOR).filter(Boolean);
+    for (const rule of rules) {
+        // @todo: respect port when matching
+        const [ruleHost, _rulePort] = rule.split(HOST_PORT_SEPARATOR);
+        // Wildcard (*) match all hosts
+        if (ruleHost === WILDCARD) {
+            return true;
+        }
+        // Strip leading dots (.) and wildcard with dot (*.) for backward compatibility
+        const ruleHostWithoutLeadingDot = ruleHost.replace(/^\*?\./, '');
+        const matchRegex = new RegExp(`${ruleHostWithoutLeadingDot}$`);
+        /**
+         * @example
+         * 'localhost'.match(/localhost$/)
+         * 'api.test.com'.match(/test.com$/)
+         */
+        if (hostname.match(matchRegex)) {
+            return true;
+        }
+    }
+    return false;
+};
+
+/* eslint-disable no-param-reassign */
+/**
+ * Fork of https://github.com/mknj/node-keepalive-proxy-agent with monkeypatching and no_proxy support
+ */
+const addProxyToHttpsAgent = ({ logger }) => {
+    const httpsProxyEnv = getHttpsProxy();
+    const noProxyEnv = getNoProxy();
+    const noProxyMatchResults = {};
+    if (!httpsProxyEnv) {
+        return;
+    }
+    const parsedProxy = new url__default["default"].URL(httpsProxyEnv);
+    const proxy = { hostname: parsedProxy.hostname, port: parsedProxy.port };
+    logger.debug({
+        event: 'parsed proxy',
+        proxy,
+    });
+    // @ts-expect-error
+    const originalCreateConnection = https__default["default"].Agent.prototype.createConnection;
+    // @ts-expect-error
+    https__default["default"].Agent.prototype.createConnection = createConnection;
+    function createConnection(options, cb) {
+        const { hostname, href, method, headers } = options;
+        const connectionMustBeProxied = !noProxyEnv || !matchNoProxyWithCache({ hostname });
+        if (connectionMustBeProxied) {
+            logger.debug({
+                event: 'proxy connection',
+                connection: {
+                    href,
+                    method,
+                    headers,
+                },
+            });
+            createConnectionHttpsAfterHttp.call(this, options, cb);
+        }
+        else {
+            cb(null, originalCreateConnection.call(this, options));
+        }
+    }
+    function createConnectionHttpsAfterHttp(options, cb) {
+        const proxySocket = net__default["default"].connect(+proxy.port, proxy.hostname);
+        const errorListener = (error) => {
+            proxySocket.destroy();
+            cb(error);
+        };
+        proxySocket.once('error', errorListener);
+        let response = '';
+        const dataListener = (data) => {
+            response += data.toString();
+            if (!response.endsWith('\r\n\r\n')) {
+                // response not completed yet
+                return;
+            }
+            proxySocket.removeListener('error', errorListener);
+            proxySocket.removeListener('data', dataListener);
+            const m = response.match(/^HTTP\/1.\d (\d*)/);
+            if (m == null || m[1] == null) {
+                proxySocket.destroy();
+                return cb(new Error(response.trim()));
+            }
+            if (m[1] !== '200') {
+                proxySocket.destroy();
+                return cb(new Error(m[0]));
+            }
+            // tell super function to use our proxy socket
+            options.socket = proxySocket;
+            cb(null, originalCreateConnection.call(this, options));
+        };
+        proxySocket.on('data', dataListener);
+        let host = options.hostname;
+        if (!host) {
+            host = options.host;
+        }
+        // https://datatracker.ietf.org/doc/html/rfc7231#section-4.3.6
+        let cmd = `CONNECT ${host}:${options.port} HTTP/1.1\r\n`;
+        cmd += `Host: ${host}:${options.port}\r\n`;
+        cmd += '\r\n';
+        proxySocket.write(cmd);
+    }
+    function matchNoProxyWithCache({ hostname }) {
+        if (hostname in noProxyMatchResults) {
+            return noProxyMatchResults[hostname];
+        }
+        const noProxy = noProxyEnv;
+        const result = matchNoProxy({ noProxy, hostname });
+        noProxyMatchResults[hostname] = result;
+        return result;
+    }
+};
+/* eslint-enable no-param-reassign */
+
+exports.HttpProxyAgentModule = class HttpProxyAgentModule {
+};
+exports.HttpProxyAgentModule = tslib.__decorate([
+    core.Module({
+        imports: [],
+        providers: [
+            httpProxyEnabled() && {
+                provide: core.commandLineListTokens.init,
+                multi: true,
+                useFactory: ({ loggerFactory }) => function addHttpsProxy() {
+                    const logger = loggerFactory('http-proxy-agent');
+                    logger.debug({
+                        event: 'proxy agent enabled',
+                        proxyEnv: getHttpsProxy(),
+                        noProxyEnv: getNoProxy(),
+                    });
+                    addProxyToHttpsAgent({ logger });
+                },
+                deps: {
+                    loggerFactory: tokensCommon.LOGGER_TOKEN,
+                },
+            },
+        ].filter(Boolean),
+    })
+], exports.HttpProxyAgentModule);

package/lib/utils/env.d.ts

@@ -0,0 +1,3 @@
+export declare const httpProxyEnabled: () => boolean;
+export declare const getHttpsProxy: () => string;
+export declare const getNoProxy: () => string;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@tramvai/module-http-proxy-agent",
+  "version": "1.55.0",
+  "description": "Enable support for http_proxy, https_proxy and no_proxy env variables",
+  "browser": "lib/browser.js",
+  "main": "lib/server.js",
+  "module": "lib/server.es.js",
+  "typings": "lib/server.d.ts",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:Tinkoff/tramvai.git"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "tramvai-build --for-publish",
+    "watch": "tsc -w",
+    "build-for-publish": "true"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@tramvai/tokens-common": "1.55.0"
+  },
+  "devDependencies": {},
+  "peerDependencies": {
+    "@tramvai/core": "1.55.0",
+    "@tinkoff/dippy": "0.7.37",
+    "tslib": "^2.0.3"
+  }
+}