@nocobase/plugin-idp-oauth 2.1.0-alpha.10

package/dist/node_modules/light-my-request/lib/form-data.js

@@ -0,0 +1,79 @@
+'use strict'
+
+const { randomUUID } = require('node:crypto')
+const { Readable } = require('node:stream')
+
+let textEncoder
+
+function isFormDataLike (payload) {
+  return (
+    payload &&
+    typeof payload === 'object' &&
+    typeof payload.append === 'function' &&
+    typeof payload.delete === 'function' &&
+    typeof payload.get === 'function' &&
+    typeof payload.getAll === 'function' &&
+    typeof payload.has === 'function' &&
+    typeof payload.set === 'function' &&
+    payload[Symbol.toStringTag] === 'FormData'
+  )
+}
+
+/*
+  partial code extraction and refactoring of `undici`.
+  MIT License. https://github.com/nodejs/undici/blob/043d8f1a89f606b1db259fc71f4c9bc8eb2aa1e6/lib/web/fetch/LICENSE
+  Reference https://github.com/nodejs/undici/blob/043d8f1a89f606b1db259fc71f4c9bc8eb2aa1e6/lib/web/fetch/body.js#L102-L168
+*/
+function formDataToStream (formdata) {
+  // lazy creation of TextEncoder
+  textEncoder = textEncoder ?? new TextEncoder()
+
+  // we expect the function argument must be FormData
+  const boundary = `----formdata-${randomUUID()}`
+  const prefix = `--${boundary}\r\nContent-Disposition: form-data`
+
+  /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+  const escape = (str) =>
+    str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22')
+  const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, '\r\n')
+
+  const linebreak = new Uint8Array([13, 10]) // '\r\n'
+
+  async function * asyncIterator () {
+    for (const [name, value] of formdata) {
+      if (typeof value === 'string') {
+        // header
+        yield textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"\r\n\r\n`)
+        // body
+        yield textEncoder.encode(`${normalizeLinefeeds(value)}\r\n`)
+      } else {
+        let header = `${prefix}; name="${escape(normalizeLinefeeds(name))}"`
+        value.name && (header += `; filename="${escape(value.name)}"`)
+        header += `\r\nContent-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`
+        // header
+        yield textEncoder.encode(header)
+        // body
+        if (value.stream) {
+          yield * value.stream()
+        } /* c8 ignore start */ else {
+          // shouldn't be here since Blob / File should provide .stream
+          // and FormData always convert to USVString
+          yield value
+        } /* c8 ignore stop */
+        yield linebreak
+      }
+    }
+    // end
+    yield textEncoder.encode(`--${boundary}--`)
+  }
+
+  const stream = Readable.from(asyncIterator())
+
+  return {
+    stream,
+    contentType: `multipart/form-data; boundary=${boundary}`
+  }
+}
+
+module.exports.isFormDataLike = isFormDataLike
+module.exports.formDataToStream = formDataToStream

package/dist/node_modules/light-my-request/lib/parse-url.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const { URL } = require('node:url')
+
+const BASE_URL = 'http://localhost'
+
+/**
+ * Parse URL
+ *
+ * @param {(Object|String)} url
+ * @param {Object} [query]
+ * @return {URL}
+ */
+module.exports = function parseURL (url, query) {
+  if ((typeof url === 'string' || Object.prototype.toString.call(url) === '[object String]') && url.startsWith('//')) {
+    url = BASE_URL + url
+  }
+  const result = typeof url === 'object'
+    ? Object.assign(new URL(BASE_URL), url)
+    : new URL(url, BASE_URL)
+
+  if (typeof query === 'string') {
+    query = new URLSearchParams(query)
+    for (const key of query.keys()) {
+      result.searchParams.delete(key)
+      for (const value of query.getAll(key)) {
+        result.searchParams.append(key, value)
+      }
+    }
+  } else {
+    const merged = Object.assign({}, url.query, query)
+    for (const key in merged) {
+      const value = merged[key]
+
+      if (Array.isArray(value)) {
+        result.searchParams.delete(key)
+        for (const param of value) {
+          result.searchParams.append(key, param)
+        }
+      } else {
+        result.searchParams.set(key, value)
+      }
+    }
+  }
+
+  return result
+}

