Porting connections from graphql-mongoose

Author: nodkz

src/composeWithConnection.js

@@ -0,0 +1,21 @@
+/* @flow */
+/* eslint-disable no-use-before-define */
+
+import { TypeComposer } from 'graphql-compose';
+
+
+export function composeWithConnection(
+  typeComposer: TypeComposer
+): TypeComposer {
+  if (!(typeComposer instanceof TypeComposer)) {
+    throw new Error('You should provide TypeComposer instance to composeWithRelay method');
+  }
+
+  const findById = typeComposer.getResolver('findById');
+  if (!findById) {
+    throw new Error(`TypeComposer(${typeComposer.getTypeName()}) provided to composeWithRelay `
+                  + 'should have findById resolver.');
+  }
+
+  return typeComposer;
+}

src/connectionResolver.js

@@ -0,0 +1,116 @@
+import { cursorToId, idToCursor, dotObject } from '../utils';
+import { projectionCollection, projectionFixRenamed } from './projection';
+import {
+  getArgsFromOpts,
+  getRenamedMongooseFields,
+} from './commons';
+import { connectionArgs } from 'graphql-relay';
+
+
+/**
+ * Helper to get an empty connection.
+ */
+export function emptyConnection() {
+  return {
+    count: 0,
+    edges: [],
+    pageInfo: {
+      startCursor: null,
+      endCursor: null,
+      hasPreviousPage: false,
+      hasNextPage: false,
+    },
+  };
+}
+
+
+export function getIdFromCursor(cursor) {
+  if (cursor === undefined || cursor === null) {
+    return null;
+  }
+
+  return cursorToId(cursor);
+}
+
+
+export function getByConnectionResolver(typeName, resolverOpts = {}) {
+  const mongooseModel = Storage.MongooseModels.get(typeName);
+
+  if (!mongooseModel) {
+    if (process.env.NODE_ENV !== 'production') {
+      console.log(`graphql-mongoose warn: could not find model '${typeName}' `
+        + `for getByConnectionResolver. You should call populateModels(${typeName}).`);
+    }
+  }
+
+  const args = {
+    ...connectionArgs,
+    ...getArgsFromOpts(typeName, resolverOpts),
+  };
+
+  const renamedFields = getRenamedMongooseFields(mongooseModel);
+  const projectionFn = renamedFields
+    ? projectionFixRenamed.bind(this, renamedFields)
+    : projectionCollection;
+
+  const resolve = async function(root, queryArgs = {}, context, info) {
+    const { before, after, first, last, sort = { _id: 1 }, filter } = queryArgs;
+
+    const begin = getIdFromCursor(after);
+    const end = getIdFromCursor(before);
+
+    const skip = (first - last) || 0;
+    const limit = last || first;
+
+    const selector = Object.assign({}, filter ? dotObject(filter) : null);
+    if (begin) {
+      selector._id = {};
+      selector._id.$gt = begin;
+    }
+
+    if (end) {
+      selector._id = {};
+      selector._id.$lt = end;
+    }
+
+    if (mongooseModel) {
+      const projFields = projectionFn(info);
+
+      let count = 0;
+      if (projFields.count) {
+        count = await mongoose.getCount(mongooseModel, selector);
+      }
+
+      const result = await mongoose.getList(
+        mongooseModel,
+        selector,
+        { limit, skip, sort },
+        projFields
+      );
+
+      if (result.length === 0) {
+        return emptyConnection();
+      }
+
+      const edges = result.map((value) => ({
+        cursor: idToCursor(value._id),
+        node: value,
+      }));
+
+      return {
+        count,
+        edges,
+        pageInfo: {
+          startCursor: edges[0].cursor,
+          endCursor: edges[edges.length - 1].cursor,
+          hasPreviousPage: skip !== 0 || !!begin,
+          hasNextPage: result.length === limit,
+        },
+      };
+    }
+
+    return null;
+  };
+
+  return { args, resolve };
+}

src/index.js

@@ -0,0 +1,3 @@
+import { composeWithConnection } from './composeWithConnection';
+
+export default composeWithConnection;

src/type/connection.js

@@ -0,0 +1,56 @@
+/* eslint-disable arrow-body-style */
+
+import {
+  GraphQLInt,
+  GraphQLString,
+  GraphQLObjectType,
+  GraphQLNonNull,
+  GraphQLList,
+} from 'graphql';
+
+import PageInfoType from './pageInfo';
+
+export function getEdgeType(graphqlType, opts) {
+  const name = `${graphqlType.name}Edge`;
+
+  return new GraphQLObjectType({
+    name,
+    description: 'An edge in a connection.',
+    fields: () => ({
+      node: {
+        type: graphqlType,
+        description: 'The item at the end of the edge',
+      },
+      cursor: {
+        type: new GraphQLNonNull(GraphQLString),
+        description: 'A cursor for use in pagination',
+      },
+    }),
+  });
+}
+
+
+export function getConnectionType(graphqlType, opts) {
+  const name = `${graphqlType.name}Connection`;
+
+  return Storage.getTypeWithCache(name, () => {
+    return new GraphQLObjectType({
+      name,
+      description: 'A connection to a list of items.',
+      fields: () => ({
+        count: {
+          type: GraphQLInt,
+          description: 'Total object count.',
+        },
+        pageInfo: {
+          type: new GraphQLNonNull(PageInfoType),
+          description: 'Information to aid in pagination.',
+        },
+        edges: {
+          type: new GraphQLList(getEdgeType(graphqlType, opts)),
+          description: 'Information to aid in pagination.',
+        },
+      }),
+    });
+  });
+}

src/type/pageInfo.js

@@ -0,0 +1,31 @@
+import {
+  GraphQLBoolean,
+  GraphQLString,
+  GraphQLObjectType,
+  GraphQLNonNull,
+} from 'graphql';
+
+const PageInfoType = new GraphQLObjectType({
+  name: 'PageInfo',
+  description: 'Information about pagination in a connection.',
+  fields: () => ({
+    hasNextPage: {
+      type: new GraphQLNonNull(GraphQLBoolean),
+      description: 'When paginating forwards, are there more items?',
+    },
+    hasPreviousPage: {
+      type: new GraphQLNonNull(GraphQLBoolean),
+      description: 'When paginating backwards, are there more items?',
+    },
+    startCursor: {
+      type: GraphQLString,
+      description: 'When paginating backwards, the cursor to continue.',
+    },
+    endCursor: {
+      type: GraphQLString,
+      description: 'When paginating forwards, the cursor to continue.',
+    },
+  }),
+});
+
+export default PageInfoType;