@nxtedition/lib 15.0.34 → 15.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "15.0.34",
+  "version": "15.0.36",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "files": [
@@ -8,8 +8,6 @@
     "ass.js",
     "rxjs/*",
     "util/*",
-    "lib/*",
-    "undici.js",
     "http-client.js",
     "subtract-ranges.js",
     "serializers.js",
@@ -74,7 +72,6 @@
     "/__tests__"
   ],
   "dependencies": {
-    "cache-control-parser": "^2.0.4",
     "date-fns": "^2.29.3",
     "fast-querystring": "^1.1.1",
     "hasha": "^5.2.2",
@@ -82,13 +79,11 @@
     "json5": "^2.2.3",
     "koa-compose": "^4.1.0",
     "lodash": "^4.17.21",
-    "lru-cache": "^10.0.1",
     "mime": "^3.0.0",
     "moment-timezone": "^0.5.43",
     "nconf": "^0.12.0",
     "nested-error-stacks": "^2.1.1",
     "object-hash": "^3.0.0",
-    "omit-empty": "^1.0.0",
     "pino-std-serializers": "^6.2.2",
     "qs": "^6.11.1",
     "request-target": "^1.0.2",
@@ -96,8 +91,7 @@
     "split-string": "^6.0.0",
     "toobusy-js": "^0.5.1",
     "undici": "^5.25.4",
-    "url-join": "^4.0.0",
-    "xuid": "^4.1.2"
+    "url-join": "^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.8.2",

package/lib/undici/index.js

@@ -1,237 +0,0 @@
-const assert = require('assert')
-const createError = require('http-errors')
-const xuid = require('xuid')
-const undici = require('undici')
-const stream = require('stream')
-const { parseHeaders } = require('../../http')
-
-class Readable extends stream.Readable {
-  constructor({ statusCode, statusMessage, headers, size, ...opts }) {
-    super(opts)
-    this.statusCode = statusCode
-    this.statusMessage = statusMessage
-    this.headers = headers
-    this.body = this
-    this.size = size
-  }
-
-  async text() {
-    const dec = new TextDecoder()
-    let str = ''
-    for await (const chunk of this) {
-      if (typeof chunk === 'string') {
-        str += chunk
-      } else {
-        str += dec.decode(chunk, { stream: true })
-      }
-    }
-    // Flush the streaming TextDecoder so that any pending
-    // incomplete multibyte characters are handled.
-    str += dec.decode(undefined, { stream: false })
-    return str
-  }
-
-  async json() {
-    return JSON.parse(await this.text())
-  }
-
-  async arrayBuffer() {
-    const buffers = []
-    for await (const chunk of this) {
-      buffers.push(chunk)
-    }
-    return Buffer.concat(buffers)
-  }
-
-  async buffer() {
-    return Buffer.from(await this.arrayBuffer())
-  }
-
-  async dump() {
-    let n = 0
-    try {
-      for await (const chunk of this) {
-        // do nothing
-        n += chunk.length
-        if (n > 128 * 1024) {
-          break
-        }
-      }
-    } catch {
-      this.destroy()
-    }
-  }
-}
-
-const dispatchers = {
-  abort: require('./interceptor/abort.js'),
-  catch: require('./interceptor/catch.js'),
-  content: require('./interceptor/content.js'),
-  log: require('./interceptor/log.js'),
-  redirect: require('./interceptor/redirect.js'),
-  responseBodyRetry: require('./interceptor/response-body-retry.js'),
-  responseStatusRetry: require('./interceptor/response-status-retry.js'),
-  responseRetry: require('./interceptor/response-retry.js'),
-  signal: require('./interceptor/signal.js'),
-  proxy: require('./interceptor/proxy.js'),
-  cache: require('./interceptor/cache.js'),
-}
-
-async function request(url, opts) {
-  if (typeof url === 'string') {
-    url = new URL(url)
-  } else if (url instanceof URL) {
-    // Do nothing...
-  } else if (typeof url.origin === 'string' && typeof (url.path ?? url.pathname) === 'string') {
-    // Do nothing...
-  } else {
-    throw new Error('missing url')
-  }
-
-  if (opts == null && typeof url === 'object' && url != null) {
-    opts = url
-  }
-
-  const method = opts.method ?? (opts.body ? 'POST' : 'GET')
-  const idempotent = opts.idempotent ?? (method === 'GET' || method === 'HEAD')
-
-  let headers
-  if (Array.isArray(opts.headers)) {
-    headers = parseHeaders(opts.headers)
-  } else {
-    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,
-    body: opts.body,
-    headers: {
-      'request-id': xuid(),
-      'user-agent': opts.userAgent ?? globalThis.userAgent,
-      ...headers,
-    },
-    origin: url.origin,
-    path: url.path ? url.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'
-
-  if (opts.headers['content-length'] === '0' && !expectsPayload) {
-    // https://tools.ietf.org/html/rfc7230#section-3.3.2
-    // A user agent SHOULD NOT send a Content-Length header field when
-    // the request message does not contain a payload body and the method
-    // semantics do not anticipate such a body.
-
-    // undici will error if provided an unexpected content-length: 0 header.
-    delete opts.headers['content-length']
-  }
-
-  const dispatcher = opts.dispatcher ?? undici.getGlobalDispatcher()
-
-  return new Promise((resolve) => {
-    let dispatch = (opts, handler) => dispatcher.dispatch(opts, handler)
-
-    dispatch = dispatchers.catch(dispatch)
-    dispatch = dispatchers.abort(dispatch)
-    dispatch = dispatchers.log(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(opts, {
-      resolve,
-      logger: opts.logger,
-      /** @type {Function | null} */ abort: null,
-      /** @type {stream.Readable | null} */ body: null,
-      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)
-
-        const headers = parseHeaders(rawHeaders)
-
-        if (statusCode >= 400) {
-          this.abort(createError(statusCode, { headers }))
-        } else {
-          assert(statusCode >= 200)
-
-          const contentLength = Number(headers['content-length'] ?? headers['Content-Length'])
-
-          this.body = new Readable({
-            read: resume,
-            highWaterMark: 128 * 1024,
-            statusCode,
-            statusMessage,
-            headers,
-            size: Number.isFinite(contentLength) ? contentLength : null,
-          }).on('error', (err) => {
-            if (this.logger && this.body?.listenerCount('error') === 1) {
-              this.logger.error({ err }, 'unhandled response body error')
-            }
-          })
-
-          this.resolve(this.body)
-          this.resolve = null
-        }
-
-        return false
-      },
-      onData(chunk) {
-        assert(this.body)
-        return this.body.push(chunk)
-      },
-      onComplete() {
-        assert(this.body)
-        this.body.push(null)
-      },
-      onError(err) {
-        if (this.body) {
-          this.body.destroy(err)
-        } else {
-          this.resolve(Promise.reject(err))
-        }
-      },
-    })
-  })
-}
-
-module.exports = { request }

package/lib/undici/interceptor/abort.js

@@ -1,65 +0,0 @@
-const { AbortError } = require('../../../errors')
-
-class Handler {
-  constructor(opts, { handler }) {
-    this.handler = handler
-    this.pos = 0
-    this.reason = null
-  }
-
-  onConnect(abort) {
-    this.abort = abort
-    this.handler.onConnect?.((reason) => {
-      this.reason = reason ?? new AbortError()
-    })
-  }
-
-  onBodySent(chunk) {
-    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)
-      if (this.reason == null) {
-        return ret
-      }
-    }
-
-    return true
-  }
-
-  onData(chunk) {
-    if (this.reason == null) {
-      const ret = this.handler.onData?.(chunk)
-      if (this.reason == null) {
-        return ret
-      }
-    }
-
-    this.pos += chunk.length
-    if (this.pos < 128 * 1024) {
-      return true
-    }
-
-    this.abort(this.reason)
-
-    return false
-  }
-
-  onComplete(rawTrailers) {
-    return this.reason == null
-      ? this.handler.onComplete?.(rawTrailers)
-      : this.handler.onError?.(this.reason)
-  }
-
-  onError(err) {
-    return this.handler.onError?.(err)
-  }
-}
-
-module.exports = (dispatch) => (opts, handler) => dispatch(opts, new Handler(opts, { handler }))

