node-fastify 5.8.3

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

@@ -0,0 +1,266 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('../fastify')
+const jsonParser = require('fast-json-body')
+
+process.removeAllListeners('warning')
+
+test('Should have typeof body object with no custom parser defined, null body and content type = \'text/plain\'', async (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    body: null,
+    headers: {
+      'Content-Type': 'text/plain'
+    }
+  })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.strictEqual(await result.text(), '')
+})
+
+test('Should have typeof body object with no custom parser defined, undefined body and content type = \'text/plain\'', async (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    body: undefined,
+    headers: {
+      'Content-Type': 'text/plain'
+    }
+  })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.strictEqual(await result.text(), '')
+})
+
+test('Should get the body as string /1', async (t) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser('text/plain', { 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'
+    }
+  })
+
+  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()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser('application/json', { parseAs: 'buffer' }, function (req, body, done) {
+    t.assert.ok('called')
+    t.assert.ok(body instanceof Buffer)
+    try {
+      const json = JSON.parse(body)
+      done(null, json)
+    } 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': 'application/json'
+    }
+  })
+
+  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()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser('text/plain', { parseAs: 'buffer' }, function (req, body, done) {
+    t.assert.ok('called')
+    t.assert.ok(body instanceof Buffer)
+    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'
+    }
+  })
+
+  t.assert.strictEqual(result.status, 200)
+  t.assert.strictEqual(await result.text(), 'hello world')
+})
+
+test('Should parse empty bodies as a string', async (t) => {
+  t.plan(8)
+  const fastify = Fastify()
+
+  fastify.addContentTypeParser('text/plain', { parseAs: 'string' }, (req, body, done) => {
+    t.assert.strictEqual(body, '')
+    done(null, body)
+  })
+
+  fastify.route({
+    method: ['POST', 'DELETE'],
+    url: '/',
+    handler (request, reply) {
+      reply.send(request.body)
+    }
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const postResult = await fetch(fastifyServer, {
+    method: 'POST',
+    body: '',
+    headers: {
+      'Content-Type': 'text/plain'
+    }
+  })
+
+  t.assert.ok(postResult.ok)
+  t.assert.strictEqual(postResult.status, 200)
+  t.assert.strictEqual(await postResult.text(), '')
+
+  const deleteResult = await fetch(fastifyServer, {
+    method: 'DELETE',
+    body: '',
+    headers: {
+      'Content-Type': 'text/plain',
+      'Content-Length': '0'
+    }
+  })
+
+  t.assert.ok(deleteResult.ok)
+  t.assert.strictEqual(deleteResult.status, 200)
+  t.assert.strictEqual(await deleteResult.text(), '')
+})
+
+test('Should parse empty bodies as a buffer', async (t) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser('text/plain', { parseAs: 'buffer' }, function (req, body, done) {
+    t.assert.ok(body instanceof Buffer)
+    t.assert.strictEqual(body.length, 0)
+    done(null, body)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    body: '',
+    headers: {
+      'Content-Type': 'text/plain'
+    }
+  })
+
+  t.assert.strictEqual(result.status, 200)
+  t.assert.strictEqual((await result.arrayBuffer()).byteLength, 0)
+})
+
+test('The charset should not interfere with the content type handling', async (t) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser('application/json', function (req, payload, done) {
+    t.assert.ok('called')
+    jsonParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    body: '{"hello":"world"}',
+    headers: {
+      'Content-Type': 'application/json; charset=utf-8'
+    }
+  })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.strictEqual(await result.text(), '{"hello":"world"}')
+})

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

@@ -0,0 +1,91 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+process.removeAllListeners('warning')
+
+test('Wrong parseAs parameter', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  try {
+    fastify.addContentTypeParser('application/json', { parseAs: 'fireworks' }, () => {})
+    t.assert.fail('should throw')
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'FST_ERR_CTP_INVALID_PARSE_TYPE')
+    t.assert.strictEqual(err.message, "The body parser can only parse your data as 'string' or 'buffer', you asked 'fireworks' which is not supported.")
+  }
+})
+
+test('Should allow defining the bodyLimit per parser', async (t) => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser(
+    'x/foo',
+    { parseAs: 'string', bodyLimit: 5 },
+    function (req, body, done) {
+      t.assert.fail('should not be invoked')
+      done()
+    }
+  )
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    body: '1234567890',
+    headers: {
+      'Content-Type': 'x/foo'
+    }
+  })
+
+  t.assert.ok(!result.ok)
+  t.assert.deepStrictEqual(await result.json(), {
+    statusCode: 413,
+    code: 'FST_ERR_CTP_BODY_TOO_LARGE',
+    error: 'Payload Too Large',
+    message: 'Request body is too large'
+  })
+})
+
+test('route bodyLimit should take precedence over a custom parser bodyLimit', async (t) => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.post('/', { bodyLimit: 5 }, (request, reply) => {
+    reply.send(request.body)
+  })
+
+  fastify.addContentTypeParser(
+    'x/foo',
+    { parseAs: 'string', bodyLimit: 100 },
+    function (req, body, done) {
+      t.assert.fail('should not be invoked')
+      done()
+    }
+  )
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    body: '1234567890',
+    headers: { 'Content-Type': 'x/foo' }
+  })
+
+  t.assert.ok(!result.ok)
+  t.assert.deepStrictEqual(await result.json(), {
+    statusCode: 413,
+    code: 'FST_ERR_CTP_BODY_TOO_LARGE',
+    error: 'Payload Too Large',
+    message: 'Request body is too large'
+  })
+})

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

