fastify 5.7.4 → 5.8.1

package/test/scripts/validate-ecosystem-links.test.js

@@ -0,0 +1,339 @@
+'use strict'
+
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert')
+const fs = require('node:fs')
+const { MockAgent, setGlobalDispatcher, getGlobalDispatcher } = require('undici')
+
+function loadValidateEcosystemLinksModule () {
+  const modulePath = require.resolve('../../scripts/validate-ecosystem-links')
+  delete require.cache[modulePath]
+  return require(modulePath)
+}
+
+describe('extractGitHubLinks', () => {
+  const { extractGitHubLinks } = loadValidateEcosystemLinksModule()
+
+  it('extracts simple GitHub repository links', () => {
+    const content = `
+# Ecosystem
+
+- [fastify-helmet](https://github.com/fastify/fastify-helmet) - Important security headers for Fastify
+- [fastify-cors](https://github.com/fastify/fastify-cors) - CORS support
+`
+    const links = extractGitHubLinks(content)
+
+    assert.strictEqual(links.length, 2)
+    assert.deepStrictEqual(links[0], {
+      name: 'fastify-helmet',
+      url: 'https://github.com/fastify/fastify-helmet',
+      owner: 'fastify',
+      repo: 'fastify-helmet'
+    })
+    assert.deepStrictEqual(links[1], {
+      name: 'fastify-cors',
+      url: 'https://github.com/fastify/fastify-cors',
+      owner: 'fastify',
+      repo: 'fastify-cors'
+    })
+  })
+
+  it('extracts links with different owner/repo combinations', () => {
+    const content = `
+- [some-plugin](https://github.com/user123/awesome-plugin)
+- [another-lib](https://github.com/org-name/lib-name)
+`
+    const links = extractGitHubLinks(content)
+
+    assert.strictEqual(links.length, 2)
+    assert.strictEqual(links[0].owner, 'user123')
+    assert.strictEqual(links[0].repo, 'awesome-plugin')
+    assert.strictEqual(links[1].owner, 'org-name')
+    assert.strictEqual(links[1].repo, 'lib-name')
+  })
+
+  it('handles links with hash fragments', () => {
+    const content = `
+- [project](https://github.com/owner/repo#readme)
+`
+    const links = extractGitHubLinks(content)
+
+    assert.strictEqual(links.length, 1)
+    assert.strictEqual(links[0].repo, 'repo')
+    assert.strictEqual(links[0].url, 'https://github.com/owner/repo#readme')
+  })
+
+  it('handles links with query parameters', () => {
+    const content = `
+- [project](https://github.com/owner/repo?tab=readme)
+`
+    const links = extractGitHubLinks(content)
+
+    assert.strictEqual(links.length, 1)
+    assert.strictEqual(links[0].repo, 'repo')
+  })
+
+  it('handles links with subpaths', () => {
+    const content = `
+- [docs](https://github.com/owner/repo/tree/main/docs)
+`
+    const links = extractGitHubLinks(content)
+
+    assert.strictEqual(links.length, 1)
+    assert.strictEqual(links[0].owner, 'owner')
+    assert.strictEqual(links[0].repo, 'repo')
+  })
+
+  it('returns empty array for content with no GitHub links', () => {
+    const content = `
+# No GitHub links here
+
+Just some regular text and [a link](https://example.com).
+`
+    const links = extractGitHubLinks(content)
+
+    assert.strictEqual(links.length, 0)
+  })
+
+  it('ignores non-GitHub links', () => {
+    const content = `
+- [gitlab](https://gitlab.com/owner/repo)
+- [github](https://github.com/owner/repo)
+- [bitbucket](https://bitbucket.org/owner/repo)
+`
+    const links = extractGitHubLinks(content)
+
+    assert.strictEqual(links.length, 1)
+    assert.strictEqual(links[0].owner, 'owner')
+  })
+
+  it('extracts multiple links from complex markdown', () => {
+    const content = `
+## Category 1
+
+Some description [inline link](https://github.com/a/b).
+
+| Plugin | Description |
+|--------|-------------|
+| [plugin1](https://github.com/x/y) | Desc 1 |
+| [plugin2](https://github.com/z/w) | Desc 2 |
+`
+    const links = extractGitHubLinks(content)
+
+    assert.strictEqual(links.length, 3)
+  })
+})
+
+describe('checkGitHubRepo', () => {
+  let originalDispatcher
+  let mockAgent
+  let originalFetch
+  let originalSetTimeout
+
+  beforeEach(() => {
+    delete process.env.GITHUB_TOKEN
+    originalDispatcher = getGlobalDispatcher()
+    mockAgent = new MockAgent()
+    mockAgent.disableNetConnect()
+    setGlobalDispatcher(mockAgent)
+    originalFetch = global.fetch
+    originalSetTimeout = global.setTimeout
+  })
+
+  afterEach(async () => {
+    global.fetch = originalFetch
+    global.setTimeout = originalSetTimeout
+    setGlobalDispatcher(originalDispatcher)
+    await mockAgent.close()
+    delete process.env.GITHUB_TOKEN
+  })
+
+  it('returns exists: true for status 200', async () => {
+    const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/fastify/fastify',
+      method: 'HEAD'
+    }).reply(200)
+
+    const result = await checkGitHubRepo('fastify', 'fastify')
+
+    assert.strictEqual(result.exists, true)
+    assert.strictEqual(result.status, 200)
+    assert.strictEqual(result.owner, 'fastify')
+    assert.strictEqual(result.repo, 'fastify')
+  })
+
+  it('returns exists: false for status 404', async () => {
+    const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/nonexistent/repo',
+      method: 'HEAD'
+    }).reply(404)
+
+    const result = await checkGitHubRepo('nonexistent', 'repo')
+
+    assert.strictEqual(result.exists, false)
+    assert.strictEqual(result.status, 404)
+  })
+
+  it('returns invalid status for malformed owner or repository names', async () => {
+    const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
+    let called = false
+
+    global.fetch = async () => {
+      called = true
+      return { status: 200 }
+    }
+
+    const result = await checkGitHubRepo('owner/evil', 'repo', 1)
+
+    assert.strictEqual(called, false)
+    assert.strictEqual(result.exists, false)
+    assert.strictEqual(result.status, 'invalid')
+    assert.strictEqual(result.error, 'Invalid GitHub repository identifier')
+  })
+
+  it('retries on rate limit responses', async () => {
+    const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
+    let attempts = 0
+
+    global.setTimeout = (fn) => {
+      fn()
+      return 0
+    }
+
+    global.fetch = async () => {
+      attempts++
+      return {
+        status: attempts === 1 ? 403 : 200
+      }
+    }
+
+    const result = await checkGitHubRepo('owner', 'repo', 1)
+
+    assert.strictEqual(attempts, 2)
+    assert.strictEqual(result.exists, true)
+    assert.strictEqual(result.status, 200)
+  })
+
+  it('adds authorization header when GITHUB_TOKEN is set', async () => {
+    process.env.GITHUB_TOKEN = 'my-token'
+    const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
+    let authorization
+
+    global.fetch = async (url, options) => {
+      authorization = options.headers.Authorization
+      return {
+        status: 200
+      }
+    }
+
+    const result = await checkGitHubRepo('owner', 'repo')
+
+    assert.strictEqual(authorization, 'token my-token')
+    assert.strictEqual(result.exists, true)
+  })
+
+  it('handles network errors', async () => {
+    const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD'
+    }).replyWithError(new Error('Network error'))
+
+    const result = await checkGitHubRepo('owner', 'repo')
+
+    assert.strictEqual(result.exists, false)
+    assert.strictEqual(result.status, 'error')
+    assert.ok(result.error.length > 0)
+  })
+})
+
+describe('validateAllLinks', () => {
+  let originalReadFileSync
+  let originalFetch
+  let originalSetTimeout
+  let originalConsoleLog
+  let originalStdoutWrite
+
+  beforeEach(() => {
+    originalReadFileSync = fs.readFileSync
+    originalFetch = global.fetch
+    originalSetTimeout = global.setTimeout
+    originalConsoleLog = console.log
+    originalStdoutWrite = process.stdout.write
+
+    console.log = () => {}
+    process.stdout.write = () => true
+
+    global.setTimeout = (fn) => {
+      fn()
+      return 0
+    }
+  })
+
+  afterEach(() => {
+    fs.readFileSync = originalReadFileSync
+    global.fetch = originalFetch
+    global.setTimeout = originalSetTimeout
+    console.log = originalConsoleLog
+    process.stdout.write = originalStdoutWrite
+  })
+
+  it('validates links, deduplicates repositories and groups inaccessible links', async () => {
+    const { validateAllLinks } = loadValidateEcosystemLinksModule()
+
+    fs.readFileSync = () => `
+- [repo one](https://github.com/owner/repo)
+- [repo one duplicate](https://github.com/owner/repo)
+- [repo two](https://github.com/another/project)
+`
+
+    let requests = 0
+    global.fetch = async (url) => {
+      requests++
+      const pathname = new URL(url).pathname
+
+      if (pathname === '/repos/owner/repo') {
+        return { status: 404 }
+      }
+
+      if (pathname === '/repos/another/project') {
+        return { status: 200 }
+      }
+
+      throw new Error(`Unexpected url: ${url}`)
+    }
+
+    const result = await validateAllLinks()
+
+    assert.strictEqual(requests, 2)
+    assert.strictEqual(result.notFound.length, 1)
+    assert.strictEqual(result.found.length, 1)
+    assert.strictEqual(result.notFound[0].owner, 'owner')
+    assert.strictEqual(result.notFound[0].repo, 'repo')
+    assert.strictEqual(result.found[0].owner, 'another')
+    assert.strictEqual(result.found[0].repo, 'project')
+  })
+
+  it('returns empty result when no GitHub links are present', async () => {
+    const { validateAllLinks } = loadValidateEcosystemLinksModule()
+
+    fs.readFileSync = () => '# Ecosystem\nNo links here.'
+
+    let requests = 0
+    global.fetch = async () => {
+      requests++
+      return { status: 200 }
+    }
+
+    const result = await validateAllLinks()
+
+    assert.strictEqual(requests, 0)
+    assert.strictEqual(result.notFound.length, 0)
+    assert.strictEqual(result.found.length, 0)
+  })
+})

