@nxtedition/lib 15.0.31 → 15.0.33

package/lib/undici/index.js

@@ -77,17 +77,13 @@ const dispatchers = {
   cache: require('./interceptor/cache.js'),
 }
 
-async function request(urlOrOpts, opts = {}) {
-  let url
-  if (typeof urlOrOpts === 'string') {
-    url = new URL(urlOrOpts)
-  } else if (urlOrOpts instanceof URL) {
-    url = urlOrOpts
-  } else if (typeof urlOrOpts?.origin === 'string' && typeof urlOrOpts?.path === 'string') {
-    url = urlOrOpts
-  } else if (typeof urlOrOpts === 'object' && urlOrOpts != null) {
-    opts = urlOrOpts
-    url = opts.url
+async function request(url, opts = {}) {
+  if (typeof url === 'string') {
+    url = new URL(url)
+  } else if (url instanceof URL) {
+    // Do nothing...
+  } else {
+    throw new Error('missing url')
   }
 
   const method = opts.method ?? (opts.body ? 'POST' : 'GET')
@@ -100,6 +96,17 @@ async function request(urlOrOpts, opts = {}) {
     headers = opts.headers
   }
 
+  if (method === 'CONNECT') {
+    throw new createError.MethodNotAllowed()
+  }
+
+  if (
+    (method === 'HEAD' || method === 'GET') &&
+    (parseInt(headers['content-length']) > 0 || headers['transfer-encoding'])
+  ) {
+    throw new createError.BadRequest('HEAD and GET cannot have body')
+  }
+
   opts = {
     url,
     method,
@@ -109,16 +116,20 @@ async function request(urlOrOpts, opts = {}) {
       'user-agent': opts.userAgent ?? globalThis.userAgent,
       ...headers,
     },
-    origin: opts.origin ?? url.origin,
-    path: opts.path ?? url.search ? `${url.pathname}${url.search ?? ''}` : url.pathname,
+    origin: url.origin,
+    path: url.search ? `${url.pathname}${url.search ?? ''}` : url.pathname,
     reset: opts.reset ?? false,
     headersTimeout: opts.headersTimeout,
     bodyTimeout: opts.bodyTimeout,
     idempotent,
     signal: opts.signal,
     retry: opts.retry ?? 8,
+    proxy: opts.proxy,
+    cache: opts.cache,
+    upgrade: opts.upgrade,
     follow: { count: opts.maxRedirections ?? 8, ...opts.redirect, ...opts.follow },
     logger: opts.logger,
+    maxRedirections: 0, // Disable undici's redirect handling.
   }
 
   const expectsPayload = opts.method === 'PUT' || opts.method === 'POST' || opts.method === 'PATCH'
@@ -141,15 +152,14 @@ async function request(urlOrOpts, opts = {}) {
     dispatch = dispatchers.catch(dispatch)
     dispatch = dispatchers.abort(dispatch)
     dispatch = dispatchers.log(dispatch)
-    dispatch = dispatchers.responseRetry(dispatch)
-    dispatch = dispatchers.responseStatusRetry(dispatch)
-    dispatch = dispatchers.responseBodyRetry(dispatch)
-    dispatch = dispatchers.content(dispatch)
-    dispatch = dispatchers.responseBodyDump(dispatch)
+    dispatch = opts.upgrade ? dispatch : dispatchers.responseRetry(dispatch)
+    dispatch = opts.upgrade ? dispatch : dispatchers.responseStatusRetry(dispatch)
+    dispatch = opts.upgrade ? dispatch : dispatchers.responseBodyRetry(dispatch)
+    dispatch = opts.upgrade ? dispatch : dispatchers.content(dispatch)
     dispatch = dispatchers.redirect(dispatch)
     dispatch = dispatchers.signal(dispatch)
+    dispatch = opts.upgrade ? dispatch : dispatchers.cache(dispatch)
     dispatch = dispatchers.proxy(dispatch)
-    dispatch = dispatchers.cache(dispatch)
 
     dispatch(opts, {
       resolve,
@@ -159,6 +169,15 @@ async function request(urlOrOpts, opts = {}) {
       onConnect(abort) {
         this.abort = abort
       },
+      onUpgrade(statusCode, rawHeaders, socket) {
+        const headers = parseHeaders(rawHeaders)
+
+        if (statusCode !== 101) {
+          this.abort(createError(statusCode, { headers }))
+        } else {
+          this.resolve({ headers, socket })
+        }
+      },
       onHeaders(statusCode, rawHeaders, resume, statusMessage) {
         assert(this.abort)
 

package/lib/undici/interceptor/abort.js

@@ -18,6 +18,10 @@ class Handler {
     return this.handler.onBodySent?.(chunk)
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
   onHeaders(statusCode, rawHeaders, resume, statusMessage) {
     if (this.reason == null) {
       const ret = this.handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage)

package/lib/undici/interceptor/cache.js

@@ -14,6 +14,10 @@ class CacheHandler {
     return this.handler.onConnect(abort)
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
   onHeaders(statusCode, rawHeaders, resume, statusMessage) {
     // NOTE: Only cache 307 respones for now...
     if (statusCode !== 307) {
@@ -142,8 +146,9 @@ module.exports = (dispatch) => (opts, handler) => {
 
   // TODO (fix): Support body...
   assert(opts.method === 'GET' || opts.method === 'HEAD')
+
   // Dump body...
-  opts.body.on('error', () => {}).resume()
+  opts.body?.on('error', () => {}).resume()
 
   const store = opts.cache === true ? DEFAULT_CACHE_STORE : opts.cache
 

package/lib/undici/interceptor/catch.js

@@ -12,6 +12,14 @@ class Handler {
     }
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    try {
+      return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+    } catch (err) {
+      this.abort(err)
+    }
+  }
+
   onBodySent(chunk) {
     try {
       return this.handler.onBodySent?.(chunk)

package/lib/undici/interceptor/content.js

@@ -18,6 +18,10 @@ class Handler {
     return this.handler.onConnect?.(abort)
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
   onBodySent(chunk) {
     return this.handler.onBodySent?.(chunk)
   }

package/lib/undici/interceptor/log.js

@@ -23,6 +23,14 @@ class Handler {
     })
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    this.logger.debug({ ureq: this.opts }, 'upstream request upgraded')
+    socket.on('close', () => {
+      this.logger.debug({ ureq: this.opts }, 'upstream request socket closed')
+    })
+    return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
   onBodySent(chunk) {
     return this.handler.onBodySent?.(chunk)
   }

package/lib/undici/interceptor/proxy.js

@@ -11,6 +11,26 @@ class Handler {
     return this.handler.onConnect?.(abort)
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade?.(
+      statusCode,
+      reduceHeaders(
+        {
+          headers: rawHeaders,
+          httpVersion: this.opts.proxy.httpVersion ?? this.opts.proxy.req?.httpVersion,
+          socket: null,
+          proxyName: this.opts.proxy.name,
+        },
+        (acc, key, val) => {
+          acc.push(key, val)
+          return acc
+        },
+        [],
+      ),
+      socket,
+    )
+  }
+
   onBodySent(chunk) {
     return this.handler.onBodySent?.(chunk)
   }
@@ -54,22 +74,21 @@ module.exports = (dispatch) => (opts, handler) => {
     return dispatch(opts, handler)
   }
 
-  opts = {
-    ...opts,
-    headers: reduceHeaders(
-      {
-        headers: opts.headers ?? {},
-        httpVersion: opts.proxy.httpVersion ?? opts.proxy.req?.httpVersion,
-        socket: opts.proxy.socket ?? opts.proxy.req?.socket,
-        proxyName: opts.proxy.name,
-      },
-      (obj, key, val) => {
-        obj[key] = val
-        return obj
-      },
-      {},
-    ),
-  }
+  const headers = reduceHeaders(
+    {
+      headers: opts.headers ?? {},
+      httpVersion: opts.proxy.httpVersion ?? opts.proxy.req?.httpVersion,
+      socket: opts.proxy.socket ?? opts.proxy.req?.socket,
+      proxyName: opts.proxy.name,
+    },
+    (obj, key, val) => {
+      obj[key] = val
+      return obj
+    },
+    {},
+  )
+
+  opts = { ...opts, headers }
 
   return dispatch(opts, new Handler(opts, { handler }))
 }
@@ -83,7 +102,7 @@ const HOP_EXPR =
 function forEachHeader(headers, fn) {
   if (Array.isArray(headers)) {
     for (let n = 0; n < headers.length; n += 2) {
-      fn(headers[n + 0], headers[n + 1])
+      fn(headers[n + 0].toString(), headers[n + 1].toString())
     }
   } else {
     for (const [key, val] of Object.entries(headers)) {

package/lib/undici/interceptor/redirect.js

@@ -35,7 +35,7 @@ class Handler {
   }
 
   onUpgrade(statusCode, headers, socket) {
-    this.handler.onUpgrade(statusCode, headers, socket)
+    this.handler.onUpgrade?.(statusCode, headers, socket)
   }
 
   onError(error) {
@@ -51,18 +51,26 @@ class Handler {
       throw new Error(`Disturbed request cannot be redirected.`)
     }
 
-    const maxCount = this.opts.follow.count
-
-    if (this.count++ >= maxCount) {
-      throw new Error(`Max redirections reached: ${maxCount}.`)
-    }
-
     this.location = findHeader(headers, 'location')
 
     if (!this.location) {
       throw new Error(`Missing redirection location.`)
     }
 
+    this.count += 1
+
+    if (typeof this.opts.follow === 'function') {
+      if (!this.opts.follow(this.location, this.count)) {
+        return this.handler.onHeaders?.(statusCode, headers, resume, statusText)
+      }
+    } else {
+      const maxCount = this.opts.follow.count ?? 0
+
+      if (this.count >= maxCount) {
+        throw new Error(`Max redirections reached: ${maxCount}.`)
+      }
+    }
+
     const { origin, pathname, search } = parseURL(
       new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)),
     )
@@ -174,6 +182,4 @@ function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
 }
 
 module.exports = (dispatch) => (opts, handler) =>
-  opts.follow?.count
-    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
-    : dispatch(opts, handler)
+  opts.follow ? dispatch(opts, new Handler(opts, { handler, dispatch })) : dispatch(opts, handler)

package/lib/undici/interceptor/response-body-retry.js

@@ -1,10 +1,5 @@
 const assert = require('node:assert')
-const {
-  parseContentRange,
-  isDisturbed,
-  findHeader,
-  retryAfter: retryAfterFn,
-} = require('../utils.js')
+const { parseContentRange, isDisturbed, findHeader, retry: retryFn } = require('../utils.js')
 
 class Handler {
   constructor(opts, { dispatch, handler }) {
@@ -39,6 +34,10 @@ class Handler {
     }
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
   onBodySent(chunk) {
     return this.handler.onBodySent?.(chunk)
   }
@@ -125,11 +124,23 @@ class Handler {
       return this.handler.onError?.(err)
     }
 
-    const retryAfter = retryAfterFn(err, this.count++, this.opts)
-    if (retryAfter == null) {
+    const retryPromise = retryFn(err, this.count++, this.opts)
+    if (retryPromise == null) {
       return this.handler.onError?.(err)
     }
-    assert(Number.isFinite(retryAfter), 'invalid retry')
+
+    retryPromise
+      .then(() => {
+        this.timeout = null
+        try {
+          this.dispatch(this.opts, this)
+        } catch (err2) {
+          this.handler.onError?.(err)
+        }
+      })
+      .catch((err) => {
+        this.handler.onError?.(err)
+      })
 
     this.error = err
     this.opts = {
@@ -141,16 +152,7 @@ class Handler {
       },
     }
 
-    this.opts.logger?.debug('retrying response body', { retryAfter })
-
-    this.timeout = setTimeout(() => {
-      this.timeout = null
-      try {
-        this.dispatch(this.opts, this)
-      } catch (err) {
-        this.handler.onError?.(err)
-      }
-    }, retryAfter)
+    this.opts.logger?.debug('retrying response body')
   }
 }
 

package/lib/undici/interceptor/response-retry.js

@@ -1,5 +1,4 @@
-const assert = require('node:assert')
-const { isDisturbed, retryAfter: retryAfterFn } = require('../utils.js')
+const { isDisturbed, retry: retryFn } = require('../utils.js')
 
 class Handler {
   constructor(opts, { dispatch, handler }) {
@@ -31,6 +30,10 @@ class Handler {
     }
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
   onBodySent(chunk) {
     return this.handler.onBodySent?.(chunk)
   }
@@ -58,23 +61,25 @@ class Handler {
       return this.handler.onError?.(err)
     }
 
-    const retryAfter = retryAfterFn(err, this.count++, this.opts)
-    if (retryAfter == null) {
+    const retryPromise = retryFn(err, this.count++, this.opts)
+    if (retryPromise == null) {
       return this.handler.onError?.(err)
     }
-    assert(Number.isFinite(retryAfter), 'invalid retryAfter')
 
-    this.opts.logger?.debug('retrying response', { retryAfter })
-
-    this.timeout = setTimeout(() => {
-      this.timeout = null
-      try {
-        this.dispatch(this.opts, this)
-      } catch (err2) {
+    retryPromise
+      .then(() => {
+        this.timeout = null
+        try {
+          this.dispatch(this.opts, this)
+        } catch (err2) {
+          this.handler.onError?.(err)
+        }
+      })
+      .catch((err) => {
         this.handler.onError?.(err)
-      }
-    }, retryAfter)
-    this.retryAfter = null
+      })
+
+    this.opts.logger?.debug('retrying response')
   }
 }
 

package/lib/undici/interceptor/response-status-retry.js

@@ -1,5 +1,4 @@
-const assert = require('node:assert')
-const { isDisturbed, retryAfter: retryAfterFn } = require('../utils')
+const { isDisturbed, retry: retryFn } = require('../utils')
 const createError = require('http-errors')
 const { parseHeaders } = require('../../../http')
 
@@ -14,7 +13,7 @@ class Handler {
 
     this.timeout = null
     this.count = 0
-    this.retryAfter = null
+    this.retryPromise = null
 
     this.handler.onConnect?.((reason) => {
       this.aborted = true
@@ -34,6 +33,10 @@ class Handler {
     }
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
   onBodySent(chunk) {
     return this.handler.onBodySent?.(chunk)
   }
@@ -45,13 +48,14 @@ class Handler {
 
     const err = createError(statusCode, { headers: parseHeaders(rawHeaders) })
 
-    const retryAfter = retryAfterFn(err, this.count++, this.opts)
-    if (retryAfter == null) {
+    const retryPromise = retryFn(err, this.count++, this.opts)
+    if (retryPromise == null) {
       return this.handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage)
     }
-    assert(Number.isFinite(retryAfter), 'invalid retryAfter')
 
-    this.retryAfter = retryAfter
+    retryPromise.catch(() => {})
+
+    this.retryPromise = retryPromise
 
     this.abort(err)
 
@@ -72,21 +76,25 @@ class Handler {
       this.timeout = null
     }
 
-    if (this.retryAfter == null || this.aborted || isDisturbed(this.opts.body)) {
+    if (this.retryPromise == null || this.aborted || isDisturbed(this.opts.body)) {
       return this.handler.onError?.(err)
     }
 
-    this.opts.logger?.debug('retrying response status', { retryAfter: this.retryAfter })
-
-    this.timeout = setTimeout(() => {
-      this.timeout = null
-      try {
-        this.dispatch(this.opts, this)
-      } catch (err) {
+    this.retryPromise
+      .then(() => {
+        this.timeout = null
+        try {
+          this.dispatch(this.opts, this)
+        } catch (err) {
+          this.handler.onError?.(err)
+        }
+      })
+      .catch((err) => {
         this.handler.onError?.(err)
-      }
-    }, this.retryAfter)
-    this.retryAfter = null
+      })
+    this.retryPromise = null
+
+    this.opts.logger?.debug('retrying response status')
   }
 }
 

package/lib/undici/interceptor/signal.js

@@ -18,6 +18,10 @@ class Handler {
     }
   }
 
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
   onBodySent(chunk) {
     return this.handler.onBodySent?.(chunk)
   }

package/lib/undici/utils.js

@@ -1,5 +1,15 @@
+const tp = require('node:timers/promises')
+
 function isDisturbed(body) {
-  return !(body == null || typeof body === 'string' || Buffer.isBuffer(body))
+  if (body == null || typeof body === 'string' || Buffer.isBuffer(body)) {
+    return false
+  }
+
+  if (body.readableDidRead === false) {
+    return false
+  }
+
+  return true
 }
 
 function parseContentRange(range) {
@@ -42,16 +52,13 @@ function findHeader(rawHeaders, name) {
   return null
 }
 
-function retryAfter(err, retryCount, opts) {
+function retry(err, retryCount, opts) {
   if (opts.retry === null || opts.retry === false) {
     return null
   }
 
   if (typeof opts.retry === 'function') {
-    const ret = opts.retry(err, retryCount)
-    if (ret != null) {
-      return ret
-    }
+    return opts.retry(err, retryCount, opts)
   }
 
   const retryMax = opts.retry?.count ?? opts.maxRetries ?? 8
@@ -61,8 +68,13 @@ function retryAfter(err, retryCount, opts) {
   }
 
   if (err.statusCode && [420, 429, 502, 503, 504].includes(err.statusCode)) {
-    const retryAfter = err.headers['retry-after'] ? err.headers['retry-after'] * 1e3 : null
-    return Number.isFinite(retryAfter) ? retryAfter : Math.min(10e3, retryCount * 1e3)
+    let retryAfter = err.headers['retry-after'] ? err.headers['retry-after'] * 1e3 : null
+    retryAfter = Number.isFinite(retryAfter) ? retryAfter : Math.min(10e3, retryCount * 1e3)
+    if (retryAfter != null && Number.isFinite(retryAfter)) {
+      return tp.setTimeout(retryAfter, undefined, { signal: opts.signal })
+    } else {
+      return null
+    }
   }
 
   if (
@@ -78,11 +90,11 @@ function retryAfter(err, retryCount, opts) {
       'EPIPE',
     ].includes(err.code)
   ) {
-    return Math.min(10e3, retryCount * 1e3)
+    return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })
   }
 
   if (err.message && ['other side closed'].includes(err.message)) {
-    return Math.min(10e3, retryCount * 1e3)
+    return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })
   }
 
   return null
@@ -165,7 +177,7 @@ module.exports = {
   isDisturbed,
   parseContentRange,
   findHeader,
-  retryAfter,
+  retry,
   parseURL,
   parseOrigin,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "15.0.31",
+  "version": "15.0.33",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "files": [

package/util/template/index.js

@@ -84,7 +84,7 @@ module.exports = ({ ds, proxify }) => {
     let indices
 
     for (let i = 0; i < template.length; i++) {
-      const resolver = compileTemplate(template[i])
+      const resolver = _compileTemplate(template[i])
       if (resolver) {
         resolvers ??= []
         resolvers.push(resolver)
@@ -121,7 +121,7 @@ module.exports = ({ ds, proxify }) => {
     const keys = Object.keys(template)
 
     for (let i = 0; i < keys.length; i++) {
-      const resolver = compileTemplate(template[keys[i]])
+      const resolver = _compileTemplate(template[keys[i]])
       if (resolver) {
         resolvers ??= []
         resolvers.push(resolver)
@@ -207,7 +207,7 @@ module.exports = ({ ds, proxify }) => {
     return typeof val === 'string' && val.indexOf('{{') !== -1
   }
 
-  const compileTemplateCache = weakCache(
+  const _compileTemplateCache = weakCache(
     (template) => {
       if (fp.isPlainObject(template)) {
         return compileObjectTemplate(template)
@@ -222,9 +222,14 @@ module.exports = ({ ds, proxify }) => {
     (template, hash) => hash,
   )
 
-  function compileTemplate(template) {
+  function _compileTemplate(template) {
     const hash = hashTemplate(template)
-    const resolver = hash ? compileTemplateCache(template, hash) : null
+    const resolver = hash ? _compileTemplateCache(template, hash) : null
+    return resolver // ? (args$) => resolver(template, args$) : null
+  }
+
+  function compileTemplate(template) {
+    const resolver = _compileTemplate(template)
     return resolver ? (args$) => resolver(template, args$) : null
   }
 
@@ -234,7 +239,7 @@ module.exports = ({ ds, proxify }) => {
 
   function onResolveTemplate(template, args$) {
     try {
-      return compileTemplate(template)?.(args$) ?? rxjs.of(template)
+      return _compileTemplate(template)?.(template, args$) ?? rxjs.of(template)
     } catch (err) {
       return rxjs.throwError(() => err)
     }