Summary I am selling you future books (programming).

Contents
About ................................................................................................................................................................................... 1
Chapter 1: Getting started with Node.js ............................................................................................................ 2
Section 1.1: Hello World HTTP server ........................................................................................................................... 4
Section 1.2: Hello World command line ....................................................................................................................... 5
Section 1.3: Hello World with Express .......................................................................................................................... 6
Section 1.4: Installing and Running Node.js ................................................................................................................. 6
Section 1.5: Debugging Your NodeJS Application ...................................................................................................... 7
Section 1.6: Hello World basic routing ......................................................................................................................... 7
Section 1.7: Hello World in the REPL ............................................................................................................................ 8
Section 1.8: Deploying your application online ........................................................................................................... 9
Section 1.9: Core modules ............................................................................................................................................. 9
Section 1.10: TLS Socket: server and client ................................................................................................................ 14
Section 1.11: How to get a basic HTTPS web server up and running! ..................................................................... 16
Chapter 2: npm ............................................................................................................................................................ 19
Section 2.1: Installing packages ................................................................................................................................. 19
Section 2.2: Uninstalling packages ............................................................................................................................ 22
Section 2.3: Setting up a package configuration ..................................................................................................... 23
Section 2.4: Running scripts ....................................................................................................................................... 24
Section 2.5: Basic semantic versioning ..................................................................................................................... 24
Section 2.6: Publishing a package ............................................................................................................................. 25
Section 2.7: Removing extraneous packages .......................................................................................................... 26
Section 2.8: Listing currently installed packages ..................................................................................................... 26
Section 2.9: Updating npm and packages ............................................................................................................... 26
Section 2.10: Scopes and repositories ....................................................................................................................... 27
Section 2.11: Linking projects for faster debugging and development .................................................................. 27
Section 2.12: Locking modules to specific versions ................................................................................................. 28
Section 2.13: Setting up for globally installed packages ......................................................................................... 28
Chapter 3: Web Apps With Express .................................................................................................................... 30
Section 3.1: Getting Started ......................................................................................................................................... 30
Section 3.2: Basic routing ........................................................................................................................................... 31
Section 3.3: Modular express application ................................................................................................................. 32
Section 3.4: Using a Template Engine ....................................................................................................................... 33
Section 3.5: JSON API with ExpressJS ....................................................................................................................... 34
Section 3.6: Serving static files ................................................................................................................................... 35
Section 3.7: Adding Middleware ................................................................................................................................. 36
Section 3.8: Error Handling ......................................................................................................................................... 36
Section 3.9: Getting info from the request ................................................................................................................ 37
Section 3.10: Error handling in Express ...................................................................................................................... 38
Section 3.11: Hook: How to execute code before any req and after any res ........................................................ 38
Section 3.12: Setting cookies with cookie-parser ..................................................................................................... 39
Section 3.13: Custom middleware in Express ............................................................................................................ 39
Section 3.14: Named routes in Django-style ............................................................................................................. 39
Section 3.15: Hello World ............................................................................................................................................. 40
Section 3.16: Using middleware and the next callback ............................................................................................ 40
Section 3.17: Error handling ........................................................................................................................................ 42
Section 3.18: Handling POST Requests ...................................................................................................................... 43
Chapter 4: Filesystem I/O ...................................................................................................................................... 45

