node-fastify 5.8.3

package/test/esm/other.mjs

@@ -0,0 +1,8 @@
+// Imported in both index.test.js & esm.test.mjs
+import { strictEqual } from 'node:assert'
+
+async function other (fastify, opts) {
+  strictEqual(fastify.foo, 'bar')
+}
+
+export default other

package/test/esm/plugin.mjs

@@ -0,0 +1,8 @@
+// Imported in both index.test.js & esm.test.mjs
+async function plugin (fastify, opts) {
+  fastify.decorate('foo', opts.foo)
+}
+
+plugin[Symbol.for('skip-override')] = true
+
+export default plugin

package/test/fastify-instance.test.js

@@ -0,0 +1,300 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+const os = require('node:os')
+
+const {
+  kOptions,
+  kErrorHandler,
+  kChildLoggerFactory,
+  kState
+} = require('../lib/symbols')
+
+const isIPv6Missing = !Object.values(os.networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
+
+test('root fastify instance is an object', t => {
+  t.plan(1)
+  t.assert.strictEqual(typeof Fastify(), 'object')
+})
+
+test('fastify instance should contains ajv options', t => {
+  t.plan(1)
+  const fastify = Fastify({
+    ajv: {
+      customOptions: {
+        nullable: false
+      }
+    }
+  })
+  t.assert.deepStrictEqual(fastify[kOptions].ajv, {
+    customOptions: {
+      nullable: false
+    },
+    plugins: []
+  })
+})
+
+test('fastify instance should contains ajv options.plugins nested arrays', t => {
+  t.plan(1)
+  const fastify = Fastify({
+    ajv: {
+      customOptions: {
+        nullable: false
+      },
+      plugins: [[]]
+    }
+  })
+  t.assert.deepStrictEqual(fastify[kOptions].ajv, {
+    customOptions: {
+      nullable: false
+    },
+    plugins: [[]]
+  })
+})
+
+test('fastify instance get invalid ajv options', t => {
+  t.plan(1)
+  t.assert.throws(() => Fastify({
+    ajv: {
+      customOptions: 8
+    }
+  }))
+})
+
+test('fastify instance get invalid ajv options.plugins', t => {
+  t.plan(1)
+  t.assert.throws(() => Fastify({
+    ajv: {
+      customOptions: {},
+      plugins: 8
+    }
+  }))
+})
+
+test('fastify instance should contain default errorHandler', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.assert.ok(fastify[kErrorHandler].func instanceof Function)
+  t.assert.deepStrictEqual(fastify.errorHandler, fastify[kErrorHandler].func)
+  t.assert.deepStrictEqual(Object.getOwnPropertyDescriptor(fastify, 'errorHandler').set, undefined)
+})
+
+test('errorHandler in plugin should be separate from the external one', async t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    const inPluginErrHandler = (_, __, reply) => {
+      reply.send({ plugin: 'error-object' })
+    }
+
+    instance.setErrorHandler(inPluginErrHandler)
+
+    t.assert.notDeepStrictEqual(instance.errorHandler, fastify.errorHandler)
+    t.assert.strictEqual(instance.errorHandler.name, 'bound inPluginErrHandler')
+
+    done()
+  })
+
+  await fastify.ready()
+
+  t.assert.ok(fastify[kErrorHandler].func instanceof Function)
+  t.assert.deepStrictEqual(fastify.errorHandler, fastify[kErrorHandler].func)
+})
+
+test('fastify instance should contain default childLoggerFactory', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.assert.ok(fastify[kChildLoggerFactory] instanceof Function)
+  t.assert.deepStrictEqual(fastify.childLoggerFactory, fastify[kChildLoggerFactory])
+  t.assert.deepStrictEqual(Object.getOwnPropertyDescriptor(fastify, 'childLoggerFactory').set, undefined)
+})
+
+test('childLoggerFactory in plugin should be separate from the external one', async t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    const inPluginLoggerFactory = function (logger, bindings, opts) {
+      return logger.child(bindings, opts)
+    }
+
+    instance.setChildLoggerFactory(inPluginLoggerFactory)
+
+    t.assert.notDeepStrictEqual(instance.childLoggerFactory, fastify.childLoggerFactory)
+    t.assert.strictEqual(instance.childLoggerFactory.name, 'inPluginLoggerFactory')
+
+    done()
+  })
+
+  await fastify.ready()
+
+  t.assert.ok(fastify[kChildLoggerFactory] instanceof Function)
+  t.assert.deepStrictEqual(fastify.childLoggerFactory, fastify[kChildLoggerFactory])
+})
+
+test('ready should resolve in order when called multiply times (promises only)', async (t) => {
+  const app = Fastify()
+  const expectedOrder = [1, 2, 3, 4, 5]
+  const result = []
+
+  const promises = [1, 2, 3, 4, 5]
+    .map((id) => app.ready().then(() => result.push(id)))
+
+  await Promise.all(promises)
+
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
+})
+
+test('ready should reject in order when called multiply times (promises only)', async (t) => {
+  const app = Fastify()
+  const expectedOrder = [1, 2, 3, 4, 5]
+  const result = []
+
+  app.register((instance, opts, done) => {
+    setTimeout(() => done(new Error('test')), 500)
+  })
+
+  const promises = [1, 2, 3, 4, 5]
+    .map((id) => app.ready().catch(() => result.push(id)))
+
+  await Promise.all(promises)
+
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
+})
+
+test('ready should reject in order when called multiply times (callbacks only)', async (t) => {
+  const app = Fastify()
+  const expectedOrder = [1, 2, 3, 4, 5]
+  const result = []
+
+  app.register((instance, opts, done) => {
+    setTimeout(() => done(new Error('test')), 500)
+  })
+
+  expectedOrder.map((id) => app.ready(() => result.push(id)))
+
+  await app.ready().catch(err => {
+    t.assert.strictEqual(err.message, 'test')
+  })
+
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
+})
+
+test('ready should resolve in order when called multiply times (callbacks only)', async (t) => {
+  const app = Fastify()
+  const expectedOrder = [1, 2, 3, 4, 5]
+  const result = []
+
+  expectedOrder.map((id) => app.ready(() => result.push(id)))
+
+  await app.ready()
+
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
+})
+
+test('ready should resolve in order when called multiply times (mixed)', async (t) => {
+  const app = Fastify()
+  const expectedOrder = [1, 2, 3, 4, 5, 6]
+  const result = []
+
+  for (const order of expectedOrder) {
+    if (order % 2) {
+      app.ready(() => result.push(order))
+    } else {
+      app.ready().then(() => result.push(order))
+    }
+  }
+
+  await app.ready()
+
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
+})
+
+test('ready should reject in order when called multiply times (mixed)', async (t) => {
+  const app = Fastify()
+  const expectedOrder = [1, 2, 3, 4, 5, 6]
+  const result = []
+
+  app.register((instance, opts, done) => {
+    setTimeout(() => done(new Error('test')), 500)
+  })
+
+  for (const order of expectedOrder) {
+    if (order % 2) {
+      app.ready(() => result.push(order))
+    } else {
+      app.ready().then(null, () => result.push(order))
+    }
+  }
+
+  await app.ready().catch(err => {
+    t.assert.strictEqual(err.message, 'test')
+  })
+
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
+})
+
+test('ready should resolve in order when called multiply times (mixed)', async (t) => {
+  const app = Fastify()
+  const expectedOrder = [1, 2, 3, 4, 5, 6]
+  const result = []
+
+  for (const order of expectedOrder) {
+    if (order % 2) {
+      app.ready().then(() => result.push(order))
+    } else {
+      app.ready(() => result.push(order))
+    }
+  }
+
+  await app.ready()
+
+  t.assert.deepStrictEqual(result, expectedOrder, 'Should resolve in order')
+})
+
+test('fastify instance should contains listeningOrigin property (with port and host)', async t => {
+  t.plan(1)
+  const port = 3000
+  const host = '127.0.0.1'
+  const fastify = Fastify()
+  await fastify.listen({ port, host })
+  t.assert.deepStrictEqual(fastify.listeningOrigin, `http://${host}:${port}`)
+  await fastify.close()
+})
+
+test('fastify instance should contains listeningOrigin property (with port and https)', async t => {
+  t.plan(1)
+  const port = 3000
+  const host = '127.0.0.1'
+  const fastify = Fastify({ https: {} })
+  await fastify.listen({ port, host })
+  t.assert.deepStrictEqual(fastify.listeningOrigin, `https://${host}:${port}`)
+  await fastify.close()
+})
+
+test('fastify instance should contains listeningOrigin property (unix socket)', { skip: os.platform() === 'win32' }, async t => {
+  const fastify = Fastify()
+  const path = `fastify.${Date.now()}.sock`
+  await fastify.listen({ path })
+  t.assert.deepStrictEqual(fastify.listeningOrigin, path)
+  await fastify.close()
+})
+
+test('fastify instance should contains listeningOrigin property (IPv6)', { skip: isIPv6Missing }, async t => {
+  t.plan(1)
+  const port = 3000
+  const host = '::1'
+  const fastify = Fastify()
+  await fastify.listen({ port, host })
+  t.assert.deepStrictEqual(fastify.listeningOrigin, `http://[::1]:${port}`)
+  await fastify.close()
+})
+
+test('fastify instance should ensure ready promise cleanup on ready', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  await fastify.ready()
+  t.assert.strictEqual(fastify[kState].readyResolver, null)
+})

