update package request -> axios

Author: bjrmatos

lib/client.js

@@ -5,7 +5,7 @@
  * able to render reports or do crud using jaydata context.
  */
 
-const request = require('request')
+const axios = require('axios')
 const url = require('url')
 const concat = require('concat-stream')
 const mimicResponse = require('mimic-response')
@@ -28,12 +28,13 @@ class Client {
     const password = this.password
 
     const optionsToUse = Object.assign({
-      uri: url.resolve(rootUrl, 'api/report'),
-      body: JSON.stringify(req),
-      strictSSL: false,
+      method: 'post',
+      url: url.resolve(rootUrl, 'api/report'),
+      data: JSON.stringify(req),
       headers: {
         'Content-Type': 'application/json'
-      }
+      },
+      responseType: 'stream'
     }, options)
 
     if (username) {
@@ -43,10 +44,14 @@ class Client {
       }
     }
 
-    return new Promise((resolve, reject) => {
-      const responseStream = request.post(optionsToUse)
+    let response
 
-      responseStream.on('error', (err) => {
+    try {
+      response = await axios(optionsToUse)
+    } catch (err) {
+      if (err.response) {
+        response = err.response
+      } else {
         const error = new Error('Error while executing request to remote server')
 
         addStack(error, err.stack, {
@@ -55,58 +60,57 @@ class Client {
 
         error.message = `${error.message}. ${err.message}`
 
-        reject(err)
-      })
+        throw error
+      }
+    }
 
-      responseStream.on('response', (response) => {
-        if (response.statusCode !== 200) {
-          return responseToBuffer(response, (err, data) => {
-            if (err) {
-              return reject(err)
-            }
-
-            try {
-              const errorMessage = JSON.parse(data.toString())
-              const error = new Error(errorMessage.message)
-
-              addStack(error, errorMessage.stack, {
-                stripMessage: true,
-                stackPrefix: 'Remote stack: '
-              })
-
-              error.remoteStack = errorMessage.stack
-              reject(error)
-            } catch (e) {
-              const err = new Error(`Error while executing request to remote server: Unknown error, status code ${response.statusCode}`)
-
-              addStack(err, e.stack, {
-                stackPrefix: 'Parsing Error stack: '
-              })
-
-              err.response = response
-              reject(err)
-            }
-          })
-        }
+    const responseStream = response.data
 
-        // when working with streams and promises we should be extra-careful,
-        // promises resolves in next ticks so there is a chance that a stream
-        // can loose some data because consumer does not took the chance to process
-        // the data when it was ready.
-        // to solve this we create a transform stream that starts paused (any stream starts paused)
-        // and flow the data from response to it, since the stream is paused it won't loose data
-        // and will start emiting it when consumer calls `.body()` or any other stream method like `.pipe`
-        const newResponseStream = new PassThrough()
+    let bodyData
 
-        mimicResponse(response, newResponseStream)
+    if (response.status !== 200) {
+      bodyData = await responseToBuffer(responseStream)
+      let error
 
-        newResponseStream.body = () => responseToBuffer(newResponseStream)
+      try {
+        const errorMessage = JSON.parse(bodyData.toString())
+        error = new Error(errorMessage.message)
 
-        response.pipe(newResponseStream)
+        addStack(error, errorMessage.stack, {
+          stripMessage: true,
+          stackPrefix: 'Remote stack: '
+        })
 
-        resolve(newResponseStream)
-      })
-    })
+        error.remoteStack = errorMessage.stack
+      } catch (e) {
+        error = new Error(`Error while executing request to remote server: Unknown error, status code ${response.status}`)
+
+        addStack(error, e.stack, {
+          stackPrefix: 'Parsing Error stack: '
+        })
+
+        error.response = response
+      }
+
+      throw error
+    }
+
+    // when working with streams and promises we should be extra-careful,
+    // promises resolves in next ticks so there is a chance that a stream
+    // can loose some data because consumer does not took the chance to process
+    // the data when it was ready.
+    // to solve this we create a transform stream that starts paused (any stream starts paused)
+    // and flow the data from response to it, since the stream is paused it won't loose data
+    // and will start emiting it when consumer calls `.body()` or any other stream method like `.pipe`
+    const newResponseStream = new PassThrough()
+
+    mimicResponse(responseStream, newResponseStream)
+
+    newResponseStream.body = () => responseToBuffer(newResponseStream)
+
+    responseStream.pipe(newResponseStream)
+
+    return newResponseStream
   }
 }