@nocobase/plugin-idp-oauth 2.2.17 → 2.2.19

package/dist/node_modules/undici/lib/handler/redirect-handler.js

@@ -1,238 +0,0 @@
-'use strict'
-
-const util = require('../core/util')
-const { kBodyUsed } = require('../core/symbols')
-const assert = require('node:assert')
-const { InvalidArgumentError } = require('../core/errors')
-const EE = require('node:events')
-
-const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
-
-const kBody = Symbol('body')
-
-const noop = () => {}
-
-class BodyAsyncIterable {
-  constructor (body) {
-    this[kBody] = body
-    this[kBodyUsed] = false
-  }
-
-  async * [Symbol.asyncIterator] () {
-    assert(!this[kBodyUsed], 'disturbed')
-    this[kBodyUsed] = true
-    yield * this[kBody]
-  }
-}
-
-class RedirectHandler {
-  static buildDispatch (dispatcher, maxRedirections) {
-    if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
-      throw new InvalidArgumentError('maxRedirections must be a positive number')
-    }
-
-    const dispatch = dispatcher.dispatch.bind(dispatcher)
-    return (opts, originalHandler) => dispatch(opts, new RedirectHandler(dispatch, maxRedirections, opts, originalHandler))
-  }
-
-  constructor (dispatch, maxRedirections, opts, handler) {
-    if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
-      throw new InvalidArgumentError('maxRedirections must be a positive number')
-    }
-
-    this.dispatch = dispatch
-    this.location = null
-    const { maxRedirections: _, ...cleanOpts } = opts
-    this.opts = cleanOpts // opts must be a copy, exclude maxRedirections
-    this.maxRedirections = maxRedirections
-    this.handler = handler
-    this.history = []
-
-    if (util.isStream(this.opts.body)) {
-      // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
-      // so that it can be dispatched again?
-      // TODO (fix): Do we need 100-expect support to provide a way to do this properly?
-      if (util.bodyLength(this.opts.body) === 0) {
-        this.opts.body
-          .on('data', function () {
-            assert(false)
-          })
-      }
-
-      if (typeof this.opts.body.readableDidRead !== 'boolean') {
-        this.opts.body[kBodyUsed] = false
-        EE.prototype.on.call(this.opts.body, 'data', function () {
-          this[kBodyUsed] = true
-        })
-      }
-    } else if (this.opts.body && typeof this.opts.body.pipeTo === 'function') {
-      // TODO (fix): We can't access ReadableStream internal state
-      // to determine whether or not it has been disturbed. This is just
-      // a workaround.
-      this.opts.body = new BodyAsyncIterable(this.opts.body)
-    } else if (
-      this.opts.body &&
-      typeof this.opts.body !== 'string' &&
-      !ArrayBuffer.isView(this.opts.body) &&
-      util.isIterable(this.opts.body) &&
-      !util.isFormDataLike(this.opts.body)
-    ) {
-      // TODO: Should we allow re-using iterable if !this.opts.idempotent
-      // or through some other flag?
-      this.opts.body = new BodyAsyncIterable(this.opts.body)
-    }
-  }
-
-  onRequestStart (controller, context) {
-    this.handler.onRequestStart?.(controller, { ...context, history: this.history })
-  }
-
-  onRequestUpgrade (controller, statusCode, headers, socket) {
-    this.handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
-  }
-
-  onResponseStart (controller, statusCode, headers, statusMessage) {
-    if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
-      throw new Error('max redirects')
-    }
-
-    // https://tools.ietf.org/html/rfc7231#section-6.4.2
-    // https://fetch.spec.whatwg.org/#http-redirect-fetch
-    // In case of HTTP 301 or 302 with POST, change the method to GET
-    if ((statusCode === 301 || statusCode === 302) && this.opts.method === 'POST') {
-      this.opts.method = 'GET'
-      if (util.isStream(this.opts.body)) {
-        util.destroy(this.opts.body.on('error', noop))
-      }
-      this.opts.body = null
-    }
-
-    // https://tools.ietf.org/html/rfc7231#section-6.4.4
-    // In case of HTTP 303, always replace method to be either HEAD or GET
-    if (statusCode === 303 && this.opts.method !== 'HEAD') {
-      this.opts.method = 'GET'
-      if (util.isStream(this.opts.body)) {
-        util.destroy(this.opts.body.on('error', noop))
-      }
-      this.opts.body = null
-    }
-
-    this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) || redirectableStatusCodes.indexOf(statusCode) === -1
-      ? null
-      : headers.location
-
-    if (this.opts.origin) {
-      this.history.push(new URL(this.opts.path, this.opts.origin))
-    }
-
-    if (!this.location) {
-      this.handler.onResponseStart?.(controller, statusCode, headers, statusMessage)
-      return
-    }
-
-    const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)))
-    const path = search ? `${pathname}${search}` : pathname
-
-    // Check for redirect loops by seeing if we've already visited this URL in our history
-    // This catches the case where Client/Pool try to handle cross-origin redirects but fail
-    // and keep redirecting to the same URL in an infinite loop
-    const redirectUrlString = `${origin}${path}`
-    for (const historyUrl of this.history) {
-      if (historyUrl.toString() === redirectUrlString) {
-        throw new InvalidArgumentError(`Redirect loop detected. Cannot redirect to ${origin}. This typically happens when using a Client or Pool with cross-origin redirects. Use an Agent for cross-origin redirects.`)
-      }
-    }
-
-    // Remove headers referring to the original URL.
-    // By default it is Host only, unless it's a 303 (see below), which removes also all Content-* headers.
-    // https://tools.ietf.org/html/rfc7231#section-6.4
-    this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin)
-    this.opts.path = path
-    this.opts.origin = origin
-    this.opts.query = null
-  }
-
-  onResponseData (controller, chunk) {
-    if (this.location) {
-      /*
-        https://tools.ietf.org/html/rfc7231#section-6.4
-
-        TLDR: undici always ignores 3xx response bodies.
-
-        Redirection is used to serve the requested resource from another URL, so it assumes that
-        no body is generated (and thus can be ignored). Even though generating a body is not prohibited.
-
-        For status 301, 302, 303, 307 and 308 (the latter from RFC 7238), the specs mention that the body usually
-        (which means it's optional and not mandated) contain just an hyperlink to the value of
-        the Location response header, so the body can be ignored safely.
-
-        For status 300, which is "Multiple Choices", the spec mentions both generating a Location
-        response header AND a response body with the other possible location to follow.
-        Since the spec explicitly chooses not to specify a format for such body and leave it to
-        servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it.
-      */
-    } else {
-      this.handler.onResponseData?.(controller, chunk)
-    }
-  }
-
-  onResponseEnd (controller, trailers) {
-    if (this.location) {
-      /*
-        https://tools.ietf.org/html/rfc7231#section-6.4
-
-        TLDR: undici always ignores 3xx response trailers as they are not expected in case of redirections
-        and neither are useful if present.
-
-        See comment on onData method above for more detailed information.
-      */
-      this.dispatch(this.opts, this)
-    } else {
-      this.handler.onResponseEnd(controller, trailers)
-    }
-  }
-
-  onResponseError (controller, error) {
-    this.handler.onResponseError?.(controller, error)
-  }
-}
-
-// https://tools.ietf.org/html/rfc7231#section-6.4.4
-function shouldRemoveHeader (header, removeContent, unknownOrigin) {
-  if (header.length === 4) {
-    return util.headerNameToString(header) === 'host'
-  }
-  if (removeContent && util.headerNameToString(header).startsWith('content-')) {
-    return true
-  }
-  if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
-    const name = util.headerNameToString(header)
-    return name === 'authorization' || name === 'cookie' || name === 'proxy-authorization'
-  }
-  return false
-}
-
-// https://tools.ietf.org/html/rfc7231#section-6.4
-function cleanRequestHeaders (headers, removeContent, unknownOrigin) {
-  const ret = []
-  if (Array.isArray(headers)) {
-    for (let i = 0; i < headers.length; i += 2) {
-      if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
-        ret.push(headers[i], headers[i + 1])
-      }
-    }
-  } else if (headers && typeof headers === 'object') {
-    const entries = util.hasSafeIterator(headers) ? headers : Object.entries(headers)
-
-    for (const [key, value] of entries) {
-      if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
-        ret.push(key, value)
-      }
-    }
-  } else {
-    assert(headers == null, 'headers must be an object or an array')
-  }
-  return ret
-}
-
-module.exports = RedirectHandler