package/test/types/dummy-plugin.ts

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

package/test/types/fastify.test-d.ts

@@ -113,6 +113,7 @@ expectAssignable<FastifyInstance>(fastify({ forceCloseConnections: true }))
 expectAssignable<FastifyInstance>(fastify({ keepAliveTimeout: 1000 }))
 expectAssignable<FastifyInstance>(fastify({ pluginTimeout: 1000 }))
 expectAssignable<FastifyInstance>(fastify({ bodyLimit: 100 }))
+expectAssignable<FastifyInstance>(fastify({ handlerTimeout: 5000 }))
 expectAssignable<FastifyInstance>(fastify({ maxParamLength: 100 }))
 expectAssignable<FastifyInstance>(fastify({ disableRequestLogging: true }))
 expectAssignable<FastifyInstance>(fastify({ disableRequestLogging: (req) => req.url?.includes('/health') ?? false }))

package/test/types/logger.test-d.ts

@@ -2,38 +2,37 @@ import { expectAssignable, expectDeprecated, expectError, expectNotAssignable, e
 import fastify, {
   FastifyLogFn,
   LogLevel,
-  FastifyLoggerInstance,
+  FastifyBaseLogger,
   FastifyRequest,
-  FastifyReply,
-  FastifyBaseLogger
+  FastifyReply
 } from '../../fastify'
 import { Server, IncomingMessage, ServerResponse } from 'node:http'
 import * as fs from 'node:fs'
 import P from 'pino'
-import { ResSerializerReply } from '../../types/logger'
+import { FastifyLoggerInstance, ResSerializerReply } from '../../types/logger'
 
-expectType<FastifyLoggerInstance>(fastify().log)
+expectType<FastifyBaseLogger>(fastify().log)
 
 class Foo {}
 
 ['trace', 'debug', 'info', 'warn', 'error', 'fatal'].forEach(logLevel => {
   expectType<FastifyLogFn>(
-    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]
   )
   expectType<void>(
-    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]('')
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]('')
   )
   expectType<void>(
-    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({})
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]({})
   )
   expectType<void>(
-    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({ foo: 'bar' })
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]({ foo: 'bar' })
   )
   expectType<void>(
-    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Error())
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel](new Error())
   )
   expectType<void>(
-    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Foo())
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel](new Foo())
   )
 })
 
