@motif/api/lib/Process.js

"use strict"

const path = require("path")
const glob = require("glob")
const fs = require("fs")
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 contextService = require('request-context')
const userAgent = require('express-useragent')

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
  }

  get constants() {
    return this._constants
  }

  get service() {
    return contextService.get('request')
  }

  _importFile(file) {
    debug("_importFile", 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({ debug: false })

    let modelFiles = []

    macro.add("INITIALIZE-CONFIG", async action => {
      await this._context.config._initialize()
      action.complete()
    })

    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)

      app.use(contextService.middleware('request'))
      app.use(require("request-ip").mw())

      app.use(function (req, res, next) {

        contextService.set('request:req', req)

        if (req.headers['user-agent']) {
          let source = req.headers['user-agent']
          let ua = userAgent.parse(source)
          contextService.set('request:ua', ua)
        }

        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-CONSTANTS", async action => {

      let constantFiles = glob.sync("data/constants/*.js", { cwd: this._context.appPath })

      for (var i = 0, max = constantFiles.length; i < max; i++) {
        let file = constantFiles[i]
        let constant = this._importFile(file)
        let key = path.basename(file, '.js').toUpperCase()

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

        this._constants[key] = constant
      }

      action.complete()
    })

    macro.add("LOAD-MODELS", async action => {

      let config = this._context.config
      let modelFiles = glob.sync("services/*/models/*.js", { cwd: this._context.appPath })

      for (var i = 0, max = modelFiles.length; i < max; i++) {
        let modelFile = modelFiles[i]
        let modelClass = this._importFile(modelFile)
        let className = modelClass.prototype.constructor.name
        let key = className.replace("Model", "")
        let model = new modelClass({config})
        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 {
          await design.initialize({
            autoCreate: process.motif.context.initMode ? true : false
          })
        } catch (e) {
          console.error("className", className, e)
        }
      }

      action.complete()
    })

    macro.add("LOAD-SERVICES", action => {
      let serviceFiles = glob.sync("services/*/*Service.js", { cwd: this._context.appPath })

      _.each(serviceFiles, file => {
        let service = this._importFile(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({
            routes: this._routerPaths,
            models: this._models,
          }, false)
          let swaggerPath = path.join(this._context.appPath, "public/swagger")
          let swaggerDataPath = path.join(this._context.appPath, "public/swagger/data")

          if (!fs.existsSync(swaggerPath)){
            fs.mkdirSync(swaggerPath)
          }

          if (!fs.existsSync(swaggerDataPath)){
            fs.mkdirSync(swaggerDataPath)
          }

          await swagger.jsonWriteAsync(
            path.join(swaggerDataPath, "swag.json"),
            json
          )

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

          app.get(path.join(this._context.docPath, "data"), (req, res) => {
            res.sendFile("data/swag.json", { root: swaggerPath })
          })

          app.get(this._context.docPath, (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({
            routes: this._routerPaths,
            models: this._models
          }, true)
          let swaggerPath = path.join(this._context.appPath, "public/swagger")
          let swaggerDataPath = path.join(this._context.appPath, "public/swagger/data")

          if (!fs.existsSync(swaggerPath)){
            fs.mkdirSync(swaggerPath)
          }

          if (!fs.existsSync(swaggerDataPath)){
            fs.mkdirSync(swaggerDataPath)
          }

          await swagger.jsonWriteAsync(
            path.join(swaggerDataPath, "swag.admin.json"),
            json
          )

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

          app.get(path.join(this._context.docPath, "admin/data"), (req, res) => {
            res.sendFile("data/swag.admin.json", { root: swaggerPath })
          })

          app.get(path.join(this._context.docPath, "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({
      motif: this,
      appPath: path.resolve(process.env.PWD, "."),
      ...options
    })

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

    debug('Motif.Process', {
      MOTIF_API_MODE: process.env.MOTIF_API_MODE,
      NODE_ENV: process.env.NODE_ENV,
      appPath: this._context.appPath,
      createDoc: this._context.createDoc,
      port: this._context.config.port,
      mode: this._context.config.mode
    })
  }

  run() {
    this._attachExceptionHandlers()

    this._loadServices()
  }

  onListening() {
    debug("onListening")
  }

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

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

module.exports = Process