graphbrainz/lib/resolvers.js

'use strict';

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

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _extends3 = require('babel-runtime/helpers/extends');

var _extends4 = _interopRequireDefault(_extends3);

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

var _keys2 = _interopRequireDefault(_keys);

exports.includeRelationships = includeRelationships;
exports.includeSubqueries = includeSubqueries;
exports.resolveLookup = resolveLookup;
exports.resolveBrowse = resolveBrowse;
exports.resolveSearch = resolveSearch;
exports.resolveRelationship = resolveRelationship;
exports.resolveLinked = resolveLinked;
exports.createSubqueryResolver = createSubqueryResolver;
exports.resolveDiscReleases = resolveDiscReleases;

var _helpers = require('./types/helpers');

var _graphqlRelay = require('graphql-relay');

var _util = require('./util');

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

function includeRelationships(params, info) {
  var fragments = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : info.fragments;

  var fields = (0, _util.getFields)(info, fragments);
  if (info.fieldName !== 'relationships') {
    if (fields.relationships) {
      fields = (0, _util.getFields)(fields.relationships, fragments);
    } else {
      if (fields.edges) {
        fields = (0, _util.getFields)(fields.edges, fragments);
        if (fields.node) {
          return includeRelationships(params, fields.node, fragments);
        }
      }
      return params;
    }
  }
  if (fields) {
    var relationships = (0, _keys2.default)(fields);
    var includeRels = relationships.map(function (field) {
      return (0, _helpers.toDashed)((0, _helpers.toSingular)(field)) + '-rels';
    });
    if (includeRels.length) {
      params = (0, _extends4.default)({}, params, {
        inc: (0, _util.extendIncludes)(params.inc, includeRels)
      });
    }
  }
  return params;
}

function includeSubqueries(params, info) {
  var fragments = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : info.fragments;

  var subqueryIncludes = {
    aliases: ['aliases'],
    artistCredit: ['artist-credits'],
    artistCredits: ['artist-credits'],
    isrcs: ['isrcs'],
    media: ['media', 'discids'],
    rating: ['ratings'],
    tags: ['tags']
  };
  var fields = (0, _util.getFields)(info, fragments);
  var include = [];
  for (var key in subqueryIncludes) {
    if (fields[key]) {
      var value = subqueryIncludes[key];
      include.push.apply(include, (0, _toConsumableArray3.default)(value));
    }
  }
  params = (0, _extends4.default)({}, params, {
    inc: (0, _util.extendIncludes)(params.inc, include)
  });
  if (fields.edges) {
    fields = (0, _util.getFields)(fields.edges, fragments);
    if (fields.node) {
      params = includeSubqueries(params, fields.node, fragments);
    }
  }
  return params;
}

function resolveLookup(root, _ref, _ref2, info) {
  var mbid = _ref.mbid,
      params = (0, _objectWithoutProperties3.default)(_ref, ['mbid']);
  var loaders = _ref2.loaders;

  if (!mbid && !params.resource) {
    throw new Error('Lookups by a field other than MBID must provide: resource');
  }
  var entityType = (0, _helpers.toDashed)(info.fieldName);
  params = includeSubqueries(params, info);
  params = includeRelationships(params, info);
  return loaders.lookup.load([entityType, mbid, params]);
}

function resolveBrowse(root, _ref3, _ref4, info) {
  var first = _ref3.first,
      after = _ref3.after,
      _ref3$type = _ref3.type,
      type = _ref3$type === undefined ? [] : _ref3$type,
      _ref3$status = _ref3.status,
      status = _ref3$status === undefined ? [] : _ref3$status,
      discID = _ref3.discID,
      isrc = _ref3.isrc,
      iswc = _ref3.iswc,
      args = (0, _objectWithoutProperties3.default)(_ref3, ['first', 'after', 'type', 'status', 'discID', 'isrc', 'iswc']);
  var loaders = _ref4.loaders;

  var pluralName = (0, _helpers.toDashed)(info.fieldName);
  var singularName = (0, _helpers.toSingular)(pluralName);
  var params = (0, _extends4.default)({}, args, {
    type: type,
    status: status,
    limit: first,
    offset: (0, _graphqlRelay.getOffsetWithDefault)(after, -1) + 1 || undefined
  });
  params = includeSubqueries(params, info);
  params = includeRelationships(params, info, info.fragments);
  var formatParam = function formatParam(value) {
    return value.toLowerCase().replace(/ /g, '');
  };
  params.type = params.type.map(formatParam);
  params.status = params.status.map(formatParam);
  var request = void 0;
  if (discID) {
    request = loaders.lookup.load(['discid', discID, params]);
    // If fetching releases by disc ID, they will already include the `media`
    // and `discids` subqueries, and it is invalid to specify them.
    if (params.inc) {
      params.inc = params.inc.filter(function (value) {
        return value !== 'media' && value !== 'discids';
      });
    }
  } else if (isrc) {
    request = loaders.lookup.load(['isrc', isrc, params]);
  } else if (iswc) {
    request = loaders.lookup.load(['iswc', iswc, params]);
  } else {
    request = loaders.browse.load([singularName, params]);
  }
  return request.then(function (list) {
    // Grab the list, offet, and count from the response and use them to build
    // a Relay connection object.
    var arraySlice = list[pluralName],
        _list$ = list[singularName + '-offset'],
        sliceStart = _list$ === undefined ? 0 : _list$,
        _list$2 = list[singularName + '-count'],
        arrayLength = _list$2 === undefined ? arraySlice.length : _list$2;

    var meta = { sliceStart: sliceStart, arrayLength: arrayLength };
    var connection = (0, _graphqlRelay.connectionFromArraySlice)(arraySlice, { first: first, after: after }, meta);
    return (0, _extends4.default)({
      nodes: connection.edges.map(function (edge) {
        return edge.node;
      }),
      totalCount: arrayLength
    }, connection);
  });
}