package/dist/node_modules/undici/lib/handler/retry-handler.js

@@ -1,394 +0,0 @@
-'use strict'
-const assert = require('node:assert')
-
-const { kRetryHandlerDefaultRetry } = require('../core/symbols')
-const { RequestRetryError } = require('../core/errors')
-const WrapHandler = require('./wrap-handler')
-const {
-  isDisturbed,
-  parseRangeHeader,
-  wrapRequestBody
-} = require('../core/util')
-
-function calculateRetryAfterHeader (retryAfter) {
-  const retryTime = new Date(retryAfter).getTime()
-  return isNaN(retryTime) ? 0 : retryTime - Date.now()
-}
-
-class RetryHandler {
-  constructor (opts, { dispatch, handler }) {
-    const { retryOptions, ...dispatchOpts } = opts
-    const {
-      // Retry scoped
-      retry: retryFn,
-      maxRetries,
-      maxTimeout,
-      minTimeout,
-      timeoutFactor,
-      // Response scoped
-      methods,
-      errorCodes,
-      retryAfter,
-      statusCodes,
-      throwOnError
-    } = retryOptions ?? {}
-
-    this.error = null
-    this.dispatch = dispatch
-    this.handler = WrapHandler.wrap(handler)
-    this.opts = { ...dispatchOpts, body: wrapRequestBody(opts.body) }
-    this.retryOpts = {
-      throwOnError: throwOnError ?? true,
-      retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry],
-      retryAfter: retryAfter ?? true,
-      maxTimeout: maxTimeout ?? 30 * 1000, // 30s,
-      minTimeout: minTimeout ?? 500, // .5s
-      timeoutFactor: timeoutFactor ?? 2,
-      maxRetries: maxRetries ?? 5,
-      // What errors we should retry
-      methods: methods ?? ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
-      // Indicates which errors to retry
-      statusCodes: statusCodes ?? [500, 502, 503, 504, 429],
-      // List of errors to retry
-      errorCodes: errorCodes ?? [
-        'ECONNRESET',
-        'ECONNREFUSED',
-        'ENOTFOUND',
-        'ENETDOWN',
-        'ENETUNREACH',
-        'EHOSTDOWN',
-        'EHOSTUNREACH',
-        'EPIPE',
-        'UND_ERR_SOCKET'
-      ]
-    }
-
-    this.retryCount = 0
-    this.retryCountCheckpoint = 0
-    this.headersSent = false
-    this.start = 0
-    this.end = null
-    this.etag = null
-  }
-
-  onResponseStartWithRetry (controller, statusCode, headers, statusMessage, err) {
-    if (this.retryOpts.throwOnError) {
-      // Preserve old behavior for status codes that are not eligible for retry
-      if (this.retryOpts.statusCodes.includes(statusCode) === false) {
-        this.headersSent = true
-        this.handler.onResponseStart?.(controller, statusCode, headers, statusMessage)
-      } else {
-        this.error = err
-      }
-
-      return
-    }
-
-    if (isDisturbed(this.opts.body)) {
-      this.headersSent = true
-      this.handler.onResponseStart?.(controller, statusCode, headers, statusMessage)
-      return
-    }
-
-    function shouldRetry (passedErr) {
-      if (passedErr) {
-        this.headersSent = true
-        this.handler.onResponseStart?.(controller, statusCode, headers, statusMessage)
-        controller.resume()
-        return
-      }
-
-      this.error = err
-      controller.resume()
-    }
-
-    controller.pause()
-    this.retryOpts.retry(
-      err,
-      {
-        state: { counter: this.retryCount },
-        opts: { retryOptions: this.retryOpts, ...this.opts }
-      },
-      shouldRetry.bind(this)
-    )
-  }
-
-  onRequestStart (controller, context) {
-    if (!this.headersSent) {
-      this.handler.onRequestStart?.(controller, context)
-    }
-  }
-
-  onRequestUpgrade (controller, statusCode, headers, socket) {
-    this.handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
-  }
-
-  static [kRetryHandlerDefaultRetry] (err, { state, opts }, cb) {
-    const { statusCode, code, headers } = err
-    const { method, retryOptions } = opts
-    const {
-      maxRetries,
-      minTimeout,
-      maxTimeout,
-      timeoutFactor,
-      statusCodes,
-      errorCodes,
-      methods
-    } = retryOptions
-    const { counter } = state
-
-    // Any code that is not a Undici's originated and allowed to retry
-    if (code && code !== 'UND_ERR_REQ_RETRY' && !errorCodes.includes(code)) {
-      cb(err)
-      return
-    }
-
-    // If a set of method are provided and the current method is not in the list
-    if (Array.isArray(methods) && !methods.includes(method)) {
-      cb(err)
-      return
-    }
-
-    // If a set of status code are provided and the current status code is not in the list
-    if (
-      statusCode != null &&
-      Array.isArray(statusCodes) &&
-      !statusCodes.includes(statusCode)
-    ) {
-      cb(err)
-      return
-    }
-
-    // If we reached the max number of retries
-    if (counter > maxRetries) {
-      cb(err)
-      return
-    }
-
-    let retryAfterHeader = headers?.['retry-after']
-    if (retryAfterHeader) {
-      retryAfterHeader = Number(retryAfterHeader)
-      retryAfterHeader = Number.isNaN(retryAfterHeader)
-        ? calculateRetryAfterHeader(headers['retry-after'])
-        : retryAfterHeader * 1e3 // Retry-After is in seconds
-    }
-
-    const retryTimeout =
-      retryAfterHeader > 0
-        ? Math.min(retryAfterHeader, maxTimeout)
-        : Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout)
-
-    setTimeout(() => cb(null), retryTimeout)
-  }
-
-  onResponseStart (controller, statusCode, headers, statusMessage) {
-    this.error = null
-    this.retryCount += 1
-
-    if (statusCode >= 300) {
-      const err = new RequestRetryError('Request failed', statusCode, {
-        headers,
-        data: {
-          count: this.retryCount
-        }
-      })
-
-      this.onResponseStartWithRetry(controller, statusCode, headers, statusMessage, err)
-      return
-    }
-
-    // Checkpoint for resume from where we left it
-    if (this.headersSent) {
-      // Only Partial Content 206 supposed to provide Content-Range,
-      // any other status code that partially consumed the payload
-      // should not be retried because it would result in downstream
-      // wrongly concatenate multiple responses.
-      if (statusCode !== 206 && (this.start > 0 || statusCode !== 200)) {
-        throw new RequestRetryError('server does not support the range header and the payload was partially consumed', statusCode, {
-          headers,
-          data: { count: this.retryCount }
-        })
-      }
-
-      const contentRange = parseRangeHeader(headers['content-range'])
-      // If no content range
-      if (!contentRange) {
-        // We always throw here as we want to indicate that we entred unexpected path
-        throw new RequestRetryError('Content-Range mismatch', statusCode, {
-          headers,
-          data: { count: this.retryCount }
-        })
-      }
-
-      // Let's start with a weak etag check
-      if (this.etag != null && this.etag !== headers.etag) {
-        // We always throw here as we want to indicate that we entred unexpected path
-        throw new RequestRetryError('ETag mismatch', statusCode, {
-          headers,
-          data: { count: this.retryCount }
-        })
-      }
-
-      const { start, size, end = size ? size - 1 : null } = contentRange
-
-      assert(this.start === start, 'content-range mismatch')
-      assert(this.end == null || this.end === end, 'content-range mismatch')
-
-      return
-    }
-
-    if (this.end == null) {
-      if (statusCode === 206) {
-        // First time we receive 206
-        const range = parseRangeHeader(headers['content-range'])
-
-        if (range == null) {
-          this.headersSent = true
-          this.handler.onResponseStart?.(
-            controller,
-            statusCode,
-            headers,
-            statusMessage
-          )
-          return
-        }
-
-        const { start, size, end = size ? size - 1 : null } = range
-        assert(
-          start != null && Number.isFinite(start),
-          'content-range mismatch'
-        )
-        assert(end != null && Number.isFinite(end), 'invalid content-length')
-
-        this.start = start
-        this.end = end
-      }
-
-      // We make our best to checkpoint the body for further range headers
-      if (this.end == null) {
-        const contentLength = headers['content-length']
-        this.end = contentLength != null ? Number(contentLength) - 1 : null
-      }
-
-      assert(Number.isFinite(this.start))
-      assert(
-        this.end == null || Number.isFinite(this.end),
-        'invalid content-length'
-      )
-
-      this.resume = true
-      this.etag = headers.etag != null ? headers.etag : null
-
-      // Weak etags are not useful for comparison nor cache
-      // for instance not safe to assume if the response is byte-per-byte
-      // equal
-      if (
-        this.etag != null &&
-        this.etag[0] === 'W' &&
-        this.etag[1] === '/'
-      ) {
-        this.etag = null
-      }
-
-      this.headersSent = true
-      this.handler.onResponseStart?.(
-        controller,
-        statusCode,
-        headers,
-        statusMessage
-      )
-    } else {
-      throw new RequestRetryError('Request failed', statusCode, {
-        headers,
-        data: { count: this.retryCount }
-      })
-    }
-  }
-
-  onResponseData (controller, chunk) {
-    if (this.error) {
-      return
-    }
-
-    this.start += chunk.length
-
-    this.handler.onResponseData?.(controller, chunk)
-  }
-
-  onResponseEnd (controller, trailers) {
-    if (this.error && this.retryOpts.throwOnError) {
-      throw this.error
-    }
-
-    if (!this.error) {
-      this.retryCount = 0
-      return this.handler.onResponseEnd?.(controller, trailers)
-    }
-
-    this.retry(controller)
-  }
-
-  retry (controller) {
-    if (this.start !== 0) {
-      const headers = { range: `bytes=${this.start}-${this.end ?? ''}` }
-
-      // Weak etag check - weak etags will make comparison algorithms never match
-      if (this.etag != null) {
-        headers['if-match'] = this.etag
-      }
-
-      this.opts = {
-        ...this.opts,
-        headers: {
-          ...this.opts.headers,
-          ...headers
-        }
-      }
-    }
-
-    try {
-      this.retryCountCheckpoint = this.retryCount
-      this.dispatch(this.opts, this)
-    } catch (err) {
-      this.handler.onResponseError?.(controller, err)
-    }
-  }
-
-  onResponseError (controller, err) {
-    if (controller?.aborted || isDisturbed(this.opts.body)) {
-      this.handler.onResponseError?.(controller, err)
-      return
-    }
-
-    function shouldRetry (returnedErr) {
-      if (!returnedErr) {
-        this.retry(controller)
-        return
-      }
-
-      this.handler?.onResponseError?.(controller, returnedErr)
-    }
-
-    // We reconcile in case of a mix between network errors
-    // and server error response
-    if (this.retryCount - this.retryCountCheckpoint > 0) {
-      // We count the difference between the last checkpoint and the current retry count
-      this.retryCount =
-        this.retryCountCheckpoint +
-        (this.retryCount - this.retryCountCheckpoint)
-    } else {
-      this.retryCount += 1
-    }
-
-    this.retryOpts.retry(
-      err,
-      {
-        state: { counter: this.retryCount },
-        opts: { retryOptions: this.retryOpts, ...this.opts }
-      },
-      shouldRetry.bind(this)
-    )
-  }
-}
-
-module.exports = RetryHandler