gatsby-source-morty/gatsby-node.js

Gatsby source plugin for building websites using the Morty CMS as a data source

'use strict';

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var _extends3 = _interopRequireDefault(_extends2);

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

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

var _keys2 = _interopRequireDefault(_keys);

var _of = require('babel-runtime/core-js/array/of');

var _of2 = _interopRequireDefault(_of);

var sourceNodes = function () {
  var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(_ref2, pluginOptions) {
    var boundActionCreators = _ref2.boundActionCreators,
        getNode = _ref2.getNode;
    var createNode, schema, graphqlSchema, queryAst, errors, result, operationAst, fragments, findFields, makeNodes, typeInfo, fields;
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            createNode = boundActionCreators.createNode;
            _context.next = 3;
            return (0, _utils.getSchema)(pluginOptions);

          case 3:
            schema = _context.sent;
            graphqlSchema = (0, _utilities.buildClientSchema)(schema.data);
            queryAst = (0, _language.parse)(_dataQuery2.default);
            errors = (0, _validation.validate)(graphqlSchema, queryAst);

            if (!errors.length) {
              _context.next = 10;
              break;
            }

            console.log(errors);
            throw new Error('Not a valid query, you likely need to upgrade the gatsby-source-morty plugin');

          case 10:
            _context.prev = 10;
            _context.next = 13;
            return (0, _utils.fetchData)(pluginOptions, {
              query: _dataQuery2.default
            });

          case 13:
            result = _context.sent;
            operationAst = (0, _utilities.getOperationAST)(queryAst);


            if (operationAst) {
              fragments = gatherFragmentsFromAst(queryAst);
              findFields = buildFindFields(fragments);
              makeNodes = buildMakeNodes(findFields, createNode);
              typeInfo = new _utilities.TypeInfo(graphqlSchema);
              fields = gatherFields(operationAst.selectionSet.selections, result.data);


              typeInfo.enter(operationAst);
              iterateFields(typeInfo, operationAst, fields, result.data, makeNodes);
            }
            _context.next = 21;
            break;

          case 18:
            _context.prev = 18;
            _context.t0 = _context['catch'](10);

            console.log(_context.t0);

          case 21:
            return _context.abrupt('return');

          case 22:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this, [[10, 18]]);
  }));

  return function sourceNodes(_x2, _x3) {
    return _ref.apply(this, arguments);
  };
}();

var _lodash = require('lodash');

var _validation = require('graphql/validation');

var _utilities = require('graphql/utilities');

var _language = require('graphql/language');

var _dataQuery = require('./dataQuery.graphql');

var _dataQuery2 = _interopRequireDefault(_dataQuery);

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

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

var typePrefix = 'Morty';
var makeTypeName = function makeTypeName(type) {
  return (0, _lodash.upperFirst)((0, _lodash.camelCase)(typePrefix + ' ' + type));
};

function flatten(arr) {
  return [].concat.apply([], arr);
}

exports.onCreateNode = require('./on-create-node').onCreateNode;

var SPECIAL_FIELDS = ['bannerImage', 'abstractPhoto', 'headshot', 'image', 'attributionPhoto', 'descriptionListItems'];

function gatherFragmentsFromAst(ast) {
  return ast.definitions.filter(function (d) {
    return d.kind === 'FragmentDefinition';
  }).reduce(function (acc, d) {
    acc[d.name.value] = d.selectionSet.selections;
    return acc;
  }, {});
}

function makeArray(items) {
  if (!Array.isArray(items)) {
    return (0, _of2.default)(items);
  }
  return items;
}

function gatherFields(fields, data) {
  return (0, _keys2.default)(data).filter(function (key) {
    return !!data[key];
  }).map(function (key) {
    return fields.find(function (s) {
      return s.name && s.name.value === key;
    });
  }).filter(function (f) {
    return !!f;
  });
}

function iterateFields(typeInfo, parentField, fields, data, makeNodes, parentId) {
  typeInfo.enter(parentField.selectionSet);
  fields.forEach(function (field) {
    typeInfo.enter(field);
    makeNodes(data[field.name.value], field, typeInfo, parentId);
    typeInfo.leave(field);
  });
  typeInfo.leave(parentField.selectionSet);
}

function buildFindFields(fragmentFields) {
  return function (selectionSet, item) {
    var allFields = selectionSet.selections.filter(function (s) {
      return s.kind !== 'FragmentSpread' || fragmentFields[s.name.value] && fragmentFields[s.name.value].typeCondition && fragmentFields[s.name.value].typeCondition.name.value === item.__typename;
    }).map(function (s) {
      if (s.kind === 'InlineFragment') {
        return flatten(s.selectionSet.selections.map(function (s) {
          if (s.kind === 'FragmentSpread') {
            return fragmentFields[s.name.value];
          }
          return s;
        }));
      }
      if (s.kind === 'FragmentSpread') {
        return fragmentFields[s.name.value];
      }
      return s;
    });
    return flatten(allFields);
  };
}

function buildMakeNodes(findFields, createNode) {
  var makeNodes = function makeNodes(items, parentField, typeInfo) {
    var parent = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '__SOURCE__';

    makeArray(items).forEach(function (item, i) {
      var fields = findFields(parentField.selectionSet, item) || [];
      var childFields = (0, _lodash.uniq)(fields.filter(function (f) {
        return f.selectionSet;
      }).map(function (f) {
        return f.name.value;
      }));

      var itemStr = (0, _stringify2.default)(item);
      var kids = (0, _lodash.pick)(item, childFields);
      var specialFields = (0, _keys2.default)(item).filter(function (field) {
        return field.slice(0, 2) === '__';
      });
      var ommittedFields = specialFields.concat((0, _lodash.omit)(childFields, SPECIAL_FIELDS));
      var itemWithoutKids = (0, _lodash.omit)(item, ommittedFields);
      var children = childFields.reduce(function (acc, c) {
        if (kids[c]) {
          makeArray(kids[c]).forEach(function (k) {
            return acc.push(k.id);
          });
        }
        return acc;
      }, []);

      if (itemWithoutKids.content) {
        itemWithoutKids.content = (0, _utils.mdToHtml)(itemWithoutKids.content);
      }

      var type = typeInfo.getType();
      var typeName = '';
      if (type && type.name) {
        typeName = String(type.name);
      } else if (type && type.ofType) {
        typeName = String(type.ofType);
      }

      var internal = {
        type: makeTypeName(typeName),
        mediaType: 'application/json'
      };

      var node = (0, _extends3.default)({}, itemWithoutKids, {
        parent: parent,
        children: children,
        internal: internal
      });

      // Get content digest of node.
      var contentDigest = (0, _utils.digest)(node);

      node.internal.contentDigest = contentDigest;
      createNode(node);

      if (childFields.length) {
        iterateFields(typeInfo, parentField, gatherFields(fields, kids), kids, makeNodes, item.id);
      }
    });
  };
  return makeNodes;
}

exports.sourceNodes = sourceNodes;