jishushell 0.6.18 → 0.7.3

package/node_modules/fastify/test/router-options.test.js

@@ -6,6 +6,7 @@ const querystring = require('node:querystring')
 const Fastify = require('../')
 const {
   FST_ERR_BAD_URL,
+  FST_ERR_MAX_PARAM_LENGTH,
   FST_ERR_ASYNC_CONSTRAINT
 } = require('../lib/errors')
 
@@ -84,7 +85,7 @@ test('Should honor maxParamLength option', async (t) => {
     method: 'GET',
     url: '/test/123456789abcd'
   })
-  t.assert.strictEqual(resError.statusCode, 404)
+  t.assert.strictEqual(resError.statusCode, 414)
 })
 
 test('Should expose router options via getters on request and reply', (t, done) => {
@@ -262,6 +263,130 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
   )
 })
 
+test('Should honor frameworkErrors option - FST_ERR_MAX_PARAM_LENGTH', (t, done) => {
+  t.plan(3)
+  const fastify = Fastify({
+    maxParamLength: 1,
+    frameworkErrors: function (err, req, res) {
+      if (err instanceof FST_ERR_MAX_PARAM_LENGTH) {
+        t.assert.ok(true)
+      } else {
+        t.assert.fail()
+      }
+      res.send(`${err.message} - ${err.code}`)
+    }
+  })
+
+  fastify.get('/test/:id', (req, res) => {
+    res.send('{ hello: \'world\' }')
+  })
+
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/test/123'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/123\' is exceeding the max param length - FST_ERR_MAX_PARAM_LENGTH')
+      done()
+    }
+  )
+})
+
+test('Should supply Fastify request to the logger in frameworkErrors wrapper - FST_ERR_MAX_PARAM_LENGTH', (t, done) => {
+  t.plan(8)
+
+  const REQ_ID = 'REQ-1234'
+  const logStream = split(JSON.parse)
+
+  const fastify = Fastify({
+    maxParamLength: 1,
+    frameworkErrors: function (err, req, res) {
+      t.assert.deepStrictEqual(req.id, REQ_ID)
+      t.assert.deepStrictEqual(req.raw.httpVersion, '1.1')
+      res.send(`${err.message} - ${err.code}`)
+    },
+    logger: {
+      stream: logStream,
+      serializers: {
+        req (request) {
+          t.assert.deepStrictEqual(request.id, REQ_ID)
+          return { httpVersion: request.raw.httpVersion }
+        }
+      }
+    },
+    genReqId: () => REQ_ID
+  })
+
+  fastify.get('/test/:id', (req, res) => {
+    res.send('{ hello: \'world\' }')
+  })
+
+  logStream.on('data', (json) => {
+    t.assert.deepStrictEqual(json.msg, 'incoming request')
+    t.assert.deepStrictEqual(json.reqId, REQ_ID)
+    t.assert.deepStrictEqual(json.req.httpVersion, '1.1')
+  })
+
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/test/123'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/123\' is exceeding the max param length - FST_ERR_MAX_PARAM_LENGTH')
+      done()
+    }
+  )
+})
+
+test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST_ERR_MAX_PARAM_LENGTH', (t, done) => {
+  t.plan(2)
+
+  const logStream = split(JSON.parse)
+
+  const fastify = Fastify({
+    disableRequestLogging: true,
+    maxParamLength: 1,
+    frameworkErrors: function (err, req, res) {
+      res.send(`${err.message} - ${err.code}`)
+    },
+    logger: {
+      stream: logStream,
+      serializers: {
+        req () {
+          t.assert.fail('should not be called')
+        },
+        res () {
+          t.assert.fail('should not be called')
+        }
+      }
+    }
+  })
+
+  fastify.get('/test/:id', (req, res) => {
+    res.send('{ hello: \'world\' }')
+  })
+
+  logStream.on('data', (json) => {
+    t.assert.fail('should not be called')
+  })
+
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/test/123'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/123\' is exceeding the max param length - FST_ERR_MAX_PARAM_LENGTH')
+      done()
+    }
+  )
+})
+
 test('Should honor frameworkErrors option - FST_ERR_ASYNC_CONSTRAINT', (t, done) => {
   t.plan(3)
 
@@ -507,6 +632,67 @@ test('Should honor disableRequestLogging function in frameworkErrors wrapper - F
   )
 })
 
