dafit/dist/index.js

Transform data to fit your structures

'use strict';

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

/**
 * Returns an array of resolving functions to apply
 * @param {Object} mapping A transformation map
 */
function buildResolvers(mapping = {}) {
  return Object.keys(mapping).reduce(
    (resolvers, key) => {
      const val = mapping[key];

      if (val !== null && typeof val === 'function') {
        resolvers.push({ key, fn: val });
        return resolvers;
      }

      resolvers.push({ key, fn: (value = {}) => value[key] || val });
      return resolvers;
    },
    []
  );
}

/**
 * Returns a function for handling key resolver pairs
 * @param {Object} input object
 */
function resolveKey(
  input,
  context = {},
  { isSync = false } = {}
) {
  return isSync === true
    ? ({ key, fn }) => ({ key, value: fn(input, context) })
    : ({ key, fn }) =>
        Promise.resolve(fn(input, context)).then(value => ({ key, value }));
}

const assign = Object.assign;

function resolverObject(
  resolvers,
  values,
  context = {},
  { isSync = false } = {}
) {
  return isSync
    ? resolvers
        .map(resolveKey(values, context, { isSync }))
        .reduce((o, { key, value }) => assign(o, { [key]: value }), {})
    : Promise.all(
        resolvers.map(resolveKey(values, context))
      ).then(resolvedValues =>
        resolvedValues.reduce(
          (o, { key, value }) => assign(o, { [key]: value }),
          {}
        ));
}

function invariant(predicate, error) {
  if (!predicate) throw error;
}

const mappingInvariant = mapping =>
  invariant(
    typeof mapping === 'object' && mapping !== null,
    'You must provide a mapping object'
  );

const SyncResolver = function SyncResolver(mapping) {
  mappingInvariant(mapping);

  const resolvers = buildResolvers(mapping);

  function Resolve(values, context) {
    return resolverObject(resolvers, values, context, { isSync: true });
  }
  return Resolve;
};

const Resolver = function Resolver(mapping) {
  mappingInvariant(mapping);

  const resolvers = buildResolvers(mapping);

  function Resolve(values, context) {
    return resolverObject(resolvers, values, context);
  }
  return Resolve;
};

var Resolver$1 = {
  Resolver,
  SyncResolver,
};

exports['default'] = Resolver$1;
exports.Resolver = Resolver;
exports.SyncResolver = SyncResolver;