@ekhein/http-request 1.0.21 → 1.0.22

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@ekhein/http-request",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "license": "MIT",
   "author": "ekhein",
   "main": "./dist/index.js",
   "types": "./types/index.d.ts",
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "build": "tsc"
   },

package/src/agent/index.ts

@@ -0,0 +1,11 @@
+import { CookieAgentOptions, createCookieAgent, HttpCookieAgent, HttpsCookieAgent } from 'http-cookie-agent/http';
+import { LiuGuanProxy, Phone4GProxy } from '../proxy'
+
+export const HttpCookieWithPhone4GProxyAgent  = createCookieAgent<Phone4GProxy, [ConstructorParameters<typeof Phone4GProxy>[0], CookieAgentOptions]>(Phone4GProxy)
+export const HttpsCookieWithPhone4GProxyAgent = createCookieAgent<Phone4GProxy, [ConstructorParameters<typeof Phone4GProxy>[0], CookieAgentOptions]>(Phone4GProxy)
+export const HttpCookieWithLiuGuanProxyAgent  = createCookieAgent<LiuGuanProxy, [ConstructorParameters<typeof LiuGuanProxy>[0], CookieAgentOptions]>(LiuGuanProxy)
+export const HttpsCookieWithLiuGuanProxyAgent = createCookieAgent<LiuGuanProxy, [ConstructorParameters<typeof LiuGuanProxy>[0], CookieAgentOptions]>(LiuGuanProxy)
+export {
+  HttpCookieAgent,
+  HttpsCookieAgent
+}

package/src/exceptions/attempt.exception.ts

