@mepkg/maxios 1.0.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@mepkg/maxios",
+  "type": "module",
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test 'tests/**/*.test.js'",
+    "test:watch": "node --test --watch 'tests/**/*.test.js'"
+  },
+  "dependencies": {
+    "axios": "1.16.0",
+    "hpagent": "^1.2.0",
+    "lodash-es": "^4.18.1",
+    "melperjs": "^15.0.0"
+  },
+  "version": "1.0.0"
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export * from './maxios.js';
+export * from './tls-client.js';

package/src/maxios.js

@@ -0,0 +1,122 @@
+import {HttpProxyAgent, HttpsProxyAgent} from "hpagent";
+import {cookieDict, cookieHeader} from "melperjs";
+import axios from "axios";
+import {isNil, omitBy} from "lodash-es";
+
+
+export class Maxios {
+    constructor(proxy = null, config = {}, cookies = {}) {
+        this.proxy = proxy;
+        this.cookies = cookies;
+        config = config || {};
+
+        const axiosOptions = {
+            responseType: 'text',
+            timeout: config.timeout ?? 10000
+        };
+        if (this.proxy) {
+            const proxyTimeout = axiosOptions.timeout * 0.75 || undefined;
+            axiosOptions.httpsAgent = new HttpsProxyAgent({proxy, timeout: proxyTimeout});
+            axiosOptions.httpAgent = new HttpProxyAgent({proxy, timeout: proxyTimeout});
+        }
+        this.client = axios.create(axiosOptions);
+
+        this.client.interceptors.request.use((request) => {
+            this.#requestCookies(request);
+            return request;
+        });
+        this.client.interceptors.response.use(response => {
+            this.#responseCookies(response);
+            this.#attachJsonMethod(response);
+            this.#attachFinalUrl(response);
+            return response;
+        }, error => {
+            if (error.response) {
+                this.#responseCookies(error.response);
+                this.#attachJsonMethod(error.response);
+                this.#attachFinalUrl(error.response);
+            }
+            return Promise.reject(error);
+        });
+    }
+
+    async request(config = {}) {
+        config.headers = omitBy(config.headers, isNil);
+        return this.client.request(config);
+    }
+
+    async get(url, config = {}) {
+        config.headers = omitBy(config.headers, isNil);
+        return this.client.get(url, config);
+    }
+
+    async post(url, data = {}, config = {}) {
+        config.headers = omitBy(config.headers, isNil);
+        return this.client.post(url, data, config);
+    }
+
+    async put(url, data = {}, config = {}) {
+        config.headers = omitBy(config.headers, isNil);
+        return this.client.put(url, data, config);
+    }
+
+    async delete(url, config = {}) {
+        config.headers = omitBy(config.headers, isNil);
+        return this.client.delete(url, config);
+    }
+
+    async patch(url, data = {}, config = {}) {
+        config.headers = omitBy(config.headers, isNil);
+        return this.client.patch(url, data, config);
+    }
+
+    async head(url, config = {}) {
+        config.headers = omitBy(config.headers, isNil);
+        return this.client.head(url, config);
+    }
+
+    async options(url, config = {}) {
+        config.headers = omitBy(config.headers, isNil);
+        return this.client.options(url, config);
+    }
+
+    #attachFinalUrl = (response) => {
+        response.finalUrl = response?.request?.res?.responseUrl || "";
+    }
+
+    #attachJsonMethod = (response) => {
+        response.json = function (isSilent = false) {
+            try {
+                return JSON.parse(this.data);
+            } catch (error) {
+                if (isSilent) {
+                    return null;
+                }
+                throw error;
+            }
+        };
+    }
+
+    #responseCookies = (response) => {
+        if (!this.cookies) return;
+        const parsed = cookieDict(response);
+        Object.keys(parsed).forEach(key => {
+            if (!parsed[key]) {
+                delete parsed[key];
+            }
+        });
+        this.cookies = {...this.cookies, ...parsed};
+    }
+
+    #requestCookies = (request) => {
+        if (!this.cookies) return;
+        request.headers = request.headers || {};
+        if (!request.headers.cookie && !request.headers.Cookie) {
+            const header = cookieHeader(this.cookies);
+            header && (request.headers.cookie = header);
+        }
+    }
+
+}
+
+export const maxios = new Maxios(null, {}, false);

package/src/tls-client.js

