Datasets:

Partha117

/

oss_bugs

like 0

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Ecosystem.md"]

Add fastify-schema-to-typescript to ecosystem

Hi team, I've been working on this tool to generate typescript types from a json schema. It allows to have types that match the validation schema. Would it be possible to add it to the ecosystem? If no would it be possible to have some feedback to make it better Here's the repo https://github.com/thomasthiebaud/fastify-schema-to-typescript

https://github.com/fastify/fastify/issues/2897

https://github.com/fastify/fastify/pull/2898

fefab178bc1cc14cfd5965583500800ff0c61d27

efa77faeac506c0339c28a6708d42a0876d8e2d5

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/ContentTypeParser.md", "lib/contentTypeParser.js", "lib/errors.js", "test/content-parser.test.js", "test/custom-parser.test.js", "types/content-type-parser.d.ts"]

Support RegExp for the addContentTypeParser API

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🚀 Feature Proposal Support `RegExp` for the `addContentTypeParser` API. ## Motivation Currently, you need to add a new content type parser for each new content type you use. So you have to add 2 parsers if you use the content types `application/vnd.user+json` and `application/vnd.book+json`, even though both are valid JSON objects and could use the same content type parser. This could be possible if the `addContentTypeParser` API supported `RegExp` in addition to string values. ## Example ```javascript fastify.addContentTypeParser(/s*\+json$/, { parseAs: "string" }, function (req, body, done) { try { var json = JSON.parse(body) done(null, json) } catch (err) { err.statusCode = 400 done(err, undefined) } }) ```

https://github.com/fastify/fastify/issues/2885

https://github.com/fastify/fastify/pull/2890

0b6ca3afaa4687ee83412ab010df62b8261a3684

fefab178bc1cc14cfd5965583500800ff0c61d27

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reference/Validation-and-Serialization.md", "package.json", "test/schema-feature.test.js"]

Should array support in validation be enabled by default?

## 🚀 Feature Proposal In #2841 the question came up whether supporting array validation should be enabled by default, and I was asked to open a new issue to discuss the breaking change. My naive reasoning was: - In cases that don't use `type: 'array'` in the schema there shouldn't be an impact on either behavior or performance, because nothing gets coerced as array anyway. - As soon as arrays are involved, users probably would want to have it enabled to make it actually do what is intuitively expected. In particular in query string validation, arrays do not work by default without array coercing as discussed in in #2841. - Even for body validation where arrays do work already there shouldn't be a performance difference: The validation has to run `Array.isArray` anyway, and no further coercion is required in these cases where the object already is an array. The question is if this would be a semver-major change. As far as I can see the change would strictly increase the set of inputs that pass validation, i.e., everything that has passed validation before still passes validation, but there is now more input that fits to the schema, because scalars / missing values could be coerced to 1-element or 0-element arrays. In the case of query string validation this is certainly desired, because otherwise passing-in arrays isn't working (easily / by default). In the case of request body validation it is a question of API strictness whether one considers it a breaking change. Looks like a classical problem of semantic versioning: To 90% of the users a scope broadening change like that isn't breaking and may be welcome, but there may be a minority relying on it. ## Motivation See #2841.

https://github.com/fastify/fastify/issues/2852

https://github.com/fastify/fastify/pull/3594

38fc063ecd3febeb7e2d93453760ab4cd9147845

0033f739d4c8471b55991835f92eee94d7491292

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Errors.md", "fastify.js", "lib/errors.js", "lib/hooks.js", "package.json", "test/hooks.on-ready.test.js", "test/plugin.test.js"]

Improve errors user experience

Fastify has many assertions around in the codebase to make sure that the user didn't misconfigure something, for instance, it checks if a route has been declared twice or if a plugin is not a function. This is great, we vastly reduce the possibility of weird runtime issues, but for historical reasons the errors we are emitting are everything but user friendly. We should improve this situation, as it is a big pain point in our user experience. Example of double route declaration: ```js 'use strict' const fastify = require('fastify')() fastify.get('/', () => {}) fastify.get('/', () => {}) fastify.listen(3000, console.log) ``` ``` ▶ node index.js AssertionError [ERR_ASSERTION]: Method 'GET' already declared for route '/' at Router._insert (.../fst-err/node_modules/find-my-way/index.js:304:9) at Router._on (.../fst-err/node_modules/find-my-way/index.js:197:8) at Router.on (.../fst-err/node_modules/find-my-way/index.js:74:8) at Object.afterRouteAdded (.../fst-err/node_modules/fastify/lib/route.js:253:16) at .../fst-err/node_modules/fastify/lib/route.js:187:25 at Object._encapsulateThreeParam (.../fst-err/node_modules/avvio/boot.js:545:7) at Boot.timeoutCall (.../fst-err/node_modules/avvio/boot.js:447:5) at Boot.callWithCbOrNextTick (.../fst-err/node_modules/avvio/boot.js:428:19) at Boot._after (.../fst-err/node_modules/avvio/boot.js:273:26) at Plugin.exec (.../fst-err/node_modules/avvio/plugin.js:131:17) { generatedMessage: false, code: 'ERR_ASSERTION', actual: false, expected: true, operator: '==' } ``` What I would expect instead is: ``` FastifyError: Method 'GET' already declared for route '/' at fastify.get('/', () => {}) (.../fst-err/index.js:4:9) ``` Which is quite complex, given that our route declaration is asynchronous. Another example, this time with bad plugin type: ```js 'use strict' const fastify = require('fastify')() fastify.register(null) fastify.listen(3000, console.log) ``` ``` ▶ node index.js .../fst-err/node_modules/avvio/boot.js:200 throw new Error('plugin must be a function or a promise') ^ Error: plugin must be a function or a promise at assertPlugin (.../fst-err/node_modules/avvio/boot.js:200:11) at Boot._addPlugin (.../fst-err/node_modules/avvio/boot.js:233:12) at Boot.use (.../fst-err/node_modules/avvio/boot.js:209:25) at Object.server.<computed> [as register] (.../fst-err/node_modules/avvio/boot.js:33:14) at Object.<anonymous> (.../fst-err/index.js:5:9) at Module._compile (internal/modules/cjs/loader.js:1063:30) at Object.Module._extensions..js (internal/modules/cjs/loader.js:1092:10) at Module.load (internal/modules/cjs/loader.js:928:32) at Function.Module._load (internal/modules/cjs/loader.js:769:14) at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:72:12) ``` As you can see, the error is not being helpful at all.

https://github.com/fastify/fastify/issues/2842

https://github.com/fastify/fastify/pull/3106

71b21bfafc4b074b2e4d42f20b5e60a4a7ada395

c631bb71b8c180c8ba326e81455836f93b0d08c9

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Server.md"]

Logger option genReqId not considered

## 🐛 Bug Report The `genReqId` function specified within the standard Pino Logger options object is not considered, when generating identifiers for incoming requests. ## To Reproduce ```js fastify({ logger: { genReqId: req => 'whatever string', }, }); ``` This bug was fixed here https://github.com/fastify/fastify/commit/526e3a5fc243984270ab4cf22609c79c5de409ba, but got reintroduced. ## Expected behavior According to the docs, the logger's `genReqId` function should be applied. The fix might be to check if the `logger.genReqId` is set. ```js // Update the options with the fixed values ... options.logger = logger options.genReqId = logger.genReqId || genReqId options.requestIdHeader = requestIdHeader ... ``` ## Your Environment - *node version*: 14.15 - *fastify version*: 3.11.0 - *os*: Mac

https://github.com/fastify/fastify/issues/2836

https://github.com/fastify/fastify/pull/2838

fc33ae97ed2de9d2c9c262f5efb966c84e942547

91d87c54efe961496e85053bdb1bebbdffbd29ef

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Request.md", "lib/request.js", "test/schema-special-usage.test.js"]

Validation tries to set headers but its not possible

## 🐛 Bug Report Hi people, while upgrading to v3 I've noticed a strange behavior. #2426 has changed headers to be a getter, but `validateParam` (https://github.com/fastify/fastify/blob/master/lib/validation.js#L74) does try to assign it if the validation result contains the `value`. This does not come up with ajv because it mutates the original headers if `coerceTypes` is set. Joi returns the modified value that broke my upgrade to v3. I do not know how do other libraries do that. This did not happen on 2.14, what we are currently using. I see that since #2355 joi is not supported officially, but this still smells like a bug. It is not clear how we should proceed. We can of course consider moving to ajv, but that is a lot more involved than just updating fastify. ## To Reproduce Steps to reproduce the behavior: ```js const Joi = require('joi') const schemaValidator = ({ schema }) => data => schema.validate(data) const fastify = require('fastify')({ logger: { leve: 'debug' }}) .setValidatorCompiler(schemaValidator) const options = { schema: { headers: Joi.object({ 'user-agent': Joi.string().required(), host: Joi.string().required() }) } } fastify.post('/', options, (request, reply) => { reply.status(200) }) fastify.inject({ method: 'POST', url: '/' }) ``` This results in the following stack trace: ``` TypeError: Cannot set property headers of #<Request> which has only a getter at validateParam (/home/ttancos/node_modules/fastify/lib/validation.js:74:44) at validate (/home/ttancos/node_modules/fastify/lib/validation.js:92:19) at preValidationCallback (/home/ttancos/node_modules/fastify/lib/handleRequest.js:87:18) at handler (/home/ttancos/node_modules/fastify/lib/handleRequest.js:70:7) at handleRequest (/home/ttancos/node_modules/fastify/lib/handleRequest.js:30:9) at runPreParsing (/home/ttancos/node_modules/fastify/lib/route.js:416:5) at Object.routeHandler [as handler] (/home/ttancos/node_modules/fastify/lib/route.js:374:7) at Router.lookup (/home/ttancos/node_modules/find-my-way/index.js:367:14) at /home/ttancos/node_modules/fastify/fastify.js:401:11 at manageErr (/home/ttancos/node_modules/fastify/fastify.js:438:11) ``` ## Expected behavior Headers contain the validation result. ## Your Environment - *node version*: 12.19.1 - *fastify version*: 3.10.1 - *os*: ArchLinux

https://github.com/fastify/fastify/issues/2813

https://github.com/fastify/fastify/pull/2817

612ff0beacd7c803114853dd29ec27f3c7c1178d

fb5e1f176500654a97fc27f91a08288a83eb3ebe

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/route.js", "test/route.test.js"]

Creates incorrect HEAD route when using exposeHeadRoute

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report As discovered in https://github.com/fastify/fastify/pull/2782#discussion_r554836505, when a route is set up with `exposeHeadRoute: true` with `prefix` and `prefixTrailingSlash`, a mysterious `HEAD` route is created. Needs more investigation. ## To Reproduce Steps to reproduce the behavior: ```js fastify.register(function routes (f, opts, next) { f.route({ method: 'GET', url: '/', exposeHeadRoute: true, prefixTrailingSlash: 'no-slash', handler: (req, reply) => { reply.send({ hello: 'world' }) } }) next() }, { prefix: '/prefix' }) ``` Creates following routes - `GET /prefix` - `HEAD /prefix/prefix` (incorrect) When `prefixTrailingSlash` is set to `"both"`, it creates an **extra** route. - `GET /prefix` - `HEAD /prefix/prefix` - `GET /prefix/` - `HEAD /prefix` - `HEAD /prefix/` ## Expected behavior Should not create extra or incorrect routes.

https://github.com/fastify/fastify/issues/2788

https://github.com/fastify/fastify/pull/2790

3634c6e01e4049e946da68647a6aaf5847dbccbd

f3d5742f5398e37401d9ea0766d9a37d6f38f08a

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/reply.js", "test/internals/reply.test.js"]

preSerialization won't be exeecuted in case of a custom serializer.