package/dist/node_modules/light-my-request/lib/request.js

@@ -0,0 +1,290 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const { Readable, addAbortSignal } = require('node:stream')
+const util = require('node:util')
+const cookie = require('cookie')
+const assert = require('node:assert')
+const { createDeprecation } = require('process-warning')
+
+const parseURL = require('./parse-url')
+const { isFormDataLike, formDataToStream } = require('./form-data')
+const { EventEmitter } = require('node:events')
+
+// request.connectin deprecation https://nodejs.org/api/http.html#http_request_connection
+const FST_LIGHTMYREQUEST_DEP01 = createDeprecation({
+  name: 'FastifyDeprecationLightMyRequest',
+  code: 'FST_LIGHTMYREQUEST_DEP01',
+  message: 'You are accessing "request.connection", use "request.socket" instead.'
+})
+
+/**
+ * Get hostname:port
+ *
+ * @param {URL} parsedURL
+ * @return {String}
+ */
+function hostHeaderFromURL (parsedURL) {
+  return parsedURL.port
+    ? parsedURL.host
+    : parsedURL.hostname + (parsedURL.protocol === 'https:' ? ':443' : ':80')
+}
+
+/**
+ * Mock socket object used to fake access to a socket for a request
+ *
+ * @constructor
+ * @param {String} remoteAddress the fake address to show consumers of the socket
+ */
+class MockSocket extends EventEmitter {
+  constructor (remoteAddress) {
+    super()
+    this.remoteAddress = remoteAddress
+  }
+}
+
+/**
+ * CustomRequest
+ *
+ * @constructor
+ * @param {Object} options
+ * @param {(Object|String)} options.url || options.path
+ * @param {String} [options.method='GET']
+ * @param {String} [options.remoteAddress]
+ * @param {Object} [options.cookies]
+ * @param {Object} [options.headers]
+ * @param {Object} [options.query]
+ * @param {Object} [options.Request]
+ * @param {any} [options.payload]
+ */
+function CustomRequest (options) {
+  return new _CustomLMRRequest(this)
+
+  function _CustomLMRRequest (obj) {
+    Request.call(obj, {
+      ...options,
+      Request: undefined
+    })
+    Object.assign(this, obj)
+
+    for (const fn of Object.keys(Request.prototype)) {
+      this.constructor.prototype[fn] = Request.prototype[fn]
+    }
+
+    util.inherits(this.constructor, options.Request)
+    return this
+  }
+}
+
+/**
+ * Request
+ *
+ * @constructor
+ * @param {Object} options
+ * @param {(Object|String)} options.url || options.path
+ * @param {String} [options.method='GET']
+ * @param {String} [options.remoteAddress]
+ * @param {Object} [options.cookies]
+ * @param {Object} [options.headers]
+ * @param {Object} [options.query]
+ * @param {any} [options.payload]
+ */
+function Request (options) {
+  Readable.call(this, {
+    autoDestroy: false
+  })
+
+  const parsedURL = parseURL(options.url || options.path, options.query)
+
+  this.url = parsedURL.pathname + parsedURL.search
+
+  this.aborted = false
+  this.httpVersionMajor = 1
+  this.httpVersionMinor = 1
+  this.httpVersion = '1.1'
+  this.method = options.method ? options.method.toUpperCase() : 'GET'
+
+  this.headers = {}
+  this.rawHeaders = []
+
+  const headers = options.headers || {}
+
+  for (const field in headers) {
+    const fieldLowerCase = field.toLowerCase()
+    if (
+      (
+        fieldLowerCase === 'user-agent' ||
+        fieldLowerCase === 'content-type'
+      ) && headers[field] === undefined
+    ) {
+      this.headers[fieldLowerCase] = undefined
+      continue
+    }
+    const value = headers[field]
+    assert(value !== undefined, 'invalid value "undefined" for header ' + field)
+    this.headers[fieldLowerCase] = '' + value
+  }
+
+  if (('user-agent' in this.headers) === false) {
+    this.headers['user-agent'] = 'lightMyRequest'
+  }
+  this.headers.host = this.headers.host || options.authority || hostHeaderFromURL(parsedURL)
+
+  if (options.cookies) {
+    const { cookies } = options
+    const cookieValues = Object.keys(cookies).map(key => cookie.serialize(key, cookies[key]))
+    if (this.headers.cookie) {
+      cookieValues.unshift(this.headers.cookie)
+    }
+    this.headers.cookie = cookieValues.join('; ')
+  }
+
+  this.socket = new MockSocket(options.remoteAddress || '127.0.0.1')
+
+  Object.defineProperty(this, 'connection', {
+    get () {
+      FST_LIGHTMYREQUEST_DEP01()
+      return this.socket
+    },
+    configurable: true
+  })
+
+  // we keep both payload and body for compatibility reasons
+  let payload = options.payload || options.body || null
+  let payloadResume = payload && typeof payload.resume === 'function'
+
+  if (isFormDataLike(payload)) {
+    const stream = formDataToStream(payload)
+    payload = stream.stream
+    payloadResume = true
+    // we override the content-type
+    this.headers['content-type'] = stream.contentType
+    this.headers['transfer-encoding'] = 'chunked'
+  }
+
+  if (payload && typeof payload !== 'string' && !payloadResume && !Buffer.isBuffer(payload)) {
+    payload = JSON.stringify(payload)
+
+    if (('content-type' in this.headers) === false) {
+      this.headers['content-type'] = 'application/json'
+    }
+  }
+
+  // Set the content-length for the corresponding payload if none set
+  if (payload && !payloadResume && !Object.hasOwn(this.headers, 'content-length')) {
+    this.headers['content-length'] = (Buffer.isBuffer(payload) ? payload.length : Buffer.byteLength(payload)).toString()
+  }
+
+  for (const header of Object.keys(this.headers)) {
+    this.rawHeaders.push(header, this.headers[header])
+  }
+
+  // Use _lightMyRequest namespace to avoid collision with Node
+  this._lightMyRequest = {
+    payload,
+    isDone: false,
+    simulate: options.simulate || {},
+    payloadAsStream: options.payloadAsStream,
+    signal: options.signal
+  }
+
+  const signal = options.signal
+  /* c8 ignore next 3 */
+  if (signal) {
+    addAbortSignal(signal, this)
+  }
+
+  {
+    const payload = this._lightMyRequest.payload
+    if (payload?._readableState) { // does quack like a modern stream
+      this._read = readStream
+
+      payload.on('error', (err) => {
+        this.destroy(err)
+      })
+
+      payload.on('end', () => {
+        this.push(null)
+      })
+    } else {
+      // Stream v1 are handled in index.js synchronously
+      this._read = readEverythingElse
+    }
+  }
+
+  return this
+}
+
+function readStream () {
+  const payload = this._lightMyRequest.payload
+
+  let more = true
+  let pushed = false
+  let chunk
+  while (more && (chunk = payload.read())) {
+    pushed = true
+    more = this.push(chunk)
+  }
+
+  // We set up a recursive 'readable' event only if we didn't read anything.
+  // Otheriwse, the stream machinery will call _read() for us.
+  if (more && !pushed) {
+    this._lightMyRequest.payload.once('readable', this._read.bind(this))
+  }
+}
+
+function readEverythingElse () {
+  setImmediate(() => {
+    if (this._lightMyRequest.isDone) {
+      // 'end' defaults to true
+      if (this._lightMyRequest.simulate.end !== false) {
+        this.push(null)
+      }
+      return
+    }
+
+    this._lightMyRequest.isDone = true
+
+    if (this._lightMyRequest.payload) {
+      if (this._lightMyRequest.simulate.split) {
+        this.push(this._lightMyRequest.payload.slice(0, 1))
+        this.push(this._lightMyRequest.payload.slice(1))
+      } else {
+        this.push(this._lightMyRequest.payload)
+      }
+    }
+
+    if (this._lightMyRequest.simulate.error) {
+      this.emit('error', new Error('Simulated'))
+    }
+
+    if (this._lightMyRequest.simulate.close) {
+      this.emit('close')
+    }
+
+    // 'end' defaults to true
+    if (this._lightMyRequest.simulate.end !== false) {
+      this.push(null)
+    }
+  })
+}
+
+util.inherits(Request, Readable)
+util.inherits(CustomRequest, Request)
+
+Request.prototype.destroy = function (error) {
+  if (this.destroyed || this._lightMyRequest.isDone) return
+  this.destroyed = true
+
+  if (error) {
+    this._error = true
+    process.nextTick(() => this.emit('error', error))
+  }
+
+  process.nextTick(() => this.emit('close'))
+}
+
+module.exports = Request
+module.exports.Request = Request
+module.exports.CustomRequest = CustomRequest