, Section 4.1: Asynchronously Read from Files ........................................................................................................... 45
Section 4.2: Listing Directory Contents with readdir or readdirSync ..................................................................... 45
Section 4.3: Copying files by piping streams ............................................................................................................ 46
Section 4.4: Reading from a file synchronously ...................................................................................................... 47
Section 4.5: Check Permissions of a File or Directory ............................................................................................. 47
Section 4.6: Checking if a file or a directory exists .................................................................................................. 48
Section 4.7: Determining the line count of a text file ............................................................................................... 49
Section 4.8: Reading a file line by line ....................................................................................................................... 49
Section 4.9: Avoiding race conditions when creating or using an existing directory ........................................... 49
Section 4.10: Cloning a file using streams ................................................................................................................. 50
Section 4.11: Writing to a file using writeFile or writeFileSync ................................................................................. 51
Section 4.12: Changing contents of a text file .......................................................................................................... 51
Section 4.13: Deleting a file using unlink or unlinkSync ........................................................................................... 52
Section 4.14: Reading a file into a Buer using streams ......................................................................................... 52
Chapter 5: Exporting and Consuming Modules ........................................................................................... 53
Section 5.1: Creating a hello-world.js module ........................................................................................................... 53
Section 5.2: Loading and using a module ................................................................................................................ 54
Section 5.3: Folder as a module ................................................................................................................................. 55
Section 5.4: Every module injected only once .......................................................................................................... 55
Section 5.5: Module loading from node_modules ................................................................................................... 56
Section 5.6: Building your own modules ................................................................................................................... 56
Section 5.7: Invalidating the module cache .............................................................................................................. 57
Chapter 6: Exporting and Importing Module in node.js .......................................................................... 58
Section 6.1: Exporting with ES6 syntax ...................................................................................................................... 58
Section 6.2: Using a simple module in node.js ......................................................................................................... 58
Chapter 7: How modules are loaded ................................................................................................................ 59
Section 7.1: Global Mode ............................................................................................................................................. 59
Section 7.2: Loading modules .................................................................................................................................... 59
Chapter 8: Cluster Module ..................................................................................................................................... 60
Section 8.1: Hello World .............................................................................................................................................. 60
Section 8.2: Cluster Example ...................................................................................................................................... 60
Chapter 9: Readline ................................................................................................................................................... 62
Section 9.1: Line-by-line file reading .......................................................................................................................... 62
Section 9.2: Prompting user input via CLI ................................................................................................................. 62
Chapter 10: package.json ....................................................................................................................................... 63
Section 10.1: Exploring package.json ......................................................................................................................... 63
Section 10.2: Scripts ..................................................................................................................................................... 66
Section 10.3: Basic project definition ......................................................................................................................... 67
Section 10.4: Dependencies ........................................................................................................................................ 67
Section 10.5: Extended project definition .................................................................................................................. 68
Chapter 11: Event Emitters ..................................................................................................................................... 69
Section 11.1: Basics ....................................................................................................................................................... 69
Section 11.2: Get the names of the events that are subscribed to .......................................................................... 69
Section 11.3: HTTP Analytics through an Event Emitter ........................................................................................... 70
Section 11.4: Get the number of listeners registered to listen for a specific event ............................................... 70
Chapter 12: Autoreload on changes .................................................................................................................. 72
Section 12.1: Autoreload on source code changes using nodemon ....................................................................... 72
Section 12.2: Browsersync .......................................................................................................................................... 72
Chapter 13: Environment ......................................................................................................................................... 74

, Section 13.1: Accessing environment variables ......................................................................................................... 74
Section 13.2: process.argv command line arguments ............................................................................................. 74
Section 13.3: Loading environment properties from a "property file" ................................................................... 75
Section 13.4: Using dierent Properties/Configuration for dierent environments like dev, qa, staging etc
................................................................................................................................................................................ 75
Chapter 14: Callback to Promise ........................................................................................................................ 77
Section 14.1: Promisifying a callback ......................................................................................................................... 77
Section 14.2: Manually promisifying a callback ........................................................................................................ 77
Section 14.3: setTimeout promisified ......................................................................................................................... 78
Chapter 15: Executing files or commands with Child Processes ......................................................... 79
Section 15.1: Spawning a new process to execute a command .............................................................................. 79
Section 15.2: Spawning a shell to execute a command ........................................................................................... 79
Section 15.3: Spawning a process to run an executable ......................................................................................... 80
Chapter 16: Exception handling ........................................................................................................................... 82
Section 16.1: Handling Exception In Node.Js ............................................................................................................. 82
Section 16.2: Unhanded Exception Management ..................................................................................................... 83
Section 16.3: Errors and Promises .............................................................................................................................. 84
Chapter 17: Keep a node application constantly running ..................................................................... 86
Section 17.1: Use PM2 as a process manager ........................................................................................................... 86
Section 17.2: Running and stopping a Forever daemon ......................................................................................... 87
Section 17.3: Continuous running with nohup ........................................................................................................... 88
Chapter 18: Uninstalling Node.js ......................................................................................................................... 89
Section 18.1: Completely uninstall Node.js on Mac OSX ........................................................................................... 89
Section 18.2: Uninstall Node.js on Windows .............................................................................................................. 89
Chapter 19: nvm - Node Version Manager ..................................................................................................... 90
Section 19.1: Install NVM .............................................................................................................................................. 90
Section 19.2: Check NVM version ............................................................................................................................... 90
Section 19.3: Installing an specific Node version ...................................................................................................... 90
Section 19.4: Using an already installed node version ............................................................................................ 90
Section 19.5: Install nvm on Mac OSX ........................................................................................................................ 91
Section 19.6: Run any arbitrary command in a subshell with the desired version of node ................................. 91
Section 19.7: Setting alias for node version .............................................................................................................. 92
Chapter 20: http .......................................................................................................................................................... 93
Section 20.1: http server .............................................................................................................................................. 93
Section 20.2: http client .............................................................................................................................................. 94
Chapter 21: Using Streams ..................................................................................................................................... 95
Section 21.1: Read Data from TextFile with Streams ............................................................................................... 95
Section 21.2: Piping streams ....................................................................................................................................... 95
Section 21.3: Creating your own readable/writable stream ................................................................................... 96
Section 21.4: Why Streams? ....................................................................................................................................... 97
Chapter 22: Deploying Node.js applications in production ................................................................... 99
Section 22.1: Setting NODE_ENV="production" ........................................................................................................ 99
Section 22.2: Manage app with process manager ................................................................................................ 100
Section 22.3: Deployment using process manager ............................................................................................... 100
Section 22.4: Deployment using PM2 ...................................................................................................................... 101
Section 22.5: Using dierent Properties/Configuration for dierent environments like dev, qa, staging etc
............................................................................................................................................................................. 102
Section 22.6: Taking advantage of clusters ........................................................................................................... 103
Chapter 23: Securing Node.js applications .................................................................................................. 104

