Solving some of Learnyounode's problems using events

api_server.js

 /*
 ## HTTP JSON API SERVER (Exercise 13 of 13)

  Write an HTTP server that serves JSON data when it receives a GET request
  to the path '/api/parsetime'. Expect the request to contain a query string
  with a key 'iso' and an ISO-format time as the value.

  For example:

  /api/parsetime?iso=2013-08-10T12:10:15.474Z

  The JSON response should contain only 'hour', 'minute' and 'second'
  properties. For example:

     {
       "hour": 14,
       "minute": 23,
       "second": 15
     }

  Add second endpoint for the path '/api/unixtime' which accepts the same
  query string but returns UNIX epoch time in milliseconds (the number of
  milliseconds since 1 Jan 1970 00:00:00 UTC) under the property 'unixtime'.
  For example:

     { "unixtime": 1376136615474 }

  Your server should listen on the port provided by the first argument to
  your program.

 ─────────────────────────────────────────────────────────────────────────────

 ## HINTS

  The request object from an HTTP server has a url property that you will
  need to use to "route" your requests for the two endpoints.

  You can parse the URL and query string using the Node core 'url' module.
  url.parse(request.url, true) will parse content of request.url and provide
  you with an object with helpful properties.

  For example, on the command prompt, type:

     $ node -pe "require('url').parse('/test?q=1', true)"

  Documentation on the url module can be found by pointing your browser
  here:
  file:///Users/Aurelio/Code/tests/learnyounode/node_modules/learnyounode/no
  de_apidoc/url.html

  Your response should be in a JSON string format. Look at JSON.stringify()
  for more information.

  You should also be a good web citizen and set the Content-Type properly:

     res.writeHead(200, { 'Content-Type': 'application/json' })

  The JavaScript Date object can print dates in ISO format, e.g. new
  Date().toISOString(). It can also parse this format if you pass the string
  into the Date constructor. Date.getTime() will also come in handy.
*/

const http = require('http');
const url = require('url');

const PORT = process.argv[2];

const API = {
  parseTime: '/api/parsetime',
  unixTime: '/api/unixtime'
};

const resObj = {
  "hour": 0,
  "minute": 0,
  "second": 0
};

const server = http.createServer((req, res) => {
  const method = req.method;
  const reqUrl = url.parse(req.url, true);

  if (method !== 'GET') {
    res.end();
  }

  const qp = reqUrl.query;
  const date = new Date(qp.iso);

  if (reqUrl.pathname === API.parseTime) {
    res.writeHead(200, { 'Content-Type': 'application/json' })
    res.end(JSON.stringify({
      hour: date.getHours(),
      minute: date.getMinutes(),
      second: date.getSeconds()
    }));
    return;
  }

  if (reqUrl.pathname === API.unixTime) {
    res.writeHead(200, { 'Content-Type': 'application/json' })
    res.end(JSON.stringify({
      unixtime: date.getTime(),
    }));
    return;
  }

  res.end();

}).listen(PORT);

file_server.js

/*

 ## HTTP FILE SERVER (Exercise 11 of 13)

  Write an HTTP server that serves the same text file for each request it
  receives.

  Your server should listen on the port provided by the first argument to
  your program.

  You will be provided with the location of the file to serve as the second
  command-line argument. You must use the fs.createReadStream() method to
  stream the file contents to the response.

 ─────────────────────────────────────────────────────────────────────────────

 ## HINTS

  Because we need to create an HTTP server for this exercise rather than a
  generic TCP server, we should use the http module from Node core. Like the
  net module, http also has a method named http.createServer() but this one
  creates a server that can talk HTTP.

  http.createServer() takes a callback that is called once for each
  connection received by your server. The callback function has the
  signature:

     function callback (request, response) { / ... / }

  Where the two arguments are objects representing the HTTP request and the
  corresponding response for this request. request is used to fetch
  properties, such as the header and query-string from the request while
  response is for sending data to the client, both headers and body.

  Both request and response are also Node streams! Which means that you can
  use the streaming abstractions to send and receive data if they suit your
  use-case.

  http.createServer() also returns an instance of your server. You must call
  server.listen(portNumber) to start listening on a particular port.

  A typical Node HTTP server looks like this:

     var http = require('http')
     var server = http.createServer(function (req, res) {
       // request handling logic...
     })
     server.listen(8000)

  Documentation on the http module can be found by pointing your browser
  here:
  file:///Users/Aurelio/Code/tests/learnyounode/node_modules/learnyounode/node_apidoc/http.html

  The fs core module also has some streaming APIs for files. You will need
  to use the fs.createReadStream() method to create a stream representing
  the file you are given as a command-line argument. The method returns a
  stream object which you can use src.pipe(dst) to pipe the data from the
  src stream to the dst stream. In this way you can connect a filesystem
  stream with an HTTP response stream.
*/

