charlotte-graphql/lib/resolvers.js

Generates GraphQL type definitions and resolvers off of a concise spec.

'use strict';

const _ = require('lodash');
const { expandTypes } = require('./helpers');

const createResolvers = ({
  types,
  typesExpanded,
  adapter
}) => {
  typesExpanded = typesExpanded || expandTypes(types);

  const resolvers = {
    Query: {},
    Mutation: {}
  };

  _.each(typesExpanded, type => {
    const typeFieldResolvers = resolvers[type.name] = {};

    // Add field resolvers
    _.each(type.fields, field => {
      if (field.type.isScalar) {
        return;
      }

      // Resolve reciprocal fields
      if (field.reciprocalOf) {
        typeFieldResolvers[field.name] = (parent, args) => {
          const conditions = field.reciprocalOf.map(_field => {
            return Object.assign({
              [_field.name]: [{ uuid: [parent.uuid] }]
            }, args);
          });

          return adapter.find(field.reciprocalOf[0].parentType, { conditions });
        };

        return;
      }

      // Resolve relations
      typeFieldResolvers[field.name] = parent => {
        return parent[field.name] && parent[field.name].uuid
          ? adapter.get(field.type, parent[field.name].uuid)
          : adapter.get(type, parent).then(result => result[field.name]);
      };
    });

    // Get a hyperedge
    resolvers.Query[type.nameCamel] = (parent, arg) => {
      return adapter.get(type, arg);
    };

    // Find hyperedges
    resolvers.Query[type.pluralCamel] = (parent, args) => {
      return adapter.find(type, args);
    };

    // Create hyperedge
    resolvers.Mutation['create' + type.name] = (parent, args) => {
      return adapter.create(type, args);
    };

    // Update matching hyperedges
    resolvers.Mutation['update' + type.plural] = (parent, args) => {
      return adapter.update(type, args);
    };

    // Update a particular hyperedge
    resolvers.Mutation['update' + type.name] = (parent, { uuid, updates }) => {
      return adapter
        .update(type, {
          conditions: [{ uuid: [uuid] }],
          updates
        })
        .then(results => {
          return results[0];
        });
    };

    // Remove hyperedge
    resolvers.Mutation['remove' + type.name] = (parent, arg) => {
      return adapter.remove(type, arg);
    };
  });

  return resolvers;
};

module.exports = {
  createResolvers
};