fastify 4.19.0 → 4.19.1

package/docs/Guides/Serverless.md

@@ -28,7 +28,7 @@ snippet of code.
 - [Google Cloud Functions](#google-cloud-functions)
 - [Google Cloud Run](#google-cloud-run)
 - [Netlify Lambda](#netlify-lambda)
-- [Platformatic Cloud](#platformatic)
+- [Platformatic Cloud](#platformatic-cloud)
 - [Vercel](#vercel)
 
 ## AWS

package/docs/Guides/Testing.md

@@ -1,12 +1,15 @@
-<h1 align="center">Fastify</h1>
+<h1 style="text-align: center;">Fastify</h1>
 
-## Testing
+# Testing
+<a id="testing"></a>
 
 Testing is one of the most important parts of developing an application. Fastify
 is very flexible when it comes to testing and is compatible with most testing
 frameworks (such as [Tap](https://www.npmjs.com/package/tap), which is used in
 the examples below).
 
+## Application
+
 Let's `cd` into a fresh directory called 'testing-example' and type `npm init
 -y` in our terminal.
 
@@ -345,3 +348,133 @@ test('should ...', {only: true}, t => ...)
 
 Now you should be able to step through your test file (and the rest of
 `Fastify`) in your code editor.
+
+
+
+## Plugins
+Let's `cd` into a fresh directory called 'testing-plugin-example' and type `npm init
+-y` in our terminal.
+
+Run `npm i fastify fastify-plugin && npm i tap -D`
+
+**plugin/myFirstPlugin.js**:
+
+```js
+const fP = require("fastify-plugin")
+
+async function myPlugin(fastify, options) {
+    fastify.decorateRequest("helloRequest", "Hello World")
+    fastify.decorate("helloInstance", "Hello Fastify Instance")
+}
+
+module.exports = fP(myPlugin)
+```
+
+A basic example of a Plugin. See [Plugin Guide](./Plugins-Guide.md)
+
+**test/myFirstPlugin.test.js**:
+
+```js
+const Fastify = require("fastify");
+const tap = require("tap");
+const myPlugin = require("../plugin/myFirstPlugin");
+
+tap.test("Test the Plugin Route", async t => {
+    // Create a mock fastify application to test the plugin
+    const fastify = Fastify()
+
+    fastify.register(myPlugin)
+
+    // Add an endpoint of your choice 
+    fastify.get("/", async (request, reply) => {
+        return ({ message: request.helloRequest })
+    })
+
+    // Use fastify.inject to fake a HTTP Request
+    const fastifyResponse = await fastify.inject({
+        method: "GET",
+        url: "/"
+    })
+    
+  console.log('status code: ', fastifyResponse.statusCode)
+  console.log('body: ', fastifyResponse.body)
+})
+```
+Learn more about [```fastify.inject()```](#benefits-of-using-fastifyinject).
+Run the test file in your terminal `node test/myFirstPlugin.test.js`
+
+```sh
+status code:  200
+body:  {"message":"Hello World"}
+```
+
+Now we can replace our `console.log` calls with actual tests!
+
+In your `package.json` change the "test" script to:
+
+`"test": "tap --reporter=list --watch"`
+
+Create the tap test for the endpoint.
+
+**test/myFirstPlugin.test.js**:
+
+```js
+const Fastify = require("fastify");
+const tap = require("tap");
+const myPlugin = require("../plugin/myFirstPlugin");
+
+tap.test("Test the Plugin Route", async t => {
+    // Specifies the number of test
+    t.plan(2)
+
+    const fastify = Fastify()
+
+    fastify.register(myPlugin)
+
+    fastify.get("/", async (request, reply) => {
+        return ({ message: request.helloRequest })
+    })
+
+    const fastifyResponse = await fastify.inject({
+        method: "GET",
+        url: "/"
+    })
+    
+    t.equal(fastifyResponse.statusCode, 200)
+    t.same(JSON.parse(fastifyResponse.body), { message: "Hello World" })
+})
+```
+
+Finally, run `npm test` in the terminal and see your test results!
+
+Test the ```.decorate()``` and ```.decorateRequest()```.
+
+**test/myFirstPlugin.test.js**:
+
+```js
+const Fastify = require("fastify");
+const tap = require("tap");
+const myPlugin = require("../plugin/myFirstPlugin");
+
+tap.test("Test the Plugin Route", async t => {
+    t.plan(5)
+    const fastify = Fastify()
+
+    fastify.register(myPlugin)
+
+    fastify.get("/", async (request, reply) => {
+        // Testing the fastify decorators
+        t.not(request.helloRequest, null) 
+        t.ok(request.helloRequest, "Hello World")
+        t.ok(fastify.helloInstance, "Hello Fastify Instance")
+        return ({ message: request.helloRequest })
+    })
+
+    const fastifyResponse = await fastify.inject({
+        method: "GET",
+        url: "/"
+    })
+    t.equal(fastifyResponse.statusCode, 200)
+    t.same(JSON.parse(fastifyResponse.body), { message: "Hello World" })
+})
+```

package/docs/Guides/Write-Plugin.md

@@ -1,4 +1,4 @@
-<h1 align="center">Fastify</h1>
+<h1 style="text-align: center;">Fastify</h1>
 
 # How to write a good plugin
 First, thank you for deciding to write a plugin for Fastify. Fastify is a
@@ -63,6 +63,8 @@ among different versions of its dependencies.
 We do not enforce any testing library. We use [`tap`](https://www.node-tap.org/)
 since it offers out-of-the-box parallel testing and code coverage, but it is up
 to you to choose your library of preference.
+We highly recommend you read the [Plugin Testing](./Testing.md#plugins) to 
+learn about how to test your plugins.
 
 ## Code Linter
 It is not mandatory, but we highly recommend you use a code linter in your

package/docs/Reference/TypeScript.md

@@ -508,7 +508,7 @@ Fastify Plugin in a TypeScript Project.
    `"compilerOptions"` object.
    ```json
    {
-     "compileOptions": {
+     "compilerOptions": {
        "declaration": true
      }
    }

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.19.0'
+const VERSION = '4.19.1'
 
 const Avvio = require('avvio')
 const http = require('http')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.19.0",
+  "version": "4.19.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",

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

@@ -18,6 +18,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   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)
+  expectType<(payload?: unknown) => FastifyReply>(reply.code(100 as number).send)
   expectType<number>(reply.statusCode)
   expectType<boolean>(reply.sent)
   expectType<((payload?: unknown) => FastifyReply)>(reply.send)

package/types/reply.d.ts

@@ -12,10 +12,11 @@ export interface ReplyGenericInterface {
   Reply?: ReplyDefault;
 }
 
-export type ReplyTypeConstrainer<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>> =
+export type ReplyTypeConstrainer<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>, ReplyKey = CodeToReplyKey<Code>> =
   Code extends keyof RouteGenericReply ? RouteGenericReply[Code] :
-    CodeToReplyKey<Code> extends keyof RouteGenericReply ? RouteGenericReply[CodeToReplyKey<Code>] :
-      unknown;
+    [ReplyKey] extends [never] ? unknown :
+      ReplyKey extends keyof RouteGenericReply ? RouteGenericReply[ReplyKey] :
+        unknown;
 /**
  * FastifyReply is an instance of the standard http or http2 reply types.
  * It defaults to http.ServerResponse, and it also extends the relative reply object.