node-fastify 5.8.3

package/test/internals/validation.test.js

@@ -0,0 +1,352 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const Ajv = require('ajv')
+const ajv = new Ajv({ coerceTypes: true })
+
+const validation = require('../../lib/validation')
+const { normalizeSchema } = require('../../lib/schemas')
+const symbols = require('../../lib/validation').symbols
+const { kSchemaVisited } = require('../../lib/symbols')
+
+test('Symbols', t => {
+  t.plan(5)
+  t.assert.strictEqual(typeof symbols.responseSchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.bodySchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.querystringSchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.paramsSchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.headersSchema, 'symbol')
+})
+
+;['compileSchemasForValidation',
+  'compileSchemasForSerialization'].forEach(func => {
+  test(`${func} schema - missing schema`, t => {
+    t.plan(2)
+    const context = {}
+    validation[func](context)
+    t.assert.strictEqual(typeof context[symbols.bodySchema], 'undefined')
+    t.assert.strictEqual(typeof context[symbols.responseSchema], 'undefined')
+  })
+
+  test(`${func} schema - missing output schema`, t => {
+    t.plan(1)
+    const context = { schema: {} }
+    validation[func](context, null)
+    t.assert.strictEqual(typeof context[symbols.responseSchema], 'undefined')
+  })
+})
+
+test('build schema - output schema', t => {
+  t.plan(2)
+  const opts = {
+    schema: {
+      response: {
+        '2xx': {
+          type: 'object',
+          properties: {
+            hello: { type: 'string' }
+          }
+        },
+        201: {
+          type: 'object',
+          properties: {
+            hello: { type: 'number' }
+          }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForSerialization(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.strictEqual(typeof opts[symbols.responseSchema]['2xx'], 'function')
+  t.assert.strictEqual(typeof opts[symbols.responseSchema]['201'], 'function')
+})
+
+test('build schema - body schema', t => {
+  t.plan(1)
+  const opts = {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.strictEqual(typeof opts[symbols.bodySchema], 'function')
+})
+
+test('build schema - body with multiple content type schemas', t => {
+  t.plan(2)
+  const opts = {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                hello: { type: 'string' }
+              }
+            }
+          },
+          'text/plain': {
+            schema: { type: 'string' }
+          }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.ok(opts[symbols.bodySchema]['application/json'], 'function')
+  t.assert.ok(opts[symbols.bodySchema]['text/plain'], 'function')
+})
+
+test('build schema - avoid repeated normalize schema', t => {
+  t.plan(3)
+  const serverConfig = {}
+  const opts = {
+    schema: {
+      query: {
+        type: 'object',
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    }
+  }
+  opts.schema = normalizeSchema(opts.schema, serverConfig)
+  t.assert.notStrictEqual(kSchemaVisited, undefined)
+  t.assert.strictEqual(opts.schema[kSchemaVisited], true)
+  t.assert.strictEqual(opts.schema, normalizeSchema(opts.schema, serverConfig))
+})
+
+test('build schema - query schema', t => {
+  t.plan(2)
+  const serverConfig = {}
+  const opts = {
+    schema: {
+      query: {
+        type: 'object',
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    }
+  }
+  opts.schema = normalizeSchema(opts.schema, serverConfig)
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.ok(typeof opts[symbols.querystringSchema].schema.type === 'string')
+  t.assert.strictEqual(typeof opts[symbols.querystringSchema], 'function')
+})
+
+test('build schema - query schema abbreviated', t => {
+  t.plan(2)
+  const serverConfig = {}
+  const opts = {
+    schema: {
+      query: {
+        type: 'object',
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    }
+  }
+  opts.schema = normalizeSchema(opts.schema, serverConfig)
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.ok(typeof opts[symbols.querystringSchema].schema.type === 'string')
+  t.assert.strictEqual(typeof opts[symbols.querystringSchema], 'function')
+})
+
+test('build schema - querystring schema', t => {
+  t.plan(2)
+  const opts = {
+    schema: {
+      querystring: {
+        type: 'object',
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.ok(typeof opts[symbols.querystringSchema].schema.type === 'string')
+  t.assert.strictEqual(typeof opts[symbols.querystringSchema], 'function')
+})
+
+test('build schema - querystring schema abbreviated', t => {
+  t.plan(2)
+  const serverConfig = {}
+  const opts = {
+    schema: {
+      querystring: {
+        type: 'object',
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    }
+  }
+  opts.schema = normalizeSchema(opts.schema, serverConfig)
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.ok(typeof opts[symbols.querystringSchema].schema.type === 'string')
+  t.assert.strictEqual(typeof opts[symbols.querystringSchema], 'function')
+})
+
+test('build schema - must throw if querystring and query schema exist', t => {
+  t.plan(2)
+  try {
+    const serverConfig = {}
+    const opts = {
+      schema: {
+        query: {
+          type: 'object',
+          properties: {
+            hello: { type: 'string' }
+          }
+        },
+        querystring: {
+          type: 'object',
+          properties: {
+            hello: { type: 'string' }
+          }
+        }
+      }
+    }
+    opts.schema = normalizeSchema(opts.schema, serverConfig)
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_DUPLICATE')
+    t.assert.strictEqual(err.message, 'Schema with \'querystring\' already present!')
+  }
+})
+
+test('build schema - params schema', t => {
+  t.plan(1)
+  const opts = {
+    schema: {
+      params: {
+        type: 'object',
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.strictEqual(typeof opts[symbols.paramsSchema], 'function')
+})
+
+test('build schema - headers schema', t => {
+  t.plan(1)
+  const opts = {
+    schema: {
+      headers: {
+        type: 'object',
+        properties: {
+          'content-type': { type: 'string' }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.assert.strictEqual(typeof opts[symbols.headersSchema], 'function')
+})
+
+test('build schema - headers are lowercase', t => {
+  t.plan(1)
+  const opts = {
+    schema: {
+      headers: {
+        type: 'object',
+        properties: {
+          'Content-Type': { type: 'string' }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
+    t.assert.ok(schema.properties['content-type'], 'lowercase content-type exists')
+    return () => { }
+  })
+})
+
+test('build schema - headers are not lowercased in case of custom object', t => {
+  t.plan(1)
+
+  class Headers { }
+  const opts = {
+    schema: {
+      headers: new Headers()
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
+    t.assert.ok(schema, Headers)
+    return () => { }
+  })
+})
+
+test('build schema - headers are not lowercased in case of custom validator provided', t => {
+  t.plan(1)
+
+  class Headers { }
+  const opts = {
+    schema: {
+      headers: new Headers()
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
+    t.assert.ok(schema, Headers)
+    return () => { }
+  }, true)
+})
+
+test('build schema - uppercased headers are not included', t => {
+  t.plan(1)
+  const opts = {
+    schema: {
+      headers: {
+        type: 'object',
+        properties: {
+          'Content-Type': { type: 'string' }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
+    t.assert.ok(!('Content-Type' in schema.properties), 'uppercase does not exist')
+    return () => { }
+  })
+})
+
+test('build schema - mixed schema types are individually skipped or normalized', t => {
+  t.plan(2)
+
+  class CustomSchemaClass { }
+
+  const testCases = [{
+    schema: {
+      body: new CustomSchemaClass()
+    },
+    assertions: (schema) => {
+      t.assert.ok(schema.body, CustomSchemaClass)
+    }
+  }, {
+    schema: {
+      response: {
+        200: new CustomSchemaClass()
+      }
+    },
+    assertions: (schema) => {
+      t.assert.ok(schema.response[200], CustomSchemaClass)
+    }
+  }]
+
+  testCases.forEach((testCase) => {
+    const result = normalizeSchema(testCase.schema, {})
+    testCase.assertions(result)
+  })
+})

package/test/issue-4959.test.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const { test } = require('node:test')
+const http = require('node:http')
+const Fastify = require('../fastify')
+const { setTimeout } = require('node:timers')
+
+/*
+* Ensure that a socket error during the request does not cause the
+* onSend hook to be called multiple times.
+*
+* @see https://github.com/fastify/fastify/issues/4959
+*/
+function runBadClientCall (reqOptions, payload, waitBeforeDestroy) {
+  let innerResolve, innerReject
+  const promise = new Promise((resolve, reject) => {
+    innerResolve = resolve
+    innerReject = reject
+  })
+
+  const postData = JSON.stringify(payload)
+
+  const req = http.request({
+    ...reqOptions,
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(postData)
+    }
+  }, () => {
+    innerReject(new Error('Request should have failed'))
+  })
+
+  // Kill the socket after the request has been fully written.
+  // Destroying it on `connect` can race before any bytes are sent, making the
+  // server-side assertions (hooks/handler) non-deterministic.
+  //
+  // To keep the test deterministic, we optionally wait for a server-side signal
+  // (e.g. onSend entered) before aborting the client.
+  let socket
+  req.on('socket', (s) => { socket = s })
+  req.on('finish', () => {
+    if (waitBeforeDestroy && typeof waitBeforeDestroy.then === 'function') {
+      Promise.race([
+        waitBeforeDestroy,
+        new Promise(resolve => setTimeout(resolve, 200))
+      ]).then(() => {
+        if (socket) socket.destroy()
+      }, innerResolve)
+      return
+    }
+    setTimeout(() => { socket.destroy() }, 0)
+  })
+  req.on('error', innerResolve)
+  req.write(postData)
+  req.end()
+
+  return promise
+}
+
+test('should handle a socket error', async (t) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  let resolveOnSendEntered
+  const onSendEntered = new Promise((resolve) => {
+    resolveOnSendEntered = resolve
+  })
+
+  function shouldNotHappen () {
+    t.assert.fail('This should not happen')
+  }
+  process.on('unhandledRejection', shouldNotHappen)
+
+  t.after(() => {
+    fastify.close()
+    process.removeListener('unhandledRejection', shouldNotHappen)
+  })
+
+  fastify.addHook('onRequest', async (request, reply) => {
+    t.assert.ok('onRequest hook called')
+  })
+
+  fastify.addHook('onSend', async (request, reply, payload) => {
+    if (request.onSendCalled) {
+      t.assert.fail('onSend hook called more than once')
+      return
+    }
+
+    t.assert.ok('onSend hook called')
+    request.onSendCalled = true
+
+    if (resolveOnSendEntered) {
+      resolveOnSendEntered()
+      resolveOnSendEntered = null
+    }
+
+    // Introduce a delay (gives time for client-side abort to happen while the
+    // request has already been processed, exercising the original issue).
+    await new Promise(resolve => setTimeout(resolve, 50))
+    return payload
+  })
+
+  // The handler must be async to trigger the error
+  fastify.put('/', async (request, reply) => {
+    t.assert.ok('PUT handler called')
+    return reply.send({ hello: 'world' })
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const err = await runBadClientCall({
+    hostname: 'localhost',
+    port: fastify.server.address().port,
+    path: '/',
+    method: 'PUT'
+  }, { test: 'me' }, onSendEntered)
+  t.assert.equal(err.code, 'ECONNRESET')
+})

package/test/keep-alive-timeout.test.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const Fastify = require('..')
+const http = require('node:http')
+const { test } = require('node:test')
+
+test('keepAliveTimeout', t => {
+  t.plan(6)
+
+  try {
+    Fastify({ keepAliveTimeout: 1.3 })
+    t.assert.fail('option must be an integer')
+  } catch (err) {
+    t.assert.ok(err)
+  }
+
+  try {
+    Fastify({ keepAliveTimeout: [] })
+    t.assert.fail('option must be an integer')
+  } catch (err) {
+    t.assert.ok(err)
+  }
+
+  const httpServer = Fastify({ keepAliveTimeout: 1 }).server
+  t.assert.strictEqual(httpServer.keepAliveTimeout, 1)
+
+  const httpsServer = Fastify({ keepAliveTimeout: 2, https: {} }).server
+  t.assert.strictEqual(httpsServer.keepAliveTimeout, 2)
+
+  const http2Server = Fastify({ keepAliveTimeout: 3, http2: true }).server
+  t.assert.notStrictEqual(http2Server.keepAliveTimeout, 3)
+
+  const serverFactory = (handler, _) => {
+    const server = http.createServer((req, res) => {
+      handler(req, res)
+    })
+    server.keepAliveTimeout = 5
+    return server
+  }
+  const customServer = Fastify({ keepAliveTimeout: 4, serverFactory }).server
+  t.assert.strictEqual(customServer.keepAliveTimeout, 5)
+})

package/test/listen.1.test.js

@@ -0,0 +1,154 @@
+'use strict'
+
+const { networkInterfaces } = require('node:os')
+const { test, before } = require('node:test')
+const Fastify = require('..')
+const helper = require('./helper')
+
+let localhost
+let localhostForURL
+
+before(async function () {
+  [localhost, localhostForURL] = await helper.getLoopbackHost()
+})
+
+test('listen works without arguments', async t => {
+  const doNotWarn = () => {
+    t.assert.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.after(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  await fastify.listen()
+  const address = fastify.server.address()
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
+})
+
+test('Async/await listen with arguments', async t => {
+  const doNotWarn = () => {
+    t.assert.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.after(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  const addr = await fastify.listen({ port: 0, host: '0.0.0.0' })
+  const address = fastify.server.address()
+  const { protocol, hostname, port, pathname } = new URL(addr)
+  t.assert.strictEqual(protocol, 'http:')
+  t.assert.ok(Object.values(networkInterfaces())
+    .flat()
+    .filter(({ internal }) => internal)
+    .some(({ address }) => address === hostname))
+  t.assert.strictEqual(pathname, '/')
+  t.assert.strictEqual(Number(port), address.port)
+  t.assert.deepEqual(address, {
+    address: '0.0.0.0',
+    family: 'IPv4',
+    port: address.port
+  })
+})
+
+test('listen accepts a callback', (t, done) => {
+  t.plan(2)
+  const doNotWarn = () => {
+    t.assert.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.after(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  fastify.listen({ port: 0 }, (err) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    done()
+  })
+})
+
+test('listen accepts options and a callback', (t, done) => {
+  t.plan(1)
+  const doNotWarn = () => {
+    t.assert.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.after(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  fastify.listen({
+    port: 0,
+    host: 'localhost',
+    backlog: 511,
+    exclusive: false,
+    readableAll: false,
+    writableAll: false,
+    ipv6Only: false
+  }, (err) => {
+    t.assert.ifError(err)
+    done()
+  })
+})
+
+test('listen after Promise.resolve()', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  Promise.resolve()
+    .then(() => {
+      fastify.listen({ port: 0 }, (err, address) => {
+        fastify.server.unref()
+        t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+        t.assert.ifError(err)
+        done()
+      })
+    })
+})
+
+test('listen works with undefined host', async t => {
+  const doNotWarn = () => {
+    t.assert.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  t.after(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  await fastify.listen({ host: undefined, port: 0 })
+  const address = fastify.server.address()
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
+})
+
+test('listen works with null host', async t => {
+  const doNotWarn = () => {
+    t.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  t.after(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  await fastify.listen({ host: null, port: 0 })
+  const address = fastify.server.address()
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
+})