fastify 4.25.2 → 4.26.1

package/test/useSemicolonDelimiter.test.js

@@ -0,0 +1,113 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const sget = require('simple-get').concat
+
+test('use semicolon delimiter default true', t => {
+  t.plan(4)
+
+  const fastify = Fastify({})
+
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.get('/1234', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    console.log('http://localhost:' + fastify.server.address().port + '/1234;foo=bar')
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(JSON.parse(body), {
+        foo: 'bar'
+      })
+    })
+  })
+})
+
+test('use semicolon delimiter set to true', t => {
+  t.plan(4)
+
+  const fastify = Fastify({
+    useSemicolonDelimiter: true
+  })
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.get('/1234', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(JSON.parse(body), {
+        foo: 'bar'
+      })
+    })
+  })
+})
+
+test('use semicolon delimiter set to false', t => {
+  t.plan(4)
+
+  const fastify = Fastify({
+    useSemicolonDelimiter: false
+  })
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.get('/1234;foo=bar', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(JSON.parse(body), {})
+    })
+  })
+})
+
+test('use semicolon delimiter set to false return 404', t => {
+  t.plan(3)
+
+  const fastify = Fastify({
+    useSemicolonDelimiter: false
+  })
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.get('/1234', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 404)
+    })
+  })
+})

package/test/web-api.test.js

@@ -0,0 +1,208 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('../fastify')
+const fs = require('node:fs')
+const semver = require('semver')
+const { Readable } = require('node:stream')
+const { fetch: undiciFetch } = require('undici')
+
+if (semver.lt(process.versions.node, '18.0.0')) {
+  t.skip('Response or ReadableStream not available, skipping test')
+  process.exit(0)
+}
+
+test('should response with a ReadableStream', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    const stream = fs.createReadStream(__filename)
+    reply.code(200).send(Readable.toWeb(stream))
+  })
+
+  const {
+    statusCode,
+    body
+  } = await fastify.inject({ method: 'GET', path: '/' })
+
+  const expected = await fs.promises.readFile(__filename)
+
+  t.equal(statusCode, 200)
+  t.equal(expected.toString(), body.toString())
+})
+
+test('should response with a Response', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    const stream = fs.createReadStream(__filename)
+    reply.send(new Response(Readable.toWeb(stream), {
+      status: 200,
+      headers: {
+        hello: 'world'
+      }
+    }))
+  })
+
+  const {
+    statusCode,
+    headers,
+    body
+  } = await fastify.inject({ method: 'GET', path: '/' })
+
+  const expected = await fs.promises.readFile(__filename)
+
+  t.equal(statusCode, 200)
+  t.equal(expected.toString(), body.toString())
+  t.equal(headers.hello, 'world')
+})
+
+test('able to use in onSend hook - ReadableStream', async (t) => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    const stream = fs.createReadStream(__filename)
+    reply.code(500).send(Readable.toWeb(stream))
+  })
+
+  fastify.addHook('onSend', (request, reply, payload, done) => {
+    t.equal(Object.prototype.toString.call(payload), '[object ReadableStream]')
+    done(null, new Response(payload, {
+      status: 200,
+      headers: {
+        hello: 'world'
+      }
+    }))
+  })
+
+  const {
+    statusCode,
+    headers,
+    body
+  } = await fastify.inject({ method: 'GET', path: '/' })
+
+  const expected = await fs.promises.readFile(__filename)
+
+  t.equal(statusCode, 200)
+  t.equal(expected.toString(), body.toString())
+  t.equal(headers.hello, 'world')
+})
+
+test('able to use in onSend hook - Response', async (t) => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    const stream = fs.createReadStream(__filename)
+    reply.send(new Response(Readable.toWeb(stream), {
+      status: 500,
+      headers: {
+        hello: 'world'
+      }
+    }))
+  })
+
+  fastify.addHook('onSend', (request, reply, payload, done) => {
+    t.equal(Object.prototype.toString.call(payload), '[object Response]')
+    done(null, new Response(payload.body, {
+      status: 200,
+      headers: payload.headers
+    }))
+  })
+
+  const {
+    statusCode,
+    headers,
+    body
+  } = await fastify.inject({ method: 'GET', path: '/' })
+
+  const expected = await fs.promises.readFile(__filename)
+
+  t.equal(statusCode, 200)
+  t.equal(expected.toString(), body.toString())
+  t.equal(headers.hello, 'world')
+})
+
+test('Error when Response.bodyUsed', async (t) => {
+  t.plan(4)
+
+  const expected = await fs.promises.readFile(__filename)
+
+  const fastify = Fastify()
+
+  fastify.get('/', async function (request, reply) {
+    const stream = fs.createReadStream(__filename)
+    const response = new Response(Readable.toWeb(stream), {
+      status: 200,
+      headers: {
+        hello: 'world'
+      }
+    })
+    const file = await response.text()
+    t.equal(expected.toString(), file)
+    t.equal(response.bodyUsed, true)
+    return reply.send(response)
+  })
+
+  const response = await fastify.inject({ method: 'GET', path: '/' })
+
+  t.equal(response.statusCode, 500)
+  const body = response.json()
+  t.equal(body.code, 'FST_ERR_REP_RESPONSE_BODY_CONSUMED')
+})
+
+test('allow to pipe with fetch', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.get('/', function (request, reply) {
+    return fetch(`${fastify.listeningOrigin}/fetch`, {
+      method: 'GET'
+    })
+  })
+
+  fastify.get('/fetch', function (request, reply) {
+    reply.code(200).send({ ok: true })
+  })
+
+  await fastify.listen()
+
+  const response = await fastify.inject({ method: 'GET', path: '/' })
+
+  t.equal(response.statusCode, 200)
+  t.same(response.json(), { ok: true })
+})
+
+test('allow to pipe with undici.fetch', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.get('/', function (request, reply) {
+    return undiciFetch(`${fastify.listeningOrigin}/fetch`, {
+      method: 'GET'
+    })
+  })
+
+  fastify.get('/fetch', function (request, reply) {
+    reply.code(200).send({ ok: true })
+  })
+
+  await fastify.listen()
+
+  const response = await fastify.inject({ method: 'GET', path: '/' })
+
+  t.equal(response.statusCode, 200)
+  t.same(response.json(), { ok: true })
+})

