undici 7.0.0-alpha.7 → 7.0.0-alpha.8

package/lib/util/cache.js

@@ -96,36 +96,27 @@ function assertCacheValue (value) {
 /**
  * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-cache-control
  * @see https://www.iana.org/assignments/http-cache-directives/http-cache-directives.xhtml
- *
- * @typedef {{
- *   'max-stale'?: number;
- *   'min-fresh'?: number;
- *   'max-age'?: number;
- *   's-maxage'?: number;
- *   'stale-while-revalidate'?: number;
- *   'stale-if-error'?: number;
- *   public?: true;
- *   private?: true | string[];
- *   'no-store'?: true;
- *   'no-cache'?: true | string[];
- *   'must-revalidate'?: true;
- *   'proxy-revalidate'?: true;
- *   immutable?: true;
- *   'no-transform'?: true;
- *   'must-understand'?: true;
- *   'only-if-cached'?: true;
- * }} CacheControlDirectives
- *
+
  * @param {string | string[]} header
- * @returns {CacheControlDirectives}
+ * @returns {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives}
  */
 function parseCacheControlHeader (header) {
   /**
-   * @type {import('../util/cache.js').CacheControlDirectives}
+   * @type {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives}
    */
   const output = {}
 
-  const directives = Array.isArray(header) ? header : header.split(',')
+  let directives
+  if (Array.isArray(header)) {
+    directives = []
+
+    for (const directive of header) {
+      directives.push(...directive.split(','))
+    }
+  } else {
+    directives = header.split(',')
+  }
+
   for (let i = 0; i < directives.length; i++) {
     const directive = directives[i].toLowerCase()
     const keyValueDelimiter = directive.indexOf('=')
@@ -133,10 +124,8 @@ function parseCacheControlHeader (header) {
     let key
     let value
     if (keyValueDelimiter !== -1) {
-      key = directive.substring(0, keyValueDelimiter).trim()
-      value = directive
-        .substring(keyValueDelimiter + 1)
-        .trim()
+      key = directive.substring(0, keyValueDelimiter).trimStart()
+      value = directive.substring(keyValueDelimiter + 1)
     } else {
       key = directive.trim()
     }
@@ -148,16 +137,28 @@ function parseCacheControlHeader (header) {
       case 's-maxage':
       case 'stale-while-revalidate':
       case 'stale-if-error': {
-        if (value === undefined) {
+        if (value === undefined || value[0] === ' ') {
           continue
         }
 
+        if (
+          value.length >= 2 &&
+          value[0] === '"' &&
+          value[value.length - 1] === '"'
+        ) {
+          value = value.substring(1, value.length - 1)
+        }
+
         const parsedValue = parseInt(value, 10)
         // eslint-disable-next-line no-self-compare
         if (parsedValue !== parsedValue) {
           continue
         }
 
+        if (key === 'max-age' && key in output && output[key] >= parsedValue) {
+          continue
+        }
+
         output[key] = parsedValue
 
         break
@@ -206,11 +207,19 @@ function parseCacheControlHeader (header) {
                 headers[headers.length - 1] = lastHeader
               }
 
-              output[key] = headers
+              if (key in output) {
+                output[key] = output[key].concat(headers)
+              } else {
+                output[key] = headers
+              }
             }
           } else {
             // Something like `no-cache=some-header`
-            output[key] = [value]
+            if (key in output) {
+              output[key] = output[key].concat(value)
+            } else {
+              output[key] = [value]
+            }
           }
 
           break
@@ -248,7 +257,7 @@ function parseCacheControlHeader (header) {
  * @returns {Record<string, string | string[]>}
  */
 function parseVaryHeader (varyHeader, headers) {
-  if (typeof varyHeader === 'string' && varyHeader === '*') {
+  if (typeof varyHeader === 'string' && varyHeader.includes('*')) {
     return headers
   }
 
@@ -262,6 +271,8 @@ function parseVaryHeader (varyHeader, headers) {
 
     if (headers[trimmedHeader]) {
       output[trimmedHeader] = headers[trimmedHeader]
+    } else {
+      return undefined
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "7.0.0-alpha.7",
+  "version": "7.0.0-alpha.8",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -73,6 +73,7 @@
     "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp -p \"test/busboy/*.js\"",
     "test:cache": "borp -p \"test/cache/*.js\"",
+    "test:sqlite": "NODE_OPTIONS=--experimental-sqlite borp -p \"test/cache-interceptor/*.js\"",
     "test:cache-interceptor": "borp -p \"test/cache-interceptor/*.js\"",
     "test:cookies": "borp -p \"test/cookie/*.js\"",
     "test:eventsource": "npm run build:node && borp --expose-gc -p \"test/eventsource/*.js\"",
@@ -110,7 +111,7 @@
     "@sinonjs/fake-timers": "^12.0.0",
     "@types/node": "^18.19.50",
     "abort-controller": "^3.0.0",
-    "borp": "^0.18.0",
+    "borp": "^0.19.0",
     "c8": "^10.0.0",
     "cross-env": "^7.0.3",
     "dns-packet": "^5.4.0",
@@ -128,7 +129,7 @@
     "ws": "^8.11.0"
   },
   "engines": {
-    "node": ">=18.17"
+    "node": ">=20.18.1"
   },
   "tsd": {
     "directory": "test/types",

package/types/cache-interceptor.d.ts

@@ -7,6 +7,10 @@ declare namespace CacheHandler {
 
   export interface CacheHandlerOptions {
     store: CacheStore
+
+    cacheByDefault?: number
+
+    type?: CacheOptions['type']
   }
 
   export interface CacheOptions {
@@ -20,6 +24,39 @@ declare namespace CacheHandler {
      * @see https://www.rfc-editor.org/rfc/rfc9110#section-9.2.1
      */
     methods?: CacheMethods[]
+
+    /**
+     * RFC9111 allows for caching responses that we aren't explicitly told to
+     *  cache or to not cache.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#section-3-5
+     * @default undefined
+     */
+    cacheByDefault?: number
+
+    /**
+     * TODO docs
+     * @default 'shared'
+     */
+    type?: 'shared' | 'private'
+  }
+
+  export interface CacheControlDirectives {
+    'max-stale'?: number;
+    'min-fresh'?: number;
+    'max-age'?: number;
+    's-maxage'?: number;
+    'stale-while-revalidate'?: number;
+    'stale-if-error'?: number;
+    public?: true;
+    private?: true | string[];
+    'no-store'?: true;
+    'no-cache'?: true | string[];
+    'must-revalidate'?: true;
+    'proxy-revalidate'?: true;
+    immutable?: true;
+    'no-transform'?: true;
+    'must-understand'?: true;
+    'only-if-cached'?: true;
   }
 
   export interface CacheKey {
@@ -35,6 +72,7 @@ declare namespace CacheHandler {
     headers: Record<string, string | string[]>
     vary?: Record<string, string | string[]>
     etag?: string
+    cacheControlDirectives?: CacheControlDirectives
     cachedAt: number
     staleAt: number
     deleteAt: number
@@ -50,8 +88,10 @@ declare namespace CacheHandler {
     statusCode: number
     statusMessage: string
     headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[]>
     etag?: string
     body: null | Readable | Iterable<Buffer> | AsyncIterable<Buffer> | Buffer | Iterable<string> | AsyncIterable<string> | string
+    cacheControlDirectives: CacheControlDirectives,
     cachedAt: number
     staleAt: number
     deleteAt: number