@ekhein/http-request 1.0.0

package/README.md

@@ -0,0 +1,57 @@
+# Sekiro Node.js Client
+
+A Node.js client for the Sekiro WebSocket API.
+
+## Installation
+
+```bash
+npm install sekiro-node-client
+```
+
+## Usage
+
+```javascript
+import SekiroClient from 'sekiro-node-client';
+
+// Create client instance
+const client = new SekiroClient('ws://your-sekiro-server:port', {
+  reconnectInterval: 2000,
+  maxReconnectAttempts: 10
+});
+
+// Register action handlers
+client.registerAction('test', (request, success, failure) => {
+  try {
+    // Process request
+    success({ result: 'ok', data: request });
+  } catch (error) {
+    failure(error.message);
+  }
+});
+
+// Graceful shutdown
+process.on('SIGINT', () => {
+  client.close();
+  process.exit();
+});
+```
+
+## API
+
+### `new SekiroClient(wsURL, [options])`
+Creates a new SekiroClient instance.
+
+**Parameters:**
+- `wsURL`: WebSocket server URL (required)
+- `options`: Configuration options (optional)
+  - `reconnectInterval`: Base reconnect interval in ms (default: 2000)
+  - `maxReconnectAttempts`: Maximum reconnect attempts (default: 10)
+  - `wsOptions`: Additional WebSocket options
+
+### Methods:
+- `registerAction(action, handler)`: Register a handler for an action
+- `close()`: Close the WebSocket connection
+
+## License
+
+MIT

package/dist/agent/index.d.ts

@@ -0,0 +1,19 @@
+import { CookieAgentOptions, HttpCookieAgent, HttpsCookieAgent } from 'http-cookie-agent/http';
+import { LiuGuanProxy, Phone4GProxy } from '../proxy';
+export declare const HttpCookieWithPhone4GProxyAgent: new (rest_0: {
+    clientIp: string;
+}, rest_1: CookieAgentOptions) => Phone4GProxy;
+export declare const HttpsCookieWithPhone4GProxyAgent: new (rest_0: {
+    clientIp: string;
+}, rest_1: CookieAgentOptions) => Phone4GProxy;
+export declare const HttpCookieWithLiuGuanProxyAgent: new (rest_0: {
+    adcode?: string;
+    visitorId?: string;
+    unbindTime?: string;
+}, rest_1: CookieAgentOptions) => LiuGuanProxy;
+export declare const HttpsCookieWithLiuGuanProxyAgent: new (rest_0: {
+    adcode?: string;
+    visitorId?: string;
+    unbindTime?: string;
+}, rest_1: CookieAgentOptions) => LiuGuanProxy;
+export { HttpCookieAgent, HttpsCookieAgent };

package/dist/agent/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpsCookieAgent = exports.HttpCookieAgent = exports.HttpsCookieWithLiuGuanProxyAgent = exports.HttpCookieWithLiuGuanProxyAgent = exports.HttpsCookieWithPhone4GProxyAgent = exports.HttpCookieWithPhone4GProxyAgent = void 0;
+const http_1 = require("http-cookie-agent/http");
+Object.defineProperty(exports, "HttpCookieAgent", { enumerable: true, get: function () { return http_1.HttpCookieAgent; } });
+Object.defineProperty(exports, "HttpsCookieAgent", { enumerable: true, get: function () { return http_1.HttpsCookieAgent; } });
+const proxy_1 = require("../proxy");
+exports.HttpCookieWithPhone4GProxyAgent = (0, http_1.createCookieAgent)(proxy_1.Phone4GProxy);
+exports.HttpsCookieWithPhone4GProxyAgent = (0, http_1.createCookieAgent)(proxy_1.Phone4GProxy);
+exports.HttpCookieWithLiuGuanProxyAgent = (0, http_1.createCookieAgent)(proxy_1.LiuGuanProxy);
+exports.HttpsCookieWithLiuGuanProxyAgent = (0, http_1.createCookieAgent)(proxy_1.LiuGuanProxy);

package/dist/exceptions/axiosRetryLimitError.d.ts

@@ -0,0 +1,4 @@
+import { AxiosError, InternalAxiosRequestConfig } from "axios";
+export declare class AxiosRetryLimitError extends AxiosError {
+    constructor(config: InternalAxiosRequestConfig);
+}

package/dist/exceptions/axiosRetryLimitError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosRetryLimitError = void 0;
+const axios_1 = require("axios");
+class AxiosRetryLimitError extends axios_1.AxiosError {
+    constructor(config) {
+        const code = String("AXIOS_RETRY_LIMIT_ERROR");
+        const message = String("Axios retry limit error");
+        super(message, code, config);
+    }
+}
+exports.AxiosRetryLimitError = AxiosRetryLimitError;

package/dist/exceptions/axiosRetryableError.d.ts

