fix(challenges): add class to backend challenge wrapper, fix basic node formatting

challenges/05-apis-and-microservices/basic-node-and-express.json

@@ -58,14 +58,12 @@
       "id": "587d7fb0367417b2b2512bee",
       "title": "Start a working Express Server",
       "description": [
-        "In the first two lines of the file myApp.js you can see how it’s easy to create an Express app object. This object has several methods, and we will learn many of them in these challenges. One fundamental method is app.listen(<port>). It tells your server to listen on a given port, putting it in running state. You can see it at the bottom of the file. It is inside comments because for testing reasons we need the app to be running in background. All the code that you may want to add goes between these two fundamental parts. Gomix stores the port number in the environemet variable process.env.PORT. Its value is 3000.",
+        "In the first two lines of the file myApp.js you can see how it’s easy to create an Express app object. This object has several methods, and we will learn many of them in these challenges. One fundamental method is <code>app.listen(<port>)</code>. It tells your server to listen on a given port, putting it in running state. You can see it at the bottom of the file. It is inside comments because for testing reasons we need the app to be running in background. All the code that you may want to add goes between these two fundamental parts. Gomix stores the port number in the environemet variable <code>process.env.PORT</code>. Its value is <code>3000</code>.",
-        "Let’s serve our first string ! In Express, routes takes the following structure: app.METHOD(PATH, HANDLER). METHOD is an http method in lowercase. PATH is a relative path on the server (it can be a string, or even a regular expression). HANDLER is a function that Express calls when the route is matched.",
+        "Let’s serve our first string ! In Express, routes takes the following structure: <code>app.METHOD(PATH, HANDLER)</code>. METHOD is an http method in lowercase. PATH is a relative path on the server (it can be a string, or even a regular expression). HANDLER is a function that Express calls when the route is matched.",
-        "Handlers take the form function(req, res) {...}, where req is the request object, and res is the response object. For example, the handler",
+        "Handlers take the form <code>function(req, res) {...}</code>, where req is the request object, and res is the response object. For example, the handler",
-        "<code>function(req, res) {</code>",
+        "<blockquote>function(req, res) {<br> res.send('Response String');<br>}</blockquote>",
-        "<code> res.send('Response String');</code>",
-        "<code>}</code>",
         "will serve the string 'Response String'.",
-        "Use the app.get() method to serve the string Hello Express, to GET requests matching the / root path. Be sure that your code works by looking at the logs, then see the results in your browser, clicking the button ‘Show Live’ in the Gomix UI."
+        "Use the <code>app.get()</code> method to serve the string Hello Express, to GET requests matching the / root path. Be sure that your code works by looking at the logs, then see the results in your browser, clicking the button ‘Show Live’ in the Gomix UI."
       ],
       "challengeSeed": [],
       "tests": [
@@ -84,10 +82,10 @@
       "id": "587d7fb0367417b2b2512bef",
       "title": "Serve an HTML file",
       "description": [
-        "We can respond with a file using the method res.sendFile(<file>).",
+        "We can respond with a file using the method <code>res.sendFile(<file>)</code>.",
-        "You can put it inside the app.get('/', ...) route handler. Behind the scenes this method will set the appropriate headers to instruct your browser on how to handle the file you want to send, according to its type. Then it will read and send the file. This method needs an absolute file-path. We recommend you to use the node global variable __dirname to calculate the path.",
+        "You can put it inside the <code>app.get('/', ...)</code> route handler. Behind the scenes this method will set the appropriate headers to instruct your browser on how to handle the file you want to send, according to its type. Then it will read and send the file. This method needs an absolute file-path. We recommend you to use the node global variable <code>__dirname</code> to calculate the path.",
-        "e.g. absolutePath = __dirname + relativePath/file.ext .",
+        "e.g. <code>absolutePath = __dirname + relativePath/file.ext</code>.",
-        "The file to send is /views/index.html. Try to ‘Show Live’ your app, you should see a big HTML heading (and a form that we will use later…), with no style applied.",
+        "The file to send is <code>/views/index.html</code>. Try to ‘Show Live’ your 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 preceding challenge, or create a new one. If you create a new solution, keep in mind that Express evaluates the routes from top to bottom. It executes the handler for the first match. You have to comment out the preceding solution, or the server will keep responding with a string."
       ],
       "challengeSeed": [],
@@ -107,8 +105,8 @@
       "id": "587d7fb0367417b2b2512bf0",
       "title": "Serve Static assets",
       "description": [
-        "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(<public-dir-absolute_path>). If don’t know what a midleware is, don’t worry. We’ll discuss about it later in details. Basically middleware are function that intercept route handlers, adding some kind of information. A middleware needs to be mounted using the method app.use([optional-path], <mware function>). The first path argument is optional. If you don’t pass it, the middleware will be executed for all the requests.",
+        "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 <code>express.static(<public-dir-absolute_path>)</code>. If don’t know what a midleware is, don’t worry. We’ll discuss about it later in details. Basically middleware are function that intercept route handlers, adding some kind of information. A middleware needs to be mounted using the method <code>app.use([optional-path], <mware function>)</code>. The first path argument is optional. If you don’t pass it, the middleware will be executed for all the requests.",
-        "Mount the express.static() middleware for all the requests with app.use(). The absolute path to the assets folder is __dirname + /public.",
+        "Mount the <code>express.static()</code> middleware for all the requests with <code>app.use()</code>. The absolute path to the assets folder is <code>__dirname + /public</code>.",
         "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"
       ],
       "challengeSeed": [],
@@ -170,15 +168,12 @@
       "id": "587d7fb1367417b2b2512bf3",
       "title": "Implement a Root-level Request Logger Middleware",
       "description": [
-        "Before we introduced the express.static() middleware function. Now it’s time to see what middleware is, in more detail. Middleware functions are functions that take 3 arguments: the request object, the response object, and the next function in the application’s request-response cycle. These functions execute some code that can have side effects on the app, and usually add informations to the request or response objects. They can also end the cycle sending the response, when some condition is met. If they don’t send the response, when they are done they start the execution of the next function in the stack. This is triggered calling the 3rd argument next(). More information here in the express documentation.",
+        "Before we introduced the <code>express.static()</code> middleware function. Now it’s time to see what middleware is, in more detail. Middleware functions are functions that take 3 arguments: the request object, the response object, and the next function in the application’s request-response cycle. These functions execute some code that can have side effects on the app, and usually add informations to the request or response objects. They can also end the cycle sending the response, when some condition is met. If they don’t send the response, when they are done they start the execution of the next function in the stack. This is triggered calling the 3rd argument <code>next()</code>. More information here in the express documentation.",
         "Look at the following example :",
-        "<code>function(req, res, next) {</code>",
+        "<blockquote>function(req, res, next) {<br>  console.log(\"I'm middleware...\");<br>  next();<br>}</blockquote>",
-        "<code>  console.log(\"I'm middleware...\" );</code>",
-        "<code>  next();</code>",
-        "<code>}</code>",
         "Let’s suppose we mounted this function on a route. When a request matches the route, it displays the string “I’m middleware…”. Then it executes the next function in the stack.",
-        "In this exercise we are going to build a root-level middleware. As we have seen in challenge 4, to mount a middleware function at root level we can use the method app.use(<mware-function). In this case the function will be executed for all the request. If you want a function to be executed let’s say only for POST request, you could use app.post(<mware-function>). Analogous methods exist for all the http verbs (GET, DELETE, PUT, …).",
+        "In this exercise we are going to build a root-level middleware. As we have seen in challenge 4, to mount a middleware function at root level we can use the method <code>app.use(<mware-function)</code>. In this case the function will be executed for all the request. If you want a function to be executed let’s say only for POST request, you could use <code>app.post(<mware-function>)</code>. Analogous methods exist for all the http verbs (GET, DELETE, PUT, …).",
-        "Build a simple logger. For every request, it should log in the console a string taking the following format : method path - ip. 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…",
+        "Build a simple logger. For every request, it should log in the console a string taking the following format: <code>method path - ip</code>. An example would look like: <code>GET /json - ::ffff:127.0.0.1</code>. Note that there is a space between <code>method</code> and <code>path</code> and that the dash separating <code>path</code> and <code>ip</code> is surrounded by a space on either side. You can get the request method (http verb), the relative route path, and the caller’s ip from the request object, using <code>req.method</code>, <code>req.path</code> and <code>req.ip</code>. Remember to call <code>next()</code> 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…",
         "Hint: Express evaluates functions in order. This is true for middleware too. If you want it to work for all the routes, it should be mounted before them."
       ],
       "challengeSeed": [],
@@ -198,16 +193,11 @@
       "id": "587d7fb1367417b2b2512bf4",
       "title": "Chain Middleware to Create a Time Server",
       "description": [
-        "Middleware can be mounted at a specific route using app.METHOD('<path>', mware). Middleware can also be chained inside route definition.",
+        "Middleware can be mounted at a specific route using <code>app.METHOD('<path>', mware)</code>. Middleware can also be chained inside route definition.",
         "Look at the following example :",
-        "<code>app.get('/user', function(req, res, next){</code>",
+        "<blockquote>app.get('/user', function(req, res, next){<br>  req.user = getTheUserSync();  // Hypotetical Synchronous operation<br>  next();<br>}, function(req, res) {<br>  res.send(req.user)<br>})</blockquote>",
-        "<code>  req.user = getTheUserSync();  // Hypotetical Synchronous operation</code>",
-        "<code>  next();</code>",
-        "<code>}, function(req, res) {</code>",
-        "<code>  res.send(req.user)</code>",
-        "<code>})</code>",
         "This approach is useful to split the server operations into smaller units. That leads a to a better app structure, and the possibility to reuse code in different places. This approach can be also 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 desinged 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.",
-        "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}.",
+        "In the route <code>app.get('/now', ...)</code> chain a middleware function and the final handler. In the middleware function you should add the current time to the request object in the <code>req.time</code> key. You can use new <code>Date().toString()</code>. In the handler, respond with a json object, taking the structure <code>{time: req.time}</code>.",
         "Hint: 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."
       ],
       "challengeSeed": [],
@@ -231,11 +221,9 @@
       "id": "587d7fb2367417b2b2512bf5",
       "title": "Get Route Parameter Input from the Client",
       "description": [
-        "When building an API, we have to allow users to comunicate us what they want to get from our service. For example, if the client is requesting informations about a user stored in the database, she needs a way to let us know which user she is interested in. One possible way to get this result, is 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 match its position. The captured values are populated in the req.params object.",
+        "When building an API, we have to allow users to comunicate us what they want to get from our service. For example, if the client is requesting informations about a user stored in the database, she needs a way to let us know which user she is interested in. One possible way to get this result, is 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 match its position. The captured values are populated in the <code>req.params</code> object.",
-        "<code>route_path: '/user/:userId/book/:bookId'</code>",
+        "<blockquote>route_path: '/user/:userId/book/:bookId'<br>actual_request_URL: '/user/546/book/6754' <br>req.params: {userId: '546', bookId: '6754'}</blockquote>",
-        "<code>actual_request_URL: '/user/546/book/6754' </code>",
+        "Build an echo server, mounted at the route <code>GET /:word/echo</code>. Respond with a json document, taking the structure <code>{echo: <word>}</code>. You can find the word to be repeated at <code>req.params.word</code>. You can test your route from your browser the address bar, visiting some matching routes, e.g. <your-app-rootpath>/freecodecamp/echo"
-        "<code>req.params: {userId: '546', bookId: '6754'}</code>",
-        "Build an echo server, mounted at the route GET /:word/echo. Respond with a json document, taking the structure {echo: <word>}. You can find the word to be repeated at req.params.word. You can test your route from your browser the address bar, visiting some matching routes, e.g. <your-app-rootpath>/freecodecamp/echo"
       ],
       "challengeSeed": [],
       "tests": [
@@ -258,12 +246,10 @@
       "id": "587d7fb2367417b2b2512bf6",
       "title": "Get Query Parameter Input from the Client",
       "description": [
-        "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 character cannot be in URLs, so the query string needs to be encoded. If you use the API from javascript, you can use specific methods to encode/decode the URL.",
+        "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 <code>req.query</code>. Some character cannot be in URLs, so the query string needs to be encoded. If you use the API from javascript, you can use specific methods to encode/decode the URL.",
-        "<code>route_path: '/library'</code>",
+        "<blockquote>route_path: '/library'<br>actual_request_URL: '/library?userId=546&bookId=6754' <br>req.query: {userId: '546', bookId: '6754'}</blockquote>",
-        "<code>actual_request_URL: '/library?userId=546&bookId=6754' </code>",
+        "Build an API endpoint, mounted at <code>GET /name</code>. Respond with a json document, taking the structure <code>{ name: '<firstname> <lastname>'}</code>. The first and last name parameters should be encoded in a query string e.g. <code>?first=<firstname>&last=<lastname></code>.",
-        "<code>req.query: {userId: '546', bookId: '6754'}</code>",
+        "TIP: In the following exercise we are going to receive data from a POST request, at the same <code>/name</code> route path. If you want you can use the method <code>app.route(<path>).get(<handler>).post(<handler>)</code>. 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."
-        "Build an API endpoint, mounted at GET /name. Respond with a json document, taking the structure <code>{ name: '<firstname> <lastname>'}</code>. The first and last name parameters should be encoded in a query string e.g. ?first=<firstname>&last=<lastname>.",
-        "TIP: In the following exercise we 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."
       ],
       "challengeSeed": [],
       "tests": [
@@ -286,19 +272,14 @@
       "id": "587d7fb2367417b2b2512bf7",
       "title": "Use Body-Parser to Parse POST Requests",
       "description": [
-        "Besides GET there is another common http verb , it is POST. POST is the default method used to send client data with HTML forms. In the REST convention POST is used to send data to create new items in the database (a new user, or a new blog post). We don’t have a database in this project, but we are going to learn how to handle POST requests anyway.",
+        "Besides GET there is another common http verb, it is POST. POST is the default method used to send client data with HTML forms. In the REST convention POST is used to send data to create new items in the database (a new user, or a new blog post). We don’t have a database in this project, but we are going to learn how to handle POST requests anyway.",
         "In these kind of request the data doesn’t appear in the URL, it is hidden in the request body. This is a part of the HTML request, also called payload. Since HTML is text based, even if you don’t see the data, it doesn’t mean that they are secret. The raw content of an HTTP Post is shown below:",
-        "<code>POST /path/subpath HTTP/1.0</code>",
+        "<blockquote>POST /path/subpath HTTP/1.0<br>From: john@example.com<br>User-Agent: someBrowser/1.0<br>Content-Type: application/x-www-form-urlencoded<br>Content-Length: 20<br>name=John+Doe&age=25</blockquote>",
-        "<code>From: john@example.com</code>",
-        "<code>User-Agent: someBrowser/1.0</code>",
-        "<code>Content-Type: application/x-www-form-urlencoded</code>",
-        "<code>Content-Length: 20</code>",
-        "<code>name=John+Doe&age=25</code>",
         "As you can see the body is encoded like the query string. This is the default format used by HTML forms. With Ajax we can also use JSON to be able 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 we will use an urlencoded body.",
-        "To parse the data coming from POST requests, you have to install a package: the body-parser. This package allows you to use a series of middleware, which can decode data in different formats. See the docs here.",
+        "To parse the data coming from POST requests, you have to install a package: the body-parser. This package allows you to use a series of middleware, which can decode data in different formats. See the docs <a href=\"https://github.com/expressjs/body-parser\" target=\"_blank\" >here</a>.",
         "Install the body-parser module in your package.json. Then require it at the top of the file. Store it in a variable named bodyParser.",
-        "The middleware to handle url encoded data is returned by bodyParser.urlencoded({extended: false}). extended=false is a configuration options that tells the parser to use the classic encoding. When using it, values can be only strings or arrays. The extended version allows more data flexibility, but is outmatched by JSON. app.use() the function returned by the previous method call. As usual, the middleware must be mounted before all the routes which need it."
+        "The middleware to handle url encoded data is returned by <code>bodyParser.urlencoded({extended: false})</code>. <code>extended=false</code> is a configuration options that tells the parser to use the classic encoding. When using it, values can be only strings or arrays. The extended version allows more data flexibility, but is outmatched by JSON. <code>app.use()</code> the function returned by the previous method call. As usual, the middleware must be mounted before all the routes which need it."
       ],
       "challengeSeed": [],
       "tests": [
@@ -317,12 +298,10 @@
       "id": "587d7fb2367417b2b2512bf8",
       "title": "Get Data from POST Requests",
       "description": [
-        "Mount a POST handler at the path /name. It’s the same path as before. We have prepared a form in the html frontpage. It will submit the same data of exercise 10 (Query string). If the body-parser is configured correctly, you should find the parameters in the object req.body. Have a look at the usual library example :",
+        "Mount a POST handler at the path <code>/name</code>. It’s the same path as before. We have prepared a form in the html frontpage. It will submit the same data of exercise 10 (Query string). If the body-parser is configured correctly, you should find the parameters in the object <code>req.body</code>. Have a look at the usual library example:",
-        "<code>route: POST '/library'</code>",
+        "<blockquote>route: POST '/library'<br>urlencoded_body: userId=546&bookId=6754 <br>req.body: {userId: '546', bookId: '6754'}</blockquote>",
-        "<code>urlencoded_body: userId=546&bookId=6754 </code>",
+        "Respond with the same JSON object as before: <code>{name: '<firstname> <lastname>'}</code>. Test if your endpoint works using the html form we provided in the app frontpage.",
-        "<code>req.body: {userId: '546', bookId: '6754'}</code>",
+        "Tip: There are several other http methods other than GET and POST. And by convention there is a corrispondence between the http verb, and the operation you are going to execute on the server. The conventional mapping is:",
-        "Respond with the same JSON object as before: {name: '<firstname> <lastname>'}. Test if your endpoint works using the html form we provided in the app frontpage.",
-        "Tip: There are several other http methods other than GET and POST. And by convention there is a corrispondence between the http verb, and the operation you are going to execute on the server. The conventional mapping is :",
         "POST (sometimes PUT) - Create a new resource using the information sent with the request,",
         "GET - Read an existing resource without modifying it,",
         "PUT or PATCH (sometimes POST) - Update a resource using the data sent,",