node-fastify 5.8.3

package/test/throw.test.js

@@ -0,0 +1,359 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('Fastify should throw on wrong options', (t) => {
+  t.plan(2)
+  try {
+    Fastify('lol')
+    t.assert.fail()
+  } catch (e) {
+    t.assert.strictEqual(e.message, 'Options must be an object')
+    t.assert.ok(true)
+  }
+})
+
+test('Fastify should throw on multiple assignment to the same route', (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/', () => {})
+
+  try {
+    fastify.get('/', () => {})
+    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)
+
+  const badSchema = {
+    type: 'object',
+    properties: {
+      bad: {
+        type: 'bad-type'
+      }
+    }
+  }
+  const fastify = Fastify()
+  fastify.get('/', { schema: { headers: badSchema } }, () => {})
+  fastify.get('/not-loaded', { schema: { headers: badSchema } }, () => {})
+
+  await t.assert.rejects(fastify.ready(), {
+    code: 'FST_ERR_SCH_VALIDATION_BUILD',
+    message: /Failed building the validation schema for GET: \//
+  })
+})
+
+test('Fastify should throw for an invalid schema, printing the error route - body', async (t) => {
+  t.plan(1)
+  const badSchema = {
+    type: 'object',
+    properties: {
+      bad: {
+        type: 'bad-type'
+      }
+    }
+  }
+
+  const fastify = Fastify()
+  fastify.register((instance, opts, done) => {
+    instance.post('/form', { schema: { body: badSchema } }, () => {})
+    done()
+  }, { prefix: 'hello' })
+
+  await t.assert.rejects(fastify.ready(), {
+    code: 'FST_ERR_SCH_VALIDATION_BUILD',
+    message: /Failed building the validation schema for POST: \/hello\/form/
+  })
+})
+
+test('Should throw on unsupported method', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+  try {
+    fastify.route({
+      method: 'TROLL',
+      url: '/',
+      schema: {},
+      handler: function (req, reply) {}
+    })
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})
+
+test('Should throw on missing handler', (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+  try {
+    fastify.route({
+      method: 'GET',
+      url: '/'
+    })
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})
+
+test('Should throw if one method is unsupported', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+  try {
+    fastify.route({
+      method: ['GET', 'TROLL'],
+      url: '/',
+      schema: {},
+      handler: function (req, reply) {}
+    })
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})
+
+test('Should throw on duplicate content type parser', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+  function customParser (req, payload, done) { done(null, '') }
+
+  fastify.addContentTypeParser('application/qq', customParser)
+  try {
+    fastify.addContentTypeParser('application/qq', customParser)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})
+
+test('Should throw on duplicate decorator', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify()
+  const fooObj = {}
+
+  fastify.decorate('foo', fooObj)
+  try {
+    fastify.decorate('foo', fooObj)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})
+
+test('Should not throw on duplicate decorator encapsulation', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+  const foo2Obj = {}
+
+  fastify.decorate('foo2', foo2Obj)
+
+  fastify.register(function (fastify, opts, done) {
+    t.assert.doesNotThrow(() => {
+      fastify.decorate('foo2', foo2Obj)
+    })
+    done()
+  })
+
+  await fastify.ready()
+})
+
+test('Should throw on duplicate request decorator', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.decorateRequest('foo', null)
+  try {
+    fastify.decorateRequest('foo', null)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.strictEqual(e.code, 'FST_ERR_DEC_ALREADY_PRESENT')
+    t.assert.strictEqual(e.message, 'The decorator \'foo\' has already been added!')
+  }
+})
+
+test('Should throw if request decorator dependencies are not met', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  try {
+    fastify.decorateRequest('bar', null, ['world'])
+    t.assert.fail()
+  } catch (e) {
+    t.assert.strictEqual(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')
+    t.assert.strictEqual(e.message, 'The decorator is missing dependency \'world\'.')
+  }
+})
+
+test('Should throw on duplicate reply decorator', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  fastify.decorateReply('foo', null)
+  try {
+    fastify.decorateReply('foo', null)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(/has already been added/.test(e.message))
+  }
+})
+
+test('Should throw if reply decorator dependencies are not met', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  try {
+    fastify.decorateReply('bar', null, ['world'])
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(/missing dependency/.test(e.message))
+  }
+})
+
+test('Should throw if handler as the third parameter to the shortcut method is missing and the second parameter is not a function and also not an object', async (t) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  try {
+    fastify.get('/foo/1', '')
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/2', 1)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/3', [])
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/4', undefined)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/5', null)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})
+
+test('Should throw if handler as the third parameter to the shortcut method is missing and the second parameter is not a function and also not an object', async (t) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  try {
+    fastify.get('/foo/1', '')
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/2', 1)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/3', [])
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/4', undefined)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/5', null)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})
+
+test('Should throw if there is handler function as the third parameter to the shortcut method and options as the second parameter is not an object', async (t) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  try {
+    fastify.get('/foo/1', '', (req, res) => {})
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/2', 1, (req, res) => {})
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/3', [], (req, res) => {})
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/4', undefined, (req, res) => {})
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+
+  try {
+    fastify.get('/foo/5', null, (req, res) => {})
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})
+
+test('Should throw if found duplicate handler as the third parameter to the shortcut method and in options', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  try {
+    fastify.get('/foo/abc', {
+      handler: (req, res) => {}
+    }, (req, res) => {})
+    t.assert.fail()
+  } catch (e) {
+    t.assert.ok(true)
+  }
+})

