Add ConnectionResolver

Author: nodkz

package.json

@@ -26,6 +26,7 @@
   "dependencies": {
     "graphql": "^0.5.0",
     "graphql-compose": ">=0.0.2",
+    "graphql-compose-connection": "^0.0.1",
     "object-path": "^0.9.2",
     "mongoose": "^4.4.20"
   },

src/modelConverter.js renamed to src/composeWithMongoose.js

@@ -4,6 +4,8 @@
 import { convertModelToGraphQL } from './fieldsConverter';
 import { TypeComposer, InputTypeComposer } from 'graphql-compose';
 import * as resolvers from './resolvers';
+import composeWithConnection from 'graphql-compose-connection';
+import { OPERATORS_FIELDNAME } from './resolvers/helpers/filter';
 
 import type {
   MongooseModelT,
@@ -13,7 +15,7 @@ import type {
 } from './definition';
 
 
-export function mongooseModelToTypeComposer(
+export function composeWithMongoose(
   model: MongooseModelT,
   opts: typeConverterOpts = {}
 ): TypeComposer {
@@ -111,12 +113,55 @@ export function createResolvers(
   names.forEach(resolverName => {
     if (!opts.hasOwnProperty(resolverName) || opts[resolverName] !== false) {
       const createResolverFn = resolvers[resolverName];
-      const resolver = createResolverFn(
-        model,
-        typeComposer,
-        opts[resolverName] || {}
-      );
-      typeComposer.setResolver(resolver);
+      if (createResolverFn) {
+        const resolver = createResolverFn(
+          model,
+          typeComposer,
+          opts[resolverName] || {}
+        );
+        typeComposer.setResolver(resolver);
+      }
     }
   });
+
+  if (!opts.hasOwnProperty('connection') || opts['connection'] !== false) {
+    prepareConnectionResolver(typeComposer, opts['connection']);
+  }
+}
+
+export function prepareConnectionResolver(typeComposer: TypeComposer, opts) {
+  composeWithConnection(typeComposer, {
+    findResolverName: 'findMany',
+    countResolverName: 'count',
+    sort: {
+      _ID_DESC: {
+        uniqueFields: ['_id'],
+        sortValue: { _id: -1 },
+        directionFilter: (cursorData, filter, isBefore) => {
+          filter[OPERATORS_FIELDNAME] = filter[OPERATORS_FIELDNAME] || {};
+          filter[OPERATORS_FIELDNAME]._id = filter[OPERATORS_FIELDNAME]._id || {};
+          if (isBefore) {
+            filter[OPERATORS_FIELDNAME]._id.gt = cursorData._id;
+          } else {
+            filter[OPERATORS_FIELDNAME]._id.lt = cursorData._id;
+          }
+          return filter;
+        },
+      },
+      _ID_ASC: {
+        uniqueFields: ['_id'],
+        sortValue: { _id: 1 },
+        directionFilter: (cursorData, filter, isBefore) => {
+          filter[OPERATORS_FIELDNAME] = filter[OPERATORS_FIELDNAME] || {};
+          filter[OPERATORS_FIELDNAME]._id = filter[OPERATORS_FIELDNAME]._id || {};
+          if (isBefore) {
+            filter[OPERATORS_FIELDNAME]._id.lt = cursorData._id;
+          } else {
+            filter[OPERATORS_FIELDNAME]._id.gt = cursorData._id;
+          }
+          return filter;
+        },
+      }
+    },
+  })
 }

src/definition.js

@@ -49,13 +49,12 @@ export type MongooseFieldMapT = { [fieldName: string]: MongooseFieldT };
 export type ResolverNames = 'findById' | 'findByIds' | 'findOne' | 'findMany' |
                             'updateById' | 'updateOne' | 'updateMany' |
                             'removeById' | 'removeOne' | 'removeMany' |
-                            'createOne' | 'count';
+                            'createOne' | 'count' | 'connection';
 
 export type MongooseQuery = {
   exec(): Promise<any>,
-  where(criteria: ObjectMap): MongooseQuery,
+  where(criteriaOrFieldName: ObjectMap | string): MongooseQuery,
   where(fieldName: string, equalTo: string): MongooseQuery,
-  where(fieldName: string): MongooseQuery,
   skip(num: number): MongooseQuery,
   limit(num: number): MongooseQuery,
   select(projection: ObjectMap): MongooseQuery,
@@ -173,6 +172,7 @@ export type typeConverterResolversOpts = {
   count?: false | {
     filter?: filterHelperArgsOpts | false,
   },
+  connection?: false,
 };
 
 export type filterHelperArgsOpts = {

src/index.js

@@ -1,5 +1,5 @@
 /* @flow */
 
-import { mongooseModelToTypeComposer } from './modelConverter';
+import { composeWithMongoose } from './composeWithMongoose';
 
-export default mongooseModelToTypeComposer;
+export default composeWithMongoose;