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

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

@@ -0,0 +1,16 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const Request = require('../lib/request')
+
+test('aborted property should be false', async (t) => {
+  const mockReq = {
+    url: 'http://localhost',
+    method: 'GET',
+    headers: {}
+  }
+  const req = new Request(mockReq)
+
+  t.assert.strictEqual(req.aborted, false)
+})

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

@@ -0,0 +1,19 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const Response = require('../lib/response')
+
+test('multiple calls to res.destroy should not be called', (t, done) => {
+  t.plan(2)
+
+  const mockReq = {}
+  const res = new Response(mockReq, (err) => {
+    t.assert.ok(err)
+    t.assert.strictEqual(err.code, 'LIGHT_ECONNRESET')
+    done()
+  })
+
+  res.destroy()
+  res.destroy()
+})

package/dist/node_modules/light-my-request/test/stream.test.js

@@ -0,0 +1,359 @@
+'use strict'
+
+const t = require('node:test')
+const fs = require('node:fs')
+const test = t.test
+const zlib = require('node:zlib')
+const express = require('express')
+
+const inject = require('../index')
+
+function accumulate (stream, cb) {
+  const chunks = []
+  stream.on('error', cb)
+  stream.on('data', (chunk) => {
+    chunks.push(chunk)
+  })
+  stream.on('end', () => {
+    cb(null, Buffer.concat(chunks))
+  })
+}
+
+test('stream mode - non-chunked payload', (t, done) => {
+  t.plan(9)
+  const output = 'example.com:8080|/hello'
+
+  const dispatch = function (req, res) {
+    res.statusMessage = 'Super'
+    res.setHeader('x-extra', 'hello')
+    res.writeHead(200, { 'Content-Type': 'text/plain', 'Content-Length': output.length })
+    res.end(req.headers.host + '|' + req.url)
+  }
+
+  inject(dispatch, {
+    url: 'http://example.com:8080/hello',
+    payloadAsStream: true
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.statusMessage, 'Super')
+    t.assert.ok(res.headers.date)
+    t.assert.deepStrictEqual(res.headers, {
+      date: res.headers.date,
+      connection: 'keep-alive',
+      'x-extra': 'hello',
+      'content-type': 'text/plain',
+      'content-length': output.length.toString()
+    })
+    t.assert.strictEqual(res.payload, undefined)
+    t.assert.strictEqual(res.rawPayload, undefined)
+
+    accumulate(res.stream(), (err, payload) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(payload.toString(), 'example.com:8080|/hello')
+      done()
+    })
+  })
+})
+
+test('stream mode - passes headers', (t, done) => {
+  t.plan(3)
+  const dispatch = function (req, res) {
+    res.writeHead(200, { 'Content-Type': 'text/plain' })
+    res.end(req.headers.super)
+  }
+
+  inject(dispatch, {
+    method: 'GET',
+    url: 'http://example.com:8080/hello',
+    headers: { Super: 'duper' },
+    payloadAsStream: true
+  }, (err, res) => {
+    t.assert.ifError(err)
+    accumulate(res.stream(), (err, payload) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(payload.toString(), 'duper')
+      done()
+    })
+  })
+})
+
+test('stream mode - returns chunked payload', (t, done) => {
+  t.plan(6)
+  const dispatch = function (_req, res) {
+    res.writeHead(200, 'OK')
+    res.write('a')
+    res.write('b')
+    res.end()
+  }
+
+  inject(dispatch, { method: 'GET', url: '/', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.ok(res.headers.date)
+    t.assert.ok(res.headers.connection)
+    t.assert.strictEqual(res.headers['transfer-encoding'], 'chunked')
+    accumulate(res.stream(), (err, payload) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(payload.toString(), 'ab')
+      done()
+    })
+  })
+})
+
+test('stream mode - backpressure', (t, done) => {
+  t.plan(7)
+  let expected
+  const dispatch = function (_req, res) {
+    res.writeHead(200, 'OK')
+    res.write('a')
+    const buf = Buffer.alloc(1024 * 1024).fill('b')
+    t.assert.strictEqual(res.write(buf), false)
+    expected = 'a' + buf.toString()
+    res.on('drain', () => {
+      res.end()
+    })
+  }
+
+  inject(dispatch, { method: 'GET', url: '/', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.ok(res.headers.date)
+    t.assert.ok(res.headers.connection)
+    t.assert.strictEqual(res.headers['transfer-encoding'], 'chunked')
+    accumulate(res.stream(), (err, payload) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(payload.toString(), expected)
+      done()
+    })
+  })
+})
+
+test('stream mode - sets trailers in response object', (t, done) => {
+  t.plan(4)
+  const dispatch = function (_req, res) {
+    res.setHeader('Trailer', 'Test')
+    res.addTrailers({ Test: 123 })
+    res.end()
+  }
+
+  inject(dispatch, { method: 'GET', url: '/', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers.trailer, 'Test')
+    t.assert.strictEqual(res.headers.test, undefined)
+    t.assert.strictEqual(res.trailers.test, '123')
+    done()
+  })
+})
+
+test('stream mode - parses zipped payload', (t, done) => {
+  t.plan(5)
+  const dispatch = function (_req, res) {
+    res.writeHead(200, 'OK')
+    const stream = fs.createReadStream('./package.json')
+    stream.pipe(zlib.createGzip()).pipe(res)
+  }
+
+  inject(dispatch, { method: 'GET', url: '/', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    fs.readFile('./package.json', { encoding: 'utf-8' }, (err, file) => {
+      t.assert.ifError(err)
+
+      accumulate(res.stream(), (err, payload) => {
+        t.assert.ifError(err)
+
+        zlib.unzip(payload, (err, unzipped) => {
+          t.assert.ifError(err)
+          t.assert.strictEqual(unzipped.toString('utf-8'), file)
+          done()
+        })
+      })
+    })
+  })
+})
+
+test('stream mode - returns multi buffer payload', (t, done) => {
+  t.plan(3)
+  const dispatch = function (_req, res) {
+    res.writeHead(200)
+    res.write('a')
+    res.write(Buffer.from('b'))
+    res.end()
+  }
+
+  inject(dispatch, { method: 'GET', url: '/', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+
+    const chunks = []
+    const stream = res.stream()
+    stream.on('data', (chunk) => {
+      chunks.push(chunk)
+    })
+
+    stream.on('end', () => {
+      t.assert.strictEqual(chunks.length, 2)
+      t.assert.strictEqual(Buffer.concat(chunks).toString(), 'ab')
+      done()
+    })
+  })
+})
+
+test('stream mode - returns null payload', (t, done) => {
+  t.plan(4)
+  const dispatch = function (_req, res) {
+    res.writeHead(200, { 'Content-Length': 0 })
+    res.end()
+  }
+
+  inject(dispatch, { method: 'GET', url: '/', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, undefined)
+    accumulate(res.stream(), (err, payload) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(payload.toString(), '')
+      done()
+    })
+  })
+})
+
+test('stream mode - simulates error', (t, done) => {
+  t.plan(3)
+  const dispatch = function (req, res) {
+    req.on('readable', () => {
+    })
+
+    req.on('error', () => {
+      res.writeHead(200, { 'Content-Length': 0 })
+      res.end('error')
+    })
+  }
+
+  const body = 'something special just for you'
+  inject(dispatch, { method: 'GET', url: '/', payload: body, simulate: { error: true }, payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    accumulate(res.stream(), (err, payload) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(payload.toString(), 'error')
+      done()
+    })
+  })
+})
+
+test('stream mode - promises support', (t, done) => {
+  t.plan(1)
+  const dispatch = function (_req, res) {
+    res.writeHead(200, { 'Content-Type': 'text/plain' })
+    res.end('hello')
+  }
+
+  inject(dispatch, { method: 'GET', url: 'http://example.com:8080/hello', payloadAsStream: true })
+    .then((res) => {
+      return new Promise((resolve, reject) => {
+        accumulate(res.stream(), (err, payload) => {
+          if (err) {
+            return reject(err)
+          }
+          resolve(payload)
+        })
+      })
+    })
+    .then(payload => t.assert.strictEqual(payload.toString(), 'hello'))
+    .catch(t.assert.fail)
+    .finally(done)
+})
+
+test('stream mode - Response.json() should throw', (t, done) => {
+  t.plan(2)
+
+  const jsonData = {
+    a: 1,
+    b: '2'
+  }
+
+  const dispatch = function (_req, res) {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify(jsonData))
+  }
+
+  inject(dispatch, { method: 'GET', path: 'http://example.com:8080/hello', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    const { json } = res
+    t.assert.throws(json, Error)
+    done()
+  })
+})
+
+test('stream mode - error for response destroy', (t, done) => {
+  t.plan(2)
+
+  const dispatch = function (_req, res) {
+    res.writeHead(200)
+    setImmediate(() => {
+      res.destroy()
+    })
+  }
+
+  inject(dispatch, { method: 'GET', url: '/', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    accumulate(res.stream(), (err) => {
+      t.assert.ok(err)
+      done()
+    })
+  })
+})
+
+test('stream mode - request destroy with error', (t, done) => {
+  t.plan(3)
+
+  const fakeError = new Error('some-err')
+
+  const dispatch = function (req) {
+    req.destroy(fakeError)
+  }
+
+  inject(dispatch, { method: 'GET', url: '/', payloadAsStream: true }, (err, res) => {
+    t.assert.ok(err)
+    t.assert.strictEqual(err, fakeError)
+    t.assert.strictEqual(res, null)
+    done()
+  })
+})
+
+test('stream mode - Can abort a request using AbortController/AbortSignal', async (t) => {
+  const dispatch = function (_req, res) {
+    res.writeHead(200)
+  }
+
+  const controller = new AbortController()
+  const res = await inject(dispatch, {
+    method: 'GET',
+    url: 'http://example.com:8080/hello',
+    signal: controller.signal,
+    payloadAsStream: true
+  })
+  controller.abort()
+
+  await t.assert.rejects(async () => {
+    for await (const c of res.stream()) {
+      t.assert.fail(`should not loop, got ${c.toString()}`)
+    }
+  }, Error)
+}, { skip: globalThis.AbortController == null })
+
+test("stream mode - passes payload when using express' send", (t, done) => {
+  t.plan(4)
+
+  const app = express()
+
+  app.get('/hello', (_req, res) => {
+    res.send('some text')
+  })
+
+  inject(app, { method: 'GET', url: 'http://example.com:8080/hello', payloadAsStream: true }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['content-length'], '9')
+    accumulate(res.stream(), function (err, payload) {
+      t.assert.ifError(err)
+      t.assert.strictEqual(payload.toString(), 'some text')
+      done()
+    })
+  })
+})

