update tutorial for v0.4.1

Author: ShMcK

TUTORIAL.md

@@ -2,7 +2,7 @@
 
 Build a server with Node & Express
 
-## L1 Meet the Node Console
+## 1. Meet the Node Console
 
 > Introduction to the Node console
 
@@ -18,15 +18,15 @@ During the development process, it is important to be able to check what’s goi
 
 We recommend to keep the log panel open while working at these challenges. By reading the logs, you can be aware of the nature of errors that may occur.
 
-### L1S1
+### 1.1
 
 NPM install the "express" library module version. Use version 4.x.
 
-### L1S2
+### 1.2
 
 Modify the `server.js` file to log "Hello World" to the console.
 
-## L2 Start a Working Server
+## 2. Start a Working Server
 
 > Create a server
 
@@ -44,13 +44,13 @@ function(req, res) {
 
 will serve the string 'Response String'.
 
-### L2S1
+### 2.1
 
 Use the `app.get()` method to serve the string "Hello Express" to GET requests matching the `/` (root) path.
 
 **Note:** Be sure that your code works by looking at the logs, then see the results in your browser by running `npm start`.
 
-## L3 Serve an HTML File
+## 3. Serve an HTML File
 
 > Serve an HTML file over the server
 
@@ -60,61 +60,61 @@ You can respond to requests with a file using the `res.sendFile(path)` method. Y
 absolutePath = __dirname + relativePath / file.ext;
 ```
 
-### L3S1
+### 3.1
 
 Send the `/views/index.html` file as a response to GET requests to the `/` path. If you view your live app, you should see a big HTML heading (and a form that we will use later…), with no style applied.
 
 **Note:** You can edit the solution of the previous challenge or create a new one. If you create a new solution, keep in mind that Express evaluates routes from top to bottom, and executes the handler for the first match. You have to comment out the preceding solution, or the server will keep responding with a string.
 
-## L4 Serve Static Assets
+## 4. Serve Static Assets
 
 > Serve static CSS
 
 An HTML server usually has one or more directories that are accessible by the user. You can place there the static assets needed by your application (stylesheets, scripts, images). In Express, you can put in place this functionality using the middleware `express.static(path)`, where the `path` parameter is the absolute path of the folder containing the assets. If you don’t know what middleware is... don’t worry, we will discuss in detail later. Basically, middleware are functions that intercept route handlers, adding some kind of information. A middleware needs to be mounted using the method `app.use(path, middlewareFunction)`. The first `path` argument is optional. If you don’t pass it, the middleware will be executed for all requests.
 
-### L4S1
+### 4.1
 
 Mount the `express.static()` middleware for all requests with `app.use()`. The absolute path to the assets folder is `\_\_dirname + /public`.
 Now your app should be able to serve a CSS stylesheet. From outside, the public folder will appear mounted to the root directory. Your front-page should look a little better now!
 
-## L5 Serve JSON on a Route
+## 5. Serve JSON on a Route
 
 > Serve JSON over a REST API
 
 While an HTML server serves (you guessed it!) HTML, an API serves data. A <dfn>REST</dfn> (REpresentational State Transfer) API allows data exchange in a simple way, without the need for clients to know any detail about the server. The client only needs to know where the resource is (the URL), and the action it wants to perform on it (the verb). The GET verb is used when you are fetching some information, without modifying anything. These days, the preferred data format for moving information around the web is JSON. Simply put, JSON is a convenient way to represent a JavaScript object as a string, so it can be easily transmitted.
 
 Let's create a simple API by creating a route that responds with JSON at the path `/json`. You can do it as usual, with the `app.get()` method. Inside the route handler, use the method `res.json()`, passing in an object as an argument. This method closes the request-response loop, returning the data. Behind the scenes, it converts a valid JavaScript object into a string, then sets the appropriate headers to tell your browser that you are serving JSON, and sends the data back. A valid object has the usual structure `{key: data}`. `data` can be a number, a string, a nested object or an array. `data` can also be a variable or the result of a function call, in which case it will be evaluated before being converted into a string.
 
-### L5S1
+### 5.1
 
 Serve the object `{"message": "Hello json"}` as a response, in JSON format, to GET requests to the `/json` route. Then point your browser to `your-app-url/json`, you should see the message on the screen.
 
-## L6 Use the .env File
+## 6. Use the .env File
 
 > Load secrets with the .env file
 
 The `.env` file is a hidden file that is used to pass environment variables to your application. This file is secret, no one but you can access it, and it can be used to store data that you want to keep private or hidden. For example, you can store API keys from external services or your database URI. You can also use it to store configuration options. By setting configuration options, you can change the behavior of your application, without the need to rewrite some code.
 
 The environment variables are accessible from the app as `process.env.VAR_NAME`. The `process.env` object is a global Node object, and variables are passed as strings. By convention, the variable names are all uppercase, with words separated by an underscore. The `.env` is a shell file, so you don’t need to wrap names or values in quotes. It is also important to note that there cannot be space around the equals sign when you are assigning values to your variables, e.g. `VAR_NAME=value`. Usually, you will put each variable definition on a separate line.
 
-### L6S1
+### 6.1
 
 Create a .env file in the root of your project.
 
-### L6S2
+### 6.2
 
 Add the .env file to your .gitignore file. It should be kept a secret.
 
-### L6S3
+### 6.3
 
 Let's add an environment variable as a configuration option.
 Store the variable `MESSAGE_STYLE=uppercase` in the `.env` file.
 
-### L6S4
+### 6.4
 
 Install the dependency for the package "dotenv" as a devDependency (`npm install --save-dev module`). The package helps make variables from the .env file available in your code.
 
-### L6S5
+### 6.5
 
 Load dependencies into your server.js by adding the following line to the top of your file:
 
@@ -124,11 +124,11 @@ require("dotenv").config();
 
 You can test if it works by logging `process.env.MESSAGE_STYLE`.
 
-### L6S6
+### 6.6
 
 Tell the GET `/json` route handler that you created in the last challenge to transform the response object’s message to uppercase if `process.env.MESSAGE_STYLE` equals `uppercase`. The response object should become `{"message": "HELLO JSON"}`.
 
-## L7 Root-Level Request Logger Middleware
+## 7. Root-Level Request Logger Middleware
 
 > Add logger middleware
 
@@ -147,13 +147,13 @@ Let’s suppose you mounted this function on a route. When a request matches the
 
 In this exercise, you are going to build root-level middleware. As you have seen in challenge 4, to mount a middleware function at root level, you can use the `app.use(&lt;mware-function&gt;)` method. In this case, the function will be executed for all the requests, but you can also set more specific conditions. For example, if you want a function to be executed only for POST requests, you could use `app.post(&lt;mware-function&gt;)`. Analogous methods exist for all the HTTP verbs (GET, DELETE, PUT, …).
 
-### L7S1
+### 7.1
 
 Build a simple logger. For every request, it should log to the console a string taking the following format: `method path - ip`. An example would look like this: `GET /json - ::ffff:127.0.0.1`. Note that there is a space between `method` and `path` and that the dash separating `path` and `ip` is surrounded by a space on both sides. You can get the request method (http verb), the relative route path, and the caller’s ip from the request object using `req.method`, `req.path` and `req.ip`. Remember to call `next()` when you are done, or your server will be stuck forever. Be sure to have the ‘Logs’ opened, and see what happens when some request arrives.
 
 **Note:** Express evaluates functions in the order they appear in the code. This is true for middleware too. If you want it to work for all the routes, it should be mounted before them.
 
-## L8 Chain Middleware
+## 8. Chain Middleware
 
 > Combine middleware in a chain
 
@@ -175,38 +175,38 @@ app.get(
 
 This approach is useful to split the server operations into smaller units. That leads to a better app structure, and the possibility to reuse code in different places. This approach can also be used to perform some validation on the data. At each point of the middleware stack you can block the execution of the current chain and pass control to functions specifically designed to handle errors. Or you can pass control to the next matching route, to handle special cases. We will see how in the advanced Express section.
 
-### L8S1
+### 8.1
 
 In the route `app.get('/now', ...)` chain a middleware function and the final handler. In the middleware function you should add the current time to the request object in the `req.time` key. You can use `new Date().toString()`. In the handler, respond with a JSON object, taking the structure `{time: req.time}`.
 **Note:** The test will not pass if you don’t chain the middleware. If you mount the function somewhere else, the test will fail, even if the output result is correct.
 
-## L9 Route Parameter Input
+## 9. Route Parameter Input
 
 > Pass params in route names
 
 When building an API, we have to allow users to communicate to us what they want to get from our service. For example, if the client is requesting information about a user stored in the database, they need a way to let us know which user they're interested in. One possible way to achieve this result is by using route parameters. Route parameters are named segments of the URL, delimited by slashes (/). Each segment captures the value of the part of the URL which matches its position. The captured values can be found in the `req.params` object.
 
 <blockquote>route_path: '/user/:userId/book/:bookId'<br>actual_request_URL: '/user/546/book/6754' <br>req.params: {userId: '546', bookId: '6754'}</blockquote>
 
-### L9S1
+### 9.1
 
 Build an echo server, mounted at the route `GET /echo/:word`. Respond with a JSON object, taking the structure `{echo: word}`. You can find the word to be repeated at `req.params.word`.
 
-## L10 Query Parameter Input
+## 10. Query Parameter Input
 
 > Pass params in a query string
 
 Another common way to get input from the client is by encoding the data after the route path, using a query string. The query string is delimited by a question mark (?), and includes field=value couples. Each couple is separated by an ampersand (&). Express can parse the data from the query string, and populate the object `req.query`. Some characters, like the percent (%), cannot be in URLs and have to be encoded in a different format before you can send them. If you use the API from JavaScript, you can use specific methods to encode/decode these characters.
 
 <blockquote>route_path: '/library'<br>actual_request_URL: '/library?userId=546&bookId=6754' <br>req.query: {userId: '546', bookId: '6754'}</blockquote>
 
-### L10S1
+### 10.1
 
 Build an API endpoint, mounted at `GET /name`. Respond with a JSON document, taking the structure `{ name: 'firstname lastname'}`. The first and last name parameters should be encoded in a query string e.g. `?first=firstname&last=lastname`.
 
 **Note:** In the following exercise you are going to receive data from a POST request, at the same `/name` route path. If you want, you can use the method `app.route(path).get(handler).post(handler)`. This syntax allows you to chain different verb handlers on the same path route. You can save a bit of typing, and have cleaner code.
 
-## L11 Body-Parser
+## 11. Body-Parser
 
 > Parse JSON from POST requests
 
@@ -225,11 +225,11 @@ name=John+Doe&age=25
 As you can see, the body is encoded like the query string. This is the default format used by HTML forms. With Ajax, you can also use JSON to handle data having a more complex structure. There is also another type of encoding: multipart/form-data. This one is used to upload binary files.
 In this exercise, you will use a urlencoded body. To parse the data coming from POST requests, you have to install the `body-parser` package. This package allows you to use a series of middleware, which can decode data in different formats.
 
-### L11S1
+### 11.1
 
 Install the `body-parser` module in your `package.json`.
 
-### L11S2
+### 11.2
 
 Require "body-parser" at the top of the server.js file. Store it in a variable named `bodyParser`. The middleware to handle urlencoded data is returned by `bodyParser.urlencoded({extended: false})`. Pass to `app.use()` the function returned by the previous method call. As usual, the middleware must be mounted before all the routes which need it.