Professional Node.js

PART I: INTRODUCTION AND SETUP

CHAPTER 1: INSTALLING NODE 3

Installing Node on Windows 4

Installing on Mac OS X 5

Installing Node Using the Source Code 6

Choosing the Node Version 6

Downloading the Node Source Code 6

Building Node 7

Installing Node 7

Running Node 8

Setting Up and Using Node Package Manager 8

Using NPM to Install, Update, and Uninstall Packages 9

Summary 13

CHAPTER 2: INTRODUCING NODE 15

Introducing the Event-Driven Programming Style 16

How Node and JavaScript Make Writing Asynchronous Applications Easier 17

What Are Closures? 18

How Closures Help When Programming Asynchronously 19

Summary 19

PART II: NODE CORE API BASICS

CHAPTER 3: LOADING MODULES 23

Understanding How Node Loads Modules 24

Exporting a Module 24

Loading a Module 25

Summary 28

CHAPTER 4: USING BUFFERS TO MANIPULATE, ENCODE, AND DECODE BINARY DATA 29

Creating a Buffer 30

Getting and Setting Bytes in a Buffer 30

Slicing a Buffer 32

Copying a Buffer 32

Decoding a Buffer 32

Summary 33

CHAPTER 5: USING THE EVENT EMITTER PATTERN TO SIMPLIFY EVENT BINDING 35

Understanding the Standard Callback Pattern 36

Understanding the Event Emitter Pattern 36

Understanding Event Types 37

Using the Event Emitter API 38

Binding Callbacks Using .addListener() or .on() 38

Binding Multiple Event Listeners 39

Removing an Event Listener from an Event Emitter

Using .removeListener() 40

Getting a Callback Executed at Most Once Using .once() 40

Removing All Event Listeners from an Event Emitter Using .removeAllListeners() 41

Creating an Event Emitter 41

Inheriting from Node Event Emitter 42

Emitting Events 42

Summary 43

CHAPTER 6: SCHEDULING THE EXECUTION OF FUNCTIONS USING TIMERS 45

Using setTimeout to Defer the Execution of a Function 46

Using clearTimeout to Cancel the Execution of a Function 46

Scheduling and Canceling the Repetitive Execution of a Function 47

Using process.nextTick to Defer the Execution of a Function Until the Next Event Loop Iteration 47

Blocking the Event Loop 48

Escaping the Event Loop 49

Using setTimeout Instead of setInterval to Force Serialization 49

Summary 50

PART III: FILES, PROCESSES, STREAMS, AND NETWORKING

CHAPTER 7: QUERYING, READING FROM, AND WRITING TO FILES 53

Manipulating File Paths 54

Normalizing Paths 54

Joining Paths 54

Resolving Paths 55

Finding the Relative Path Between Two Absolute Paths 55

Extracting Components of a Path 55

Determining the Existence of a Path 56

Introducing the fs Module 57

Querying File Statistics 57

Opening a File 58

Reading from a File 59

Writing to a File 60

Closing a File 60

Summary 62

CHAPTER 8: CREATING AND CONTROLLING EXTERNAL PROCESSES 63

Executing External Commands 64

Spawning Child Processes 69

Creating the Child Process 69

Listening for Data from the Child Process 69

Sending Data to the Child Process 70

Receiving Notification When the Child Process Exits 72

Signaling and Killing Processes 73

Summary 74

CHAPTER 9: READING AND WRITING STREAMS OF DATA 75

Using a Readable Stream 76

Waiting for Data 76

Pausing and Resuming a Stream 77

Knowing When the Stream Ends 77

Using Writable Streams 77

Writing Data into a Stream 78

Waiting for a Stream to Drain 78

Considering Some Stream Examples 78

Creating File-System Streams 79

Understanding Networking Streams 80

Avoiding the Slow Client Problem and Saving Your Server 80

Understanding the Slow Client Problem 80