package/test/find-route.test.js

@@ -0,0 +1,152 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+const fastifyPlugin = require('fastify-plugin')
+
+test('findRoute should return null when route cannot be found due to a different method', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  t.assert.strictEqual(fastify.findRoute({
+    method: 'POST',
+    url: '/artists/:artistId'
+  }), null)
+})
+
+test('findRoute should return an immutable route to avoid leaking and runtime route modifications', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  let route = fastify.findRoute({
+    method: 'GET',
+    url: '/artists/:artistId'
+  })
+
+  route.params = {
+    ...route.params,
+    id: ':id'
+  }
+
+  route = fastify.findRoute({
+    method: 'GET',
+    url: '/artists/:artistId'
+  })
+
+  t.assert.strictEqual(route.params.artistId, ':artistId')
+})
+
+test('findRoute should return null when when url is not passed', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  t.assert.strictEqual(fastify.findRoute({
+    method: 'POST'
+  }), null)
+})
+
+test('findRoute should return null when route cannot be found due to a different path', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  t.assert.strictEqual(fastify.findRoute({
+    method: 'GET',
+    url: '/books/:bookId'
+  }), null)
+})
+
+test('findRoute should return the route when found', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  const handler = (req, reply) => reply.send(typeof req.params.artistId)
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler
+  })
+
+  const route = fastify.findRoute({
+    method: 'GET',
+    url: '/artists/:artistId'
+  })
+  t.assert.strictEqual(route.params.artistId, ':artistId')
+})
+
+test('findRoute should work correctly when used within plugins', (t, done) => {
+  t.plan(1)
+  const fastify = Fastify()
+  const handler = (req, reply) => reply.send(typeof req.params.artistId)
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler
+  })
+
+  function validateRoutePlugin (instance, opts, done) {
+    const validateParams = function () {
+      return instance.findRoute({
+        method: 'GET',
+        url: '/artists/:artistId'
+      }) !== null
+    }
+    instance.decorate('validateRoutes', { validateParams })
+    done()
+  }
+
+  fastify.register(fastifyPlugin(validateRoutePlugin))
+
+  fastify.ready(() => {
+    t.assert.strictEqual(fastify.validateRoutes.validateParams(), true)
+    done()
+  })
+})
+
+test('findRoute should not expose store', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  const route = fastify.findRoute({
+    method: 'GET',
+    url: '/artists/:artistId'
+  })
+  t.assert.strictEqual(route.store, undefined)
+})

