fastify 5.7.0 → 5.7.2

package/test/content-parser.test.js

@@ -55,6 +55,7 @@ test('getParser', async t => {
     fastify.addContentTypeParser(/^image\/.*/, first)
     fastify.addContentTypeParser(/^application\/.+\+xml/, second)
     fastify.addContentTypeParser('text/html', third)
+    fastify.addContentTypeParser('text/html; charset=utf-8', third)
 
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('application/t+xml').fn, second)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('image/png').fn, first)
@@ -66,14 +67,15 @@ test('getParser', async t => {
   })
 
   await t.test('should return matching parser with caching /1', t => {
-    t.plan(6)
+    t.plan(7)
 
     const fastify = Fastify()
 
     fastify.addContentTypeParser('text/html', first)
 
-    t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text/html').fn, first)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 0)
+    t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text/html').fn, first)
+    t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 1)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text/html ').fn, first)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 1)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text/html ').fn, first)
@@ -81,20 +83,21 @@ test('getParser', async t => {
   })
 
   await t.test('should return matching parser with caching /2', t => {
-    t.plan(8)
+    t.plan(9)
 
     const fastify = Fastify()
 
     fastify.addContentTypeParser('text/html', first)
 
-    t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text/html').fn, first)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 0)
+    t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text/html').fn, first)
+    t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 1)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text/HTML').fn, first)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 1)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('TEXT/html').fn, first)
-    t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 2)
+    t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 1)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('TEXT/html').fn, first)
-    t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 2)
+    t.assert.strictEqual(fastify[keys.kContentTypeParser].cache.size, 1)
   })
 
   await t.test('should return matching parser with caching /3', t => {
@@ -125,7 +128,7 @@ test('getParser', async t => {
   })
 
   await t.test('should return parser that catches all if no other is set', t => {
-    t.plan(3)
+    t.plan(2)
 
     const fastify = Fastify()
 
@@ -134,7 +137,6 @@ test('getParser', async t => {
 
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('image/gif').fn, first)
     t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text/html').fn, second)
-    t.assert.strictEqual(fastify[keys.kContentTypeParser].getParser('text').fn, first)
   })
 
   await t.test('should return undefined if no matching parser exist', t => {
@@ -208,7 +210,7 @@ test('add', async t => {
     const fastify = Fastify()
     const contentTypeParser = fastify[keys.kContentTypeParser]
 
-    t.assert.ifError(contentTypeParser.add('test', {}, first))
+    t.assert.ifError(contentTypeParser.add('test/type', {}, first))
     t.assert.ifError(contentTypeParser.add(/test/, {}, first))
     t.assert.throws(
       () => contentTypeParser.add({}, {}, first),
@@ -557,7 +559,7 @@ test('content-type match parameters - regexp', async t => {
 
   const fastify = Fastify()
   fastify.removeAllContentTypeParsers()
-  fastify.addContentTypeParser(/application\/json; charset=utf8/, function (request, body, done) {
+  fastify.addContentTypeParser(/application\/json; charset="utf8"/, function (request, body, done) {
     t.assert.ok('should be called')
     done(null, body)
   })
@@ -697,37 +699,17 @@ test('content-type regexp list should be cloned when plugin override', async t =
   }
 })
 
-test('edge case content-type - ;', async t => {
+test('content-type fail when not a valid type', async t => {
   t.plan(1)
 
   const fastify = Fastify()
   fastify.removeAllContentTypeParsers()
-  fastify.addContentTypeParser(';', function (request, body, done) {
-    t.assert.fail('should not be called')
-    done(null, body)
-  })
-
-  fastify.post('/', async () => {
-    return 'ok'
-  })
-
-  await fastify.inject({
-    method: 'POST',
-    path: '/',
-    headers: {
-      'content-type': 'application/json; foo=bar; charset=utf8'
-    },
-    body: ''
-  })
-
-  await fastify.inject({
-    method: 'POST',
-    path: '/',
-    headers: {
-      'content-type': 'image/jpeg'
-    },
-    body: ''
-  })
-
-  t.assert.ok('end')
+  try {
+    fastify.addContentTypeParser('type-only', function (request, body, done) {
+      t.assert.fail('shouldn\'t be called')
+      done(null, body)
+    })
+  } catch (error) {
+    t.assert.equal(error.message, 'The content type should be a string or a RegExp')
+  }
 })

package/test/content-type.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const { test } = require('node:test')
+const { describe, test } = require('node:test')
+const ContentType = require('../lib/content-type')
 const Fastify = require('..')
 
 test('should remove content-type for setErrorHandler', async t => {
@@ -40,3 +41,103 @@ test('should remove content-type for setErrorHandler', async t => {
   t.assert.strictEqual(statusCode, 400)
   t.assert.strictEqual(body, JSON.stringify({ foo: 'bar' }))
 })
+
+describe('ContentType class', () => {
+  test('returns empty instance for empty value', (t) => {
+    let found = new ContentType('')
+    t.assert.equal(found.isEmpty, true)
+
+    found = new ContentType('undefined')
+    t.assert.equal(found.isEmpty, true)
+
+    found = new ContentType()
+    t.assert.equal(found.isEmpty, true)
+  })
+
+  test('indicates media type is not correct format', (t) => {
+    let found = new ContentType('foo')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('foo /bar')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('foo/ bar')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('foo; param=1')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('foo/π; param=1')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+  })
+
+  test('returns a plain media type instance', (t) => {
+    const found = new ContentType('Application/JSON')
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.type, 'application')
+    t.assert.equal(found.subtype, 'json')
+    t.assert.equal(found.parameters.size, 0)
+  })
+
+  test('handles empty parameters list', (t) => {
+    const found = new ContentType('Application/JSON ;')
+    t.assert.equal(found.isEmpty, false)
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.type, 'application')
+    t.assert.equal(found.subtype, 'json')
+    t.assert.equal(found.parameters.size, 0)
+  })
+
+  test('returns a media type instance with parameters', (t) => {
+    const found = new ContentType('Application/JSON ; charset=utf-8; foo=BaR;baz=" 42"')
+    t.assert.equal(found.isEmpty, false)
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.type, 'application')
+    t.assert.equal(found.subtype, 'json')
+    t.assert.equal(found.parameters.size, 3)
+
+    const expected = [
+      ['charset', 'utf-8'],
+      ['foo', 'BaR'],
+      ['baz', ' 42']
+    ]
+    t.assert.deepStrictEqual(
+      Array.from(found.parameters.entries()),
+      expected
+    )
+
+    t.assert.equal(
+      found.toString(),
+      'application/json; charset="utf-8"; foo="BaR"; baz=" 42"'
+    )
+  })
+
+  test('skips invalid quoted string parameters', (t) => {
+    const found = new ContentType('Application/JSON ; charset=utf-8; foo=BaR;baz=" 42')
+    t.assert.equal(found.isEmpty, false)
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.type, 'application')
+    t.assert.equal(found.subtype, 'json')
+    t.assert.equal(found.parameters.size, 3)
+
+    const expected = [
+      ['charset', 'utf-8'],
+      ['foo', 'BaR'],
+      ['baz', 'invalid quoted string']
+    ]
+    t.assert.deepStrictEqual(
+      Array.from(found.parameters.entries()),
+      expected
+    )
+
+    t.assert.equal(
+      found.toString(),
+      'application/json; charset="utf-8"; foo="BaR"; baz="invalid quoted string"'
+    )
+  })
+})

package/test/custom-parser.0.test.js

@@ -354,7 +354,7 @@ test('catch all content type parser', async (t) => {
     method: 'POST',
     body: 'hello',
     headers: {
-      'Content-Type': 'very-weird-content-type'
+      'Content-Type': 'very-weird-content-type/foo'
     }
   })
 
@@ -363,7 +363,7 @@ test('catch all content type parser', async (t) => {
   t.assert.strictEqual(await result2.text(), 'hello')
 })
 
-test('catch all content type parser should not interfere with other conte type parsers', async (t) => {
+test('catch all content type parser should not interfere with other content type parsers', async (t) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -404,7 +404,7 @@ test('catch all content type parser should not interfere with other conte type p
     method: 'POST',
     body: 'hello',
     headers: {
-      'Content-Type': 'very-weird-content-type'
+      'Content-Type': 'very-weird-content-type/foo'
     }
   })
 

package/test/custom-parser.1.test.js

@@ -89,41 +89,6 @@ test('Should get the body as string /1', async (t) => {
   t.assert.strictEqual(await result.text(), 'hello world')
 })
 
-test('Should get the body as string /2', async (t) => {
-  t.plan(4)
-  const fastify = Fastify()
-
-  fastify.post('/', (req, reply) => {
-    reply.send(req.body)
-  })
-
-  fastify.addContentTypeParser('text/plain/test', { parseAs: 'string' }, function (req, body, done) {
-    t.assert.ok('called')
-    t.assert.ok(typeof body === 'string')
-    try {
-      const plainText = body
-      done(null, plainText)
-    } catch (err) {
-      err.statusCode = 400
-      done(err, undefined)
-    }
-  })
-
-  const fastifyServer = await fastify.listen({ port: 0 })
-  t.after(() => fastify.close())
-
-  const result = await fetch(fastifyServer, {
-    method: 'POST',
-    body: 'hello world',
-    headers: {
-      'Content-Type': '   text/plain/test  '
-    }
-  })
-
-  t.assert.strictEqual(result.status, 200)
-  t.assert.strictEqual(await result.text(), 'hello world')
-})
-
 test('Should get the body as buffer', async (t) => {
   t.plan(4)
   const fastify = Fastify()

package/test/custom-parser.3.test.js

@@ -189,7 +189,7 @@ test('catch all content type parser should not interfere with content type parse
 
   const assertions = [
     { body: '{"myKey":"myValue"}', contentType: 'application/json', expected: JSON.stringify({ myKey: 'myValue' }) },
-    { body: 'body', contentType: 'very-weird-content-type', expected: 'body' },
+    { body: 'body', contentType: 'very-weird-content-type/foo', expected: 'body' },
     { body: 'my text', contentType: 'text/html', expected: 'my texthtml' }
   ]
 

package/test/schema-validation.test.js

@@ -1416,7 +1416,7 @@ test('Schema validation will not be bypass by different content type', async t =
   t.after(() => fastify.close())
   const address = fastify.listeningOrigin
 
-  const correct1 = await fetch(address, {
+  let found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1424,10 +1424,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ foo: 'string' })
   })
-  t.assert.strictEqual(correct1.status, 200)
-  await correct1.bytes()
+  t.assert.strictEqual(found.status, 200)
+  await found.bytes()
 
-  const correct2 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1435,10 +1435,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ foo: 'string' })
   })
-  t.assert.strictEqual(correct2.status, 200)
-  await correct2.bytes()
+  t.assert.strictEqual(found.status, 200)
+  await found.bytes()
 
-  const correct3 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1446,10 +1446,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ foo: 'string' })
   })
-  t.assert.strictEqual(correct2.status, 200)
-  await correct3.bytes()
+  t.assert.strictEqual(found.status, 200)
+  await found.bytes()
 
-  const invalid1 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1457,10 +1457,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid1.status, 400)
-  t.assert.strictEqual((await invalid1.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(found.status, 400)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_VALIDATION')
 
-  const invalid2 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1468,10 +1468,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid2.status, 400)
-  t.assert.strictEqual((await invalid2.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(found.status, 400)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_VALIDATION')
 
-  const invalid3 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1479,10 +1479,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid3.status, 400)
-  t.assert.strictEqual((await invalid3.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(found.status, 400)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_VALIDATION')
 
-  const invalid4 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1490,10 +1490,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid4.status, 400)
-  t.assert.strictEqual((await invalid4.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(found.status, 415)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
 
-  const invalid5 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1501,10 +1501,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid5.status, 400)
-  t.assert.strictEqual((await invalid5.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(found.status, 415)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
 
-  const invalid6 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1512,10 +1512,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid6.status, 400)
-  t.assert.strictEqual((await invalid6.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(found.status, 415)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
 
-  const invalid7 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1523,10 +1523,10 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid7.status, 400)
-  t.assert.strictEqual((await invalid7.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(found.status, 400)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_VALIDATION')
 
-  const invalid8 = await fetch(address, {
+  found = await fetch(address, {
     method: 'POST',
     url: '/',
     headers: {
@@ -1534,6 +1534,39 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid8.status, 400)
-  t.assert.strictEqual((await invalid8.json()).code, 'FST_ERR_VALIDATION')
+  t.assert.strictEqual(found.status, 400)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_VALIDATION')
+
+  found = await fetch(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn\ta'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.assert.strictEqual(found.status, 415)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
+
+  found = await fetch(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn\ta; charset=utf-8'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.assert.strictEqual(found.status, 415)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
+
+  found = await fetch(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/ json'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.assert.strictEqual(found.status, 415)
+  t.assert.strictEqual((await found.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
 })

package/.claude/settings.local.json

@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:github.com)",
-      "Bash(curl -sI https://github.com/nucleode/arecibo)",
-      "Bash(curl:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}