@motif/api/lib/Swagger.js

"use strict"

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: _.filter(tags, tag => { return tag !== 'admin' }),
      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/BasicResult"
              }
            }
          }
        }
      }
    }

    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( "(\\d+)", "" )
          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
  }

  getSchemaInfos(model) {
    const modelObjects = []
    const schemaLength = model.design._schemas.length
    if (schemaLength > 0) {
      _.forEach(model.design._schemas, schema => {

        const properties = {}
        _.map(schema.attributes, attribute => {
          if (attribute.length) {
            properties[attribute.key] = {
              type: `${attribute.type}(${attribute.length})`
            }
          }
          else {
            properties[attribute.key] = {
              type: `${attribute.type}`
            }
          }
        })

        const modelObject = {
          name: schema.default === true ? model.name : `${model.name}.${schema.name}`,
          description: schema.description || "",
          properties: properties
        }

        modelObjects.push(modelObject)
      })
    }
    return modelObjects
  }

  buildModels(models) {
    const modelObjects = {}

    _.forEach(models, model => {
      let schemaInfos = this.getSchemaInfos(model)

      _.forEach(schemaInfos, schemaInfo => {
        modelObjects[schemaInfo.name] = schemaInfo
      })
    })

    return modelObjects
  }

  getErrors() {
    let constaints = this._context.constants["ERROR"] || {}
    let errors = {}
    for (var key in constaints) {
      let constaint = constaints[key]
      let errorComponents = constaint.split(":")
      let error = {
        type: errorComponents[1]
      }

      errors[errorComponents[0]] = error
    }
    return errors
  }

  buildJSON(options = {}, isAdmin = false) {
    const { routes, models } = options
    const routePaths = this.buildPaths(routes, isAdmin)
    const host = this._config.host ?
      this._config.host :
      ip.address() + ":" + this._context.port

    const modelObjects = this.buildModels(models, isAdmin)
    const errors = this.getErrors()

    const json = {
      swagger: "2.0",
      info: {
        title: this._config.title || "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: {
        "BasicResult": {
          type: "object",
          properties: {
            error: {
              $ref: "#/definitions/CommonError"
            },
            status: {
              type: "string"
            },
            data: {
              type: "json"
            }
          }
        },
        "CommonError": {
          type: "object",
          properties: errors
        },
        ...modelObjects
      },
      host: host,
      basePath: "/",
      schemes: this._config.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