@superhero/http-request 4.1.0 → 4.1.2

package/index.js

@@ -18,8 +18,9 @@ import { setTimeout as wait } from 'node:timers/promises'
 /**
  * @typedef {Object} RequestOptions
  * 
- * @property {String} url   - The URL to make the request to.
- * @property {String} base  - The base path to resolve the URL against.
+ * @property {String} [method] - The HTTP method to use.
+ * @property {String} url - The URL to make the request to.
+ * @property {String} base - The base path to resolve the URL against.
  * @property {Object.<String, String>} [headers] - The request headers.
  * @property {Object|String} [body] - The request body.
  * @property {Object|String} [data] - Alias for body.
@@ -35,7 +36,6 @@ import { setTimeout as wait } from 'node:timers/promises'
  * @property {Boolean} [doNotThrowOnRedirectStatus] - Set to true to avoid throwing on redirect status.
  * @property {Stream.Readable>} [upstream] - An optional upstream stream to make it possible to pipe body to the upstream directly.
  * @property {Stream.Writable} [downstream] - An optional downstream stream to make it possible to pipe body from the downstream to.
- * @property {String} [method] - The HTTP method to use.
  * 
  * @see {@link https://nodejs.org/api/http.html#httprequestoptions-callback}
  * @see {@link https://nodejs.org/api/https.html#httpsrequestoptions-callback}
@@ -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()
     })
   }
 
@@ -162,7 +159,9 @@ export default class Request
    */
   get(options)
   {
-    return this.#fetch('GET', options)
+    options = this.#normalizeOptions(options)
+    options.method = 'GET'
+    return this.fetch(options)
   }
 
   /**
@@ -175,7 +174,9 @@ export default class Request
    */
   post(options)
   {
-    return this.#fetch('POST', options)
+    options = this.#normalizeOptions(options)
+    options.method = 'POST'
+    return this.fetch(options)
   }
 
   /**
@@ -188,7 +189,9 @@ export default class Request
    */
   put(options)
   {
-    return this.#fetch('PUT', options)
+    options = this.#normalizeOptions(options)
+    options.method = 'PUT'
+    return this.fetch(options)
   }
 
   /**
@@ -201,7 +204,9 @@ export default class Request
    */
   patch(options)
   {
-    return this.#fetch('PATCH', options)
+    options = this.#normalizeOptions(options)
+    options.method = 'PATCH'
+    return this.fetch(options)
   }
 
   /**
@@ -213,7 +218,9 @@ export default class Request
    */
   delete(options)
   {
-    return this.#fetch('DELETE', options)
+    options = this.#normalizeOptions(options)
+    options.method = 'DELETE'
+    return this.fetch(options)
   }
 
   /**
@@ -226,7 +233,9 @@ export default class Request
    */
   head(options)
   {
-    return this.#fetch('HEAD', options)
+    options = this.#normalizeOptions(options)
+    options.method = 'HEAD'
+    return this.fetch(options)
   }
 
   /**
@@ -239,7 +248,9 @@ export default class Request
    */
   options(options)
   {
-    return this.#fetch('OPTIONS', options)
+    options = this.#normalizeOptions(options)
+    options.method = 'OPTIONS'
+    return this.fetch(options)
   }
 
   /**
@@ -254,17 +265,19 @@ export default class Request
    */
   trace(options)
   {
-    return this.#fetch('TRACE', options)
+    options = this.#normalizeOptions(options)
+    options.method = 'TRACE'
+    return this.fetch(options)
   }
 
   /**
    * Generic fetch method.
    * 
-   * @param {string} method 
    * @param {RequestOptions} options 
    * 
    * @returns {RequestResponse}
    * 
+   * @throws {TypeError} E_HTTP_REQUEST_INVALID_METHOD
    * @throws {Error} E_HTTP_REQUEST_CLIENT_ERROR
    * @throws {Error} E_HTTP_REQUEST_CLIENT_TIMEOUT
    * @throws {Error} E_HTTP_REQUEST_DOWNSTREAM_ERROR
@@ -275,23 +288,11 @@ export default class Request
    * @throws {Error} E_HTTP_REQUEST_RETRY_HTTP2_RECONNECT
    * @throws {Error} E_HTTP_REQUEST_RETRY_ERROR
    */
-  async #fetch(method, options)
+  async fetch(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 = this.#normalizeOptions(options)
     options = Object.assign(
     {
-      method,
       headers       : {},
       retry         : 3,
       retryDelay    : 200,
@@ -300,6 +301,15 @@ export default class Request
       retryOnStatus : []
     }, this.config, options)
 
+    if('string' !== typeof options.method)
+    {
+      const error = new TypeError(`Method must be a string, got ${typeof options.method}`)
+      error.code  = 'E_HTTP_REQUEST_INVALID_METHOD'
+      throw error
+    }
+
+    options.method = options.method.toUpperCase()
+
     try
     {
       return options.retry
@@ -308,13 +318,23 @@ export default class Request
     }
     catch(reason)
     {
-      const error = new Error(`Failed request ${method} ${options.url}`)
+      const error = new Error(`Failed request ${options.method} ${options.url}`)
       error.code  = 'E_HTTP_REQUEST_FAILED'
       error.cause = reason
       throw error
     }
   }
 
+  #normalizeOptions(options)
+  {
+    if(typeof options === 'string')
+    {
+      options = { url:options }
+    }
+
+    return options
+  }
+
   /**
    * Resolves the request.
    * 
@@ -325,20 +345,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)
@@ -346,7 +366,7 @@ export default class Request
     })
   }
 
-  #resolveHttp2Client(options, method, headers, url, accept, reject)
+  #resolveHttp2Client(options, method, headers, url, resolve, reject)
   {
     if(true === this.http2Session.destroyed)
     {
@@ -394,13 +414,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,
@@ -410,7 +430,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
   }
@@ -429,13 +449,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 =
     {
@@ -458,11 +478,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)
     }
   }
 
@@ -509,19 +529,16 @@ export default class Request
       }
     }
 
-    const 
-      uniqueReasons = reasons.filter((reason, i) => [i, -1].includes(reasons.lastIndexOf(({ code }) => code === reason.code))),
-      reason        = uniqueReasons.pop()
+    const
+      unique = reasons.filter((reason, i) => [i, -1].includes(reasons.map(e => e.code).lastIndexOf(code => code === reason.code))),
+      reason = unique.pop()
 
-    if(uniqueReasons.length === 1)
+    if(unique.length)
     {
-      throw reason
-    }
-    else
-    {
-      reason.previous = uniqueReasons
-      throw reason
+      reason.retried = unique
     }
+
+    throw reason
   }
 
   /**
@@ -662,17 +679,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
   }
 
   /**
@@ -723,12 +751,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()
   }
 
@@ -759,14 +787,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
     {
@@ -791,7 +819,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' })
@@ -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()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superhero/http-request",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "description": "HTTP(S) request component supporting HTTP 1.1 and HTTP 2.0",
   "keywords": [
     "http request",
@@ -18,7 +18,10 @@
     ".": "./index.js"
   },
   "scripts": {
-    "test": "node --trace-warnings --test --experimental-test-coverage"
+    "test": "node --test --test-reporter=@superhero/audit/reporter --experimental-test-coverage"
+  },
+  "devDependencies": {
+    "@superhero/audit": "^4.0.3"
   },
   "author": {
     "name": "Erik Landvall",