@mepkg/maxios 2.0.1 → 3.0.0

package/package.json

@@ -14,10 +14,10 @@
     "test:watch": "node --test --watch 'tests/**/*.test.js'"
   },
   "dependencies": {
-    "axios": "1.16.1",
-    "es-toolkit": "^1.47.0",
+    "axios": "1.17.0",
+    "es-toolkit": "^1.47.1",
     "hpagent": "^1.2.0",
     "melperjs": "^17.1.1"
   },
-  "version": "2.0.1"
+  "version": "3.0.0"
 }

package/src/helpers.js

@@ -0,0 +1,35 @@
+import {cookiesFromResponse, cookiesToHeader} from "melperjs";
+import isNil from "es-toolkit/compat/isNil";
+import omitBy from "es-toolkit/compat/omitBy";
+
+
+export function jsonMethod(throwOnError = false) {
+    try {
+        return JSON.parse(this.data);
+    } catch (error) {
+        if (throwOnError) {
+            return null;
+        }
+        throw error;
+    }
+}
+
+export function attachJsonMethod(response) {
+    response.json = jsonMethod;
+    return response;
+}
+
+export function mergeResponseCookies(cookies, response) {
+    if (!cookies) return cookies;
+    const parsed = omitBy(cookiesFromResponse(response), isNil);
+    return {...cookies, ...parsed};
+}
+
+export function attachRequestCookies(cookies, request) {
+    if (!cookies) return;
+    request.headers = request.headers || {};
+    if (isNil(request.headers.cookie) && isNil(request.headers.Cookie)) {
+        const header = cookiesToHeader(cookies);
+        header && (request.headers.cookie = header);
+    }
+}

package/src/maxios.js

@@ -1,15 +1,35 @@
+import axios from "axios";
 import {HttpProxyAgent, HttpsProxyAgent} from "hpagent";
-import {cookiesFromResponse, cookiesToHeader} from "melperjs";
 import isNil from "es-toolkit/compat/isNil";
 import omitBy from "es-toolkit/compat/omitBy";