package/test/toolkit.js

@@ -0,0 +1,63 @@
+'use strict'
+
+exports.waitForCb = function (options) {
+  let count = null
+  let done = false
+  let iResolve
+  let iReject
+
+  function stepIn () {
+    if (done) {
+      iReject(new Error('Unexpected done call'))
+      return
+    }
+
+    if (--count) {
+      return
+    }
+
+    done = true
+    iResolve()
+  }
+
+  const patience = new Promise((resolve, reject) => {
+    iResolve = resolve
+    iReject = reject
+  })
+
+  count = options.steps || 1
+  done = false
+
+  return { stepIn, patience }
+}
+
+exports.partialDeepStrictEqual = function partialDeepStrictEqual (actual, expected) {
+  if (typeof expected !== 'object' || expected === null) {
+    return actual === expected
+  }
+
+  if (typeof actual !== 'object' || actual === null) {
+    return false
+  }
+
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) return false
+    if (expected.length > actual.length) return false
+
+    for (let i = 0; i < expected.length; i++) {
+      if (!partialDeepStrictEqual(actual[i], expected[i])) {
+        return false
+      }
+    }
+    return true
+  }
+
+  for (const key of Object.keys(expected)) {
+    if (!(key in actual)) return false
+    if (!partialDeepStrictEqual(actual[key], expected[key])) {
+      return false
+    }
+  }
+
+  return true
+}

package/test/trust-proxy.test.js