package/dist/node_modules/light-my-request/types/index.d.ts

@@ -0,0 +1,128 @@
+import * as http from 'node:http'
+import { Readable } from 'node:stream'
+
+type HTTPMethods = 'DELETE' | 'delete' |
+                   'GET' | 'get' |
+                   'HEAD' | 'head' |
+                   'PATCH' | 'patch' |
+                   'POST' | 'post' |
+                   'PUT' | 'put' |
+                   'OPTIONS' | 'options'
+
+type Inject = typeof inject
+
+declare namespace inject {
+
+  export type DispatchFunc = http.RequestListener
+
+  export type CallbackFunc = (err: Error | undefined, response: Response | undefined) => void
+
+  export type InjectPayload = string | object | Buffer | NodeJS.ReadableStream
+
+  export function isInjection (obj: http.IncomingMessage | http.ServerResponse): boolean
+
+  export interface AbortSignal {
+    readonly aborted: boolean;
+  }
+
+  export interface InjectOptions {
+    url?: string | {
+      pathname: string
+      protocol?: string
+      hostname?: string
+      port?: string | number
+      query?: string | { [k: string]: string | string[] }
+    }
+    path?: string | {
+      pathname: string
+      protocol?: string
+      hostname?: string
+      port?: string | number
+      query?: string | { [k: string]: string | string[] }
+    }
+    headers?: http.IncomingHttpHeaders | http.OutgoingHttpHeaders
+    query?: string | { [k: string]: string | string[] }
+    simulate?: {
+      end: boolean,
+      split: boolean,
+      error: boolean,
+      close: boolean
+    }
+    authority?: string
+    remoteAddress?: string
+    method?: HTTPMethods
+    validate?: boolean
+    payload?: InjectPayload
+    body?: InjectPayload
+    server?: http.Server
+    autoStart?: boolean
+    cookies?: { [k: string]: string },
+    signal?: AbortSignal,
+    Request?: object,
+    payloadAsStream?: boolean
+  }
+
+  /**
+   * https://github.com/nfriedly/set-cookie-parser/blob/3eab8b7d5d12c8ed87832532861c1a35520cf5b3/lib/set-cookie.js#L41
+   */
+  interface Cookie {
+    name: string;
+    value: string;
+    expires?: Date;
+    maxAge?: number;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: string;
+    [name: string]: unknown
+  }
+
+  export interface Response {
+    raw: {
+      res: http.ServerResponse,
+      req: http.IncomingMessage
+    }
+    rawPayload: Buffer
+    headers: http.OutgoingHttpHeaders
+    statusCode: number
+    statusMessage: string
+    trailers: { [key: string]: string }
+    payload: string
+    body: string
+    json: <T = any>() => T
+    stream: () => Readable
+    cookies: Array<Cookie>
+  }
+
+  export interface Chain extends Promise<Response> {
+    delete: (url: string) => Chain
+    get: (url: string) => Chain
+    head: (url: string) => Chain
+    options: (url: string) => Chain
+    patch: (url: string) => Chain
+    post: (url: string) => Chain
+    put: (url: string) => Chain
+    trace: (url: string) => Chain
+    body: (body: InjectPayload) => Chain
+    headers: (headers: http.IncomingHttpHeaders | http.OutgoingHttpHeaders) => Chain
+    payload: (payload: InjectPayload) => Chain
+    query: (query: string | { [k: string]: string | string[] }) => Chain
+    cookies: (query: object) => Chain
+    end(): Promise<Response>
+    end(callback: CallbackFunc): void
+  }
+
+  export const inject: Inject
+  export { inject as default }
+}
+
+declare function inject (
+  dispatchFunc: inject.DispatchFunc,
+  options?: string | inject.InjectOptions
+): inject.Chain
+declare function inject (
+  dispatchFunc: inject.DispatchFunc,
+  options: string | inject.InjectOptions,
+  callback: inject.CallbackFunc
+): void
+
+export = inject