+test('Should honor disableRequestLogging function in frameworkErrors wrapper - FST_ERR_MAX_PARAM_LENGTH', (t, done) => {
+  t.plan(4)
+
+  let logCallCount = 0
+  const logStream = split(JSON.parse)
+
+  const fastify = Fastify({
+    maxParamLength: 1,
+    disableRequestLogging: (req) => {
+      // Disable logging for URLs containing 'silent'
+      return req.url.includes('silent')
+    },
+    frameworkErrors: function (err, req, res) {
+      res.send(`${err.message} - ${err.code}`)
+    },
+    logger: {
+      stream: logStream,
+      level: 'info'
+    }
+  })
+
+  fastify.get('/test/:id', (req, res) => {
+    res.send('{ hello: \'world\' }')
+  })
+
+  logStream.on('data', (json) => {
+    if (json.msg === 'incoming request') {
+      logCallCount++
+    }
+  })
+
+  // First request: URL does not contain 'silent', so logging should happen
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/test/123'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/123\' is exceeding the max param length - FST_ERR_MAX_PARAM_LENGTH')
+
+      // Second request: URL contains 'silent', so logging should be disabled
+      fastify.inject(
+        {
+          method: 'GET',
+          url: '/silent/123'
+        },
+        (err2, res2) => {
+          t.assert.ifError(err2)
+          // Give time for any potential log events
+          setImmediate(() => {
+            // Only the first request should have logged
+            t.assert.strictEqual(logCallCount, 1)
+            done()
+          })
+        }
+      )
+    }
+  )
+})
+
 test('Should honor disableRequestLogging function in frameworkErrors wrapper - FST_ERR_ASYNC_CONSTRAINT', (t, done) => {
   t.plan(4)
 
@@ -615,7 +801,7 @@ test('Should honor routerOptions.defaultRoute', async t => {
   t.assert.strictEqual(res.payload, 'default route')
 })
 
-test('Should honor routerOptions.badUrl', async t => {
+test('Should honor routerOptions.onBadUrl', async t => {
   t.plan(3)
   const fastify = Fastify({
     routerOptions: {
@@ -625,7 +811,7 @@ test('Should honor routerOptions.badUrl', async t => {
       onBadUrl: function (path, _, res) {
         t.assert.ok('bad url called')
         res.statusCode = 400
-        res.end(`Bath URL: ${path}`)
+        res.end(`Bad URL: ${path}`)
       }
     }
   })
@@ -636,7 +822,32 @@ test('Should honor routerOptions.badUrl', async t => {
 
   const res = await fastify.inject('/hello/%world')
   t.assert.strictEqual(res.statusCode, 400)
-  t.assert.strictEqual(res.payload, 'Bath URL: /hello/%world')
+  t.assert.strictEqual(res.payload, 'Bad URL: /hello/%world')
+})
+
+test('Should honor routerOptions.onMaxParamLength', async t => {
+  t.plan(3)
+  const fastify = Fastify({
+    routerOptions: {
+      defaultRoute: function (_, res) {
+        t.asset.fail('default route should not be called')
+      },
+      maxParamLength: 10,
+      onMaxParamLength: function (path, _, res) {
+        t.assert.ok('max param length called')
+        res.statusCode = 414
+        res.end(`URL: ${path}`)
+      }
+    }
+  })
+
+  fastify.get('/hello/:id', (req, res) => {
+    res.send({ hello: 'world' })
+  })
+
+  const res = await fastify.inject('/hello/12345678901')
+  t.assert.strictEqual(res.statusCode, 414)
+  t.assert.strictEqual(res.payload, 'URL: /hello/12345678901')
 })
 
 test('Should honor routerOptions.ignoreTrailingSlash', async t => {
@@ -727,7 +938,7 @@ test('Should honor routerOptions.maxParamLength', async (t) => {
     method: 'GET',
     url: '/test/123456789abcd'
   })
-  t.assert.strictEqual(resError.statusCode, 404)
+  t.assert.strictEqual(resError.statusCode, 414)
 })
 
 test('Should honor routerOptions.allowUnsafeRegex', async (t) => {
@@ -854,11 +1065,11 @@ test('Should honor routerOptions.buildPrettyMeta', async (t) => {
     }
   })
 
-  fastify.get('/test', () => {})
-  fastify.get('/test/hello', () => {})
-  fastify.get('/testing', () => {})
-  fastify.get('/testing/:param', () => {})
-  fastify.put('/update', () => {})
+  fastify.get('/test', () => { })
+  fastify.get('/test/hello', () => { })
+  fastify.get('/testing', () => { })
+  fastify.get('/testing/:param', () => { })
+  fastify.put('/update', () => { })
 
   await fastify.ready()
 
@@ -928,7 +1139,7 @@ test('Should honor routerOptions.maxParamLength over maxParamLength option', asy
     method: 'GET',
     url: '/test/123456789abcd'
   })
-  t.assert.strictEqual(resError.statusCode, 404)
+  t.assert.strictEqual(resError.statusCode, 414)
 })
 
 test('Should honor routerOptions.allowUnsafeRegex over allowUnsafeRegex option', async (t) => {

package/node_modules/fastify/test/schema-serialization.test.js

@@ -1169,3 +1169,111 @@ test('allow default as status code and used as last fallback', (t, testDone) =>
     testDone()
   })
 })
+
+test('response schema is applied when Content-Type has whitespace before parameters', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                required: ['public'],
+                additionalProperties: false,
+                properties: {
+                  public: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/json ; charset=utf-8')
+    reply.send({ public: 'ok', secret: 'SHOULD_BE_STRIPPED' })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { public: 'ok' })
+    testDone()
+  })
+})
+
+test('response schema is applied when Content-Type has tab before semicolon', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                required: ['public'],
+                additionalProperties: false,
+                properties: {
+                  public: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/json\t; charset=utf-8')
+    reply.send({ public: 'ok', secret: 'SHOULD_BE_STRIPPED' })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { public: 'ok' })
+    testDone()
+  })
+})
+
+test('response schema is applied when Content-Type has trailing semicolon only', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                required: ['public'],
+                additionalProperties: false,
+                properties: {
+                  public: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/json ;')
+    reply.send({ public: 'ok', secret: 'SHOULD_BE_STRIPPED' })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { public: 'ok' })
+    testDone()
+  })
+})