If you define a custom [reply serializer](https://www.fastify.io/docs/latest/Reply/#serializerfunc), the `preSerialization` won't be executed. I think this is a leftover of previous implementations and it should considered a bug. https://github.com/fastify/fastify/blob/834a4e58de86d7996b50a4663fbf2b0fac4686ee/lib/reply.js#L146-L147 To reproduce: ```js 'use strict' const fastify = require('fastify')() fastify.addHook('preSerialization', async (req, reply, payload) => { console.log('preSerialization', payload) return payload }) fastify.get('/', (req, reply) => { reply .type('application/json') .serializer(JSON.stringify) .send({ hello: 'world' }) }) fastify.inject('/', (e, response) => console.log(response.json())) ```

https://github.com/fastify/fastify/issues/2770

https://github.com/fastify/fastify/pull/2773

886fd348150476ff1303f7ca28d76546c57a3f15

9b0c85472e07cc2907591b3df8f9e7e0b1869b7d

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/route.js", "test/hooks.test.js", "test/route-prefix.test.js", "test/route.test.js"]

Allow onRoute to alter options without side effects

## 🚀 Feature Proposal The way the `onRoute` hook can be used is to derive some info from the route settings (for swagger for example), or to __mutate the route definition itself__. However in certain cases Fastify creates two routes from the same definition (see https://github.com/fastify/fastify/blob/834a4e58de86d7996b50a4663fbf2b0fac4686ee/lib/route.js#L163-L170). I propose to update the `onRoute` hook so that: ```js fastify.addHook('onRoute', function (opts) { const copy = Object.assign({}, opts) copy.onRequest = newHook return copy }) ``` This is to avoid having some custom state like in: https://github.com/fastify/fastify-compress/pull/141. Note that the actual change is quite simple, as we just need to alter: https://github.com/fastify/fastify/blob/834a4e58de86d7996b50a4663fbf2b0fac4686ee/lib/route.js#L200-L207. This change is semver-major and should target the `next` branch.

https://github.com/fastify/fastify/issues/2767

https://github.com/fastify/fastify/pull/2782

9135e8e79a03e02063b1e6b96115ac6abca5ccf0

5a6aa29a113704448433b6cc19f6e33032aae77f

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/request.js", "package.json", "test/internals/request.test.js"]

[FST_LIGHTMYREQUEST_DEP01] When I run my test units

## 🐛 Bug Report When I run my test units , i get [FST_LIGHTMYREQUEST_DEP01] deprecation warning. I use jest for testing and request injetcion: #sample.spec.js ```js describe('SampleTest', () => { /** @type {import('awilix').AwilixContainer} */ let container; afterEach(async () => { await container.dispose(); }); it('sample-test', async () => { // resolve awilix containers that I need const FastifyOpenApi = container.resolve('FastifyOpenApi'); /** @type {import('fastify').FastifyInstance} app */ const app = FastifyOpenApi.getFastify(); container.resolve('AddSchema'); container.resolve('AddTagApp'); const config = container.resolve('config'); const injectReq = await app.inject({ url: `${config.API_PREFIX}/tag`, method: 'POST', payload: { title: 'title', description: '', }, }); expect(injectReq.statusCode).toEqual(200); }); }); ``` My tests passed successfully but I got this deprecation warning: ``` (node:64) [FST_LIGHTMYREQUEST_DEP01] FastifyDeprecationLightMyRequest: You are accessing "request.connection", use "request.socket" instead. ``` I want to know why it happened? and what should I do? ## My Environment - *node version*: 12.18.3 - *fastify version*: >=3.9 - *os*: ubuntu 20.04 - jest: 26

https://github.com/fastify/fastify/issues/2761

https://github.com/fastify/fastify/pull/2849

7fdef2dcd7d08c2b908402fa6fb5ecc26b762c41

e5ed15466f26840bc7a71f8f74da54dcce4192e2

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/pluginUtils.js", "test/plugin.test.js"]

Report actual plugin requiring decorator

https://github.com/fastify/fastify/blob/c2c5cfca689234864d5a208301dde10cefab9804/lib/pluginUtils.js#L82-L85 The above assertion isn't too helpful. If a plugin asks for the "foo" decorator on the "fastify" object, then it gives a message like the following when that decorator is not found: > The decorator 'foo' is not present in Fastify The stack trace ends up looking something like: ``` "error": { "generatedMessage": false, "code": "ERR_ASSERTION", "actual": false, "expected": true, "operator": "==", "name": "AssertionError", "message": "The decorator 'mysql' is not present in Fastify", "errorClass": "AssertionError", "stacktrace": [ { "file": "node_modules/fastify/lib/pluginUtils.js", "method": "<anonymous>", "lineNumber": 79, "columnNumber": 5 }, { "file": "node_modules/fastify/lib/pluginUtils.js", "method": "Object._checkDecorators", "lineNumber": 78, "columnNumber": 14 }, { "file": "node_modules/fastify/lib/pluginUtils.js", "method": "Object.checkDecorators", "lineNumber": 70, "columnNumber": 44 }, { "file": "node_modules/fastify/lib/pluginUtils.js", "method": "Object.registerPlugin", "lineNumber": 97, "columnNumber": 19 }, { "file": "node_modules/fastify/fastify.js", "method": "Boot.override", "lineNumber": 566, "columnNumber": 57 }, { "file": "node_modules/fastify/node_modules/avvio/plugin.js", "method": "Plugin.exec", "lineNumber": 64, "columnNumber": 31 }, { "file": "node_modules/fastify/node_modules/avvio/plugin.js", "method": "Boot.loadPlugin", "lineNumber": 187, "columnNumber": 10 }, { "file": "node_modules/fastify/node_modules/avvio/node_modules/fastq/queue.js", "method": "release", "lineNumber": 140, "columnNumber": 16 }, { "file": "node_modules/fastify/node_modules/avvio/node_modules/fastq/queue.js", "method": "Object.resume", "lineNumber": 74, "columnNumber": 7 }, { "file": "node_modules/fastify/node_modules/avvio/plugin.js", "method": "Plugin.finish", "lineNumber": 166, "columnNumber": 10 }, { "file": "node_modules/fastify/node_modules/avvio/plugin.js", "method": "<anonymous>", "lineNumber": 188, "columnNumber": 12 }, { "file": "node_modules/fastify/node_modules/avvio/plugin.js", "method": "done", "lineNumber": 115, "columnNumber": 5 } ] } } ``` Notice that none of this information gives me any hint as to which plugin is causing this error.

https://github.com/fastify/fastify/issues/2760

https://github.com/fastify/fastify/pull/2778

9b0c85472e07cc2907591b3df8f9e7e0b1869b7d

af87e7bae038abffe46ff51a0bbd5b0c797cf495

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Server.md", "fastify.js", "lib/schema-compilers.js", "lib/schema-controller.js", "package.json", "test/schema-serialization.test.js", "test/schema-special-usage.test.js"]

Ajv@7 upgrade plan

Ajv@6 will be discontinued at 28/2/2021, well before we retire Fastify v3. We are at the early stages of Fastify v4 right now, so there might be 6+ months of potentially unsupported validator against security vulnerabilities. However the code in Ajv@6 is really battle tested, so there might be a small chance of that happening. I see a couple of options. ### Option 1 Quickly release a Fastify v4 with Ajv@7 to minimize the time where Fastify v3 will have an unsupported validator. ### Option 2 Ship Ajv@7 in Fastify@3 even if it has a few breaking changes. We can also decide to do this _only_ if there is a security vulnerability. ### Option 3 Use `peerDependencies` so that Fastify@3 can work with both Ajv@6 and Ajv@7. ### Option 4 Ignore Ajv@7 for Fastify@3 and release Fastify@4 when we are ready. ## Benefits Ajv has one key feature that is interesting me a lot: a better "standalone mode: https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md. We could potentially support some pre-compiled schemas so that we can speed up our startup time. See https://github.com/ajv-validator/ajv/releases/tag/v7.0.0 for more details for all the other changes. ---- Feel free to edit this if you see more options for us.

https://github.com/fastify/fastify/issues/2742

https://github.com/fastify/fastify/pull/2862

5eeab8b1bdacf14cd7ac2b5785cd0908e8f9693e

5dfec548f890277cfc2b2f4653e4dd3889af2b3c

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/reqIdGenFactory.js"]

Have default request id generation generate unique id:s

## 🚀 Feature Proposal Currently request id:s default to an auto-incremented number, but that number is generated locally in each instance, meaning that if one run two or more instances of Fastify, or restarts a single Fastify instance, then the default generated id:s will be duplicated between between two or more requests: https://github.com/fastify/fastify/blob/453028bbfbb34a240bddb146549d91261deac495/lib/reqIdGenFactory.js#L3-L9 Instead truly unique string id:s should be generated, by eg. using @mcollina's performant [hyperid](https://github.com/mcollina/hyperid) module. ## Motivation The general expectation of a request id is that it should uniquely identify a request, across instances and across time. The current solution solves neither. (Minor bonus motivation: Also, the common style of request id:s is that they are quite long unique text strings, whereas Fastify currently is a bit odd in that it generates an actual number rather than a string, possibly giving people a false impression, as Fastify do persist any incoming `x-request-id` header and few of those will likely be a number. If a developer has assumed that a request id is actually always a number, then that could cause some issues as well.) ## Example If I want to track down all logs that belong to a single request and filter all of those logs using the request id, then the expectation should be that any log point with the request id of that single request is caused by that request – either within the same application logs or in services called by the current instance and where the request id has been forwarded. Currently, with a restarted fastify instance or an horizontally scaled fastify instance, the logs of multiple different requests all share the same request id, making the request id in such cases much less useful. ## PR I can help make a PR if there's agreement on this.

https://github.com/fastify/fastify/issues/2736

https://github.com/fastify/fastify/pull/2848

914000d22694eb30a0601c2fccb232e936e2849c

291afba794a2ecf780162f27e1b460f9a5670198

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/schema.test-d.ts", "types/instance.d.ts", "types/route.d.ts", "types/schema.d.ts"]

Typescript types for `setSerializerCompiler` mismatch

## 🐛 Bug Report Similar to #2572 the serializer does not like the type signatures it is given even when using the code sample from the readme. ## To Reproduce Steps to reproduce the behavior: ```js fastify.setSerializerCompiler(({ schema, method, url, httpStatus }) => { return data => JSON.stringify(data) }) ```  ## Expected behavior Typescript accepts the types it is given ## Your Environment - *node version*: 10, 12, 13 - *fastify version*: >=2.0.0 - *os*: Mac, Windows, Linux - *any other relevant information*

https://github.com/fastify/fastify/issues/2722

https://github.com/fastify/fastify/pull/2745

6b64483acc1f27202b393dc5a22ab7bb96e2623c

b9d0859b4b36a609eea6fa55a19b3ce73d5057c7

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/instance.test-d.ts", "types/instance.d.ts"]

FastifyInstance interface doesn't expose errorHandler

## 🐛 Bug Report While documentation states that `FastifyInstance` has a `errorHandler` method: https://www.fastify.io/docs/latest/Server/#errorhandler And it is indeed implemented that way, but when trying to implement in TypeScript with strict compilation it fails as `FastifyInstance` doesn't expose this method: https://github.com/fastify/fastify/blob/de94d314e940fba2c7021b0e180445a814d4d068/types/instance.d.ts ## To Reproduce Steps to reproduce the behavior: ```ts import { fastify } from 'fastify'; const fastify = fastify(); fastify.get('/testErrorHandler', errorHandler: (error, request, reply) => { if (error.code === 'SOMETHING_SPECIFIC') { reply.send({ custom: 'response' }); return; } fastify.errorHandler(error, request, response); // <-------- this fails compilation }, async (_request: FastifyRequest, reply: FastifyReply) => { reply.status(204).send(); }); ``` ## Expected behavior The above should work ## Your Environment - *node version*: v12.13.0 - *fastify version*: 3.8.0 - *os*: Mac

https://github.com/fastify/fastify/issues/2711

https://github.com/fastify/fastify/pull/2712

db39fa74c0d9d5ead9371e414f533f33c2bfd5b5

61c8a7bc3c91907e97813b631d35ae1f250b40e2

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/hooks.js", "test/hooks-async.test.js"]

schema validation error on an async response does not trigger the error handler

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report When using response schema validation on a route with an async handler errors are not caught by the error handler set using `setErrorHandler`, unlike params schema validation. ### Update This happens only when an async `preSerialization` handler is also present. ## To Reproduce Let's take a simple working example: ```js fastify.addHook("preSerialization", async (request, reply, payload) => payload); fastify.setErrorHandler((error, request, reply) => { reply .status(error.statusCode || 500) .send(error instanceof Error ? { message: error.message, error: error.name } : error); }); fastify.get( '/:id', { schema: { params: { type: 'object', required: ['id'], properties: { id: { type: 'string' } }, }, response: { 200: { type: 'object', required: ['id'], properties: { id: { type: 'string' } }, }, }, }, }, async ({ params: { id } }) => ({ id }) ); ``` Now what happens if we mess it up? 1. let's replace the route param from `/:id` to `/:blah` 2. let's replace the response from `({ id })` to `({ blah: id })` This is what produced from both changes: 1. returns the following response, as expected: ```json {"message":"params should have required property 'id'","error":"Error"} ``` 2. returns nothing and doesn't end the request, prints on the server side: ``` (node:1589948) UnhandledPromiseRejectionWarning: Error: "id" is required! at Object.$main (eval at build (/home/imoses/workspace/application/node_modules/fast-json-stringify/index.js:158:20), <anonymous>:135:15) at serialize (/home/imoses/workspace/application/node_modules/fastify/lib/validation.js:116:41) at preserializeHookEnd (/home/imoses/workspace/application/node_modules/fastify/lib/reply.js:349:15) at next (/home/imoses/workspace/application/node_modules/fastify/lib/hooks.js:198:7) at handleResolve (/home/imoses/workspace/application/node_modules/fastify/lib/hooks.js:209:5) at processTicksAndRejections (internal/process/task_queues.js:93:5) (Use `node --trace-warnings ...` to show where the warning was created) (node:1589948) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `--unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 1) (node:1589948) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code. ``` ## Expected behavior I expect a validation error on the response schema to be caught and handled by the error handler and not crash the request. ## Your Environment - *node version*: 14 - *fastify version*: =3.8.0 - *os*: Linux

https://github.com/fastify/fastify/issues/2707

https://github.com/fastify/fastify/pull/2713

273a76f8a6963cd0f633e7e87f5e053a176e0e66

db39fa74c0d9d5ead9371e414f533f33c2bfd5b5

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/hooks.js", "lib/route.js", "test/hooks.test.js", "test/internals/hookRunner.test.js"]

Errors in `onSend` makes fastify not respond

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report If an `onSend` handler (hook?) throws, the error does not bubble up to the application and the response never finishes. ## To Reproduce Steps to reproduce the behavior: ```js const fastify = require('fastify')(); fastify.route({ path: '/hello', handler(_, reply) { reply.code(200).send(); }, method: 'GET', onSend() { throw new Error('boom'); }, }); fastify.listen(3000); ``` ## Expected behavior It should return a 500 error. Changing `onSend` to ```js onSend(_, __, ___, done) { done(new Error('boom')); }, ``` fixes the error. I think those 2 approaches should behave the same. ## Your Environment - *node version*: 14.15.1 - *fastify version*: 3.8.0 - *os*: macOS - *any other relevant information*

https://github.com/fastify/fastify/issues/2692

https://github.com/fastify/fastify/pull/2695

d7d8c2787698a2e03d9ed02af03027f23d8d3a83

088a07c2b26deb93d8d4cd64601bae3e09799b66

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reply.md", "lib/reply.js", "lib/route.js", "lib/symbols.js", "lib/validation.js", "package.json", "test/hooks.test.js", "test/schema-serialization.test.js"]

Custom error properties via schemas

## 🚀 Feature Proposal Right now setting the schema response of errors doesn't enhance the default error handler. ```js const Fastify = require('fastify') const statusCodes = require('http').STATUS_CODES async function run () { const app = Fastify() app.get('/async-throw', { schema: { response: { '5xx': { type: 'object', properties: { statusCode: { type: 'number' }, code: { type: 'string' }, error: { type: 'string' }, lang: { type: 'string' }, message: { type: 'string' } } } } } }, async () => { const e = new Error('async-throw') e.code = 'this is a code' e.lang = 'this is a custom field' // this will be ignored throw e }) let res res = await app.inject('/async-throw') console.log(res.payload) // print: // {"statusCode":500,"code":"this is a code","error":"Internal Server Error","message":"async-throw"} } run() ``` ## Motivation The user may customize the default error handler properties just defining the output schema. This will: - improve the benefit of using schemas - spread the pattern to throws `Error` and not object ( #2134 ) - easier way to add custom param to an error object on custom routes ## Example The user will be able to let the script above works out of the box without the need to customize the error handler like this ```js app.setErrorHandler(function (error, request, reply) { const statusCode = reply.statusCode reply.send({ error: statusCodes[statusCode + ''], code: error.code, lang: error.lang, message: error.message || '', statusCode: statusCode }) }) ```

https://github.com/fastify/fastify/issues/2687

https://github.com/fastify/fastify/pull/2691

61c8a7bc3c91907e97813b631d35ae1f250b40e2

43ea177527d535cc17ed168dd479e07cc61db19d

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/wrapThenable.js", "test/async-await.test.js"]

reply.sent is false in setErrorHandler

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report reply.sent property is supposed to indicate, if .send() was already used, but it does not work properly in .setEventHandler(). It will be false, even if .send() was used in the route handler. It will only turn true, if .send() was used in .setEventHandler(). ## To Reproduce Steps to reproduce the behavior: ```js fastify.setErrorHandler((error, request, reply) => { console.log(reply.sent); }); fastify.get('/', async (request, reply) => { reply.send({ test: true }); throw new Error(); }); ``` ## Expected behavior I would expect to see "true" printed in my console, but I see "false". ```js true ``` ## Your Environment - *node version*: 12.19.0 - *fastify version*: >=3.4.1 - *os*: Linux

https://github.com/fastify/fastify/issues/2653

https://github.com/fastify/fastify/pull/2774

035ca57a4360900bd2fa81ba1d91405e603f1b5f

5e0e674823642d851fefb73d78fc590325c880b2

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Request.md", "docs/Server.md"]

Support case insensitive query parameters

## 🚀 Feature Proposal Could it be possible to support an optional case insentive option for query parameters? Adding the option `caseSensitive: false` does not seems to impact query parameters ## Motivation For backward compatibilitites you sometime need to support multiple casing ## Example With that code ``` fastify.get<{ Querystring: { test: string } }>( "/caseinsensitivequery", async (request, reply) => { return { test: request.query.test }; } ); ``` Both tests below should pass ``` let res = await request.get("/caseinsensitivequery?test=yes"); expect(res.body).toEqual({ test: "yes" }); res = await request.get("/caseinsensitivequery?tEsT=yes"); expect(res.body).toEqual({ test: "yes" }); ```

https://github.com/fastify/fastify/issues/2644

https://github.com/fastify/fastify/pull/3319

ce6270608be0dd56de629be0df149f94c5df95ba

ad967c2cc878eea3e832503e6a081003d13df110

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reply.md"]

[Minor] Wrong anchor link in Docs

In der [Docs](https://www.fastify.io/docs/latest/Reply/) for Reply the anchor link for _Redirect_ does not work. * Link: `#redirectdest` * actual id: `redirectcode--dest` I don't know how to fix that. Seems like a problem with the markdown-to-html conversion.

https://github.com/fastify/fastify/issues/2633

https://github.com/fastify/fastify/pull/2640

b7e31b387641e9a35cadb6948e758dff14a76b01

2e9da06e42c14876547d7e95771aefbc5ebdf878

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Routes.md", "docs/Server.md", "fastify.d.ts", "fastify.js", "lib/headRoute.js", "lib/route.js", "lib/warnings.js", "test/route.test.js", "types/route.d.ts"]

Automatically handle `HEAD` requests in `GET` handler unless explicit `HEAD` handler exists

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🚀 Feature Proposal Fastify does not automatically handle `HEAD` requests in `GET` handlers, unlike Express. From [`express`' docs](https://expressjs.com/en/api.html#app.METHOD) >The `app.get()` function is automatically called for the HTTP `HEAD` method in addition to the `GET` method if `app.head()` was not called for the path before `app.get()`. I think it makes sense for Fastify to do the same (possibly via some option?). From [Wikipedia](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods) >The HEAD method asks for a response identical to that of a GET request, but without the response body. This is useful for retrieving meta-information written in response headers, without having to transport the entire content. As mentioned in https://github.com/fastify/fastify/issues/2061#issuecomment-579848040, `express` just skips sending the body on `HEAD` (via `send`). I tried to find some issue where this was discussed without finding one. Apologies if this has already been discussed. ## Motivation Forcing the user to use two handlers (or pass `methods: ['GET', 'HEAD'])` to `fastify.route`) when we almost always have to do the same thing in the handlers (e.g. we need `content-length` header, so the only real difference in the handlers is often if body is sent or not - the user would still have to _construct_ the body) seems unnecessary to me. We also have to manually set the `content-length` header now for the body. ## Example ```js const express = require('express')(); const fastify = require('fastify')(); express.get('/hello', (_, res) => { res.send('hi from express'); }); fastify.get('/hello', (_, reply) => { reply.send('hi from fastify'); }); express.listen(3000); fastify.listen(3001); ``` ```sh-session $ curl -i http://localhost:3000/hello HTTP/1.1 200 OK X-Powered-By: Express Content-Type: text/html; charset=utf-8 Content-Length: 15 ETag: W/"f-JpU+vo3voFR+FPycQwU/gyiCSag" Date: Wed, 14 Oct 2020 12:20:54 GMT Connection: keep-alive Keep-Alive: timeout=5 hi from express% $ curl -i http://localhost:3001/hello HTTP/1.1 200 OK content-type: text/plain; charset=utf-8 content-length: 15 Date: Wed, 14 Oct 2020 12:20:56 GMT Connection: keep-alive Keep-Alive: timeout=5 hi from fastify% $ curl -I http://localhost:3000/hello HTTP/1.1 200 OK X-Powered-By: Express Content-Type: text/html; charset=utf-8 Content-Length: 15 ETag: W/"f-JpU+vo3voFR+FPycQwU/gyiCSag" Date: Wed, 14 Oct 2020 12:20:59 GMT Connection: keep-alive Keep-Alive: timeout=5 $ curl -I http://localhost:3001/hello HTTP/1.1 404 Not Found content-type: application/json; charset=utf-8 content-length: 78 Date: Wed, 14 Oct 2020 12:21:02 GMT Connection: keep-alive Keep-Alive: timeout=5 ``` If this change were to be implemented that last request would be correct out of the box.

https://github.com/fastify/fastify/issues/2619

https://github.com/fastify/fastify/pull/2700

27373efa587927f9546fb93489ab2a0455f4b8ca

834a4e58de86d7996b50a4663fbf2b0fac4686ee

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.js", "test/internals/version.test.js", "types/instance.d.ts"]

Plugin registration no longer works with webpack

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 💥 Regression Report The change from #2549 has caused plugin registration to error when using fastify with webpack. Previously when checking the version of fastify against the version supported by plugins, the fastify version was being derived from the `fastify/package.json` explicitly in [this block](https://github.com/fastify/fastify-plugin/blob/master/plugin.js#L93-L123). With the change from #2549, there are two error cases introduced by the file reading logic in [this block](https://github.com/zekth/fastify-1/blob/e8ef66273b722080a4be13996431bea7c0deae6a/fastify.js#L593-L598): 1. A `package.json` for reading is not found because of the project/directory organization in which case `Error: ENOENT: no such file or directory, open '/package.json'` is shown. 2. The fastify version is derived from the `version` in the user project `package.json`. This results in errors of the form `fastify-plugin: {{plugin name}} - expected '>=3.x' fastify version, '{{version from user project package.json}}' is installed`. ## Last working version Worked up to version: 3.4.1 Stopped working in version: 3.5.0 ## To Reproduce Clone the the *webpack* branch from the project [here](https://github.com/agramian/fastify-examples/tree/webpack). From a terminal within the project folder execute `npm i; npm run build; npm run start`. ## Expected behavior Either plugin registration should work as it did before, or the documentation should be updated to recommend how to register plugins going forward when using a bundler like webpack, or as a workaround it should be possible to explicitly define the fastify version when initializing the instance (I will open a PR and reference back here for this). ## Your Environment - *node version*: v12.18.3 - *fastify version*: >=3.5.1 - *os*: macOS

https://github.com/fastify/fastify/issues/2603

https://github.com/fastify/fastify/pull/2605

341bbc86c94df5cec49778e9c5657b27cbf59282

f22cb2f3105d2dfbf4400abe7ade93f48d5d0851

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/schema.test-d.ts", "types/schema.d.ts"]

Typescript types for `setValidatorCompiler` mismatch

## 🐛 Bug Report Typescript typings no longer work for setting ajv as a schema validator (even when using the code sample from the README). ## To Reproduce Steps to reproduce the behavior: ```typescript const ajv = new Ajv({ // the fastify defaults (if needed) removeAdditional: false, useDefaults: true, // replace missing properties and items with the values from corresponding default keyword coerceTypes: true, // change data type of data to match type keyword allErrors: true, // check for all errors nullable: true, }) fastify.setValidatorCompiler(({ schema }) => { return ajv.compile(schema) }) ``` This yields: ``` src/setupFastify.ts:74:47 - error TS2322: Type 'ValidateFunction' is not assignable to type 'FastifyValidationResult'. Types of property 'errors' are incompatible. Type 'ErrorObject[]' is not assignable to type 'FastifySchemaValidationError[]'. Type 'ErrorObject' is not assignable to type 'FastifySchemaValidationError'. Property 'message' is optional in type 'ErrorObject' but required in type 'FastifySchemaValidationError'. 74 fastify.setValidatorCompiler(({ schema }) => ajv.compile(schema)) ~~~~~~~~~~~~~~~~~~~ node_modules/fastify/types/schema.d.ts:35:37 35 export type FastifySchemaCompiler = (routeSchema: FastifyRouteSchemaDef) => FastifyValidationResult ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The expected type comes from the return type of this signature. ``` It would be nice to get an up to date sample on how to configure fastify with different ajv settings. ## Expected behavior Typescript compilation succeeds ## Your Environment - *node version*: 12.13 - *fastify version*: 3.4.1 - *typescript version*: 4.0.3 - *os*: Mac - *any other relevant information*

https://github.com/fastify/fastify/issues/2572

https://github.com/fastify/fastify/pull/2576

c15e8381b23176bc20c390324941e6abceaf318d

df9fbc183fa05fa1a23781b3f11fbf81f6854033

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reference/Validation-and-Serialization.md", "lib/handleRequest.js", "lib/validation.js", "test/schema-special-usage.test.js"]

Support for async ajv schemas

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🚀 Feature Proposal Ajv supports async schema with ability to define your own keywords for validation. But Fastify is not handling async validation properly. ## Motivation My motivation is to clearly define all request validations in one place (in schema). ## Example ```js const Ajv = require('ajv'); const fastify = require('fastify'); const app = fastify({}); const ajv = new Ajv({ removeAdditional: true, useDefaults: true, coerceTypes: true, nullable: true, }); ajv.addKeyword('validator', { async: true, errors: false, validate: (schema, data) => new Promise( (resolve) => console.log(schema, data) || resolve(false) ), }); app.setValidatorCompiler(({ schema }) => ajv.compile(schema)); app.get('/', { schema: { description: 'Tests if server is working.', query: { $async: true, type: 'object', properties: { data: { type: 'string', validator: 'custom:validator', }, }, }, }, handler: (req, res) => console.log(req.query) || res.send('ok'), }); app.listen(8000, (err) => { if (err) throw err; }); ``` Send test query ```bash ❯ curl http://localhost:8000/?data=test ok ``` Logs of the query ```bash ❯ node testFastify.js custom:validator asd [Object: null prototype] { data: 'asd' } (node:28661) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `--unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 1) (node:28661) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code. ```

https://github.com/fastify/fastify/issues/2568

https://github.com/fastify/fastify/pull/4752

4f367eabcdd70be5e969883c44290a83e8d5f18e

a649133ebd60c59b284dcd92834aa20fa5d2a8e1

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/route.js", "test/route.test.js"]

Strange behavior with route reusage

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report By reusing the same route inside more than one plugins, I've noticed that the second time the route is registered, its URL is somehow prefixed by the previous plugin. I'm not sure if this behavior is intentional or a bug. ## To Reproduce ```js const fastify = require('fastify')({ logger: true }) const route = { method: 'GET', url: '/', async handler(request, reply) { return { hello: 'world' } }, } async function v1Plugin(fastify) { fastify.route(route) } async function v2Plugin(fastify) { fastify.route(route) } fastify.register(v1Plugin, { prefix: '/api/v1' }) fastify.register(v2Plugin, { prefix: '/api/v2' }) const start = async () => { try { await fastify.listen(3000) console.log(fastify.printRoutes()) fastify.log.info(`server listening on ${fastify.server.address().port}`) } catch (err) { fastify.log.error(err) process.exit(1) } } start() ``` ## Expected behavior I was expecting this output: ``` └── / └── api/v ├── 1 (GET) │ └── / (GET) └── 2 (GET) └── / (GET) ``` I got this instead: ``` └── / └── api/v ├── 1 (GET) │ └── / (GET) └── 2/api/v1/ (GET) ``` And I can "fix" that by cloning the `route` object and redefining the `url` property: ```js fastify.route({ ...route, url: '/' }) ``` ## Your Environment - *node version*: 12 - *fastify version*: ^3.4.1 - *os*: Linux

https://github.com/fastify/fastify/issues/2567

https://github.com/fastify/fastify/pull/2569

a40de6d26a92b9d4749d610161efef85d2f23157

c15e8381b23176bc20c390324941e6abceaf318d

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/TypeScript.md", "fastify.d.ts", "package.json", "test/types/decorate-request-reply.test-d.ts"]

Declaration merging broken for FastifyRequest and FastifyReply

#### What are you trying to achieve or the steps to reproduce? I've followed the steps for [Creating a TypeScript Fastify Plugin](https://www.fastify.io/docs/latest/TypeScript/#creating-a-typescript-fastify-plugin) exactly (twice), but when I reach step 6 and execute `npm run build` in my terminal I receive four errors from TypeScript (version 4.0.2). #### What was the result you received? ``` > tsc -p tsconfig.json error TS2468: Cannot find global value 'Promise'. index.ts:6:12 - error TS2428: All declarations of 'FastifyRequest' must have identical type parameters. 6 interface FastifyRequest { ~~~~~~~~~~~~~~ index.ts:9:12 - error TS2428: All declarations of 'FastifyReply' must have identical type parameters. 9 interface FastifyReply { ~~~~~~~~~~~~ index.ts:28:60 - error TS2705: An async function or method in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option. 28 const myPluginAsync: FastifyPluginAsync<MyPluginOptions> = async (fastify, options) => { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Found 4 errors. ``` #### What did you expect? A successful TypeScript build with no errors. #### Context * *node version*: v12.16.2 * *fastify version*: ^3.4.1 * *os*: Linux (Ubuntu 20.04)

https://github.com/fastify/fastify/issues/2557

https://github.com/fastify/fastify/pull/2558

f32061907495eee99f51e93d50aae858f8467aa3

29c2af10fa0cc4898a86c66772d6ce4079251ab0

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Errors.md", "fastify.js", "lib/reply.js", "lib/setErrorHeaders.js", "test/reply-error.test.js", "test/route-hooks.test.js"]

Fastify's default error handling can serve unexpected responses

## 🐛 Bug Report I'm not sure if this is a bug or intended behavior (it is documented to some extent, but it seems like setting your own error handler should disable it), so apologies in advance if this should be a feature request versus a bug report. Fastify's default error handling checks for properties like `status`, `statusCode`, and `headers` [1] on the error that is thrown and then uses them for preparing part of the response. I was running into an issue when I was testing some errors in a few of my routes. I expected to hit a normal 500, but instead was greeted with a parse error: ``` Parse Error: The response headers can't include "Content-Length" with chunked encoding ``` It turned out some of the APIs I was testing add a lot of additional properties to the errors that are thrown, one of them being the headers of the failed request, which caused Fastify to then set a dozen or so headers from the failed API call on the response to the end user, which made everything blow up from there. Long story short, any failed API calls that include the request headers will subsequently have a high likelihood of failing in Fastify to the point where an end user won't even get a valid response, they'll get a malformed blob that will be unusable. While I certainly understand the value in the current implementation, there doesn't appear to be any way to disable this behavior. I believe the only two options I have are: 1. Wrap every single API call in my routes and re-throw errors without the `headers` property that gets added by certain SDKs. 1. Use something like `setErrorHandler` [2] and manually iterate through all the headers and call something like `reply.removeHeader('name')` on each one. Neither of those options are ideal and both add a bit of unnecessary code (first being far worse than the second). I was hoping I could simply bubble errors to the top and return an error response to the user. Are there any other options I'm missing, or is there any way to disable the logic (based on the code it doesn't appear there is but maybe I'm missing something)? If this isn't a bug and is intended behavior. Is it possible to move L519 [3] up to the top of the `handleError` function (above L507 at a minimum)? In other words, if a user manually specifies an error handler, Fastify won't modify the response based off any of the error properties? Fastify will only inherit error properties if the user is relying on the default error handling logic? [1] https://github.com/fastify/fastify/blob/f458cea2d360444fd1a2ca5972e8fca6f2e07d88/lib/reply.js#L507 [2] https://www.fastify.io/docs/latest/Server/#seterrorhandler [3] https://github.com/fastify/fastify/blob/f458cea2d360444fd1a2ca5972e8fca6f2e07d88/lib/reply.js#L519 ## To Reproduce Steps to reproduce the behavior: 1. Throw an error inside an async route that has a `headers` property. 1. Fastify will automatically set them on the response. 1. Depending on what the headers are, Fastify will try to serve a malformed blob. ## Expected behavior At the very least, if I'm manually setting my own error handler, I would expect that the reply argument I receive is pristine and hasn't already had status code or headers set. If you're relying on Fastify's default behavior, there's still potentially room for improvement by overriding certain header values if they won't be valid for the error response. ## Workaround This fixes the issue: ``` app.setErrorHandler(async (err, req, res) => { Object.keys(res.getHeaders()).forEach((h) => res.removeHeader(h)); // ... }); ``` I know it's a one-liner, but would be awesome if there was a better way. Better yet, if it was possible to define the key from the error that should be used for status, I wouldn't need to manually set an error handler at all. Some SDKs set `error.code === statusCode`, etc. ## Your Environment - *node version*: 14 - *fastify version*: 3.4.1 (latest) - *os*: Windows, Linux

https://github.com/fastify/fastify/issues/2602

https://github.com/fastify/fastify/pull/2609

14f967961623defb907852be9108f710dffa185d

f6ee35587345fac4f4cf9212d139fde97f3ab36e

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/reply.js", "test/content-length.test.js"]

Invalid content-length in custom ErrorHandler

## 🐛 Bug Report I add a custom error handler to add some extra data to my api answer (stack, ...). - I send a request too an elasticsearch server, which reply an answer (an error) with a content-length of 335 bytes. - In my error handler, I answer with bigger body (more than 335 bytes content-length). ## To Reproduce If a thrown error have headers.'content-length' properties it is propagated to the fastify answer like #2214 but with an errorHandler. ```js import fastify from 'fastify'; const server = fastify(); server.get('/', async (request, reply) => { const error = new Error('MY_ERROR_MESSAGE'); error.headers = { 'content-length': 2, }; throw error; }); server.setErrorHandler((error, request, reply) => { reply.code(500).send({ error: 'longer than 2' }); }); const start = async () => { await server.listen(3000, '0.0.0.0'); }; start(); ``` ``` curl -v http://127.0.0.1:3000/ * Trying 127.0.0.1... * Connected to 127.0.0.1 (127.0.0.1) port 3000 (#0) > GET / HTTP/1.1 > Host: 127.0.0.1:3000 > User-Agent: curl/7.47.0 > Accept: */* > < HTTP/1.1 500 Internal Server Error < content-length: 2 < content-type: application/json; charset=utf-8 < Date: Tue, 08 Sep 2020 13:33:51 GMT < Connection: keep-alive < Keep-Alive: timeout=5 < * Excess found in a non pipelined read: excess = 23, size = 2, maxdownload = 2, bytecount = 0 * Connection #0 to host 127.0.0.1 left intact ``` ## Expected behavior Answer generated by my error handler should have the right content length. It has the following side effects : - if my answer is smaller than 2 bytes : it hangs for 5secs - if my answer is bigger than 2 bytes : my answer is truncated and my json is not valid. ## Your Environment - *node version*: 14 - *fastify version*: >=3.3.0 - *os*: Linux Thx

https://github.com/fastify/fastify/issues/2543

https://github.com/fastify/fastify/pull/2546

ee84e873ada86dd8a1ba2e1c862cf1ae4b29a25e

f458cea2d360444fd1a2ca5972e8fca6f2e07d88

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Request.md"]

definition for request hostname is incorrect

## 🐛 Bug Report in the docs request `hostname` is defined as providing the hostname -- which is very incorrect for [what it actually does](https://github.com/fastify/fastify/blob/f2982a245e55f6c9d0a88837434e8423db6cc0ae/lib/request.js#L74-L81). what it actually does: - if request.headers['x-forwared-for'] exists, the value is returned. (i believe this could be an array?) - host header as-is (so it's returning "host" and not "hostname") - if no host header exists, [return ":authority"](https://github.com/fastify/fastify/issues/2112) so, the one thing request.hostname doesn't do is return the hostname.

https://github.com/fastify/fastify/issues/2538

https://github.com/fastify/fastify/pull/3325

ad967c2cc878eea3e832503e6a081003d13df110

c872f0b009bcdd08c5f79b42421f2432075754d2

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/ContentTypeParser.md", "docs/Server.md", "fastify.js", "lib/contentTypeParser.js", "test/custom-parser.test.js"]

Import the default (json) content type parser?

#### You have already researched for similiar issues? It's not uncommon that somebody already opened an issue or in best case it's already fixed but not merged. That's the reason why you should [search](https://github.com/fastify/fastify/issues) at first before submitting a new one. #### What are you trying to achieve or the steps to reproduce? I have an external caller that I can't change sending requests with `content-type: text/json` is there any way to use the default built in JSON parser for this? From what I can tell it's not exported so I can't just call `server.addContentTypeParser('text/json', defaultParser)`. #### What did you expect? Ability to accept JSON content that other than `application/json` content type set without having to write custom parser. #### Context * *node version*: 12 * *fastify version*: 3.2.0

https://github.com/fastify/fastify/issues/2566

https://github.com/fastify/fastify/pull/2573

4068406b1b63ec895ef62a5e16e12430174bec17

4ac15542e730a4ff560e73cbd059e633c05d2106

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.js", "test/404s.test.js"]

Chaining setNotFoundHandler

`setNotFoundHandler` doesn't support chaining calls: ``` fastify .setNotFoundHandler(function (request, reply) { }) .get('/', schema, function (req, reply) { reply.send({ hello: 'world' }) }) ``` As does `setErrorHandler` and `setValidatorCompiler` etc.. https://github.com/fastify/fastify/blob/21578f56dea6bfd3de1c9a4df497fd535d174221/fastify.js#L499-L503 _Originally posted by @Eomm in https://github.com/fastify/fastify/pull/2467#discussion_r466178333_

https://github.com/fastify/fastify/issues/2531

https://github.com/fastify/fastify/pull/2533

7369e7e3f0e881afecb5cf8854afb03edc708b83

87ed2a4875ed77d4c37039998ab30f88751eb661

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/reply.test-d.ts", "types/reply.d.ts", "types/route.d.ts"]

TypeScript: reply.send validates against argument's type, not route method payload's type

## 🐛 Bug Report If RouteShorthand method is configured with a specific Reply type, i.e. ``` interface Topics { items: { id: string }[] } fastify.get<{ Reply: Topics }>('/topics', { ... skipped ... }, async (request, reply) => { reply.send({ items: [123] }) } ) ``` reply.send won't detect a typing error because it uses a type of it's argument, not the type it should be validating against (i.e. Topics). Using `return` form also doesn't detect the error because it's typed as unknown. ## To Reproduce Configure Reply and pass incompatible type to reply.send() or return. ## Your Environment - *node version*: 12 - *fastify version*: >=3.2.1 - *os*: Mac

https://github.com/fastify/fastify/issues/2529

https://github.com/fastify/fastify/pull/2530

ebca8b478afc6584633dc1964ed9e9830ce776c3

8ee4a98df4163a04e4beaaa499c809a69231261d

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

[".github/workflows/ci.yml"]

Stop running CI on Node 13

EOL for Node 13 was on 2020-06-01. We probably should stop running CI for it, same as we stopped running it for Node 11. Thoughts?

https://github.com/fastify/fastify/issues/2512

https://github.com/fastify/fastify/pull/2513

b9fcf3fae0317a54f4f32c5121d5099d1a4d0ed9

f71adb1e7cf4ccf189328453ff4551033dae1700

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Guides/Delay-Accepting-Requests.md", "docs/Guides/Index.md"]

Improve developer experience around server listening

## 🚀 Feature Proposal Document or formalize notifying when the Fastify server is listening for and accepting requests. ## Motivation I have encountered a need to know when the server is listening for and accepting requests. This is different from our `onReady` hook (which is really `onReadyToListen`). Basic premise is, I have to work with a third party API that requires OAuth 2.0 authorization via the [Authorization Code Grant](https://oauth.net/2/grant-types/authorization-code/) instead of the more desirable [Client Credentials Grant](https://oauth.net/2/grant-types/client-credentials/). As a result, I need to obtain a token upon server start which requires the server to be able to process the callback portion of the ACG flow. ## Example This is currently achievable by: ```js async function aPlugin(fastify) { // Setup some stuff. fastify.server.on('listening', doSomeThings) function doSomeThings () { // Do some things after the server is accepting connections. // For example, the scenario described in this issue might do: refreshToken() .then((token) => { fastify.acgToken = token // Added by a decorator. setTimeout(refreshToken, ms('1 hour')) }) .catch((error) => { fastify.log.error({ err: error }) process.exit(1) }) } } async function refreshToken() { await getToken() } ``` We should either document this or make it more "Fastify-like" with a proper hook.

https://github.com/fastify/fastify/issues/2500

https://github.com/fastify/fastify/pull/3837

bd4914c1b85305e33b3d541bd85f4f288aad910f

c97fa0fc0d73d128ed72ddd7ba101cd0704e6162

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["README.md"]

doc: Add discord badge

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🚀 Feature Proposal To promote the use of discord to make the community grow, the addition of a badge within the others on the README can be a plus. Here is how to setup it : https://shields.io/category/chat (needs admin permission to allow it on discord side) ## Motivation Promote the discord server

https://github.com/fastify/fastify/issues/2488

https://github.com/fastify/fastify/pull/2489

480d985b98c779fd8eb83f54ae0e2e728f1afa27

2ad4fde842b4d872c1532030c73efc1685c14eb7

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/logger.js", "test/logger.test.js"]

Fastify must not mutate passed in options

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report Fastify mutates passed in options ## To Reproduce This is mimalistic example to reproduce the issue but the actual issue happens when trying to pass configuration using `config` npm package as options to `fastify` function: ```js import fastify from 'fastify'; const server = fastify({ logger: Object.defineProperty({}, 'level', { value: 'info' }) }); ``` This code throws: ``` Uncaught TypeError: Cannot assign to read only property 'level' of object '#<Object>' at createLogger (/api/node_modules/fastify/lib/logger.js:85:26) at fastify (/api/node_modules/fastify/fastify.js:87:33) ``` ## Expected behavior Fastify should not mutate passed in options object ## Your Environment - *node version*: 12.17.0 - *fastify version*: 3.1.1 - *os*: Linux

https://github.com/fastify/fastify/issues/2455

https://github.com/fastify/fastify/pull/2474

eee6c8dac6959310703699ddee6fb512cab285c3

e02c80f95e13d2030aab8de03863212cc9a1f4cc

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/route.js", "lib/schemas.js", "test/schema-feature.test.js", "test/schema-serialization.test.js"]

CORS is breaking Schemas

# 🐛 Bug Report If I define a schema inside a plugin, `fastify-cors` breaks the application when `preflight` is enabled. ## To Reproduce I created a simple repository showing the problem. https://github.com/wandersonwhcr/fastify-cors-problem ## Your Environment - *node version*: 14 - *fastify version*: >=3.1.1 - *os*: Linux

https://github.com/fastify/fastify/issues/2462

https://github.com/fastify/fastify/pull/2463

ff886c7c54d9de1afed4e215d174279f3ad72385

dbfbb310cd03f46b734f8069e80181dc414942c2

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/hooks.test-d.ts", "types/hooks.d.ts"]

TypeScript: addHook'a 'onSend' callback typings

## 🐛 Bug Report addHook('onSend') disallows next() without arguments. ## To Reproduce ``` fastify.addHook('onSend', function (_request, reply, payload, next) { Object.assign(reply.res, { payload }) next() // <--- error }) ``` Error: ``` Expected 1-2 arguments, but got 0. hooks.d.ts[93, 41]: An argument for 'err' was not provided. ``` ## Expected behavior Code compiles, payload not modified. ## Your Environment - *node version*: 12 - *fastify version*: >=3.0.3 - *os*: Mac

https://github.com/fastify/fastify/issues/2439

https://github.com/fastify/fastify/pull/2485

955314d4b51175952f2e62167075cfa349e33434

c8eb3d47fe0294554e60e1d5ae643612da8f9a2b

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/errors.js", "lib/server.js", "test/close.test.js"]

Cannot listen on a port after closing the server. Error is misleading.

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report I am trying to temporarily swap out my main fastify server instance with a maintenance server while I handle some background processes. When I try to swap back to my main server that was previously closed, it throws an error saying `Fastify is already listening` I'm not sure if this is a bug or not supported since the documentation is unclear. I have already worked around this by migrating the maintenance logic to the prehandler. I'm just looking for some clarification on the expected behavior or a clearer error message. ## To Reproduce Here is a minimal example to demonstrate: ```js const create= require("fastify"); const mainServer = create(); await mainServer.listen(8080, "0.0.0.0"); const maintenanceServer = create(); await mainServer.close(); await maintenanceServer.listen(8080, "0.0.0.0"); await maintenanceServer.close(); await mainServer.listen(8080, "0.0.0.0"); // throws an error with message 'Fastify is already listening' ``` ## Expected behavior Either `mainServer` starts listening on port 8080 or a message saying that the fastify instance has already been closed and cannot be reopened. ## Your Environment - *node version*: 12.16.1 - *fastify version*: >=2.3.0 - *os*: Windows

https://github.com/fastify/fastify/issues/2411

https://github.com/fastify/fastify/pull/2415

d06287a9a612d218d26e3a94b248b5035d5c44cb

e53abd1118a305763d75fe4c3224e42b7166608d

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/request.test-d.ts", "types/request.d.ts"]

Add validationErrors property to request object when using attachValidation option

 * *fastify version*: >=3.0.2 * *os*: Linux

https://github.com/fastify/fastify/issues/2409

https://github.com/fastify/fastify/pull/2422

28881ca8f515789176e37bd6dd5bb1071a40b374

af880ad3db6bd05468141cd4e136467ab80bfd46

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/dummy-plugin.ts", "test/types/plugin.test-d.ts", "types/register.d.ts"]

ESM-style plugin import doesn't pass TypeScript type check.

## 🐛 Bug Report ## To Reproduce Pick any Fastify plugin (I'll use `fastify-formbody` for now): ```js fastify().register(import('fastify-formbody')); ``` TypeScript compiler gives the following error: ``` No overload matches this call. Overload 1 of 3, '(plugin: FastifyPluginCallback<FastifyPluginOptions>, opts?: FastifyRegisterOptions<FastifyPluginOptions>): FastifyInstance<...> & PromiseLike<...>', gave the following error. Argument of type 'Promise<typeof import(".../node_modules/fastify-formbody/formbody")>' is not assignable to parameter of type 'FastifyPluginCallback<FastifyPluginOptions>'. Type 'Promise<typeof import(".../node_modules/fastify-formbody/formbody")>' provides no match for the signature '(instance: FastifyInstance<RawServerBase, IncomingMessage | Http2ServerRequest, ServerResponse | Http2ServerResponse, FastifyLoggerInstance>, opts: FastifyPluginOptions, next: (err?: Error) => void): void'. Overload 2 of 3, '(plugin: FastifyPluginAsync<FastifyPluginOptions>, opts?: FastifyRegisterOptions<FastifyPluginOptions>): FastifyInstance<...> & PromiseLike<...>', gave the following error. Argument of type 'Promise<typeof import(".../node_modules/fastify-formbody/formbody")>' is not assignable to parameter of type 'FastifyPluginAsync<FastifyPluginOptions>'. Type 'Promise<typeof import(".../node_modules/fastify-formbody/formbody")>' provides no match for the signature '(instance: FastifyInstance<RawServerBase, IncomingMessage | Http2ServerRequest, ServerResponse | Http2ServerResponse, FastifyLoggerInstance>, opts: FastifyPluginOptions): Promise<...>'. Overload 3 of 3, '(plugin: FastifyPluginCallback<FastifyPluginOptions> | FastifyPluginAsync<FastifyPluginOptions>, opts?: FastifyRegisterOptions<...>): FastifyInstance<...> & PromiseLike<...>', gave the following error. Argument of type 'Promise<typeof import(".../node_modules/fastify-formbody/formbody")>' is not assignable to parameter of type 'FastifyPluginCallback<FastifyPluginOptions> | FastifyPluginAsync<FastifyPluginOptions>'. Type 'Promise<typeof import(".../node_modules/fastify-formbody/formbody")>' is not assignable to type 'FastifyPluginAsync<FastifyPluginOptions>'. ``` ## Expected behavior There should be no errors. We can use `as any` to bypass this problem but not sure it's the best thing to do. ## Your Environment - *node version*: 14 - *fastify version*: 3.0.1 - *os*: Mac

https://github.com/fastify/fastify/issues/2403

https://github.com/fastify/fastify/pull/2494

1cf972e500f8d5ab215b2217cc133cca6bb4f269

102654ecd9957035fcfe58958752314c0e6ede91

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.d.ts", "test/types/reply.test-d.ts", "test/types/request.test-d.ts", "types/content-type-parser.d.ts", "types/hooks.d.ts", "types/instance.d.ts", "types/reply.d.ts", "types/request.d.ts", "types/route.d.ts", "types/utils.d.ts"]

Type `FastifyReply` body

## 🚀 Feature Proposal The `send` method from `FastifyReply` accepts a generic parameter `T` ([code here](https://github.com/fastify/fastify/blob/master/types/reply.d.ts#L25)), but it is not used anywhere else Could we make that `T` parameter part of the `FastifyReply` parameters? `express` is doing something similar here https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/express-serve-static-core/index.d.ts#L505 A strech goal would be to change the types to have a different reply type per status code, so it maps event better to the json schema (not sure this is possible) ## Motivation Having `T` forwarded into `FastifyReply` would allow for better typings, for example ``` type CustomReply = FastifyReply<{ isTypedReplyBody: boolean; }> fastify.get('/', async (request: FastifyRequest, reply: CustomReply) => { reply.send({isTypedReplyBody: true}) // ok reply.send({raw: true}) // not ok, ts error }) ```

https://github.com/fastify/fastify/issues/2385

https://github.com/fastify/fastify/pull/2389

f5ca1fac02d61b0280f191b7019deadc20466570

87efb7e7d2c27d3d0e5c7c045b15edb18e95a6be

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.d.ts", "test/types/fastify.test-d.ts", "test/types/plugin.test-d.ts"]

Investigate how to support `const app = fastify(); await app;` in TypeScript

Related to https://github.com/fastify/fastify/pull/2376 See the test in the PR. How do we type this behavior? If its not possible (which I sorta expect but don't know for sure), then we should provide some type-cast option like: ```ts // untested code ahead do not assume this is the solution :-) const _app = fastify() const app = _app as unknown as () => Promise<FastifyInstance> await app; // resolves FastifyInstance ```

https://github.com/fastify/fastify/issues/2378

https://github.com/fastify/fastify/pull/2428

2a2be75309a796cbe450fdeb39e0d100c78b98d7

6233a8f77fd53da88ef001c4e9d4047cda8a6af0

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reply.md"]

Unexpected cookies behaviour

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report When the ServerResponse instance (`reply.raw`) is used to respond to the client after setting a cookie, the cookie doesn't appear in the browser. ## To Reproduce Reproducible example: https://codesandbox.io/s/adoring-solomon-n61yz?file=/src/build.js:589-592 1. Go to the provided server on CodeSanbox: https://n61yz.sse.codesandbox.io/ 3. Open the dev tools and enter the cookies viewer in the application tab. 2. Go to `/cookie-2` 3. There is no cookie ❌ But if you go to `/cookie-1` instead, the cookie will appear. ✅ ```js // expected app.get('/cookie-1', (req, reply) => { reply .setCookie('session', 'value', { secure: false }) .header('Content-Type', 'text/plain') .send('ok') }) // unexpected app.get('/cookie-2', (req, reply) => { reply.setCookie('session', 'value', { secure: false }) reply.raw.writeHead(200, { 'Content-Type': 'text/plain' }) reply.raw.write('ok') reply.raw.end() }) ``` ## Expected behavior In both cases, the client should have the cookie saved on the server-side. ## Your Environment - *node version*: 10.20.1 - *fastify version*: 3.0.0-rc.5 - *os*: Windows

https://github.com/fastify/fastify/issues/2372

https://github.com/fastify/fastify/pull/2553

1ce1b308513d2f3e491d8cc2da68b25806e49760

875f8a3cf760f363baf1febf5eedb82d1b6da2c8

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/instance.test-d.ts", "types/instance.d.ts"]

Error: Property 'setReplySerializer' does not exist on type 'FastifyInstance'

## 🐛 Bug Report I'm trying to use setReplySerializer() in my Fastify-powered TypeScript project. However, an error is thrown: `error TS2339: Property 'setReplySerializer' does not exist on type 'FastifyInstance<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>'.` ## To Reproduce Steps to reproduce the behavior: ```js import * as Fastify from 'fastify'; (async () => { try { const server = Fastify.fastify(); // Based upon https://www.fastify.io/docs/master/Server/#setreplyserializer server.setReplySerializer(function (payload: any, statusCode: any) { return `my serialized ${statusCode} content: ${payload}`; }); await server.listen(3000, '0.0.0.0'); } catch (err) { console.error(err); } })(); ``` ## Expected behavior No TypeScript error ## Your Environment - *Node version*: 12 - *Fastify version*: 3.0.0-rc.4 - *TypeScript version*: 3.9.5 - *os*: Linux

https://github.com/fastify/fastify/issues/2358

https://github.com/fastify/fastify/pull/2400

da021f14c37b2f9a259d5328416afeb4dcc4252b

2495ba1d62de9ba0c289463cac0c45809a7bb87b

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["package.json"]

Validate this context for fastify errorHandler

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🚀 Feature Proposal Original issue: https://github.com/fastify/fastify/issues/2304 #2306 binds the instance to the errorHandler. We should validate this works in TypeScript land and also include a unit a test. It may require a type fix; it may not - that is the purpose of the validation.

https://github.com/fastify/fastify/issues/2316

https://github.com/fastify/fastify/pull/2198

457886a136aff1f60a8e2c27dfb35789a78f5b6b

a2859c03cd37904994644936fc8b400dae07da56

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Ecosystem.md"]

Asynchronous local storage support

## 🚀 Feature Proposal Support for AsyncLocalStorage via an official plugin. If user enables this functionality, then fastify will automatically create ALS scope for every new request that could be populated within standard hooks. ## Motivation Certain cross-cutting functionality (logging, monitoring, authentication) benefits from threadlocal-like functionality. `cls-hooked` can be used as a fallback solution for older Node versions. ## Example ``` fastify.register(require('fastify-als')) fastify.addHook('onRequest', (req, reply, done) => { fastify.setLocal('user', { id: 'fastifyUser' }) }); fastify.get('/', async (request, reply) => { return { user: fastify.getLocal('user') } }); ``` There is prior art already: https://github.com/thorough-developer/fastify-http-context Maybe it could be used as a basis for an official plugin, or made an official plugin. I can work on implementing this if approved.

https://github.com/fastify/fastify/issues/2298

https://github.com/fastify/fastify/pull/2324

df40dac9b9e296c13d975c4bb47202610ba282f4

09fd065d41ba147726499b5f0cad9d5638b56151

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Server.md", "examples/example.js", "fastify.d.ts", "fastify.js", "test/types/fastify.test-d.ts", "test/types/route.test-d.ts", "test/url-rewriting.test.js", "types/route.d.ts"]

Possible type regression from v2 to v3

## 💥 Regression Report It appears that the type definition for route handlers (`RouteHandlerMethod` in v3) no longer has a binding for `this`. I may be entirely misunderstanding the new types though; the abundance of generics is quite clever, but a little hard to quickly grasp. ## Last working version Worked up to version: 2.14.1 Stopped working in version: 3.0.0-rc.2 ## To Reproduce This is not strictly correct code, but it should illustrate the point: Steps to reproduce the behaviour In the following file, `this` produces an error ```ts export const handler: RouteHandlerMethod = async function(req, reply) { const id = req.params.id; this.log({ id }, 'User deleted') reply.code(204).send(); } ``` The error is: ``` 'this' implicitly has type 'any' because it does not have a type annotation.ts(2683) ``` ## Expected behavior I'd expect this to work as it did in v2, where I used the `RequestHandler` interface, which seems to have been replaced by `RouteHandlerMethod` ? ## Your Environment - *node version*: 12 - *fastify version*: >=3.0.0 - *os*: Linux

https://github.com/fastify/fastify/issues/2288

https://github.com/fastify/fastify/pull/2290

8b8485ac5ff56d1ead387f6dd76384f996a2cf8e

4f3a945871060365117b7ce8eb5d3fb4fd178fef

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.js", "test/schema-feature.test.js"]

Can't getSchema() even though getSchemas() "has it"

## 🐛 Bug Report Schema added inside plugin can't be fetched using getSchema('someid') ## To Reproduce Steps to reproduce the behavior: ```js fastify.addSchema({ $id: 'http://example.com/', type: 'object', properties: { hello: { type: 'string' } } }) console.log('1 getSchemassssss()', fastify.getSchemas()); // OK console.log('1 getSchema()', fastify.getSchema('http://example.com/')); // OK fastify.register((instance, opts, done) => { instance.addSchema({ $id: 'http://example.com/plugin/', type: 'object', properties: { hello: { type: 'string' } } }) console.log('2 getSchemassssss()', instance.getSchemas()); // OK: both schemas console.log('2 getSchema()', instance.getSchema('http://example.com/')); // OK console.log('3 getSchema()', instance.getSchema('http://example.com/plugin/')); // NOT OK: undefined done() }) ``` ## Expected behavior A clear and concise description of what you expected to happen. ```js instance.getSchema('http://example.com/plugin/') // should return 'http://example.com/plugin/' schema ``` ## Your Environment - *node version*: 12 - *fastify version*: >=3.x - *os*: Mac

https://github.com/fastify/fastify/issues/2279

https://github.com/fastify/fastify/pull/2280

2f56e10a24ecb70c2c7950bfffd60eda8f7782a6

425b68e71c3f88cd16e45b831c6cf017d95bbefa

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["README.md"]

Remove absolute URL

In our docs, there are some link that refers to `master` Like https://raw.githubusercontent.com/fastify/fastify/master/docs/Server.md ``` <a href="https://github.com/fastify/fastify/blob/master/docs/Server.md"><code><b>Fastify server</b></code></a> ``` I think we should update all those links to relative ones because if a user browsers old tag in GitHub, he would redirect to `master` causing confusion. Kudos to @lmammino because the fastify.io site already applies this fix 🙌🏻 ---- EDIT checklist of files to fix - [x] README.md - [ ] docs\ContentTypeParser.md - [ ] docs\Errors.md - [ ] docs\Fluent-Schema.md - [ ] docs\Getting-Started.md - [ ] docs\Hooks.md - [ ] docs\Logging.md - [ ] docs\Middleware.md - [ ] docs\Migration-Guide-V3.md - [ ] docs\Plugins-Guide.md - [ ] docs\Plugins.md - [ ] docs\Reply.md - [ ] docs\Request.md - [ ] docs\Routes.md - [x] docs\Server.md - [ ] docs\TypeScript.md - [ ] docs\Validation-and-Serialization.md - [ ] docs\Write-Plugin.md

https://github.com/fastify/fastify/issues/2265

https://github.com/fastify/fastify/pull/2274

15703f51109d0381e6abed1c4c226f25ceefc4d0

82a081dfea3b065492df435cff3d695a36ceb60c

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.js", "test/inject.test.js"]

`started` flag for fastify no longer set in v3 on ready()

## 🐛 Bug Report In v3 running `fastify.ready()` no longer sets `fastify[kState].started` to `true`. This results in `lightMyRequest` Chain returned for a builder to be wrapped into a Promise and prematurely resolved, failing with an error. ## To Reproduce Steps to reproduce the behavior: https://github.com/fastify/fastify/pull/2257/files ## Expected behavior Same code would work in v2. Since this is not listed as a breaking change in migration guide, I assume this is a regression rather than removal of deprecated feature. ## Your Environment - *node version*: 12 - *fastify version*: 3.0.0-rc1

https://github.com/fastify/fastify/issues/2259

https://github.com/fastify/fastify/pull/2257

a60391e9b6b7b516e24d18f0c5a437db28989ff8

09170fe41777ddf821179c4aef60d434d6de1efb

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reply.md", "docs/Server.md", "lib/handleRequest.js", "lib/reply.js", "test/404s.test.js"]

reply.callNotFound not triggering hooks

<!-- Before you submit an issue we recommend you visit [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** --> ## 🐛 Bug Report reply.callNotFound() does not trigger hooks ## To Reproduce Steps to reproduce the behavior see https://github.com/fastify/fastify-static/issues/126, fastify-static use callNotFound internally. ## Expected behavior The hooks must be called. ## Your Environment - *node version*: 10, 12, 13 - *fastify version*: >=2.0.0 - *os*: Mac, Windows, Linux - *any other relevant information*

https://github.com/fastify/fastify/issues/2229

https://github.com/fastify/fastify/pull/2256

1cdf6219ca4ebb015c926f5c467b1bf7b6c88c67

ae6b57c94cbfcec10b66c4a19d8a62df540486c1

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/route.test-d.ts", "types/reply.d.ts"]

reply.statusCode is not defined in TS type definitions

## 🐛 Bug Report Docs & implementation have a prop `statusCode`, which isn't available via `FastifyReply<HttpResponse>` definition. Docs: https://www.fastify.io/docs/latest/Reply/#statuscode Definitions: https://github.com/fastify/fastify/blob/64296c84b57eb8f6f63bf51579febcfd274a97a5/types/reply.d.ts#L8

https://github.com/fastify/fastify/issues/2223

https://github.com/fastify/fastify/pull/2224

28fcb5f9438e85031265a9b0ba60bb01791db010

2e9994d1c3cb0c61424d624674ec517360542c26

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/reply.js", "test/content-length.test.js"]

Error with `content-lenght` header

## 🐛 Bug Report If in a async handler, an error is thrown and `headers` property contains `content-length` key, the response header `content-length` doesn't match the real response body length ## To Reproduce ```js 'use strict' const assert = require('assert') const fastify = require('./fastify')({ log: { level: 'trace' } }) fastify.get('/', async () => { const error = new Error('MY_ERROR_MESSAGE') error.headers = { 'content-length': 2 } throw error }) fastify.inject({ method: 'GET', path: '/' }) .then(response => { assert.strictEqual(response.headers['content-length'], response.rawPayload.length) }) ``` ## Expected behavior The response `content-length` should not be propagated to ## Your Environment - *node version*: v12.16.1 - *fastify version*: = 2.13.1 - *os*: Mac

https://github.com/fastify/fastify/issues/2214

https://github.com/fastify/fastify/pull/2215

121f32a46b9f3d4df2be4e81ea9427386c37eb14

6e8035201b07b5a7a7fe2c7722652d50c37e07bb

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Hooks.md", "lib/context.js", "lib/hooks.js", "lib/route.js", "test/hooks.test.js", "test/types/hooks.test-d.ts", "types/hooks.d.ts", "types/instance.d.ts", "types/route.d.ts"]

Add an onTimeout hook

## 🚀 Feature Proposal There are hooks for most events in a request's lifecycle, but I believe that a request that times out doesn't go through the onError or onResponse hooks, so there currently isn't any way to respond to timeouts. This feature proposal is adding an onTimeout hook (or something similar) that would be invoked whenever a request times out. ## Motivation In our app, we want to know how many currently-outstanding requests there are. That way, when we stop sending requests to one server (to do a rolling update), we can know when the server is fully drained and it's safe to update it. To implement our currently-outstanding-request-counter, we can increment a counter when the request comes in, but without an onTimeout hook, we can't properly decrement the counter. We could manually manage the timeouts out of band, but it would be more convenient to do it all in the context of Fastify hooks. ## Example ``` fastify.addHook('onTimeout', () => counter--) ```

https://github.com/fastify/fastify/issues/2203

https://github.com/fastify/fastify/pull/2457

21578f56dea6bfd3de1c9a4df497fd535d174221

8e2d008c450b29b39aff8aa127e0ed7a10775988

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/errors.js", "lib/reply.js", "test/reply-error.test.js"]

Fastify crashes when reply code is not recognized

## 🐛 Bug Report Fastify crashes when reply code is not recognized. ## To Reproduce Steps to reproduce the behavior: Run fastify server that returns an exotic response code. ```js const fastify = require('fastify')({ logger: true }); fastify.get('/', async (request, reply) => { reply.code(525); // exotic response code return { hello: 'world' }; }); const start = async () => { try { await fastify.listen(3000); fastify.log.info(`server listening on ${fastify.server.address().port}`); } catch (err) { fastify.log.error(err); process.exit(1); } }; start(); ``` Make a request to the server ```bash curl http://localhost:3000 ``` The application crashes. The HTTP response code is 500 and the response body is as follows. ```json {"statusCode":500,"code":"FST_ERR_BAD_STATUS_CODE","error":"Internal Server Error","message":"FST_ERR_BAD_STATUS_CODE: Called reply with malformed status code"} ``` ## Expected behavior The application should not crash ## Your Environment - *node version*: v10.19.0 - *fastify version*: 2.13.0 - *os*: Mac

https://github.com/fastify/fastify/issues/2169

https://github.com/fastify/fastify/pull/2184

08e0a0443cbdd432c87cc0cfaf8f10d54e42ff45

8ba959d67c5bc3782eec891cc44bdc1c8ce5d641

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Decorators.md"]

Add docs for explaining the concept of object shapes

Using the decorator defines the shape of request objects. See https://mathiasbynens.be/notes/shapes-ics _Originally posted by @jsumners in https://github.com/fastify/fastify/issues/2115#issuecomment-590562376_

https://github.com/fastify/fastify/issues/2117

https://github.com/fastify/fastify/pull/2127

ba9086b163ea0e9ac3b4a4ec935cb8e4b64fea6d

2874af53002dd9fde9ab24e74b90121cb86bc62d

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/decorate.js", "lib/errors.js", "test/decorator.test.js", "test/internals/decorator.test.js"]

Make decorate* methods throw after server is started.

## 🚀 Feature Proposal In https://github.com/fastify/fastify/issues/2115, the reporter is trying to decorate the global request object within a route. This is not supported by Fastify, and we should throw if `server.decorate()`, `server.decorateRequest()` or `server.decorateReply()` are called after `.ready()`.

https://github.com/fastify/fastify/issues/2116

https://github.com/fastify/fastify/pull/2128

2874af53002dd9fde9ab24e74b90121cb86bc62d

512561f9b868d5ebc5b3cdf9016bf73ae07304ad

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/route.js", "test/http2/plain.js"]

request.hostname isn't set when using HTTP2

## 🐛 Bug Report `request.hostname` isn't set when using HTTP2. ## To Reproduce `index.js`: ```js module.exports = async function (fastify, opts) { fastify.get('/', async (req, r) => r.send(`hostname: ${req.hostname}\n`)); }; module.exports.options = { http2: true }; ``` ## Expected behavior Running `fastify start -o index.js` and `curl --http2-prior-knowledge http://localhost:3000` gives: ``` hostname: localhost:3000 ``` ## Actual behavior ``` hostname: undefined ``` ## Your Environment - *node version*: v13.9.0 - *fastify version*: 2.11.0 - *os*: Windows

https://github.com/fastify/fastify/issues/2112

https://github.com/fastify/fastify/pull/2113

6f79a90703078451f4571ac3e08b815a26753503

093947b75dfbb5da784c3714550d4d7ecf9a340f

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/schemas.js", "lib/symbols.js", "test/hooks.test.js", "test/route.test.js"]

PR-2044 (one schema for multiple routes) introduce breaking change behavior on routes schema resolve.

## 💥 Regression Report PR https://github.com/fastify/fastify/pull/2044 breaks https://github.com/SkeLLLa/fastify-oas and probably related to https://github.com/fastify/fastify-swagger/issues/224 Consider you have fastify onRoute hook and save the routes like ```js const myRouteData = [] fastify.addHook('onRoute', (route) => { myRouteData.push(route); }); ``` Earlier after `.ready()` method is finished his job, e.g. `await app.ready()`, in `schema` in route object was resolved to actual schema objects. E.g. if you referenced schemas by id ```js { query: 'mySchema#' } ``` after app is `ready` you could expect an object in `route.schema.querystring`. However now it's not resolved and still is a string. ## Last working version Worked up to version: 2.11.0 Stopped working in version: 2.12.0 ## To Reproduce Steps to reproduce the behaviour: 1. Add schema with `fastify.addSchema` 2. Reference that schema in route Paste your code here: ```js const routes = [] fastify.addHook('onRoute', (route) => { // here route.schema should be an object routes.push(route) }); await fastify.ready() // iterate over routes and check if `body`, `params`, etc. are not strings. ``` ## Expected behavior It expects that `route.schema.[body,querystring,params,headers]` will be an resolved object after app is ready. However after that PR it is a string (when schema ids are used) ## Your Environment - *node version*: 12 - *fastify version*: >=2.12.0 - *os*: Linux - *any other relevant information*

https://github.com/fastify/fastify/issues/2104

https://github.com/fastify/fastify/pull/2108

98ca7fd538c1f2ebc0ee5d71272d9dcd3f34601b

6f79a90703078451f4571ac3e08b815a26753503

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/errors.js", "lib/reply.js", "test/reply-error.test.js"]

Truncated error response when using reply.code(undefined)

## 🐛 Bug Report When setting the response status code to `undefined` inside error handler, response returned is truncated. This bug was unveiled while working on an issue with `fastifh-gql` [default error handler](https://github.com/mcollina/fastify-gql/blob/174ebb5185e0377acefcac0b0c638b3a575e61e3/lib/routes.js#L58), which set the response code to `err.statusCode`, that could be undefined. ## To Reproduce [Codesandbox](https://codesandbox.io/s/upbeat-napier-broov?expanddevtools=1&fontsize=14&hidenavigation=1&moduleview=1&theme=dark) Paste your code here: ```js const fastify = require("fastify"); const axios = require("axios"); async function start() { const app = fastify({ logger: true }); app.setErrorHandler(async (err, request, reply) => { reply.code(undefined); return { errors: [err.message] }; }); app.get("/", async (request, reply) => { throw new Error("This message will be truncated"); }); const port = 8080; try { await app.listen(port); } catch (err) { app.log.error(err); process.exit(1); } await axios(`http://localhost:${port}`); } if (require.main === module) { start(); } ``` You'll get in return: ```js (node:1727) UnhandledPromiseRejectionWarning: Error: Parse Error at Socket.socketOnData (_http_client.js:442:20) at Socket.emit (events.js:198:13) at addChunk (_stream_readable.js:287:12) at readableAddChunk (_stream_readable.js:268:11) at Socket.Readable.push (_stream_readable.js:223:10) at TCP.onStreamRead (internal/stream_base_commons.js:94:17) ``` On a browser such as Firefox or Chrome, the response is truncated. ## Expected behavior The response should not be truncated. ## Your Environment - *node version*: 13.3 - *fastify version*: >=2.11.0 - *os*: Linux

https://github.com/fastify/fastify/issues/2078

https://github.com/fastify/fastify/pull/2082

14b4e02d3648355987568eccf328a7111558c1b2

41cd02fe81f8895ee7fe9de6579ac39438465776

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Hooks.md", "test/hooks-async.js", "test/hooks.test.js"]

Use symbol to denote early termination of request

## 🚀 Feature Proposal Introduce `Symbol.for('fastify.end-request')` to terminate requests prior to reaching the defined request handler. When this symbol is received from a hook, or any function in the request life _prior_ to the defined request handler, Fastify should issue a `res.send()` that sends any headers and content currently attached to `res` to the requesting client. This should also take the place of returning `undefined` to signal the same thing. Thus, when `undefined` is received from such a function, a deprecation notice/error/warning should be logged. ## Motivation As highlighted in https://github.com/fastify/fastify/issues/2070 and https://github.com/fastify/help/issues/135 , it is unclear how one should terminate a request response before reaching the handler. ## Example ```js fastify.addHook('onRequest', () => { // do something return Symbol.for('fastify.end-request') }) // or fastify.addHook('onRequest', (req, res, next) => { // do something next(null, Symbol.for('fastify.end-request')) }) // or fastify.addHook('onRequest', async (req, res) => { // do something return Symbol.for('fastify.end-request') }) ```

https://github.com/fastify/fastify/issues/2075

https://github.com/fastify/fastify/pull/2079

c052c21db4b1d8b80eafd3435a6ba4ccdc9f97f8

aacefcde84334edc0feeb335807bd530a2bcff19

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Errors.md", "lib/errors.js", "lib/hooks.js", "test/hooks.test.js"]

Promise rejection without error

## 🐛 Bug Report If an async hook returns a `Promise.reject()` the flow continue. This usage of promise should be avoided at all, let me know if you think this is an `invalid` bug. Here we should check the `err` param https://github.com/fastify/fastify/blob/7fa4bddca07aac18e0600cff40d97b95a96ab970/lib/hooks.js#L80-L82 ## To Reproduce Steps to reproduce the behavior: ```js const fastify = require('./fastify')({ logger: true }) fastify.addHook('onRequest', function (request, reply) { return Promise.reject() }) fastify.get('/', async (request, reply) => { return 'hi' }) fastify.listen(3001) ``` ## Expected behavior The rejection should be managed. _Originally posted by @Eomm in https://github.com/fastify/help/issues/135#issuecomment-580913741_

https://github.com/fastify/fastify/issues/2070

https://github.com/fastify/fastify/pull/2074

6b3987003fea822feee9eb559e009efbb177ff67

c052c21db4b1d8b80eafd3435a6ba4ccdc9f97f8

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Errors.md", "lib/handleRequest.js", "test/error-in-post.test.js", "test/sync-routes.test.js"]

Support synchronous routes

## 🚀 Feature Proposal I propose we call `reply.send()` in synchronous routes if the returned value is not Promise or a Stream. ## Motivation It seems a lot of newbies to fastify mistake the use of `async`, and we are not providing them a good developer experience. ## Example ```js 'use strict'; module.exports = (server, opts, done) => { server.get('/', () => { return "Hello World"; }); done(); }; ```

https://github.com/fastify/fastify/issues/2065

https://github.com/fastify/fastify/pull/2073

798f18526d6199b505141724a6c6ed2804bb80fd

3486afe04a05c0874c63010f7525361a316905fe

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.d.ts", "test/types/hooks.test-d.ts", "test/types/route.test-d.ts", "types/hooks.d.ts", "types/instance.d.ts", "types/middleware.d.ts", "types/route.d.ts"]

v3 type def clarification for `addHook` method

I've been fixing the `hooks.d.ts` part of the new types and I've hit a very difficult snag. We have two hooks `onSend` and `preSerialization` that pass through the `payload` argument to the hook handler. For best type safety, we should allow the user to specify what this is via a generic parameter. But because all of the other hook handlers do not require this generic parameter I cannot just add it to `addHook`. What I can do is specify the generic parameter from the specific hook handler definition; and then allow the user to pass this through to the `addHook` function. This requires the user to specify the `onSend` and `preSerialization` hooks like so: ```typescript type TestPayloadType = { foo: string, bar: number } // equivalent for `onSend` const preSerializationHook: preSerializationHookHandler<TestPayloadType> = (request, reply, payload, done) => { // you can ignore this code its just apart of the unit tests expectType<FastifyRequest>(request) expectType<FastifyReply>(reply) expectType<TestPayloadType>(payload) expectType<(err: FastifyError) => void>(done(new Error())) expectType<(err: null, res: string) => void>(done(null, 'foobar')) expectError(done()) } server.addHook('preSerialization', preSerializationHook) ``` There does not seem to be a way to pass that generic in line: ```typescript // THIS CODE IS INVALID type TestPayloadType = { foo: string, bar: number } // Where would `<TestPayloadType>` go? server.addHook('preSerialization', (request, reply, payload, done) => { // ... }) ``` Also, please note that **for all other hooks** the normal way of specifying them will work: ```typescript server.addHook('onRequest', (request, reply, done) => { expectType<FastifyRequest>(request) expectType<FastifyReply>(reply) expectType<(err?: FastifyError) => void>(done) }) ``` --- I've attempted to write a definition that supports passing the payload generic to the `addHook` method but could not figure it out (i believe it might be impossible). So with all of this considered, **is the previously mention specification okay?** Of course, this will be detailed in the TypeScript documentation with code examples -- and I'll include a special note in the type definition comments (editors bubble these up to the user so they can get more info without leaving the editor). Lastly, i'm going to make a gist with all of my type def attempts as a reference -- [will add that here when its ready.](https://gist.github.com/Ethan-Arrowood/c0294ae9533a8b1908cf9c1a0e0208c0) <-- check it out. i'll be adding to it with other attempts as I go

https://github.com/fastify/fastify/issues/2040

https://github.com/fastify/fastify/pull/2042

b9a6a041d1dfc341600abe16f6ec309f0386c402

aadefb2e5c4451452c03573e0c8e844812864b19

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Server.md", "fastify.js", "test/request-error.test.js"]

fastify behind haproxy results into "read ECONNRESET" errors

## 🐛 Bug Report As mentioned in https://github.com/fastify/fastify/blob/master/docs/Recommendations.md we would like to run fastify behind haproxy (for TLS termination and load balancing) After processing an request proxied over haproxy it throws an ECONNRESET error: ``` {"level":30,"time":1578524093038,"pid":16376,"hostname":"ip-10-64-1-175","reqId":1,"req":{"method":"GET","url":"/check","hostname":"localhost","remoteAddress":"127.0.0.1","remotePort":42838},"msg":"incoming request","v":1} {"level":30,"time":1578524093045,"pid":16376,"hostname":"ip-10-64-1-175","reqId":1,"res":{"statusCode":200},"responseTime":5.577713999897242,"msg":"request completed","v":1} {"level":20,"time":1578524093046,"pid":16376,"hostname":"ip-10-64-1-175","err":{"type":"Error","message":"read ECONNRESET","stack":"Error: read ECONNRESET\n at TCP.onStreamRead (internal/stream_base_commons.js:200:27)","errno":"ECONNRESET","code":"ECONNRESET","syscall":"read"},"msg":"client error","v":1} {"level":30,"time":1578524101311,"pid":16376,"hostname":"ip-10-64-1-175","reqId":2,"req":{"method":"GET","url":"/check","hostname":"localhost","remoteAddress":"127.0.0.1","remotePort":42842},"msg":"incoming request","v":1} {"level":30,"time":1578524101311,"pid":16376,"hostname":"ip-10-64-1-175","reqId":2,"res":{"statusCode":200},"responseTime":0.34771000035107136,"msg":"request completed","v":1} {"level":20,"time":1578524101311,"pid":16376,"hostname":"ip-10-64-1-175","err":{"type":"Error","message":"read ECONNRESET","stack":"Error: read ECONNRESET\n at TCP.onStreamRead (internal/stream_base_commons.js:200:27)","errno":"ECONNRESET","code":"ECONNRESET","syscall":"read"},"msg":"client error","v":1} ``` If I bypass haproxy and call directly the NodeJS process this is not happening: ``` {"level":30,"time":1578524117357,"pid":16376,"hostname":"ip-10-64-1-175","reqId":3,"req":{"method":"GET","url":"/check","hostname":"localhost:8337","remoteAddress":"127.0.0.1","remotePort":42850},"msg":"incoming request","v":1} {"level":30,"time":1578524117357,"pid":16376,"hostname":"ip-10-64-1-175","reqId":3,"res":{"statusCode":200},"responseTime":0.4655680004507303,"msg":"request completed","v":1} {"level":30,"time":1578524120839,"pid":16376,"hostname":"ip-10-64-1-175","reqId":4,"req":{"method":"GET","url":"/check","hostname":"localhost:8337","remoteAddress":"127.0.0.1","remotePort":42852},"msg":"incoming request","v":1} {"level":30,"time":1578524120840,"pid":16376,"hostname":"ip-10-64-1-175","reqId":4,"res":{"statusCode":200},"responseTime":0.3121840003877878,"msg":"request completed","v":1} ``` Error is triggered via HTTP.Server 'clientError' - logged at https://github.com/fastify/fastify/blob/master/fastify.js#L417 - also I would ask why errors are just logged as "debug" severity? ## To Reproduce To exclude other possible errors like network issues node and haproxy are running on the same machine. As HTTP client for testing I used cmd line CURL on same machine. I could reproduce the same also with links & lynx browser on CMD line. Also it was reproducible from remote. 1. Node with fastify on Port 8337 (simple.ts) 2. Haproxy with haproxy.cfg on Port 80 3. "curl http://localhost/check" (over haproxy, causes that issue) 4. "curl http://localhost:8337/check" (directly NodeJS, no issue) (Error is only logged on logger level >= debug) *simple.ts* ```js import * as fastify from 'fastify'; const app = fastify({ logger: { level: 'trace', }, trustProxy: true, }); app.get('*', (_req, reply) => { reply.send('foo'); }); app.listen(8337, '0.0.0.0'); ``` *haproxy.cfg* (reduced version out of Recommendations.md) ```haproxy global log /dev/log syslog maxconn 4096 chroot /var/lib/haproxy user haproxy group haproxy defaults log global mode http option httplog option dontlognull option forwardfor retries 3 option redispatch maxconn 2000 timeout connect 5000 timeout client 50000 timeout server 50000 frontend proxy bind 0.0.0.0:80 default_backend fastify backend fastify server local 127.0.0.1:8337 ``` ## Expected behavior I also tested if this also occurs with just node HTTP.server implementation, I couldn't reprodue it. Also I couldn't see this behavior with express.js. There should be no "Error: read ECONNRESET\n at TCP.onStreamRead" Looks for me if something is trying to read on a already ended connection? ## Your Environment - *node version*: 12.14.1 - *fastify version*: 2.11.0 - *os*: Linux, debian buster - also reproduced on Mac - *haproxy version*: 1.8.19-1+deb10u1 - *curl version*: 7.64.0 - *any other relevant information*

https://github.com/fastify/fastify/issues/2036

https://github.com/fastify/fastify/pull/2268

d335a7a729c0bbba4a3ae0fbe08254fd410f86ea

d8feb2323c00d49a16b48401a2f7e8fcfbbb0338

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.d.ts", "test/types/index.ts"]

Add generic parameter for Reply send method

Based on a discussion in https://github.com/fastify/help/issues/125 a good feature for the type system (current and future) would be to add a generic parameter to the `reply.send` method to allow the user to specify the payload type being passed in. It is currently set to `any` see [v2](https://github.com/fastify/fastify/blob/master/fastify.d.ts#L180) and [v3](https://github.com/fastifyf/fastify/blob/next/types/reply.d.ts#L22). This is not a breaking feature to the type system so it should not block the v3 release.

https://github.com/fastify/fastify/issues/2030

https://github.com/fastify/fastify/pull/2032

620a7a073b8eca1d7be5cae22fad6e7f9348623b

e6c63c33327084b6feaac147ab6e82d5d0ae47b9

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/schemas.js", "test/route.test.js"]

I cant use one schema for two different routes

🐛 Bug Report when I want too set my schema to different routs I get this error FastifyError [FST_ERR_SCH_DUPLICATE]: FST_ERR_SCH_DUPLICATE: Schema with 'querystring' already present! ## To Reproduce create a schema with query and add it to different routes ```js this is my schema "sportSite_sportSiteSessionForGetAllSchema": { "params": { "type": "object", "required": [ "sportSiteUUID" ], "properties": { "sportSiteUUID": { "type": "string", "format": "uuid" } } }, "query": { "type": "object", "properties": { "pageSize": { "type": "integer", "maximum": sportSiteWorkPlanMaxPage }, "pageNumber": { "type": "integer" } } } } and my routes fastify.get( "/:sportSiteUUID/sessions/userType/customer", { "schema": sportSite_sportSiteSessionForGetAllSchema }, httpHandlers.getAllSportSiteSessionsForSportSiteForCustomerHandler ); fastify.get( "/:sportSiteUUID/sessions/userType/provider", { "schema": sportSite_sportSiteSessionForGetAllSchema, "preHandler": [ fastify.authenticate( fastify.tokenUtil ), fastify.authorizeByRoles( [ "provider" ] ), fastify.authorizeResource( fastify, ( req ) => req.params.sportSiteUUID ) ] }, httpHandlers.getAllSportSiteSessionsForSportSiteForProviderHandler ); ``` - *node version*: 13.5 - *fastify version*: >=2.11.0 - *os*: Windows

https://github.com/fastify/fastify/issues/2024

https://github.com/fastify/fastify/pull/2044

5258f421a32592396d9e9999812f6c6096ccf6db

62f21b1211dab665cccca4dec966169ae548ba1b

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/handleRequest.js", "test/http2/head.test.js", "test/internals/handleRequest.test.js"]

Under Nodejs v13.5.0, Fastify HTTP2.0 use .finished which could be true when .writableEnded is false

Maybe it is a nodejs bug, but in handleRequest.js: function preValidationCallback (err, request, reply) { if (reply.sent === true || reply.res.**finished** === true) return if (err != null) { reply.send(err) return } ... function preHandlerCallback (err, request, reply) { if (reply.sent || reply.res.**finished** === true) return if (err != null) { reply.send(err) return } ... when handle **HEAD** request, reply.res.**finished** will be true, but reply.res.**writableEnded** is false. use .finished would cause client pending because server early returns. I changed my node_modules/fastify source, use **writableEnded**, then everything is Ok. Since .finished is Deprecated in Nodejs v13.4.0, I think use .writableEnded (if it exists) is the right thing.

https://github.com/fastify/fastify/issues/1993

https://github.com/fastify/fastify/pull/2233

4f88ce7034597199ed4b5e6c76819cfd80e6d487

a0b5673447de3451e43ef46960045ce352b4ae32

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["package.json"]

Use Pino v6

In fastify v3 we will use Pino v6.

https://github.com/fastify/fastify/issues/1973

https://github.com/fastify/fastify/pull/2163

f1cfcadbe201f98137a5b2a9ee1159215b5d81e5

f40ca9729eec4d8632fd3397b691a31c0ad3c671

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Hooks.md", "fastify.js", "lib/hooks.js", "lib/route.js", "lib/symbols.js", "test/hooks.test.js"]

new scope for fastify plugin

## 💬 Questions and Help I try to encapsule the rate-limit plugin to its own fastify instance. ```js const fastify = require("fastify"); const fastifyRateLimit = require("fastify-rate-limit"); const ioredis_1 = require("ioredis"); const server = fastify(); const start = async () => { server.get('/', async (request, response) => { return { hello: 'world' }; }); server.register(async (instance, opts) => { instance.register(fastifyRateLimit, { max: 1, timeWindow: 10 * 1000, redis: new ioredis_1.default() }); instance.get('/limit1', async (request, response) => { return { limit: 1 }; }); instance.get('/limit2', async (request, response) => { return { limit: 2 }; }); }); server.get('/broken', async (request, response) => { return { broken: true }; }); await server.listen(3000); }; start() .catch((e) => { throw e; }); ``` ## Expected behavior Only the routes `/limit1` and `/limit2` should have the rate-limit plugin "attached". But currently the route `/broken` is also limited by the rate-limiter, while the `/` is without any rate-limit. As far as I understood the `.register` function it shall gave you a new scope of fastify that you can modify without effecting the "outer" fastify instance. ## Your Environment - *node version*: 13.3.0 - *fastify version*: 2.11.0 - *fastify-rate-limit version*: 3.0.1 - *os*: Linux

https://github.com/fastify/fastify/issues/1970

https://github.com/fastify/fastify/pull/2004

747311e820b2c964b2d01dadbcba425617787065

80d87c959fcbb2ae00295bebbd1d912c97f64184

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/route.js", "package.json", "test/route.test.js", "test/schemas.test.js"]

Schema and route declaration order conflict.

## 🐛 Bug Report Initially opened at https://github.com/fastify/fastify-cors/issues/47 because upgrading the cors plugin caused shared schemas to fail. I looped through the debugger many times and I think I found the issue. This was because the `fastify-cors` plugin starting from version 2.2.0 added a default line that hide OPTIONS routes from swagger. [Relevant commit](https://github.com/fastify/fastify-cors/commit/a28da42af1f92b819241c975436bade27f5dc9b2). If a shared schema was added after the cors plugin was registered, and used in a subsequent route declaration, the list of schemas attached to the default schema compiler (ajv in this case) is already set, and additional referenced schemas can't be found. To see what I mean, set a breakpoint at line 229 in `fastify/lib/route.js` where `buildSchema` is called. If you inspect `this[kSchemaCompiler]`'s bound `this`'s `_refs` field, you'll see that in the cases where it works, there is a schema keyed `https://example.com/bson/objectId`; in cases where it doesn't, this property is missing. ## To Reproduce Referring to the sample code below... Running the script as is will throw a `FST_ERR_SCH_BUILD` error, saying it cannot find the `https://example.com/bson/objectId` ref. Any of the options will make it work, and show the right properties in `_refs`. 1. Comment out the line below `1a`. 2. Comment out `2`, and uncomment `3`. 3. Move `1` below `2`. ```js const fastify = require('fastify')({ logger: true }); const fp = require('fastify-plugin'); /** * 1. An example of a plugin declaring a route with one of the options * being a schema option. */ fastify.get( '/', /** * 1a. The option line below is one of the cause of the issue. */ { schema: { random: 'options' } }, (req, reply) => reply.send(), ); /** * 2. Registration of shared schemas used throughout the server in a plugin. */ fastify.register(fp(async f => f.addSchema({ $id: 'https://example.com/bson/objectId', type: 'string', pattern: '\\b[0-9A-Fa-f]{24}\\b', }))); /** * 3. Registration of shared schemas used throughout the server inline. */ // fastify.addSchema({ // $id: 'https://example.com/bson/objectId', // type: 'string', // pattern: '\\b[0-9A-Fa-f]{24}\\b', // }); /** * 4. Another route declaration, this time using the shared schema in $ref-way form. */ fastify.get( '/:id', { schema: { params: { type: 'object', properties: { id: { $ref: 'https://example.com/bson/objectId#' }, }, }, }, }, (req, reply) => reply.send({ hello: req.params.id }), ); /** * Start the server. */ fastify.listen('1337', '127.0.0.1'); ``` ## Expected behavior Perhaps this is an expected behavior but it seems like a gotcha since there shouldn't be any conflict between declaring routes/schemas in any order, as long as the declared schema happens before the route that uses it and is in its inherited scope. ## Your Environment - *node version*: 12 - *fastify version*: >=2.9.0 - *os*: Mac/Linux - *any other relevant information*

https://github.com/fastify/fastify/issues/1960

https://github.com/fastify/fastify/pull/2077

a272f153946fbe5134ff2d55d1e9526967e0ad41

0b50f38df033ae112d5043cdf21297c7562f608e

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["test/types/hooks.test-d.ts", "test/types/instance.test-d.ts", "test/types/route.test-d.ts", "types/error.d.ts", "types/hooks.d.ts", "types/instance.d.ts"]

TypeScript FastifyError inherits from Error instead of ErrnoException

## 🐛 Bug Report `FastifyError` inherits from `Error` (JavaScript type), but it can hold other properties as `NodeJS.ErrnoException` (Node.js Error type) defined. `ErrnoException` in: Node.js v6: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/v6/base.d.ts#L327 Node.js v8: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/v8/base.d.ts#L375 ```js export interface ErrnoException extends Error { errno?: number; code?: string; path?: string; syscall?: string; stack?: string; } ``` Error: ```js interface Error { stack?: string; } ``` ## To Reproduce Steps to reproduce the behavior: `error` argument is a `FastifyError` instance. We need to cast to Node.js `ErrnoException` to get code property. ```js fastify.setErrorHandler((error, request, reply): void => { const e = error as NodeJS.ErrnoException if (e.code === 'ECONNREFUSED' || e.code === 'ENOTFOUND') { reply.send(new create.ServiceUnavailable()) ``` ## Expected behavior If `interface FastifyError extends ErrnoException` then we needn't cast error. See: https://github.com/fastify/fastify/blob/master/fastify.d.ts#L51 ```js fastify.setErrorHandler((error, request, reply): void => { if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') { reply.send(new create.ServiceUnavailable()) ``` ## Your Environment - *node version*: 10 - *fastify version*: >=2.10.0 - *os*: Mac

https://github.com/fastify/fastify/issues/1914

https://github.com/fastify/fastify/pull/2337

68f1ac6b727d938287d5d8dba114ea8c8c63f4ee

25d7ba2b86d00dd68c4bbb5648ee3706a6b8dafe

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["README.md"]

Fluent Schema not shown in documentations?

Before you submit an issue we recommend you drop into the [Gitter community](https://gitter.im/fastify) or [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** ## 🐛 Bug Report Had me scratching my head if this is an experimental feature since it's hidden. Is this expected? <img width="550" alt="Screen Shot 2019-10-18 at 7 24 01 AM" src="https://user-images.githubusercontent.com/7200153/67054822-5d962000-f178-11e9-85a5-420e0e9a8d68.png">

https://github.com/fastify/fastify/issues/1900

https://github.com/fastify/fastify/pull/1903

3991088b4b22fb04263d197eb271973390f28e6a

7f8c3f2ba7c7f01cd24397976e545dd57e924d47

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.js", "package.json", "test/404s.test.js"]

404 with not encoded URI path parameter

## 🐛 Bug Report If I send a wrong path parameter without appling an `encodedURI` I get a 404 response and a warn: ``` {"level":30,"time":1570179820901,"pid":21956,"hostname":"MSPIGOLON5591","reqId":3,"req":{"method":"GET","url":"/%25what%","remotePort":53476},"msg":"incoming request","v":1} {"level":40,"time":1570179820902,"pid":21956,"hostname":"MSPIGOLON5591","reqId":3,"msg":"the default handler for 404 did not catch this, this is likely a fastify bug, please report it","v":1} {"level":40,"time":1570179820902,"pid":21956,"hostname":"MSPIGOLON5591","reqId":3,"msg":"ÔööÔöÇÔöÇ / (ACL|BIND|CHECKOUT|CONNECT|COPY|DELETE|GET|HEAD|LINK|LOCK|M-SEARCH|MERGE|MKACTIVITY|MKCALENDAR|MKCOL|MOVE|NOTIFY|OPTIONS|PATCH|POST|PROPFIND|PROPPATCH|PURGE|PUT|REBIND|REPORT|SEARCH|SOURCE|SUBSCRIBE|TRACE|UNBIND|UNLINK|UNLOCK|UNSUBSCRIBE)\n ÔööÔöÇÔöÇ * (ACL|BIND|CHECKOUT|CONNECT|COPY|DELETE|GET|HEAD|LINK|LOCK|M-SEARCH|MERGE|MKACTIVITY|MKCALENDAR|MKCOL|MOVE|NOTIFY|OPTIONS|PATCH|POST|PROPFIND|PROPPATCH|PURGE|PUT|REBIND|REPORT|SEARCH|SOURCE|SUBSCRIBE|TRACE|UNBIND|UNLINK|UNLOCK|UNSUBSCRIBE)\n","v":1} ``` ## To Reproduce ```js const fastify = require('fastify')({ logger: true }) fastify.get('/:strangeId', (req, reply) => { reply.send({ strangeId: req.params.strangeId }) }) fastify.listen(3000) ``` ``` curl -X GET http://localhost:3000/%what% -H 'Accept: */*' -H 'Accept-Encoding: gzip, deflate' -H 'Connection: keep-alive' -H 'Host: localhost:3000' -H 'User-Agent: PostmanRuntime/7.17.1' ``` All work with an encoded path param: ``` curl -X GET http://localhost:3000/%25what%25 -H 'Accept: */*' -H 'Accept-Encoding: gzip, deflate' -H 'Connection: keep-alive' -H 'Host: localhost:3000' -H 'User-Agent: PostmanRuntime/7.17.1' ``` ## Expected behaviour I wouldn't expect a 404. With a plain server, the URL is: ``` { req: '/%what%' } { req: '/%25what%25' } ``` ```js const http = require('http') const server = http.createServer(function manageResponse (req, res) { console.log({ req: req.url }) res.end('hello') }) server.listen(3000) ``` ## Your Environment - *node version*: 12 - *fastify version*: 2.9 - *os*: Windows

https://github.com/fastify/fastify/issues/1884

https://github.com/fastify/fastify/pull/1888

7c4c7d64ee84655cfa00d34e450404cf10145662

11d286e4cab57d466b58385ee7a091abcc5348cc

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.d.ts", "lib/schemas.js", "package.json", "test/schemas.test.js", "test/types/index.ts"]

Broken JSON Schema resolution

## 🐛 Bug Report When using a reference to a full schema definition, instead of to a sub resource of the referenced schema, Fastify's schema resolution incorrectly mutates the reference name. The result is that it cannot find the referenced schema. ## To Reproduce Steps to reproduce the behavior: Paste your code here: ```js 'use strict'; const AJV = require('ajv'); const ajv = new AJV(); ajv.addSchema({ $id: 'urn:schema:foo', definitions: { foo: { type: 'string' } }, type: 'object', properties: { foo: { $ref: '#/definitions/foo' } } }); ajv.addSchema({ $id: 'urn:schema:response', type: 'object', properties: { bar: { $ref: 'urn:schema:foo' } } }); const fastify = require('fastify')(); fastify.setSchemaCompiler(schema => ajv.compile(schema)); fastify.setSchemaResolver(name => ajv.getSchema(name).schema); fastify.route({ path: '/', method: 'GET', schema: { response: { '2xx': ajv.getSchema('urn:schema:response').schema } }, handler(req, reply) { reply.send({ bar: { foo: 'bar' } }); } }); fastify.inject({ url: '/' }, (err, response) => { if (err) { throw err; } console.log(response.body); }); ``` ## Expected behavior The `urn:schema:foo` reference should resolve to an object schema. ## Cause https://github.com/fastify/fastify/blob/89dd7493c06774600635b010ebac6a622bfd42f2/lib/schemas.js#L110 Notice that on this line the value of `refValue` will be `'urn:schema:foo'`. Since this string does not have a `#` character, the line will execute `refValue.slice(0, -1)` which will yield `'urn:schema:fo'`.

https://github.com/fastify/fastify/issues/1881

https://github.com/fastify/fastify/pull/1882

89dd7493c06774600635b010ebac6a622bfd42f2

f199f9ff8723d7c04b93c6db3a941f675365d75b

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/schemas.js", "test/internals/schemas.test.js"]

Creates invalid schema

## 🐛 Bug Report Fastify with fastify-swagger creates invalid swagger schema. It should not contain $id fields. ## To Reproduce https://repl.it/repls/HoarseCoolEditor And you'll got ```json ... "paths": { "/first": { "get": { "responses": { "200": { "schema": { "type": "array", "items": { "type": "object", "properties": { "a": { "type": "number" } }, "$id": "A" } }, "description": "Default Response" } } } }, } ... ``` Notice the `responses.200.schema.items.$id`. Swagger generates error like ``` should NOT have additional properties additionalProperty: $id ``` ## Your Environment - *node version*: 8 - *fastify version*: 2.8.0 - *os*: Linux I plan to create PR with fix a bit later

https://github.com/fastify/fastify/issues/1871

https://github.com/fastify/fastify/pull/1872

72451e901227048707fff157df6abeab6d5e23a8

5c00909721c16ceafae46da9378017a401ed96be

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

[".github/workflows/ci.yml"]

Coveralls GH action posts too many comments

Currently, the coveralls GitHub action is posting too many comments in the pull request. I've checked our coveralls configuration, and the comments are disabled. I'm not even sure that problem is caused by the [coveralls GitHub action](https://github.com/coverallsapp/github-action). A couple of examples of pr with too many comments: https://github.com/fastify/fastify/pull/1869 https://github.com/fastify/fastify/pull/1867 Related: https://github.com/fastify/fastify/issues/1847 https://github.com/fastify/fastify/pull/1853 https://github.com/coverallsapp/github-action/issues/5

https://github.com/fastify/fastify/issues/1870

https://github.com/fastify/fastify/pull/1918

16173896d42ce34f7af5d702587d9487762cf444

d0e78d16d151db402332386127385fed8541a9cb

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reply.md", "docs/Routes.md", "lib/reply.js", "test/async-await.js", "test/internals/reply.test.js", "test/promises.test.js"]

Async style with reply.send

## 🐛 Bug Report `repl.send` inside an async function has created a lot of headache. - https://github.com/fastify/fastify/issues/238 - https://github.com/fastify/fastify/issues/238 - https://github.com/fastify/fastify/issues/548 - https://github.com/fastify/fastify/issues/1131 with https://github.com/fastify/fastify-static/issues/110 we have another issue. The issue ist that an error is logged because `sendFile` doesn't accept a callback or return a promise. The route is fulfilled to `undefined` before the file was sent. This behaviour doesn't agree with https://github.com/fastify/fastify/blob/master/docs/Routes.md#promise-resolution. Due to the current implementation every decorator/plugin which calls `.send` under the hood must provide a callback or promise to the consumer. If they don't the handler can't use async/await and will loose the control over the response. ## Expected behavior **In the longer term we change the api.** ```js // the data flow isnt determined by the function return value (koajs be like) fastify .get('/', async (request, reply) => { reply.body = await data() repl.body = sync() }); ``` **In short term:** Teach and update the docs that you can use only `reply.send` in async/await if you still return a promise that controls the asynchronous operation. ```js until send is called fastify .get('/', async (request, reply) => { return op().then(reply.send) }); ``` or we recommend to not use `rely.send` at all in async functions

https://github.com/fastify/fastify/issues/1864

https://github.com/fastify/fastify/pull/1869

5a61f3e0b163bfa51df846e29cce6519c94ef5ee

0e39b83c3bde8a9cb6531ad2dbe960be75199e1d

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Server.md", "docs/Validation-and-Serialization.md", "fastify.js", "lib/errors.js", "lib/handleRequest.js", "lib/route.js", "lib/schemas.js", "lib/symbols.js", "lib/validation.js", "test/schemas.test.js"]

Using custom AJV breaks resolving references

## 🐛 Bug Report When using a custom AJV instance as described in the documentation (https://www.fastify.io/docs/latest/Validation-and-Serialization/#schema-compiler) one cannot provide a schema with references as a response schema. ## To Reproduce ```js 'use strict'; const AJV = require('ajv'); const ajv = new AJV(); ajv.addSchema({ $id: 'urn:schema:foo', definitions: { foo: { type: 'string' } }, type: 'object', properties: { foo: { $ref: '#/definitions/foo' } } }); ajv.addSchema({ $id: 'urn:schema:response', type: 'object', properties: { foo: { $ref: 'urn:schema:foo#/definitions/foo' } } }); const fastify = require('fastify')(); fastify.setSchemaCompiler(schema => ajv.compile(schema)); fastify.route({ path: '/', method: 'GET', schema: { response: { '2xx': ajv.getSchema('urn:schema:response').schema } }, handler(req, reply) { reply.send({ foo: 'bar' }); } }); fastify.inject({ url: '/' }, (err, response) => { if (err) { throw err; } console.log(response.body); }); ``` ## Expected behavior The route should register and resolve references correctly. Paste the results here: ```js /private/tmp/17/fastify-custom-ajv/index.js:44 throw err; ^ FastifyError [FST_ERR_SCH_BUILD]: FST_ERR_SCH_BUILD: Failed building the schema for GET: /, due error Cannot read property '$ref' of undefined at Object.afterRouteAdded (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/fastify/2.8.0/node_modules/fastify/lib/route.js:224:37) at after (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/fastify/2.8.0/node_modules/fastify/lib/route.js:165:25) at Object._encapsulateThreeParam (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/avvio/6.2.2/node_modules/avvio/boot.js:417:7) at Boot.callWithCbOrNextTick (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/avvio/6.2.2/node_modules/avvio/boot.js:339:5) at Boot._after (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/avvio/6.2.2/node_modules/avvio/boot.js:230:26) at Plugin.exec (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/avvio/6.2.2/node_modules/avvio/plugin.js:89:17) at Boot.loadPlugin (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/avvio/6.2.2/node_modules/avvio/plugin.js:175:10) at Task.release (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/fastq/1.6.0/node_modules/fastq/queue.js:127:16) at worked (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/fastq/1.6.0/node_modules/fastq/queue.js:169:10) at toLoad.finish (/private/tmp/17/fastify-custom-ajv/node_modules/.registry.npmjs.org/avvio/6.2.2/node_modules/avvio/plugin.js:178:7) ``` ## Your Environment - *node version*: 10.16.3 - *fastify version*: 2.8.0 - *os*: Mac

https://github.com/fastify/fastify/issues/1855

https://github.com/fastify/fastify/pull/1858

27ff97cad56f01d5b5bcb71c0b919a04ae0b3a6a

4cf5c338edcdece7272f9935da91e6b1080eb190

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

[".github/workflows/ci.yml", ".github/workflows/package-manager-ci.yml", ".github/workflows/website.yml", ".travis.yml", "README.md", "docs/LTS.md"]

Leverage Github Actions

## 🚀 Feature Proposal We have Github Actions enabled in this repo! What can we do with them? One thing that would be nice is to move the trigger to CircleCI for deploying the website. Moreover, we can actually redo the automation for the [website](https://github.com/fastify/website) using actions! @lmammino and maybe others, would it be nice to have these here?

https://github.com/fastify/fastify/issues/1847

https://github.com/fastify/fastify/pull/1853

d50e173c6ca46a43c2b357de759cdf793ed6a1ee

03d2408a2d910df2a4625c590fe15ee1ae0e277a

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/fourOhFour.js", "test/404s.test.js", "test/logger.test.js", "test/route-prefix.test.js"]

Do not create an Error for the default 404 route

## 🚀 Feature Proposal Creating an `Error` is costly, and we should be able to avoid that in https://github.com/fastify/fastify/blob/d48c6a21f21d72b7683808aa88b3fdcd2e0478db/lib/fourOhFour.js#L53. Moreover, it complicates debugging (see #1822 for details).

https://github.com/fastify/fastify/issues/1823

https://github.com/fastify/fastify/pull/1826

05c0329cce02d3124e868d13c4072b9c6c9981ad

76c8879a07aa221f98aa9df89cfdac7ad844c521

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/handleRequest.js", "package.json", "test/hooks-async.js"]

async preValidation hook does not abort request

## 🐛 Bug Report When calling `reply.send` within an async preValidation hook, this does not abort the request and thus emits a `Response has already been sent` error. Related: #677 According to the linked issue and pr, it should have been fixed, however it doesn't seem to be (At least for me): ## To Reproduce Hook: ```js fastify.addHook("preValidation", async function (request, reply) { reply.code(403).send({error: "unauthenticated"}); }); ``` Handler: ```js module.exports = function (fastify, opts, next) { fastify.get("/", {}, async (request, reply) => { // This gets still executed, and reply.sent is true here }); next(); } ``` ## Expected behavior The handler should not get called. ## Your Environment - *node version*: 10.16.0 - *fastify version*: >=2.5.0 - *os*: Windows, Linux

https://github.com/fastify/fastify/issues/1776

https://github.com/fastify/fastify/pull/1778

b856f07facb6667d8e34e6e352d76a0c53b452f9

2996fd83042084a2ecccc38b6fa123ec87546eec

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/handleRequest.js", "package.json", "test/hooks-async.js"]

Lifecycle is not interrupted when onSend executes asynchronously

## 🐛 Bug Report When an instance `onSend` hook executes asynchronously, responding from a route hook does not always prevent the route handler from being called. ## To Reproduce #### Setup 1. `npm init -y && npm i -S [email protected]` 2. Add the code from [this gist](https://gist.github.com/ericmacfa/e5331a632464ec4530c7a42617b67f45) to index.js <details> <summary>Bare-bones snippet</summary> <p> ```js const fastify = require('fastify')(); // This issue occurs with both callback and promise based `onSend` hooks fastify.addHook('onSend', (request, reply, payload, done) => { setTimeout(() => { done(null, payload); }, 50); }); fastify.route({ method: 'GET', path: '/', preHandler: async function(request, reply) { console.log('GET / -> preHandler()'); reply.redirect('/login'); }, handler: function(request, reply) { console.log('GET / -> handler() !! This should never be shown !!'); reply.send({ hello: 'world' }); } }); fastify.route({ method: 'GET', path: '/login', handler: function(request, reply) { console.log('GET /login -> handler()'); reply.send('Please log in\n'); } }); fastify.listen(3000); ``` </p> </details> 3. `node ./index.js` #### Steps to reproduce 1. `curl -L localhost:3000` (Or via a browser, postman, etc.) 2. Notice that the `/` route handler was called, even though we responded in the `preHandler` hook. ``` server listening on port 3000 GET / -> preHandler() GET / -> handler() !! This should never be shown !! GET /login -> handler() ``` #### Additional notes (from gist code comments) - This issue occurs when either the callback or the promise based `onSend` hook is used. - This issue occurs when the promise based `preHandler` hook is used, but not when the callback based version is used. ## Expected behavior 1. `curl -L localhost:3000` 2. The handler for the `/` route should not be called. ``` server listening on port 3000 GET / -> preHandler() GET /login -> handler() ``` ## Your Environment - _node version_: `10.16.0` - _fastify version_: `2.6.0` - _os_: Mac

https://github.com/fastify/fastify/issues/1733

https://github.com/fastify/fastify/pull/1778

b856f07facb6667d8e34e6e352d76a0c53b452f9

2996fd83042084a2ecccc38b6fa123ec87546eec

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reply.md"]

Error thrown from a hook is not propagating to custom error handler

If you throw an error from a hook it is not propagated to the custom error handler. ## To Reproduce ```js const fastify = require('fastify')(); fastify.setErrorHandler(async (error, request, reply) => { console.log("Im in error handler", error); reply.code(401).send({ error }); }); fastify.addHook("preValidation", async (request) => { console.log("Im in pre validation"); throw { detail: "Token is not valid" }; }); fastify.get('/', (req, reply) => { reply.send({ hello: 'world' }) }); fastify.listen(3000, err => { if (err) throw err; const port = fastify.server.address().port; console.log(`server listening on ${port}`) }); ``` ```curl --request GET --url http://localhost:3000/``` ## Expected behavior The error should propagate to custom `errorHandler` and respond with 401 in this case. ## Current behavior Not propagated error handler and responding with 200 `{ detail: "Token is not valid" }` as the body. ## Environment - *node version*: 10 - *fastify version*: 2.4.1 - *os*: Mac

https://github.com/fastify/fastify/issues/1680

https://github.com/fastify/fastify/pull/2126

a8d5448862bcff5c616ac863d73e2b3f2e00d6e6

ba9086b163ea0e9ac3b4a4ec935cb8e4b64fea6d

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/route.js", "test/route-prefix.test.js"]

Setting ignoreTrailingSlash and prefixTrailingSlash prevents avvio from throwing an error

## 🐛 Bug Report Setting `ignoreTrailingSlash: true` on main Fastify instance and registering a plugin with tralingSlash prefixed path (`prefix: '/attendances/'`), prevents avvio from crashing on startup with `AssertionError [ERR_ASSERTION]: Method 'GET' already declared for route '/v1/attendances/'` error. As you can see on [repro repo](https://github.com/fox1t/afterRouteAdded-swallowed-error), in this case fastify registers two routes on the inner plugin and starts the server: * GET /v1/attendances/ * GET /v1/attendances// After the server is ready, calling `/v1/attendances//` route will result in `TypeError: Cannot read property 'length' of undefined` in [`/lib/hooks.js:65:32`](https://github.com/fastify/fastify/blob/master/lib/hooks.js#L65). This happens because [`/lib/route.js#L246`](https://github.com/fastify/fastify/blob/master/lib/route.js#L246) is never reached for `/v1/attendances//` and therefore some pre* hooks (preParsing, preValidation preSerialization) are never set to `null`. There is only a default for preHandler hook [lib/context.js#L16](https://github.com/fastify/fastify/blob/master/lib/context.js#L16). The others are supposed to be set in afterRouteAdded function, but for `/v1/attendances//` the execution goes in [lib/route.js#L228](https://github.com/fastify/fastify/blob/master/lib/route.js#L228) (as already pointed out with an`AssertionError [ERR_ASSERTION]: Method 'GET' already declared for route '/v1/attendances/'`). The `done` callback is located in avvio [plugin.js#L98](https://github.com/mcollina/avvio/blob/master/plugin.js#L98) and when called for `/v1/attendances//` it finds the `completed===true` because of `/v1/attendances/`. The bug is generated on [lib/route.js#L144](https://github.com/fastify/fastify/blob/master/lib/route.js#L144) since it calls `afterRouteAdded.call` two times in a row. In fact, using a non default value for `prefixTrailingSlash` (so `slash` or `no-slash`) it works as expected. ## To Reproduce Clone this [repo](https://github.com/fox1t/afterRouteAdded-swallowed-error): `npm i` `npm run dev` call the `/v1/attendances//` rout using postman or similar. ## Expected behavior Avvio must stop loading the plugin and throwing `AssertionError [ERR_ASSERTION]: Method 'GET' already declared for route '/v1/attendances/'` error. ## Your Environment - *node version*: 10 - *fastify version*: >=2.4.1 - *os*: Mac

https://github.com/fastify/fastify/issues/1672

https://github.com/fastify/fastify/pull/1675

fc52dc3813dec514b8bb374660818e0a52ec13b6

ecea232ae596fd0eb06a5b38080e19e4414bd942

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/TypeScript.md", "fastify.d.ts", "types/instance.d.ts", "types/plugin.d.ts", "types/register.d.ts", "types/reply.d.ts", "types/request.d.ts"]

TypeScript Schema Example Documentation

## 🚀 Feature Proposal The upcoming type refactor #1569 references a documentation example of how to declare strict schema types. This issue will track that documentation addition. (It'll also be the start to the next stage of v3 types which is improving the TS docs and examples). ## Motivation TypeScript support 🎉 ## Example Copied from PR comment: > It looks like others are solving this problem by using [json-schema-to-typescript](https://www.npmjs.com/package/json-schema-to-typescript). This [article](https://spin.atomicobject.com/2018/03/26/typescript-data-validation/) discusses how a specific team is using it directly with Ajv too! > > I'm thinking about using a similar approach to the Pino type definition. I'll use a JSDoc comment on FastifySchema in order to tell the user if they'd like more strict schema type support they should utilize the above library -- this should point to a detailed write up in our own documentation to show users exactly how to make it work with Fastify (or a custom fastify plugin that can do this automatically for the user)

https://github.com/fastify/fastify/issues/1668

https://github.com/fastify/fastify/pull/1966

feb0bb6d3cf338fca35ced347d904e7a6a45eafa

f7bc276008b85215e4901ad271cf29dea69c8af4

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.d.ts", "test/types/index.ts"]

TypeScript RouteOptions interface generics missing defaults

## 🐛 Bug Report Working with routes definition I found that `RouteOptions` interface hasn't default generics declared. (https://github.com/fastify/fastify/blob/master/fastify.d.ts#L266) as opposed to `RouteShorthandOptions`(https://github.com/fastify/fastify/blob/master/fastify.d.ts#L230) that it extends from. Is this a wanted behavior? I think this is too verbose since it forces to pass every time a route is declared a full set of same generics: `RouteOptions<Server, IncomingMessage, ServerResponse>`. ## To Reproduce Removing generics (`<Server, IncomingMessage, ServerResponse>`) TypeScript pops a compiler error: `Generic type 'RouteOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>' requires between 3 and 7 type arguments.` ```ts import { Server, IncomingMessage, ServerResponse } from 'http' import { RouteOptions, RouteShorthandOptions } from 'fastify' const listAttendance: RouteOptions<Server, IncomingMessage, ServerResponse> = { method: 'GET', url: '/', handler: (req, reply) => { reply.send([]) }, } const listAttendances: RouteShorthandOptions = {} ``` ## Expected behavior Adding the defaults to `RouteOptions` the error goes away. I think this is the desirable behavior. Paste the results here: ```ts /** * Route configuration options such as "url" and "method" */ interface RouteOptions< HttpServer = http.Server, HttpRequest = http.IncomingMessage, HttpResponse = http.ServerResponse, Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody > extends RouteShorthandOptions< HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body > { method: HTTPMethod | HTTPMethod[] url: string handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body> } ``` ## Your Environment - *node version*: 10 - *fastify version*: 2.4.1 - *os*: Mac

https://github.com/fastify/fastify/issues/1667

https://github.com/fastify/fastify/pull/1669

712337d6be084b8fc6dca88923eb9cbe6c205b13

1958c74a2bc2e96d3892254904f485985bc57330

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

[".npmignore"]

Git folder was included in v2.4.0

Hi! In v2.4.0 NPM package `.git` folder was included and this can cause 2 issue - Security issue (may be?) - Installation fails (after installing fastify v2.4.0) You can see direct NPM folder online at [here](https://unpkg.com/[email protected]/) Have a nice day!

https://github.com/fastify/fastify/issues/1662

https://github.com/fastify/fastify/pull/1663

a6fa039939ee9f9317f9ef7739f265e45f2427b2

5d442c54970797a985eaad981abca2342eae23f9

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

[".npmignore", ".travis.yml", "README.md", "docs/LTS.md"]

Remove Travis CI from next branch

As title says. I think the azure-pipelines CI is much better than Travis; I see no reason to continue using the service going forward.

https://github.com/fastify/fastify/issues/1658

https://github.com/fastify/fastify/pull/1670

05ed74244d6050aaa87a615df7e9c6f8506e20df

98658080df2d1d26b45d8752958399d2eac48707

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["fastify.js", "test/route-hooks.test.js"]

Make logs (errors, warnings) useful

Before you submit an issue we recommend you drop into the [Gitter community](https://gitter.im/fastify) or [Fastify Help](https://github.com/fastify/help) and ask any questions you have or mention any problems you've had getting started with Fastify. **Please read this entire template before posting any issue. If you ignore these instructions and post an issue here that does not follow the instructions, your issue might be closed, locked, and assigned the `missing discussion` label.** ## 🐛 Bug Report A clear and concise description of what the bug is. Logs aren't useful, especially for beginners. ## To Reproduce Steps to reproduce the behavior: Use fastify as backend with some plugins. My log: ```sh [Server]: Warning: The route option `beforeHandler` has been deprecated, use `preHandler` instead at beforeHandlerWarning (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/fastify/lib/warnings.js611) at Object.afterRouteAdded (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/fastify/fastify.js4909) at /Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/fastify/fastify.js42729 at Object.encapsulateThreeParam (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/nodemodules/avvio/boot.js4197) at Boot.callWithCbOrNextTick (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/avvio/boot.js3415) at Boot.after (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/nodemodules/avvio/boot.js23226) at Plugin.exec (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/avvio/plugin.js8917) at Boot.loadPlugin (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/avvio/plugin.js17510) at Task.release (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/fastq/queue.js12716) at worked (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/fastq/queue.js16910) at /Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/avvio/plugin.js1787 at done (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/avvio/plugin.js1365) at check (/Users/dalisoft/Desktop/Dev Env from null/fastifydevenv/node_modules/avvio/plugin.js1477) at processTicksAndRejections (internal/process/task_queues.js829) ``` ## Expected behavior A clear and concise description of what you expected to happen. Logs should show which plugin or where warning/error happened. ## Your Environment - *node version*: 12 - *fastify version*: >=2.0.0 - *os*: Mac - [repository](https://github.com/dalisoft/fastify-dev-env)

https://github.com/fastify/fastify/issues/1656

https://github.com/fastify/fastify/pull/1657

dd059016134f97fa8b8509e373dbc0b8194455a4

1f3c0de979ed8e6edf2e30c9a8594d85d4299ee9

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["package.json"]

An in-range update of flatstr is breaking the build 🚨

## The dependency [flatstr](https://github.com/davidmarkclements/flatstr) was updated from `1.0.11` to `1.0.12`. 🚨 [View failing branch](https://github.com/fastify/fastify/compare/master...fastify:greenkeeper%2Fflatstr-1.0.12). This version is **covered** by your **current version range** and after updating it in your project **the build failed**. flatstr is a direct dependency of this project, and **it is very likely causing it to break**. If other packages depend on yours, this update is probably also breaking those in turn. <details> <summary>Status Details</summary> - ✅ **continuous-integration/travis-ci/push:** The Travis CI build passed ([Details](https://travis-ci.org/fastify/fastify/builds/533373028?utm_source=github_status&utm_medium=notification)). - ✅ **coverage/coveralls:** First build on greenkeeper/flatstr-1.0.12 at 99.355% ([Details](https://coveralls.io/builds/23431007)). - ❌ **fastify.fastify:** [7 errors / 6 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Windows_yarn node_8_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Windows_yarn node_10_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Windows_yarn node_11_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ❌ **fastify.fastify (Windows_yarn node_12_x):** [1 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOS_yarn node_8_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOS_yarn node_10_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOS_yarn node_11_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOs_npm node_6_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOS_yarn node_12_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOs_npm node_8_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Linux_Yarn node_8_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOs_npm node_10_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Linux_Yarn node_10_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOs_npm node_11_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (macOs_npm node_12_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Linux_Yarn node_11_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Linux_Yarn node_12_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Windows_NPM node_6_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ❌ **fastify.fastify (Linux_npm node_6_x):** [2 errors / 2 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Windows_NPM node_8_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Linux_npm node_8_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Windows_NPM node_10_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ❌ **fastify.fastify (Linux_npm node_10_x):** [2 errors / 2 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ❌ **fastify.fastify (Linux_npm node_11_x):** [2 errors / 2 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Windows_NPM node_11_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Linux_npm node_12_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) - ✅ **fastify.fastify (Windows_NPM node_12_x):** [0 errors / 0 warnings](https://dev.azure.com/fastify/16bca441-2e2c-4036-b359-402bd9231591/_build/results?buildId=1596) </details> --- <details> <summary>Commits</summary> <p>The new version differs by 3 commits.</p> <ul> <li><a href="https://urls.greenkeeper.io/davidmarkclements/flatstr/commit/94d5343a6197cdedf90fe7fbcf6dff2b80e0d550"><code>94d5343</code></a> <code>1.0.12</code></li> <li><a href="https://urls.greenkeeper.io/davidmarkclements/flatstr/commit/543c4513bbd490a9eb2b797419f1fd4240adb190"><code>543c451</code></a> <code>found a new flattenning method which is faster than the current solution</code></li> <li><a href="https://urls.greenkeeper.io/davidmarkclements/flatstr/commit/869e4a3caa05faf494015e3afe4e18c0dc8b217c"><code>869e4a3</code></a> <code>win support for benchmarks</code></li> </ul> <p>See the <a href="https://urls.greenkeeper.io/davidmarkclements/flatstr/compare/1b63eebba9e88c7d21d1643055e22aa830b3e12b...94d5343a6197cdedf90fe7fbcf6dff2b80e0d550">full diff</a></p> </details> <details> <summary>FAQ and help</summary> There is a collection of [frequently asked questions](https://greenkeeper.io/faq.html). If those don’t help, you can always [ask the humans behind Greenkeeper](https://github.com/greenkeeperio/greenkeeper/issues/new). </details> --- Your [Greenkeeper](https://greenkeeper.io) Bot :palm_tree:

https://github.com/fastify/fastify/issues/1652

https://github.com/fastify/fastify/pull/1653

f627bbf5b35bfb9f5d91f8d3a83275f1f437e616

6e4e662bc51c8e5dd5aa960efb8575e183fd7e6a

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["package.json"]

Cannot access with ip

`localhost:8080` can work but `[ipv4]:8080`. Express.js can work properly.

https://github.com/fastify/fastify/issues/1620

https://github.com/fastify/fastify/pull/4581

c6a40ebe3ec9aaa2886d8ba7646fea88559412f6

2e9526e6245421570a5ef54d3676421f617dc4d7

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Reply.md"]

set status code to 302 on res.redirect by default.

## 🚀 Feature Proposal Right now fastify `redirect` method set the status code only to `302` when it's not set before. I would like to have this changed and make it act like `express` does. What express does is: set the status code to `302` when `redirect` is called. You can still sent an other code by providing it in the redirect like so: `res.redirect(404, '/login')`. ## Motivation Right now I'm using the [nestjs](https://github.com/nestjs/nest) framework. Nest currently supports multiple routing libraries such as `express` and `fastify`. `nestjs` is setting the http status code default to `200` or `201` depending on the type of request (`GET`, `POST`). When I'm redirecting the request with `redirect` it returns it with a status of `200` instead of `302` this forms an issue because the browser won't redirect. I hope we could change `fastify` to set the status to `302` by default when `redirect` is called. You could still sent a custom code by putting it like: `res.redirect(404, '/not-found')`.

https://github.com/fastify/fastify/issues/1592

https://github.com/fastify/fastify/pull/2121

a378dd583dfc2ae0f705e09b449aa6a636c639b2

350f00b6bf508b40c1f6bb5fa1a9e81b1b09ef3a

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Hooks.md", "fastify.js", "lib/fourOhFour.js", "lib/hooks.js", "lib/route.js", "test/hooks-async.test.js"]

Enable to set all hooks (including .use middlewares) in route()

## 🚀 Feature Proposal Currently we do not expose an API to add `onRequest` and route specific middlewares, however our codebase can definitely support them. Adding them would ensure an higher level of flexibility combined with the new `onRoute`  hook. Missing things: * [x] `onRequest` - done in https://github.com/fastify/fastify/pull/1594 * [ ] `onSend` * [ ] `onError` * [x] `onResponse` * [ ] middlewares ## Example Please provide an example for how this feature would be used. ```js app.route({ method: 'GET', async onRoute (req, reply) { }, middlewares: [function (req, res, next) { next() }] }, async (req, reply) => {}) ```

https://github.com/fastify/fastify/issues/1587

https://github.com/fastify/fastify/pull/2005

f47b3d2e174d71c2443c9425cb3eddf7f63815fb

747311e820b2c964b2d01dadbcba425617787065

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/initialConfigValidation.js", "test/internals/initialConfig.test.js"]

Azure Pipeline Failing

## 💥 Regression Report Branch master Azure says: > should be equal Error: should be equal at Test.t (test/internals/initialConfig.test.js:154:7) at loop (node_modules/function-loop/index.js:46:15) Travis agree but says more: > test/internals/initialConfig.test.js ................ 58/59 Return an error if options do not match the validation schema not ok should be equal --- wanted +++ found -FST_ERR_INIT_OPTS_INVALID: Invalid initialization options: 'should be boolean' +FST_ERR_INIT_OPTS_INVALID: Invalid initialization options: '[ 'should be boolean' ]' I clean the dep in my local environment and I replicated the error. npm outdated before reinstalling fastify: there wasn't the issue ``` Package Current Wanted Latest Location @types/node 11.10.4 11.12.0 11.12.0 fastify @typescript-eslint/eslint-plugin 1.4.2 1.5.0 1.5.0 fastify @typescript-eslint/parser 1.4.2 1.5.0 1.5.0 fastify autocannon 3.2.0 3.2.1 3.2.1 fastify avvio 6.1.1 6.2.1 6.2.1 fastify fast-json-stringify 1.11.3 1.12.0 1.12.0 fastify fluent-schema 0.6.1 0.6.2 0.7.0 fastify helmet 3.15.1 3.16.0 3.16.0 fastify hsts 2.1.0 2.2.0 2.2.0 fastify ienoopen 1.0.0 1.1.0 1.1.0 fastify joi 12.0.0 12.0.0 14.3.1 fastify pino 5.11.1 5.12.0 5.12.0 fastify split2 3.1.0 3.1.1 3.1.1 fastify tap 12.5.3 12.6.1 12.6.1 fastify tap-mocha-reporter 3.0.9 3.0.9 4.0.1 fastify typescript 3.3.3333 3.3.4000 3.3.4000 fastify ``` npm outdated after the reinstall (and the error show up): ``` Package Current Wanted Latest Location fluent-schema 0.6.2 0.6.2 0.7.0 fastify joi 12.0.0 12.0.0 14.3.1 fastify tap-mocha-reporter 3.0.9 3.0.9 4.0.1 fastify ``` I will check deeply late today if someone can't work on it sooner than me

https://github.com/fastify/fastify/issues/1560

https://github.com/fastify/fastify/pull/1561

9ee4ecda4f953376fa3143d46bf3ab1d6da8acb1

fc388633f6e1f5e250f06ee41bcfa0650c10ccdd

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["lib/schemas.js", "test/shared-schemas.test.js"]

Server.close() mutates used shared schemas

## 🐛 Bug Report I've encountered this super weird bug. It seems that if you use a shared schema in an endpoint schema, then shut down the server, the shared schema will get mutated somehow :man_shrugging: ## To Reproduce ```js const t = require("tap"); const fastify = require("fastify"); const sharedSchema = { $id: "schema", type: "object", properties: { message: { type: "string" } } }; const endpointSchema = { response: { "2xx": "schema#" // not referencing the shared schema does resolve the issue } }; const setup = () => { const server = fastify(); server.addSchema(sharedSchema); server.get("/", { schema: endpointSchema }, async (request, reply) => { reply.send(); }); return server; }; t.test("$id", async t => { const server = await setup(); t.ok(sharedSchema.$id); // passes await server.close(); t.ok(sharedSchema.$id); // fails }); ``` I need to admit that it took a while to find out what causes the issue. This is a complete mystery to me. Why does this happen? ## Expected behavior I expected the schemas not to be mutated because... who on earth would expect that? :smile: I see that most examples in the docs imply creating the schema explicitly in the parameter (not storing it in a variable), but as I'm starting to have a bunch of shared schemas I'd rather move them to separate files for less code clutter. ## Your Environment - *node version*: v10.15.1 - *fastify version*: 1.14.1 - *os*: Linux

https://github.com/fastify/fastify/issues/1553

https://github.com/fastify/fastify/pull/1565

d98629b36b5dedfaa9385c99f9c913f2fe6ad944

5de74406dbff5cba90516f6c9f499ea9d5e70e1b

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Logging.md", "docs/Request.md", "lib/context.js", "lib/logger.js", "lib/reply.js", "lib/request.js", "lib/route.js", "test/internals/handleRequest.test.js"]

Logger: serialize Fastify objects instead of Node.js

Since Fastify v2 we can access our `Request` and `Reply` objects anywhere, it could be a useful enhancement *(unfortunately it is a breaking change)* update our logger serializers to handle our objects instead of Node.js core ones. Thoughts? Related: https://github.com/fastify/fastify/issues/1548 /cc @fastify/fastify

https://github.com/fastify/fastify/issues/1551

https://github.com/fastify/fastify/pull/2017

94bcf373cf5ff05fda5dddfb31b480b6e2f7d7ca

8f210861cfe8f49c601ae57605933bf6851c648e

javascript

closed

fastify/fastify

https://github.com/fastify/fastify

["docs/Server.md"]

Update Server#logger to discuss custom logger option

The [Server#logger](https://www.fastify.io/docs/latest/Server/#logger) doc section lists 3 options for the logger server option. I believe the `pinoInstance` option should be expanded (or a new, 4th option should be added) to tell the user they can define or use their own custom logger as long as it follows the rules set forth by our code (I believe it needs a certain list of methods and an optional serializer list for `req`, `res`, and `err`).

https://github.com/fastify/fastify/issues/1542

https://github.com/fastify/fastify/pull/1577

c79d90e3a9762723509f25955649580e80eb5b68

62dc95651f2725a14ead5805d48af4594570fc5c

javascript