fastify 6.0.0-alpha.5 → 6.0.0-alpha.6

package/test/router-compile.test.js

@@ -0,0 +1,241 @@
+'use strict'
+
+const { test } = require('node:test')
+const FindMyWay = require('find-my-way')
+const Fastify = require('..')
+const { FST_ERR_INIT_OPTS_INVALID } = require('../lib/errors')
+
+const RouterPrototype = Object.getPrototypeOf(FindMyWay())
+
+function buildApp (opts) {
+  const fastify = Fastify(opts)
+
+  fastify.get('/', () => ({ route: 'root' }))
+  fastify.get('/users/:id', (req) => ({ route: 'user', id: req.params.id }))
+  fastify.post('/users', (req) => ({ route: 'create', body: req.body }))
+  fastify.get('/files/*', (req) => ({ route: 'files', path: req.params['*'] }))
+  fastify.get('/search', (req) => ({ route: 'search', query: req.query }))
+  fastify.get('/versioned', { constraints: { version: '1.2.0' } }, () => ({ route: 'v1' }))
+  fastify.get('/versioned', { constraints: { version: '2.0.0' } }, () => ({ route: 'v2' }))
+
+  return fastify
+}
+
+async function assertRoutes (t, fastify) {
+  let res = await fastify.inject('/')
+  t.assert.deepStrictEqual(res.json(), { route: 'root' })
+
+  res = await fastify.inject('/users/42')
+  t.assert.deepStrictEqual(res.json(), { route: 'user', id: '42' })
+
+  res = await fastify.inject('/users/caf%C3%A9')
+  t.assert.deepStrictEqual(res.json(), { route: 'user', id: 'café' })
+
+  res = await fastify.inject({ method: 'POST', url: '/users', payload: { name: 'foo' } })
+  t.assert.deepStrictEqual(res.json(), { route: 'create', body: { name: 'foo' } })
+
+  res = await fastify.inject('/files/a/b/c.txt')
+  t.assert.deepStrictEqual(res.json(), { route: 'files', path: 'a/b/c.txt' })
+
+  res = await fastify.inject('/search?q=fastify')
+  t.assert.deepStrictEqual(res.json(), { route: 'search', query: { q: 'fastify' } })
+
+  res = await fastify.inject({ url: '/versioned', headers: { 'accept-version': '2.x' } })
+  t.assert.deepStrictEqual(res.json(), { route: 'v2' })
+
+  res = await fastify.inject({ method: 'HEAD', url: '/users/42' })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.body, '')
+
+  res = await fastify.inject('/not-found')
+  t.assert.strictEqual(res.statusCode, 404)
+
+  res = await fastify.inject({ method: 'DELETE', url: '/users/42' })
+  t.assert.strictEqual(res.statusCode, 404)
+}
+
+test('routerOptions.compile defaults to false', async t => {
+  const compile = t.mock.method(RouterPrototype, 'compile')
+  const fastify = buildApp()
+  t.after(() => fastify.close())
+
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.compile, false)
+  await assertRoutes(t, fastify)
+  t.assert.strictEqual(compile.mock.callCount(), 0)
+})
+
+test('routerOptions.compile: true compiles the routes on ready', async t => {
+  const compile = t.mock.method(RouterPrototype, 'compile')
+  const fastify = buildApp({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.compile, true)
+  await fastify.ready()
+  // the main router and the 404 router
+  t.assert.strictEqual(compile.mock.callCount(), 2)
+  await assertRoutes(t, fastify)
+  t.assert.strictEqual(compile.mock.callCount(), 2)
+})
+
+test('routerOptions.compile: true works with real http requests', async t => {
+  const fastify = buildApp({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  const address = await fastify.listen({ port: 0 })
+
+  let res = await fetch(address + '/users/42')
+  t.assert.deepStrictEqual(await res.json(), { route: 'user', id: '42' })
+
+  res = await fetch(address + '/files/a/b')
+  t.assert.deepStrictEqual(await res.json(), { route: 'files', path: 'a/b' })
+
+  res = await fetch(address + '/nope')
+  t.assert.strictEqual(res.status, 404)
+})
+
+test('routerOptions.compile: true honors the other router options', async t => {
+  const fastify = Fastify({
+    routerOptions: {
+      compile: true,
+      ignoreTrailingSlash: true,
+      ignoreDuplicateSlashes: true,
+      caseSensitive: false,
+      maxParamLength: 5
+    }
+  })
+  t.after(() => fastify.close())
+
+  fastify.get('/foo/:id', (req) => ({ id: req.params.id }))
+
+  let res = await fastify.inject('/foo/abc/')
+  t.assert.deepStrictEqual(res.json(), { id: 'abc' })
+
+  res = await fastify.inject('//FOO//abc')
+  t.assert.deepStrictEqual(res.json(), { id: 'abc' })
+
+  res = await fastify.inject('/foo/toolongparam')
+  t.assert.strictEqual(res.statusCode, 414)
+})
+
+test('routerOptions.compile: true supports rewriteUrl', async t => {
+  const fastify = Fastify({
+    routerOptions: { compile: true },
+    rewriteUrl: (req) => req.url === '/old' ? '/new' : req.url
+  })
+  t.after(() => fastify.close())
+
+  fastify.get('/new', () => ({ route: 'new' }))
+
+  const res = await fastify.inject('/old')
+  t.assert.deepStrictEqual(res.json(), { route: 'new' })
+})
+
+test('routerOptions.compile: true supports asynchronous constraints', async t => {
+  const fastify = Fastify({
+    routerOptions: {
+      compile: true,
+      constraints: {
+        secret: {
+          name: 'secret',
+          storage () {
+            const secrets = {}
+            return {
+              get: (secret) => secrets[secret] ?? null,
+              set: (secret, store) => { secrets[secret] = store }
+            }
+          },
+          deriveConstraint (req, ctx, done) {
+            setImmediate(() => done(null, req.headers['x-secret']))
+          },
+          validate () { return true }
+        }
+      }
+    }
+  })
+  t.after(() => fastify.close())
+
+  fastify.get('/', { constraints: { secret: 'alpha' } }, () => ({ secret: 'alpha' }))
+  fastify.get('/', { constraints: { secret: 'beta' } }, () => ({ secret: 'beta' }))
+
+  let res = await fastify.inject({ url: '/', headers: { 'x-secret': 'beta' } })
+  t.assert.deepStrictEqual(res.json(), { secret: 'beta' })
+
+  res = await fastify.inject({ url: '/', headers: { 'x-secret': 'gamma' } })
+  t.assert.strictEqual(res.statusCode, 404)
+})
+
+test('routerOptions.compile: true supports encapsulated 404 handlers', async t => {
+  const fastify = Fastify({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  fastify.register(async (instance) => {
+    instance.setNotFoundHandler((req, reply) => {
+      reply.code(404).send({ notFound: 'api' })
+    })
+    instance.get('/ok', () => ({ ok: true }))
+  }, { prefix: '/api' })
+
+  let res = await fastify.inject('/api/ok')
+  t.assert.deepStrictEqual(res.json(), { ok: true })
+
+  res = await fastify.inject('/api/missing')
+  t.assert.deepStrictEqual(res.json(), { notFound: 'api' })
+})
+
+test('routerOptions.compile: true compiles the 404 router', async t => {
+  const fastify = Fastify({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  fastify.setNotFoundHandler((req, reply) => {
+    reply.code(404).send({ notFound: 'root', method: req.method })
+  })
+
+  fastify.register(async (instance) => {
+    instance.setNotFoundHandler((req, reply) => {
+      reply.code(404).send({ notFound: 'api', method: req.method })
+    })
+
+    instance.register(async (instance) => {
+      instance.setNotFoundHandler((req, reply) => {
+        reply.code(404).send({ notFound: 'v1', method: req.method })
+      })
+    }, { prefix: '/v1' })
+  }, { prefix: '/api' })
+
+  for (const method of ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']) {
+    let res = await fastify.inject({ method, url: '/missing' })
+    t.assert.deepStrictEqual(res.json(), { notFound: 'root', method })
+
+    res = await fastify.inject({ method, url: '/api/missing?x=1' })
+    t.assert.deepStrictEqual(res.json(), { notFound: 'api', method })
+
+    res = await fastify.inject({ method, url: '/api/v1/a/b/c' })
+    t.assert.deepStrictEqual(res.json(), { notFound: 'v1', method })
+  }
+
+  let res = await fastify.inject('/api')
+  t.assert.deepStrictEqual(res.json(), { notFound: 'api', method: 'GET' })
+
+  res = await fastify.inject('/api/v1/caf%C3%A9')
+  t.assert.deepStrictEqual(res.json(), { notFound: 'v1', method: 'GET' })
+})
+
+test('routerOptions.compile: true keeps findRoute and hasRoute working', async t => {
+  const fastify = Fastify({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  fastify.get('/users/:id', () => ({}))
+  await fastify.ready()
+
+  t.assert.ok(fastify.hasRoute({ method: 'GET', url: '/users/:id' }))
+  const route = fastify.findRoute({ method: 'GET', url: '/users/42' })
+  t.assert.deepStrictEqual({ ...route.params }, { id: '42' })
+  t.assert.strictEqual(fastify.findRoute({ method: 'GET', url: '/nope' }), null)
+})
+
+test('routerOptions.compile must be a boolean', t => {
+  t.assert.throws(
+    () => Fastify({ routerOptions: { compile: 'yes' } }),
+    FST_ERR_INIT_OPTS_INVALID
+  )
+})

package/test/schema-serialization.test.js

@@ -243,7 +243,7 @@ test('Different content types', (t, testDone) => {
         reply.send({ details: 'validation error' })
         break
       default:
-        // to test if schema not found
+        // to test failing closed on an undeclared content-type
         reply.header('Content-Type', 'application/vnd.v3+json')
         reply.code(200)
         reply.send([{ type: 'student', grade: 6 }, { type: 'student', grade: 9 }])
@@ -320,8 +320,8 @@ test('Different content types', (t, testDone) => {
   })
   fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
     t.assert.ifError(err)
-    t.assert.strictEqual(res.payload, JSON.stringify([{ type: 'student', grade: 6 }, { type: 'student', grade: 9 }]))
-    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.payload, '{}')
     completion.stepIn()
   })
   fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v2+json' } }, (err, res) => {
@@ -332,8 +332,8 @@ test('Different content types', (t, testDone) => {
   })
   fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v3+json' } }, (err, res) => {
     t.assert.ifError(err)
-    t.assert.strictEqual(res.payload, JSON.stringify({ firstName: 'New', lastName: 'Hoo', country: 'eg', city: 'node' }))
-    t.assert.strictEqual(res.statusCode, 300)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.payload, '{}')
     completion.stepIn()
   })
   fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v4+json' } }, (err, res) => {
@@ -386,8 +386,8 @@ test('Different content types', (t, testDone) => {
   })
   fastify.inject({ method: 'GET', url: '/test', headers: { Accept: 'application/vnd.v1+json' } }, (err, res) => {
     t.assert.ifError(err)
-    t.assert.strictEqual(res.payload, JSON.stringify({ created: true }))
-    t.assert.strictEqual(res.statusCode, 201)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.payload, '{}')
     completion.stepIn()
   })
 
@@ -1310,3 +1310,116 @@ test('response schema is applied when Content-Type has trailing semicolon only',
     testDone()
   })
 })
+
+test('fails closed when the response content-type is not declared in the content map', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/hal+json')
+    reply.send({ name: 'alice', password: 'SHOULD_NOT_LEAK' })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(
+      JSON.parse(res.payload).code,
+      'FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN'
+    )
+    testDone()
+  })
+})
+
+test('response content-type matching */* still serialises when no exact content-type is declared', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            '*/*': {
+              schema: {
+                type: 'object',
+                required: ['name'],
+                additionalProperties: false,
+                properties: {
+                  name: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/hal+json')
+    reply.send({ name: 'alice', password: 'SHOULD_BE_STRIPPED' })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { name: 'alice' })
+    testDone()
+  })
+})
+
+test('error responses fall back to the default error serializer when the content map does not declare the error content type', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  // The content map does not declare `application/json` and has no `*/*`
+  // catch-all, so the error handler must fall back to the default serializer
+  // instead of failing closed.
+  fastify.get('/', {
+    schema: {
+      response: {
+        default: {
+          content: {
+            'application/problem+json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  title: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    throw new Error('boom')
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
+      statusCode: 500,
+      error: 'Internal Server Error',
+      message: 'boom'
+    })
+    testDone()
+  })
+})

package/test/types/fastify.tst.ts

@@ -361,5 +361,9 @@ fastify({ routerOptions: { allowUnsafeRegex: true } })
 fastify({ routerOptions: { allowUnsafeRegex: false } })
 expect(fastify).type.not.toBeCallableWith({ routerOptions: { allowUnsafeRegex: 'invalid' } })
 
+fastify({ routerOptions: { compile: true } })
+fastify({ routerOptions: { compile: false } })
+expect(fastify).type.not.toBeCallableWith({ routerOptions: { compile: 'invalid' } })
+
 expect(fastify({ allowErrorHandlerOverride: true })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ allowErrorHandlerOverride: false })).type.toBeAssignableTo<FastifyInstance>()

