openapi-client-sdk-loader/dist/compile/utils.js

An Open API loader for webpack. Compiles yaml to client sdk.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.parseResponses = exports.parseResponse = exports.parseBody = exports.parseParams = exports.isApplicationJson = exports.prepareMimeType = void 0;

var _lodash = require("lodash");

var _utils = require("../utils");

const prepareMimeType = mimeType => (0, _utils.dashes2capitals)((0, _utils.basepath)(mimeType.split(';')[0]));

exports.prepareMimeType = prepareMimeType;

const isApplicationJson = mimeType => mimeType.startsWith('application/json') || mimeType.startsWith('application/hal+json');

exports.isApplicationJson = isApplicationJson;

const parseParams = schemas => schemas.reduce((prevParams, {
  name,
  in: inPath,
  required,
  schema
}) => {
  const inName = inPath === 'path' ? 'params' : inPath;
  const params = { ...prevParams
  };

  if (!params[inName]) {
    params[inName] = {
      type: 'object',
      required: [],
      properties: {},
      additionalProperties: false
    };
  }

  params[inName].properties[name] = schema;

  if (required) {
    params[inName].required.push(name);
  }

  return params;
}, {});

exports.parseParams = parseParams;

const normalizeMultipartSchema = schema => {
  const normalizedSchema = (0, _lodash.cloneDeep)(schema);

  if (normalizedSchema.type === 'string' && normalizedSchema.format === 'binary') {
    normalizedSchema.type = 'object';
  }

  if (normalizedSchema.type === 'object' && normalizedSchema.properties) {
    normalizedSchema.properties = (0, _lodash.toPairs)(normalizedSchema.properties).reduce((nextProperties, [propName, props]) => {
      return { ...nextProperties,
        [propName]: normalizeMultipartSchema(props)
      };
    }, {});
  }

  if (normalizedSchema.type === 'array' && normalizedSchema.items) {
    normalizedSchema.items = normalizeMultipartSchema(normalizedSchema.items);
  }

  return normalizedSchema;
};

const parseBody = requestBody => {
  if (Object.keys(requestBody).length) {
    const mimeType = Object.keys(requestBody).find(isApplicationJson) || Object.keys(requestBody)[0];
    return {
      mimeType,
      mimeTypeSuffix: prepareMimeType(mimeType),
      data: mimeType.startsWith('multipart/form-data') ? normalizeMultipartSchema(requestBody[mimeType].schema) : requestBody[mimeType].schema
    };
  }

  return {};
};

exports.parseBody = parseBody;

const parseResponse = response => {
  if (!response || !response.content || !Object.keys(response.content)) {
    return [{}, []];
  }

  const pairs = (0, _lodash.toPairs)(response.content);
  const jsonResponse = pairs.find(([contentType]) => isApplicationJson(contentType));
  return [jsonResponse && jsonResponse[1] && jsonResponse[1].schema || {}, pairs.map(([contentType]) => contentType)];
};

exports.parseResponse = parseResponse;

const parseResponses = operationResponses => ({
  responses: (0, _lodash.toPairs)(operationResponses).reduce((result, [statusCode, response]) => {
    const [responses, contentTypes] = parseResponse(response);
    return { ...result,
      [statusCode]: {
        response: Object.keys(responses).length ? responses : null,
        contentTypes: contentTypes.length ? contentTypes : null
      }
    };
  }, {})
});

exports.parseResponses = parseResponses;