feat: add doOriginalCall method for nodejs request modules

Author: huturen

experiment/try-get.js

@@ -0,0 +1,20 @@
+
+const https = require('https');
+
+const request = (url) => new Promise(resolve => {
+  let buffer = '';
+  https.get(url, (res) => {
+    res.on('data', chunk => (buffer += chunk));
+    res.on('end', () => resolve(buffer));
+  }).on('error', (e) => {
+    console.log('https.get error:', '[', e, ']');
+    resolve(e.message);
+  });
+});
+
+const main = async () => {
+  const res = await request('https://jsonplaceholder.typicode.com/todos/1');
+  console.log('res:', res);
+};
+
+main();

experiment/try-request.js

@@ -0,0 +1,39 @@
+
+const https = require('https');
+
+const request = (url, callback) => new Promise(resolve => {
+  let buffer = '';
+  const options = {};
+  const req = https
+    .request(url, options, async res => {
+
+      // log the data
+      res.on('data', d => {
+        buffer += d;
+      });
+      res.on('end', () => {
+        resolve(buffer);
+        console.log('end: ', buffer);
+      });
+      await callback(res);
+    })
+    .on('error', err => {
+      console.log('Error: ' + err.message);
+    });
+  req.end();
+});
+
+const main = async () => {
+  let buffer = '';
+  const data = await request('https://jsonplaceholder.typicode.com/todos/1', async res => {
+    res.on('data', d => {
+      buffer += d;
+    });
+    res.on('end', () => {
+      console.log('end2: ', buffer);
+    });
+  });
+  console.log('res:', data);
+};
+
+main();

src/common/request.ts

@@ -1,10 +1,10 @@
+import { http, https } from 'follow-redirects';
 import { IncomingMessage } from 'http';
+import Stream from 'stream';
 import { URL } from 'url';
 import * as zlib from 'zlib';
-import { AnyObject } from './../types';
-import { tryToParseJson } from './utils';
-import Stream from 'stream';
-import { http, https } from 'follow-redirects';
+import { AnyObject, OriginalResponse } from './../types';
+import { str2arrayBuffer, tryToParseJson } from './utils';
 
 /**
  * In nodejs environment, by default for XMLHttpRequest, fetch and wx.request, http-request-mock
@@ -74,7 +74,20 @@ function isHttpsUrl(url: string | URL) {
   return false;
 }
 
-function getResponseBody(response: IncomingMessage): Promise<{ body: string, json: AnyObject }> {
+async function getResponseBody(response: IncomingMessage): Promise<{ body: string, json: AnyObject }> {
+  try {
+    const data = await parseResponseBody(response);
+    if (data.error) {
+      throw data.error;
+    }
+
+    return { body: data.responseText as string, json: data.responseJson as AnyObject };
+  } catch(err) {
+    throw new Error(`getResponseBody error: ${(err as Error).message}`);
+  }
+}
+
+export function parseResponseBody(response: IncomingMessage): Promise<OriginalResponse> {
   let stream: Stream;
   if (['gzip', 'compress', 'deflate'].includes(response.headers['content-encoding'] || '')) {
     stream = response.pipe(zlib.createGunzip());
@@ -84,18 +97,38 @@ function getResponseBody(response: IncomingMessage): Promise<{ body: string, jso
     stream = response;
   }
 
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => {
     stream.once('error', (error) => {
       stream.removeAllListeners();
-      reject(error);
+      resolve({
+        status: null,
+        headers: {},
+        responseText: null,
+        responseJson: null,
+        responseBuffer: null,
+        responseBlob: null,
+        error,
+      });
     });
 
     const buf: Buffer[] = [];
     stream.on('data', chunk => buf.push(chunk));
 
     stream.once('end', () => {
-      const body = Buffer.concat(buf).toString();
-      resolve({ body, json: tryToParseJson(body, null) });
+      const type = (response.headers['content-type'] || '').replace(/^application\//, '').replace(/;.*/, '');
+      const responseText = Buffer.concat(buf).toString();
+      const responseJson = tryToParseJson(responseText, null);
+      const responseBuffer = str2arrayBuffer(responseText);
+      const responseBlob = typeof Blob === 'function' ? new Blob([responseText], { type }) : null;
+      resolve({
+        status: response.statusCode || null,
+        headers: response.headers,
+        responseText,
+        responseJson,
+        responseBuffer,
+        responseBlob,
+        error: null,
+      } as OriginalResponse);
       stream.removeAllListeners();
     });
   });

src/common/utils.ts

@@ -116,12 +116,16 @@ export function str2arrayBuffer(str: string) {
     return new TextEncoder().encode(str);
   }
 