package/lib/undici/interceptor/cache.js

@@ -1,202 +0,0 @@
-const assert = require('node:assert')
-const { LRUCache } = require('lru-cache')
-const cacheControlParser = require('cache-control-parser')
-
-class CacheHandler {
-  constructor({ key, handler, store }) {
-    this.key = key
-    this.handler = handler
-    this.store = store
-    this.value = null
-  }
-
-  onConnect(abort) {
-    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) {
-      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
-    }
-
-    let cacheControl
-    for (let n = 0; n < rawHeaders.length; n += 2) {
-      if (
-        rawHeaders[n].length === 'cache-control'.length &&
-        rawHeaders[n].toString().toLowerCase() === 'cache-control'
-      ) {
-        cacheControl = cacheControlParser.parse(rawHeaders[n + 1].toString())
-        break
-      }
-    }
-
-    if (
-      cacheControl &&
-      cacheControl.public &&
-      !cacheControl.private &&
-      !cacheControl['no-store'] &&
-      // TODO (fix): Support all cache control directives...
-      // !opts.headers['no-transform'] &&
-      !cacheControl['no-cache'] &&
-      !cacheControl['must-understand'] &&
-      !cacheControl['must-revalidate'] &&
-      !cacheControl['proxy-revalidate']
-    ) {
-      const maxAge = cacheControl['s-max-age'] ?? cacheControl['max-age']
-      const ttl = cacheControl.immutable
-        ? 31556952 // 1 year
-        : Number(maxAge)
-
-      if (ttl > 0) {
-        this.value = {
-          statusCode,
-          statusMessage,
-          rawHeaders,
-          rawTrailers: null,
-          body: [],
-          size: 0,
-          ttl: ttl * 1e3,
-        }
-      }
-    }
-
-    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
-  }
-
-  onData(chunk) {
-    if (this.value) {
-      this.value.size += chunk.bodyLength
-      if (this.value.size > this.store.maxEntrySize) {
-        this.value = null
-      } else {
-        this.value.body.push(chunk)
-      }
-    }
-    return this.handler.onData(chunk)
-  }
-
-  onComplete(rawTrailers) {
-    if (this.value) {
-      this.value.rawTrailers = rawTrailers
-      this.store.set(this.key, this.value, this.value.ttl)
-    }
-    return this.handler.onComplete(rawTrailers)
-  }
-
-  onError(err) {
-    return this.handler.onError(err)
-  }
-}
-
-// TODO (fix): Async filesystem cache.
-class CacheStore {
-  constructor({ maxSize, maxEntrySize }) {
-    this.maxSize = maxSize
-    this.maxEntrySize = maxEntrySize
-    this.cache = new LRUCache({
-      maxSize,
-      sizeCalculation: (value) => value.body.byteLength,
-    })
-  }
-
-  set(key, value, ttl) {
-    this.cache.set(key, value, ttl)
-  }
-
-  get(key) {
-    return this.cache.get(key)
-  }
-}
-
-function makeKey(opts) {
-  // NOTE: Ignores headers...
-  return `${opts.method}:${opts.path}`
-}
-
-const DEFAULT_CACHE_STORE = new CacheStore({ maxSize: 128 * 1024, maxEntrySize: 1024 })
-
-module.exports = (dispatch) => (opts, handler) => {
-  if (!opts.cache) {
-    return dispatch(opts, handler)
-  }
-
-  if (opts.method !== 'GET' && opts.method !== 'HEAD') {
-    dispatch(opts, handler)
-    return
-  }
-
-  if (opts.headers?.['cache-control'] || opts.headers?.authorization) {
-    // TODO (fix): Support all cache control directives...
-    // const cacheControl = cacheControlParser.parse(opts.headers['cache-control'])
-    // cacheControl['no-cache']
-    // cacheControl['no-store']
-    // cacheControl['max-age']
-    // cacheControl['max-stale']
-    // cacheControl['min-fresh']
-    // cacheControl['no-transform']
-    // cacheControl['only-if-cached']
-    dispatch(opts, handler)
-    return
-  }
-
-  // TODO (fix): Support body...
-  assert(opts.method === 'GET' || opts.method === 'HEAD')
-
-  // Dump body...
-  opts.body?.on('error', () => {}).resume()
-
-  const store = opts.cache === true ? DEFAULT_CACHE_STORE : opts.cache
-
-  if (!store) {
-    throw new Error(`Cache store not provided.`)
-  }
-
-  let key = makeKey(opts)
-  let value = store.get(key)
-
-  if (value == null && opts.method === 'HEAD') {
-    key = makeKey({ ...opts, method: 'GET' })
-    value = store.get(key)
-  }
-
-  if (value) {
-    const { statusCode, statusMessage, rawHeaders, rawTrailers, body } = value
-    const ac = new AbortController()
-    const signal = ac.signal
-
-    const resume = () => {}
-    const abort = () => {
-      ac.abort()
-    }
-
-    try {
-      handler.onConnect(abort)
-      signal.throwIfAborted()
-      handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
-      signal.throwIfAborted()
-      if (opts.method !== 'HEAD') {
-        for (const chunk of body) {
-          const ret = handler.onData(chunk)
-          signal.throwIfAborted()
-          if (ret === false) {
-            // TODO (fix): back pressure...
-          }
-        }
-        handler.onComplete(rawTrailers)
-        signal.throwIfAborted()
-      } else {
-        handler.onComplete([])
-        signal.throwIfAborted()
-      }
-    } catch (err) {
-      handler.onError(err)
-    }
-  } else {
-    dispatch(opts, new CacheHandler({ handler, store, key: makeKey(opts) }))
-  }
-}

package/lib/undici/interceptor/catch.js

@@ -1,63 +0,0 @@
-class Handler {
-  constructor(opts, { handler }) {
-    this.handler = handler
-  }
-
-  onConnect(abort) {
-    this.abort = abort
-    try {
-      return this.handler.onConnect?.(abort)
-    } catch (err) {
-      this.abort(err)
-    }
-  }
-
-  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)
-    } catch (err) {
-      this.abort(err)
-    }
-  }
-
-  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-    try {
-      return this.handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage)
-    } catch (err) {
-      this.abort(err)
-      return false
-    }
-  }
-
-  onData(chunk) {
-    try {
-      return this.handler.onData?.(chunk)
-    } catch (err) {
-      this.abort(err)
-      return false
-    }
-  }
-
-  onComplete(rawTrailers) {
-    try {
-      return this.handler.onComplete?.(rawTrailers)
-    } catch (err) {
-      this.abort(err)
-      return false
-    }
-  }
-
-  onError(err) {
-    return this.handler.onError?.(err)
-  }
-}
-
-module.exports = (dispatch) => (opts, handler) => dispatch(opts, new Handler(opts, { handler }))