book

Node.js Design Patterns - Third Edition

by Mario Casciaro, Luciano Mammino

July 2020

Intermediate to advanced

664 pages

15h 24m

English

Packt Publishing

Read now

Unlock full access

What you need for this bookWho this book is forWhat this book coversTo get the most out of this bookGet in touch
The Node.js philosophySmall coreSmall modulesSmall surface areaSimplicity and pragmatismHow Node.js worksI/O is slowBlocking I/ONon-blocking I/OEvent demultiplexingThe reactor patternLibuv, the I/O engine of Node.jsThe recipe for Node.jsJavaScript in Node.jsRun the latest JavaScript with confidenceThe module systemFull access to operating system servicesRunning native codeSummary
The need for modulesModule systems in JavaScript and Node.jsThe module system and its patternsThe revealing module patternCommonJS modulesA homemade module loaderDefining a modulemodule.exports versus exportsThe require function is synchronousThe resolving algorithmThe module cacheCircular dependenciesModule definition patternsNamed exportsExporting a functionExporting a classExporting an instanceModifying other modules or the global scopeESM: ECMAScript modulesUsing ESM in Node.jsNamed exports and importsDefault exports and importsMixed exportsModule identifiersAsync importsModule loading in depthLoading phasesRead-only live bindingsCircular dependency resolutionModifying other modulesESM and CommonJS differences and interoperabilityESM runs in strict modeMissing references in ESMInteroperabilitySummary
The Callback patternThe continuation-passing styleSynchronous CPSAsynchronous CPSNon-CPS callbacksSynchronous or asynchronous?An unpredictable functionUnleashing ZalgoUsing synchronous APIsGuaranteeing asynchronicity with deferred executionNode.js callback conventionsThe callback comes lastAny error always comes firstPropagating errorsUncaught exceptionsThe Observer patternThe EventEmitterCreating and using the EventEmitterPropagating errorsMaking any object observableEventEmitter and memory leaksSynchronous and asynchronous eventsEventEmitter versus callbacksCombining callbacks and eventsSummaryExercises
The difficulties of asynchronous programmingCreating a simple web spiderCallback hellCallback best practices and control flow patternsCallback disciplineApplying the callback disciplineSequential executionExecuting a known set of tasks in sequenceSequential iterationParallel executionWeb spider version 3The patternFixing race conditions with concurrent tasksLimited parallel executionLimiting concurrencyGlobally limiting concurrencyThe async librarySummaryExercises
PromisesWhat is a promise?Promises/A+ and thenablesThe promise APICreating a promisePromisificationSequential execution and iterationParallel executionLimited parallel executionImplementing the TaskQueue class with promisesUpdating the web spiderAsync/awaitAsync functions and the await expressionError handling with async/awaitA unified try...catch experienceThe "return" versus "return await" trapSequential execution and iterationAntipattern – using async/await with Array.forEach for serial executionParallel executionLimited parallel executionThe problem with infinite recursive promise resolution chainsSummaryExercises
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 parallel executionImplementing an unordered parallel streamImplementing a URL status monitoring applicationUnordered limited parallel executionOrdered parallel executionPiping patternsCombining streamsImplementing a combined streamForking streamsImplementing a multiple checksum generatorMerging streamsMerging text filesMultiplexing and demultiplexingBuilding a remote loggerMultiplexing and demultiplexing object streamsSummaryExercises
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
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 augmentationDecorating with the Proxy objectDecorating a LevelUP databaseIntroducing LevelUP and LevelDBImplementing a LevelUP pluginIn the wildThe line between proxy and decoratorAdapterUsing LevelUP through the filesystem APIIn the wildSummaryExercises
StrategyMulti-format configuration objectsIn the wildStateImplementing a basic failsafe socketTemplateA configuration manager templateIn the wildIteratorThe iterator protocolThe iterable protocolIterators and iterables as a native JavaScript interfaceGeneratorsGenerators in theoryA simple generator functionControlling a generator iteratorHow to use generators in place of iteratorsAsync iteratorsAsync generatorsAsync iterators and Node.js streamsIn 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 commandSummaryExercises

Sharing code with the browserJavaScript modules in a cross-platform contextModule bundlersHow a module bundler worksUsing webpackFundamentals of cross-platform developmentRuntime code branchingChallenges of runtime code branchingBuild-time code branchingModule swappingDesign patterns for cross-platform developmentA brief introduction to ReactHello ReactAlternatives to react.createElementStateful componentsCreating a Universal JavaScript appFrontend-only appServer-side renderingAsynchronous data retrievalUniversal data retrievalTwo-pass renderingAsync pagesImplementing async pagesSummaryExercises
Dealing with asynchronously initialized componentsThe issue with asynchronously initialized componentsLocal initialization checkDelayed startupPre-initialization queuesIn the wildAsynchronous request batching and cachingWhat's asynchronous request batching?Optimal asynchronous request cachingAn API server without caching or batchingBatching and caching with promisesBatching requests in the total sales web serverCaching requests in the total sales web serverNotes about implementing caching mechanismsCanceling asynchronous operationsA basic recipe for creating cancelable functionsWrapping asynchronous invocationsCancelable async functions with generatorsRunning 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
An introduction to application scalingScaling Node.js applicationsThe three dimensions of scalabilityCloning 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 balancer with http-proxy and ConsulPeer-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
Fundamentals of a messaging systemOne way versus request/reply patternsMessage typesCommand MessagesEvent MessagesDocument MessagesAsynchronous 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 Fanout/Fanin 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

Content preview from Node.js Design Patterns - Third Edition

3 Callbacks and Events

In synchronous programming, we conceptualize code as a series of consecutive computing steps that solve a specific problem. Every operation is blocking, which means that only when an operation is completed, it is possible to execute the next one. This approach makes the code very easy to read, understand, and debug.

On the other side, in asynchronous programming, some operations, such as reading from a file or performing a network request, are launched and then executed "in the background." When we invoke an asynchronous operation, the instruction that follows is executed immediately, even if the previous asynchronous operation has not finished yet. In this scenario, we need a way to get notified when an asynchronous operation ...