@superhero/http-request 4.0.10 → 4.1.1

package/README.md

@@ -95,11 +95,12 @@ console.log(response.body)
 
 Errors are thrown with specific error codes for easier handling:
 
-- `E_HTTP_REQUEST_CLIENT_ERROR`
-- `E_HTTP_REQUEST_CLIENT_TIMEOUT`
-- `E_HTTP_REQUEST_DOWNSTREAM_ERROR`
-- `E_HTTP_REQUEST_INVALID_RESPONSE_BODY_FORMAT`
-- `E_HTTP_REQUEST_INVALID_RESPONSE_STATUS`
+- `E_HTTP_REQUEST_FAILED`
+  - `E_HTTP_REQUEST_CLIENT_ERROR`
+  - `E_HTTP_REQUEST_CLIENT_TIMEOUT`
+  - `E_HTTP_REQUEST_DOWNSTREAM_ERROR`
+  - `E_HTTP_REQUEST_INVALID_RESPONSE_BODY_FORMAT`
+  - `E_HTTP_REQUEST_INVALID_RESPONSE_STATUS`
 
 Example:
 
@@ -334,10 +335,10 @@ pass 42
 ----------------------------------------------------------------------------------------
 file            | line % | branch % | funcs % | uncovered lines
 ----------------------------------------------------------------------------------------
-index.js        |  94.05 |    91.74 |   92.86 | 496-505 533-535 671-677 702-705 735-755
+index.js        |  89.56 |    87.39 |   86.67 | 100-104 137-139 150-153 353-357 361-365
 index.test.js   | 100.00 |    97.67 |  100.00 | 
 ----------------------------------------------------------------------------------------