@@ -0,0 +1,4 @@
+import { AxiosError, InternalAxiosRequestConfig } from "axios";
+export declare class AxiosRetryableError extends AxiosError {
+    constructor(config: InternalAxiosRequestConfig);
+}

package/dist/exceptions/axiosRetryableError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosRetryableError = void 0;
+const axios_1 = require("axios");
+class AxiosRetryableError extends axios_1.AxiosError {
+    constructor(config) {
+        const code = String("AXIOS_RETRYABLE_ERROR");
+        const message = String("Axios retryable error");
+        super(message, code, config);
+    }
+}
+exports.AxiosRetryableError = AxiosRetryableError;

package/dist/exceptions/index.d.ts

@@ -0,0 +1,2 @@
+export { AxiosRetryableError } from './axiosRetryableError';
+export { AxiosRetryLimitError } from './axiosRetryLimitError';

package/dist/exceptions/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosRetryLimitError = exports.AxiosRetryableError = void 0;
+var axiosRetryableError_1 = require("./axiosRetryableError");
+Object.defineProperty(exports, "AxiosRetryableError", { enumerable: true, get: function () { return axiosRetryableError_1.AxiosRetryableError; } });
+var axiosRetryLimitError_1 = require("./axiosRetryLimitError");
+Object.defineProperty(exports, "AxiosRetryLimitError", { enumerable: true, get: function () { return axiosRetryLimitError_1.AxiosRetryLimitError; } });

package/dist/main.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance, AxiosRequestConfig } from "axios";
+export declare class HttpRequest {
+    readonly instance: AxiosInstance;
+    constructor(options: AxiosRequestConfig);
+    execute<R = any>(options: AxiosRequestConfig): Promise<R>;
+    post<R = any>(url: string, data?: any): Promise<R>;
+    call<R = any>(path: string, data: object): Promise<R>;
+}

package/dist/main.js