, Section 23.1: SSL/TLS in Node.js .............................................................................................................................. 104
Section 23.2: Preventing Cross Site Request Forgery (CSRF) .............................................................................. 104
Section 23.3: Setting up an HTTPS server .............................................................................................................. 105
Section 23.4: Using HTTPS ....................................................................................................................................... 107
Section 23.5: Secure express.js 3 Application ......................................................................................................... 107
Chapter 24: Mongoose Library ......................................................................................................................... 109
Section 24.1: Connect to MongoDB Using Mongoose ........................................................................................... 109
Section 24.2: Find Data in MongoDB Using Mongoose, Express.js Routes and $text Operator ....................... 109
Section 24.3: Save Data to MongoDB using Mongoose and Express.js Routes ................................................. 111
Section 24.4: Find Data in MongoDB Using Mongoose and Express.js Routes .................................................. 113
Section 24.5: Useful Mongoose functions ............................................................................................................... 115
Section 24.6: Indexes in models ............................................................................................................................... 115
Section 24.7: find data in mongodb using promises ............................................................................................. 117
Chapter 25: async.js ................................................................................................................................................ 120
Section 25.1: Parallel : multi-tasking ........................................................................................................................ 120
Section 25.2: async.each(To handle array of data eciently) ............................................................................ 121
Section 25.3: Series : independent mono-tasking .................................................................................................. 122
Section 25.4: Waterfall : dependent mono-tasking ............................................................................................... 123
Section 25.5: async.times(To handle for loop in better way) ............................................................................... 124
Section 25.6: async.series(To handle events one by one) .................................................................................... 124
Chapter 26: File upload .......................................................................................................................................... 125
Section 26.1: Single File Upload using multer ......................................................................................................... 125
Section 26.2: Using formidable module .................................................................................................................. 126
Chapter 27: Socket.io communication ........................................................................................................... 128
Section 27.1: "Hello world!" with socket messages ................................................................................................. 128
Chapter 28: Mongodb integration ................................................................................................................... 129
Section 28.1: Simple connect .................................................................................................................................... 129
Section 28.2: Simple connect, using promises ....................................................................................................... 129
Section 28.3: Connect to MongoDB ......................................................................................................................... 129
Section 28.4: Insert a document .............................................................................................................................. 130
Section 28.5: Read a collection ................................................................................................................................ 131
Section 28.6: Update a document ........................................................................................................................... 131
Section 28.7: Delete a document ............................................................................................................................. 132
Section 28.8: Delete multiple documents ............................................................................................................... 132
Chapter 29: Handling POST request in Node.js ......................................................................................... 134
Section 29.1: Sample node.js server that just handles POST requests ................................................................ 134
Chapter 30: Simple REST based CRUD API .................................................................................................. 135
Section 30.1: REST API for CRUD in Express 3+ ...................................................................................................... 135
Chapter 31: Template frameworks .................................................................................................................. 136
Section 31.1: Nunjucks ................................................................................................................................................ 136
Chapter 32: Node.js Architecture & Inner Workings ............................................................................... 138
Section 32.1: Node.js - under the hood .................................................................................................................... 138
Section 32.2: Node.js - in motion ............................................................................................................................. 138
Chapter 33: Debugging Node.js application ............................................................................................... 139
Section 33.1: Core node.js debugger and node inspector ..................................................................................... 139
Chapter 34: Node server without framework ........................................................................................... 142
Section 34.1: Framework-less node server ............................................................................................................. 142
Section 34.2: Overcoming CORS Issues .................................................................................................................. 143