@motif/core/lib/Process.js

const path = require("path");
const glob = require("glob");
const favicon = require("serve-favicon");
const _ = require("lodash");
const debug = require("debug")("motif:process");

const Macro = require("node-macro");

const http = require("http");
const express = require("express");

const session = require("express-session");
const cookieParser = require("cookie-parser");
const bodyParser = require("body-parser");
const helmet = require("helmet");
const cors = require("cors");
const formidable = require("formidable");

const Context = require("./Context");
const Swagger = require("./Swagger");

class Process {

  get app() {
    return this._app;
  }

  get context() {
    return this._context;
  }

  get models() {
    return this._models;
  }

  _importClassFile(file) {
    debug("_importClassFile", file);
    delete require.cache[
      require.resolve(path.resolve(this._context.appPath, file))
    ];
    return require(path.resolve(this._context.appPath, file));
  }

  _loadServices() {
    debug("_loadServices");

    const macro = new Macro();

    let modelFiles = [],
      serviceFiles = [];

    macro.add("CREATE-APP", action => {
      let app = express();
      app.use(helmet());
      app.use(bodyParser.urlencoded({ extended: false }));
      app.use(bodyParser.json());
      app.use(cors());

      if(this._context.useCookie === true) {
        app.use(cookieParser());
      }

      if(this._context.useFavicon === true) {
        app.use(
          favicon(path.join(this._context.appPath, "public", "favicon.ico"))
        );
      }

      if(this._context.useProxy === true) {
        app.set("trust proxy", true);
      }

      app.on("uncaughtException", this.onException);

      // file uploader
      app.use(function (req, res, next) {
        if(
          req.headers["content-type"] &&
          req.headers["content-type"].indexOf("multipart/form-data") > -1
        ) {
          // 멀티파트 데이터
          const form = new formidable.IncomingForm({
            encoding: "utf-8",
            multiples: true,
            type: "multipart", // or urlencoded
            maxFieldsSize: 20 * 1024 * 1024,
            maxFileSize: 200 * 1024 * 1024,
            maxFields: 1000,
            hash: true,
            keepExtensions: false
          });
          form.parse(req, function (err, fields) {
            _.merge(req.body, fields);
            req.openedFiles = [];
          });
          form.on("file", function (name, file) {
            if(!req.files) {
              req.files = {};
            }
            req.files[name] = file;
            req.body[name] = file;
          });
          form.on("end", function () {
            req.openedFiles = this.openedFiles;
            next();
          });
        } else {
          next();
        }
      });

      this._app = app;
      action.complete();
    });

    macro.add("LOAD-MODEL-FILES", action => {
      glob(
        "services/*/models/*.js", { cwd: this._context.appPath },
        (err, files) => {
          if(err) {
            action.error(err);
            return;
          }

          modelFiles = files;
          action.complete();
        }
      );
    });

    macro.add("LOAD-MODELS", async action => {
      for(var i = 0, max = modelFiles.length; i < max; i++) {
        let modelFile = modelFiles[i];
        let modelClass = this._importClassFile(modelFile);
        let className = modelClass.prototype.constructor.name;
        let key = className.replace("Model", "");
        let model = new modelClass();
        let design = model.createDesign();

        if(this._models[key]) {
          console.warn(`${key} model with the same name is already created.`);
        }

        this._models[key] = {
          name: key,
          constructor: modelClass,
          design: design
        };

        try {
          console.log("design initialize", className);
          await design.initialize();
        } catch (e) {
          console.error("className", className, e);
        }
      }

      action.complete();
    });

    macro.add("LOAD-SERVICE-FILES", action => {
      glob(
        "services/*/*Service.js", { cwd: this._context.appPath },
        (err, files) => {
          if(err) {
            action.error(err);
            return;
          }

          serviceFiles = files;
          action.complete();
        }
      );
    });

    macro.add("LOAD-SERVICES", action => {
      _.each(serviceFiles, file => {
        let service = this._importClassFile(file);

        this._services.push(service);
      });

      action.complete();
    });

    if(this._context.createDoc === true) {
      macro.add("CRAETE-SWAGGER-DOCS", async action => {
        try {
          let app = this._app;
          let swagger = new Swagger(this._context);

          let json = swagger.buildJSON(this._routerPaths, false);
          let swaggerPath = path.join(this._context.appPath, "public/swagger");

          await swagger.jsonWriteAsync(
            path.join(swaggerPath, "/data/swag.json"),
            json
          );

          app.use(
            express.static(
              path.join(this._context.appPath, "public", "swagger")
            )
          );

          app.get("/doc/data", (req, res) => {
            res.sendFile("data/swag.json", { root: swaggerPath });
          });

          app.get("/doc", (req, res) => {
            res.sendFile("index.html", { root: swaggerPath });
          });
        } catch (e) {
          console.log(e);
        }

        action.complete();
      });

      macro.add("CRAETE-SWAGGER-ADMIN-DOCS", async action => {
        try {
          let app = this._app;
          let swagger = new Swagger(this._context);

          let json = swagger.buildJSON(this._routerPaths, true);
          let swaggerPath = path.join(this._context.appPath, "public/swagger");

          await swagger.jsonWriteAsync(
            path.join(swaggerPath, "/data/swag.admin.json"),
            json
          );

          app.use(
            express.static(
              path.join(this._context.appPath, "public", "swagger")
            )
          );

          app.get("/doc/data-admin", (req, res) => {
            res.sendFile("data/swag.admin.json", { root: swaggerPath });
          });

          app.get("/doc-admin", (req, res) => {
            res.sendFile("index.admin.html", { root: swaggerPath });
          });
        } catch (e) {
          console.log(e);
        }

        action.complete();
      });
    }

    macro.add("RUN-SERVER", action => {
      let server = http.createServer(this._app);
      server.listen(this.context.port, () => {
        debug(`Server is running on port ${this.context.port}`);
      });
      server.on("error", this.onError);
      server.on("listening", this.onListening);

      this._server = server;

      action.complete();
    });

    macro.start(error => {
      if(error) {
        debug(error);
      }
    });
  }

  _attachExceptionHandlers() {
    process.on("uncaughtException", async function (err) {
      console.error(err.stack);
      process.exit(1);
    });

    process.on("unhandledRejection", async function (err) {
      console.error(err.stack);
      process.exit(1);
    });
  }

  constructor(options) {

    process.motif = this;

    this._context = new Context({
      appPath: path.resolve(process.env.PWD, "."),
      ...options
    });

    this._app = null;
    this._server = null;
    this._models = {};
    this._services = [];
    this._routerPaths = [];
  }

  run() {
    this._attachExceptionHandlers();

    this._loadServices();
  }

  onListening() {
    debug("onListening");
  }

  onException(req, res, route, err) {
    debug("onException", err);
  }

  onError(error) {
    debug("onError", error);
  }
}

module.exports = Process;