@motif/core/lib/Swagger.js

const _ = require('lodash');
const jsonfile = require('jsonfile');
const shell = require('shelljs');
const ip = require('ip');
const fs = require('fs');

const debug = require('debug')('motif:swagger');

class Swagger {

    constructor( context ) {

        this._context = context;
        this._config = context.config.get("swagger");
    }

    isMultipartData( params ) {
        let isMultipartData = false;
        _.forEach(params, (param) => {
            if (param.type === 'file') {
                isMultipartData = true;
            }
        });
        return;
    }

    paramInfo( param, typeIn ) {

        const paramInfo = {
            "name": param.name,
            "in": typeIn,
            "description": param.description || 'No description',
            "required": param.optional === true ? false : true,
            "type": param.type || "string"
            // enums
        };

        if ( _.isArray(param.enum) ) {
            paramInfo.enum = param.enum;
        }

        return paramInfo;
    }

    pathInfo( route, info, isAdmin = false ) {

        const responseType = "application/json";
        const requestType = this.isMultipartData( route.params || [] )
                                ? "multipart/form-data"
                                : "application/x-www-form-urlencoded";

        const parameters = (route.params || []).map((param) => {

            const paramsTypeIn = ((route, param) => {

                if (route.path.indexOf(':' + param.name) !== -1) {
                    return 'path';
                }

                if (route.method === 'put' || route.method === 'post') {
                    return 'formData';
                }

                return 'query';
            })(route, param);

            debug( "paramsTypeIn", route.path, param.name, paramsTypeIn );

            return this.paramInfo(param, paramsTypeIn)
        });

        const tags = route.tags || [route.group];
        const isAdminAPI = tags.indexOf("admin") !== -1 || (route.permissions && route.permissions.indexOf("admin") !== -1);

        if (!isAdmin && isAdminAPI) {
            return null;
        }
        else if (isAdmin && !isAdminAPI) {
            return null;
        }

        const pathInfo = {
            "tags": tags,
            "summary": route.summary || '',
            "description": route.description || 'No description',
            "produces": [responseType],
            "consumes": [requestType],
            "parameters": parameters,
            "responses": {
                "200": {
                    "description": "A JSON result",
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/definitions/Result"
                            }
                        }
                    }
                }
            }
        };

        if ( route.permissions ) {
            pathInfo['security'] = [
                {"APIKeyHeader": []}
            ];
        }

        info[route.method] = pathInfo;

        return info;
    }

    buildPaths( routes, isAdmin = false ) {
        const routePaths = {};

        _.forEach(routes, (route) => {
            // if (!route.path) continue;
            // if (!["get", "post","put","delete"].includes(route.method)) continue;
            const routePath = (( routePath, params ) => {

                _.forEach(params, (param) => {
                    routePath = routePath.replace(':' + param.name, '{' + param.name + '}')
                })

                return routePath;
            })( route.routePath, route.params );

            debug( "routePath", routePath );

            let pathInfo = this.pathInfo(route, routePaths[routePath] || {}, isAdmin);
            if (pathInfo) {
                routePaths[routePath] = pathInfo;
            }
        });

        return routePaths;
    }

    buildJSON( routes, isAdmin = false ) {

        const routePaths = this.buildPaths( routes, isAdmin );
        const host = this._config.host ? this._config.host : ip.address() + ":" + this._context.port;

        const json = {
            "swagger": "2.0",
            "info": {
                "title": this._config.title || "Motif API",
                "description":  "Auto created swagger api document by motif",
                "version": this._config.version || "0.0.0"
            },
            "securityDefinitions": {
                "APIKeyHeader": {
                    "type": "apiKey",
                    "in": "header",
                    "name": "x-access-token"
                }
            },
            "definitions": {
                "Result": {
                    "type": "object",
                    "properties": {
                        "error": {
                            "type": "string"
                        },
                        "status": {
                            "type": "string",
                        },
                        "data": {
                            "type": "object"
                        }
                    }
                }
            },
            "host": host,
            "basePath": "/",
            "schemes": [
                "http",
                "https"
            ],
            "paths": routePaths
        };

        return json;
    }

    jsonWriteAsync( path, json ) {
        return new Promise((resolve, reject) => {
            jsonfile.writeFile(path, json, function (err) {
                if (err) {
                    console.error(`json ${path} create fail !!`);
                    return reject(err)
                }
                // console.log(`json ${path} create success`);
                resolve();
            });
        });
    }
}

module.exports = Swagger;