feat(ConnectionResolver): Add unique indexed fields to the connection sort argument

Author: nodkz

src/composeWithMongoose.js

@@ -5,6 +5,10 @@ import { TypeComposer, InputTypeComposer } from 'graphql-compose';
 import composeWithConnection from 'graphql-compose-connection';
 import { convertModelToGraphQL } from './fieldsConverter';
 import * as resolvers from './resolvers';
+import {
+  getUniqueIndexes,
+  extendByReversedIndexes,
+} from './utils/getIndexesFromModel';
 
 import type {
   MongooseModelT,
@@ -125,50 +129,56 @@ export function createResolvers(
   });
 
   if (!{}.hasOwnProperty.call(opts, 'connection') || opts.connection !== false) {
-    prepareConnectionResolver(typeComposer, opts.connection ? opts.connection : {});
+    prepareConnectionResolver(model, typeComposer, opts.connection ? opts.connection : {});
   }
 }
 
 export function prepareConnectionResolver(
+  model: MongooseModelT,
   typeComposer: TypeComposer,
   opts: connectionSortMapOpts
 ) {
+  const uniqueIndexes = extendByReversedIndexes(getUniqueIndexes(model), { reversedFirst: true });
+  const sortConfigs = {};
+  uniqueIndexes.forEach((indexData) => {
+    const keys = Object.keys(indexData);
+    let name = keys.join('__').toUpperCase().replace(/[^_a-zA-Z0-9]/i, '__');
+    if (indexData[keys[0]] === 1) {
+      name = `${name}_ASC`;
+    } else if (indexData[keys[0]] === -1) {
+      name = `${name}_DESC`;
+    }
+    sortConfigs[name] = {
+      value: indexData,
+      cursorFields: keys,
+      beforeCursorQuery: (rawQuery, cursorData) => {
+        keys.forEach((k) => {
+          if (!rawQuery[k]) rawQuery[k] = {};
+          if (indexData[k] === 1) {
+            rawQuery[k].$lt = cursorData[k];
+          } else {
+            rawQuery[k].$gt = cursorData[k];
+          }
+        });
+      },
+      afterCursorQuery: (rawQuery, cursorData) => {
+        keys.forEach((k) => {
+          if (!rawQuery[k]) rawQuery[k] = {};
+          if (indexData[k] === 1) {
+            rawQuery[k].$gt = cursorData[k];
+          } else {
+            rawQuery[k].$lt = cursorData[k];
+          }
+        });
+      },
+    };
+  });
+
   composeWithConnection(typeComposer, {
     findResolverName: 'findMany',
     countResolverName: 'count',
     sort: {
-      _ID_DESC: {
-        value: { _id: -1 },
-        cursorFields: ['_id'],
-        beforeCursorQuery: (rawQuery, cursorData) => {
-          // $FlowFixMe
-          if (!rawQuery._id) rawQuery._id = {};
-          // $FlowFixMe
-          rawQuery._id.$gt = cursorData._id;
-        },
-        afterCursorQuery: (rawQuery, cursorData) => {
-          // $FlowFixMe
-          if (!rawQuery._id) rawQuery._id = {};
-          // $FlowFixMe
-          rawQuery._id.$lt = cursorData._id;
-        },
-      },
-      _ID_ASC: {
-        value: { _id: 1 },
-        cursorFields: ['_id'],
-        beforeCursorQuery: (rawQuery, cursorData) => {
-          // $FlowFixMe
-          if (!rawQuery._id) rawQuery._id = {};
-          // $FlowFixMe
-          rawQuery._id.$gt = cursorData._id;
-        },
-        afterCursorQuery: (rawQuery, cursorData) => {
-          // $FlowFixMe
-          if (!rawQuery._id) rawQuery._id = {};
-          // $FlowFixMe
-          rawQuery._id.$lt = cursorData._id;
-        },
-      },
+      ...sortConfigs,
       ...opts,
     },
   });

src/resolvers/helpers/__tests__/sort-test.js

@@ -8,7 +8,7 @@ import {
   getSortTypeFromModel,
 } from '../sort';
 import { UserModel } from '../../../__mocks__/userModel';
-import getIndexesFromModel from '../../../utils/getIndexesFromModel';
+import { getIndexesFromModel } from '../../../utils/getIndexesFromModel';
 import typeStorage from '../../../typeStorage';
 
 describe('Resolver helper `sort` ->', () => {

src/resolvers/helpers/filter.js

@@ -8,7 +8,7 @@ import {
   getNamedType,
 } from 'graphql';
 import { TypeComposer, InputTypeComposer } from 'graphql-compose';
-import getIndexesFromModel from '../../utils/getIndexesFromModel';
+import { getIndexesFromModel } from '../../utils/getIndexesFromModel';
 import { isObject } from '../../utils/is';
 import { toDottedObject, upperFirst } from '../../utils';
 import typeStorage from '../../typeStorage';

src/resolvers/helpers/sort.js

@@ -2,7 +2,7 @@
 /* eslint-disable no-use-before-define */
 
 import { GraphQLEnumType } from 'graphql';
-import getIndexesFromModel from '../../utils/getIndexesFromModel';
+import { getIndexesFromModel, extendByReversedIndexes } from '../../utils/getIndexesFromModel';
 import typeStorage from '../../typeStorage';
 import type {
   ExtendedResolveParams,
@@ -49,7 +49,7 @@ export function getSortTypeFromModel(
   typeName: string,
   model: MongooseModelT
 ): GraphQLEnumType {
-  const indexes = getIndexesFromModelWithReverse(model);
+  const indexes = extendByReversedIndexes(getIndexesFromModel(model));
 
   const sortEnumValues = {};
   indexes.forEach((indexData) => {
@@ -74,27 +74,3 @@ export function getSortTypeFromModel(
     })
   );
 }
-
-
-export function getIndexesFromModelWithReverse(model: MongooseModelT) {
-  const indexes = getIndexesFromModel(model);
-  const result: ObjectMap[] = [];
-
-  indexes.forEach((indexObj) => {
-    let hasSpecificIndex = false;
-    // https://docs.mongodb.org/manual/tutorial/sort-results-with-indexes/#sort-on-multiple-fields
-    const reversedIndexObj = Object.assign({}, indexObj);
-    Object.keys(reversedIndexObj).forEach((f) => {
-      if (reversedIndexObj[f] === 1) reversedIndexObj[f] = -1;
-      else if (reversedIndexObj[f] === -1) reversedIndexObj[f] = 1;
-      else hasSpecificIndex = true;
-    });
-
-    result.push(indexObj);
-    if (!hasSpecificIndex) {
-      result.push(reversedIndexObj);
-    }
-  });
-
-  return result;
-}

src/utils/__tests__/getIndexesFromModel-test.js

@@ -1,6 +1,10 @@
 import { expect } from 'chai';
 import mongoose from 'mongoose';
-import getIndexesFromModel from '../getIndexesFromModel';
+import {
+  getIndexesFromModel,
+  getUniqueIndexes,
+  extendByReversedIndexes,
+} from '../getIndexesFromModel';
 
 const AgentSchema = new mongoose.Schema(
   {
@@ -17,6 +21,11 @@ const AgentSchema = new mongoose.Schema(
       description: 'Person name',
     },
 
+    someUniqField: {
+      type: String,
+      unique: true,
+    },
+
     age: {
       type: Number,
       description: 'Full years',
@@ -43,18 +52,21 @@ const AgentSchema = new mongoose.Schema(
 AgentSchema.set('autoIndex', false);
 AgentSchema.index({ name: 1, age: -1 });
 AgentSchema.index({ 'subDoc.field2': 1 });
-AgentSchema.index({ name: 'text', skills: 'text' });
+AgentSchema.index({ name: 'text', skills: 'text' }, { unique: true });
+AgentSchema.index({ name: 1, someOtherField: -1 }, { unique: true });
 
 const AgentModel = mongoose.model('Agent', AgentSchema);
 
-describe('getIndexesFromModel', () => {
+describe('getIndexesFromModel()', () => {
   it('should get regular indexes and extract compound idx by default', () => {
     const idx = getIndexesFromModel(AgentModel);
     expect(idx).to.deep.have.all.members([
       { _id: 1 },
       { name: 1 },
       { name: 1, age: -1 },
       { 'subDoc.field2': 1 },
+      { someUniqField: 1 },
+      { name: 1, someOtherField: -1 },
     ]);
   });
 
@@ -64,18 +76,70 @@ describe('getIndexesFromModel', () => {
       { _id: 1 },
       { name: 1, age: -1 },
       { 'subDoc.field2': 1 },
+      { someUniqField: 1 },
+      { name: 1, someOtherField: -1 },
     ]);
   });
 
   it('it should return specialIndexes indexes', () => {
-    const idx = getIndexesFromModel(AgentModel, { skipSpecificIndexes : false });
+    const idx = getIndexesFromModel(AgentModel, { skipSpecificIndexes: false });
     expect(idx).to.deep.have.all.members([
       { _id: 1 },
       { name: 1 },
       { name: 1, age: -1 },
       { 'subDoc.field2': 1 },
       { name: 'text' },
       { name: 'text', skills: 'text' },
+      { someUniqField: 1 },
+      { name: 1, someOtherField: -1 },
+    ]);
+  });
+});
+
+
+describe('getUniqueIndexes()', () => {
+  it('should return unique indexes', () => {
+    const idx = getUniqueIndexes(AgentModel);
+    expect(idx).to.deep.have.all.members([
+      { _id: 1 },
+      { someUniqField: 1 },
+      { name: 1, someOtherField: -1 },
+    ]);
+  });
+});
+
+describe('extendByReversedIndexes()', () => {
+  it('should return extended indexes list', () => {
+    const idxSource = [
+      { _id: 1 },
+      { someUniqField: 1 },
+      { name: 1, someOtherField: -1 },
+    ];
+    const idx = extendByReversedIndexes(idxSource);
+    expect(idx).deep.equal([
+      { _id: 1 },
+      { _id: -1 },
+      { someUniqField: 1 },
+      { someUniqField: -1 },
+      { name: 1, someOtherField: -1 },
+      { name: -1, someOtherField: 1 },
+    ]);
+  });
+
+  it('should return extended indexes list with reversed first', () => {
+    const idxSource = [
+      { _id: 1 },
+      { someUniqField: 1 },
+      { name: 1, someOtherField: -1 },
+    ];
+    const idx = extendByReversedIndexes(idxSource, { reversedFirst: true });
+    expect(idx).deep.equal([
+      { _id: -1 },
+      { _id: 1 },
+      { someUniqField: -1 },
+      { someUniqField: 1 },
+      { name: -1, someOtherField: 1 },
+      { name: 1, someOtherField: -1 },
     ]);
   });
 });

src/utils/getIndexesFromModel.js

@@ -25,7 +25,7 @@ function isSpecificIndex(idx) {
 * Get mongoose model, and return array of fields with indexes.
 *  MongooseModel  ->  [ { _id: 1 }, { name: 1, surname: -1 } ]
 **/
-export default function getIndexesFromModel(
+export function getIndexesFromModel(
   mongooseModel: MongooseModelT,
   opts: getIndexesFromModelOpts = {}
 ): ObjectMap[] {
@@ -73,3 +73,74 @@ export default function getIndexesFromModel(
 
   return indexedFields;
 }
+
+
+export function getUniqueIndexes(mongooseModel: MongooseModelT): ObjectMap[] {
+  const indexedFields = [];
+
+  // add _id field if existed
+  if (mongooseModel.schema.paths._id) {
+    indexedFields.push({ _id: 1 });
+  }
+
+  // scan all fields on index presence [MONGOOSE FIELDS LEVEL INDEX]
+  Object.keys(mongooseModel.schema.paths).forEach((name) => {
+    if (mongooseModel.schema.paths[name]._index
+     && mongooseModel.schema.paths[name]._index.unique) {
+      indexedFields.push({ [name]: 1 }); // ASC by default
+    }
+  });
+
+  // scan compound and special indexes [MONGOOSE SCHEMA LEVEL INDEXES]
+  if (Array.isArray(mongooseModel.schema._indexes)) {
+    mongooseModel.schema._indexes.forEach((idxData) => {
+      const idxFields = idxData[0];
+      const idxCfg = idxData[1];
+      if (idxCfg.unique && !isSpecificIndex(idxFields)) {
+        indexedFields.push(idxFields);
+      }
+    });
+  }
+
+  return indexedFields;
+}
+
+export type extendByReversedIndexesOpts = {
+  reversedFirst?: boolean, // false by default
+}
+
+export function extendByReversedIndexes(
+  indexes: ObjectMap[],
+  opts: extendByReversedIndexesOpts = {}
+) {
+  const reversedFirst = opts.reversedFirst === undefined
+    ? false
+    : Boolean(opts.reversedFirst);
+
+  const result: ObjectMap[] = [];
+
+  indexes.forEach((indexObj) => {
+    let hasSpecificIndex = false;
+    // https://docs.mongodb.org/manual/tutorial/sort-results-with-indexes/#sort-on-multiple-fields
+    const reversedIndexObj = Object.assign({}, indexObj);
+    Object.keys(reversedIndexObj).forEach((f) => {
+      if (reversedIndexObj[f] === 1) reversedIndexObj[f] = -1;
+      else if (reversedIndexObj[f] === -1) reversedIndexObj[f] = 1;
+      else hasSpecificIndex = true;
+    });
+
+    if (reversedFirst) {
+      if (!hasSpecificIndex) {
+        result.push(reversedIndexObj);
+      }
+      result.push(indexObj);
+    } else {
+      result.push(indexObj);
+      if (!hasSpecificIndex) {
+        result.push(reversedIndexObj);
+      }
+    }
+  });
+
+  return result;
+}