book

Node.js Design Patterns - Fourth Edition

Name: Node.js Design Patterns - Fourth Edition
ISBN: 9781803238944

by Luciano Mammino, Mario Casciaro

September 2025

Beginner

732 pages

19h 14m

English

Packt Publishing

Read now

Unlock full access

Foreword 1
Foreword 2ContributorsAbout the reviewersBeta readers
Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touchYour Book Comes with Exclusive Perks - Here’s How to Unlock ThemUnlock Your Book’s Exclusive BenefitsHow to unlock these benefits in three easy stepsStep 1Step 2Step 3Need help?
The Node.js Platform
The Node.js philosophySmall coreSmall modulesSmall surface areaSimplicity and pragmatismHow Node.js worksI/O is often the bottleneckBlocking I/ONon-blocking I/OEvent demultiplexingThe reactor patternlibuv, the I/O engine of Node.jsThe complete recipe for Node.jsJavaScript in Node.jsRun the latest JavaScript with confidenceThe module systemFull access to operating system servicesRunning native codeNode.js and TypeScriptUsing TypeScript with Node.jsThe @types/node packageSummary
The Module System
The need for modulesModule systems in JavaScript and Node.jsThe revealing module patternES modulesUsing ES modules in Node.jsThe ES module syntaxNamed exports and importsDefault exports and importsMixed exportsModule identifiersStatic and dynamic importsThe module resolution algorithmModule loading in depthLoading phasesRead-only live bindingsCircular dependenciesModules that modify other modulesHow monkey patching affects type safety in TypeScript projectsCommonJS modulesES modules and CommonJS—differences and interoperabilityStrict modeTop-level awaitBehavior of `this`Missing references in ES modulesImport interoperabilityImport CommonJS modules from ES modulesImport ES modules from CommonJSImporting JSON filesUsing modules in TypeScriptThe role of the TypeScript compilerConfiguring the module output formatInput module syntax and output emissionModule resolutionSummary
Callbacks and Events
The Callback patternThe continuation-passing styleSynchronous CPSAsynchronous CPSNon-CPS callbacksSynchronous or asynchronous?Writing an inconsistent functionUnleashing ZalgoUsing synchronous APIsGuaranteeing asynchronicity with deferred executionNode.js callback conventionsThe callback is the last argumentAny error always comes firstPropagating errorsAvoiding uncaught exceptionsThe Observer patternThe EventEmitterCreating and using the EventEmitterPropagating errorsMaking any object observableThe risk of memory leaksSynchronous and asynchronous eventsEventEmitter versus callbacksCombining callbacks and eventsSummaryExercises
Asynchronous Control Flow Patterns with Callbacks
The challenges of asynchronous programmingCreating a simple web spiderCallback hellCallback best practicesCallback disciplineApplying the callback disciplineControl flow patternsSequential executionExecuting a known set of tasks in sequenceSequential iterationConcurrent executionWeb spider version 3The patternFixing race conditions with concurrent tasksLimited concurrent executionLimiting concurrencyGlobally limiting concurrencySummaryExercises
Asynchronous Control Flow Patterns with Promises and Async/Await
PromisesWhat is a promise?Promises/A+ and thenablesThe promise APICreating a promisePromisificationSequential execution and iterationConcurrent executionLimited concurrent executionImplementing the TaskQueue class with promisesUpdating the web spiderLazy promisesAsync/awaitAsync functions and the await expressionTop-level awaitError handling with async/awaitA unified try...catch experienceThe “return” versus “return await” trapSequential execution and iterationAntipattern – using async/await with Array.forEach for serial executionConcurrent executionLimited concurrent executionThe problem with infinite recursive promise resolution chainsSummaryExercises
Coding with Streams
Discovering the importance of streamsBuffering versus streamingSpatial efficiencyGzipping using a buffered APIGzipping using streamsTime efficiencyComposabilityAdding client-side encryptionAdding server-side decryptionGetting started with streamsAnatomy of streamsReadable streamsReading from a streamImplementing Readable streamsWritable streamsWriting to a streamBackpressureImplementing Writable streamsDuplex streamsTransform streamsImplementing Transform streamsFiltering and aggregating data with Transform streamsPassThrough streamsObservabilityLate pipingLazy streamsConnecting streams using pipesPipes and error handlingBetter error handling with pipeline()Asynchronous control flow patterns with streamsSequential executionUnordered concurrent executionImplementing an unordered concurrent streamImplementing a URL status monitoring applicationUnordered limited concurrent executionOrdered concurrent executionPiping patternsCombining streamsImplementing a combined streamForking streamsImplementing a multiple checksum generatorMerging streamsMerging text filesMultiplexing and demultiplexingBuilding a remote loggerMultiplexing and demultiplexing object streamsReadable stream utilitiesMapping and transformationFiltering and iterationSearching and evaluationLimiting and reducingWeb StreamsConverting Node.js streams to Web StreamsConverting Web Streams to Node.js streamsStream consumer utilitiesSummaryExercises
Creational Design Patterns
FactoryDecoupling object creation and implementationA mechanism to enforce encapsulationBuilding a simple code profilerIn the wildBuilderImplementing a URL object builderIn the wildRevealing ConstructorBuilding an immutable bufferIn the wildSingletonWiring modulesSingleton dependenciesDependency InjectionSummaryExercises
Structural Design Patterns
ProxyTechniques for implementing proxiesObject compositionObject augmentationThe built-in Proxy objectA comparison of the different proxying techniquesCreating a logging Writable streamChange Observer with ProxyIn the wildDecoratorTechniques for implementing decoratorsCompositionObject decorationDecorating with the Proxy objectDecorating a Level databaseIntroducing Level and LevelDBImplementing a Level pluginIn the wildThe decorator proposal for ECMAScriptThe line between Proxy and DecoratorAdapterUsing Level through the filesystem APIIn the wildSummaryExercises