-  const buf = new ArrayBuffer(str.length*2); // 2 bytes for each char
-  const bufView = new Uint16Array(buf);
-  for (let i=0, strLen=str.length; i<strLen; i++) {
-    bufView[i] = str.charCodeAt(i);
+  if (typeof ArrayBuffer === 'function') {
+    const buf = new ArrayBuffer(str.length*2); // 2 bytes for each char
+    const bufView = new Uint16Array(buf);
+    for (let i=0, strLen=str.length; i<strLen; i++) {
+      bufView[i] = str.charCodeAt(i);
+    }
+    return buf;
   }
-  return buf;
+
+  return null;
 }
 
 /**

src/interceptor/node/client-request.ts

@@ -1,14 +1,15 @@
+import { IncomingMessage } from 'http';
 /* eslint-disable @typescript-eslint/ban-types */
 import http from 'http';
 import { Socket } from 'net';
 import { inherits } from 'util';
 import Bypass from '../../common/bypass';
-import simpleRequest from '../../common/request';
+import simpleRequest, { parseResponseBody } from '../../common/request';
 import { getQuery } from '../../common/utils';
 import { HTTPStatusCodes } from '../../config';
 import MockItem from '../../mocker/mock-item';
 import Mocker from '../../mocker/mocker';
-import { ClientRequestOptions, ClientRequestType, RequestInfo } from '../../types';
+import { ClientRequestOptions, ClientRequestType, OriginalResponse, RequestInfo } from '../../types';
 import { RemoteResponse } from './../../types';
 
 /**
@@ -93,7 +94,12 @@ function ClientRequest(
     return this;
   };
 
-  this.setOriginalRequestInfo = (nativeReqestMethod: Function, nativeRequestArgs: unknown[]) => {
+  this.setOriginalRequestInfo = (
+    getOrRequest: 'get' | 'request',
+    nativeReqestMethod: Function,
+    nativeRequestArgs: unknown[]
+  ) => {
+    this.nativeReqestName = getOrRequest; // get or request
     this.nativeReqestMethod = nativeReqestMethod;
     this.nativeRequestArgs = nativeRequestArgs;
   };
@@ -205,6 +211,12 @@ function ClientRequest(
         body: method === 'GET' ? undefined : this.bufferToString(this.requestBody)
       };
 
+      requestInfo.doOriginalCall = async (): Promise<OriginalResponse> => {
+        const res = await this.getOriginalResponse();
+        requestInfo.doOriginalCall = undefined;
+        return res;
+      };
+
       let remoteResponse: RemoteResponse | null = null;
       const remoteInfo = mockItem?.getRemoteInfo(url);
       if (remoteInfo) {
@@ -310,6 +322,46 @@ function ClientRequest(
     return this.nativeInstance;
   };
 
+  this.getOriginalResponse = (): Promise<OriginalResponse> => {
+    const callback = this.nativeRequestArgs[this.nativeRequestArgs.length - 1];
+
+    const defaultResponse = {
+      status: null,
+      headers: {},
+      responseText: null,
+      responseJson: null,
+      responseBuffer: null,
+      responseBlob: null,
+      error: null,
+    };
+    return new Promise((resolve) => {
+      const newCallback = (res: IncomingMessage) => {
+        parseResponseBody(res).then(data => {
+          resolve(data);
+        }).catch(err => {
+          resolve({ ...defaultResponse, error: err });
+        });
+        if (typeof callback === 'function') {
+          callback(res);
+        }
+      };
+      const callbackIndex = typeof callback === 'function'
+        ? this.nativeRequestArgs.length - 1
+        : this.nativeRequestArgs.length;
+
+      this.nativeRequestArgs[callbackIndex] = newCallback;
+
+      // do original call
+      const req = this.nativeReqestMethod(...this.nativeRequestArgs);
+      req.on('error', (err: Error) => {
+        resolve({ ...defaultResponse, error: err });
+      });
+      if (this.nativeReqestName = 'get') {
+        req.end();
+      }
+    });
+  };
+
   /**
    * https://nodejs.org/api/http.html#http_request_end_data_encodingcallback
    *

src/interceptor/node/http-and-https.ts

@@ -107,7 +107,7 @@ export default class NodeHttpAndHttpsRequestInterceptor extends Base{
     }
 
     const client = result as ClientRequestType;
-    client.setOriginalRequestInfo(getOrRequestFunc, args);
+    client.setOriginalRequestInfo(getOrRequest, getOrRequestFunc, args);
     getOrRequest === 'get' && client.end();
     return result;
   }
@@ -130,6 +130,10 @@ export default class NodeHttpAndHttpsRequestInterceptor extends Base{
     const mockItem:MockItem | null  = this.matchMockRequest(url, method);
     if (!mockItem) return false;
 
+    //
+    //
+    //s
+
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     const clientRequest: ClientRequestType = new ClientRequest(url, options, callback);

src/types.ts

@@ -139,6 +139,7 @@ export interface WxResponse {
 
 export interface ClientRequestType extends http.ClientRequest{
   nativeInstance: null | http.ClientRequest;
+  nativeReqestName: 'get' | 'request';
   nativeReqestMethod: Function;
   nativeRequestArgs: unknown[];
 
@@ -163,6 +164,7 @@ export interface ClientRequestType extends http.ClientRequest{
   getRequestHeaders: Function;
   bufferToString: Function;
   fallbackToNativeRequest: Function;
+  getOriginalResponse: Function;
 }
 
 export interface NodeRequestOpts {