node-fastify 5.8.3

package/test/input-validation.js

@@ -0,0 +1,335 @@
+'use strict'
+
+const Ajv = require('ajv')
+const Joi = require('joi')
+const yup = require('yup')
+const assert = require('node:assert')
+
+module.exports.payloadMethod = function (method, t) {
+  const test = t.test
+  const fastify = require('..')()
+  const upMethod = method.toUpperCase()
+  const loMethod = method.toLowerCase()
+
+  const opts = {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'integer'
+          }
+        }
+      }
+    }
+  }
+
+  const ajv = new Ajv({ coerceTypes: true, removeAdditional: true })
+  const optsWithCustomValidator = {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'integer'
+          }
+        },
+        additionalProperties: false
+      }
+    },
+    validatorCompiler: function ({ schema, method, url, httpPart }) {
+      return ajv.compile(schema)
+    }
+  }
+
+  const optsWithJoiValidator = {
+    schema: {
+      body: Joi.object().keys({
+        hello: Joi.string().required()
+      }).required()
+    },
+    validatorCompiler: function ({ schema, method, url, httpPart }) {
+      return schema.validate.bind(schema)
+    }
+  }
+
+  const yupOptions = {
+    strict: true, // don't coerce
+    abortEarly: false, // return all errors
+    stripUnknown: true, // remove additional properties
+    recursive: true
+  }
+
+  const optsWithYupValidator = {
+    schema: {
+      body: yup.object().shape({
+        hello: yup.string().required()
+      }).required()
+    },
+    validatorCompiler: function ({ schema, method, url, httpPart }) {
+      return data => {
+        try {
+          const result = schema.validateSync(data, yupOptions)
+          return { value: result }
+        } catch (e) {
+          return { error: [e] }
+        }
+      }
+    }
+  }
+
+  test(`${upMethod} can be created`, t => {
+    t.plan(1)
+    try {
+      fastify[loMethod]('/', opts, function (req, reply) {
+        reply.send(req.body)
+      })
+      fastify[loMethod]('/custom', optsWithCustomValidator, function (req, reply) {
+        reply.send(req.body)
+      })
+      fastify[loMethod]('/joi', optsWithJoiValidator, function (req, reply) {
+        reply.send(req.body)
+      })
+      fastify[loMethod]('/yup', optsWithYupValidator, function (req, reply) {
+        reply.send(req.body)
+      })
+
+      fastify.register(function (fastify2, opts, done) {
+        fastify2.setValidatorCompiler(function schema ({ schema, method, url, httpPart }) {
+          return body => ({ error: new Error('From custom schema compiler!') })
+        })
+        const withInstanceCustomCompiler = {
+          schema: {
+            body: {
+              type: 'object',
+              properties: { },
+              additionalProperties: false
+            }
+          }
+        }
+        fastify2[loMethod]('/plugin', withInstanceCustomCompiler, (req, reply) => reply.send({ hello: 'never here!' }))
+
+        const optsWithCustomValidator2 = {
+          schema: {
+            body: {
+              type: 'object',
+              properties: { },
+              additionalProperties: false
+            }
+          },
+          validatorCompiler: function ({ schema, method, url, httpPart }) {
+            return function (body) {
+              return { error: new Error('Always fail!') }
+            }
+          }
+        }
+        fastify2[loMethod]('/plugin/custom', optsWithCustomValidator2, (req, reply) => reply.send({ hello: 'never here!' }))
+
+        done()
+      })
+      t.assert.ok(true)
+    } catch (e) {
+      t.assert.fail()
+    }
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    assert.ifError(err)
+
+    t.after(() => { fastify.close() })
+
+    test(`${upMethod} - correctly replies`, async (t) => {
+      if (upMethod === 'HEAD') {
+        t.plan(2)
+        const result = await fetch('http://localhost:' + fastify.server.address().port, {
+          method: upMethod
+        })
+        t.assert.ok(result.ok)
+        t.assert.strictEqual(result.status, 200)
+      } else {
+        t.plan(3)
+
+        const result = await fetch('http://localhost:' + fastify.server.address().port, {
+          method: upMethod,
+          body: JSON.stringify({ hello: 42 }),
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        })
+
+        t.assert.ok(result.ok)
+        t.assert.strictEqual(result.status, 200)
+        t.assert.deepStrictEqual(await result.json(), { hello: 42 })
+      }
+    })
+
+    test(`${upMethod} - 400 on bad parameters`, async (t) => {
+      t.plan(3)
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port, {
+        method: upMethod,
+        body: JSON.stringify({ hello: 'world' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: 'body/hello must be integer',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
+      })
+    })
+
+    test(`${upMethod} - input-validation coerce`, async (t) => {
+      t.plan(3)
+
+      const restult = await fetch('http://localhost:' + fastify.server.address().port, {
+        method: upMethod,
+        body: JSON.stringify({ hello: '42' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(restult.ok)
+      t.assert.strictEqual(restult.status, 200)
+      t.assert.deepStrictEqual(await restult.json(), { hello: 42 })
+    })
+
+    test(`${upMethod} - input-validation custom schema compiler`, async (t) => {
+      t.plan(3)
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/custom', {
+        method: upMethod,
+        body: JSON.stringify({ hello: '42', world: 55 }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: 42 })
+    })
+
+    test(`${upMethod} - input-validation joi schema compiler ok`, async (t) => {
+      t.plan(3)
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/joi', {
+        method: upMethod,
+        body: JSON.stringify({ hello: '42' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: '42' })
+    })
+
+    test(`${upMethod} - input-validation joi schema compiler ko`, async (t) => {
+      t.plan(3)
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/joi', {
+        method: upMethod,
+        body: JSON.stringify({ hello: 44 }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: '"hello" must be a string',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
+      })
+    })
+
+    test(`${upMethod} - input-validation yup schema compiler ok`, async (t) => {
+      t.plan(3)
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/yup', {
+        method: upMethod,
+        body: JSON.stringify({ hello: '42' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: '42' })
+    })
+
+    test(`${upMethod} - input-validation yup schema compiler ko`, async (t) => {
+      t.plan(3)
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/yup', {
+        method: upMethod,
+        body: JSON.stringify({ hello: 44 }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: 'body hello must be a `string` type, but the final value was: `44`.',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
+      })
+    })
+
+    test(`${upMethod} - input-validation instance custom schema compiler encapsulated`, async (t) => {
+      t.plan(3)
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/plugin', {
+        method: upMethod,
+        body: JSON.stringify({}),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: 'From custom schema compiler!',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
+      })
+    })
+
+    test(`${upMethod} - input-validation custom schema compiler encapsulated`, async (t) => {
+      t.plan(3)
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/plugin/custom', {
+        method: upMethod,
+        body: JSON.stringify({}),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 400)
+      t.assert.deepStrictEqual(await result.json(), {
+        error: 'Bad Request',
+        message: 'Always fail!',
+        statusCode: 400,
+        code: 'FST_ERR_VALIDATION'
+      })
+    })
+  })
+}