function resolveSearch(root, _ref5, _ref6, info) {
  var after = _ref5.after,
      first = _ref5.first,
      query = _ref5.query,
      args = (0, _objectWithoutProperties3.default)(_ref5, ['after', 'first', 'query']);
  var loaders = _ref6.loaders;

  var pluralName = (0, _helpers.toDashed)(info.fieldName);
  var singularName = (0, _helpers.toSingular)(pluralName);
  var params = (0, _extends4.default)({}, args, {
    limit: first,
    offset: (0, _graphqlRelay.getOffsetWithDefault)(after, -1) + 1 || undefined
  });
  params = includeSubqueries(params, info);
  return loaders.search.load([singularName, query, params]).then(function (list) {
    var arraySlice = list[pluralName],
        sliceStart = list.offset,
        arrayLength = list.count;

    var meta = { sliceStart: sliceStart, arrayLength: arrayLength };
    var connection = (0, _graphqlRelay.connectionFromArraySlice)(arraySlice, { first: first, after: after }, meta);
    // Move the `score` field up to the edge object and make sure it's a
    // number (MusicBrainz returns a string).
    var edges = connection.edges.map(function (edge) {
      return (0, _extends4.default)({}, edge, { score: +edge.node.score });
    });
    var connectionWithExtras = (0, _extends4.default)({
      nodes: edges.map(function (edge) {
        return edge.node;
      }),
      totalCount: arrayLength
    }, connection, {
      edges: edges
    });
    return connectionWithExtras;
  });
}

function resolveRelationship(rels, args, context, info) {
  var targetType = (0, _helpers.toDashed)((0, _helpers.toSingular)(info.fieldName)).replace('-', '_');
  var matches = rels.filter(function (rel) {
    return rel['target-type'] === targetType;
  });
  // There's no way to filter these at the API level, so do it here.
  if (args.direction != null) {
    matches = matches.filter(function (rel) {
      return rel.direction === args.direction;
    });
  }
  if (args.type != null) {
    matches = matches.filter(function (rel) {
      return rel.type === args.type;
    });
  }
  if (args.typeID != null) {
    matches = matches.filter(function (rel) {
      return rel['type-id'] === args.typeID;
    });
  }
  var connection = (0, _graphqlRelay.connectionFromArray)(matches, args);
  return (0, _extends4.default)({
    nodes: connection.edges.map(function (edge) {
      return edge.node;
    }),
    totalCount: matches.length
  }, connection);
}

function resolveLinked(entity, args, context, info) {
  var parentEntity = (0, _helpers.toDashed)(info.parentType.name);
  args = (0, _extends4.default)({}, args, (0, _defineProperty3.default)({}, parentEntity, entity.id));
  return resolveBrowse(entity, args, context, info);
}

/**
 * If we weren't smart enough or weren't able to include the `inc` parameter
 * for a particular field that's being requested, make another request to grab
 * it (after making sure it isn't already available).
 */
function createSubqueryResolver() {
  var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      inc = _ref7.inc,
      key = _ref7.key;

  var handler = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (value) {
    return value;
  };

  return function (entity, args, _ref8, info) {
    var loaders = _ref8.loaders;

    key = key || (0, _helpers.toDashed)(info.fieldName);
    var promise = void 0;
    if (key in entity) {
      promise = _promise2.default.resolve(entity);
    } else {
      var entityType = entity._type,
          id = entity.id;

      var params = { inc: [inc || key] };
      promise = loaders.lookup.load([entityType, id, params]);
    }
    return promise.then(function (entity) {
      return handler(entity[key], args);
    });
  };
}

function resolveDiscReleases(disc, args, context, info) {
  var releases = disc.releases;

  if (releases != null) {
    var connection = (0, _graphqlRelay.connectionFromArray)(releases, args);
    return (0, _extends4.default)({
      nodes: connection.edges.map(function (edge) {
        return edge.node;
      }),
      totalCount: releases.length
    }, connection);
  }
  args = (0, _extends4.default)({}, args, { discID: disc.id });
  return resolveBrowse(disc, args, context, info);
}