package/node_modules/fastify/test/schema-validation.test.js

@@ -6,6 +6,7 @@ const Fastify = require('..')
 const AJV = require('ajv')
 const Schema = require('fluent-json-schema')
 const { waitForCb } = require('./toolkit')
+const { kRequestContentType } = require('../lib/symbols')
 
 const customSchemaCompilers = {
   body: new AJV({
@@ -1374,6 +1375,7 @@ test('Schema validation when no content type is provided', async t => {
     },
     preValidation: async (request) => {
       request.headers['content-type'] = undefined
+      request[kRequestContentType] = undefined
     }
   }, async () => 'ok')
 
@@ -1591,3 +1593,25 @@ test('Schema validation will not be bypass by different content type', async t =
   t.assert.strictEqual(found.status, 415)
   t.assert.strictEqual((await found.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
 })
+test('coercion of empty string to null with nullable types', async t => {
+  const assert = require('node:assert')
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      querystring: {
+        type: 'object',
+        properties: {
+          param: { type: ['integer', 'null'] }
+        }
+      }
+    }
+  }, async (req, reply) => {
+    return { param: req.query.param }
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/?param='
+  })
+  assert.strictEqual(JSON.parse(res.payload).param, null)
+})

package/node_modules/fastify/test/scripts/validate-ecosystem-links.test.js