@@ -0,0 +1,192 @@
+import {cookieDict, cookieHeader, Exception} from "melperjs";
+import {isNil, omitBy} from "lodash-es";
+import {maxios} from "./maxios.js";
+
+
+export const TLS_SERVER = {
+    url: null,
+    key: null
+};
+
+export class TlsClient {
+    constructor(proxy = null, {
+        tlsServer = TLS_SERVER,
+        timeout = 30000,
+        httpVersion = 2,
+        impersonate = "chrome_windows",
+        visit = null,
+        maxRedirects = 0,
+        base64 = false,
+        validateStatus = (status) => (status >= 200 && status <= 299) || (maxRedirects && status >= 300 && status <= 399)
+    } = {}, cookies = {}) {
+        this.proxy = proxy;
+        this.config = {timeout, httpVersion, impersonate, visit, maxRedirects, base64, validateStatus};
+        this.cookies = cookies;
+        this.tlsServer = tlsServer;
+        if (!this.tlsServer.url) {
+            throw Exception("TLS Server URL is not defined");
+        }
+    }
+
+    async request({
+                      headers,
+                      data,
+                      method,
+                      url,
+                      params,
+                      timeout,
+                      httpVersion,
+                      proxy,
+                      impersonate,
+                      visit,
+                      maxRedirects,
+                      base64,
+                      validateStatus
+                  } = {}) {
+        let tlsResponse;
+        try {
+            {
+                const adjustedHeaders = omitBy(headers, isNil);
+                headers = {};
+                for (const key in adjustedHeaders) {
+                    headers[key.toLowerCase()] = adjustedHeaders[key];
+                }
+            }
+            if (typeof data === "object") {
+                data = omitBy(data, isNil);
+                if (headers['content-type'] === 'application/json') {
+                    data = JSON.stringify(data);
+                } else {
+                    data = new URLSearchParams(data).toString();
+                }
+            }
+            if (params) {
+                const parsedUrl = new URL(url);
+                for (const key in params) {
+                    parsedUrl.searchParams.append(key, params[key].toString());
+                }
+                url = parsedUrl.toString();
+            }
+            maxRedirects = maxRedirects ?? this.config.maxRedirects;
+            const request = {
+                "method": method || "GET",
+                "url": url,
+                "headers": headers || {},
+                "data": data || "",
+                "timeout": timeout || this.config.timeout,
+                "httpVersion": httpVersion || this.config.httpVersion,
+                "proxy": proxy || this.proxy || undefined,
+                "impersonate": impersonate || this.config.impersonate,
+                "visit": visit || this.config.visit,
+                "redirects": maxRedirects,
+                "base64": base64 ?? this.config.base64,
+                "key": this.tlsServer.key
+            };
+            this.#requestCookies(request);
+            const axiosResponse = await maxios.post(this.tlsServer.url + "/execute", request, {
+                timeout: request.timeout + 1000,
+                maxRedirects: 0,
+                validateStatus: status => status === 200
+            });
+            const result = axiosResponse.json();
+
+            const responseHeaders = result.headers || {};
+            for (const key in responseHeaders) {
+                if (responseHeaders?.[key]?.length === 1) {
+                    responseHeaders[key] = responseHeaders[key][0];
+                }
+            }
+            tlsResponse = {
+                status: result.code,
+                headers: responseHeaders,
+                data: result.body,
+                finalUrl: result.final_url,
+                json: function (isSilent = false) {
+                    try {
+                        return JSON.parse(this.data);
+                    } catch (error) {
+                        if (isSilent) {
+                            return null;
+                        }
+                        throw error;
+                    }
+                }
+            };
+            this.#responseCookies(tlsResponse);
+            validateStatus = validateStatus || this.config.validateStatus;
+            if (validateStatus(result.code)) {
+                return tlsResponse;
+            }
+        } catch (e) {
+            throw Exception(`TlsClientException: ${e.response?.data || e.message}`, e.response, 'TlsClientException');
+        }
+
+        throw Exception("Request failed with status code " + tlsResponse?.status, tlsResponse, "TlsClientResponseException");
+    }
+
+    async get(url, config = {}) {
+        config.url = url;
+        config.method = "GET";
+        return this.request(config);
+    }
+
+    async post(url, data, config = {}) {
+        config.url = url;
+        config.method = "POST";
+        config.data = data;
+        return this.request(config);
+    }
+
+    async put(url, data, config = {}) {
+        config.url = url;
+        config.method = "PUT";
+        config.data = data;
+        return this.request(config);
+    }
+
+    async delete(url, config = {}) {
+        config.url = url;
+        config.method = "DELETE";
+        return this.request(config);
+    }
+
+    async patch(url, data, config = {}) {
+        config.url = url;
+        config.method = "PATCH";
+        config.data = data;
+        return this.request(config);
+    }
+
+    async head(url, config = {}) {
+        config.url = url;
+        config.method = "HEAD";
+        return this.request(config);
+    }
+
+    async options(url, config = {}) {
+        config.url = url;
+        config.method = "OPTIONS";
+        return this.request(config);
+    }
+
+    #responseCookies = (response) => {
+        if (!this.cookies) return;
+        const parsed = cookieDict(response);
+        Object.keys(parsed).forEach(key => {
+            if (!parsed[key]) {
+                delete parsed[key];
+            }
+        });
+        this.cookies = {...this.cookies, ...parsed};
+    }
+
+    #requestCookies = (request) => {
+        if (!this.cookies) return;
+        request.headers = request.headers || {};
+        if (!request.headers.cookie && !request.headers.Cookie) {
+            const header = cookieHeader(this.cookies);
+            header && (request.headers.cookie = header);
+        }
+    }
+
+}