@nocobase/plugin-idp-oauth 2.3.0-beta.12 → 2.3.0-beta.14

package/dist/node_modules/undici/lib/dispatcher/round-robin-pool.js

@@ -1,137 +0,0 @@
-'use strict'
-
-const {
-  PoolBase,
-  kClients,
-  kNeedDrain,
-  kAddClient,
-  kGetDispatcher,
-  kRemoveClient
-} = require('./pool-base')
-const Client = require('./client')
-const {
-  InvalidArgumentError
-} = require('../core/errors')
-const util = require('../core/util')
-const { kUrl } = require('../core/symbols')
-const buildConnector = require('../core/connect')
-
-const kOptions = Symbol('options')
-const kConnections = Symbol('connections')
-const kFactory = Symbol('factory')
-const kIndex = Symbol('index')
-
-function defaultFactory (origin, opts) {
-  return new Client(origin, opts)
-}
-
-class RoundRobinPool extends PoolBase {
-  constructor (origin, {
-    connections,
-    factory = defaultFactory,
-    connect,
-    connectTimeout,
-    tls,
-    maxCachedSessions,
-    socketPath,
-    autoSelectFamily,
-    autoSelectFamilyAttemptTimeout,
-    allowH2,
-    clientTtl,
-    ...options
-  } = {}) {
-    if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
-      throw new InvalidArgumentError('invalid connections')
-    }
-
-    if (typeof factory !== 'function') {
-      throw new InvalidArgumentError('factory must be a function.')
-    }
-
-    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
-      throw new InvalidArgumentError('connect must be a function or an object')
-    }
-
-    if (typeof connect !== 'function') {
-      connect = buildConnector({
-        ...tls,
-        maxCachedSessions,
-        allowH2,
-        socketPath,
-        timeout: connectTimeout,
-        ...(typeof autoSelectFamily === 'boolean' ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
-        ...connect
-      })
-    }
-
-    super()
-
-    this[kConnections] = connections || null
-    this[kUrl] = util.parseOrigin(origin)
-    this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl, socketPath }
-    this[kOptions].interceptors = options.interceptors
-      ? { ...options.interceptors }
-      : undefined
-    this[kFactory] = factory
-    this[kIndex] = -1
-
-    this.on('connect', (origin, targets) => {
-      if (clientTtl != null && clientTtl > 0) {
-        for (const target of targets) {
-          Object.assign(target, { ttl: Date.now() })
-        }
-      }
-    })
-
-    this.on('connectionError', (origin, targets, error) => {
-      for (const target of targets) {
-        const idx = this[kClients].indexOf(target)
-        if (idx !== -1) {
-          this[kClients].splice(idx, 1)
-        }
-      }
-    })
-  }
-
-  [kGetDispatcher] () {
-    const clientTtlOption = this[kOptions].clientTtl
-    const clientsLength = this[kClients].length
-
-    // If we have no clients yet, create one
-    if (clientsLength === 0) {
-      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
-      this[kAddClient](dispatcher)
-      return dispatcher
-    }
-
-    // Round-robin through existing clients
-    let checked = 0
-    while (checked < clientsLength) {
-      this[kIndex] = (this[kIndex] + 1) % clientsLength
-      const client = this[kClients][this[kIndex]]
-
-      // Check if client is stale (TTL expired)
-      if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
-        this[kRemoveClient](client)
-        checked++
-        continue
-      }
-
-      // Return client if it's not draining
-      if (!client[kNeedDrain]) {
-        return client
-      }
-
-      checked++
-    }
-
-    // All clients are busy, create a new one if we haven't reached the limit
-    if (!this[kConnections] || clientsLength < this[kConnections]) {
-      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
-      this[kAddClient](dispatcher)
-      return dispatcher
-    }
-  }
-}
-
-module.exports = RoundRobinPool

package/dist/node_modules/undici/lib/dispatcher/socks5-proxy-agent.js