package/dist/node_modules/light-my-request/lib/response.js

@@ -0,0 +1,240 @@
+'use strict'
+
+const http = require('node:http')
+const { Writable, Readable, addAbortSignal } = require('node:stream')
+const util = require('node:util')
+
+const setCookie = require('set-cookie-parser')
+
+function Response (req, onEnd, reject) {
+  http.ServerResponse.call(this, req)
+
+  if (req._lightMyRequest?.payloadAsStream) {
+    const read = this.emit.bind(this, 'drain')
+    this._lightMyRequest = { headers: null, trailers: {}, stream: new Readable({ read }) }
+    const signal = req._lightMyRequest.signal
+
+    if (signal) {
+      addAbortSignal(signal, this._lightMyRequest.stream)
+    }
+  } else {
+    this._lightMyRequest = { headers: null, trailers: {}, payloadChunks: [] }
+  }
+  // This forces node@8 to always render the headers
+  this.setHeader('foo', 'bar'); this.removeHeader('foo')
+
+  this.assignSocket(getNullSocket())
+
+  this._promiseCallback = typeof reject === 'function'
+
+  let called = false
+  const onEndSuccess = (payload) => {
+    if (called) return
+    called = true
+    if (this._promiseCallback) {
+      return process.nextTick(() => onEnd(payload))
+    }
+    process.nextTick(() => onEnd(null, payload))
+  }
+  this._lightMyRequest.onEndSuccess = onEndSuccess
+
+  let finished = false
+  const onEndFailure = (err) => {
+    if (called) {
+      if (this._lightMyRequest.stream && !finished) {
+        if (!err) {
+          err = new Error('response destroyed before completion')
+          err.code = 'LIGHT_ECONNRESET'
+        }
+        this._lightMyRequest.stream.destroy(err)
+        this._lightMyRequest.stream.on('error', () => {})
+      }
+      return
+    }
+    called = true
+    if (!err) {
+      err = new Error('response destroyed before completion')
+      err.code = 'LIGHT_ECONNRESET'
+    }
+    if (this._promiseCallback) {
+      return process.nextTick(() => reject(err))
+    }
+    process.nextTick(() => onEnd(err, null))
+  }
+
+  if (this._lightMyRequest.stream) {
+    this.once('finish', () => {
+      finished = true
+      this._lightMyRequest.stream.push(null)
+    })
+  } else {
+    this.once('finish', () => {
+      const res = generatePayload(this)
+      res.raw.req = req
+      onEndSuccess(res)
+    })
+  }
+
+  this.connection.once('error', onEndFailure)
+
+  this.once('error', onEndFailure)
+
+  this.once('close', onEndFailure)
+}
+
+util.inherits(Response, http.ServerResponse)
+
+Response.prototype.setTimeout = function (msecs, callback) {
+  this.timeoutHandle = setTimeout(() => {
+    this.emit('timeout')
+  }, msecs)
+  this.on('timeout', callback)
+  return this
+}
+
+Response.prototype.writeHead = function () {
+  const result = http.ServerResponse.prototype.writeHead.apply(this, arguments)
+
+  copyHeaders(this)
+
+  if (this._lightMyRequest.stream) {
+    this._lightMyRequest.onEndSuccess(generatePayload(this))
+  }
+
+  return result
+}
+
+Response.prototype.write = function (data, encoding, callback) {
+  if (this.timeoutHandle) {
+    clearTimeout(this.timeoutHandle)
+  }
+  http.ServerResponse.prototype.write.call(this, data, encoding, callback)
+  if (this._lightMyRequest.stream) {
+    return this._lightMyRequest.stream.push(Buffer.from(data, encoding))
+  } else {
+    this._lightMyRequest.payloadChunks.push(Buffer.from(data, encoding))
+    return true
+  }
+}
+
+Response.prototype.end = function (data, encoding, callback) {
+  if (data) {
+    this.write(data, encoding)
+  }
+
+  http.ServerResponse.prototype.end.call(this, callback)
+
+  this.emit('finish')
+
+  // We need to emit 'close' otherwise stream.finished() would
+  // not pick it up on Node v16
+
+  this.destroy()
+}
+
+Response.prototype.destroy = function (error) {
+  if (this.destroyed) return
+  this.destroyed = true
+
+  if (error) {
+    process.nextTick(() => this.emit('error', error))
+  }
+
+  process.nextTick(() => this.emit('close'))
+}
+
+Response.prototype.addTrailers = function (trailers) {
+  for (const key in trailers) {
+    this._lightMyRequest.trailers[key.toLowerCase().trim()] = trailers[key].toString().trim()
+  }
+}
+
+function generatePayload (response) {
+  // This seems only to happen when using `fastify-express` - see https://github.com/fastify/fastify-express/issues/47
+  /* c8 ignore next 3  */
+  if (response._lightMyRequest.headers === null) {
+    copyHeaders(response)
+  }
+  serializeHeaders(response)
+  // Prepare response object
+  const res = {
+    raw: {
+      res: response
+    },
+    headers: response._lightMyRequest.headers,
+    statusCode: response.statusCode,
+    statusMessage: response.statusMessage,
+    trailers: {},
+    get cookies () {
+      return setCookie.parse(this)
+    }
+  }
+
+  res.trailers = response._lightMyRequest.trailers
+
+  if (response._lightMyRequest.payloadChunks) {
+    // Prepare payload and trailers
+    const rawBuffer = Buffer.concat(response._lightMyRequest.payloadChunks)
+    res.rawPayload = rawBuffer
+
+    // we keep both of them for compatibility reasons
+    res.payload = rawBuffer.toString()
+    res.body = res.payload
+
+    // Prepare payload parsers
+    res.json = function parseJsonPayload () {
+      return JSON.parse(res.payload)
+    }
+  } else {
+    res.json = function () {
+      throw new Error('Response payload is not available with payloadAsStream: true')
+    }
+  }
+
+  // Provide stream Readable for advanced user
+  res.stream = function streamPayload () {
+    if (response._lightMyRequest.stream) {
+      return response._lightMyRequest.stream
+    }
+    return Readable.from(response._lightMyRequest.payloadChunks)
+  }
+
+  return res
+}
+
+// Throws away all written data to prevent response from buffering payload
+function getNullSocket () {
+  return new Writable({
+    write (_chunk, _encoding, callback) {
+      setImmediate(callback)
+    }
+  })
+}
+
+function serializeHeaders (response) {
+  const headers = response._lightMyRequest.headers
+
+  for (const headerName of Object.keys(headers)) {
+    const headerValue = headers[headerName]
+    if (Array.isArray(headerValue)) {
+      headers[headerName] = headerValue.map(value => '' + value)
+    } else {
+      headers[headerName] = '' + headerValue
+    }
+  }
+}
+
+function copyHeaders (response) {
+  response._lightMyRequest.headers = Object.assign({}, response.getHeaders())
+
+  // Add raw headers
+  ;['Date', 'Connection', 'Transfer-Encoding'].forEach((name) => {
+    const regex = new RegExp('\\r\\n' + name + ': ([^\\r]*)\\r\\n')
+    const field = response._header?.match(regex)
+    if (field) {
+      response._lightMyRequest.headers[name.toLowerCase()] = field[1]
+    }
+  })
+}
+
+module.exports = Response

package/dist/node_modules/light-my-request/node_modules/process-warning/.gitattributes

@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf

package/dist/node_modules/light-my-request/node_modules/process-warning/.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    open-pull-requests-limit: 10
+
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10

package/dist/node_modules/light-my-request/node_modules/process-warning/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches:
+     - main
+     - master
+     - next
+     - 'v*'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
+jobs:
+  test:
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
+    with:
+      license-check: true
+      lint: true
+      node-versions: '["16", "18", "20", "22"]'

package/dist/node_modules/light-my-request/node_modules/process-warning/.taprc

@@ -0,0 +1,2 @@
+files:
+  - test/**/*[!jest].test.js