package/test/internals/all.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('../..')
+
+test('fastify.all should add all the methods to the same url', async t => {
+  const fastify = Fastify()
+
+  const requirePayload = [
+    'POST',
+    'PUT',
+    'PATCH'
+  ]
+
+  const supportedMethods = fastify.supportedMethods
+  t.plan(supportedMethods.length)
+
+  fastify.all('/', (req, reply) => {
+    reply.send({ method: req.raw.method })
+  })
+
+  await Promise.all(supportedMethods.map(async method => injectRequest(method)))
+
+  async function injectRequest (method) {
+    const options = {
+      url: '/',
+      method
+    }
+
+    if (requirePayload.includes(method)) {
+      options.payload = { hello: 'world' }
+    }
+
+    const res = await fastify.inject(options)
+    const payload = JSON.parse(res.payload)
+    t.assert.deepStrictEqual(payload, { method })
+  }
+})

package/test/internals/content-type-parser.test.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const { test } = require('node:test')
+const proxyquire = require('proxyquire')
+const { Readable } = require('node:stream')
+const { kTestInternals, kRouteContext } = require('../../lib/symbols')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('rawBody function', t => {
+  t.plan(2)
+
+  const internals = require('../../lib/content-type-parser')[kTestInternals]
+  const body = Buffer.from('你好 世界')
+  const parser = {
+    asString: true,
+    asBuffer: false,
+    fn (req, bodyInString, done) {
+      t.assert.strictEqual(bodyInString, body.toString())
+      t.assert.strictEqual(typeof done, 'function')
+      return {
+        then (cb) {
+          cb()
+        }
+      }
+    }
+  }
+  const res = {}
+  res.end = () => { }
+  res.writeHead = () => { }
+
+  res.log = { error: () => { }, info: () => { } }
+  const context = {
+    Reply,
+    Request,
+    preHandler: [],
+    onSend: [],
+    _parserOptions: {
+      limit: 1024
+    }
+  }
+  const rs = new Readable()
+  rs._read = function () { }
+  rs.headers = { 'content-length': body.length }
+  const request = new Request('id', 'params', rs, 'query', 'log', context)
+  const reply = new Reply(res, request)
+  const done = () => { }
+
+  internals.rawBody(
+    request,
+    reply,
+    reply[kRouteContext]._parserOptions,
+    parser,
+    done
+  )
+  rs.emit('data', body.toString())
+  rs.emit('end')
+})
+
+test('Should support Webpack and faux modules', t => {
+  t.plan(2)
+
+  const internals = proxyquire('../../lib/content-type-parser', {
+    'toad-cache': { default: () => { } }
+  })[kTestInternals]
+
+  const body = Buffer.from('你好 世界')
+  const parser = {
+    asString: true,
+    asBuffer: false,
+    fn (req, bodyInString, done) {
+      t.assert.strictEqual(bodyInString, body.toString())
+      t.assert.strictEqual(typeof done, 'function')
+      return {
+        then (cb) {
+          cb()
+        }
+      }
+    }
+  }
+  const res = {}
+  res.end = () => { }
+  res.writeHead = () => { }
+
+  res.log = { error: () => { }, info: () => { } }
+  const context = {
+    Reply,
+    Request,
+    preHandler: [],
+    onSend: [],
+    _parserOptions: {
+      limit: 1024
+    }
+  }
+  const rs = new Readable()
+  rs._read = function () { }
+  rs.headers = { 'content-length': body.length }
+  const request = new Request('id', 'params', rs, 'query', 'log', context)
+  const reply = new Reply(res, request)
+  const done = () => { }
+
+  internals.rawBody(
+    request,
+    reply,
+    reply[kRouteContext]._parserOptions,
+    parser,
+    done
+  )
+  rs.emit('data', body.toString())
+  rs.emit('end')
+})

