peddlers-of-ketran/server/app.js

"use strict";

process.env.TZ = "Etc/GMT";

console.log("Loading ketr.ketran");

const express = require("express"),
  bodyParser = require("body-parser"),
  config = require("config"),
  session = require('express-session'),
  hb = require("handlebars"),
  SQLiteStore = require('connect-sqlite3')(session),
  basePath = require("./basepath"),
  app = express(),
  server = require("http").createServer(app),
  ws = require('express-ws')(app, server);

require("./console-line.js"); /* Monkey-patch console.log with line numbers */

const frontendPath = config.get("frontendPath").replace(/\/$/, "") + "/",
  serverConfig = config.get("server");

console.log("Hosting server from: " + basePath);

let userDB, gameDB;

app.use(bodyParser.json());


/* App is behind an nginx proxy which we trust, so use the remote address
 * set in the headers */
app.set("trust proxy", true);

app.set("basePath", basePath);
app.use(basePath, require("./routes/basepath.js"));

/* Handle static files first so excessive logging doesn't occur */
app.use(basePath, express.static(frontendPath, { index: false }));

/*
app.use(bodyParser.urlencoded({
  extended: false
}));
*/

/* body-parser does not support text/*, so add support for that here */
if (0) app.use(function(req, res, next){
  if (!req.is('text/*')) {
    return next();
  }
  req.setEncoding('utf8');
  let text = '';
  req.on('data', function(chunk) {
    text += chunk;
  });
  req.on('end', function() {
    req.text = text;
    next();
  });
});

const sessionParser = session({
  store: new SQLiteStore({ db: config.get("sessions.db") }),
  secret: config.get("sessions.store-secret"),
  cookie: { maxAge: 21 * 24 * 60 * 60 * 1000 }, // 3 weeks
  saveUninitialized: false,
  resave: true
});

app.use(sessionParser);

const index = require("./routes/index");

if (config.has("admin")) {
  const admin = config.get("admin");
  app.set("admin", admin);
}

/* Allow loading of the app w/out being logged in */
app.use(basePath, index);

/* /games loads the default index */
app.use(basePath + "games", index);


/* Allow access to the 'users' API w/out being logged in */
/*
const users = require("./routes/users");
app.use(basePath + "api/v1/users", users.router);
*/

app.use(function(err, req, res, next) {
  console.error(err.message);
  res.status(err.status || 500).json({
    message: err.message,
    error: {}
  });
});

if (0) {
/* Check authentication */
app.use(basePath, function(req, res, next) {
  return users.getSessionUser(req).then(function(user) {
    if (user.restriction) {
      return res.status(401).send(user.restriction);
    }
    req.user = user;
    return next();
  }).catch(function(error) {
    return res.status(403).send(error);
  });
});
}

/* Everything below here requires a successful authentication */
app.use(basePath, express.static(frontendPath, { index: false }));

app.set('ws', ws);
app.use(`${basePath}api/v1/games`, require("./routes/games"));

/* Declare the "catch all" index route last; the final route is a 404 dynamic router */
app.use(basePath, index);

/**
 * Create HTTP server and listen for new connections
 */
app.set("port", serverConfig.port);

process.on('SIGINT', () => {
  server.close(() => {
    console.log("Gracefully shutting down from SIGINT (Ctrl-C)");
    process.exit(1);
  });
});

require("./db/games").then(function(db) {
  gameDB = db;
}).then(function() {
  return require("./db/users").then(function(db) {
    userDB = db;
  });
}).then(function() {
  console.log("DB connected. Opening server.");
  server.listen(serverConfig.port, () => {
    console.log(`http/ws server listening on ${serverConfig.port}`);
  });
}).catch(function(error) {
  console.error(error);
  process.exit(-1);
});

server.on("error", function(error) {
  if (error.syscall !== "listen") {
    throw error;
  }

  // handle specific listen errors with friendly messages
  switch (error.code) {
    case "EACCES":
      console.error(serverConfig.port + " requires elevated privileges");
      process.exit(1);
      break;
    case "EADDRINUSE":
      console.error(serverConfig.port + " is already in use");
      process.exit(1);
      break;
    default:
      throw error;
  }
});