@shoutem/redux-io/schemaConfig.js

'use strict';

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.validateSchemaConfig = validateSchemaConfig;
exports.resolveConfig = resolveConfig;
exports.buildEndpoint = buildEndpoint;
exports.resolveSchemaName = resolveSchemaName;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _zSchema = require('z-schema');

var _zSchema2 = _interopRequireDefault(_zSchema);

var _urijs = require('urijs');

var _urijs2 = _interopRequireDefault(_urijs);

var _status = require('./status');

var _consts = require('./consts');

var _rio = require('./rio');

var _rio2 = _interopRequireDefault(_rio);

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

var validator = new _zSchema2.default();
var schemaDefinition = {
  type: 'object',
  properties: {
    schema: {
      type: 'string'
    },
    request: {
      type: 'object',
      properties: {
        endpoint: {
          type: 'string'
        },
        headers: {
          type: 'object'
        },
        method: {
          type: 'string'
        },
        types: {
          type: 'array'
        },
        resourceType: {
          type: 'string'
        },
        body: {
          type: ['object', 'string']
        }
      },
      additionalProperties: false,
      required: ['endpoint', 'headers']
    },
    actions: {
      type: 'object'
    }
  },
  additionalProperties: false,
  required: ['schema', 'request']
};

/**
 * Validates schema configuration using AJV library and json-schema convention.
 * Returns useful errors to enable developer easier fixing invalid schema configuration.
 * @param config
 */
function validateSchemaConfig(config) {
  var validResult = validator.validate(config, schemaDefinition);
  if (!validResult) {
    var validationErrorsMsg = JSON.stringify(validator.getLastErrors());
    var configMsg = JSON.stringify(config);
    throw new Error('Schema configuration is invalid. Error: ' + validationErrorsMsg + '.' + (' Invalid schema config: ' + configMsg));
  }
}

/**
 * Encapsulates additional logic around rio.resolveSchema. In case schema argument is object,
 * function merges argument configuration with registered configuration in rio. Allowing
 * overriding base configuration.
 * @param schema
 * @returns config
 */
function resolveConfig(schema) {
  if (_lodash2.default.isString(schema)) {
    return _rio2.default.getSchema(schema);
  } else if (_lodash2.default.isObject(schema)) {
    var argConfig = schema;
    var rioConfig = _rio2.default.getSchema(argConfig.schema);
    var resolvedSchema = _lodash2.default.merge(rioConfig, argConfig);
    validateSchemaConfig(resolvedSchema);
    return resolvedSchema;
  }
  return undefined;
}

/**
 * Replace endpoint placeholders '{key}' with corresponding value of key in params dict.
 * Unused params are resolved into query params as 'key=value' pairs and concatenated to endpoint
 * @param endpoint
 * @param params
 * @param options
 * @returns {string}
 */
function buildEndpoint(endpoint) {
  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

  var isEndpointResolved = options[_consts.RESOLVED_ENDPOINT];
  if (isEndpointResolved) {
    return endpoint;
  }

  var usedParams = [];
  var paramEndpoint = endpoint.replace(/{(\w+)}/g, function (match, key) {
    usedParams.push(key);
    return _lodash2.default.get(params, [key], '');
  });

  var unusedQueryParams = _lodash2.default.omit(params, usedParams);

  var paramEndpointUri = new _urijs2.default(paramEndpoint);

  var resolvedQueryParams = _extends({}, paramEndpointUri.query(true), unusedQueryParams);

  return paramEndpointUri.query(resolvedQueryParams).toString();
}

function resolveSchemaName(reference, schema) {
  var referenceSchema = _lodash2.default.get((0, _status.getStatus)(reference), 'schema');

  var isReferenceSchemaValid = !_lodash2.default.isEmpty(referenceSchema) && _lodash2.default.isString(referenceSchema);
  var isArgumentSchemaValid = !_lodash2.default.isEmpty(schema) && _lodash2.default.isString(schema);

  if (isReferenceSchemaValid && isArgumentSchemaValid) {
    // eslint-disable-next-line no-console
    console.warn('getCollection or getOne gets both reference schema (' + referenceSchema + ')' + (' and argument schema (' + schema + '). Reference schema has priority') + ' over schema argument.');
  }
  if (!isReferenceSchemaValid && !isArgumentSchemaValid) {
    throw new Error('Missing schema name in getCollection or getOne function. Schema needs to' + ' be defined in reference or as argument.');
  }

  if (isReferenceSchemaValid) {
    return referenceSchema;
  }
  return schema;
}