package/types/instance.d.ts

@@ -1,14 +1,15 @@
 import { FastifyError } from '@fastify/error'
-import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { ConstraintStrategy, FindResult, HTTPVersion } from 'find-my-way'
 import * as http from 'http'
-import { CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse } from 'light-my-request'
-import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, getDefaultJsonParser, hasContentTypeParser, ProtoAction, removeAllContentTypeParsers, removeContentTypeParser } from './content-type-parser'
-import { onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onListenAsyncHookHandler, onListenHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onRequestAbortAsyncHookHandler, onRequestAbortHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, preCloseHookHandler, preCloseAsyncHookHandler, LifecycleHook, ApplicationHook, HookAsyncLookup, HookLookup } from './hooks'
+import { InjectOptions, CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, Response as LightMyRequestResponse } from 'light-my-request'
+import { AddressInfo } from 'net'
+import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, ProtoAction, getDefaultJsonParser, hasContentTypeParser, removeAllContentTypeParsers, removeContentTypeParser } from './content-type-parser'
+import { ApplicationHook, HookAsyncLookup, HookLookup, LifecycleHook, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onListenAsyncHookHandler, onListenHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAbortAsyncHookHandler, onRequestAbortHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preCloseAsyncHookHandler, preCloseHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler } from './hooks'
 import { FastifyBaseLogger, FastifyChildLoggerFactory } from './logger'
 import { FastifyRegister } from './register'
 import { FastifyReply } from './reply'
 import { FastifyRequest } from './request'
