bodyshop/server.js

const express = require("express");
const cors = require("cors");
const bodyParser = require("body-parser");
const path = require("path");
const compression = require("compression");
const cookieParser = require("cookie-parser");
const http = require("http");
const { Server } = require("socket.io");
// const { createClient } = require("redis");
const Redis = require("ioredis");
const { createAdapter } = require("@socket.io/redis-adapter");
const logger = require("./server/utils/logger");
const { redisSocketEvents } = require("./server/web-sockets/redisSocketEvents");
const { instrument } = require("@socket.io/admin-ui");

const { isString, isEmpty } = require("lodash");
const applyRedisHelpers = require("./server/utils/redisHelpers");
const applyIOHelpers = require("./server/utils/ioHelpers");

// Load environment variables
require("dotenv").config({
  path: path.resolve(process.cwd(), `.env.${process.env.NODE_ENV || "development"}`)
});

/**
 * CORS Origin for Socket.IO
 * @type {string[][]}
 */
const SOCKETIO_CORS_ORIGIN = [
  "https://test.imex.online",
  "https://www.test.imex.online",
  "http://localhost:3000",
  "https://localhost:3000",
  "https://imex.online",
  "https://www.imex.online",
  "https://romeonline.io",
  "https://www.romeonline.io",
  "https://test.romeonline.io",
  "https://www.test.romeonline.io",
  "https://beta.romeonline.io",
  "https://www.beta.romeonline.io",
  "https://beta.test.imex.online",
  "https://www.beta.test.imex.online",
  "https://beta.imex.online",
  "https://www.beta.imex.online",
  "https://www.test.promanager.web-est.com",
  "https://test.promanager.web-est.com",
  "https://www.promanager.web-est.com",
  "https://promanager.web-est.com",
  "https://old.imex.online",
  "https://www.old.imex.online",
  "https://wsadmin.imex.online",
  "https://www.wsadmin.imex.online",
  "http://localhost:3333",
  "https://localhost:3333"
];

/**
 * Middleware for Express app
 * @param app
 */
const applyMiddleware = (app) => {
  app.use(compression());
  app.use(cookieParser());
  app.use(bodyParser.json({ limit: "50mb" }));
  app.use(bodyParser.urlencoded({ limit: "50mb", extended: true }));
  app.use(cors({ credentials: true, exposedHeaders: ["set-cookie"] }));

  // Helper middleware
  app.use((req, res, next) => {
    req.logger = logger;
    next();
  });
};

/**
 * Route groupings for Express app
 * @param app
 */
const applyRoutes = (app) => {
  app.use("/", require("./server/routes/miscellaneousRoutes"));
  app.use("/notifications", require("./server/routes/notificationsRoutes"));
  app.use("/render", require("./server/routes/renderRoutes"));
  app.use("/mixdata", require("./server/routes/mixDataRoutes"));
  app.use("/accounting", require("./server/routes/accountingRoutes"));
  app.use("/qbo", require("./server/routes/qboRoutes"));
  app.use("/media", require("./server/routes/mediaRoutes"));
  app.use("/sms", require("./server/routes/smsRoutes"));
  app.use("/job", require("./server/routes/jobRoutes"));
  app.use("/scheduling", require("./server/routes/schedulingRoutes"));
  app.use("/utils", require("./server/routes/utilRoutes"));
  app.use("/data", require("./server/routes/dataRoutes"));
  app.use("/adm", require("./server/routes/adminRoutes"));
  app.use("/tech", require("./server/routes/techRoutes"));
  app.use("/intellipay", require("./server/routes/intellipayRoutes"));
  app.use("/cdk", require("./server/routes/cdkRoutes"));
  app.use("/csi", require("./server/routes/csiRoutes"));
  app.use("/payroll", require("./server/routes/payrollRoutes"));

  // Default route for forbidden access
  app.get("/", (req, res) => {
    res.status(200).send("Access Forbidden.");
  });
};

/**
 * Apply Redis to the server
 * @param server
 * @param app
 */
