Building Backend Applications with Fastify: Serialization & Error Handling
Written on
Chapter 1 Understanding Fastify
Fastify is a lightweight Node.js framework designed for creating back-end web applications. In this article, we will explore how to utilize Fastify for developing back-end services, particularly focusing on response serialization and error handling.
Section 1.1 Response Serialization
One of the key features of Fastify is the ability to customize the serialization of responses. Here’s how you can achieve this:
const fastify = require('fastify')({})
const schema = {
response: {
'2xx': {
type: 'object',
properties: {
value: { type: 'string' },
otherValue: { type: 'boolean' }
}
},
201: {
value: { type: 'string' }}
}
}
fastify.get('/', { schema }, (request, reply) => {
reply.send({ value: 1, otherValue: 'foo' })
})
const start = async () => {
try {
await fastify.listen(3000, '0.0.0.0')} catch (err) {
fastify.log.error(err)
process.exit(1)
}
}
start()
In this example, we define a response schema through the schema.response property. This allows us to specify the structure and data types of the response for various HTTP status codes. The type defines the data type, while properties outlines the specific types for each property.
When you send a GET request to /, the response will be automatically formatted according to the schema, resulting in:
{"value":"1","otherValue":true}
Section 1.2 Custom Response Schema
You can also define the response schema directly in the request handler. Here’s how:
const fastify = require('fastify')({})
fastify.setSerializerCompiler(({ schema, method, url, httpStatus }) => {
return data => JSON.stringify(data)
})
fastify.get('/', {
handler (req, reply) {
reply.send({ id: 1, name: 'Foo', image: 'BIG IMAGE' })},
schema: {
response: {
'2xx': {
id: { type: 'number' },
name: { type: 'string' }
}
}
}
})
const start = async () => {
try {
await fastify.listen(3000, '0.0.0.0')} catch (err) {
fastify.log.error(err)
process.exit(1)
}
}
start()
In this code snippet, we utilize fastify.setSerializerCompiler to compile the response. Additionally, we include the schema within the fastify.get method to define the response format.
Chapter 2 Error Handling in Fastify
Error handling is another crucial aspect of developing applications with Fastify. You can customize how validation errors are managed with the following setup:
const fastify = require('fastify')({})
const schema = {
body: {
type: 'object',
properties: {
name: { type: 'string' }},
required: ['name']
}
}
fastify.post('/', { schema, attachValidation: true }, function (req, reply) {
if (req.validationError) {
reply.code(400).send(req.validationError)}
else {
reply.send('success')}
})
const start = async () => {
try {
await fastify.listen(3000, '0.0.0.0')} catch (err) {
fastify.log.error(err)
process.exit(1)
}
}
start()
In this example, we define a validation schema for the request body. By setting attachValidation to true in the fastify.post method, we can check for validation errors using the req.validationError property. If there are errors, we can return a 400 status code along with the error details.
Conclusion
Fastify provides powerful tools for customizing response serialization and error handling in your back-end applications. By leveraging these features, you can create robust and efficient web services.