feat: add doOriginalCall method

Author: huturen

src/common/utils.ts

@@ -75,13 +75,14 @@ export function isObject(obj: unknown) {
 export function tryToParseObject(body: unknown) {
   const isObjLiked = typeof body === 'string' && body[0] === '{' && body[body.length-1] === '}';
   const isArrLiked = typeof body === 'string' && body[0] === '[' && body[body.length-1] === ']';
-  if (isObjLiked || isArrLiked) {
-    try {
-      return JSON.parse(body);
-    } catch(e) {
-      return body;
-    }
-  } else {
+
+  if (!isObjLiked && !isArrLiked) {
+    return body;
+  }
+
+  try {
+    return JSON.parse(body);
+  } catch(e) {
     return body;
   }
 }

src/interceptor/base.ts

@@ -1,7 +1,7 @@
 import { getQuery, tryToParseObject } from '../common/utils';
 import MockItem from '../mocker/mock-item';
 import Mocker from '../mocker/mocker';
-import { HttpVerb, MixedRequestInfo, RequestInfo } from '../types';
+import { HttpVerb, RequestInfo } from '../types';
 import InterceptorFetch from './fetch';
 import InterceptorNode from './node/http-and-https';
 import InterceptorWxRequest from './wx-request';
@@ -67,17 +67,17 @@ export default class BaseInterceptor {
     return mockItem;
   }
 
-  public getRequestInfo(mixedRequestInfo: MixedRequestInfo) : RequestInfo {
+  public getRequestInfo(requestInfo: RequestInfo) : RequestInfo {
     const info: RequestInfo = {
-      url: mixedRequestInfo.url,
-      method: mixedRequestInfo.method || 'GET',
-      query: getQuery(mixedRequestInfo.url),
+      url: requestInfo.url,
+      method: requestInfo.method || 'GET',
+      query: getQuery(requestInfo.url),
     };
-    if (mixedRequestInfo.headers || mixedRequestInfo.header) {
-      info.headers = mixedRequestInfo.headers || mixedRequestInfo.header;
+    if (requestInfo.headers || requestInfo.header) {
+      info.headers = requestInfo.headers || requestInfo.header;
     }
-    if (mixedRequestInfo.body !== undefined) {
-      info.body = tryToParseObject(mixedRequestInfo.body);
+    if (requestInfo.body !== undefined) {
+      info.body = tryToParseObject(requestInfo.body);
     }
     return info;
   }

src/interceptor/fetch.ts

@@ -4,7 +4,7 @@ import { sleep, tryToParseJson } from '../common/utils';
 import { HTTPStatusCodes } from '../config';
 import MockItem from '../mocker/mock-item';
 import Mocker from '../mocker/mocker';
-import { FetchRequest, FetchResponse, HttpVerb, RemoteResponse, RequestInfo } from '../types';
+import { FetchRequest, FetchResponse, HttpVerb, OriginalResponse, RemoteResponse, RequestInfo } from '../types';
 import { AnyObject } from './../types';
 import Base from './base';
 
@@ -49,13 +49,20 @@ export default class FetchInterceptor extends Base{
       const requestUrl = me.getFullRequestUrl(url, method);
 
       return new Promise((resolve, reject) => {
-        const mockItem:MockItem | null  = me.matchMockRequest(requestUrl, method);
+        const mockItem:MockItem | null = me.matchMockRequest(requestUrl, method);
+
         if (!mockItem) {
           me.fetch(requestUrl, params).then(resolve).catch(reject);
           return;
         }
 
         const requestInfo = me.getRequestInfo({ ...params, url: requestUrl, method: method as HttpVerb });
+        requestInfo.doOriginalCall = async (): Promise<OriginalResponse> => {
+          const res = await me.getOriginalResponse(requestUrl, params);
+          requestInfo.doOriginalCall = undefined;
+          return res;
+        };
+
         const remoteInfo = mockItem?.getRemoteInfo(requestUrl);
         if (remoteInfo) {
           params.method = remoteInfo.method || method;
@@ -127,6 +134,29 @@ export default class FetchInterceptor extends Base{
     });
   }
 
+  private async getOriginalResponse(requestUrl: string, params: FetchRequest | AnyObject): Promise<OriginalResponse> {
+    let status = null;
+    const headers: Record<string, string | string[]> = {};
+    let responseText = null;
+    let responseJson = null;
+    let responseBuffer = null;
+    let responseBlob = null;
+    try {
+      const res = await this.fetch(requestUrl, params);
+      status = res.status;
+      if (typeof Headers === 'function' && res.headers instanceof Headers) {
+        res.headers.forEach((val: string, key: string) => (headers[key.toLocaleLowerCase()] = val));
+      }
+      responseBlob = await res.blob();
+      responseText = await responseBlob.text();
+      responseBuffer = await responseBlob.arrayBuffer();
+      responseJson = tryToParseJson(responseText);
+      return { status, headers, responseText, responseJson, responseBuffer, responseBlob, error: null };
+    } catch(err) {
+      return { status, headers, responseText, responseJson, responseBuffer, responseBlob, error: err as Error };
+    }
+  }
+
   /**
    * Make mock request.
    * @param {MockItem} mockItem

src/interceptor/xml-http-request.ts

@@ -4,6 +4,7 @@ import { HTTPStatusCodes } from '../config';
 import MockItem from '../mocker/mock-item';
 import Mocker from '../mocker/mocker';
 import { HttpVerb, RemoteResponse, XMLHttpRequestInstance } from '../types';
+import { OriginalResponse } from './../types';
 import Base from './base';
 
 export default class XMLHttpRequestInterceptor extends Base {
@@ -74,6 +75,12 @@ export default class XMLHttpRequestInterceptor extends Base {
               this.mockResponse = new NotResolved();
               this.requestInfo = me.getRequestInfo({ url: requestUrl, method, });
               this.requestArgs = [method, requestUrl, async, user, password];
+
+              this.requestInfo.doOriginalCall = async (): Promise<OriginalResponse> => {
+                const res = await me.getOriginalResponse(this);
+                this.requestInfo.doOriginalCall = undefined;
+                return res;
+              };
               return;
             }
           }
@@ -128,17 +135,20 @@ export default class XMLHttpRequestInterceptor extends Base {
    * @param {Record<string, string>} remoteInfo
    */
   private sendRemoteResult(xhr: XMLHttpRequestInstance, mockItem: MockItem, remoteInfo: Record<string, string>) {
-    const [ method, , async, user, password ] = xhr.requestArgs;
+    const [ method, async, user, password ] = xhr.requestArgs;
 
     const newXhr = new XMLHttpRequest();
+    newXhr.responseType = xhr.responseType;
+    newXhr.timeout = xhr.timeout;
+
     Object.assign(newXhr, { isMockRequest: false, bypassMock: true });
     newXhr.onreadystatechange = () => {
       if (newXhr.readyState === 4) {
         const remoteResponse: RemoteResponse = {
           status: newXhr.status,
           headers: newXhr.getAllResponseHeaders().split('\r\n').reduce((res: Record<string, string>, item: string) => {
             const [key, val] = item.split(':');
-            if (key) {
+            if (key && val) {
               res[key.toLowerCase()] = val.trim();
             }
             return res;
@@ -164,11 +174,83 @@ export default class XMLHttpRequestInterceptor extends Base {
     return xhr;
   }
 
+  private getOriginalResponse(xhr: XMLHttpRequestInstance): Promise<OriginalResponse> {
+    const [ method, requestUrl, async, user, password ] = xhr.requestArgs;
+    const { requestInfo } = xhr;
+
+    return new Promise(resolve => {
+      const newXhr = new XMLHttpRequest();
+      newXhr.responseType = xhr.responseType;
+      newXhr.timeout = xhr.timeout;
+
+      Object.assign(newXhr, { isMockRequest: false, bypassMock: true });
+      let status: OriginalResponse['status'] = null;
+      let headers: OriginalResponse['headers'] = {};
+      let responseText: OriginalResponse['responseText'] = null;
+      let responseJson: OriginalResponse['responseJson'] = null;
+      let responseBuffer: OriginalResponse['responseBuffer'] = null;
+      let responseBlob: OriginalResponse['responseBlob'] = null;
+
+      newXhr.onreadystatechange = function handleLoad() {
+        if (newXhr.readyState === 4) {
+          const responseType = newXhr.responseType;
+          status = newXhr.status;
+          headers = newXhr.getAllResponseHeaders()
+            .split('\r\n')
+            .reduce((res: Record<string, string>, item: string) => {
+              const [key, val] = item.split(':');
+              if (key && val) {
+                res[key.toLowerCase()] = val.trim();
+              }
+              return res;
+            }, {} as Record<string, string>);
+
+          responseText = !responseType || responseType === 'text' || responseType === 'json'
+            ? newXhr.responseText
+            : (typeof newXhr.response === 'string' ? typeof newXhr.response : null);
+
+          responseJson = tryToParseJson(responseText as string);
+          responseBuffer = (typeof ArrayBuffer === 'function') && (newXhr.response instanceof ArrayBuffer)
+            ? newXhr.response
+            : null;
+          responseBlob = (typeof Blob === 'function') && (newXhr.response instanceof Blob)
+            ? newXhr.response
+            : null;
+
+          resolve({ status, headers, responseText, responseJson, responseBuffer, responseBlob, error: null});
+        }
+      };
+      newXhr.open(method as string, requestUrl as string, async as boolean, user as string, password as string);
+      newXhr.ontimeout = function handleTimeout() {
+        const error = new Error('timeout exceeded');
+        resolve({ status, headers, responseText, responseJson, responseBuffer, responseBlob, error });
+      };
+
+      // Real errors are hidden from us by the browser
+      // onerror should only fire if it's a network error
+      newXhr.onerror = function handleError() {
+        const error = new Error('network error');
+        resolve({ status, headers, responseText, responseJson, responseBuffer, responseBlob, error });
+      };
+
+      // Handle browser request cancellation (as opposed to a manual cancellation)
+      newXhr.onabort = function handleAbort() {
+        const error = new Error('request aborted');
+        resolve({ status, headers, responseText, responseJson, responseBuffer, responseBlob, error });
+      };
+
+
+      Object.entries(requestInfo.headers || {}).forEach(([key, val]: [string, string]) => {
+        newXhr.setRequestHeader(key, val);
+      });
+      newXhr.send(requestInfo.rawBody as Document); // raw body
+    });
+  }
+
   /**
    * Make mock request.
    * @param {XMLHttpRequestInstance} xhr
-   * @param {MockItemInfo} mockItem
-   * @param {RequestInfo} requestInfo
+   * @param {RemoteResponse | null} remoteResponse
    */
   private async doMockRequest(xhr: XMLHttpRequestInstance, remoteResponse: RemoteResponse | null = null) {
     let isBypassed = false;
@@ -185,8 +267,7 @@ export default class XMLHttpRequestInterceptor extends Base {
   /**
    * Make mock response.
    * @param {XMLHttpRequestInstance} xhr
-   * @param {MockItemInfo} mockItem
-   * @param {RequestInfo} requestInfo
+   * @param {RemoteResponse | null} remoteResponse
    */
   private async doMockResponse(xhr: XMLHttpRequestInstance, remoteResponse: RemoteResponse | null = null) {
     const { mockItem, requestInfo } = xhr;
@@ -326,7 +407,9 @@ export default class XMLHttpRequestInterceptor extends Base {
         return (header: string, value: string) => {
           if (this.isMockRequest) {
             this.requestInfo.headers = this.requestInfo.headers || {};
+            this.requestInfo.header = this.requestInfo.header || {};
             this.requestInfo.headers[header] = value;
+            this.requestInfo.header[header] = value;
             return;
           }
           return original.call(this, header, value);

src/mocker/mock-item.ts

@@ -20,6 +20,8 @@ export default class MockItem {
   public times: number;
   public key: string;
   public deProxy = false; // Use this option to make the mock use case run in the browser instead of nodejs.
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  public doOriginalRequest: Function;
 
   /**
    * Format specified mock item.

src/types.ts

@@ -65,10 +65,25 @@ export interface MockConfigData {
 export interface RequestInfo {
   url: string;
   method: HttpVerb;
-  query: object; // url search query
+  query?: object; // url search query
   headers?: object; // request header
+  header?: object; // request header
   body?: unknown; // post body
   rawBody?: unknown; // post body
+  doOriginalCall?: () => Promise<OriginalResponse>; // can only be called once
+}
+
+export interface OriginalResponse {
+  // if the original call is returned successfully, the following fields will be populated
+  status: number | null; // http response status
+  headers: Record<string, string | string[]>; // response headers
+  responseText: string | null;
+  responseJson: unknown | null;
+  responseBuffer: ArrayBuffer | null;
+  responseBlob: Blob | null;
+
+  // if the original call throws an exception, the error field will be populated
+  error: Error | null;
 }
 
 export interface RemoteResponse {
@@ -79,15 +94,6 @@ export interface RemoteResponse {
   responseJson: AnyObject;
 }
 
-export interface MixedRequestInfo {
-  url: string;
-  method: HttpVerb;
-  query?: object; // url search query
-  headers?: object; // request header
-  header?: object; // request header
-  body?: unknown; // post body
-}
-
 export interface XMLHttpRequestInstance extends XMLHttpRequest {
   bypassMock: boolean;
   isMockRequest: string;