@@ -1,249 +0,0 @@
-'use strict'
-
-const net = require('node:net')
-const { URL } = require('node:url')
-
-let tls // include tls conditionally since it is not always available
-const DispatcherBase = require('./dispatcher-base')
-const { InvalidArgumentError } = require('../core/errors')
-const { Socks5Client } = require('../core/socks5-client')
-const { kDispatch, kClose, kDestroy } = require('../core/symbols')
-const Pool = require('./pool')
-const buildConnector = require('../core/connect')
-const { debuglog } = require('node:util')
-
-const debug = debuglog('undici:socks5-proxy')
-
-const kProxyUrl = Symbol('proxy url')
-const kProxyHeaders = Symbol('proxy headers')
-const kProxyAuth = Symbol('proxy auth')
-const kPool = Symbol('pool')
-const kConnector = Symbol('connector')
-
-// Static flag to ensure warning is only emitted once per process
-let experimentalWarningEmitted = false
-
-/**
- * SOCKS5 proxy agent for dispatching requests through a SOCKS5 proxy
- */
-class Socks5ProxyAgent extends DispatcherBase {
-  constructor (proxyUrl, options = {}) {
-    super()
-
-    // Emit experimental warning only once
-    if (!experimentalWarningEmitted) {
-      process.emitWarning(
-        'SOCKS5 proxy support is experimental and subject to change',
-        'ExperimentalWarning'
-      )
-      experimentalWarningEmitted = true
-    }
-
-    if (!proxyUrl) {
-      throw new InvalidArgumentError('Proxy URL is mandatory')
-    }
-
-    // Parse proxy URL
-    const url = typeof proxyUrl === 'string' ? new URL(proxyUrl) : proxyUrl
-
-    if (url.protocol !== 'socks5:' && url.protocol !== 'socks:') {
-      throw new InvalidArgumentError('Proxy URL must use socks5:// or socks:// protocol')
-    }
-
-    this[kProxyUrl] = url
-    this[kProxyHeaders] = options.headers || {}
-
-    // Extract auth from URL or options
-    this[kProxyAuth] = {
-      username: options.username || (url.username ? decodeURIComponent(url.username) : null),
-      password: options.password || (url.password ? decodeURIComponent(url.password) : null)
-    }
-
-    // Create connector for proxy connection
-    this[kConnector] = options.connect || buildConnector({
-      ...options.proxyTls,
-      servername: options.proxyTls?.servername || url.hostname
-    })
-
-    // Pool for the actual HTTP connections (with SOCKS5 tunnel connect function)
-    this[kPool] = null
-  }
-
-  /**
-   * Create a SOCKS5 connection to the proxy
-   */
-  async createSocks5Connection (targetHost, targetPort) {
-    const proxyHost = this[kProxyUrl].hostname
-    const proxyPort = parseInt(this[kProxyUrl].port) || 1080
-
-    debug('creating SOCKS5 connection to', proxyHost, proxyPort)
-
-    // Connect to the SOCKS5 proxy
-    const socket = await new Promise((resolve, reject) => {
-      const onConnect = () => {
-        socket.removeListener('error', onError)
-        resolve(socket)
-      }
-
-      const onError = (err) => {
-        socket.removeListener('connect', onConnect)
-        reject(err)
-      }
-
-      const socket = net.connect({
-        host: proxyHost,
-        port: proxyPort
-      })
-
-      socket.once('connect', onConnect)
-      socket.once('error', onError)
-    })
-
-    // Create SOCKS5 client
-    const socks5Client = new Socks5Client(socket, this[kProxyAuth])
-
-    // Handle SOCKS5 errors
-    socks5Client.on('error', (err) => {
-      debug('SOCKS5 error:', err)
-      socket.destroy()
-    })
-
-    // Perform SOCKS5 handshake
-    await socks5Client.handshake()
-
-    // Wait for authentication (if required)
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error('SOCKS5 authentication timeout'))
-      }, 5000)
-
-      const onAuthenticated = () => {
-        clearTimeout(timeout)
-        socks5Client.removeListener('error', onError)
-        resolve()
-      }
-
-      const onError = (err) => {
-        clearTimeout(timeout)
-        socks5Client.removeListener('authenticated', onAuthenticated)
-        reject(err)
-      }
-
-      // Check if already authenticated (for NO_AUTH method)
-      if (socks5Client.state === 'authenticated') {
-        clearTimeout(timeout)
-        resolve()
-      } else {
-        socks5Client.once('authenticated', onAuthenticated)
-        socks5Client.once('error', onError)
-      }
-    })
-
-    // Send CONNECT command
-    await socks5Client.connect(targetHost, targetPort)
-
-    // Wait for connection
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error('SOCKS5 connection timeout'))
-      }, 5000)
-
-      const onConnected = (info) => {
-        debug('SOCKS5 tunnel established to', targetHost, targetPort, 'via', info)
-        clearTimeout(timeout)
-        socks5Client.removeListener('error', onError)
-        resolve()
-      }
-
-      const onError = (err) => {
-        clearTimeout(timeout)
-        socks5Client.removeListener('connected', onConnected)
-        reject(err)
-      }
-
-      socks5Client.once('connected', onConnected)
-      socks5Client.once('error', onError)
-    })
-
-    return socket
-  }
-
-  /**
-   * Dispatch a request through the SOCKS5 proxy
-   */
-  async [kDispatch] (opts, handler) {
-    const { origin } = opts
-
-    debug('dispatching request to', origin, 'via SOCKS5')
-
-    try {
-      // Create Pool with custom connect function if we don't have one yet
-      if (!this[kPool] || this[kPool].destroyed || this[kPool].closed) {
-        this[kPool] = new Pool(origin, {
-          pipelining: opts.pipelining,
-          connections: opts.connections,
-          connect: async (connectOpts, callback) => {
-            try {
-              const url = new URL(origin)
-              const targetHost = url.hostname
-              const targetPort = parseInt(url.port) || (url.protocol === 'https:' ? 443 : 80)
-
-              debug('establishing SOCKS5 connection to', targetHost, targetPort)
-
-              // Create SOCKS5 tunnel
-              const socket = await this.createSocks5Connection(targetHost, targetPort)
-
-              // Handle TLS if needed
-              let finalSocket = socket
-              if (url.protocol === 'https:') {
-                if (!tls) {
-                  tls = require('node:tls')
-                }
-                debug('upgrading to TLS')
-                finalSocket = tls.connect({
-                  socket,
-                  servername: targetHost,
-                  ...connectOpts.tls || {}
-                })
-
-                await new Promise((resolve, reject) => {
-                  finalSocket.once('secureConnect', resolve)
-                  finalSocket.once('error', reject)
-                })
-              }
-
-              callback(null, finalSocket)
-            } catch (err) {
-              debug('SOCKS5 connection error:', err)
-              callback(err)
-            }
-          }
-        })
-      }
-
-      // Dispatch the request through the pool
-      return this[kPool][kDispatch](opts, handler)
-    } catch (err) {
-      debug('dispatch error:', err)
-      if (typeof handler.onError === 'function') {
-        handler.onError(err)
-      } else {
-        throw err
-      }
-    }
-  }
-
-  async [kClose] () {
-    if (this[kPool]) {
-      await this[kPool].close()
-    }
-  }
-
-  async [kDestroy] (err) {
-    if (this[kPool]) {
-      await this[kPool].destroy(err)
-    }
-  }
-}
-
-module.exports = Socks5ProxyAgent