package/test/types/instance.tst.ts

@@ -29,7 +29,7 @@ expect(server.addSchema({ schemas: [] })).type.toBe<FastifyInstance>()
 expect(server.pluginName).type.toBe<string>()
 
 expect(server.getSchemas()).type.toBe<Record<string, unknown>>()
-expect(server.addresses()).type.toBe<AddressInfo[]>()
+expect(server.addresses()).type.toBe<Array<AddressInfo | string>>()
 expect(server.getSchema('SchemaId')).type.toBe<unknown>()
 expect(server.printRoutes()).type.toBe<string>()
 expect(server.printPlugins()).type.toBe<string>()

package/test/types/route.tst.ts

@@ -83,6 +83,22 @@ fastify().get(
   }
 )
 
+fastify().get(
+  '/',
+  { logLevel: 'info', logSerializers: { test: (value: number) => 'X' + value } },
+  routeHandler
+)
+
+fastify().route({
+  method: 'GET',
+  url: '/',
+  logSerializers: {
+    // serializers may return objects as well as strings
+    req: (req: FastifyRequest) => ({ url: req.url })
+  },
+  handler: routeHandler
+})
+
 type LowerCaseHTTPMethods = 'delete' | 'get' | 'head' | 'patch' | 'post' | 'put' |
   'options' | 'query' | 'propfind' | 'proppatch' | 'mkcol' | 'copy' | 'move' | 'lock' |
   'unlock' | 'trace' | 'search' | 'mkcalendar' | 'report'