package/test/internals/context.test.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { test } = require('node:test')
+const { kRouteContext } = require('../../lib/symbols')
+const Context = require('../../lib/context')
+
+const Fastify = require('../..')
+
+test('context', async context => {
+  context.plan(1)
+
+  await context.test('Should not contain undefined as key prop', async t => {
+    t.plan(4)
+    const app = Fastify()
+
+    app.get('/', (req, reply) => {
+      t.assert.ok(req[kRouteContext] instanceof Context)
+      t.assert.ok(reply[kRouteContext] instanceof Context)
+      t.assert.ok(!('undefined' in reply[kRouteContext]))
+      t.assert.ok(!('undefined' in req[kRouteContext]))
+
+      reply.send('hello world!')
+    })
+
+    try {
+      await app.inject('/')
+    } catch (e) {
+      t.assert.fail(e)
+    }
+  })
+})

package/test/internals/decorator.test.js

@@ -0,0 +1,156 @@
+'use strict'
+
+const { test } = require('node:test')
+const decorator = require('../../lib/decorate')
+const {
+  kState
+} = require('../../lib/symbols')
+
+test('decorate should add the given method to its instance', t => {
+  t.plan(1)
+  function build () {
+    server.add = decorator.add
+    server[kState] = {
+      listening: false,
+      closing: false,
+      started: false
+    }
+    return server
+    function server () {}
+  }
+
+  const server = build()
+  server.add('test', () => {})
+  t.assert.ok(server.test)
+})
+
+test('decorate is chainable', t => {
+  t.plan(3)
+  function build () {
+    server.add = decorator.add
+    server[kState] = {
+      listening: false,
+      closing: false,
+      started: false
+    }
+    return server
+    function server () {}
+  }
+
+  const server = build()
+  server
+    .add('test1', () => {})
+    .add('test2', () => {})
+    .add('test3', () => {})
+
+  t.assert.ok(server.test1)
+  t.assert.ok(server.test2)
+  t.assert.ok(server.test3)
+})
+
+test('checkExistence should check if a property is part of the given instance', t => {
+  t.plan(1)
+  const instance = { test: () => {} }
+  t.assert.ok(decorator.exist(instance, 'test'))
+})
+
+test('checkExistence should find the instance if not given', t => {
+  t.plan(1)
+  function build () {
+    server.add = decorator.add
+    server.check = decorator.exist
+    server[kState] = {
+      listening: false,
+      closing: false,
+      started: false
+    }
+    return server
+    function server () {}
+  }
+
+  const server = build()
+  server.add('test', () => {})
+  t.assert.ok(server.check('test'))
+})
+
+test('checkExistence should check the prototype as well', t => {
+  t.plan(1)
+  function Instance () {}
+  Instance.prototype.test = () => {}
+
+  const instance = new Instance()
+  t.assert.ok(decorator.exist(instance, 'test'))
+})
+
+test('checkDependencies should throw if a dependency is not present', t => {
+  t.plan(2)
+  const instance = {}
+  try {
+    decorator.dependencies(instance, 'foo', ['test'])
+    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 \'test\'.')
+  }
+})
+
+test('decorate should internally call checkDependencies', t => {
+  t.plan(2)
+  function build () {
+    server.add = decorator.add
+    server[kState] = {
+      listening: false,
+      closing: false,
+      started: false
+    }
+    return server
+    function server () {}
+  }
+
+  const server = build()
+
+  try {
+    server.add('method', () => {}, ['test'])
+    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 \'test\'.')
+  }
+})
+
+test('decorate should recognize getter/setter objects', t => {
+  t.plan(6)
+
+  const one = {
+    [kState]: {
+      listening: false,
+      closing: false,
+      started: false
+    }
+  }
+  decorator.add.call(one, 'foo', {
+    getter: () => this._a,
+    setter: (val) => {
+      t.assert.ok(true)
+      this._a = val
+    }
+  })
+  t.assert.strictEqual(Object.hasOwn(one, 'foo'), true)
+  t.assert.strictEqual(one.foo, undefined)
+  one.foo = 'a'
+  t.assert.strictEqual(one.foo, 'a')
+
+  // getter only
+  const two = {
+    [kState]: {
+      listening: false,
+      closing: false,
+      started: false
+    }
+  }
+  decorator.add.call(two, 'foo', {
+    getter: () => 'a getter'
+  })
+  t.assert.strictEqual(Object.hasOwn(two, 'foo'), true)
+  t.assert.strictEqual(two.foo, 'a getter')
+})