@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;
    }

    _loadService( file ) {
        debug("_loadService", 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 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-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) => {
                this._services.push(
                    this._loadService( file )
                );
            });

            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 ) {

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

        this._app = null;
        this._server = null;
        this._services = [];
        this._views = [];
        this._routerPaths = [];

        process.motif = this;
    }

    run( ) {

        this._attachExceptionHandlers();

        this._loadServices();
    }

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

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

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

};

module.exports = Process;