package/test/types/using.tst.ts

@@ -12,3 +12,23 @@ test("has 'Symbol.dispose'", async () => {
   expect(app).type.toBeAssignableTo<FastifyInstance>()
   expect(app[Symbol.asyncDispose]).type.toBe<() => Promise<undefined>>()
 })
+
+test("addHook('onClose') accepts AsyncDisposable", () => {
+  const app = fastify()
+
+  const asyncDisposable: AsyncDisposable = {
+    async [Symbol.asyncDispose] () {}
+  }
+
+  expect(app.addHook('onClose', asyncDisposable)).type.toBeAssignableTo<FastifyInstance>()
+})
+
+test("addHook('onClose') accepts Disposable", () => {
+  const app = fastify()
+
+  const syncDisposable: Disposable = {
+    [Symbol.dispose] () {}
+  }
+
+  expect(app.addHook('onClose', syncDisposable)).type.toBeAssignableTo<FastifyInstance>()
+})

package/test/validation-error-handling.test.js

@@ -252,6 +252,26 @@ test('attached validationError exposes the same message sent by the default hand
   t.assert.strictEqual(notAttached.statusCode, 400)
 })
 
+test('default validation errors are FST_ERR_VALIDATION errors without a stack trace', async (t) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  let validationError
+  fastify.post('/', { schema, attachValidation: true }, function (req, reply) {
+    validationError = req.validationError
+    reply.code(400).send()
+  })
+
+  await fastify.inject({ method: 'POST', payload: { hello: 'michelangelo' }, url: '/' })
+
+  t.assert.ok(validationError instanceof Fastify.errorCodes.FST_ERR_VALIDATION)
+  t.assert.ok(validationError instanceof Error)
+  t.assert.strictEqual(validationError.name, 'FastifyError')
+  t.assert.strictEqual(validationError.message, "body must have required property 'name'")
+  t.assert.strictEqual(validationError.stack, undefined)
+})
+
 test('should respect when attachValidation is explicitly set to false', async (t) => {
   t.plan(2)
 
@@ -303,7 +323,7 @@ test('Attached validation error should take precedence over setErrorHandler', as
     url: '/'
   })
 
-  t.assert.deepStrictEqual(response.payload, "Attached: Error: body must have required property 'name'")
+  t.assert.deepStrictEqual(response.payload, "Attached: FastifyError [FST_ERR_VALIDATION]: body must have required property 'name'")
   t.assert.strictEqual(response.statusCode, 400)
 })
 

