graphql-compose-mongoose/es/discriminators/prepareBaseResolvers.js

Plugin for `graphql-compose` which derive a graphql types from a mongoose model.

import { graphql } from 'graphql-compose';
import { EMCResolvers } from '../resolvers';
import { DiscriminatorTypeComposer } from './DiscriminatorTypeComposer';
const {
  GraphQLList,
  GraphQLNonNull
} = graphql; // change type on DKey generated by composeWithMongoose
// set it to created enum TypeComposer for DKey DKeyETC
// only sets on filter and record typeComposers, since they contain our DKey

function setDKeyEnumOnITCArgs(resolver, baseTC) {
  // setDKeyEnum for filter types, and on record types
  if (resolver) {
    const argNames = resolver.getArgNames();

    for (const argName of argNames) {
      if (argName === 'filter' || argName === 'record' || argName === 'records') {
        const filterArgTC = resolver.getArgTC(argName);

        if (filterArgTC) {
          filterArgTC.extendField(baseTC.getDKey(), {
            type: baseTC.getDKeyETC()
          });
        }
      }
    }
  }
} // recomposing sets up the DInterface as the return types for
// Also sets up DKey enum as type for DKey field on composers with filter and/or record args
// composeWithMongoose composers


export function prepareBaseResolvers(baseTC) {
  for (const resolverName in EMCResolvers) {
    if (EMCResolvers.hasOwnProperty(resolverName) && baseTC.hasResolver(resolverName)) {
      const resolver = baseTC.getResolver(resolverName);

      switch (resolverName) {
        case EMCResolvers.findMany:
        case EMCResolvers.findByIds:
          resolver.setType(new GraphQLList(baseTC.getDInterface().getType()));
          break;

        case EMCResolvers.findById:
        case EMCResolvers.findOne:
          resolver.setType(baseTC.getDInterface());
          break;

        case EMCResolvers.createOne:
        case EMCResolvers.updateOne:
        case EMCResolvers.updateById:
        case EMCResolvers.removeOne:
        case EMCResolvers.removeById:
          resolver.getTypeComposer().extendField('record', {
            type: baseTC.getDInterface()
          });
          break;

        case EMCResolvers.createMany:
          resolver.getTypeComposer().extendField('records', {
            type: new GraphQLNonNull(GraphQLList(baseTC.getDInterface().getType()))
          });
          break;

        case EMCResolvers.pagination:
          resolver.getTypeComposer().extendField('items', {
            type: new GraphQLList(baseTC.getDInterface().getType())
          });
          break;

        case EMCResolvers.connection:
          const edgesTC = resolver // eslint-disable-line no-case-declarations
          .getTypeComposer().getFieldTC('edges').clone(`${baseTC.getTypeName()}Edge`);
          edgesTC.extendField('node', {
            type: new GraphQLNonNull(baseTC.getDInterface().getType())
          });
          resolver.getTypeComposer().setField('edges', new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(edgesTC.getType()))));
          break;

        default:
      }

      setDKeyEnumOnITCArgs(resolver, baseTC); // set DKey as required field to create from base
      // must be done after setting DKeyEnum

      if (resolverName === EMCResolvers.createOne || resolverName === EMCResolvers.createMany) {
        const fieldName = resolverName === EMCResolvers.createMany ? 'records' : 'record';
        resolver.getArgTC(fieldName).extendField(baseTC.getDKey(), {
          type: baseTC.getDKeyETC().getTypeNonNull()
        });
      }
    }
  }
}