@@ -127,7 +127,6 @@ Some description [inline link](https://github.com/a/b).
 describe('checkGitHubRepo', () => {
   let originalDispatcher
   let mockAgent
-  let originalFetch
   let originalSetTimeout
 
   beforeEach(() => {
@@ -136,12 +135,10 @@ describe('checkGitHubRepo', () => {
     mockAgent = new MockAgent()
     mockAgent.disableNetConnect()
     setGlobalDispatcher(mockAgent)
-    originalFetch = global.fetch
     originalSetTimeout = global.setTimeout
   })
 
   afterEach(async () => {
-    global.fetch = originalFetch
     global.setTimeout = originalSetTimeout
     setGlobalDispatcher(originalDispatcher)
     await mockAgent.close()
@@ -180,16 +177,9 @@ describe('checkGitHubRepo', () => {
 
   it('returns invalid status for malformed owner or repository names', async () => {
     const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
-    let called = false
-
-    global.fetch = async () => {
-      called = true
-      return { status: 200 }
-    }
 
     const result = await checkGitHubRepo('owner/evil', 'repo', 1)
 
-    assert.strictEqual(called, false)
     assert.strictEqual(result.exists, false)
     assert.strictEqual(result.status, 'invalid')
     assert.strictEqual(result.error, 'Invalid GitHub repository identifier')
@@ -199,17 +189,17 @@ describe('checkGitHubRepo', () => {
     const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
     let attempts = 0
 
-    global.setTimeout = (fn) => {
-      fn()
-      return 0
-    }
+    global.setTimeout = (fn) => { fn(); return 0 }
 
-    global.fetch = async () => {
-      attempts++
-      return {
-        status: attempts === 1 ? 403 : 200
-      }
-    }
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD'
+    }).reply(() => { attempts++; return { statusCode: 403 } })
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD'
+    }).reply(() => { attempts++; return { statusCode: 200 } })
 
     const result = await checkGitHubRepo('owner', 'repo', 1)
 
@@ -221,23 +211,25 @@ describe('checkGitHubRepo', () => {
   it('adds authorization header when GITHUB_TOKEN is set', async () => {
     process.env.GITHUB_TOKEN = 'my-token'
     const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
-    let authorization
 
-    global.fetch = async (url, options) => {
-      authorization = options.headers.Authorization
-      return {
-        status: 200
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD',
+      headers: {
+        authorization: 'token my-token'
       }
-    }
+    }).reply(200)
 
     const result = await checkGitHubRepo('owner', 'repo')
 
-    assert.strictEqual(authorization, 'token my-token')
     assert.strictEqual(result.exists, true)
+    assert.strictEqual(result.status, 200)
   })
 
   it('handles network errors', async () => {
     const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
+
     const mockPool = mockAgent.get('https://api.github.com')
     mockPool.intercept({
       path: '/repos/owner/repo',
@@ -254,37 +246,41 @@ describe('checkGitHubRepo', () => {
 
 describe('validateAllLinks', () => {
   let originalReadFileSync
-  let originalFetch
   let originalSetTimeout
   let originalConsoleLog
   let originalStdoutWrite
+  let mockAgent
+  let originalDispatcher
 
   beforeEach(() => {
     originalReadFileSync = fs.readFileSync
-    originalFetch = global.fetch
     originalSetTimeout = global.setTimeout
     originalConsoleLog = console.log
     originalStdoutWrite = process.stdout.write
+    originalDispatcher = getGlobalDispatcher()
+
+    mockAgent = new MockAgent()
+    mockAgent.disableNetConnect()
+    setGlobalDispatcher(mockAgent)
 
     console.log = () => {}
     process.stdout.write = () => true
 
-    global.setTimeout = (fn) => {
-      fn()
-      return 0
-    }
+    global.setTimeout = (fn) => { fn(); return 0 }
   })
 
-  afterEach(() => {
+  afterEach(async () => {
     fs.readFileSync = originalReadFileSync
-    global.fetch = originalFetch
     global.setTimeout = originalSetTimeout
     console.log = originalConsoleLog
     process.stdout.write = originalStdoutWrite
+    setGlobalDispatcher(originalDispatcher)
+    await mockAgent.close()
   })
 
   it('validates links, deduplicates repositories and groups inaccessible links', async () => {
     const { validateAllLinks } = loadValidateEcosystemLinksModule()
+    let requests = 0
 
     fs.readFileSync = () => `
 - [repo one](https://github.com/owner/repo)
@@ -292,21 +288,15 @@ describe('validateAllLinks', () => {
 - [repo two](https://github.com/another/project)
 `
 
-    let requests = 0
-    global.fetch = async (url) => {
-      requests++
-      const pathname = new URL(url).pathname
-
-      if (pathname === '/repos/owner/repo') {
-        return { status: 404 }
-      }
-
-      if (pathname === '/repos/another/project') {
-        return { status: 200 }
-      }
-
-      throw new Error(`Unexpected url: ${url}`)
-    }
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD'
+    }).reply(() => { requests++; return { statusCode: 404 } })
+    mockPool.intercept({
+      path: '/repos/another/project',
+      method: 'HEAD'
+    }).reply(() => { requests++; return { statusCode: 200 } })
 
     const result = await validateAllLinks()
 
@@ -324,15 +314,8 @@ describe('validateAllLinks', () => {
 
     fs.readFileSync = () => '# Ecosystem\nNo links here.'
 
-    let requests = 0
-    global.fetch = async () => {
-      requests++
-      return { status: 200 }
-    }
-
     const result = await validateAllLinks()
 
-    assert.strictEqual(requests, 0)
     assert.strictEqual(result.notFound.length, 0)
     assert.strictEqual(result.found.length, 0)
   })

package/node_modules/fastify/test/throw.test.js

@@ -28,6 +28,20 @@ test('Fastify should throw on multiple assignment to the same route', (t) => {
   }
 })
 
+test('Fastify should throw on multiple assignment to the same route with array method', (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.route({ method: ['GET', 'POST'], url: '/', handler: () => {} })
+
+  try {
+    fastify.route({ method: ['GET', 'POST'], url: '/', handler: () => {} })
+    t.assert.fail('Should throw fastify duplicated route declaration')
+  } catch (error) {
+    t.assert.strictEqual(error.code, 'FST_ERR_DUPLICATED_ROUTE')
+  }
+})
+
 test('Fastify should throw for an invalid schema, printing the error route - headers', async (t) => {
   t.plan(1)
 

package/node_modules/fastify/test/trust-proxy.test.js

@@ -272,3 +272,24 @@ test('trust proxy with number and null socket remoteAddress', t => {
   t.assert.ok(request.ip, 'ip is defined')
   t.assert.strictEqual(request.ip, '1.1.1.1', 'gets ip from x-forwarded-for')
 })
+
+test('trust proxy does not trust x-forwarded-host/proto when socket is null', t => {
+  t.plan(2)
+
+  const headers = {
+    host: 'real.test',
+    'x-forwarded-host': 'spoofed.test',
+    'x-forwarded-proto': 'https'
+  }
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: null,
+    headers
+  }
+
+  const TpRequest = buildRequest(Request, true)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  t.assert.strictEqual(request.host, 'real.test', 'falls back to host header')
+  t.assert.strictEqual(request.protocol, undefined, 'does not trust x-forwarded-proto')
+})