Mastering Server-Side Development with Fastify: Response Techniques
Written on
Chapter 1: Introduction to Fastify
Fastify is a lightweight framework designed for creating backend web applications in Node.js. In this article, we'll explore how to manage responses effectively when developing with Fastify.
Section 1.1: Sending String Responses
To send a simple string response, you can utilize the reply.send method. Here’s an example:
const fastify = require('fastify')({});
fastify.get('/', function(req, reply) {
reply.send('plain string');
});
const start = async () => {
try {
await fastify.listen(3000, '0.0.0.0');} catch (err) {
fastify.log.error(err);
process.exit(1);
}
};
start();
Section 1.2: Stream Responses
Fastify also allows you to send stream responses. For example:
const fastify = require('fastify')({});
fastify.get('/', function(req, reply) {
const fs = require('fs');
const stream = fs.createReadStream('some-file', 'utf8');
reply.send(stream);
});
const start = async () => {
try {
await fastify.listen(3000, '0.0.0.0');} catch (err) {
fastify.log.error(err);
process.exit(1);
}
};
start();
If the file some-file contains the text foo, that will be the output when accessing the root route.
Section 1.3: Buffer Responses
You can also send buffer responses using the fs.readFile method:
const fastify = require('fastify')({});
fastify.get('/', function(req, reply) {
fs.readFile('some-file', (err, fileBuffer) => {
reply.send(err || fileBuffer);});
});
const start = async () => {
try {
await fastify.listen(3000, '0.0.0.0');} catch (err) {
fastify.log.error(err);
process.exit(1);
}
};
start();
This code reads a file and responds with its content.
Section 1.4: Handling Errors
To manage errors, you can use the http-errors library. Here’s an example of how to send a 410 Gone status code:
const fastify = require('fastify')({});
const httpErrors = require('http-errors');
fastify.get('/', function(req, reply) {
reply.send(httpErrors.Gone());
});
const start = async () => {
try {
await fastify.listen(3000, '0.0.0.0');} catch (err) {
fastify.log.error(err);
process.exit(1);
}
};
start();
Additionally, you can set up a custom error handler to respond based on the error type:
fastify.setErrorHandler(function (error, request, reply) {
request.log.warn(error);
const statusCode = error.statusCode >= 400 ? error.statusCode : 500;
reply
.code(statusCode)
.type('text/plain')
.send(statusCode >= 500 ? 'Internal server error' : error.message);
});
Section 1.5: Custom Not Found Responses
To manage not found errors, you can create a custom handler:
fastify.setNotFoundHandler(function (request, reply) {
reply
.code(404)
.type('text/plain')
.send('a custom not found');
});
fastify.get('/', function(req, reply) {
reply.callNotFound();
});
This way, when a route isn’t found, the application responds with a custom message.
Chapter 2: Practical Application
In this section, we will delve deeper into using Fastify for building a RESTful API.
This video demonstrates how to build a RESTful API using Fastify, Prisma, and TypeScript.
In this video, we explore whether a Node.js server can handle one million concurrent requests, showcasing real-world app benchmarking on a dedicated VPS.
Conclusion
Fastify provides a robust framework for sending various types of HTTP responses. By understanding how to implement string, stream, buffer responses, and error handling, you can create more effective backend applications.