@@ -0,0 +1,13 @@
+import { AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import { HttpRequestException } from './request.exception';
+
+export class HttpRequestAttemptException extends HttpRequestException {
+  constructor(
+    message: string,
+    config?: InternalAxiosRequestConfig,
+    request?: any,
+    response?: AxiosResponse
+  ) {
+    super(message, "ERR_REQ_ATTEMPT", config, request, response)
+  }
+}

package/src/exceptions/index.ts

@@ -0,0 +1,3 @@
+
+export { HttpRequestAttemptException } from './attempt.exception';
+export { HttpRequestException } from './request.exception';

package/src/exceptions/request.exception.ts

@@ -0,0 +1,2 @@
+
+export { AxiosError as HttpRequestException } from 'axios'

package/src/headers/index.ts

@@ -0,0 +1,2 @@
+
+export { HttpRequestHeaders } from './request.headers'

package/src/headers/request.headers.ts

@@ -0,0 +1,2 @@
+
+export { AxiosHeaders as HttpRequestHeaders } from 'axios'

package/src/http-request.ts

@@ -0,0 +1,228 @@
+import axios, { AxiosInstance } from 'axios';
+import tldts from 'tldts';
+import * as cookie from 'cookie';
+import { JSDOM } from 'jsdom';
+import { Cookie, CookieJar } from 'tough-cookie';
+import { ServiceUnavailableException } from '@nestjs/common';
+import { Attempt } from '@ekhein/async-retry-decorator';
+import { ErrorHttpStatusCode, HttpErrorByCode } from '@nestjs/common/utils/http-error-by-code.util';
+import { FormData } from './libs';
+import { HttpRequestHeaders } from './headers';
+import { HttpRequestException, HttpRequestAttemptException } from './exceptions';
+import { HttpCookieAgent, HttpsCookieAgent } from './agent';
+import { HttpCookieWithPhone4GProxyAgent, HttpsCookieWithPhone4GProxyAgent } from './agent';
+import { HttpCookieWithLiuGuanProxyAgent, HttpsCookieWithLiuGuanProxyAgent } from './agent';
+import { HttpRequestConfig } from '../types';
+
+export class HttpRequest {
+
+  public readonly instance: AxiosInstance
+
+  constructor(
+    options: HttpRequestConfig = {}
+  ) {
+    /* Axios */
+    this.instance = axios.create({
+      ...Object.assign({
+        ["timeout"]: 30e3,
+        ["headers"]: {},
+        ["proxy"]: false,
+      }, options)
+    })
+    
+    /* 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 HttpCookieWithLiuGuanProxyAgent({}, {cookies})
+            request.httpsAgent = new HttpsCookieWithLiuGuanProxyAgent({}, {cookies})
+          }
+          if (typeof request.useProxy === "object") {
+            if ("clientIp" in request.useProxy) {
+              request.httpAgent  = new HttpCookieWithPhone4GProxyAgent(request.useProxy, {cookies})
+              request.httpsAgent = new HttpsCookieWithPhone4GProxyAgent(request.useProxy, {cookies})
+            } else {
+              request.httpAgent  = new HttpCookieWithLiuGuanProxyAgent(request.useProxy, {cookies})
+              request.httpsAgent = new HttpsCookieWithLiuGuanProxyAgent(request.useProxy, {cookies})
+            }
+          }
+        } else {
+          request.httpAgent  = new HttpCookieAgent({cookies})
+          request.httpsAgent = new 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 parsed  = tldts.parse(api.href)
+          const cookies = cookie.parse(request.headers.cookie)
+          const domain1 = String(parsed.domain ?? parsed.hostname) /* 顶级域名 */
+          const website = Array(api.protocol, domain1).join("//")
+          const entries = Object.entries(cookies)
+          for (const [key, value] of entries) {
+            const cookie = new Cookie({...parsed, key, value})
+            await request.jar!.setCookie(cookie, website)
+          }
+        }
+        
+        return request
+      }
+    )
+    /* Cookie Jar */
+    this.instance.interceptors.request.use(
+      async request => {
+        if (!request.jar)
+          request.jar = new CookieJar()
+        return request
+      }
+    )
+    /* Headers */
+    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
+      }
+    )
+    /* Body */
+    this.instance.interceptors.request.use(
+      async request => {
+        if (request.body) {
+          request.headers.setContentType("application/json")
+          request.data = request.body
+        }
+        if (request.form) {
+          if (request.form instanceof FormData) {
+            request.data = request.form
+          } else {
+            request.headers.setContentType("application/x-www-form-urlencoded")
+            request.data = request.form
+          }
+        }
+        
+        return request
+      }
+    )
+    /* BaseURL */
+    this.instance.interceptors.request.use(
+      async request => {
+        if (request.baseURL) return request
+        if (request.serviceType == 1)
+          request.baseURL = process.env.CORE_URL
+        if (request.serviceType == 2)
+          request.baseURL = process.env.SEKIRO_URL
+        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
+      }
+    )
+    /* Request Hook */
+    this.instance.interceptors.request.use(
+      options.interceptorHooks?.requestInterceptor,
+      options.interceptorHooks?.requestInterceptorCatch
+    )
+    
+    /* Response Hook */
+    this.instance.interceptors.response.use(
+      options.interceptorHooks?.respondInterceptor,
+      options.interceptorHooks?.respondInterceptorCatch,
+    )
+    /* Transform */
+    this.instance.interceptors.response.use(
+      async response => {
+        if (typeof response.headers == "object") {
+          if (response.headers instanceof HttpRequestHeaders) {
+            if (response.config.serviceType == 1) {
+              if (HttpErrorByCode[response.data.err as ErrorHttpStatusCode])
+                throw new HttpErrorByCode[response.data.err as ErrorHttpStatusCode](response.data.msg)
+              return response.data.res
+            }
+            if (response.config.serviceType == 2) {
+              if (response.data.status)
+                throw new ServiceUnavailableException(response.data.message)
+              return response.data.data
+            }
+            if (response.config.html) {
+              return new JSDOM(response.data)
+            }
+            if (response.config.resolveBodyOnly != false) {
+              return response.data
+            }
+          }
+        }
+
+        return response
+      }
+    )
+  }
+
+  @Attempt({
+    retries: 2,
+    ignore: [Error],
+    onError(error) {
+      if (error instanceof HttpRequestAttemptException) throw error
+      if (error instanceof HttpRequestException) {
+        switch(error.code) {
+          case HttpRequestException.ETIMEDOUT:
+          case HttpRequestException.ERR_NETWORK:
+          case HttpRequestException.ECONNABORTED: throw error
+        }
+      }
+    },
+  })
+  public async execute<R = any>(
+    options: HttpRequestConfig
+  ) {
+    return this.instance
+      .request<never, R>(options)
+  }
+
+  public async post<R = any>(
+    url: string,
+    data?: any,
+    opts: HttpRequestConfig = {}
+  ) {
+    return this.instance
+      .request<never, R>({...opts, method: "POST", serviceType: 1, data, url})
+  }
+
+  public async invoke<R = any>(
+    path: string,
+    data: object,
+    opts: HttpRequestConfig = {}
+  ) {
+    return this.instance
+      .request<never, R>({...opts, method: "POST", serviceType: 2, data, path})
+  }
+
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+
+export * from './exceptions';
+export * from './libs';
+export * from './headers';
+export * from './http-request';

package/src/libs/form-data.ts

@@ -0,0 +1,2 @@
+
+export { default as FormData } from 'form-data';

package/src/libs/index.ts

@@ -0,0 +1,2 @@
+
+export { FormData } from './form-data';

package/src/proxy/index.ts

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