working on passing options for helpers via resolver generators

Author: nodkz

src/definition.js

@@ -91,3 +91,36 @@ export type ResolverMWResolveFn = _ResolverMWResolveFn;
 export type ExtendedResolveParams = ResolveParams & {
   query: MongooseQuery,
 };
+
+
+// HELPERS OPTIONS
+
+export type filterHelperArgsOpts = {
+  filterTypeName?: string,
+  isRequired?: boolean,
+  onlyIndexed?: boolean,
+  model?: MongooseModelT,
+  requiredFields?: string | string[],
+};
+
+export type sortHelperArgsOpts = {
+  sortTypeName?: string,
+};
+
+export type inputHelperArgsOpts = {
+  inputTypeName?: string,
+  removeFields?: string | string[],
+  requiredFields?: string | string[],
+  isRequired?: boolean,
+};
+
+export type limitHelperArgsOpts = {
+  defaultValue?: number,
+};
+
+export type genResolverOpts = {
+  filter?: filterHelperArgsOpts,
+  sort?: sortHelperArgsOpts,
+  input?: inputHelperArgsOpts,
+  limit?: limitHelperArgsOpts,
+}

src/resolvers/__tests__/findOne-test.js

@@ -4,11 +4,10 @@ import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import findOne from '../findOne';
 import Resolver from '../../../../graphql-compose/src/resolver/resolver';
-import { GraphQLObjectType } from 'graphql';
+import { convertModelToGraphQL } from '../../fieldsConverter';
+import { GraphQLNonNull } from 'graphql';
 