package/types/instance.d.ts

@@ -130,7 +130,7 @@ export interface FastifyInstance<
   version: string;
   log: Logger;
   listeningOrigin: string;
-  addresses(): AddressInfo[]
+  addresses(): Array<AddressInfo | string>
   withTypeProvider<Provider extends FastifyTypeProvider>(): FastifyInstance<RawServer, RawRequest, RawReply, Logger,
     Provider>;
 
@@ -485,6 +485,10 @@ export interface FastifyInstance<
   /**
   * Triggered when fastify.close() is invoked to stop the server. It is useful when plugins need a "shutdown" event, for example to close an open connection to a database.
   */
+  addHook(
+    name: 'onClose',
+    hook: AsyncDisposable | Disposable,
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
   addHook<
     Fn extends onCloseHookHandler | onCloseAsyncHookHandler = onCloseHookHandler
   >(

package/types/route.d.ts

@@ -68,6 +68,7 @@ export interface RouteShorthandOptions<
   bodyLimit?: number;
   handlerTimeout?: number;
   logLevel?: LogLevel;
+  logSerializers?: Record<string, (value: any) => any>;
   config?: FastifyContextConfig & ContextConfig;
   constraints?: RouteConstraint,
   prefixTrailingSlash?: 'slash' | 'no-slash' | 'both';