const http = require('http');
const fs = require('fs');

const PORT = process.argv[2];
const FILE_ADDR = process.argv[3];

http.createServer((req, res) => {
  const file = fs.createReadStream(FILE_ADDR)
  file.pipe(res)
}).listen(PORT);

http_uppercaser.js

 /*
 ## HTTP UPPERCASERER (Exercise 12 of 13)

  Write an HTTP server that receives only POST requests and converts
  incoming POST body characters to upper-case and returns it to the client.

  Your server should listen on the port provided by the first argument to
  your program.

 ─────────────────────────────────────────────────────────────────────────────

 ## HINTS

  While you're not restricted to using the streaming capabilities of the
  request and response objects, it will be much easier if you do.

  There are a number of different packages in npm that you can use to
  "transform" stream data as it's passing through. For this exercise the
  through2-map package offers the simplest API.

  through2-map allows you to create a transform stream using only a single
  function that takes a chunk of data and returns a chunk of data. It's
  designed to work much like Array#map() but for streams:

     var map = require('through2-map')
     inStream.pipe(map(function (chunk) {
       return chunk.toString().split('').reverse().join('')
     })).pipe(outStream)

  In the above example, the incoming data from inStream is converted to a
  String (if it isn't already), the characters are reversed and the result
  is passed through to outStream. So we've made a chunk character reverser!
  Remember though that the chunk size is determined up-stream and you have
  little control over it for incoming data.

  To install through2-map type:

     $ npm install through2-map

  If you don't have an Internet connection, simply make a node_modules
  directory and copy the entire directory for the module you want to use
  from inside the learnyounode installation directory:

  file:///Users/Aurelio/Code/tests/learnyounode/node_modules/learnyounode/no
  de_modules/through2-map

  Documentation for through2-map has been installed along with learnyounode
  on your system and you can read them by pointing your browser here:

  file:///Users/Aurelio/Code/tests/learnyounode/node_modules/learnyounode/do
  cs/through2-map.html
*/

const http = require('http');
const map = require('through2-map');

const PORT = process.argv[2];

const uppercase = map(str => str.toString().toUpperCase());

const server = http.createServer((req, res) => {
  if (req.method === 'POST') {
    req.pipe(uppercase).pipe(res);
  }  else {
    res.end();
  }

});

server.listen(PORT);

juggling_async.js

/*
 ## JUGGLING ASYNC (Exercise 9 of 13)

  This problem is the same as the previous problem (HTTP COLLECT) in that
  you need to use http.get(). However, this time you will be provided with
  three URLs as the first three command-line arguments.

  You must collect the complete content provided to you by each of the URLs
  and print it to the console (stdout). You don't need to print out the
  length, just the data as a String; one line per URL. The catch is that you
  must print them out in the same order as the URLs are provided to you as
  command-line arguments.

 ─────────────────────────────────────────────────────────────────────────────

 ## HINTS

  Don't expect these three servers to play nicely! They are not going to
  give you complete responses in the order you hope, so you can't naively
  just print the output as you get it because they will be out of order.

  You will need to queue the results and keep track of how many of the URLs
  have returned their entire contents. Only once you have them all, you can
  print the data to the console.

  Counting callbacks is one of the fundamental ways of managing async in
  Node. Rather than doing it yourself, you may find it more convenient to
  rely on a third-party library such as [async](https://npmjs.com/async) or
  [after](https://npmjs.com/after). But for this exercise, try and do it
  without any external helper library.

  => My solution is inspired from https://stackoverflow.com/a/39517480/1446845
  I used the standard Node EE and created a state container (context) that holds
  the results as they come along. That means that the order of 'results' is the 
  order of completion. Every object in that array contains a 'order' property
  that stores the index of the http call so we can reorder the array based on
  the order of call (as the problem requires).
  */

const http = require('http');
const EventEmitter = require('events').EventEmitter;
const args = process.argv.slice(2);
const stateMachine = new EventEmitter();
let context = {
  urls: [],
  completed: false,
  results: []
};

const next = result => {
  if (result) {
    context.results.push({
      content: result.content,
      order: result.order
    });
  }

  context.completed = context.urls.length === context.results.length;

  if (context.completed) {
    stateMachine.emit('done');
  }
}

stateMachine.on('start', urls => {
  context.urls = urls;

  urls.forEach((url, index) => {
    stateMachine.emit('request', {
      url,
      index,
    });
  });
});

stateMachine.on('request', req => {
  http.get(req.url, res => {
    res.setEncoding('utf-8');
    let data = '';
    res.on('data', chunk => {
      data += chunk;
    });

    res.on('end', () => {
      next({
        content: data,
        order: req.index
      });
    });
  });
});

stateMachine.on('done', () => {
  const results = context.results.sort((a,b) => a.order - b.order);
  results.forEach(res => {
    console.log(res.content);
  });
});

stateMachine.emit('start', args);