@@ -0,0 +1,208 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+const jsonParser = require('fast-json-body')
+
+process.removeAllListeners('warning')
+
+test('should be able to use default parser for extra content type', async t => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.post('/', (request, reply) => {
+    reply.send(request.body)
+  })
+
+  fastify.addContentTypeParser('text/json', { parseAs: 'string' }, fastify.getDefaultJsonParser('ignore', 'ignore'))
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const response = await fetch(fastifyServer, {
+    method: 'POST',
+    body: '{"hello":"world"}',
+    headers: {
+      'Content-Type': 'text/json'
+    }
+  })
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+  t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
+})
+
+test('contentTypeParser should add a custom parser with RegExp value', async (t) => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.options('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser(/.*\+json$/, function (req, payload, done) {
+    jsonParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  await t.test('in POST', async t => {
+    t.plan(3)
+
+    const response = await fetch(fastifyServer, {
+      method: 'POST',
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/vnd.test+json'
+      }
+    })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
+  })
+
+  await t.test('in OPTIONS', async t => {
+    t.plan(3)
+
+    const response = await fetch(fastifyServer, {
+      method: 'OPTIONS',
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'weird/content-type+json'
+      }
+    })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
+  })
+})
+
+test('contentTypeParser should add multiple custom parsers with RegExp values', async t => {
+  t.plan(6)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser(/.*\+json$/, function (req, payload, done) {
+    jsonParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  fastify.addContentTypeParser(/.*\+xml$/, function (req, payload, done) {
+    done(null, 'xml')
+  })
+
+  fastify.addContentTypeParser(/.*\+myExtension$/i, function (req, payload, done) {
+    let data = ''
+    payload.on('data', chunk => { data += chunk })
+    payload.on('end', () => {
+      done(null, data + 'myExtension')
+    })
+  })
+
+  await fastify.ready()
+
+  {
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/',
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/vnd.hello+json'
+      }
+    })
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.payload.toString(), '{"hello":"world"}')
+  }
+
+  {
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/',
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/test+xml'
+      }
+    })
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.payload.toString(), 'xml')
+  }
+
+  await fastify.inject({
+    method: 'POST',
+    path: '/',
+    payload: 'abcdefg',
+    headers: {
+      'Content-Type': 'application/+myExtension'
+    }
+  }).then((response) => {
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.payload.toString(), 'abcdefgmyExtension')
+  }).catch((err) => {
+    t.assert.ifError(err)
+  })
+})
+
+test('catch all content type parser should not interfere with content type parser', async t => {
+  t.plan(9)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser('*', function (req, payload, done) {
+    let data = ''
+    payload.on('data', chunk => { data += chunk })
+    payload.on('end', () => {
+      done(null, data)
+    })
+  })
+
+  fastify.addContentTypeParser(/^application\/.*/, function (req, payload, done) {
+    jsonParser(payload, function (err, body) {
+      done(err, body)
+    })
+  })
+
+  fastify.addContentTypeParser('text/html', function (req, payload, done) {
+    let data = ''
+    payload.on('data', chunk => { data += chunk })
+    payload.on('end', () => {
+      done(null, data + 'html')
+    })
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const assertions = [
+    { body: '{"myKey":"myValue"}', contentType: 'application/json', expected: JSON.stringify({ myKey: 'myValue' }) },
+    { body: 'body', contentType: 'very-weird-content-type/foo', expected: 'body' },
+    { body: 'my text', contentType: 'text/html', expected: 'my texthtml' }
+  ]
+
+  for (const { body, contentType, expected } of assertions) {
+    const response = await fetch(fastifyServer, {
+      method: 'POST',
+      body,
+      headers: {
+        'Content-Type': contentType
+      }
+    })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.text(), expected)
+  }
+})