@nxtedition/nxt-undici 7.1.9 → 7.2.0

package/lib/errors.js

@@ -1,5 +1,3 @@
-'use strict'
-
 export class UndiciError extends Error {
   constructor(message, options) {
     super(message, options)

package/lib/index.js

@@ -18,6 +18,7 @@ export const interceptors = {
   requestId: (await import('./interceptor/request-id.js')).default,
   dns: (await import('./interceptor/dns.js')).default,
   lookup: (await import('./interceptor/lookup.js')).default,
+  priority: (await import('./interceptor/priority.js')).default,
 }
 
 export const cache = {
@@ -83,6 +84,7 @@ function wrapDispatch(dispatcher) {
   if (wrappedDispatcher == null) {
     wrappedDispatcher = compose(
       dispatcher,
+      interceptors.priority(),
       interceptors.dns(),
       interceptors.lookup(),
       interceptors.requestBodyFactory(),
@@ -106,6 +108,22 @@ function wrapDispatch(dispatcher) {
         headers['user-agent'] ??=
           opts.userAgent ?? globalThis.userAgent ?? globalThis.__nxt_undici_user_agent
 
+        let priority
+        if (opts.priority == null) {
+          // Do nothing
+        } else if (opts.priority === 'low' || opts.priority === 0 || opts.priority === '0') {
+          headers['nxt-priority'] = 'low'
+          priority = 0
+        } else if (opts.priority === 'normal' || opts.priority === 1 || opts.priority === '1') {
+          headers['nxt-priority'] = 'normal'
+          priority = 1
+        } else if (opts.priority === 'high' || opts.priority === 2 || opts.priority === '2') {
+          headers['nxt-priority'] = 'high'
+          priority = 2
+        } else {
+          throw new TypeError('invalid opts.priority')
+        }
+
         if (globalThis.__nxt_undici_global_headers) {
           Object.assign(headers, globalThis.__nxt_undici_global_headers)
         }
@@ -136,6 +154,7 @@ function wrapDispatch(dispatcher) {
             logger: opts.logger ?? null,
             dns: opts.dns ?? true,
             connect: opts.connect,
+            priority,
             lookup: opts.lookup ?? defaultLookup,
           },
           handler,
@@ -161,7 +180,8 @@ export function dispatch(dispatcher, opts, handler) {
  *   protocol: string?,
  *   pathname: string?,
  *   search: string?,
- * }} URLLike
+ * }} URLObject
+ * @typedef {string|URL|URLObject} URLLike
  */
 
 /**
@@ -174,7 +194,7 @@ export function dispatch(dispatcher, opts, handler) {
  *   id: string | null | undefined,
  *   dispatch: function,
  *   dispatcher: import('@nxtedition/undici').Dispatcher | null | undefined,
- *   url: URL | URLLike | string | null | undefined,
+ *   url: URLLike | null | undefined,
  *   origin: string?,
  *   path: string?,
  *   method: string | null | undefined,
@@ -198,13 +218,14 @@ export function dispatch(dispatcher, opts, handler) {
  *   logger: LoggerLike | null | undefined,
  *   dns: object | boolean | null | undefined,
  *   connect: object | null | undefined,
+ *   priority: 0 | 1 | 2 | "low" | "normal" | "high" | null | undefined,
  *   lookup: ((origin: string | URLLike | Array<string | URLLike> , opts: object, callback: (err: Error | null, address: string | null) => void) => void) | null | undefined,
  * }} RequestOptions
  */
 
 /**
  *
- * @param {URL|URLLike|string|RequestOptions} urlOrOpts
+ * @param {URLLike|RequestOptions} urlOrOpts
  * @param {RequestOptions|null} [opts]
  * @returns {Promise<{
  *  body: import('stream').Readable,

package/lib/interceptor/priority.js

@@ -0,0 +1,58 @@
+import { Scheduler } from '../utils/scheduler.js'
+import { DecoratorHandler } from '../utils.js'
+
+class Handler extends DecoratorHandler {
+  #next
+
+  constructor(handler, next) {
+    super(handler)
+    this.#next = next
+  }
+
+  onConnect(abort) {
+    this.#release()
+    super.onConnect(abort)
+  }
+
+  onComplete(trailers) {
+    this.#release()
+    super.onComplete(trailers)
+  }
+
+  onError(err) {
+    this.#release()
+    super.onError(err)
+  }
+
+  #release() {
+    if (this.#next) {
+      this.#next()
+      this.#next = null
+    }
+  }
+}
+
+export default () => (dispatch) => {
+  const schedulers = new Map()
+
+  return (opts, handler) => {
+    if (opts.priority == null || !opts.origin) {
+      return dispatch(opts, handler)
+    }
+
+    let scheduler = schedulers.get(opts.origin)
+    if (!scheduler) {
+      scheduler = new Scheduler({ concurrency: 1 })
+      schedulers.set(opts.origin, scheduler)
+    }
+
+    scheduler.schedule((next) => {
+      try {
+        dispatch(opts, new Handler(handler, next))
+      } catch (err) {
+        next()
+        handler.onError(err)
+      }
+    }, opts.priority)
+  }
+}

package/lib/interceptor/request-id.js

@@ -18,6 +18,7 @@ export default () => (dispatch) => (opts, handler) => {
     {
       ...opts,
       id: nextId,
+      logger: opts.logger?.child({ ureq: { id: nextId } }),
       headers: {
         ...opts.headers,
         'request-id': nextId,

package/lib/interceptor/response-retry.js

@@ -272,7 +272,7 @@ class Handler extends DecoratorHandler {
       .then((shouldRetry) => {
         if (this.#aborted) {
           this.#maybeError(this.#reason)
-        } else if (shouldRetry === false || isDisturbed(this.#opts.body)) {
+        } else if (!shouldRetry || isDisturbed(this.#opts.body)) {
           this.#maybeError(err)
         } else if (!this.#headersSent) {
           this.#opts.logger?.debug({ err, retryCount: this.#retryCount }, 'retry response headers')
@@ -327,6 +327,7 @@ class Handler extends DecoratorHandler {
         retryAfter != null && Number.isFinite(retryAfter)
           ? retryAfter
           : Math.min(10e3, retryCount * 1e3)
+      this.#opts.logger?.debug({ statusCode, retryAfter, delay, retryCount }, 'retry delay')
       return tp.setTimeout(delay, true, { signal: opts?.signal ?? undefined })
     }
 
@@ -347,12 +348,14 @@ class Handler extends DecoratorHandler {
         'UND_ERR_SOCKET',
       ].includes(err.code)
     ) {
+      this.#opts.logger?.debug({ err, retryCount }, 'retry delay')
       return tp.setTimeout(Math.min(10e3, retryCount * 1e3), true, {
         signal: opts?.signal ?? undefined,
       })
     }
 
     if (err?.message && ['other side closed'].includes(err.message)) {
+      this.#opts.logger?.debug({ err, retryCount }, 'retry delay')
       return tp.setTimeout(Math.min(10e3, retryCount * 1e3), true, {
         signal: opts?.signal ?? undefined,
       })

package/lib/utils/fixed-queue.js

@@ -0,0 +1,123 @@
+// Extracted from node/lib/internal/fixed_queue.js
+
+// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
+const kSize = 2048
+const kMask = kSize - 1
+
+// The FixedQueue is implemented as a singly-linked list of fixed-size
+// circular buffers. It looks something like this:
+//
+//  head                                                       tail
+//    |                                                          |
+//    v                                                          v
+// +-----------+ <-----\       +-----------+ <------\         +-----------+
+// |  [null]   |        \----- |   next    |         \------- |   next    |
+// +-----------+               +-----------+                  +-----------+
+// |   item    | <-- bottom    |   item    | <-- bottom       |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |       bottom --> |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |    ...    |               |    ...    |                  |    ...    |
+// |   item    |               |   item    |                  |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |  [empty]  | <-- top       |   item    |                  |   item    |
+// |  [empty]  |               |   item    |                  |   item    |
+// |  [empty]  |               |  [empty]  | <-- top  top --> |  [empty]  |
+// +-----------+               +-----------+                  +-----------+
+//
+// Or, if there is only one circular buffer, it looks something
+// like either of these:
+//
+//  head   tail                                 head   tail
+//    |     |                                     |     |
+//    v     v                                     v     v
+// +-----------+                               +-----------+
+// |  [null]   |                               |  [null]   |
+// +-----------+                               +-----------+
+// |  [empty]  |                               |   item    |
+// |  [empty]  |                               |   item    |
+// |   item    | <-- bottom            top --> |  [empty]  |
+// |   item    |                               |  [empty]  |
+// |  [empty]  | <-- top            bottom --> |   item    |
+// |  [empty]  |                               |   item    |
+// +-----------+                               +-----------+
+//
+// Adding a value means moving `top` forward by one, removing means
+// moving `bottom` forward by one. After reaching the end, the queue
+// wraps around.
+//
+// When `top === bottom` the current queue is empty and when
+// `top + 1 === bottom` it's full. This wastes a single space of storage
+// but allows much quicker checks.
+
+class FixedCircularBuffer {
+  constructor() {
+    this.bottom = 0
+    this.top = 0
+    this.list = new Array(kSize).fill(undefined)
+    this.next = null
+  }
+
+  isEmpty() {
+    return this.top === this.bottom
+  }
+
+  isFull() {
+    return ((this.top + 1) & kMask) === this.bottom
+  }
+
+  push(data) {
+    this.list[this.top] = data
+    this.top = (this.top + 1) & kMask
+  }
+
+  shift() {
+    const nextItem = this.list[this.bottom]
+    if (nextItem === undefined) {
+      return null
+    }
+    this.list[this.bottom] = undefined
+    this.bottom = (this.bottom + 1) & kMask
+    return nextItem
+  }
+}
+
+const POOL = []
+
+export class FixedQueue {
+  constructor() {
+    this.head = this.tail = POOL.pop() ?? new FixedCircularBuffer()
+    this.size = 0
+  }
+
+  isEmpty() {
+    return this.head.isEmpty()
+  }
+
+  push(data) {
+    if (this.head.isFull()) {
+      // Head is full: Creates a new queue, sets the old queue's `.next` to it,
+      // and sets it as the new main queue.
+      this.head = this.head.next = POOL.pop() ?? new FixedCircularBuffer()
+    }
+    this.head.push(data)
+  }
+
+  shift() {
+    const tail = this.tail
+    const next = tail.shift()
+    if (tail.isEmpty() && tail.next !== null) {
+      // If there is another queue, it forms the new tail.
+      this.tail = tail.next
+      tail.next = null
+      tail.bottom = 0
+      tail.top = 0
+      if (POOL.length < 64) {
+        POOL.push(tail)
+      }
+    }
+    return next
+  }
+}

package/lib/utils/scheduler.js

@@ -0,0 +1,74 @@
+import { FixedQueue } from './fixed-queue.js'
+
+export class Scheduler {
+  /** @type {0} */
+  static LOW = 0
+  /** @type {1} */
+  static NORMAL = 1
+  /** @type {2} */
+  static HIGH = 2
+
+  #concurrency
+  #running = 0
+  #counter = 0
+
+  #lowQueue = new FixedQueue()
+  #normalQueue = new FixedQueue()
+  #highQueue = new FixedQueue()
+
+  /**
+   * @param {{ concurrency?: number }} [options]
+   */
+  constructor({ concurrency = Infinity } = {}) {
+    this.#concurrency = concurrency
+  }
+
+  /**
+   * @param {(Function) => any} fn
+   * @param {0|1|2} priority
+   * @returns
+   */
+  schedule(fn, priority = Scheduler.NORMAL) {
+    if (typeof fn !== 'function') {
+      throw new TypeError('First argument must be a function')
+    }
+
+    if (priority == null) {
+      priority = Scheduler.NORMAL
+    }
+
+    if (!Number.isInteger(priority)) {
+      throw new Error('Invalid priority')
+    }
+
+    if (this.#running < this.#concurrency) {
+      this.#running++
+      return fn(this.#next)
+    }
+
+    if (priority > Scheduler.NORMAL) {
+      this.#highQueue.push(fn)
+    } else if (priority < Scheduler.NORMAL) {
+      this.#lowQueue.push(fn)
+    } else {
+      this.#normalQueue.push(fn)
+    }
+  }
+
+  #next = () => {
+    this.#counter++
+    this.#running--
+
+    const fn =
+      ((this.#counter & 63) === 0 && this.#lowQueue.shift()) ??
+      ((this.#counter & 15) === 0 && this.#normalQueue.shift()) ??
+      this.#highQueue.shift() ??
+      this.#normalQueue.shift() ??
+      this.#lowQueue.shift()
+
+    if (fn) {
+      this.#running++
+      fn(this.#next)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "7.1.9",
+  "version": "7.2.0",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",
@@ -12,19 +12,19 @@
     "@nxtedition/undici": "^11.1.1",
     "cache-control-parser": "^2.0.6",
     "fast-querystring": "^1.1.2",
-    "http-errors": "^2.0.0",
+    "http-errors": "^2.0.1",
     "xxhash-wasm": "^1.1.0"
   },
   "devDependencies": {
-    "@types/node": "^24.9.1",
-    "eslint": "^9.38.0",
+    "@types/node": "^25.0.0",
+    "eslint": "^9.39.1",
     "eslint-plugin-n": "^17.21.3",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.6",
+    "lint-staged": "^16.2.7",
     "pinst": "^3.0.0",
-    "prettier": "^3.6.2",
+    "prettier": "^3.7.4",
     "send": "^1.2.0",
-    "tap": "^21.1.0",
+    "tap": "^21.5.0",
     "undici-types": "^7.15.0"
   },
   "scripts": {