Avoiding the Slow Client Problem 81

Using stream.pipe() to Prevent the Slow Client Problem and Assembling Readable and Writable Streams Using pipe() 82

Summary 82

CHAPTER 10: BUILDING TCP SERVERS 83

Creating a TCP Server 83

Using the Socket Object 85

Understanding Idle Sockets 86

Setting Up Keep-Alive 87

Using Delay or No Delay 87

Listening for Client Connections 88

Closing the Server 88

Handling Errors 88

Building a Simple TCP Chat Server 89

Accepting Connections 89

Reading Data from a Connection 90

Collecting All the Clients 90

Broadcasting Data 91

Removing Closed Connections 92

Using Your TCP Chat Server 93

Summary 93

CHAPTER 11: BUILDING HTTP SERVERS 95

Understanding the http.ServerRequest Object 97

Understanding the http.ServerResponse Object 98

Writing a Header 98

Changing or Setting a Header 99

Removing a Header 99

Writing a Piece of the Response Body 99

Streaming HTTP Chunked Responses 99

Piping a File 100

Piping the Output of Another Process 100

Shutting Down the Server 101

Example 1: Building a Server that Serves Static Files 101

Example 2: Making Use of HTTP Chunked Responses and Timers 102

Summary 102

CHAPTER 12: BUILDING A TCP CLIENT 103

Connecting to a Server 104

Sending and Receiving Data 105

Ending the Connection 105

Handling Errors 106

Building an Example Command-Line TCP Client 106

Connecting to the Server 107

Sending the Command Line to the Server 107

Printing Server Messages 107

Reconnecting if the Connection Dies 108

Closing the Connection 109

Putting the Client Together 111

Summary 112

CHAPTER 13: MAKING HTTP REQUESTS 113

Making GET Requests 113

Using Other HTTP Verbs 114

Inspecting the Response Object 115

Obtaining the Response Body 116

Streaming the Response Body 116

Pooling Sockets Using http.Agent 116

Using a Third-Party Request Module to Simplify HTTP Requests 118

Installing and Using Request 118

Creating a Testing Server 120

Following Redirects 121

Setting Some Request Options 123

Encoding the Request Body 125

Streaming 127

Using a Cookie Jar 127

Summary 128

CHAPTER 14: USING DATAGRAMS (UDP) 129

Understanding UDP 129

Understanding the Uses of UDP 130

Building a Datagram Server 130

Listening for Messages 130

Testing the Server 131

Inspecting Additional Message Information 132

Creating a Simple Datagram Echo Server 132

Waiting for Messages 132

Sending Messages Back to Senders 132

Putting the Echo Server Together 133

Building a Datagram Client 134

Creating the Client 134

Sending Messages 134

Closing the Socket 134

Creating a Simple Datagram Command-Line Client 135

Reading from the Command Line 135

Sending Data to the Server 135

Receiving Data from the Server 136

Putting the Command-Line UDP Client Together 136

Understanding and Using Datagram Multicast 136

Receiving Multicast Messages 137

Sending Multicast Messages 138

Understanding Maximum Datagram Size 138

Summary 138

CHAPTER 15: SECURING YOUR TCP SERVER WITH TLS/SSL 139

Understanding Private and Public Keys 139

Generating a Private Key 140

Generating a Public Key 140

Building a TLS Server 141

Initializing the Server 141

Listening for Connections 141

Reading Data from the Client 142

Sending Data to the Client 142

Ending the Connection 142

Building a TLS Client 143

Initializing the Client 143

Connecting to the Server 143

Verifying the Server Certificate 143

Sending Data to the Server 144

Reading Data from the Server 144

Ending the Connection 144

Building Some Examples 145

Creating a TLS Chat Server 145

Creating a TLS Command-Line Chat Client 146

Verifying the Client Certificate 147

Summary 148

CHAPTER 16: SECURING YOUR HTTP SERVER WITH HTTPS 149

