Migrating to serverless Node.js functions or creating new ones can mean that some of the tools and frameworks you used previously are not suitable anymore.

With today's feature release, we want to solve this problem by providing you with a set of default helpers exposed within your Node.js function.

The recent update to serverless Node.js functions on Vercel introduces six default methods to the request and response payload:

request.query

request.cookies

request.body

response.status()

response.json()

response.send()

In order to access any of these methods, no changes are required on your side.

gain in performance when compared to a basic With the introduction of helpers, your application receives awhen compared to a basic Express.js application:

Vercel with Helpers Express.js Average

Response Time 0.50ms 0.60ms On average, requests are now served 18% faster than with Express

NOTE: The benchmarks above are used to showcase the performance difference between serverless Node.js functions on Vercel and the The benchmarks above are used to showcase the performance difference between serverless Node.js functions on Vercel and the Express.js framework.

While the relative improvement will stay the same, the actual time taken will vary depending on your system configuration.

These are the properties and methods that are available on the request and response arguments that your serverless function receives:

Before this update, the easiest way to parse the GET parameters of an incoming GET request was to retrieve the request.url property and then pass the value to a parser.

With request.query , however, you have direct access to all the GET parameters, without having to parse them on your own:

module . exports = ( request , response ) => { console . log ( request . query ) ; } ;

For example, if your endpoint's URL is /endpoint?key=value , the content of request.query would look like this:

{ "key" : "value" }

previously had to retrieve the Set-Cookie In order to access the cookies supplied by an incoming request, youhad to retrieve the header from the request and then parse it manually.

With request.cookies , you only need to invoke a property:

module . exports = ( request , response ) => { console . log ( request . cookies ) ; } ;

Doing so will give you all the cookies in a single object:

{ "cookie1" : "i am a cookie" , "cookie" : "i am yet another cookie" }

As the most versatile property out of all mentioned above, request.body allows you to easily access the body of incoming requests, no matter what format:

module . exports = ( request , response ) => { console . log ( request . body ) ; } ;

Naturally, the body for incoming requests to serverless functions can be either:

A string of text ( text/plain )

) A buffer ( application/octet-stream )

) A json object ( application/json )

) A form data query string ( application/x-www-form-urlencoded )

No matter which of those formats you are using for your body, accessing request.body will automatically parse it and return it.

For example, this is what the body would look like for a JSON request:

{ "firstKey" : "example value" , "secondKey" : "another example value" }

response.send() and response.json() in order to define a This method for outgoing responses can be invoked beforeandin order to define a status code for the response.

If you were to return an access error, for example, you could do it like this:

module . exports = ( request , response ) => { response . status ( 403 ) ; response . json ( { error : 'You do not have access' } ) ; } ;

As you can see in the example above, the response.json() method can be invoked with a JSON object as the first (and only) argument. It will then stringify the JSON it receives and send it back to the client:

module . exports = ( request , response ) => { response . json ( { property : 'value' } ) ; } ;

When invoked, the method will automatically set the Content-Type header of the outgoing response to application/json , in order for the client to understand that JSON was sent.

This method – just like response.json() – allows you to define the body of the outgoing response. However, it is used for sending plain text or buffers :

module . exports = ( request , response ) => { const example = Buffer . from ( 'Welcome!' ) ; response . send ( example ) ; } ;

Assuming you are using the latest version of Vercel, there is no action to be taken: Edit one of your serverless Node.js functions and start using the helpers.

the list of helpers will grow. So In the future,. So stay tuned

We also recommend checking out: