Table of Contents for
Node.js 8 the Right Way

Version ebook / Retour

Cover image for bash Cookbook, 2nd Edition Node.js 8 the Right Way by Jim Wilson Published by Pragmatic Bookshelf, 2018
  1. Title Page
  2. Node.js 8 the Right Way
  3. Node.js 8 the Right Way
  4. Node.js 8 the Right Way
  5. Node.js 8 the Right Way
  6.  Acknowledgments
  7.  Preface
  8. Why Node.js the Right Way?
  9. What’s in This Book
  10. What This Book Is Not
  11. Code Examples and Conventions
  12. Online Resources
  13. Part I. Getting Up to Speed on Node.js 8
  14. 1. Getting Started
  15. Thinking Beyond the web
  16. Node.js’s Niche
  17. How Node.js Applications Work
  18. Aspects of Node.js Development
  19. Installing Node.js
  20. 2. Wrangling the File System
  21. Programming for the Node.js Event Loop
  22. Spawning a Child Process
  23. Capturing Data from an EventEmitter
  24. Reading and Writing Files Asynchronously
  25. The Two Phases of a Node.js Program
  26. Wrapping Up
  27. 3. Networking with Sockets
  28. Listening for Socket Connections
  29. Implementing a Messaging Protocol
  30. Creating Socket Client Connections
  31. Testing Network Application Functionality
  32. Extending Core Classes in Custom Modules
  33. Developing Unit Tests with Mocha
  34. Wrapping Up
  35. 4. Connecting Robust Microservices
  36. Installing ØMQ
  37. Publishing and Subscribing to Messages
  38. Responding to Requests
  39. Routing and Dealing Messages
  40. Clustering Node.js Processes
  41. Pushing and Pulling Messages
  42. Wrapping Up
  43. Node.js 8 the Right Way
  44. Part II. Working with Data
  45. 5. Transforming Data and Testing Continuously
  46. Procuring External Data
  47. Behavior-Driven Development with Mocha and Chai
  48. Extracting Data from XML with Cheerio
  49. Processing Data Files Sequentially
  50. Debugging Tests with Chrome DevTools
  51. Wrapping Up
  52. 6. Commanding Databases
  53. Introducing Elasticsearch
  54. Creating a Command-Line Program in Node.js with Commander
  55. Using request to Fetch JSON over HTTP
  56. Shaping JSON with jq
  57. Inserting Elasticsearch Documents in Bulk
  58. Implementing an Elasticsearch Query Command
  59. Wrapping Up
  60. Node.js 8 the Right Way
  61. Part III. Creating an Application from the Ground Up
  62. 7. Developing RESTful Web Services
  63. Advantages of Express
  64. Serving APIs with Express
  65. Writing Modular Express Services
  66. Keeping Services Running with nodemon
  67. Adding Search APIs
  68. Simplifying Code Flows with Promises
  69. Manipulating Documents RESTfully
  70. Emulating Synchronous Style with async and await
  71. Providing an Async Handler Function to Express
  72. Wrapping Up
  73. 8. Creating a Beautiful User Experience
  74. Getting Started with webpack
  75. Generating Your First webpack Bundle
  76. Sprucing Up Your UI with Bootstrap
  77. Bringing in Bootstrap JavaScript and jQuery
  78. Transpiling with TypeScript
  79. Templating HTML with Handlebars
  80. Implementing hashChange Navigation
  81. Listing Objects in a View
  82. Saving Data with a Form
  83. Wrapping Up
  84. 9. Fortifying Your Application
  85. Setting Up the Initial Project
  86. Managing User Sessions in Express
  87. Adding Authentication UI Elements
  88. Setting Up Passport
  89. Authenticating with Facebook, Twitter, and Google
  90. Composing an Express Router
  91. Bringing in the Book Bundle UI
  92. Serving in Production
  93. Wrapping Up
  94. Node.js 8 the Right Way
  95. 10. BONUS: Developing Flows with Node-RED
  96. Setting Up Node-RED
  97. Securing Node-RED
  98. Developing a Node-RED Flow
  99. Creating HTTP APIs with Node-RED
  100. Handling Errors in Node-RED Flows
  101. Wrapping Up
  102. A1. Setting Up Angular
  103. A2. Setting Up React
  104. Node.js 8 the Right Way

Wrapping Up

This was a big chapter on creating RESTful APIs using Express. Let’s take a minute to reflect.

We started off with the basics—installing Express and a logging utility called Morgan. You learned how to put together the rough outline of an Express-powered web service using Node.

To manage the configuration of the service, we brought in a module called nconf. Using just three lines of code, we managed to configure the service through a config file while allowing overrides from command-line arguments and environment variables. You also learned how to use nodemon to keep your service running, automatically restarting whenever the code changes.

Next it was off to the races writing APIs that could use Elasticsearch to find books by the various fields in those documents. For this we started off using the Request module with regular callback handlers like in the previous chapter. But soon we upgraded to using Promises for managing asynchronous code flows, in particular those produced by the request-promise module.

After the search APIs, we developed APIs for working with book bundles. Building on Promises, we took advantage of async functions with the async and await keywords. This powerful combination encourages a readable, synchronous style of coding while enjoying the benefits of nonblocking, asynchronous functionality.

The followup tasks below ask you to continue filling out the suite of bundle-manipulation APIs. Take care!

Deleting a Bundle Entirely

In this chapter, you wrote a bunch of APIs for creating and manipulating book bundles, but not one to delete a bundle. Your task is to add one now.

Here’s the basic shell of the API you’re going to add.

web-services/b4/lib/bundle.js
​ ​/**​
​ ​ * Delete a bundle entirely.​
​ ​ * curl -X DELETE http://<host>:<port>/api/bundle/<id>​
​ ​ */​
​ app.​delete​(​'/api/bundle/:id'​, ​async​ (req, res) => {
​ });

Inside the Express route handler callback function, you should do the following:

  • Determine the bundle’s URL based on the es config object and the request parameters.

  • Use await with a call to rp to suspend until the deletion is completed.

  • Wrap your await call in a try/catch block to handle any errors.

Hint: use the rp.delete method to send an HTTP DELETE request to Elasticsearch.

Removing a Book from a Bundle

Like the previous task, this task asks you to implement a DELETE API. But this time it’s to remove a book from a bundle (not delete the bundle entirely).

Here’s the basic outline of your API:

web-services/b4/lib/bundle.js
​ ​/**​
​ ​ * Remove a book from a bundle.​
​ ​ * curl -X DELETE http://<host>:<port>/api/bundle/<id>/book/<pgid>​
​ ​ */​
​ app.​delete​(​'/api/bundle/:id/book/:pgid'​, ​async​ (req, res) => {
​  ​const​ bundleUrl = ​`​${url}​/​${req.params.id}​`​;
​ 
​  ​try​ {
​ 
​  } ​catch​ (esResErr) {
​  res.status(esResErr.statusCode || 502).json(esResErr.error);
​  }
​ });

Inside the try{} block you’ll need to do a few things:

  • Use await with rp to retrieve the bundle object from Elasticsearch.
  • Find the index of the book within the bundle.books list.
  • Remove the book from the list. (Hint: use Array.splice.)
  • PUT the updated bundle object back into the Elasticsearch index, again with await and rp.

Note that if the bundle doesn’t contain the book whose removal is being requested, your handler should return a 409 Conflict HTTP status code. You can make this happen by throwing an object with a statusCode property set to 409 and an error object that contains information about what went wrong. This will be caught by the catch block and used to finish the Express response.

If you get stuck, check out the code download that accompanies this book. Good luck!

Footnotes

[64]

http://nodejs.org/api/http.html

[65]

http://expressjs.com/

[66]

http://www.sinatrarb.com/

[67]

https://www.npmjs.com/package/nconf

[68]

https://www.elastic.co/guide/en/elasticsearch/reference/5.2/search-request-body.html

[69]

https://www.elastic.co/guide/en/elasticsearch/reference/5.2/search-suggesters.html

[70]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols

Copyright © 2018, The Pragmatic Bookshelf.