Building a Secure HTTP Server 149

Setting Up the Server Options 150

Listening for Connections 150

Validating the HTTPS Client Certificate 151

Creating an HTTPS Client 152

Initializing the Client 152

Making the Request 152

Validating the HTTPS Server Certificate 153

Summary 154

PART IV: BUILDING AND DEBUGGING MODULES AND APPLICATIONS

CHAPTER 17: TESTING MODULES AND APPLICATIONS 157

Using a Test Runner 157

Writing Tests 158

Running Tests 159

Using an Assertion Testing Module 159

Using the assert Module 159

Using the Built-in Assertion Functions in Node-Tap 161

Testing Your Asynchronous Module 163

Summary 166

CHAPTER 18: DEBUGGING MODULES AND APPLICATIONS 167

Using console.log 167

Using Node's Built-in Debugger 169

Using Node Inspector 173

Summary 175

CHAPTER 19: CONTROLLING THE CALLBACK FLOW 177

Understanding the Boomerang Effect 177

Avoiding the Boomerang Effect

by Declaring Functions 179

Using the async Flow Control Library 183

Executing in Series 184

Executing in Parallel 185

Cascading 186

Queuing 187

Iterating 189

Mapping 190

Reducing 191

Filtering 192

Detecting 193

Summary 194

PART V: BUILDING WEB APPLICATIONS

CHAPTER 20: BUILDING AND USING HTTP MIDDLEWARE 197

Understanding the Connect HTTP Middleware Framework 198

Building Your Own HTTP Middleware 198

Creating Asynchronous Middleware 200

Registering Callbacks Inside Middleware 201

Handling Errors Inside Middleware 203

Using the HTTP Middleware Bundled in Connect 206

Logging Requests 206

Handling Errors 208

Serving Static Files 209

Parsing the Query String 210

Parsing the Request Body 211

Parsing Cookies 212

Using a Session 213

Other Available Middleware 216

Summary 216

CHAPTER 21: MAKING A WEB APPLICATION USING EXPRESS.JS 217

Initializing Your Express.js Application 218

Setting Up Middleware in Your Application 220

Routing Requests 222

Handling Routes 222

Using Sessions 229

Using Route Middleware 234

Summary 238

CHAPTER 22: MAKING UNIVERSAL REAL-TIME WEB APPLICATIONS USING SOCKET.IO 241

Understanding How WebSockets Work 242

Using Socket.IO to Build WebSocket Applications 243

Installing and Running Socket.IO on the Server 243

Building a Real-Time Web Chat with Socket.IO 245

Extending the Chat Application 250

Detecting Disconnections 254

Separating Users into Rooms 255

Using Namespaces 259

Distributing the Server-Side Application Using Redis 259

Summary 263

PART VI: CONNECTING TO DATABASES

CHAPTER 23: CONNECTING TO MYSQL USING NODE-MYSQL 267

Using a Library to Connect to and Communicate

with a MySQL Database 268

Adding Data to the Database with

Security Concerns in Mind 270

Reading Data Effi ciently 272

Summary 276

CHAPTER 24: CONNECTING TO COUCHDB USING NANO 277

Installing Nano 278

Connecting and Creating a Database 281

Storing Documents 285

Creating and Using CouchDB Views 286

Attaching Files to a CouchDB Document 298

Summary 310

CHAPTER 25: CONNECTING TO MONGODB USING MONGOOSE 311

Installing Mongoose 313

Understanding How Mongoose Uses Models to Encapsulate Database Access 313

Connecting to MongoDB 314

Defining a Schema 314

Defining a Model 315

Using Validators 324

Using Modifiers 330

Using Getters 331

Using Virtual Attributes 332

Using Default Values 338

Defining Indexes 340

Referencing Other Documents Using DB Refs 341

Defining Instance Methods 347

Defining Static Methods 348

Summary 349

INDEX 351