@nxtedition/lib 15.0.28 → 15.0.30

package/lib/undici/index.js

@@ -74,6 +74,7 @@ const dispatchers = {
   responseRetry: require('./interceptor/response-retry.js'),
   signal: require('./interceptor/signal.js'),
   proxy: require('./interceptor/proxy.js'),
+  cache: require('./interceptor/cache.js'),
 }
 
 async function request(urlOrOpts, opts = {}) {
@@ -120,6 +121,18 @@ async function request(urlOrOpts, opts = {}) {
     logger: opts.logger,
   }
 
+  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) => {
@@ -136,6 +149,7 @@ async function request(urlOrOpts, opts = {}) {
     dispatch = dispatchers.redirect(dispatch)
     dispatch = dispatchers.signal(dispatch)
     dispatch = dispatchers.proxy(dispatch)
+    dispatch = dispatchers.cache(dispatch)
 
     dispatch(opts, {
       resolve,

package/lib/undici/interceptor/cache.js

@@ -0,0 +1,197 @@
+import assert from 'node:assert'
+import { LRUCache } from 'lru-cache'
+import cacheControlParser from '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)
+  }
+
+  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/log.js

@@ -1,5 +1,6 @@
 const { parseHeaders } = require('../../../http.js')
 const xuid = require('xuid')
+const { performance } = require('perf_hooks')
 
 class Handler {
   constructor(opts, { handler }) {
@@ -9,10 +10,12 @@ class Handler {
     this.aborted = false
     this.logger = opts.logger.child({ ureq: { id: opts.id } })
     this.pos = 0
+    this.startTime = 0
   }
 
   onConnect(abort) {
     this.abort = abort
+    this.startTime = performance.now()
     this.logger.debug({ ureq: this.opts }, 'upstream request started')
     this.handler.onConnect?.((reason) => {
       this.aborted = true
@@ -26,7 +29,10 @@ class Handler {
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage) {
     this.logger.debug(
-      { ures: { statusCode, headers: parseHeaders(rawHeaders) } },
+      {
+        ures: { statusCode, headers: parseHeaders(rawHeaders) },
+        elapsedTime: this.startTime - performance.now(),
+      },
       'upstream request response',
     )
     return this.handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage)
@@ -38,15 +44,24 @@ class Handler {
   }
 
   onComplete(rawTrailers) {
-    this.logger.debug({ bytesRead: this.pos }, 'upstream request completed')
+    this.logger.debug(
+      { bytesRead: this.pos, elapsedTime: this.startTime - performance.now() },
+      'upstream request completed',
+    )
     return this.handler.onComplete?.(rawTrailers)
   }
 
   onError(err) {
     if (this.aborted) {
-      this.logger.debug({ bytesRead: this.pos, err }, 'upstream request aborted')
+      this.logger.debug(
+        { bytesRead: this.pos, elapsedTime: this.startTime - performance.now(), err },
+        'upstream request aborted',
+      )
     } else {
-      this.logger.error({ bytesRead: this.pos, err }, 'upstream request failed')
+      this.logger.error(
+        { bytesRead: this.pos, elapsedTime: this.startTime - performance.now(), err },
+        'upstream request failed',
+      )
     }
     return this.handler.onError?.(err)
   }

package/lib/undici/interceptor/proxy.js

@@ -4,32 +4,11 @@ const net = require('net')
 class Handler {
   constructor(opts, { handler }) {
     this.handler = handler
-    this.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
-        },
-        {},
-      ),
-    }
-    this.abort = null
-    this.aborted = false
+    this.opts = opts
   }
 
   onConnect(abort) {
-    this.abort = abort
-    this.handler.onConnect?.((reason) => {
-      this.aborted = true
-      this.abort(reason)
-    })
+    return this.handler.onConnect?.(abort)
   }
 
   onBodySent(chunk) {
@@ -70,8 +49,30 @@ class Handler {
   }
 }
 
-module.exports = (dispatch) => (opts, handler) =>
-  opts.proxy ? dispatch(opts, new Handler(opts, { handler })) : dispatch(opts, handler)
+module.exports = (dispatch) => (opts, handler) => {
+  if (!opts.proxy) {
+    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
+      },
+      {},
+    ),
+  }
+
+  return dispatch(opts, new Handler(opts, { handler }))
+}
 
 // This expression matches hop-by-hop headers.
 // These headers are meaningful only for a single transport-level connection,

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

@@ -136,6 +136,7 @@ class Handler {
       ...this.opts,
       headers: {
         ...this.opts.headers,
+        'if-match': this.etag,
         range: `bytes=${this.pos}-${this.end ?? ''}`,
       },
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "15.0.28",
+  "version": "15.0.30",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "files": [
@@ -9,7 +9,7 @@
     "rxjs/*",
     "util/*",
     "lib/*",
-    "undici/*",
+    "undici.js",
     "http-client.js",
     "subtract-ranges.js",
     "serializers.js",

package/undici.js

@@ -0,0 +1 @@
+module.exports = require('./lib/undici/index.js')