graphql-compose-relay/lib/__mocks__/userTC.js

Plugin for `graphql-compose` which wraps graphql types with Relay specific logic.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.manyArgsWithoutInputResolver = exports.manyArgsWithInputResolver = exports.createOneResolver = exports.findByIdResolver = exports.userTC = exports.UserType = void 0;

var _graphqlCompose = require("graphql-compose");

var _graphql = require("graphql-compose/lib/graphql");

const UserType = new _graphql.GraphQLObjectType({
  name: 'User',
  fields: {
    id: {
      type: _graphql.GraphQLInt
    },
    name: {
      type: _graphql.GraphQLString
    },
    nickname: {
      type: _graphql.GraphQLString
    }
  }
});
exports.UserType = UserType;

const userTC = _graphqlCompose.schemaComposer.createObjectTC(UserType);

exports.userTC = userTC;
userTC.setRecordIdFn(obj => obj.id);

const findByIdResolver = _graphqlCompose.schemaComposer.createResolver({
  name: 'findById',
  kind: 'query',
  type: UserType,
  args: {
    _id: {
      name: '_id',
      type: new _graphql.GraphQLNonNull(_graphql.GraphQLInt)
    }
  },
  resolve: resolveParams => {
    const args = resolveParams.args || {};

    if (args._id.toString() === '1') {
      return Promise.resolve({
        id: 1,
        name: 'Pavel',
        nickname: '@nodkz'
      });
    }

    if (args._id.toString() === '2') {
      return Promise.resolve({
        id: 2,
        name: 'Lee',
        nickname: '@leeb'
      });
    }

    return Promise.resolve(null);
  }
});

exports.findByIdResolver = findByIdResolver;
userTC.setResolver('findById', findByIdResolver);

const createOneResolver = _graphqlCompose.schemaComposer.createResolver({
  name: 'createOne',
  kind: 'mutation',
  type: new _graphql.GraphQLObjectType({
    name: 'UserPayload',
    fields: {
      record: {
        type: UserType
      }
    }
  }),
  args: {
    input: {
      name: 'input',
      type: new _graphql.GraphQLInputObjectType({
        name: 'UserInput',
        fields: {
          name: {
            type: _graphql.GraphQLString
          }
        }
      })
    }
  },
  resolve: resolveParams => {
    return Promise.resolve({
      recordId: resolveParams.args.input.id,
      record: resolveParams.args && resolveParams.args.input || {}
    });
  }
});

exports.createOneResolver = createOneResolver;
userTC.setResolver('createOne', createOneResolver);

const manyArgsWithInputResolver = _graphqlCompose.schemaComposer.createResolver({
  name: 'manyArgsWithInput',
  kind: 'mutation',
  type: new _graphql.GraphQLObjectType({
    name: 'UserPayload',
    fields: {
      record: {
        type: UserType
      }
    }
  }),
  args: {
    input: {
      name: 'input',
      type: new _graphql.GraphQLInputObjectType({
        name: 'UserInput',
        fields: {
          name: {
            type: _graphql.GraphQLString
          }
        }
      })
    },
    sort: {
      name: 'sort',
      type: _graphql.GraphQLString
    },
    limit: {
      name: 'limit',
      type: _graphql.GraphQLInt
    }
  },
  resolve: resolveParams => {
    return Promise.resolve({
      recordId: resolveParams.args.input.id,
      record: resolveParams.args && resolveParams.args.input || {}
    });
  }
});

exports.manyArgsWithInputResolver = manyArgsWithInputResolver;
userTC.setResolver('manyArgsWithInput', manyArgsWithInputResolver);

const manyArgsWithoutInputResolver = _graphqlCompose.schemaComposer.createResolver({
  name: 'manyArgsWithoutInput',
  kind: 'mutation',
  type: new _graphql.GraphQLObjectType({
    name: 'UserPayload',
    fields: {
      record: {
        type: UserType
      }
    }
  }),
  args: {
    sort: {
      name: 'sort',
      type: _graphql.GraphQLString
    },
    limit: {
      name: 'limit',
      type: _graphql.GraphQLInt
    }
  },
  resolve: resolveParams => {
    return Promise.resolve({
      recordId: resolveParams.args.input.id,
      record: resolveParams.args && resolveParams.args.input || {}
    });
  }
});

exports.manyArgsWithoutInputResolver = manyArgsWithoutInputResolver;
userTC.setResolver('manyArgsWithoutInput', manyArgsWithoutInputResolver);