Learning Node.js for .NET Developers

Table of contents

1. Learning Node.js for .NET Developers
   1. Table of Contents
   2. Learning Node.js for .NET Developers
   3. Credits
   4. About the Author
   5. About the Reviewer
   6. www.PacktPub.com
      1. eBooks, discount offers, and more
         1. Why subscribe?
   7. Preface
      1. What this book covers
      2. What you need for this book
      3. Who this book is for
      4. Conventions
      5. Reader feedback
      6. Customer support
         1. Downloading the example code
         2. Downloading the color images of this book
         3. Errata
         4. Piracy
         5. Questions
   8. 1. Why Node.js?
      1. What is Node.js?
         1. Understanding the Node.js execution model
            1. Non-blocking
            2. Event-driven
            3. Single-threaded
         2. Introducing the Node.js ecosystem
      2. Why JavaScript?
         1. A clear canvas
         2. Functional nature
         3. A bright future
      3. When to use Node.js
         1. Writing web applications
         2. Identifying other use cases
         3. Why now?
      4. Summary
   9. 2. Getting Started with Node.js
      1. Installing and running Node.js
      2. Choosing an editor
      3. Using an application framework
         1. Getting started with Express
         2. Exploring our Express application
         3. Understanding Express routes and views
         4. Using nodemon for automatic restarts
         5. Creating modular applications with Express
         6. Bootstrapping an Express application
         7. Understanding Express middleware
            1. Implementing error handling
            2. Using Express middleware
      4. Summary
   10. 3. A JavaScript Primer
       1. Introducing JavaScript types
          1. JavaScript primitive types
       2. Functional object-oriented programming
          1. Functional programming in JavaScript
          2. Understanding scopes in JavaScript
             1. Strict mode
          3. Object-oriented programming in JavaScript
             1. Programming without classes
                1. Creating objects with the new keyword
             2. Programming with classes
                1. Class-based inheritance
       3. Summary
   11. 4. Introducing Node.js Modules
       1. Organizing your codebase
          1. JavaScript module systems
       2. Creating modules in Node.js
          1. Declaring a module with a name and its own scope
          2. Defining functionality provided by the module
          3. Importing a module into another script
       3. Defining a directory-level module
       4. Implementing an Express middleware module
       5. Summary
   12. 5. Creating Dynamic Websites
       1. Handling user-submitted data
       2. Communicating via Ajax
       3. Implementing other data operations
          1. Listing data in views
          2. Issuing a delete request from the client
          3. Splitting up Express views using partials
       4. Summary
   13. 6. Testing Node.js Applications
       1. Writing a simple test in Node.js
       2. Structuring the codebase for tests
       3. Writing BDD-style tests with Mocha
          1. Resetting state between tests
       4. Using Chai for assertions
       5. Creating test doubles
          1. Creating test doubles using Sinon.JS
       6. Testing an Express application
          1. Simplifying tests using SuperAgent
       7. Full-stack testing with PhantomJS
       8. Summary
   14. 7. Setting up an Automated Build
       1. Setting up an integration server
          1. Setting up a public GitHub repository
          2. Building a project on Travis CI
       2. Automating the build process with Gulp
          1. Running tests using Gulp
       3. Checking code style with ESLint
          1. Automatically fixing issues in ESLint
          2. Running ESLint from Gulp
       4. Gathering code coverage statistics
       5. Running integration tests from Gulp
       6. Summary
   15. 8. Mastering Asynchronicity
       1. Using the callback pattern for asynchronous code
          1. Exposing the callback pattern
          2. Consuming asynchronous interfaces
       2. Writing cleaner asynchronous code using promises
          1. Implementing promise-based asynchronous code
             1. Consuming the promise pattern
          2. Parallelising operations using promises
       3. Combining asynchronous programming patterns
       4. Summary
   16. 9. Persisting Data
       1. Introducing MongoDB
          1. Why choose MongoDB?
             1. Object modeling
             2. JavaScript
             3. Scalability
          2. Getting started with MongoDB
             1. Using the MongoDB shell
       2. Using MongoDB with Express
          1. Persisting objects with Mongoose
          2. Isolating persistence code
          3. Dependency injection in Node.js
          4. Providing dependencies
          5. Running database integration tests on Travis CI
       3. Introducing Redis
          1. Why use Redis?
          2. Installing Redis
          3. Using Redis as a key-value store
          4. Storing structured data in Redis
       4. Building a user ranking system with Redis
          1. Using Redis from Node.js
             1. Testing with redis-js
          2. Implementing user rankings with Redis
          3. Making use of the users service
       5. A note on security
       6. Summary
   17. 10. Creating Real-time Web Apps
       1. Understanding options for real-time communication
       2. Introducing Socket.IO
          1. Implementing a chat room with Socket.IO
       3. Scaling real-time Node.js applications
          1. Using Redis as a backend
       4. Integrating Socket.IO with Express
       5. Directing Socket.IO messages
       6. Testing Socket.IO applications
       7. Organizing Socket.IO applications
          1. Exposing real-time updates to the model
          2. Organizing Socket.IO applications using namespaces
          3. Partitioning Socket.IO clients using rooms
       8. Summary
   18. 11. Deploying Node.js Applications
       1. Working with Heroku
          1. Setting up a Heroku account and tooling
          2. Running an application locally with Heroku
          3. Deploying an application to Heroku
          4. Working with Heroku logs, config, and services
             1. Setting up MongoDB
             2. Setting up Redis
       2. Deploying from Travis CI
          1. Setting encrypted Travis CI environment variables
             1. Installing Ruby
             2. Creating an encrypted environment variable
       3. Further resources
       4. Summary
   19. 12. Authentication in Node.js
       1. Introducing Passport
          1. Choosing an authentication strategy
          2. Understanding third-party authentication
       2. Using Express sessions
          1. Specifying a session secret
          2. Deciding when the session gets saved
          3. Using alternative session stores
          4. Using session middleware
       3. Implementing social login
          1. Setting up a Twitter application
          2. Configuring Passport
          3. Persisting user data with Redis
          4. Configuring Passport with persistence
          5. Hiding functionality from unauthenticated users
          6. Integration testing with Passport
       4. Allowing users to log out
       5. Adding other login providers
       6. Summary
   20. 13. Creating JavaScript Packages
       1. Writing universal modules
          1. Comparing Node.js and RequireJS
          2. Supporting the browser environment
          3. Using AMD modules with RequireJS
          4. Isomorphic JavaScript
       2. Writing npm packages
          1. Defining an npm package
       3. Publishing a package to npm
          1. Running automated clients on the web
          2. Releasing a standalone tool to npm
       4. Using Node.js modules in the browser
          1. Controlling Browserify's output
       5. Summary
   21. 14. Node.js and Beyond
       1. Understanding Node.js versioning
          1. A brief history of Node.js
          2. Introducing the Node.js LTS schedule
       2. Understanding ECMAScript versioning
       3. Exploring ECMAScript 2015
          1. Understanding ES2015 modules
          2. Using syntax improvements from ES2015
             1. The for... of loop
             2. The spread operator and rest parameters
             3. Destructuring assignment
          3. Introducing generators
       4. Introducing ECMAScript 2016
       5. Going beyond JavaScript
          1. Exploring compile-to-JavaScript languages
             1. TypeScript
             2. CoffeeScript
             3. And beyond...
          2. Introducing a true assembly language for the web
             1. Understanding asm.js
             2. Understanding WebAssembly
       6. JavaScript and ASP.NET
          1. Exploring .NET Core
             1. Defining project structure in .NET Core
             2. Managing dependencies in .NET Core
             3. Building web applications in ASP.NET Core
          2. Integration with JavaScript
             1. Server-side JavaScript integration with .NET
       7. Summary
   22. Index