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

package/README.md

@@ -319,6 +319,7 @@ listed in alphabetical order.
   <https://x.com/manueomm>, <https://www.npmjs.com/~eomm>
 * [__James Sumners__](https://github.com/jsumners),
   <https://x.com/jsumners79>, <https://www.npmjs.com/~jsumners>
+* [__Antonio Tripodi__](https://github.com/Tony133), <https://www.npmjs.com/~tony133>
 
 ### Fastify Plugins team
 * [__Harry Brundage__](https://github.com/airhorns/),

package/build/build-validation.js

@@ -40,6 +40,7 @@ const defaultInitOptions = {
   routerOptions: {
     allowUnsafeRegex: false,
     caseSensitive: true,
+    compile: false,
     ignoreTrailingSlash: false,
     ignoreDuplicateSlashes: false,
     maxParamLength: 100,
@@ -102,6 +103,7 @@ const schema = {
       properties: {
         allowUnsafeRegex: { type: 'boolean', default: defaultInitOptions.routerOptions.allowUnsafeRegex },
         caseSensitive: { type: 'boolean', default: defaultInitOptions.routerOptions.caseSensitive },
+        compile: { type: 'boolean', default: defaultInitOptions.routerOptions.compile },
         constraints: {
           type: 'object',
           additionalProperties: {

package/docs/Guides/Ecosystem.md

@@ -190,6 +190,10 @@ section.
 - [`@gquittet/graceful-server`](https://github.com/gquittet/graceful-server)
   Tiny (~5k), Fast, KISS, and dependency-free Node.js library to make your
   Fastify API graceful.
+- [`@guardcore/fastify`](https://github.com/Guard-Core/guard-core-ts/tree/master/packages/fastify)
+  Application-layer security plugin: request attack detection, IP and country
+  controls, bans, behavior rules, honeypots, security headers and per-route
+  decorators.
 - [`@h4ad/serverless-adapter`](https://github.com/H4ad/serverless-adapter)
   Run REST APIs and other web applications using your existing Node.js
   application framework (Express, Koa, Hapi and Fastify), on top of AWS Lambda,

package/docs/Guides/Migration-Guide-V5.md

@@ -405,7 +405,7 @@ fastify.get('/example/:file(^\\d+).png', function (request, reply) { })
 console.log(fastify.hasRoute({
   method: 'GET',
   url: '/example/12345.png'
-)); // true
+})); // true
 ```
 
 ```js
@@ -416,7 +416,7 @@ fastify.get('/example/:file(^\\d+).png', function (request, reply) { })
 console.log(fastify.hasRoute({
   method: 'GET',
   url: '/example/:file(^\\d+).png'
-)); // true
+})); // true
 ```
 
 ### Removal of some non-standard HTTP methods

package/docs/Guides/Serverless.md

@@ -127,8 +127,6 @@ on Fastify to find out how to integrate.
 [Genezio](https://genezio.com/) is a platform designed to simplify the deployment
 of serverless applications to the cloud.
 
-[Genezio has a dedicated guide for deploying a Fastify application.](https://deployapps.dev/docs/frameworks/fastify/)
-
 ## Google Cloud Functions
 
 ### Creation of Fastify instance
@@ -277,20 +275,21 @@ fastify.addHook('onResponse', async (request, reply) => {
 `request.routeOptions.url` is the route pattern, so `/users/123` and
 `/users/456` are grouped under `/users/:id`. With Fastify's logger enabled, the
 fields are emitted as structured log fields, as described in the [Cloud
-Logging structured logging documentation](https://cloud.google.com/logging/docs/structured-logging)
-and the [Cloud Functions logging guide](https://cloud.google.com/functions/docs/monitoring/logging).
+Logging structured logging documentation](https://docs.cloud.google.com/logging/docs/structured-logging)
+and the [Cloud Run logging guide](https://docs.cloud.google.com/run/docs/logging).
 In Cloud Logging, create a [log-based
-metric](https://cloud.google.com/logging/docs/logs-based-metrics) or filter on
-`jsonPayload.route` to get per-route request counts, latency, and error rates.
+metric](https://docs.cloud.google.com/logging/docs/logs-based-metrics)
+or filter on `jsonPayload.route` to get per-route request counts, latency, and
+error rates.
 
 The same hook works when deploying through Firebase Functions with `onRequest`.
 
 ### References
 - [Google Cloud Functions - Node.js Quickstart
-  ](https://cloud.google.com/run/docs/quickstarts/functions/deploy-functions-gcloud)
-- [Cloud Logging - Structured Logging](https://cloud.google.com/logging/docs/structured-logging)
-- [Cloud Logging - Log-based Metrics](https://cloud.google.com/logging/docs/logs-based-metrics)
-- [Cloud Functions - Logging](https://cloud.google.com/functions/docs/monitoring/logging)
+  ](https://docs.cloud.google.com/run/docs/quickstarts/functions/deploy-functions-gcloud)
+- [Cloud Logging - Structured Logging](https://docs.cloud.google.com/logging/docs/structured-logging)
+- [Cloud Logging - Log-based Metrics](https://docs.cloud.google.com/logging/docs/logs-based-metrics)
+- [Cloud Run - Logging](https://docs.cloud.google.com/run/docs/logging)
 
 ## Google Firebase Functions
 
@@ -384,6 +383,30 @@ Final step is to export the Fastify app instance to Firebase's own
 exports.app = onRequest(fastifyApp)
 ```
 
+### A note on per-route functions and observability
+
+When a Fastify instance is wrapped with a single `onRequest()` handler, all
+routes are handled through a single Cloud Function entry point (e.g. `app`).
+Fastify still performs internal routing as usual, but from the provider's
+perspective there is only one deployed function. As a result, logs, metrics,
+and analytics in the Cloud Console are grouped under that single function
+rather than being split per route (e.g. `app-api-v1-user`).
+
+This behavior is expected because Fastify acts as a single HTTP server with
+internal routing, while Cloud Functions exposes only function-level
+observability. This is different from architectures where each route is
+deployed as an individual Cloud Function.
+
+If per-function grouping is required, you must export multiple `onRequest()`
+handlers instead of routing everything through a single Fastify instance.
+
+Alternatively, you can keep a single Fastify application and deploy it to
+Cloud Run, where it runs as a long-lived server. In that setup, Fastify's
+built-in logging (request method, URL, and response timing) provides per-route
+observability. On Cloud Functions, similar request-level logs are still
+available, but they are grouped under the single function entry in the
+provider's console.
+
 ### Local test
 
 Install the Firebase tools functions so you can use the CLI:

package/docs/Reference/Errors.md

@@ -134,6 +134,19 @@ developer is responsible for ensuring errors are handled properly.
 Most errors result from unexpected input data, so it is recommended to
 [validate input data against a JSON schema](./Validation-and-Serialization.md).
 
+Errors that Fastify creates when it rejects an invalid request, such as a
+failed schema validation or a malformed body, do not have a stack trace, as it
+would only point at Fastify internals. These are
+[`FST_ERR_VALIDATION`](#fst_err_validation),
+[`FST_ERR_CTP_BODY_TOO_LARGE`](#fst_err_ctp_body_too_large),
+[`FST_ERR_CTP_INVALID_MEDIA_TYPE`](#fst_err_ctp_invalid_media_type),
+[`FST_ERR_CTP_INVALID_CONTENT_LENGTH`](#fst_err_ctp_invalid_content_length),
+[`FST_ERR_CTP_EMPTY_JSON_BODY`](#fst_err_ctp_empty_json_body),
+[`FST_ERR_CTP_INVALID_JSON_BODY`](#fst_err_ctp_invalid_json_body),
+[`FST_ERR_BAD_URL`](#fst_err_bad_url),
+[`FST_ERR_MAX_PARAM_LENGTH`](#fst_err_max_param_length)
+and [`FST_ERR_ROUTE_MISSING_CONTENT_TYPE`](#fst_err_route_missing_content_type).
+
 #### Catching Uncaught Errors In Fastify
 Fastify tries to catch as many uncaught errors as possible without hindering
 performance. This includes:

package/docs/Reference/Hooks.md

@@ -476,6 +476,12 @@ arrive.
 
 The hook function takes the Fastify instance as a first argument,
 and a `done` callback for synchronous hook functions.
+
+Alternatively, an object implementing `Symbol.asyncDispose` or
+`Symbol.dispose` can be registered as an `onClose` hook. Fastify invokes
+the appropriate disposal method when closing the server, allowing resources
+to be cleaned up using JavaScript's Explicit Resource Management protocol.
+
 ```js
 // callback style
 fastify.addHook('onClose', (instance, done) => {
@@ -488,6 +494,13 @@ fastify.addHook('onClose', async (instance) => {
   // Some async code
   await closeDatabaseConnections()
 })
+
+// or disposable object style (Explicit Resource Management)
+fastify.addHook('onClose', {
+  async [Symbol.asyncDispose] () {
+    await closeDatabaseConnections()
+  }
+})
 ```
 
 #### Execution order