-import axios from "axios";
-
+import {attachRequestCookies, attachJsonMethod, mergeResponseCookies} from "./helpers.js";
+
+
+/**
+ * An axios response augmented by Maxios with a `finalUrl` and a `json()` helper.
+ * @typedef {import("axios").AxiosResponse & {
+ *   finalUrl: string,
+ *   json: (throwOnError?: boolean) => any
+ * }} MaxiosResponse
+ */
+
+/**
+ * Maxios constructor options. Any axios option (`headers`, `validateStatus`,
+ * `maxRedirects`, `responseType`, ...) is forwarded to `axios.create`.
+ * @typedef {Omit<import("axios").AxiosRequestConfig, "proxy"> & {
+ *   proxy?: string | null,
+ *   cookies?: Record<string, string> | false
+ * }} MaxiosConfig
+ */
 
 export class Maxios {
-    constructor(proxy = null, config = {}, cookies = {}) {
+    /**
+     * @param {MaxiosConfig} [options]
+     */
+    constructor({proxy = null, cookies = {}, ...config} = {}) {
         this.proxy = proxy;
         this.cookies = cookies;
-        this.config = config || {};
+        this.config = config;
 
         this.config.responseType = config.responseType || "text";
         this.config.timeout = config.timeout || 10000;
@@ -20,108 +40,120 @@ export class Maxios {
                 this.config.httpsAgent = new HttpsProxyAgent({proxy, timeout: proxyTimeout});
                 this.config.httpAgent = new HttpProxyAgent({proxy, timeout: proxyTimeout});
             } catch (e) {
-                e.message = "Proxy Error | " + e.message;
+                e.message = "Proxy Configuration Error | " + e.message;
                 throw e;
             }
         }
+        /** @type {import("axios").AxiosInstance} */
         this.client = axios.create(this.config);
 
         this.client.interceptors.request.use((request) => {
-            this.#requestCookies(request);
+            attachRequestCookies(this.cookies, request);
             return request;
         });
         this.client.interceptors.response.use(response => {
-            this.#responseCookies(response);
-            this.#attachJsonMethod(response);
+            this.cookies = mergeResponseCookies(this.cookies, response);
+            attachJsonMethod(response);
             this.#attachFinalUrl(response);
             return response;
         }, error => {
             if (error.response) {
-                this.#responseCookies(error.response);
-                this.#attachJsonMethod(error.response);
+                this.cookies = mergeResponseCookies(this.cookies, error.response);
+                attachJsonMethod(error.response);
                 this.#attachFinalUrl(error.response);
             }
             return Promise.reject(error);
         });
     }
 
+    /**
+     * @param {import("axios").AxiosRequestConfig} [config]
+     * @returns {Promise<MaxiosResponse>}
+     */
     async request(config = {}) {
         config.headers = omitBy(config.headers, isNil);
-        return this.client.request(config);
+        return /** @type {Promise<MaxiosResponse>} */ (this.client.request(config));
     }
 
+    /**
+     * @param {string} url
+     * @param {import("axios").AxiosRequestConfig} [config]
+     * @returns {Promise<MaxiosResponse>}
+     */
     async get(url, config = {}) {
         config.headers = omitBy(config.headers, isNil);
-        return this.client.get(url, config);
+        return /** @type {Promise<MaxiosResponse>} */ (this.client.get(url, config));
     }
 
+    /**
+     * @param {string} url
+     * @param {*} [data]
+     * @param {import("axios").AxiosRequestConfig} [config]
+     * @returns {Promise<MaxiosResponse>}
+     */
     async post(url, data = {}, config = {}) {
         config.headers = omitBy(config.headers, isNil);
-        return this.client.post(url, data, config);
+        return /** @type {Promise<MaxiosResponse>} */ (this.client.post(url, data, config));
     }
 
+    /**
+     * @param {string} url
+     * @param {*} [data]
+     * @param {import("axios").AxiosRequestConfig} [config]
+     * @returns {Promise<MaxiosResponse>}
+     */
     async put(url, data = {}, config = {}) {
         config.headers = omitBy(config.headers, isNil);
-        return this.client.put(url, data, config);
+        return /** @type {Promise<MaxiosResponse>} */ (this.client.put(url, data, config));
     }
 
+    /**
+     * @param {string} url
+     * @param {import("axios").AxiosRequestConfig} [config]
+     * @returns {Promise<MaxiosResponse>}
+     */
     async delete(url, config = {}) {
         config.headers = omitBy(config.headers, isNil);
-        return this.client.delete(url, config);
+        return /** @type {Promise<MaxiosResponse>} */ (this.client.delete(url, config));
     }
 
+    /**
+     * @param {string} url
+     * @param {*} [data]
+     * @param {import("axios").AxiosRequestConfig} [config]
+     * @returns {Promise<MaxiosResponse>}
+     */
     async patch(url, data = {}, config = {}) {
         config.headers = omitBy(config.headers, isNil);
-        return this.client.patch(url, data, config);
+        return /** @type {Promise<MaxiosResponse>} */ (this.client.patch(url, data, config));
     }
 
+    /**
+     * @param {string} url
+     * @param {import("axios").AxiosRequestConfig} [config]
+     * @returns {Promise<MaxiosResponse>}
+     */
     async head(url, config = {}) {
         config.headers = omitBy(config.headers, isNil);
-        return this.client.head(url, config);
+        return /** @type {Promise<MaxiosResponse>} */ (this.client.head(url, config));
     }
 
+    /**
+     * @param {string} url
+     * @param {import("axios").AxiosRequestConfig} [config]
+     * @returns {Promise<MaxiosResponse>}
+     */
     async options(url, config = {}) {
         config.headers = omitBy(config.headers, isNil);
-        return this.client.options(url, config);
+        return /** @type {Promise<MaxiosResponse>} */ (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 = cookiesFromResponse(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 = cookiesToHeader(this.cookies);
-            header && (request.headers.cookie = header);
-        }
+        response.finalUrl = response?.request?.res?.responseUrl
+            || (response?.config && this.client.getUri(response.config))
+            || "";
     }
 
 }
 
-export const maxios = new Maxios(null, {}, false);
+export const maxios = new Maxios({cookies: false});

package/src/tls-client.js

@@ -1,7 +1,8 @@
-import {cookiesFromResponse, cookiesToHeader, Exception} from "melperjs";
+import {Exception} from "melperjs";
 import isNil from "es-toolkit/compat/isNil";
 import omitBy from "es-toolkit/compat/omitBy";
 import {maxios} from "./maxios.js";
+import {attachRequestCookies, jsonMethod, mergeResponseCookies} from "./helpers.js";
 
 
 export const TLS_SERVER = {
@@ -10,7 +11,9 @@ export const TLS_SERVER = {
 };
 
 export class TlsClient {
-    constructor(proxy = null, {
+    constructor({
+        proxy = null,
+        cookies = {},
         tlsServer = TLS_SERVER,
         timeout = 30000,
         httpVersion = 2,
@@ -20,7 +23,7 @@ export class TlsClient {
         requestBodyFormat = "text",
         responseBodyFormat = "text",
         validateStatus = (status) => (status >= 200 && status <= 299) || (maxRedirects && status >= 300 && status <= 399)
-    } = {}, cookies = {}) {
+    } = {}) {
         this.proxy = proxy;
         this.config = {
             timeout,
@@ -94,9 +97,9 @@ export class TlsClient {
                 "responseBodyFormat": responseBodyFormat || this.config.responseBodyFormat,
                 "key": this.tlsServer.key
             };
-            this.#requestCookies(request);
+            attachRequestCookies(this.cookies, request);
             const axiosResponse = await maxios.post(this.tlsServer.url + "/execute", request, {
-                timeout: request.timeout + 1000,
+                timeout: request.timeout,
                 maxRedirects: 0,
                 validateStatus: status => status === 200
             });
@@ -113,18 +116,9 @@ export class TlsClient {
                 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;
-                    }
-                }
+                json: jsonMethod
             };
-            this.#responseCookies(tlsResponse);
+            this.cookies = mergeResponseCookies(this.cookies, tlsResponse);
             validateStatus = validateStatus || this.config.validateStatus;
             if (validateStatus(result.code)) {
                 return tlsResponse;
@@ -181,24 +175,4 @@ export class TlsClient {
         return this.request(config);
     }
 
-    #responseCookies = (response) => {
-        if (!this.cookies) return;
-        const parsed = cookiesFromResponse(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 = cookiesToHeader(this.cookies);
-            header && (request.headers.cookie = header);
-        }
-    }
-
 }