-all files       |  96.57 |    94.36 |   97.17 | 
+all files       |  93.73 |    91.71 |   94.50 |
 ----------------------------------------------------------------------------------------
 ```
 

package/index.js

@@ -68,8 +68,8 @@ export default class Request
   /**
    * Connects to a HTTP/2 server.
    * 
-   * @param {String} authority the URL
-   * @param {Object} [options]
+   * @param {String|Object} [authority] the URL to connect to the server, or the options object
+   * @param {Object} [options] @see node:http2.connect options
    * 
    * @throws {Error} E_HTTP_REQUEST_CONNECT_INVALID_ARGUMENT
    * 
@@ -77,31 +77,28 @@ export default class Request
    */
   connect(authority, options)
   {
-    return new Promise(async (accept, reject) =>
+    return new Promise(async resolve =>
     {
       await this.close()
 
-      const url = new URL(authority || this.config.base)
-      authority = url.protocol + '//' + url.host
-      options   = Object.assign(this.config, options)
+      if('object' === typeof authority 
+      && null     !== authority
+      && false    === !!options)
+      {
+        options   = authority
+        authority = null
+      }
+
+      options = Object.assign(this.config, options)
+      const url = new URL(authority || options.authority || options.base || options.url)
 
-      this.config.base  = authority
-      this.config.url   = url.pathname + url.search
-      this.http2Session = http2.connect(authority, options, () => 
+      this.config.authority = url.origin
+      this.http2Session     = http2.connect(url.origin, options, () => 
       {
         this.http2Session.removeAllListeners('error')
         this.http2Session.on('error', console.error)
 
-        accept()
-      })
-
-      // If there is a error on connection, reject the promise.
-      this.http2Session.once('error', (reason) =>
-      {
-        const error = new Error(`Failed to connect to server over HTTP2 using authority: ${authority}`)
-        error.code  = 'E_HTTP_REQUEST_CONNECT_ERROR'
-        error.cause = reason
-        reject(error)
+        resolve()
       })
     })
   }
@@ -113,7 +110,7 @@ export default class Request
    */
   close()
   {
-    return new Promise((accept, reject) =>
+    return new Promise((resolve, reject) =>
     {
       const http2Session = this.http2Session
 
@@ -129,7 +126,7 @@ export default class Request
 
             error
             ? reject(error)
-            : accept()
+            : resolve()
           })
 
           return // await the close event
@@ -138,8 +135,8 @@ export default class Request
         delete this.http2Session
       }
 
-      // fallback to accept if nothing to close
-      accept()
+      // fallback to resolve if nothing to close
+      resolve()
     })
   }
 
@@ -275,20 +272,13 @@ export default class Request
    * @throws {Error} E_HTTP_REQUEST_RETRY_HTTP2_RECONNECT
    * @throws {Error} E_HTTP_REQUEST_RETRY_ERROR
    */
-  #fetch(method, options)
+  async #fetch(method, options)
   {
     if(typeof options === 'string')
     {
       options = { url:options }
     }
 
-    if(this.config.url && options.url)
-    {
-      options.url = options.url[0] === '/' 
-                  ? options.url
-                  : this.config.url + options.url
-    }
-
     options = Object.assign(
     {
       method,
@@ -300,9 +290,19 @@ export default class Request
       retryOnStatus : []
     }, this.config, options)
 
-    return options.retry
-    ? this.#resolveRetryLoop(options)
-    : this.#resolve(options)
+    try
+    {
+      return options.retry
+      ? await this.#resolveRetryLoop(options)
+      : await this.#resolve(options)
+    }
+    catch(reason)
+    {
+      const error = new Error(`Failed request ${method} ${options.url}`)
+      error.code  = 'E_HTTP_REQUEST_FAILED'
+      error.cause = reason
+      throw error
+    }
   }
 
   /**
@@ -315,20 +315,20 @@ export default class Request
    */
   #resolve(options)
   {
-    return new Promise((accept, reject) =>
+    return new Promise((resolve, reject) =>
     {
       const
         method    = options.method,
         headers   = this.#normalizeHeaders(options.headers),
         body      = this.#normalizeBody(options.body ?? options.data, headers['content-type']),
         delimiter = this.#createBodyHeaderDelimiter(body, !!options.upstream || !!this.http2Session),
-        url       = this.#normalizeUrl(options.url, options.base)
+        url       = this.#normalizeUrl(options.authority, options.base, options.url)
 
       Object.assign(headers, delimiter)
 
       const upstream = this.http2Session
-      ? this.#resolveHttp2Client(options, method, headers, url, accept, reject)
-      : this.#resolveHttp1Client(options, method, headers, url, accept, reject)
+      ? this.#resolveHttp2Client(options, method, headers, url, resolve, reject)
+      : this.#resolveHttp1Client(options, method, headers, url, resolve, reject)
 
       options.upstream
       ? options.upstream.pipe(upstream)
@@ -336,7 +336,7 @@ export default class Request
     })
   }
 
-  #resolveHttp2Client(options, method, headers, url, accept, reject)
+  #resolveHttp2Client(options, method, headers, url, resolve, reject)
   {
     if(true === this.http2Session.destroyed)
     {
@@ -384,13 +384,13 @@ export default class Request
       delete upstream.headers[HEADER_STATUS]
       Object.defineProperty(upstream.headers, SENSITIVE_HEADERS, { enumerable:false, value:headers[SENSITIVE_HEADERS] })
 
-      this.#resolveOnResponse(options, method, url, accept, reject, upstream)
+      this.#resolveOnResponse(options, method, url, resolve, reject, upstream)
     })
 
     return upstream
   }
 
-  #resolveHttp1Client(options, method, headers, url, accept, reject)
+  #resolveHttp1Client(options, method, headers, url, resolve, reject)
   {
     const
       request   = url.startsWith('https:') ? https.request : http.request,
@@ -400,7 +400,7 @@ export default class Request
     upstream.on('close',    this.#connectionClosed      .bind(this, upstream, reject))
     upstream.on('error',    this.#resolveOnClientError  .bind(this, method, url, reject))
     upstream.on('timeout',  this.#resolveOnClientTimeout.bind(this, upstream, options.timeout, method, url, reject))
-    upstream.on('response', this.#resolveOnResponse     .bind(this, options, method, url, accept, reject))
+    upstream.on('response', this.#resolveOnResponse     .bind(this, options, method, url, resolve, reject))
 
     return upstream
   }
@@ -419,13 +419,13 @@ export default class Request
    * @param {RequestOptions} options
    * @param {String} method
    * @param {String} url
-   * @param {Function} accept Promise accept
+   * @param {Function} resolve Promise resolve
    * @param {Function} reject Promise reject
    * @param {http.IncomingMessage} readable
    * 
    * @returns {Void}
    */
-  #resolveOnResponse(options, method, url, accept, reject, readable)
+  #resolveOnResponse(options, method, url, resolve, reject, readable)
   {
     const response =
     {
@@ -448,11 +448,11 @@ export default class Request
     {
       readable.pipe(options.downstream)
       readable.resume()
-      accept(response)
+      resolve(response)
     }
     else
     {
-      this.#bufferResponseBody(readable, response, method, url, accept, reject)
+      this.#bufferResponseBody(readable, response, method, url, resolve, reject)
     }
   }
 
@@ -463,7 +463,7 @@ export default class Request
    */
   async #resolveRetryLoop(options)
   {
-    const errorTrace = []
+    const reasons = []
 
     let retry = Math.abs(Math.floor(options.retry))
 
@@ -485,49 +485,48 @@ export default class Request
           return response
         }
       }
-      catch(error)
+      catch(reason)
       {
-        if(retry === 0)
+        if(retry <= 0)
         {
-          throw error
+          reasons.push(reason)
         }
         else
         {
-          await this.#resolveRetryLoopError(options, errorTrace, error)
+          await this.#resolveRetryLoopError(options, reasons, reason)
           await wait(options.retryDelay)
         }
       }
     }
 
-    if(errorTrace.every((error) => error.code === errorTrace[0].code))
-    {
-      throw errorTrace.pop()
-    }
-    else
+    const
+      unique = reasons.filter((reason, i) => [i, -1].includes(reasons.map(e => e.code).lastIndexOf(code => code === reason.code))),
+      reason = unique.pop()
+
+    if(unique.length)
     {
-      const error = new Error('Multiple types of errors occurred during the retry loop')
-      error.code  = 'E_HTTP_REQUEST_RETRY_ERROR'
-      error.cause = errorTrace
-      throw error
+      reason.retried = unique
     }
+
+    throw reason
   }
 
   /**
    * Resolves the error in the retry loop.
    * 
    * @param {RequestOptions}  options
-   * @param {Error[]}         errorTrace
-   * @param {Error}           error
+   * @param {Error[]}         reasons
+   * @param {Error}           reason
    * 
    * @returns {Void}
    */
-  async #resolveRetryLoopError(options, errorTrace, error)
+  async #resolveRetryLoopError(options, reasons, reason)
   {
-    switch(error.code)
+    switch(reason.code)
     {
       case 'E_HTTP_REQUEST_CLIENT_ERROR':
       {
-        return errorTrace.push(error)
+        return reasons.push(reason)
       }
       case 'E_HTTP_REQUEST_HTTP2_SESSION_DESTROYED':
       case 'E_HTTP_REQUEST_HTTP2_SESSION_CLOSED':
@@ -535,67 +534,68 @@ export default class Request
         try
         {
           await this.reconnect()
+          return reasons.push(reason)
         }
         catch(reason)
         {
-          const reconnectError = new Error(`${reason.message}, retry to reconnect to the server failed`)
-          reconnectError.code  = 'E_HTTP_REQUEST_RETRY_HTTP2_RECONNECT'
-          reconnectError.cause = reason
+          const error   = new Error(`${reason.message}, retry to reconnect to the server failed`)
+          error.code    = 'E_HTTP_REQUEST_RETRY_HTTP2_RECONNECT'
+          error.cause   = reason
+          error.reasons = reasons
           throw reason
         }
-        return errorTrace.push(error)
       }
       case 'E_HTTP_REQUEST_CLIENT_TIMEOUT':
       {
         if(options.retryOnClientTimeout)
         {
-          return errorTrace.push(error)
+          return reasons.push(reason)
         }
         else
         {
-          throw error
+          throw reason
         }
       }
       case 'E_HTTP_REQUEST_DOWNSTREAM_ERROR':
       {
         if(options.retryOnDownstreamError)
         {
-          return errorTrace.push(error)
+          return reasons.push(reason)
         }
         else
         {
-          throw error
+          throw reason
         }
       }
       case 'E_HTTP_REQUEST_INVALID_RESPONSE_BODY_FORMAT':
       {
         if(options.retryOnInvalidResponseBodyFormat)
         {
-          return errorTrace.push(error)
+          return reasons.push(reason)
         }
         else
         {
-          throw error
+          throw reason
         }
       }
       case 'E_HTTP_REQUEST_INVALID_RESPONSE_STATUS':
       {
         if(options.retryOnErrorResponseStatus)
         {
-          return errorTrace.push(error)
+          return reasons.push(reason)
         }
-        else if(options.retryOnStatus.includes(error.response.status))
+        else if(options.retryOnStatus.includes(reason.response.status))
         {
-          return errorTrace.push(error)
+          return reasons.push(reason)
         }
         else
         {
-          throw error
+          throw reason
         }
       }
       default:
       {
-        throw error
+        throw reason
       }
     }
   }
@@ -649,17 +649,28 @@ export default class Request
 
   /**
    * Normalizes the URL.
+   * One of authority or base must be provided,
    * 
-   * @param {String} url
-   * @param {String} base
+   * @param {String} [base] 
+   * @param {String} [authority] the URL origin (e.g. https://example.com)
+   * @param {String} [url]
    * 
    * @returns {String} Normalized URL
    */
-  #normalizeUrl(url, base)
+  #normalizeUrl(authority, base, url)
   {
+    let baseURL = authority && base
+      ? new URL(base, authority)
+      : new URL(base || authority)
+
+    if(url && false === baseURL.pathname.endsWith('/'))
+    {
+      baseURL = new URL(baseURL.pathname + '/', baseURL.href)
+    }
+
     return url
-    ? new URL(url, base).toString()
-    : new URL(base).toString()
+    ? new URL(url, baseURL.href).href
+    : baseURL.href
   }
 
   /**
@@ -710,12 +721,12 @@ export default class Request
     upstream.destroy(error)
   }
 
-  #bufferResponseBody(readable, response, method, url, accept, reject)
+  #bufferResponseBody(readable, response, method, url, resolve, reject)
   {
     response.body = ''
     readable.on('data',   (chunk) => response.body += chunk)
     readable.on('error',  this.#onStreamError.bind(this, method, url, response))
-    readable.on('end',    this.#onStreamEnd  .bind(this, method, url, response, accept, reject))
+    readable.on('end',    this.#onStreamEnd  .bind(this, method, url, response, resolve, reject))
     readable.resume()
   }
 
@@ -746,14 +757,14 @@ export default class Request
    * @param {String} method
    * @param {String} url
    * @param {http.IncomingMessage} response
-   * @param {Function} accept promise accept
+   * @param {Function} resolve promise resolve
    * @param {Function} reject promise reject
    * 
    * @returns {void}
    * 
    * @throws {Error} E_HTTP_REQUEST_INVALID_RESPONSE_BODY_FORMAT
    */
-  #onStreamEnd(method, url, response, accept, reject)
+  #onStreamEnd(method, url, response, resolve, reject)
   {
     try
     {
@@ -778,7 +789,7 @@ export default class Request
       return 
     }
     
-    accept(response)
+    resolve(response)
   }
 
   #contentTypeApplicationJson(body)

package/index.test.js

@@ -53,6 +53,50 @@ suite('@superhero/http-request', () =>
       assert.equal(response.body.url, '/', 'Should result to /')
     })
 
+    test('Request using a relative path', async sub =>
+    {
+      // ...close the server that was started before the
+      // sub tests starts another server for each test...
+      await request.close()
+      await new Promise(resolve => server.close(resolve))
+
+      await sub.test('Request using an absolute path with a trailing base path slash', async () =>
+      {
+        const base = request.config.base || ''
+        request.config.base = base + '/path/'
+        const response = await request.get('/foobar')
+        assert.equal(response.status, 200, 'Should return a 200 status code')
+        assert.equal(response.body.url, '/foobar', 'Should result to the absolute path')
+      })
+
+      await sub.test('Request using a absolute path with out a trailing base path slash', async () =>
+      {
+        const base = request.config.base || ''
+        request.config.base = base + '/path'
+        const response = await request.get('/foobar')
+        assert.equal(response.status, 200, 'Should return a 200 status code')
+        assert.equal(response.body.url, '/foobar', 'Should result to the absolute path')
+      })
+
+      await sub.test('Request using a relative path with a trailing base path slash', async () =>
+      {
+        const base = request.config.base || ''
+        request.config.base = base + '/path/'
+        const response = await request.get('foobar')
+        assert.equal(response.status, 200, 'Should return a 200 status code')
+        assert.equal(response.body.url, '/path/foobar', 'Should result to the absolute path')
+      })
+
+      await sub.test('Request using a relative path with out a trailing base path slash', async () =>
+      {
+        const base = request.config.base || ''
+        request.config.base = base + '/path'
+        const response = await request.get('foobar')
+        assert.equal(response.status, 200, 'Should return a 200 status code')
+        assert.equal(response.body.url, '/path/foobar', 'Should result to the absolute path')
+      })
+    })
+
     test('Request using a string body', async () =>
     {
       const response = await request.post({ body: 'test body' })
@@ -199,10 +243,10 @@ suite('@superhero/http-request', () =>
         }
         await assert.rejects(
           request.get(options),
-          (error) => error.code === 'E_HTTP_REQUEST_CLIENT_TIMEOUT',
+          (error) => error.cause.code === 'E_HTTP_REQUEST_CLIENT_TIMEOUT',
           'Should throw a timeout error')
       })
-  
+
       test('Rejects invalid JSON response accurately', async () => 
       {
         // Alter the server to respond with invalid JSON
@@ -216,7 +260,7 @@ suite('@superhero/http-request', () =>
         // Make the request
         await assert.rejects(
           request.get({ url: '/invalid-json' }),
-          (error) => error.code === 'E_HTTP_REQUEST_INVALID_RESPONSE_BODY_FORMAT',
+          (error) => error.cause.code === 'E_HTTP_REQUEST_INVALID_RESPONSE_BODY_FORMAT',
           'Should throw a parse error')
       })
 
@@ -383,7 +427,7 @@ suite('@superhero/http-request', () =>
   
           await assert.rejects(
             request.get(options),
-            { code:'E_HTTP_REQUEST_INVALID_RESPONSE_STATUS' },
+            (error) => error.cause.code === 'E_HTTP_REQUEST_INVALID_RESPONSE_STATUS',
             'Should throw an error after the second attempt')
   
           assert.equal(attempt, 2, 'Should make exactly 2 attempts')
@@ -401,7 +445,7 @@ suite('@superhero/http-request', () =>
   
           await assert.rejects(
             request.get(options),
-            (error) => error.code === 'E_HTTP_REQUEST_INVALID_RESPONSE_STATUS',
+            (error) => error.cause.code === 'E_HTTP_REQUEST_INVALID_RESPONSE_STATUS',
             'Should throw an error right away')
   
           assert.equal(attempt, 1, 'Should make exactly 1 attempt')
@@ -503,7 +547,7 @@ suite('@superhero/http-request', () =>
       })
     })
 
-    afterEach((done) => request.close().then(() => server.close(done)))
+    afterEach(done => request.close().then(() => server.close(done)))
   
     executeTheSameTestSuitFor_http1_http2()
 
@@ -547,7 +591,7 @@ suite('@superhero/http-request', () =>
 
         await assert.rejects(
           request.get({ url: '/timeout-test', timeout: 100 }),
-          (error) => error.code === 'E_HTTP_REQUEST_CLIENT_TIMEOUT',
+          (error) => error.cause.code === 'E_HTTP_REQUEST_CLIENT_TIMEOUT',
           'Should throw a timeout error')
       })
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superhero/http-request",
-  "version": "4.0.10",
+  "version": "4.1.1",
   "description": "HTTP(S) request component supporting HTTP 1.1 and HTTP 2.0",
   "keywords": [
     "http request",