@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/undici/lib/interceptor/dns.js

@@ -3,146 +3,16 @@ const { isIP } = require('node:net')
 const { lookup } = require('node:dns')
 const DecoratorHandler = require('../handler/decorator-handler')
 const { InvalidArgumentError, InformationalError } = require('../core/errors')
-const { kRequestOrigin } = require('../core/symbols')
 const maxInt = Math.pow(2, 31) - 1
 
-function hasSafeIterator (headers) {
-  const prototype = Object.getPrototypeOf(headers)
-  const ownIterator = Object.hasOwn(headers, Symbol.iterator)
-  return ownIterator || (prototype != null && prototype !== Object.prototype && typeof headers[Symbol.iterator] === 'function')
-}
-
-function isHostHeader (key) {
-  return typeof key === 'string' && key.toLowerCase() === 'host'
-}
-
-function normalizeHeaders (headers) {
-  if (headers == null) {
-    return null
-  }
-
-  if (Array.isArray(headers)) {
-    if (headers.length === 0 || !Array.isArray(headers[0])) {
-      return headers
-    }
-
-    const normalized = []
-    for (const header of headers) {
-      if (Array.isArray(header) && header.length === 2) {
-        normalized.push(header[0], header[1])
-      } else {
-        normalized.push(header)
-      }
-    }
-
-    return normalized
-  }
-
-  if (typeof headers === 'object' && hasSafeIterator(headers)) {
-    const normalized = []
-    for (const header of headers) {
-      if (Array.isArray(header) && header.length === 2) {
-        normalized.push(header[0], header[1])
-      } else {
-        normalized.push(header)
-      }
-    }
-
-    return normalized
-  }
-
-  return headers
-}
-
-function hasHostHeader (headers) {
-  if (headers == null) {
-    return false
-  }
-
-  if (Array.isArray(headers)) {
-    if (headers.length === 0) {
-      return false
-    }
-
-    for (let i = 0; i < headers.length; i += 2) {
-      if (isHostHeader(headers[i])) {
-        return true
-      }
-    }
-
-    return false
-  }
-
-  if (typeof headers === 'object') {
-    for (const key in headers) {
-      if (isHostHeader(key)) {
-        return true
-      }
-    }
-  }
-
-  return false
-}
-
-function withHostHeader (host, headers) {
-  const normalizedHeaders = normalizeHeaders(headers)
-
-  if (hasHostHeader(normalizedHeaders)) {
-    return normalizedHeaders
-  }
-
-  if (Array.isArray(normalizedHeaders)) {
-    return ['host', host, ...normalizedHeaders]
-  }
-
-  if (normalizedHeaders && typeof normalizedHeaders === 'object') {
-    return {
-      host,
-      ...normalizedHeaders
-    }
-  }
-
-  return { host }
-}
-
-class DNSStorage {
-  #maxItems = 0
-  #records = new Map()
-
-  constructor (opts) {
-    this.#maxItems = opts.maxItems
-  }
-
-  get size () {
-    return this.#records.size
-  }
-
-  get (hostname) {
-    return this.#records.get(hostname) ?? null
-  }
-
-  set (hostname, records) {
-    this.#records.set(hostname, records)
-  }
-
-  delete (hostname) {
-    this.#records.delete(hostname)
-  }
-
-  // Delegate to storage decide can we do more lookups or not
-  full () {
-    return this.size >= this.#maxItems
-  }
-}
-
 class DNSInstance {
   #maxTTL = 0
   #maxItems = 0
+  #records = new Map()
   dualStack = true
   affinity = null
   lookup = null
   pick = null
-  storage = null
 
   constructor (opts) {
     this.#maxTTL = opts.maxTTL
@@ -151,15 +21,18 @@ class DNSInstance {
     this.affinity = opts.affinity
     this.lookup = opts.lookup ?? this.#defaultLookup
     this.pick = opts.pick ?? this.#defaultPick
-    this.storage = opts.storage ?? new DNSStorage(opts)
+  }
+
+  get full () {
+    return this.#records.size === this.#maxItems
   }
 
   runLookup (origin, opts, cb) {
-    const ips = this.storage.get(origin.hostname)
+    const ips = this.#records.get(origin.hostname)
 
     // If full, we just return the origin
-    if (ips == null && this.storage.full()) {
-      cb(null, origin)
+    if (ips == null && this.full) {
+      cb(null, origin.origin)
       return
     }
 
@@ -182,7 +55,7 @@ class DNSInstance {
         }
 
         this.setRecords(origin, addresses)
-        const records = this.storage.get(origin.hostname)
+        const records = this.#records.get(origin.hostname)
 
         const ip = this.pick(
           origin,
@@ -201,9 +74,9 @@ class DNSInstance {
 
         cb(
           null,
-          new URL(`${origin.protocol}//${
+          `${origin.protocol}//${
             ip.family === 6 ? `[${ip.address}]` : ip.address
-          }${port}`)
+          }${port}`
         )
       })
     } else {
@@ -216,7 +89,7 @@ class DNSInstance {
 
       // If no IPs we lookup - deleting old records
       if (ip == null) {
-        this.storage.delete(origin.hostname)
+        this.#records.delete(origin.hostname)
         this.runLookup(origin, opts, cb)
         return
       }
@@ -232,9 +105,9 @@ class DNSInstance {
 
       cb(
         null,
-        new URL(`${origin.protocol}//${
+        `${origin.protocol}//${
           ip.family === 6 ? `[${ip.address}]` : ip.address
-        }${port}`)
+        }${port}`
       )
     }
   }
@@ -319,48 +192,14 @@ class DNSInstance {
     return ip
   }
 
-  pickFamily (origin, ipFamily) {
-    const records = this.storage.get(origin.hostname)?.records
-    if (!records) {
-      return null
-    }
-
-    const family = records[ipFamily]
-    if (!family) {
-      return null
-    }
-
-    if (family.offset == null || family.offset === maxInt) {
-      family.offset = 0
-    } else {
-      family.offset++
-    }
-
-    const position = family.offset % family.ips.length
-    const ip = family.ips[position] ?? null
-    if (ip == null) {
-      return ip
-    }
-
-    if (Date.now() - ip.timestamp > ip.ttl) { // record TTL is already in ms
-      // We delete expired records
-      // It is possible that they have different TTL, so we manage them individually
-      family.ips.splice(position, 1)
-    }
-
-    return ip
-  }
-
   setRecords (origin, addresses) {
     const timestamp = Date.now()
     const records = { records: { 4: null, 6: null } }
-    let minTTL = this.#maxTTL
     for (const record of addresses) {
       record.timestamp = timestamp
       if (typeof record.ttl === 'number') {
         // The record TTL is expected to be in ms
         record.ttl = Math.min(record.ttl, this.#maxTTL)
-        minTTL = Math.min(minTTL, record.ttl)
       } else {
         record.ttl = this.#maxTTL
       }
@@ -371,12 +210,7 @@ class DNSInstance {
       records.records[record.family] = familyRecords
     }
 
-    // We provide a default TTL if external storage will be used without TTL per record-level support
-    this.storage.set(origin.hostname, records, { ttl: minTTL })
-  }
-
-  deleteRecords (origin) {
-    this.storage.delete(origin.hostname)
+    this.#records.set(origin.hostname, records)
   }
 
   getHandler (meta, opts) {
@@ -388,72 +222,49 @@ class DNSDispatchHandler extends DecoratorHandler {
   #state = null
   #opts = null
   #dispatch = null
+  #handler = null
   #origin = null
-  #controller = null
-  #newOrigin = null
-  #firstTry = true
 
-  constructor (state, { origin, handler, dispatch, newOrigin }, opts) {
+  constructor (state, { origin, handler, dispatch }, opts) {
     super(handler)
     this.#origin = origin
-    this.#newOrigin = newOrigin
+    this.#handler = handler
     this.#opts = { ...opts }
     this.#state = state
     this.#dispatch = dispatch
   }
 
-  onResponseError (controller, err) {
+  onError (err) {
     switch (err.code) {
       case 'ETIMEDOUT':
       case 'ECONNREFUSED': {
         if (this.#state.dualStack) {
-          if (!this.#firstTry) {
-            super.onResponseError(controller, err)
-            return
-          }
-          this.#firstTry = false
-
-          // Pick an ip address from the other family
-          const otherFamily = this.#newOrigin.hostname[0] === '[' ? 4 : 6
-          const ip = this.#state.pickFamily(this.#origin, otherFamily)
-          if (ip == null) {
-            super.onResponseError(controller, err)
-            return
-          }
+          // We delete the record and retry
+          this.#state.runLookup(this.#origin, this.#opts, (err, newOrigin) => {
+            if (err) {
+              return this.#handler.onError(err)
+            }
 
-          let port
-          if (typeof ip.port === 'number') {
-            port = `:${ip.port}`
-          } else if (this.#origin.port !== '') {
-            port = `:${this.#origin.port}`
-          } else {
-            port = ''
-          }
+            const dispatchOpts = {
+              ...this.#opts,
+              origin: newOrigin
+            }
 
-          const dispatchOpts = {
-            ...this.#opts,
-            origin: `${this.#origin.protocol}//${
-              ip.family === 6 ? `[${ip.address}]` : ip.address
-            }${port}`,
-            [kRequestOrigin]: this.#opts[kRequestOrigin] === undefined
-              ? this.#origin
-              : this.#opts[kRequestOrigin],
-            headers: withHostHeader(this.#origin.host, this.#opts.headers)
-          }
-          this.#dispatch(dispatchOpts, this)
+            this.#dispatch(dispatchOpts, this)
+          })
+
+          // if dual-stack disabled, we error out
           return
         }
 
-        // if dual-stack disabled, we error out
-        super.onResponseError(controller, err)
-        break
+        this.#handler.onError(err)
+        return
       }
       case 'ENOTFOUND':
-        this.#state.deleteRecords(this.#origin)
-        super.onResponseError(controller, err)
-        break
+        this.#state.deleteRecord(this.#origin)
+      // eslint-disable-next-line no-fallthrough
       default:
-        super.onResponseError(controller, err)
+        this.#handler.onError(err)
         break
     }
   }
@@ -506,17 +317,6 @@ module.exports = interceptorOpts => {
     throw new InvalidArgumentError('Invalid pick. Must be a function')
   }
 
-  if (
-    interceptorOpts?.storage != null &&
-    (typeof interceptorOpts?.storage?.get !== 'function' ||
-      typeof interceptorOpts?.storage?.set !== 'function' ||
-      typeof interceptorOpts?.storage?.full !== 'function' ||
-      typeof interceptorOpts?.storage?.delete !== 'function'
-    )
-  ) {
-    throw new InvalidArgumentError('Invalid storage. Must be a object with methods: { get, set, full, delete }')
-  }
-
   const dualStack = interceptorOpts?.dualStack ?? true
   let affinity
   if (dualStack) {
@@ -531,18 +331,13 @@ module.exports = interceptorOpts => {
     pick: interceptorOpts?.pick ?? null,
     dualStack,
     affinity,
-    maxItems: interceptorOpts?.maxItems ?? Infinity,
-    storage: interceptorOpts?.storage
+    maxItems: interceptorOpts?.maxItems ?? Infinity
   }
 
   const instance = new DNSInstance(opts)
 
   return dispatch => {
     return function dnsInterceptor (origDispatchOpts, handler) {
-      if (origDispatchOpts.origin == null) {
-        return dispatch(origDispatchOpts, handler)
-      }
-
       const origin =
         origDispatchOpts.origin.constructor === URL
           ? origDispatchOpts.origin
@@ -554,25 +349,23 @@ module.exports = interceptorOpts => {
 
       instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => {
         if (err) {
-          return handler.onResponseError(null, err)
+          return handler.onError(err)
         }
 
-        const dispatchOpts = {
+        let dispatchOpts = null
+        dispatchOpts = {
           ...origDispatchOpts,
           servername: origin.hostname, // For SNI on TLS
-          origin: newOrigin.origin,
-          [kRequestOrigin]: origDispatchOpts[kRequestOrigin] === undefined
-            ? origin
-            : origDispatchOpts[kRequestOrigin],
-          headers: withHostHeader(origin.host, origDispatchOpts.headers)
+          origin: newOrigin,
+          headers: {
+            host: origin.hostname,
+            ...origDispatchOpts.headers
+          }
         }
 
         dispatch(
           dispatchOpts,
-          instance.getHandler(
-            { origin, dispatch, handler, newOrigin },
-            origDispatchOpts
-          )
+          instance.getHandler({ origin, dispatch, handler }, origDispatchOpts)
         )
       })
 

package/node_modules/undici/lib/interceptor/dump.js

@@ -1,38 +1,43 @@
 'use strict'
 
+const util = require('../core/util')
 const { InvalidArgumentError, RequestAbortedError } = require('../core/errors')
 const DecoratorHandler = require('../handler/decorator-handler')
 
 class DumpHandler extends DecoratorHandler {
   #maxSize = 1024 * 1024
+  #abort = null
   #dumped = false
+  #aborted = false
   #size = 0
-  aborted = false
-  reason = false
+  #reason = null
+  #handler = null
+
+  constructor ({ maxSize }, handler) {
+    super(handler)
 
-  constructor ({ maxSize, signal }, handler) {
     if (maxSize != null && (!Number.isFinite(maxSize) || maxSize < 1)) {
       throw new InvalidArgumentError('maxSize must be a number greater than 0')
     }
 
-    super(handler)
-
     this.#maxSize = maxSize ?? this.#maxSize
-    // this.#handler = handler
+    this.#handler = handler
   }
 
-  #abort (reason) {
-    this.aborted = true
-    this.reason = reason
-  }
+  onConnect (abort) {
+    this.#abort = abort
 
-  onRequestStart (controller, context) {
-    controller.abort = this.#abort.bind(this)
+    this.#handler.onConnect(this.#customAbort.bind(this))
+  }
 
-    return super.onRequestStart(controller, context)
+  #customAbort (reason) {
+    this.#aborted = true
+    this.#reason = reason
   }
 
-  onResponseStart (controller, statusCode, headers, statusMessage) {
+  // TODO: will require adjustment after new hooks are out
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const headers = util.parseHeaders(rawHeaders)
     const contentLength = headers['content-length']
 
     if (contentLength != null && contentLength > this.#maxSize) {
@@ -43,40 +48,55 @@ class DumpHandler extends DecoratorHandler {
       )
     }
 
-    if (this.aborted === true) {
+    if (this.#aborted) {
       return true
     }
 
-    return super.onResponseStart(controller, statusCode, headers, statusMessage)
+    return this.#handler.onHeaders(
+      statusCode,
+      rawHeaders,
+      resume,
+      statusMessage
+    )
   }
 
-  onResponseError (controller, err) {
-    super.onResponseError(controller, this.aborted === true ? this.reason : err)
+  onError (err) {
+    if (this.#dumped) {
+      return
+    }
+
+    err = this.#reason ?? err
+
+    this.#handler.onError(err)
   }
 
-  onResponseData (controller, chunk) {
+  onData (chunk) {
     this.#size = this.#size + chunk.length
 
-    if (this.#size > this.#maxSize) {
-      throw new RequestAbortedError(
-        `Response size (${this.#size}) larger than maxSize (${this.#maxSize})`
-      )
-    }
-
-    if (this.#size === this.#maxSize) {
+    if (this.#size >= this.#maxSize) {
       this.#dumped = true
+
+      if (this.#aborted) {
+        this.#handler.onError(this.#reason)
+      } else {
+        this.#handler.onComplete([])
+      }
     }
 
     return true
   }
 
-  onResponseEnd (controller, trailers) {
-    if (this.aborted === true) {
-      super.onResponseError(controller, this.reason)
+  onComplete (trailers) {
+    if (this.#dumped) {
       return
     }
 
-    super.onResponseEnd(controller, this.#dumped ? {} : trailers)
+    if (this.#aborted) {
+      this.#handler.onError(this.reason)
+      return
+    }
+
+    this.#handler.onComplete(trailers)
   }
 }
 
@@ -87,9 +107,13 @@ function createDumpInterceptor (
 ) {
   return dispatch => {
     return function Intercept (opts, handler) {
-      const { dumpMaxSize = defaultMaxSize } = opts
+      const { dumpMaxSize = defaultMaxSize } =
+        opts
 
-      const dumpHandler = new DumpHandler({ maxSize: dumpMaxSize, signal: opts.signal }, handler)
+      const dumpHandler = new DumpHandler(
+        { maxSize: dumpMaxSize },
+        handler
+      )
 
       return dispatch(opts, dumpHandler)
     }

package/node_modules/undici/lib/interceptor/redirect-interceptor.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const RedirectHandler = require('../handler/redirect-handler')
+
+function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections }) {
+  return (dispatch) => {
+    return function Intercept (opts, handler) {
+      const { maxRedirections = defaultMaxRedirections } = opts
+
+      if (!maxRedirections) {
+        return dispatch(opts, handler)
+      }
+
+      const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler)
+      opts = { ...opts, maxRedirections: 0 } // Stop sub dispatcher from also redirecting.
+      return dispatch(opts, redirectHandler)
+    }
+  }
+}
+
+module.exports = createRedirectInterceptor

package/node_modules/undici/lib/interceptor/redirect.js

@@ -1,21 +1,24 @@
 'use strict'
-
 const RedirectHandler = require('../handler/redirect-handler')
 
-function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections, throwOnMaxRedirect: defaultThrowOnMaxRedirect, stripHeadersOnRedirect: defaultStripHeadersOnRedirect, stripHeadersOnCrossOriginRedirect: defaultStripHeadersOnCrossOriginRedirect } = {}) {
-  return (dispatch) => {
-    return function Intercept (opts, handler) {
-      const { maxRedirections = defaultMaxRedirections, throwOnMaxRedirect = defaultThrowOnMaxRedirect, stripHeadersOnRedirect = defaultStripHeadersOnRedirect, stripHeadersOnCrossOriginRedirect = defaultStripHeadersOnCrossOriginRedirect, ...rest } = opts
+module.exports = opts => {
+  const globalMaxRedirections = opts?.maxRedirections
+  return dispatch => {
+    return function redirectInterceptor (opts, handler) {
+      const { maxRedirections = globalMaxRedirections, ...baseOpts } = opts
 
-      if (maxRedirections == null || maxRedirections === 0) {
+      if (!maxRedirections) {
         return dispatch(opts, handler)
       }
 
-      const dispatchOpts = { ...rest, throwOnMaxRedirect, stripHeadersOnRedirect, stripHeadersOnCrossOriginRedirect } // Stop sub dispatcher from also redirecting.
-      const redirectHandler = new RedirectHandler(dispatch, maxRedirections, dispatchOpts, handler)
-      return dispatch(dispatchOpts, redirectHandler)
+      const redirectHandler = new RedirectHandler(
+        dispatch,
+        maxRedirections,
+        opts,
+        handler
+      )
+
+      return dispatch(baseOpts, redirectHandler)
     }
   }
 }
-
-module.exports = createRedirectInterceptor