package/test/fluent-schema.test.js

@@ -0,0 +1,209 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+const S = require('fluent-json-schema')
+
+test('use fluent-json-schema object', async (t) => {
+  t.plan(10)
+  const fastify = Fastify()
+
+  fastify.post('/:id', {
+    handler: (req, reply) => { reply.send({ name: 'a', surname: 'b', dateOfBirth: '01-01-2020' }) },
+    schema: {
+      params: S.object().prop('id', S.integer().minimum(42)),
+      headers: S.object().prop('x-custom', S.string().format('email')),
+      query: S.object().prop('surname', S.string().required()),
+      body: S.object().prop('name', S.string().required()),
+      response: {
+        200: S.object()
+          .prop('name', S.string())
+          .prop('surname', S.string())
+      }
+    }
+  })
+
+  const res1 = await fastify.inject({
+    method: 'POST',
+    url: '/1',
+    headers: { 'x-custom': 'me@me.me' },
+    query: { surname: 'bar' },
+    payload: { name: 'foo' }
+  })
+  t.assert.strictEqual(res1.statusCode, 400)
+  t.assert.deepStrictEqual(res1.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'params/id must be >= 42' })
+
+  // check header
+  const res2 = await fastify.inject({
+    method: 'POST',
+    url: '/42',
+    headers: { 'x-custom': 'invalid' },
+    query: { surname: 'bar' },
+    payload: { name: 'foo' }
+  })
+  t.assert.strictEqual(res2.statusCode, 400)
+  t.assert.deepStrictEqual(res2.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'headers/x-custom must match format "email"' })
+
+  // check query
+  const res3 = await fastify.inject({
+    method: 'POST',
+    url: '/42',
+    headers: { 'x-custom': 'me@me.me' },
+    query: { },
+    payload: { name: 'foo' }
+  })
+  t.assert.strictEqual(res3.statusCode, 400)
+  t.assert.deepStrictEqual(res3.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'querystring must have required property \'surname\'' })
+
+  // check body
+  const res4 = await fastify.inject({
+    method: 'POST',
+    url: '/42',
+    headers: { 'x-custom': 'me@me.me' },
+    query: { surname: 'bar' },
+    payload: { name: [1, 2, 3] }
+  })
+  t.assert.strictEqual(res4.statusCode, 400)
+  t.assert.deepStrictEqual(res4.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: 'body/name must be string' })
+
+  // check response
+  const res5 = await fastify.inject({
+    method: 'POST',
+    url: '/42',
+    headers: { 'x-custom': 'me@me.me' },
+    query: { surname: 'bar' },
+    payload: { name: 'foo' }
+  })
+  t.assert.strictEqual(res5.statusCode, 200)
+  t.assert.deepStrictEqual(res5.json(), { name: 'a', surname: 'b' })
+})
+
+test('use complex fluent-json-schema object', (t, done) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  const addressSchema = S.object()
+    .id('#address')
+    .prop('line1').required()
+    .prop('line2')
+    .prop('country').required()
+    .prop('city').required()
+    .prop('zipcode').required()
+
+  const commonSchemas = S.object()
+    .id('https://fastify/demo')
+    .definition('addressSchema', addressSchema)
+
+  fastify.addSchema(commonSchemas)
+
+  const bodyJsonSchema = S.object()
+    .prop('residence', S.ref('https://fastify/demo#address')).required()
+    .prop('office', S.ref('https://fastify/demo#/definitions/addressSchema')).required()
+
+  fastify.post('/the/url', { schema: { body: bodyJsonSchema } }, () => { })
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
+})
+
+test('use fluent schema and plain JSON schema', (t, done) => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  const addressSchema = S.object()
+    .id('#address')
+    .prop('line1').required()
+    .prop('line2')
+    .prop('country').required()
+    .prop('city').required()
+    .prop('zipcode').required()
+
+  const commonSchemas = S.object()
+    .id('https://fastify/demo')
+    .definition('addressSchema', addressSchema)
+
+  const sharedAddressSchema = {
+    $id: 'sharedAddress',
+    type: 'object',
+    required: ['line1', 'country', 'city', 'zipcode'],
+    properties: {
+      line1: { type: 'string' },
+      line2: { type: 'string' },
+      country: { type: 'string' },
+      city: { type: 'string' },
+      zipcode: { type: 'string' }
+    }
+  }
+
+  fastify.addSchema(commonSchemas)
+  fastify.addSchema(sharedAddressSchema)
+
+  const bodyJsonSchema = S.object()
+    .prop('residence', S.ref('https://fastify/demo#address')).required()
+    .prop('office', S.ref('https://fastify/demo#/definitions/addressSchema')).required()
+
+  fastify.post('/the/url', { schema: { body: bodyJsonSchema } }, () => { })
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
+})
+
+test('Should call valueOf internally', (t, done) => {
+  t.plan(1)
+
+  const fastify = new Fastify()
+
+  const addressSchema = S.object()
+    .id('#address')
+    .prop('line1').required()
+    .prop('line2')
+    .prop('country').required()
+    .prop('city').required()
+    .prop('zipcode').required()
+
+  const commonSchemas = S.object()
+    .id('https://fastify/demo')
+    .definition('addressSchema', addressSchema)
+
+  fastify.addSchema(commonSchemas)
+
+  fastify.route({
+    method: 'POST',
+    url: '/query',
+    handler: () => {},
+    schema: {
+      query: S.object().prop('hello', S.string()).required(),
+      body: S.object().prop('hello', S.string()).required(),
+      params: S.object().prop('hello', S.string()).required(),
+      headers: S.object().prop('hello', S.string()).required(),
+      response: {
+        200: S.object().prop('hello', S.string()).required(),
+        201: S.object().prop('hello', S.string()).required()
+      }
+    }
+  })
+
+  fastify.route({
+    method: 'POST',
+    url: '/querystring',
+    handler: () => {},
+    schema: {
+      querystring: S.object().prop('hello', S.string()).required(),
+      body: S.object().prop('hello', S.string()).required(),
+      params: S.object().prop('hello', S.string()).required(),
+      headers: S.object().prop('hello', S.string()).required(),
+      response: {
+        200: S.object().prop('hello', S.string()).required(),
+        201: S.object().prop('hello', S.string()).required()
+      }
+    }
+  })
+
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
+})