@@ -109,7 +108,7 @@ ServerResponse
   }
 })
 
-expectType<FastifyLoggerInstance>(serverWithLogOptions.log)
+expectType<FastifyBaseLogger>(serverWithLogOptions.log)
 
 const serverWithFileOption = fastify<
 Server,
@@ -122,7 +121,7 @@ ServerResponse
   }
 })
 
-expectType<FastifyLoggerInstance>(serverWithFileOption.log)
+expectType<FastifyBaseLogger>(serverWithFileOption.log)
 
 const serverAutoInferringTypes = fastify({
   logger: {
@@ -266,11 +265,11 @@ expectDeprecated({} as FastifyLoggerInstance)
 
 const childParent = fastify().log
 // we test different option variant here
-expectType<FastifyLoggerInstance>(childParent.child({}, { level: 'info' }))
-expectType<FastifyLoggerInstance>(childParent.child({}, { level: 'silent' }))
-expectType<FastifyLoggerInstance>(childParent.child({}, { redact: ['pass', 'pin'] }))
-expectType<FastifyLoggerInstance>(childParent.child({}, { serializers: { key: () => {} } }))
-expectType<FastifyLoggerInstance>(childParent.child({}, { level: 'info', redact: ['pass', 'pin'], serializers: { key: () => {} } }))
+expectType<FastifyBaseLogger>(childParent.child({}, { level: 'info' }))
+expectType<FastifyBaseLogger>(childParent.child({}, { level: 'silent' }))
+expectType<FastifyBaseLogger>(childParent.child({}, { redact: ['pass', 'pin'] }))
+expectType<FastifyBaseLogger>(childParent.child({}, { serializers: { key: () => {} } }))
+expectType<FastifyBaseLogger>(childParent.child({}, { level: 'info', redact: ['pass', 'pin'], serializers: { key: () => {} } }))
 
 // no option pass
 expectError(childParent.child())

package/test/types/register.test-d.ts

@@ -1,7 +1,7 @@
 import { expectAssignable, expectError, expectType } from 'tsd'
 import { IncomingMessage, Server, ServerResponse } from 'node:http'
 import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'node:http2'
-import fastify, { FastifyInstance, FastifyError, FastifyLoggerInstance, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, RawServerDefault } from '../../fastify'
+import fastify, { FastifyInstance, FastifyError, FastifyBaseLogger, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, RawServerDefault } from '../../fastify'
 
 const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
 const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
@@ -97,7 +97,7 @@ type ServerWithTypeProvider = FastifyInstance<
   Server,
   IncomingMessage,
   ServerResponse,
-  FastifyLoggerInstance,
+  FastifyBaseLogger,
   TestTypeProvider
 >
 const testPluginWithTypeProvider: FastifyPluginCallback<

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

@@ -2,7 +2,7 @@ import { Buffer } from 'node:buffer'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import fastify, { FastifyContextConfig, FastifyReply, FastifyRequest, FastifySchema, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
 import { FastifyInstance } from '../../types/instance'
-import { FastifyLoggerInstance } from '../../types/logger'
+import { FastifyBaseLogger } from '../../types/logger'
 import { ResolveReplyTypeWithRouteGeneric } from '../../types/reply'
 import { FastifyRouteConfig, RouteGenericInterface } from '../../types/route'
 import { ContextConfigDefault, RawReplyDefaultExpression, RawServerDefault } from '../../types/utils'
@@ -12,7 +12,7 @@ type DefaultFastifyReplyWithCode<Code extends number> = FastifyReply<RouteGeneri
 
 const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<RawReplyDefaultExpression>(reply.raw)
-  expectType<FastifyLoggerInstance>(reply.log)
+  expectType<FastifyBaseLogger>(reply.log)
   expectType<FastifyRequest<RouteGenericInterface, RawServerDefault, RawRequestDefaultExpression>>(reply.request)
   expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.code)
   expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.status)

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

@@ -15,7 +15,7 @@ import fastify, {
   SafePromiseLike
 } from '../../fastify'
 import { FastifyInstance } from '../../types/instance'
-import { FastifyLoggerInstance } from '../../types/logger'
+import { FastifyBaseLogger } from '../../types/logger'
 import { FastifyReply } from '../../types/reply'
 import { FastifyRequest, RequestRouteOptions } from '../../types/request'
 import { FastifyRouteConfig, RouteGenericInterface } from '../../types/route'
@@ -56,7 +56,7 @@ type CustomRequest = FastifyRequest<{
 type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
 type ExpectedGetValidationFunction = (input: { [key: string]: unknown }) => boolean
 
-interface CustomLoggerInterface extends FastifyLoggerInstance {
+interface CustomLoggerInterface extends FastifyBaseLogger {
   foo: FastifyLogFn; // custom severity logger method
 }
 
@@ -85,8 +85,9 @@ const getHandler: RouteHandler = function (request, _reply) {
 
   expectType<RequestQuerystringDefault>(request.query)
   expectType<string>(request.id)
-  expectType<FastifyLoggerInstance>(request.log)
+  expectType<FastifyBaseLogger>(request.log)
   expectType<RawRequestDefaultExpression['socket']>(request.socket)
+  expectType<AbortSignal>(request.signal)
   expectType<Error & { validation: any; validationContext: string } | undefined>(request.validationError)
   expectType<FastifyInstance>(request.server)
   expectAssignable<(httpPart: HTTPRequestPart) => ExpectedGetValidationFunction>(request.getValidationFunction)

package/test/types/route.test-d.ts

@@ -53,6 +53,12 @@ const routeHandlerWithReturnValue: RouteHandlerMethod = function (request, reply
   return reply.send()
 }
 
+const asyncPreHandler = async (request: FastifyRequest) => {
+  expectType<FastifyRequest>(request)
+}
+
+fastify().get('/', { preHandler: asyncPreHandler }, async () => 'this is an example')
+
 fastify().get(
   '/',
   { config: { foo: 'bar', bar: 100, includeMessage: true } },

package/test/types/type-provider.test-d.ts

@@ -9,7 +9,7 @@ import fastify, {
 } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import { IncomingHttpHeaders } from 'node:http'
-import { Type, TSchema, Static } from '@sinclair/typebox'
+import { Type, TSchema, Static } from 'typebox'
 import { FromSchema, JSONSchema } from 'json-schema-to-ts'
 
 const server = fastify()

package/test/web-api.test.js

@@ -500,6 +500,81 @@ test('WebStream should respect backpressure', async (t) => {
   t.assert.ok(secondWriteAt >= drainEmittedAt)
 })
 
+test('WebStream should stop reading on drain after response destroy', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  let cancelCalled = false
+  let resolveCancel
+  const cancelPromise = new Promise((resolve) => {
+    resolveCancel = resolve
+  })
+
+  fastify.get('/', function (request, reply) {
+    const raw = reply.raw
+    const originalWrite = raw.write.bind(raw)
+    let firstWrite = true
+
+    raw.write = function (chunk, encoding, cb) {
+      if (firstWrite) {
+        firstWrite = false
+        if (typeof cb === 'function') {
+          cb()
+        }
+        queueMicrotask(() => {
+          raw.destroy()
+          raw.emit('drain')
+        })
+        return false
+      }
+      return originalWrite(chunk, encoding, cb)
+    }
+
+    const stream = new ReadableStream({
+      start (controller) {
+        controller.enqueue(Buffer.from('chunk-1'))
+      },
+      pull (controller) {
+        controller.enqueue(Buffer.from('chunk-2'))
+        controller.close()
+      },
+      cancel () {
+        cancelCalled = true
+        resolveCancel()
+      }
+    })
+
+    reply.header('content-type', 'text/plain').send(stream)
+  })
+
+  await new Promise((resolve, reject) => {
+    fastify.listen({ port: 0 }, err => {
+      if (err) return reject(err)
+      resolve()
+    })
+  })
+
+  await new Promise((resolve, reject) => {
+    const req = http.get(`http://localhost:${fastify.server.address().port}/`, (res) => {
+      res.once('close', resolve)
+      res.resume()
+    })
+    req.once('error', (err) => {
+      if (err.code === 'ECONNRESET') {
+        resolve()
+      } else {
+        reject(err)
+      }
+    })
+  })
+
+  await cancelPromise
+  t.assert.ok(true, 'response interrupted as expected')
+  t.assert.strictEqual(cancelCalled, true)
+})
+
 test('WebStream should warn when headers already sent', async (t) => {
   t.plan(2)
 

package/types/errors.d.ts

@@ -75,6 +75,8 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_ROUTE_METHOD_NOT_SUPPORTED' |
   'FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED' |
   'FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT' |
+  'FST_ERR_HANDLER_TIMEOUT' |
+  'FST_ERR_ROUTE_HANDLER_TIMEOUT_OPTION_NOT_INT' |
   'FST_ERR_ROUTE_REWRITE_NOT_STR' |
   'FST_ERR_REOPENED_CLOSE_SERVER' |
   'FST_ERR_REOPENED_SERVER' |

package/types/logger.d.ts

@@ -28,7 +28,7 @@ export interface FastifyBaseLogger extends Pick<BaseLogger, 'level' | 'info' | '
   child(bindings: Bindings, options?: ChildLoggerOptions): FastifyBaseLogger
 }
 
-// TODO delete FastifyBaseLogger in the next major release. It seems that it is enough to have only FastifyBaseLogger.
+// TODO delete FastifyLoggerInstance in the next major release. It seems that it is enough to have only FastifyBaseLogger.
 /**
  * @deprecated Use FastifyBaseLogger instead
  */

package/types/request.d.ts

@@ -25,6 +25,7 @@ export interface RequestRouteOptions<ContextConfig = ContextConfigDefault, Schem
   // `url` can be `undefined` for instance when `request.is404` is true
   url: string | undefined;
   bodyLimit: number;
+  handlerTimeout: number;
   attachValidation: boolean;
   logLevel: string;
   exposeHeadRoute: boolean;
@@ -82,6 +83,7 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   readonly routeOptions: Readonly<RequestRouteOptions<ContextConfig, SchemaCompiler>>
   readonly is404: boolean;
   readonly socket: RawRequest['socket'];
+  readonly signal: AbortSignal;
 
   getValidationFunction(httpPart: HTTPRequestPart): ValidationFunction
   getValidationFunction(schema: { [key: string]: any }): ValidationFunction