@@ -0,0 +1,162 @@
+'use strict'
+
+const { test, before } = require('node:test')
+const fastify = require('..')
+const helper = require('./helper')
+
+const fetchForwardedRequest = async (fastifyServer, forHeader, path, protoHeader) => {
+  const headers = {
+    'X-Forwarded-For': forHeader,
+    'X-Forwarded-Host': 'fastify.test'
+  }
+  if (protoHeader) {
+    headers['X-Forwarded-Proto'] = protoHeader
+  }
+
+  return fetch(fastifyServer + path, {
+    headers
+  })
+}
+
+const testRequestValues = (t, req, options) => {
+  if (options.ip) {
+    t.assert.ok(req.ip, 'ip is defined')
+    t.assert.strictEqual(req.ip, options.ip, 'gets ip from x-forwarded-for')
+  }
+  if (options.host) {
+    t.assert.ok(req.host, 'host is defined')
+    t.assert.strictEqual(req.host, options.host, 'gets host from x-forwarded-host')
+    t.assert.ok(req.hostname)
+    t.assert.strictEqual(req.hostname, options.host, 'gets hostname from x-forwarded-host')
+  }
+  if (options.ips) {
+    t.assert.deepStrictEqual(req.ips, options.ips, 'gets ips from x-forwarded-for')
+  }
+  if (options.protocol) {
+    t.assert.ok(req.protocol, 'protocol is defined')
+    t.assert.strictEqual(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
+  }
+  if (options.port) {
+    t.assert.ok(req.port, 'port is defined')
+    t.assert.strictEqual(req.port, options.port, 'port is taken from x-forwarded-for or host')
+  }
+}
+
+let localhost
+before(async function () {
+  [localhost] = await helper.getLoopbackHost()
+})
+
+test('trust proxy, not add properties to node req', async t => {
+  t.plan(13)
+  const app = fastify({
+    trustProxy: true
+  })
+  t.after(() => app.close())
+
+  app.get('/trustproxy', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+
+  app.get('/trustproxychain', function (req, reply) {
+    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'], port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+
+  const fastifyServer = await app.listen({ port: 0 })
+
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxy', undefined)
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined)
+})
+
+test('trust proxy chain', async t => {
+  t.plan(8)
+  const app = fastify({
+    trustProxy: [localhost, '192.168.1.1']
+  })
+  t.after(() => app.close())
+
+  app.get('/trustproxychain', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined)
+})
+
+test('trust proxy function', async t => {
+  t.plan(8)
+  const app = fastify({
+    trustProxy: (address) => address === localhost
+  })
+  t.after(() => app.close())
+
+  app.get('/trustproxyfunc', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyfunc', undefined)
+})
+
+test('trust proxy number', async t => {
+  t.plan(9)
+  const app = fastify({
+    trustProxy: 1
+  })
+  t.after(() => app.close())
+
+  app.get('/trustproxynumber', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'fastify.test', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined)
+})
+
+test('trust proxy IP addresses', async t => {
+  t.plan(9)
+  const app = fastify({
+    trustProxy: `${localhost}, 2.2.2.2`
+  })
+  t.after(() => app.close())
+
+  app.get('/trustproxyipaddrs', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'fastify.test', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined)
+})
+
+test('trust proxy protocol', async t => {
+  t.plan(30)
+  const app = fastify({
+    trustProxy: true
+  })
+  t.after(() => app.close())
+
+  app.get('/trustproxyprotocol', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem', host: 'fastify.test', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+  app.get('/trustproxynoprotocol', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'http', host: 'fastify.test', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+  app.get('/trustproxyprotocols', function (req, reply) {
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'dolor', host: 'fastify.test', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
+  })
+
+  const fastifyServer = await app.listen({ port: 0 })
+
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocol', 'lorem')
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxynoprotocol', undefined)
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor')
+})

package/test/type-provider.test.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('Should export withTypeProvider function', (t, done) => {
+  t.plan(1)
+  try {
+    Fastify().withTypeProvider()
+    t.assert.ok('pass')
+    done()
+  } catch (e) {
+    t.assert.fail(e)
+  }
+})
+
+test('Should return same instance', (t, done) => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.assert.strictEqual(fastify, fastify.withTypeProvider())
+  done()
+})

package/test/types/content-type-parser.test-d.ts

@@ -0,0 +1,72 @@
+import fastify, { FastifyBodyParser } from '../../fastify'
+import { expectError, expectType } from 'tsd'
+import { IncomingMessage } from 'node:http'
+import { FastifyRequest } from '../../types/request'
+
+expectType<void>(fastify().addContentTypeParser('contentType', function (request, payload, done) {
+  expectType<FastifyRequest>(request)
+  expectType<IncomingMessage>(payload)
+  done(null)
+}))
+
+// Body limit options
+
+expectType<void>(fastify().addContentTypeParser('contentType', { bodyLimit: 99 }, function (request, payload, done) {
+  expectType<FastifyRequest>(request)
+  expectType<IncomingMessage>(payload)
+  done(null)
+}))
+
+// Array for contentType
+
+expectType<void>(fastify().addContentTypeParser(['contentType'], function (request, payload, done) {
+  expectType<FastifyRequest>(request)
+  expectType<IncomingMessage>(payload)
+  done(null)
+}))
+
+// Body Parser - the generic after addContentTypeParser enforces the type of the `body` parameter as well as the value of the `parseAs` property
+
+expectType<void>(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, function (request, body, done) {
+  expectType<FastifyRequest>(request)
+  expectType<string>(body)
+  done(null)
+}))
+
+expectType<void>(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, function (request, body, done) {
+  expectType<FastifyRequest>(request)
+  expectType<Buffer>(body)
+  done(null)
+}))
+
+expectType<void>(fastify().addContentTypeParser('contentType', async function (request: FastifyRequest, payload: IncomingMessage) {
+  expectType<FastifyRequest>(request)
+  expectType<IncomingMessage>(payload)
+  return null
+}))
+
+expectType<void>(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, async function (request: FastifyRequest, body: string) {
+  expectType<FastifyRequest>(request)
+  expectType<string>(body)
+  return null
+}))
+
+expectType<void>(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, async function (request: FastifyRequest, body: Buffer) {
+  expectType<FastifyRequest>(request)
+  expectType<Buffer>(body)
+  return null
+}))
+
+expectType<FastifyBodyParser<string>>(fastify().getDefaultJsonParser('error', 'ignore'))
+
+expectError(fastify().getDefaultJsonParser('error', 'skip'))
+
+expectError(fastify().getDefaultJsonParser('nothing', 'ignore'))
+
+expectType<void>(fastify().removeAllContentTypeParsers())
+expectError(fastify().removeAllContentTypeParsers('contentType'))
+
+expectType<void>(fastify().removeContentTypeParser('contentType'))
+expectType<void>(fastify().removeContentTypeParser(/contentType+.*/))
+expectType<void>(fastify().removeContentTypeParser(['contentType', /contentType+.*/]))
+expectError(fastify().removeContentTypeParser({}))

package/test/types/decorate-request-reply.test-d.ts

@@ -0,0 +1,18 @@
+import fastify from '../../fastify'
+import { expectType } from 'tsd'
+
+type TestType = void
+
+declare module '../../fastify' {
+  interface FastifyRequest {
+    testProp: TestType;
+  }
+  interface FastifyReply {
+    testProp: TestType;
+  }
+}
+
+fastify().get('/', (req, res) => {
+  expectType<TestType>(req.testProp)
+  expectType<TestType>(res.testProp)
+})

package/test/types/dummy-plugin.ts

@@ -0,0 +1,9 @@
+import { FastifyPluginAsync } from '../../fastify'
+
+export interface DummyPluginOptions {
+  foo?: number
+}
+
+declare const DummyPlugin: FastifyPluginAsync<DummyPluginOptions>
+
+export default DummyPlugin