rest-chronicle/lib/reporters/Swagger.js

autodocumentate rest api

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _util = require("util");
var _fsExtra = _interopRequireDefault(require("fs-extra"));
var _dotProp = _interopRequireDefault(require("dot-prop"));
var _constants = require("../constants");
var _utils = require("./utils");
var _Base = _interopRequireDefault(require("./Base"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
class SwaggerReporter extends _Base.default {
  constructor(file, {
    hash
  } = {}) {
    super(file);
    _defineProperty(this, "mergeArray", true);
    if (hash) this.getHash = hash;
  }
  _renderHeaders(headers) {
    if (!headers) return [];
    return Object.entries(headers).map(([name, value]) => ({
      name,
      in: 'header',
      'schema': {
        type: (0, _utils.detectType)(value)
      },
      example: value
    }));
  }
  _renderBody(body) {
    const result = {
      type: (0, _utils.detectType)(body),
      example: body
    };
    if (body === null) result.nullable = true;
    if (Buffer.isBuffer(body)) {
      return {
        type: 'string',
        format: 'binary',
        example: (0, _util.inspect)(body)
      };
    }
    if (body && result.type === 'object') {
      for (const [key, value] of Object.entries(body)) {
        _dotProp.default.set(result, `properties.${key}`, this._renderBody(value));
      }
    }
    return result;
  }
  _renderAction({
    context: {
      group,
      title
    },
    request,
    response
  }) {
    return {
      tags: [group],
      description: title,
      parameters: [...this._renderHeaders(request.headers)],
      requestBody: request.body ? {
        content: {
          [request.info.type]: {
            schema: this._renderBody(request.body)
          }
        }
      } : undefined,
      responses: {
        [response.status.code]: {
          description: title,
          content: {
            [response.info.type]: {
              schema: this._renderBody(response.body)
            }
          }
        }
      }
    };
  }
  _generate(groups, map, actions) {
    const paths = {};
    const origins = [...new Set(actions === null || actions === void 0 ? void 0 : actions.map(a => a.request.origin))];
    for (const [path, methods] of Object.entries(groups)) {
      for (const [method, actionIds] of Object.entries(methods)) {
        const methodName = method.toLowerCase();
        for (const id of actionIds) {
          const action = map.get(id);
          const hash = _dotProp.default.get(paths, `${path}.${methodName}`) ? `#${this.getHash(action)}` : '';
          _dotProp.default.set(paths, `${path}${hash}.${methodName}`, this._renderAction(action));
        }
      }
    }
    const content = {
      openapi: '3.0.0',
      info: {
        version: '1.0.0',
        title: 'Swagger Report'
      },
      servers: origins.map(url => ({
        url
      })),
      paths
    };
    return JSON.stringify(content, null, _constants.DEFAULT_JSON_OFFSET);
  }
  async write(actions) {
    const {
      groups,
      map
    } = this._build(actions, {
      groupBy: ['request.path', 'request.method']
    });
    const content = this._generate(groups, map, actions);
    await _fsExtra.default.writeFile(this.file, content);
  }
}
exports.default = SwaggerReporter;