-import { DefaultRoute, RouteGenericInterface, RouteOptions, RouteShorthandMethod, RouteHandlerMethod } from './route'
+import { DefaultRoute, RouteGenericInterface, RouteHandlerMethod, RouteOptions, RouteShorthandMethod } from './route'
 import {
   FastifySchema,
   FastifySchemaCompiler,
@@ -20,8 +21,7 @@ import {
   FastifyTypeProvider,
   FastifyTypeProviderDefault
 } from './type-provider'
-import { HTTPMethods, ContextConfigDefault, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
-import { AddressInfo } from 'net'
+import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
 
 export interface PrintRoutesOptions {
   method?: HTTPMethods;
@@ -86,6 +86,7 @@ export interface FastifyListenOptions {
 
 type NotInInterface<Key, _Interface> = Key extends keyof _Interface ? never : Key
 type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
+type FindMyWayFindResult<RawServer extends RawServerBase> = FindResult<FindMyWayVersion<RawServer>>
 
 type GetterSetter<This, T> = T | {
   getter: (this: This) => T,
@@ -219,6 +220,12 @@ export interface FastifyInstance<
     SchemaCompiler extends FastifySchema = FastifySchema,
   >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'method' | 'url' | 'constraints'>): boolean;
 
+  findRoute<
+    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+    ContextConfig = ContextConfigDefault,
+    SchemaCompiler extends FastifySchema = FastifySchema,
+  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'method' | 'url' | 'constraints'>): Omit<FindMyWayFindResult<RawServer>, 'store'>;
+
   // addHook: overloads
 
   // Lifecycle addHooks
@@ -458,8 +465,8 @@ export interface FastifyInstance<
 
   setNotFoundHandler<RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig extends ContextConfigDefault = ContextConfigDefault, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema> (
     opts: {
-      preValidation?: preValidationHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider> | preValidationHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>[];
-      preHandler?: preHandlerHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider> | preHandlerHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>[];
+      preValidation?: preValidationHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider> | preValidationAsyncHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider> | preValidationHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>[] | preValidationAsyncHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>[];
+      preHandler?: preHandlerHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider> | preHandlerAsyncHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider> | preHandlerHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>[] | preHandlerAsyncHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>[];
     },
     handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
@@ -476,6 +483,11 @@ export interface FastifyInstance<
     handler: (this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>, error: TError, request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfigDefault, SchemaCompiler, TypeProvider>) => any | Promise<any>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
+  /**
+   * Set a function that will generate a request-ids
+   */
+  setGenReqId(fn: (req: RawRequestDefaultExpression<RawServer>) => string): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+
   /**
    * Hook function that is called when creating a child logger instance for each request
    * which allows for modifying or adding child logger bindings and logger options, or
@@ -589,6 +601,7 @@ export interface FastifyInstance<
     pluginTimeout?: number,
     requestIdHeader?: string | false,
     requestIdLogLabel?: string,
-    http2SessionTimeout?: number
+    http2SessionTimeout?: number,
+    useSemicolonDelimiter?: boolean,
   }>
 }

package/types/reply.d.ts

@@ -40,6 +40,7 @@ export interface FastifyReply<
 > {
   raw: RawReply;
   context: FastifyReplyContext<ContextConfig>;
+  elapsedTime: number;
   log: FastifyBaseLogger;
   request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>;
   server: FastifyInstance;
@@ -59,6 +60,9 @@ export interface FastifyReply<
   redirect(url: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   hijack(): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   callNotFound(): void;
+  /**
+   * @deprecated Use the Reply#elapsedTime property instead
+   */
   getResponseTime(): number;
   type(contentType: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   serializer(fn: (payload: any) => string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;

package/types/request.d.ts

@@ -22,10 +22,11 @@ export interface ValidationFunction {
 
 export interface RequestRouteOptions<ContextConfig = ContextConfigDefault, SchemaCompiler = FastifySchema> {
   method: string;
-  url: string;
-  bodyLimit:number;
-  attachValidation:boolean;
-  logLevel:string;
+  // `url` can be `undefined` for instance when `request.is404` is true
+  url: string | undefined;
+  bodyLimit: number;
+  attachValidation: boolean;
+  logLevel: string;
   version: string | undefined;
   exposeHeadRoute: boolean;
   prefixTrailingSlash: string;