-const UserType = new GraphQLObjectType({
-  name: 'MockUserType',
-});
+const UserType = convertModelToGraphQL(UserModel, 'User');
 
 describe('findOne() ->', () => {
   let user1;
@@ -52,6 +51,18 @@ describe('findOne() ->', () => {
       expect(resolver.hasArg('filter')).to.be.true;
     });
 
+    it('should have `filter` arg only with indexed fields', async () => {
+      const result = findOne(UserModel, UserType, { filter: { onlyIndexed: true } });
+      const filterFields = result.args.filter.type._typeConfig.fields();
+      expect(filterFields).all.keys(['_id', 'name', 'employment']);
+    });
+
+    it('should have `filter` arg with required `name` field', async () => {
+      const result = findOne(UserModel, UserType, { filter: { requiredFields: 'name' } });
+      const filterFields = result.args.filter.type._typeConfig.fields();
+      expect(filterFields).deep.property('name.type').instanceof(GraphQLNonNull);
+    });
+
     it('should have `skip` arg', () => {
       const resolver = findOne(UserModel, UserType);
       expect(resolver.hasArg('skip')).to.be.true;

src/resolvers/count.js

@@ -5,20 +5,28 @@ import type {
   MongooseModelT,
   GraphQLObjectType,
   ExtendedResolveParams,
+  genResolverOpts,
 } from '../definition';
 import Resolver from '../../../graphql-compose/src/resolver/resolver';
 import { GraphQLInt } from 'graphql';
 
-import { filterHelperArgsGen, filterHelper } from './helpers/filter';
+import { filterHelperArgs, filterHelper } from './helpers/filter';
 
-export default function count(model: MongooseModelT, gqType: GraphQLObjectType): Resolver {
+
+export default function count(
+  model: MongooseModelT,
+  gqType: GraphQLObjectType,
+  opts?: genResolverOpts,
+): Resolver {
   return new Resolver({
     outputType: GraphQLInt,
     name: 'count',
     kind: 'query',
     args: {
-      ...filterHelperArgsGen(model, {
+      ...filterHelperArgs(gqType, {
         filterTypeName: `Filter${gqType.name}Input`,
+        model,
+        ...(opts && opts.filter),
       }),
     },
     resolve: (resolveParams : ExtendedResolveParams) => {

src/resolvers/createOne.js

@@ -1,18 +1,21 @@
 /* @flow */
 /* eslint-disable no-param-reassign */
-import { inputHelperArgsGen } from './helpers/input';
+import { inputHelperArgs } from './helpers/input';
 import { GraphQLObjectType } from 'graphql';
 import GraphQLMongoID from '../types/mongoid';
 
 import type {
   MongooseModelT,
   ExtendedResolveParams,
+  genResolverOpts,
 } from '../definition';
 import Resolver from '../../../graphql-compose/src/resolver/resolver';
 
+
 export default function createOne(
   model: MongooseModelT,
   gqType: GraphQLObjectType,
+  opts?: genResolverOpts,
 ): Resolver {
   const resolver = new Resolver({
     name: 'createOne',
@@ -32,10 +35,11 @@ export default function createOne(
       },
     }),
     args: {
-      ...inputHelperArgsGen(gqType, {
+      ...inputHelperArgs(gqType, {
         inputTypeName: `CreateOne${gqType.name}Input`,
         removeFields: ['id', '_id'],
         isRequired: true,
+        ...(opts && opts.input),
       }),
     },
     resolve: (resolveParams: ExtendedResolveParams) => {

src/resolvers/findById.js

@@ -4,6 +4,7 @@ import type {
   MongooseModelT,
   GraphQLObjectType,
   ExtendedResolveParams,
+  genResolverOpts,
 } from '../definition';
 import Resolver from '../../../graphql-compose/src/resolver/resolver';
 
@@ -14,7 +15,11 @@ import GraphQLMongoID from '../types/mongoid';
 
 import { projectionHelper } from './helpers/projection';
 
-export default function findById(model: MongooseModelT, gqType: GraphQLObjectType): Resolver {
+export default function findById(
+  model: MongooseModelT,
+  gqType: GraphQLObjectType,
+  opts?: genResolverOpts // eslint-disable-line no-unused-vars
+): Resolver {
   return new Resolver({
     outputType: gqType,
     name: 'findById',

src/resolvers/findByIds.js

@@ -4,6 +4,7 @@ import type {
   MongooseModelT,
   GraphQLObjectType,
   ExtendedResolveParams,
+  genResolverOpts,
 } from '../definition';
 import Resolver from '../../../graphql-compose/src/resolver/resolver';
 import mongoose from 'mongoose';
@@ -15,10 +16,14 @@ import {
 import GraphQLMongoID from '../types/mongoid';
 
 import { limitHelperArgs, limitHelper } from './helpers/limit';
-import { sortHelperArgsGen, sortHelper } from './helpers/sort';
+import { sortHelperArgs, sortHelper } from './helpers/sort';
 import { projectionHelper } from './helpers/projection';
 
-export default function findByIds(model: MongooseModelT, gqType: GraphQLObjectType): Resolver {
+export default function findByIds(
+  model: MongooseModelT,
+  gqType: GraphQLObjectType,
+  opts?: genResolverOpts
+): Resolver {
   return new Resolver({
     outputType: new GraphQLList(gqType),
     name: 'findByIds',
@@ -28,9 +33,12 @@ export default function findByIds(model: MongooseModelT, gqType: GraphQLObjectTy
         name: '_ids',
         type: new GraphQLNonNull(new GraphQLList(GraphQLMongoID)),
       },
-      ...limitHelperArgs,
-      ...sortHelperArgsGen(model, {
+      ...limitHelperArgs({
+        ...(opts && opts.limit),
+      }),
+      ...sortHelperArgs(model, {
         sortTypeName: `Sort${gqType.name}Input`,
+        ...(opts && opts.sort),
       }),
     },
     resolve: (resolveParams : ExtendedResolveParams) => {

src/resolvers/findMany.js

@@ -5,6 +5,7 @@ import type {
   MongooseModelT,
   GraphQLObjectType,
   ExtendedResolveParams,
+  genResolverOpts,
 } from '../definition';
 import Resolver from '../../../graphql-compose/src/resolver/resolver';
 import {
@@ -13,23 +14,33 @@ import {
 
 import { skipHelperArgs, skipHelper } from './helpers/skip';
 import { limitHelperArgs, limitHelper } from './helpers/limit';
-import { filterHelperArgsGen, filterHelper } from './helpers/filter';
-import { sortHelperArgsGen, sortHelper } from './helpers/sort';
+import { filterHelperArgs, filterHelper } from './helpers/filter';
+import { sortHelperArgs, sortHelper } from './helpers/sort';
 import { projectionHelper } from './helpers/projection';
 
-export default function findMany(model: MongooseModelT, gqType: GraphQLObjectType): Resolver {
+
+export default function findMany(
+  model: MongooseModelT,
+  gqType: GraphQLObjectType,
+  opts?: genResolverOpts,
+): Resolver {
   return new Resolver({
     outputType: new GraphQLList(gqType),
     name: 'findMany',
     kind: 'query',
     args: {
-      ...filterHelperArgsGen(model, {
+      ...filterHelperArgs(gqType, {
         filterTypeName: `Filter${gqType.name}Input`,
+        model,
+        ...(opts && opts.filter),
+      }),
+      ...skipHelperArgs(),
+      ...limitHelperArgs({
+        ...(opts && opts.limit),
       }),
-      ...skipHelperArgs,
-      ...limitHelperArgs,
-      ...sortHelperArgsGen(model, {
+      ...sortHelperArgs(model, {
         sortTypeName: `Sort${gqType.name}Input`,
+        ...(opts && opts.sort),
       }),
     },
     resolve: (resolveParams : ExtendedResolveParams) => {

src/resolvers/findOne.js

@@ -4,31 +4,37 @@
 import Resolver from '../../../graphql-compose/src/resolver/resolver';
 
 import { skipHelperArgs, skipHelper } from './helpers/skip';
-import { filterHelperArgsGen, filterHelper } from './helpers/filter';
-import { sortHelperArgsGen, sortHelper } from './helpers/sort';
+import { filterHelperArgs, filterHelper } from './helpers/filter';
+import { sortHelperArgs, sortHelper } from './helpers/sort';
 import { projectionHelper } from './helpers/projection';
 
 import type {
   MongooseModelT,
   GraphQLObjectType,
   ExtendedResolveParams,
+  genResolverOpts,
 } from '../definition';
 
+
 export default function findOne(
   model: MongooseModelT,
-  gqType: GraphQLObjectType
+  gqType: GraphQLObjectType,
+  opts?: genResolverOpts,
 ): Resolver {
   return new Resolver({
     outputType: gqType,
     name: 'findOne',
     kind: 'query',
     args: {
-      ...filterHelperArgsGen(model, {
+      ...filterHelperArgs(gqType, {
         filterTypeName: `Filter${gqType.name}Input`,
+        model,
+        ...(opts && opts.filter),
       }),
-      ...skipHelperArgs,
-      ...sortHelperArgsGen(model, {
+      ...skipHelperArgs(),
+      ...sortHelperArgs(model, {
         sortTypeName: `Sort${gqType.name}Input`,
+        ...(opts && opts.sort),
       }),
     },
     resolve: (resolveParams : ExtendedResolveParams) => {

src/resolvers/helpers/filter.js

@@ -1,41 +1,67 @@
 /* @flow */
+/* eslint-disable no-use-before-define */
 
-import { GraphQLInt, GraphQLInputObjectType, GraphQLNonNull } from 'graphql/type';
+import TypeComposer from '../../../../graphql-compose/src/typeComposer';
+import { GraphQLNonNull } from 'graphql/type';
+import getIndexesFromModel from '../../utils/getIndexesFromModel';
 import { toDottedObject } from '../../utils';
 import type {
   GraphQLFieldConfigArgumentMap,
   ExtendedResolveParams,
   MongooseModelT,
+  GraphQLObjectType,
+  filterHelperArgsOpts,
 } from '../../definition';
 
-export type filterHelperArgsGenOpts = {
-  filterTypeName: string,
-  isRequired?: boolean,
-};
-
-export const filterHelperArgsGen = (
-  model: MongooseModelT,
-  opts: filterHelperArgsGenOpts,
+export const filterHelperArgs = (
+  gqType: GraphQLObjectType,
+  opts: filterHelperArgsOpts,
 ): GraphQLFieldConfigArgumentMap => {
   if (!opts.filterTypeName) {
     throw new Error('You should provide `filterTypeName` in options.');
   }
+  const composer = new TypeComposer(gqType);
+
+  const removeFields = [];
+  if (opts.removeFields) {
+    if (Array.isArray(opts.removeFields)) {
+      removeFields.push(...opts.removeFields);
+    } else {
+      removeFields.push(opts.removeFields);
+    }
+  }
+
+  if (opts.onlyIndexed) {
+    if (!opts.model) {
+      throw new Error('You should provide `model` in options with mongoose model '
+                    + 'for deriving index fields.');
+    }
+
+    const indexedFieldNames = getIndexedFieldNames(opts.model);
+    Object.keys(composer.getFields()).forEach(fieldName => {
+      if (indexedFieldNames.indexOf(fieldName) === -1) {
+        removeFields.push(fieldName);
+      }
+    });
+  }
 
-  const filterType = new GraphQLInputObjectType({
-    name: opts.filterTypeName,
-    fields: {
-      age: {
-        name: 'age',
-        type: GraphQLInt, // TODO just mock, should be changed in future
-      },
-    },
-  });
+
+  const inputComposer = composer.getInputTypeComposer().clone(opts.filterTypeName);
+  inputComposer.removeField(removeFields);
+
+  if (opts.requiredFields) {
+    inputComposer.makeFieldsRequired(opts.requiredFields);
+  }
 
   return {
     filter: {
       name: 'filter',
-      type: opts.isRequired ? new GraphQLNonNull(filterType) : filterType,
-      description: 'Filter by indexed fields',
+      type: opts.isRequired
+        ? new GraphQLNonNull(inputComposer.getType())
+        : inputComposer.getType(),
+      description: opts.onlyIndexed
+        ? 'Filter only by indexed fields'
+        : 'Filter by fields',
     },
   };
 };
@@ -46,3 +72,15 @@ export function filterHelper(resolveParams: ExtendedResolveParams): void {
     resolveParams.query = resolveParams.query.where(toDottedObject(filter)); // eslint-disable-line
   }
 }
+
+export function getIndexedFieldNames(model: MongooseModelT): string[] {
+  const indexes = getIndexesFromModel(model);
+
+  const fieldNames = [];
+  indexes.forEach((indexData) => {
+    const keys = Object.keys(indexData);
+    fieldNames.push(keys[0]);
+  });
+
+  return fieldNames;
+}