Fastify middleware - access to query and params?

Question

trying to get middleware working in Fastify - I don't seem to have access to the query or params. The docs say:

Fastify supports out of the box Express/Restify/Connect middlewares, this means that you can just drop-in your old code and it will work! (faster, by the way)

But with a simple example:

fastify.use(function(req, res, next) {
  console.log('req.query', req.query);   // undefined
  console.log('req.params', req.params); // undefined
  next();
});

Same if I add/restrict the url:

fastify.use('/foo', function(req, res, next) {

I'm sure I am missing something, but the docs do claim it 'just works' - which I can't see how if you don't get access to the qs?

[I think I can re-write to use hooks, but I'm really interested in how I am meant to be doing this with middleware]

Thanks

mattcan · Answer 1 · 2020-09-01T22:52:58.003

This was answered when Fastify 2 was the main version. This answer may not be correct for Fastify 3

While Fastify is compatible with Express/Restify method signature, it isn't exactly the same values being passed in. The method signature is:

/**
 * Generic middleware method
 * @param {http.IncomingMessage} req
 * @param {http.ServerResponse} res
*/
const middleware = (req, res) => {
}

fastify.use(middleware)

When using .use, Fastify only deals with the Node.js HTTP classes which do not provide the .params or .query fields.

Express adds these fields as a nicety to developers. If the middleware you use relies on those features, unfortunately, it will not be a direct drop in.

All is not lost

If you choose to migrate your middleware to Fastify, the .params and .query fields are available on the Request object.

Using the middleware in your question, this is what the Fastify version would look like.

fastify.addHook('onRequest', function(request, reply, done) {
  console.log('query', request.query);
  console.log('params', request.params);

  done();
})

Fastify is asking developers to think more in terms of Hooks and less in terms of Middleware. This provides more flexibility and greater speed but can be a little more complicated to write at times.

Additional reading

The Lifecycle and Hooks documentation on the Fastify site give more detail on how these pieces work together.

The Middleware documentation provides more detail on what features are supported.

Somewhat related, using Plugins you are able to scope to a particular path.

References

Express middleware support

From the Middleware documentation:

Furthermore, methods added by Express and Restify to the enhanced versions of req and res are not supported in Fastify middlewares.

and

Express modifies the prototype of the node core Request and Response objects heavily so Fastify cannot guarantee full middleware compatibility.

Express adding `.params` and `.query`

Express adding .query to request and where Express runs the query middleware

Express adding parameters to route.

score 1 · Answer 2 · answered Aug 27 '19 at 14:55

The .use() function is only a utility to help users to migrate from Express to Fastify. The input function interface is (req, res, next) but the req and res object are the standard Node.js objects http.ClientRequest and http.ServerResponse (that is the same interface of Express middleware). So the assumption is that the users have implemented middleware for Express using the standard Node.js's objects.

To archive your needs you should parse the req.url as described here. The .use API will be deprecated in Fastify v3.

Instead, if you want to start developing with Fastify you should migrate to .register. The register is the great feature of Fastify that offer encapsulation

score 0 · Answer 3 · answered Aug 25 '19 at 12:32

0

I Fastify use method is used for registering middlewares. The middleware is a function with the following signature middleware(err, req, res, next) Try:

fastify.use(function(err, req, res, next) {
    console.log('req.query', req.query);   // undefined
    console.log('req.params', req.params);
    next();
});

answered Aug 25 '19 at 12:32

dima golovin

262
2
8

I don't think this is it... run your example and not only are both still undefined, you also get an TypeError (next is not a function) If you keep it like my example, you can get req.url or req.method - just not the params or query – Calv J Aug 25 '19 at 13:31
Sorry for misleading you. Use is indeed used for registering middlewares, but it appears that Fastify middleware need to be a function like (fastify, options, next) => {} You cannot use the 'use' function to register routes and access request and response objects. you can check more here: https://www.fastify.io/docs/latest/Server/#use – dima golovin Aug 25 '19 at 14:09
Thanks for your reply - I'm still not getting it - could you post an update to my simple fn above which is how a middleware should be? It just does not look like a "drop in" to me, but a refactor? – Calv J Aug 25 '19 at 14:37

score 0 · Answer 4 · answered Oct 17 '19 at 07:20

You can use fastify without .use method , just use fastify.route.

 fastify.route({
  method: 'GET',
  url: '/',
  schema: {
    // request needs to have a querystring with a `name` parameter
    querystring: {
      name: { type: 'string' }
    }
  },
  handler: async (request, reply) => {
 // here you will get request.query if your schema validate
  }
})