swagger-decorator/dist/internal/babel/ast.js

Decorator for Koa2 and koa-router, Auto-Generate Swagger Docs

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _keys = require("babel-runtime/core-js/object/keys");

var _keys2 = _interopRequireDefault(_keys);

var _getIterator2 = require("babel-runtime/core-js/get-iterator");

var _getIterator3 = _interopRequireDefault(_getIterator2);

exports.generateImportDeclaration = generateImportDeclaration;
exports.generateDecoratorWithObjectParams = generateDecoratorWithObjectParams;
exports.extractFlowTypeFromClassProperty = extractFlowTypeFromClassProperty;

var _type = require("../../entity/type");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Description 生成导入语句
 * @param specifiers
 * @param source
 * @returns {{type: string, specifiers: [*], importKind: string, source: {type: string, value: string, rawValue: string, raw: string}}}
 */
function generateImportDeclaration(specifiers, source) {
  return {
    type: "ImportDeclaration",
    specifiers: [{
      type: "ImportDefaultSpecifier",
      local: {
        type: "Identifier",
        name: specifiers
      }
    }],
    importKind: "value",
    source: {
      type: "StringLiteral",
      value: source,
      rawValue: source,
      raw: "\"" + source + "\""
    }
  };
}

/**
 * Description 生成以对象参数形式传入的装饰器
 * @param calleeName
 * @param objectParams
 * @param description
 * @returns {{type: string, expression: {type: string, callee: {type: string, name: string}, arguments: [*]}}}
 */


function generateDecoratorWithObjectParams(calleeName, objectParams, description) {
  var properties = [];

  // 如果存在注释，则添加
  if (description) {
    objectParams.description = description;
  }

  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = (0, _getIterator3.default)((0, _keys2.default)(objectParams)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var key = _step.value;

      var value = objectParams[key];

      if (!_type.innerPrimitiveTypes.includes(value) && key !== "description") {
        value = {
          type: "Identifier",
          name: value
        };
      } else {
        value = {
          type: "StringLiteral",
          value: value
        };
      }

      properties.push({
        type: "ObjectProperty",
        method: false,
        shorthand: false,
        computed: false,
        key: {
          type: "Identifier",
          name: key
        },
        value: value
      });
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return {
    type: "Decorator",
    expression: {
      type: "CallExpression",
      callee: {
        type: "Identifier",
        name: calleeName
      },
      arguments: [{
        type: "ObjectExpression",
        properties: properties
      }]
    }
  };
}

/**
 * Description 从 ClassProperty 中抽取出 Flow 类型以及值信息
 * @param classProperty
 */
function extractFlowTypeFromClassProperty(classProperty) {
  var value = void 0;

  // 首先获取默认值
  if (classProperty.value) {
    value = classProperty.value.value;
  }

  // 从 Flow 中获取类型
  var type = "string";

  // 判断是否有类型声明
  if (classProperty.typeAnnotation) {
    var typeAnnotation = classProperty.typeAnnotation.typeAnnotation;

    if (typeAnnotation.type === "NumberTypeAnnotation") {
      type = "number";
    } else if (typeAnnotation.type === "StringTypeAnnotation") {
      type = "string";
    } else if (typeAnnotation.type === "GenericTypeAnnotation") {
      type = typeAnnotation.id.name;
    } else {
      return "string;";
    }
  }

  var comment = void 0;

  // 判断是否有注释
  if (classProperty.leadingComments) {
    comment = classProperty.leadingComments.reduce(function (value, obj) {
      return value + "\n" + obj.value;
    }, "").trim();
  }

  return {
    type: type,
    value: value,
    comment: comment
  };
}