package/dist/node_modules/light-my-request/types/index.test-d.ts

@@ -0,0 +1,149 @@
+import * as http from 'node:http'
+import { inject, isInjection, Response, DispatchFunc, InjectOptions, Chain } from '..'
+import { expectType, expectAssignable, expectNotAssignable } from 'tsd'
+import { Readable } from 'node:stream'
+
+expectAssignable<InjectOptions>({ url: '/' })
+expectAssignable<InjectOptions>({ autoStart: true })
+expectAssignable<InjectOptions>({ autoStart: false })
+expectAssignable<InjectOptions>({ validate: true })
+expectAssignable<InjectOptions>({ validate: false })
+
+const dispatch: http.RequestListener = function (req, res) {
+  expectAssignable<http.IncomingMessage>(req)
+  expectAssignable<http.ServerResponse>(res)
+  expectType<boolean>(isInjection(req))
+  expectType<boolean>(isInjection(res))
+
+  const reply = 'Hello World'
+  res.writeHead(200, { 'Content-Type': 'text/plain', 'Content-Length': reply.length })
+  res.end(reply)
+}
+
+const expectResponse = function (res: Response | undefined) {
+  if (!res) {
+    return
+  }
+  expectType<Response>(res)
+  console.log(res.payload)
+  expectAssignable<Function>(res.json)
+  expectAssignable<Function>(res.stream)
+  expectAssignable<http.ServerResponse>(res.raw.res)
+  expectAssignable<http.IncomingMessage>(res.raw.req)
+  expectType<Readable>(res.stream())
+  expectType<string>(res.payload)
+  expectType<string>(res.body)
+  expectAssignable<Array<any>>(res.cookies)
+  const cookie = res.cookies[0]
+  expectType<string>(cookie.name)
+  expectType<string>(cookie.value)
+  expectType<Date | undefined>(cookie.expires)
+  expectType<number | undefined>(cookie.maxAge)
+  expectType<boolean | undefined>(cookie.httpOnly)
+  expectType<boolean | undefined>(cookie.secure)
+  expectType<string | undefined>(cookie.sameSite)
+  expectType<unknown | undefined>(cookie.additional)
+}
+
+expectType<DispatchFunc>(dispatch)
+
+inject(dispatch, { method: 'get', url: '/' }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+const url = {
+  protocol: 'http',
+  hostname: 'example.com',
+  port: '8080',
+  pathname: 'hello',
+  query: {
+    test: '1234'
+  }
+}
+inject(dispatch, { method: 'get', url }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+inject(dispatch, { method: 'get', url: '/', cookies: { name1: 'value1', value2: 'value2' } }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+inject(dispatch, { method: 'get', url: '/', query: { name1: 'value1', value2: 'value2' } }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+inject(dispatch, { method: 'get', url: '/', query: { name1: ['value1', 'value2'] } }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+inject(dispatch, { method: 'get', url: '/', query: 'name1=value1' }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+inject(dispatch, { method: 'post', url: '/', payload: { name1: 'value1', value2: 'value2' } }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+inject(dispatch, { method: 'post', url: '/', body: { name1: 'value1', value2: 'value2' } }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+expectType<void>(
+  inject(dispatch)
+    .get('/')
+    .end((err, res) => {
+      expectType<Error | undefined>(err)
+      expectType<Response | undefined>(res)
+      console.log(res?.payload)
+    })
+)
+
+inject(dispatch)
+  .get('/')
+  .then((value) => {
+    expectType<Response>(value)
+  })
+
+expectType<Chain>(inject(dispatch))
+expectType<Promise<Response>>(inject(dispatch).end())
+expectType<Chain>(inject(dispatch, { method: 'get', url: '/' }))
+// @ts-ignore tsd supports top-level await, but normal ts does not so ignore
+expectType<Response>(await inject(dispatch, { method: 'get', url: '/' }))
+
+type ParsedValue = { field: string }
+// @ts-ignore tsd supports top-level await, but normal ts does not so ignore
+const response: Response = await inject(dispatch)
+const parsedValue: ParsedValue = response.json()
+expectType<ParsedValue>(parsedValue)
+
+const parsedValueUsingGeneric = response.json<ParsedValue>()
+expectType<ParsedValue>(parsedValueUsingGeneric)
+
+expectNotAssignable<http.ServerResponse>(response)
+
+const httpDispatch = function (req: http.IncomingMessage, res: http.ServerResponse) {
+  expectType<boolean>(isInjection(req))
+  expectType<boolean>(isInjection(res))
+
+  const reply = 'Hello World'
+  res.writeHead(200, { 'Content-Type': 'text/plain', 'Content-Length': reply.length })
+  res.end(reply)
+}
+
+inject(httpDispatch, { method: 'get', url: '/' }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})
+
+inject(httpDispatch, { method: 'get', url: '/', payloadAsStream: true }, (err, res) => {
+  expectType<Error | undefined>(err)
+  expectResponse(res)
+})

package/dist/node_modules/oidc-provider/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Filip Skokan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.