A vanilla node js http server

httpserver.js

const fs = require('fs');
const http = require('http');
const path = require('path');
const process = require('process');
const server = http.createServer();
const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "*",
  "Access-Control-Max-Age": 2592000
};

const httpserver = function () {
  const start = function (address) {
    let localAddress = `${address.host}:${address.port}`;
    let processId = process.pid;
    server.listen(address);
    server
      .on("listening", () => {
        console.log(
          `Server ${localAddress} listening & running with PID ${processId}.`
        );
      })
      .on("close", () => {
        console.log(
          `Server ${localAddress} terminated running with PID ${processId}.`
        );
      })
      .on("error", error => {
        console.error(`HTTP Server Exception -> ${error}`);
      })
      .on("connection", socket => {
        console.log(
          `Client ${socket.remoteAddress}:${socket.remotePort} connected.`
        );
      })
      .on("request", (req, res) => {
        let path = req.url;
        let method = req.method;
        let socket = req.socket;
        let data = "";
        let headers = Object.assign(corsHeaders, {"Connection": "close"});
        let remoteAddress = `${socket.remoteAddress}:${socket.remotePort}`;
        let handleError = (error, socketAddress, response) => {
          let message = `Response Error for ${socketAddress} -> ${error.stack}`;
          console.error(message);
          response.statusCode = 500;
          response.end(message);
        };

        req
          .on("error", e => {
            handleError(e, remoteAddress, res);
          })
          .on("close", () => {
            console.log(`Request for ${remoteAddress} Closed.`);
          })
          .on("data", chunk => {
            data += chunk;
            console.log(`Request for ${remoteAddress} Data.`);
          })
          .on("end", () => {
            console.log(`Request for ${remoteAddress} Ended.`);
            try {
              let result = route.resolve(path,method,data);
              res.writeHead(200, headers);
              res.write(result);
              res.end();
              res.on("error", error => {
                  handleError(error, remoteAddress, res);
                })
                .on("close", () => {
                  console.log(`Response for ${remoteAddress} Closed.`);
                })
                .on("finish", () => {
                  console.log(`Response for ${remoteAddress} Finished.`);
                });
            } catch (error) {
              handleError(error, remoteAddress, res);
            }
          });
      });
    return this;
  };

  const shutdown = function () {
    let handler = e => {
      if (e instanceof Error) console.error(`Server Error -> ${e.stack}`);
      server.close(() => {
        process.exit(0);
      });
    };
    process.on("SIGINT", handler);
    process.on("SIGHUP", handler);
    process.on("SIGQUIT", handler);
    process.on("SIGTERM", handler);
    process.on("uncaughtException", handler);
    process.on("exit", handler);
    return this;
  };

  return {start:start,shutdown:shutdown};
}

const route = {
  resolve : (path,method,data) => {
      let r = route.routes[path];
      return r !== undefined ? r(method,data) :  `path '${path}' not found.`;
  },
  routes : {
      '/whatsapp/inbox/messages' : (method,data) => {
          let methods  = {
            'GET' : (data) => {
              return JSON.stringify(messages.read());
            },
            'POST': (data) => {
              return data; //echo's back data
            }
          };
          return methods[method] !== undefined ? methods[method](data) : `method '${method}' not found.`;
      },
      '/whatsapp/outbox/messages' : (method,data) => {
          let methods  = {
            'GET' : (data) => {
              return 'GET : /whatsapp/outbox/messages'; //placeholder values
            },
            'POST': (data) => {
              return 'POST : /whatsapp/outbox/messages'; //placeholder values
            }
          };
        return methods[method] !== undefined ? methods[method](data) :  `method '${method}' not found.`;
      }
  }
};

const messages = {
  read : () => {
      let store = [];
      let directory = path.resolve(__dirname,'messages');
      let files = fs.readdirSync(directory);
      for(let file of files){
        let contents = fs.readFileSync(path.resolve(directory, file),'utf8');
        store.push(messages.clean(JSON.parse(contents)));
      }
      return store;
  },
  clean : (message) => {
    delete message['ApiVersion']
    delete message['NumSegments'];
    delete message['NumMedia'];
    delete message['SmsMessageSid'];
    delete message['SmsSid'];
    delete message['SmsStatus'];
    return message;
  }
};

new httpserver().start({host:'localhost',port:8080}).shutdown();