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