Behavioral Design Patterns
StrategyMulti-format configuration objectsIn the wildStateImplementing a basic failsafe socketIn the wildTemplateA configuration manager templateIn the wildIteratorThe iterator protocolThe iterable protocolIterators and iterables as a native JavaScript interfaceImplementing the iterable protocol on iteratorsIterator utilitiesGeneratorsGenerators in theoryA simple generator functionControlling a generator iteratorHow to use generators in place of iteratorsAsync iteratorsAsync generatorsAsync iterators and Node.js streamsAsync iterator utilitiesIn the wildMiddlewareMiddleware in ExpressMiddleware as a patternCreating a middleware framework for ZeroMQThe middleware managerImplementing the middleware to process messagesUsing the ZeroMQ middleware frameworkIn the wildCommandThe Task patternA more complex commandIn the wildSummaryExercises
Testing: Patterns and Best Practices
An introduction to software testingDefinitionsSystem under testArrange, Act, AssertCode coverageTest doubles: Stubs, spies, and mocksTest-driven developmentBehavior-driven developmentContinuous integrationContinuous delivery and continuous deploymentTypes of testsUnit testsIntegration testsEnd-to-end testsOther types of testsThe testing pyramidWriting tests with Node.jsOur first unit testThe Node.js test runnerOur first test with the Node.js test runnerOrganizing testsSubtestsSubtest concurrencyParametrized test casesTest suitesTest runner tips and tricksWatch modeTargeted test execution with custom glob patternsTest reportersCollecting code coverageUsing the test runner with TypeScriptWriting unit testsTesting asynchronous codeMockingCreating spies with mock.fn()Mocking HTTP requests with the built-in test mockMocking HTTP requests with UndiciMocking Node.js core modulesMocking other dependenciesProblems with mocking importsMocking imports versus dependency injectionWriting integration testsTesting with a local databaseTesting a web applicationSetting up the projectWriting E2E testsThe application structureHome pageSign-in and sign-up formsEvent PageMy reservationsThe user flowBrowser automationWriting an E2E test with PlaywrightSetting up a new Playwright projectUnderstanding the Playwright APIUnderstanding timeoutsTesting our user flowSummaryExercises
Advanced Recipes
Dealing with asynchronously initialized componentsThe issue with asynchronously initialized componentsLocal initialization checkDelayed startupPre-initialization queuesUsing the State patternIn the wildAsynchronous request batching and cachingWhat’s asynchronous request batching?Optimal asynchronous request cachingAn API server without caching or batchingBatching and caching with promisesBatching requestsBatching and caching requestsCanceling asynchronous operationsA basic recipe for creating cancelable functionsWrapping asynchronous invocationsCancelable async functions with AbortControllerRunning CPU-bound tasksSolving the subset sum problemInterleaving with setImmediateInterleaving the steps of the subset sum algorithmConsiderations on the interleaving approachUsing external processesDelegating the subset sum task to an external processConsiderations for the multi-process approachUsing worker threadsRunning the subset sum task in a worker threadRunning CPU-bound tasks in productionSummaryExercises
Scalability and Architectural Patterns
An introduction to application scalingScaling Node.js applicationsThe three dimensions of scalabilityX-axis: cloningY-axis: decomposing by service or functionalityZ-axis: splitting by data partitionCombining strategies across the scale cubeCloning and load balancingThe cluster moduleNotes on the behavior of the cluster moduleBuilding a simple HTTP serverScaling with the cluster moduleResiliency and availability with the cluster moduleZero-downtime restartDealing with stateful communicationsSharing the state across multiple instancesSticky load balancingScaling with a reverse proxyLoad balancing with NginxDynamic horizontal scalingUsing a service registryImplementing a dynamic load balancerPeer-to-peer load balancingImplementing an HTTP client that can balance requests across multiple serversScaling applications using containersWhat is a container?Creating and running a container with DockerWhat is Kubernetes?Deploying and scaling an application on KubernetesDecomposing complex applicationsMonolithic architectureThe microservice architectureAn example of a microservice architectureMicroservices: advantages and disadvantagesIntegration patterns in a microservice architectureThe API proxyAPI orchestrationIntegration with a message brokerSummaryExercises
Messaging and Integration Patterns
Fundamentals of a messaging systemOne way versus request/reply patternsMessage typesCommand messagesEvent messagesDocument messagesPush versus pull delivery semanticsPull delivery (consumer-initiated)Push delivery (producer-initiated)Choosing between pull and push deliveryAsynchronous messaging, queues, and streamsPeer-to-peer or broker-based messagingPublish/Subscribe patternBuilding a minimalist real-time chat applicationImplementing the server sideImplementing the client sideRunning and scaling the chat applicationUsing Redis as a simple message brokerPeer-to-peer Publish/Subscribe with ZeroMQIntroducing ZeroMQDesigning a peer-to-peer architecture for the chat serverUsing the ZeroMQ PUB/SUB socketsReliable message delivery with queuesIntroducing AMQPDurable subscribers with AMQP and RabbitMQReliable messaging with streamsCharacteristics of a streaming platformStreams versus message queuesImplementing the chat application using Redis streamsTask distribution patternsThe ZeroMQ fan-out/fan-in patternPUSH/PULL socketsBuilding a distributed hashsum cracker with ZeroMQPipelines and competing consumers in AMQPPoint-to-point communications and competing consumersImplementing the hashsum cracker using AMQPDistributing tasks with Redis streamsRedis consumer groupsImplementing the hashsum cracker using Redis streamsRequest/Reply patternsCorrelation IdentifierImplementing a request/reply abstraction using correlation identifiersReturn addressImplementing the Return Address pattern in AMQPSummaryExercises
Other Books You May Enjoy
Index

Content preview from Node.js Design Patterns - Fourth Edition

2 The Module System

In Chapter 1, The Node.js Platform, we briefly introduced the importance of modules in Node.js. We discussed how modules play a fundamental role in defining some of the pillars of the Node.js philosophy and its programming experience. However, what do we mean when we talk about modules and why are they so important?

In generic terms, modules are the bricks for structuring non-trivial applications. Modules allow you to divide the code base into small units that can be developed and tested independently. Modules are also the main mechanism to enforce information hiding by keeping all the functions and variables that are not explicitly marked to be exported private. Additionally, modules make it easier to share and reuse code ...

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: 9781803238944

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Node.js Design Patterns - Fourth Edition

by Luciano Mammino, Mario Casciaro

2

The Module System

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.