const applySocketIO = async (server, app) => {
  const redisCluster = new Redis.Cluster(
    process.env.REDIS_URL
      ? JSON.parse(process.env.REDIS_URL)
      : [
          {
            host: "redis://localhost:6379"
          }
        ],
    {
      clusterRetryStrategy: function (times) {
        const delay = Math.min(100 + times * 50, 2000);
        logger.log(
          `[${process.env.NODE_ENV}] Redis cluster not yet ready. Retrying in ${delay}ms`,
          "ERROR",
          "redis",
          "api"
        );
        return delay;
      }
    }
  );

  // Handle errors
  redisCluster.on("error", (err) => {
    logger.log(`[${process.env.NODE_ENV}] Redis ERROR`, "ERROR", "redis", "api");
  });

  const pubClient = redisCluster;
  const subClient = pubClient.duplicate();

  // https://github.com/redis/node-redis/blob/master/docs/clustering.md
  // https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/accessing-elasticache.html

  pubClient.on("error", (err) => logger.log(`Redis pubClient error: ${err}`, "ERROR", "redis"));
  subClient.on("error", (err) => logger.log(`Redis subClient error: ${err}`, "ERROR", "redis"));

  // try {
  //   //   await Promise.all([pubClient.connect(), subClient.connect()]);
  //   //   logger.log(`[${process.env.NODE_ENV}] Connected to Redis`, "INFO", "redis", "api");
  //   // } catch (redisError) {
  //   //   logger.log("Failed to connect to Redis", "ERROR", "redis", redisError);
  //   // }

  process.on("SIGINT", async () => {
    logger.log("Closing Redis connections...", "INFO", "redis", "api");
    await Promise.all([pubClient.disconnect(), subClient.disconnect()]);
    process.exit(0);
  });

  const ioRedis = new Server(server, {
    path: "/wss",
    adapter: createAdapter(pubClient, subClient),
    cors: {
      origin: SOCKETIO_CORS_ORIGIN,
      methods: ["GET", "POST"],
      credentials: true,
      exposedHeaders: ["set-cookie"]
    }
  });

  if (isString(process.env.REDIS_ADMIN_PASS) && !isEmpty(process.env.REDIS_ADMIN_PASS)) {
    logger.log(`[${process.env.NODE_ENV}] Initializing Redis Admin UI....`, "INFO", "redis", "api");
    instrument(ioRedis, {
      auth: {
        type: "basic",
        username: "admin",
        password: process.env.REDIS_ADMIN_PASS
      },
      mode: process.env.REDIS_ADMIN_MODE || "development"
    });
  }

  const io = new Server(server, {
    path: "/ws",
    cors: {
      origin: SOCKETIO_CORS_ORIGIN,
      methods: ["GET", "POST"],
      credentials: true,
      exposedHeaders: ["set-cookie"]
    }
  });

  app.use((req, res, next) => {
    Object.assign(req, {
      pubClient,
      io,
      ioRedis
    });

    next();
  });

  Object.assign(module.exports, { io, pubClient, ioRedis });

  return { pubClient, io, ioRedis };
};

/**
 * Main function to start the server
 * @returns {Promise<void>}
 */
const main = async () => {
  const app = express();
  const port = process.env.PORT || 5000;

  const server = http.createServer(app);

  const { pubClient, ioRedis } = await applySocketIO(server, app);
  const api = applyRedisHelpers(pubClient, app, logger);
  const ioHelpers = applyIOHelpers(app, api, ioRedis, logger);

  // Legacy Socket Events
  require("./server/web-sockets/web-socket");

  applyMiddleware(app);
  applyRoutes(app);
  redisSocketEvents(ioRedis, api, ioHelpers);

  try {
    await server.listen(port);
    logger.log(`[${process.env.NODE_ENV}] Server started on port ${port}`, "INFO", "api");
  } catch (error) {
    logger.log(`[${process.env.NODE_ENV}] Server failed to start on port ${port}`, "ERROR", "api", error);
  }
};

// Start server
main().catch((error) => {
  logger.log(`Main-API-Error: Something was not caught in the application.`, "error", "api", null, {
    error: error.message,
    errorjson: JSON.stringify(error)
  });
  // Note: If we want the app to crash on all uncaught async operations, we would
  // need to put a `process.exit(1);` here
});