book

Accelerating Server-Side Development with Fastify

Name: Accelerating Server-Side Development with Fastify
ISBN: 9781800563582

by Manuel Spigolon, Maksim Sinik, Matteo Collina

June 2023

Intermediate to advanced

406 pages

9h 22m

English

Packt Publishing

Read now

Unlock full access

Accelerating Server-Side Development with Fastify
The Story of FastifyContributorsAbout the authorsAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchDownload a free PDF copy of this book
Part 1:Fastify Basics
Chapter 1: What Is Fastify?
Technical requirementsWhat is Fastify?Fastify’s componentsStarting your serverLifecycle and hooks overviewThe root application instanceAdding basic routesShorthand declarationThe handlerThe Reply componentThe first POST routeThe Request componentParametric routesAdding a basic plugin instanceUnderstanding configuration typesShutting down the applicationSummary
Chapter 2: The Plugin System and the Boot Process
Technical requirementsWhat is a plugin?Creating our first pluginThe alternative plugin function signatureExploring the options parameterThe options parameter typeThe prefix optionUnderstanding encapsulationHandling the contextfastify-pluginExploring the boot sequenceThe register instance methodThe after instance methodA declaration orderHandling boot and plugin errorsERR_AVVIO_PLUGIN_TIMEOUTRecovery from a boot errorSummary
Chapter 3: Working with Routes
Technical requirementsDeclaring API endpoints and managing the errorsDeclaration variantsThe route optionsBulk routes loadingSynchronous and asynchronous handlersReply is a PromiseHow to reply with errorsRouting to the endpointThe 404 handlerRouter application tuningRegistering the same URLsReading the client’s inputThe path parametersThe query stringThe headersThe bodyManaging the route’s scopeThe route server instancePrinting the routes treeAdding new behaviors to routesAccessing the route’s configurationAOPSummary
Chapter 4: Exploring Hooks
Technical requirementsWhat is a lifecycle?Declaring hooksUnderstanding the application lifecycleThe onRoute hookThe onRegister hookThe onReady hookThe onClose hookUnderstanding the request and reply lifecycleHandling errors inside hooksThe onRequest hookThe preParsing hookThe preValidation hookThe preHandler hookThe preSerialization hookThe onSend hookThe onResponse hookThe onError hookThe onTimeout hookReplying from a hookRoute-level hooksSummary
Chapter 5: Exploring Validation and Serialization
Technical requirementsUnderstanding validation and serializationThe JSON Schema specificationCompiling a JSON SchemaFastify’s compilersUnderstanding the validation processThe validator compilerValidation executionCustomizing the validator compilerFlow controlUnderstanding the Ajv configurationManaging the validator compilerConfiguring the default Ajv validator compilerThe validation errorReusing JSON schemasBuilding a new validator compilerCustomizing the schema validator compilerUnderstanding the serialization processThe reply serializerThe serializer compilerManaging the serializer compilerSummary
Part 2:Build a Real-World Project
Chapter 6: Project Structure and Configuration Management
Technical requirementsDesigning the application structureSetting up the repositoryUnderstanding the application structureImproving the application structureStarting an optimal projectManaging project directoriesLoading the configurationDebugging your applicationSharing the application configuration across pluginsUsing Fastify’s pluginsHow to get a project overviewHow to be reachableSummary

Chapter 7: Building a RESTful API
Technical requirementsApplication outlineDefining routesRegister routesData source and modelImplementing the routescreateTodolistTodoreadTodoupdateTododeleteTodochangeStatusSecuring the endpointsLoading route schemasSchemas loaderAdding the Autohooks pluginImplementing the Autohook pluginUsing the schemasDon’t repeat yourselfSummary
Chapter 8: Authentication, Authorization, and File Handling
Technical requirementsAuthentication and authorization flowBuilding the authentication layerAuthentication pluginAuthentication routesLogout routeAdding the authorization layerAdding the authentication layerUpdating the to-do data sourceManaging uploads and downloadsSummary
Chapter 9: Application Testing
Technical requirementsWriting good testsWhat tests need to be written?How to write tests?Testing the Fastify applicationInstalling the test frameworkCreating your node-tap cheatsheet testHow to write tests with Fastify?How to improve the developer experience?Dealing with complex testsReusing multiple requestsMocking the dataSpeeding up the test suiteRunning tests in parallelHow to manage shared resources?Where tests should runSummary
Chapter 10: Deployment and Process Monitoring for a Healthy Application
Technical requirementsTesting our Docker image with a local deploymentHosting our DB on MongoDB AtlasChoosing a cloud providerDeploying to Fly.ioSetting up continuous deploymentCollecting application process dataCollecting the application process data with PrometheusExploring the metrics with GrafanaSummary
Chapter 11: Meaningful Application Logging
Technical requirementsHow to use Fastify’s loggerHow Pino logs the application’s messagesCustomizing logging configurationEnhancing the default logger configurationHow to hide sensitive dataCollecting the logsHow to consolidate the logsConsolidating logs by using Pino transportsManaging distributed logsSummary
Part 3:Advanced Topics
Chapter 12: From a Monolith to Microservices
Technical requirementsImplementing API versioningVersion constraintsURL prefixesFilesystem-based routing prefixesSplitting the monolithCreating our v2 serviceBuilding the v1 service on top of v2Exposing our microservice via an API gatewaydocker-compose to emulate a production environmentNginx as an API gateway@fastify/http-proxy as an API gatewayImplementing distributed loggingSummary
Chapter 13: Performance Assessment and Improvement
Technical requirementsWhy measure performance?How to measure an application’s performance?Measuring the HTTP response timeInstrumenting the Fastify applicationVisualizing the tracing dataHow to analyze the dataCreating a flame graphHow to check memory issuesHow to identify I/O resourcesHow to optimize the applicationNode.js internals that you need to knowThe safety of parallel runningConnection management takeawaysSummary
Chapter 14: Developing a GraphQL API
Technical requirementsWhat is GraphQL?How does Fastify support GraphQL?Writing the GQL schemaDefining GQL operationsHow to make live a GQL schema?Starting the GQL serverImplementing our first GQL query resolverImplementing type object resolversHow to improve resolver performance?Managing GQL errorsSummary
Chapter 15: Type-Safe Fastify
Technical requirementsCreating the projectAdding the tsconfig.json fileAdding the application’s entry pointUsing Fastify type-providersGenerating the API documentationSummary
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youDownload a free PDF copy of this book

Content preview from Accelerating Server-Side Development with Fastify

Index

As this ebook edition doesn't have fixed pagination, the page numbers below are hyperlinked for reference only, based on the printed edition of this book.

Symbols

404 handler 72, 73

@fastify/autoload plugin 154

@fastify/http-proxy

as API gateway 297-299

--require argument

reference link 308

after instance method 52, 53

Ajv

configuration 127-130

reference link 123

API documentation

generating 360-362

API endpoints

asynchronous handlers 63, 64

bulk routes loading 62, 63

declaration variants 60

declaring 60

reply object 64

reply with errors 65-71

route options 61

synchronous handlers 63, 64 

API gateway

@fastify/http-proxy, using as 297-299

microservice, exposing via 294

Nginx as 295-297

API versioning

filesystem-based routing prefixes ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781800563582

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Accelerating Server-Side Development with Fastify

by Manuel Spigolon, Maksim Sinik, Matteo Collina

Index

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.