@@ -0,0 +1,216 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequest = void 0;
+const axios_1 = __importStar(require("axios"));
+const jsdom_1 = require("jsdom");
+const lodash_1 = require("lodash");
+const tough_cookie_1 = require("tough-cookie");
+const cookie_1 = require("cookie");
+const tldts_1 = require("tldts");
+const common_1 = require("@nestjs/common");
+const http_error_by_code_util_1 = require("@nestjs/common/utils/http-error-by-code.util");
+const agent_1 = require("./agent");
+const agent_2 = require("./agent");
+const agent_3 = require("./agent");
+const exceptions_1 = require("./exceptions");
+class HttpRequest {
+    instance;
+    constructor(options) {
+        /* Axios */
+        this.instance = axios_1.default.create({
+            ...Object.assign({
+                ["headers"]: {},
+                ["retryLimit"]: 3,
+            }, options, {
+                ["proxy"]: false,
+                ["retryCount"]: 0,
+            })
+        });
+        /* Set Http Agent */
+        this.instance.interceptors.request.use(async (request) => {
+            const jar = Object(request.jar);
+            const cookies = Object({ jar });
+            if (request.useProxy) {
+                if (typeof request.useProxy === "boolean") {
+                    request.httpAgent = new agent_3.HttpCookieWithLiuGuanProxyAgent({}, { cookies });
+                    request.httpsAgent = new agent_3.HttpsCookieWithLiuGuanProxyAgent({}, { cookies });
+                }
+                if (typeof request.useProxy === "object") {
+                    if ("clientIp" in request.useProxy) {
+                        request.httpAgent = new agent_2.HttpCookieWithPhone4GProxyAgent(request.useProxy, { cookies });
+                        request.httpsAgent = new agent_2.HttpsCookieWithPhone4GProxyAgent(request.useProxy, { cookies });
+                    }
+                    else {
+                        request.httpAgent = new agent_3.HttpCookieWithLiuGuanProxyAgent(request.useProxy, { cookies });
+                        request.httpsAgent = new agent_3.HttpsCookieWithLiuGuanProxyAgent(request.useProxy, { cookies });
+                    }
+                }
+            }
+            else {
+                request.httpAgent = new agent_1.HttpCookieAgent({ cookies });
+                request.httpsAgent = new agent_1.HttpsCookieAgent({ cookies });
+            }
+            return request;
+        });
+        /* Set Cookie */
+        this.instance.interceptors.request.use(async (request) => {
+            if (request.headers.cookie) {
+                const api = new URL(request.url, request.baseURL);
+                const domain = (0, tldts_1.getDomain)(api.href); /* 一级域名 */
+                const cookies = (0, cookie_1.parse)(request.headers.cookie);
+                const website = Array(api.protocol, domain).join("//");
+                const entries = Object.entries(cookies);
+                for (const [key, value] of entries) {
+                    const cookie = new tough_cookie_1.Cookie({ key, value, domain });
+                    request.jar.setCookieSync(cookie, website);
+                }
+            }
+            return request;
+        });
+        /* Set Cookie Jar */
+        this.instance.interceptors.request.use(async (request) => {
+            if (!request.jar)
+                request.jar = new tough_cookie_1.CookieJar();
+            return request;
+        });
+        /* Headers Format */
+        this.instance.interceptors.request.use(async (request) => {
+            if (request.headers) {
+                const headers = Object.entries(request.headers);
+                for (const [key, value] of headers) {
+                    if (/^[a-zA-Z]+(?:[A-Z][a-z]*)*$/.test(key)) {
+                        const lowerKey = String(key).replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+                        request.headers.delete(key);
+                        request.headers.set(lowerKey, value);
+                    }
+                }
+            }
+            return request;
+        });
+        /* Set Body */
+        this.instance.interceptors.request.use(async (request) => {
+            if (request.body) {
+                request.headers.setContentType("application/json");
+                request.data = request.body;
+            }
+            if (request.form) {
+                request.headers.setContentType("application/x-www-form-urlencoded");
+                request.data = request.form;
+            }
+            return request;
+        });
+        /* Transform */
+        this.instance.interceptors.request.use(async (request) => {
+            if (request.serviceType == 1) { }
+            if (request.serviceType == 2) {
+                const group = String(request.path).split("/").at(-2);
+                const action = String(request.path).split("/").at(-1);
+                const invoke_timeout = Number(request.timeout - 5e3);
+                request.url = String("/business-demo/invoke");
+                request.params = Object({ group, action, invoke_timeout });
+            }
+            return request;
+        });
+        /* Call Custom Hook */
+        this.instance.interceptors.request.use(options.interceptorHooks?.requestInterceptor, options.interceptorHooks?.requestInterceptorCatch);
+        /* Save Origin Config */
+        this.instance.interceptors.request.use(async (request) => {
+            request.__origin__ = (0, lodash_1.cloneDeep)(request);
+            return (request);
+        });
+        /* Transform */
+        this.instance.interceptors.response.use(async (response) => {
+            if (response.config.serviceType == 1) {
+                if (http_error_by_code_util_1.HttpErrorByCode[response.data.err])
+                    throw new http_error_by_code_util_1.HttpErrorByCode[response.data.err](response.data.msg);
+                return response.data.res;
+            }
+            if (response.config.serviceType == 2) {
+                if (response.data.status)
+                    throw new common_1.ServiceUnavailableException(response.data.message);
+                return response.data.data;
+            }
+            if (response.config.resolveBodyOnly != false) {
+                if (response.config.html != true)
+                    return response.data;
+                return new jsdom_1.JSDOM(response.data);
+            }
+            return response;
+        });
+        /* Call Custom Hook */
+        this.instance.interceptors.response.use(options.interceptorHooks?.respondInterceptor, options.interceptorHooks?.respondInterceptorCatch);
+        /* Handler Timeout */
+        this.instance.interceptors.response.use(async (response) => response, async (error) => {
+            if (error instanceof axios_1.AxiosError) {
+                if (!error.code)
+                    throw new exceptions_1.AxiosRetryableError(error.config);
+                switch (error.code) {
+                    case axios_1.AxiosError.ETIMEDOUT:
+                    case axios_1.AxiosError.ERR_NETWORK:
+                    case axios_1.AxiosError.ECONNABORTED:
+                        throw new exceptions_1.AxiosRetryableError(error.config);
+                }
+            }
+            throw error;
+        });
+        /* Auto Retry */
+        this.instance.interceptors.response.use(async (response) => response, async (error) => {
+            if (error instanceof exceptions_1.AxiosRetryableError) {
+                const retryCount = error.config.__origin__.retryCount++;
+                const retryLimit = error.config.__origin__.retryLimit;
+                if (retryCount < retryLimit)
+                    return this.instance.request(error.config.__origin__);
+                throw new exceptions_1.AxiosRetryLimitError(error.config);
+            }
+            else {
+                throw error;
+            }
+        });
+    }
+    async execute(options) {
+        return this.instance
+            .request(options);
+    }
+    async post(url, data) {
+        return this.instance
+            .request({ method: "POST", serviceType: 1, url, data });
+    }
+    async call(path, data) {
+        return this.instance
+            .request({ method: "POST", serviceType: 2, path, data });
+    }
+}
+exports.HttpRequest = HttpRequest;

package/dist/proxy/index.d.ts

@@ -0,0 +1,2 @@
+export { LiuGuanProxy } from './liuguan.proxy';
+export { Phone4GProxy } from './phone4g.proxy';

package/dist/proxy/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Phone4GProxy = exports.LiuGuanProxy = void 0;
+var liuguan_proxy_1 = require("./liuguan.proxy");
+Object.defineProperty(exports, "LiuGuanProxy", { enumerable: true, get: function () { return liuguan_proxy_1.LiuGuanProxy; } });
+var phone4g_proxy_1 = require("./phone4g.proxy");
+Object.defineProperty(exports, "Phone4GProxy", { enumerable: true, get: function () { return phone4g_proxy_1.Phone4GProxy; } });