Fix several broken links on website, clarify docs (fastify#2434)

Author: pearofducks

docs/ContentTypeParser.md

@@ -5,7 +5,7 @@ Natively, Fastify only supports `'application/json'` and `'text/plain'` content
 
 As with the other APIs, `addContentTypeParser` is encapsulated in the scope in which it is declared. This means that if you declare it in the root scope it will be available everywhere, while if you declare it inside a plugin it will be available only in that scope and its children.
 
-Fastify automatically adds the parsed request payload to the [Fastify request](./Request.md) object which you can access with `request.body`.
+Fastify automatically adds the parsed request payload to the [Fastify request](Request.md) object which you can access with `request.body`.
 
 ### Usage
 ```js
@@ -45,7 +45,7 @@ if (!fastify.hasContentTypeParser('application/jsoff')){
 **Notice**: The old syntaxes `function(req, done)` and `async function(req)` for the parser are still supported but they are deprecated.
 
 #### Body Parser
-You can parse the body of a request in two ways. The first one is shown above: you add a custom content type parser and handle the request stream. In the second one, you should pass a `parseAs` option to the `addContentTypeParser` API, where you declare how you want to get the body. It could be of type `'string'` or `'buffer'`. If you use the `parseAs` option, Fastify will internally handle the stream and perform some checks, such as the [maximum size](./Server.md#factory-body-limit) of the body and the content length. If the limit is exceeded the custom parser will not be invoked.
+You can parse the body of a request in two ways. The first one is shown above: you add a custom content type parser and handle the request stream. In the second one, you should pass a `parseAs` option to the `addContentTypeParser` API, where you declare how you want to get the body. It could be of type `'string'` or `'buffer'`. If you use the `parseAs` option, Fastify will internally handle the stream and perform some checks, such as the [maximum size](Server.md#factory-body-limit) of the body and the content length. If the limit is exceeded the custom parser will not be invoked.
 ```js
 fastify.addContentTypeParser('application/json', { parseAs: 'string' }, function (req, body, done) {
   try {
@@ -62,7 +62,7 @@ See [`example/parser.js`](../examples/parser.js) for an example.
 
 ##### Custom Parser Options
 + `parseAs` (string): Either `'string'` or `'buffer'` to designate how the incoming data should be collected. Default: `'buffer'`.
-+ `bodyLimit` (number): The maximum payload size, in bytes, that the custom parser will accept. Defaults to the global body limit passed to the [`Fastify factory function`](./Server.md#bodylimit).
++ `bodyLimit` (number): The maximum payload size, in bytes, that the custom parser will accept. Defaults to the global body limit passed to the [`Fastify factory function`](Server.md#bodylimit).
 
 #### Catch-All
 There are some cases where you need to catch all requests regardless of their content type. With Fastify, you can just use the `'*'` content type.
@@ -113,4 +113,4 @@ fastify.route({
 })
  ```
 
-For piping file uploads you may want to checkout [this plugin](https://github.com/fastify/fastify-multipart).
+For piping file uploads you may want to checkout [this plugin](https://github.com/fastify/fastify-multipart).

docs/Decorators.md

@@ -93,7 +93,7 @@ fastify.utility()
 console.log(fastify.conf.db)
 ```
 
-The decorated [Fastify server](./Server.md) is bound to `this` in route [route](./Routes.md) handlers:
+The decorated [Fastify server](Server.md) is bound to `this` in route [route](Routes.md) handlers:
 
 ```js
 fastify.decorate('db', new DbConnection())

docs/Errors.md

@@ -8,14 +8,14 @@
 
 Uncaught errors are likely to cause memory leaks, file descriptor leaks and other major production issues. [Domains](https://nodejs.org/en/docs/guides/domain-postmortem/) were introduced to try fixing this issue, but they did not. Given the fact that it is not possible to process all uncaught errors sensibly, the best way to deal with them at the moment is to [crash](https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly). In case of promises, make sure to [handle](https://nodejs.org/dist/latest-v8.x/docs/api/deprecations.html#deprecations_dep0018_unhandled_promise_rejections) errors [correctly](https://github.com/mcollina/make-promises-safe).
 
-Fastify follows an all-or-nothing approach and aims to be lean and optimal as much as possible. Thus, the developer is responsible for making sure that the errors are handled properly. Most of the errors are usually a result of unexpected input data, so we recommend specifying a [JSON.schema validation](./Validation-and-Serialization.md) for your input data.
+Fastify follows an all-or-nothing approach and aims to be lean and optimal as much as possible. Thus, the developer is responsible for making sure that the errors are handled properly. Most of the errors are usually a result of unexpected input data, so we recommend specifying a [JSON.schema validation](Validation-and-Serialization.md) for your input data.
 
 Fastify tries to catch as many uncaught errors it can without hindering performance. This includes:
 
 1. synchronous routes, e.g. `app.get('/', () => { throw new Error('kaboom') })`
 2. `async` routes, e.g. `app.get('/', async () => { throw new Error('kaboom') })`
 
-In those two cases, the error will safely be caught by the promise and routed to the default error handler of Fastify for a generic `Internal Server Error` response. For customizing this behaviour, you should use [`setErrorHandler`](./Server.md#seterrorhandler).
+In those two cases, the error will safely be caught by the promise and routed to the default error handler of Fastify for a generic `Internal Server Error` response. For customizing this behaviour, you should use [`setErrorHandler`](Server.md#seterrorhandler).
 
 <a name="fastify-error-codes"></a>
 ### Fastify Error Codes

docs/Fluent-Schema.md

@@ -2,7 +2,7 @@
 
 ## Fluent Schema
 
-The [Validation and Serialization](./Validation-and-Serialization.md) documentation outlines all parameters accepted by Fastify to set up JSON Schema Validation in order to validate the input, and JSON Schema Serialization in order to optimize the output.
+The [Validation and Serialization](Validation-and-Serialization.md) documentation outlines all parameters accepted by Fastify to set up JSON Schema Validation in order to validate the input, and JSON Schema Serialization in order to optimize the output.
 
 [`fluent-schema`](https://github.com/fastify/fluent-schema) can be used to simplify this task while allowing the reuse of constants.
 
@@ -53,7 +53,7 @@ fastify.post('/the/url', { schema }, handler)
 
 With `fluent-schema` you can manipulate your schemas in an easier and programmatic way and then reuse them
 thanks to the `addSchema()` method. You can refer to the schema in two different manners that are detailed
-in the [Validation-and-Serialization.md](./Validation-and-Serialization.md#adding-a-shared-schema) documentation.
+in the [Validation-and-Serialization.md](Validation-and-Serialization.md#adding-a-shared-schema) documentation.
 
 Here are some usage examples:
 

docs/Getting-Started.md

@@ -85,7 +85,7 @@ Fastify offers an easy platform that helps to solve all of the problems outlined
 ### Your first plugin
 As with JavaScript, where everything is an object, with Fastify everything is a plugin.<br>
 Before digging into it, let's see how it works!<br>
-Let's declare our basic server, but instead of declaring the route inside the entry point, we'll declare it in an external file (check out the [route declaration](./Routes.md) docs).
+Let's declare our basic server, but instead of declaring the route inside the entry point, we'll declare it in an external file (check out the [route declaration](Routes.md) docs).
 ```js
 const fastify = require('fastify')({
   logger: true
@@ -195,12 +195,12 @@ module.exports = routes
 Wow, that was fast!<br>
 Let's recap what we have done here since we've introduced some new concepts.<br>
 As you can see, we used `register` both for the database connector and the registration of the routes.
-This is one of the best features of Fastify, it will load your plugins in the same order you declare them, and it will load the next plugin only once the current one has been loaded. In this way, we can register the database connector in the first plugin and use it in the second *(read [here](./Plugins.md#handle-the-scope) to understand how to handle the scope of a plugin)*.
+This is one of the best features of Fastify, it will load your plugins in the same order you declare them, and it will load the next plugin only once the current one has been loaded. In this way, we can register the database connector in the first plugin and use it in the second *(read [here](Plugins.md#handle-the-scope) to understand how to handle the scope of a plugin)*.
 Plugin loading starts when you call `fastify.listen()`, `fastify.inject()` or `fastify.ready()`
 
 We have also used the `decorate` API to add custom objects to the Fastify namespace, making them available for use everywhere. Use of this API is encouraged to facilitate easy code reuse and to decrease code or logic duplication.
 
-To dig deeper into how Fastify plugins work, how to develop new plugins, and for details on how to use the whole Fastify API to deal with the complexity of asynchronously bootstrapping an application, read [the hitchhiker's guide to plugins](./Plugins-Guide.md).
+To dig deeper into how Fastify plugins work, how to develop new plugins, and for details on how to use the whole Fastify API to deal with the complexity of asynchronously bootstrapping an application, read [the hitchhiker's guide to plugins](Plugins-Guide.md).
 
 <a name="plugin-loading-order"></a>
 ### Loading order of your plugins
@@ -259,7 +259,7 @@ fastify.post('/', opts, async (request, reply) => {
 })
 ```
 This example shows how to pass an options object to the route, which accepts a `schema` key, that contains all of the schemas for route, `body`, `querystring`, `params` and `headers`.<br>
-Read [Validation and Serialization](./Validation-and-Serialization.md) to learn more.
+Read [Validation and Serialization](Validation-and-Serialization.md) to learn more.
 
 <a name="serialize-data"></a>
 ### Serialize your data
@@ -284,17 +284,17 @@ fastify.get('/', opts, async (request, reply) => {
 })
 ```
 Simply by specifying a schema as shown, you can speed up serialization by a factor of 2-3. This also helps to protect against leakage of potentially sensitive data, since Fastify will serialize only the data present in the response schema.
-Read [Validation and Serialization](./Validation-and-Serialization.md) to learn more.
+Read [Validation and Serialization](Validation-and-Serialization.md) to learn more.
 
 <a name="extend-server"></a>
 ### Extend your server
 Fastify is built to be extremely extensible and minimal, we believe that a bare bones framework is all that is necessary to make great applications possible.<br>
-In other words, Fastify is not a "batteries included" framework, and relies on an amazing [ecosystem](./Ecosystem.md)!
+In other words, Fastify is not a "batteries included" framework, and relies on an amazing [ecosystem](Ecosystem.md)!
 
 <a name="test-server"></a>
 ### Test your server
 Fastify does not offer a testing framework, but we do recommend a way to write your tests that uses the features and architecture of Fastify.<br>
-Read the [testing](./Testing.md) documentation to learn more!
+Read the [testing](Testing.md) documentation to learn more!
 
 <a name="cli"></a>
 ### Run your server from CLI

docs/Hooks.md

@@ -27,10 +27,10 @@ By using hooks you can interact directly with the lifecycle of Fastify. There ar
 
 ## Request/Reply Hooks
 
-[Request](./Request.md) and [Reply](./Reply.md) are the core Fastify objects.<br/>
-`done` is the function to continue with the [lifecycle](./Lifecycle.md).
+[Request](Request.md) and [Reply](Reply.md) are the core Fastify objects.<br/>
+`done` is the function to continue with the [lifecycle](Lifecycle.md).
 
-It is pretty easy to understand where each hook is executed by looking at the [lifecycle page](./Lifecycle.md).<br>
+It is pretty easy to understand where each hook is executed by looking at the [lifecycle page](Lifecycle.md).<br>
 Hooks are affected by Fastify's encapsulation, and can thus be applied to selected routes. See the [Scopes](#scope) section for more information.
 
 There are eight different hooks that you can use in Request/Reply *(in order of execution)*:
@@ -219,7 +219,7 @@ fastify.addHook('preHandler', (request, reply, done) => {
   done(new Error('Some error'))
 })
 ```
-*The error will be handled by [`Reply`](./Reply.md#errors).*
+*The error will be handled by [`Reply`](Reply.md#errors).*
 
 Or if you're using `async/await` you can just throw an error:
 ```js
@@ -322,7 +322,7 @@ fastify.addHook('onReady', async function () {
 
 <a name="on-close"></a>
 ### onClose
-Triggered when `fastify.close()` is invoked to stop the server. It is useful when [plugins](./Plugins.md) need a "shutdown" event, for example to close an open connection to a database.<br>
+Triggered when `fastify.close()` is invoked to stop the server. It is useful when [plugins](Plugins.md) need a "shutdown" event, for example to close an open connection to a database.<br>
 The first argument is the Fastify instance, the second one the `done` callback.
 ```js
 fastify.addHook('onClose', (instance, done) => {
@@ -396,7 +396,7 @@ fastify.addHook('onRegister', (instance, opts) => {
 
 <a name="scope"></a>
 ## Scope
-Except for [onClose](#onclose), all hooks are encapsulated. This means that you can decide where your hooks should run by using `register` as explained in the [plugins guide](./Plugins-Guide.md). If you pass a function, that function is bound to the right Fastify context and from there you have full access to the Fastify API.
+Except for [onClose](#onclose), all hooks are encapsulated. This means that you can decide where your hooks should run by using `register` as explained in the [plugins guide](Plugins-Guide.md). If you pass a function, that function is bound to the right Fastify context and from there you have full access to the Fastify API.
 
 ```js
 fastify.addHook('onRequest', function (request, reply, done) {

docs/Logging.md

@@ -57,9 +57,9 @@ const fastify = require('fastify')({
 
 <a name="logging-request-id"></a>
 
-By default, fastify adds an id to every request for easier tracking. If the "request-id" header is present its value is used, otherwise a new incremental id is generated. See Fastify Factory [`requestIdHeader`](./Server.md#factory-request-id-header) and Fastify Factory [`genReqId`](./Server.md#gen-request-id) for customization options.
+By default, fastify adds an id to every request for easier tracking. If the "request-id" header is present its value is used, otherwise a new incremental id is generated. See Fastify Factory [`requestIdHeader`](Server.md#factory-request-id-header) and Fastify Factory [`genReqId`](Server.md#gen-request-id) for customization options.
 
-The default logger is configured with a set of standard serializers that serialize objects with `req`, `res`, and `err` properties. The object received by `req` is the Fastify [`Request`](./Request.md) object, while the object received by `res` is the Fastify [`Reply`](./Reply.md) object.  
+The default logger is configured with a set of standard serializers that serialize objects with `req`, `res`, and `err` properties. The object received by `req` is the Fastify [`Request`](Request.md) object, while the object received by `res` is the Fastify [`Reply`](Reply.md) object.  
 This behaviour can be customized by specifying custom serializers.
 ```js
 const fastify = require('fastify')({
@@ -136,7 +136,7 @@ fastify.get('/', function (request, reply) {
 })
 ```
 
-*The logger instance for the current request is available in every part of the [lifecycle](./Lifecycle.md).*
+*The logger instance for the current request is available in every part of the [lifecycle](Lifecycle.md).*
 
 ## Log Redaction
 

docs/Middleware.md

@@ -23,9 +23,9 @@ await fastify.register(require('middie'))
 fastify.use(require('cors')())
 ```
 
-Remember that middleware can be encapsulated, this means that you can decide where your middleware should run by using `register` as explained in the [plugins guide](./Plugins-Guide.md).
+Remember that middleware can be encapsulated, this means that you can decide where your middleware should run by using `register` as explained in the [plugins guide](Plugins-Guide.md).
 
-Fastify middleware also do not expose the `send` method or other methods specific to the Fastify [Reply](./Reply.md#reply) instance. This is because Fastify wraps the incoming `req` and `res` Node instances using the [Request](./Request.md#request) and [Reply](./Reply.md#reply) objects internally, but this is done after the middleware phase. If you need to create middleware, you have to use the Node `req` and `res` instances. Otherwise, you can use the `preHandler` hook which already has the [Request](./Request.md#request) and [Reply](./Reply.md#reply) Fastify instances. For more information, see [Hooks](./Hooks.md#hooks).
+Fastify middleware also do not expose the `send` method or other methods specific to the Fastify [Reply](Reply.md#reply) instance. This is because Fastify wraps the incoming `req` and `res` Node instances using the [Request](Request.md#request) and [Reply](Reply.md#reply) objects internally, but this is done after the middleware phase. If you need to create middleware, you have to use the Node `req` and `res` instances. Otherwise, you can use the `preHandler` hook which already has the [Request](Request.md#request) and [Reply](Reply.md#reply) Fastify instances. For more information, see [Hooks](Hooks.md#hooks).
 
 <a name="restrict-usage"></a>
 #### Restrict middleware execution to a certain path(s)
@@ -41,7 +41,7 @@ const serveStatic = require('serve-static')
 fastify.use('/css', serveStatic(path.join(__dirname, '/assets')))
 
 // Wildcard path
-fastify.use('/css/*', serveStatic(path.join(__dirname, '/assets')))
+fastify.use('/css/(.*)', serveStatic(path.join(__dirname, '/assets')))
 
 // Multiple paths
 fastify.use(['/css', '/js'], serveStatic(path.join(__dirname, '/assets')))

docs/Migration-Guide-V3.md

@@ -34,8 +34,8 @@ fastify.use(require('cors')());
 
 ### Changed logging serialization ([#2017](https://github.com/fastify/fastify/pull/2017))
 
-The logging [Serializers](./Logging.md) have been updated to now Fastify
-[`Request`](./Request.md) and [`Reply`](./Reply.md) objects instead of
+The logging [Serializers](Logging.md) have been updated to now Fastify
+[`Request`](Request.md) and [`Reply`](Reply.md) objects instead of
 native ones.
 
 Any custom serializers must be updated if they rely upon `request` or `reply`
@@ -269,14 +269,14 @@ fastify.get('/', (request, reply) => {
 
 - Hooks now have consistent context irregardless of how they are registered
 ([#2005](https://github.com/fastify/fastify/pull/2005))
-- Deprecated `request.req` and `reply.res` for [`request.raw`](./Request.md) and
-[`reply.raw`](./Reply.md) ([#2008](https://github.com/fastify/fastify/pull/2008))
+- Deprecated `request.req` and `reply.res` for [`request.raw`](Request.md) and
+[`reply.raw`](Reply.md) ([#2008](https://github.com/fastify/fastify/pull/2008))
 - Removed `modifyCoreObjects` option ([#2015](https://github.com/fastify/fastify/pull/2015))
-- Added [`connectionTimeout`](./Server.md#factory-connection-timeout)
+- Added [`connectionTimeout`](Server.md#factory-connection-timeout)
 option ([#2086](https://github.com/fastify/fastify/pull/2086))
-- Added [`keepAliveTimeout`](./Server.md#factory-keep-alive-timeout)
+- Added [`keepAliveTimeout`](Server.md#factory-keep-alive-timeout)
 option ([#2086](https://github.com/fastify/fastify/pull/2086))
-- Added async-await support for [plugins](./Plugins.md#async-await)
+- Added async-await support for [plugins](Plugins.md#async-await)
 ([#2093](https://github.com/fastify/fastify/pull/2093))
 - Added the feature to throw object as error
 ([#2134](https://github.com/fastify/fastify/pull/2134))