package/dist/node_modules/undici/lib/encoding/index.js

@@ -1,33 +0,0 @@
-'use strict'
-
-const textDecoder = new TextDecoder()
-
-/**
- * @see https://encoding.spec.whatwg.org/#utf-8-decode
- * @param {Uint8Array} buffer
- */
-function utf8DecodeBytes (buffer) {
-  if (buffer.length === 0) {
-    return ''
-  }
-
-  // 1. Let buffer be the result of peeking three bytes from
-  //    ioQueue, converted to a byte sequence.
-
-  // 2. If buffer is 0xEF 0xBB 0xBF, then read three
-  //    bytes from ioQueue. (Do nothing with those bytes.)
-  if (buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
-    buffer = buffer.subarray(3)
-  }
-
-  // 3. Process a queue with an instance of UTF-8’s
-  //    decoder, ioQueue, output, and "replacement".
-  const output = textDecoder.decode(buffer)
-
-  // 4. Return output.
-  return output
-}
-
-module.exports = {
-  utf8DecodeBytes
-}

package/dist/node_modules/undici/lib/global.js

@@ -1,50 +0,0 @@
-'use strict'
-
-// We include a version number for the Dispatcher API. In case of breaking changes,
-// this version number must be increased to avoid conflicts.
-const globalDispatcher = Symbol.for('undici.globalDispatcher.1')
-const { InvalidArgumentError } = require('./core/errors')
-const Agent = require('./dispatcher/agent')
-
-if (getGlobalDispatcher() === undefined) {
-  setGlobalDispatcher(new Agent())
-}
-
-function setGlobalDispatcher (agent) {
-  if (!agent || typeof agent.dispatch !== 'function') {
-    throw new InvalidArgumentError('Argument agent must implement Agent')
-  }
-  Object.defineProperty(globalThis, globalDispatcher, {
-    value: agent,
-    writable: true,
-    enumerable: false,
-    configurable: false
-  })
-}
-
-function getGlobalDispatcher () {
-  return globalThis[globalDispatcher]
-}
-
-// These are the globals that can be installed by undici.install().
-// Not exported by index.js to avoid use outside of this module.
-const installedExports = /** @type {const} */ (
-  [
-    'fetch',
-    'Headers',
-    'Response',
-    'Request',
-    'FormData',
-    'WebSocket',
-    'CloseEvent',
-    'ErrorEvent',
-    'MessageEvent',
-    'EventSource'
-  ]
-)
-
-module.exports = {
-  setGlobalDispatcher,
-  getGlobalDispatcher,
-  installedExports
-}