fix(Indexes): Removed specific indexes and generate clean field names

Helpers `sort` and `filter` may create not valid typename with dot. Also removed `text`, `2d` and

others from creating sorting/filtering fields. Cause they have specific query syntax and should be

added by user manually.

Author: nodkz

src/resolvers/helpers/filter.js

@@ -142,7 +142,8 @@ export function getIndexedFieldNames(model: MongooseModelT): string[] {
   const fieldNames = [];
   indexes.forEach((indexData) => {
     const keys = Object.keys(indexData);
-    fieldNames.push(keys[0]);
+    const clearedName = keys[0].replace(/[^_a-zA-Z0-9]/i, '__');
+    fieldNames.push(clearedName);
   });
 
   return fieldNames;

src/resolvers/helpers/sort.js

@@ -54,7 +54,7 @@ export function getSortTypeFromModel(
   const sortEnumValues = {};
   indexes.forEach((indexData) => {
     const keys = Object.keys(indexData);
-    let name = keys.join('__').toUpperCase().replace('.', '__');
+    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) {

src/utils/__tests__/getIndexesFromModel-test.js

@@ -0,0 +1,81 @@
+import { expect } from 'chai';
+import mongoose from 'mongoose';
+import getIndexesFromModel from '../getIndexesFromModel';
+
+const AgentSchema = new mongoose.Schema(
+  {
+    subDoc: {
+      field1: String,
+      field2: {
+        field21: String,
+        field22: String,
+      },
+    },
+
+    name: {
+      type: String,
+      description: 'Person name',
+    },
+
+    age: {
+      type: Number,
+      description: 'Full years',
+    },
+
+    gender: {
+      type: String,
+      enum: ['male', 'female', 'ladyboy'],
+    },
+
+    skills: {
+      type: [String],
+      default: [],
+      description: 'List of skills',
+    },
+
+    relocation: {
+      type: Boolean,
+      description: 'Does candidate relocate to another region',
+    },
+  }
+);
+
+AgentSchema.set('autoIndex', false);
+AgentSchema.index({ name: 1, age: -1 });
+AgentSchema.index({ 'subDoc.field2': 1 });
+AgentSchema.index({ name: 'text', skills: 'text' });
+
+const AgentModel = mongoose.model('Agent', AgentSchema);
+
+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 },
+    ]);
+  });
+
+  it('should not extract compound indexes', () => {
+    const idx = getIndexesFromModel(AgentModel, { extractCompound: false });
+    expect(idx).to.deep.have.all.members([
+      { _id: 1 },
+      { name: 1, age: -1 },
+      { 'subDoc.field2': 1 },
+    ]);
+  });
+
+  it('it should return specialIndexes indexes', () => {
+    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' },
+    ]);
+  });
+});

src/utils/getIndexesFromModel.js

@@ -7,6 +7,18 @@ import type {
 
 export type getIndexesFromModelOpts = {
   extractCompound?: boolean, // true by default
+  skipSpecificIndeces?: boolean, // eg text, 2d, 2dsphere (true by default)
+}
+
+function isSpecificIndex(idx) {
+  let hasSpecialIndex = false;
+  Object.keys(idx).forEach((k) => {
+    if (typeof idx[k] !== 'number'
+      && typeof idx[k] !== 'boolean') {
+      hasSpecialIndex = true;
+    }
+  });
+  return hasSpecialIndex;
 }
 
 /**
@@ -17,7 +29,12 @@ export default function getIndexesFromModel(
   mongooseModel: MongooseModelT,
   opts: getIndexesFromModelOpts = {}
 ): ObjectMap[] {
-  const extractCompound = opts.extractCompound || true;
+  const extractCompound = opts.extractCompound === undefined
+    ? true
+    : Boolean(opts.extractCompound);
+  const skipSpecificIndexes = opts.skipSpecificIndexes === undefined
+    ? true
+    : Boolean(opts.skipSpecificIndexes);
 
   const indexedFields = [];
 
@@ -33,20 +50,23 @@ export default function getIndexesFromModel(
     }
   });
 
-  // scan compound indexes [MONGOOSE SCHEMA LEVEL INDEXES]
+  // scan compound and special indexes [MONGOOSE SCHEMA LEVEL INDEXES]
   if (Array.isArray(mongooseModel.schema._indexes)) {
     mongooseModel.schema._indexes.forEach((idxData) => {
       const partialIndexes = {};
       const idxFields = idxData[0];
-      if (!extractCompound) {
-        indexedFields.push(idxFields);
-      } else {
-        // extract partial indexes from compound index
-        // { name: 1, age: 1, salary: 1} -> [{name:1}, {name:1, age:1}, {name:1, age:1, salary:1}]
-        Object.keys(idxFields).forEach((fieldName) => {
-          partialIndexes[fieldName] = idxFields[fieldName];
-          indexedFields.push(Object.assign({}, partialIndexes));
-        });
+
+      if (!skipSpecificIndexes || !isSpecificIndex(idxFields)) {
+        if (!extractCompound) {
+          indexedFields.push(idxFields);
+        } else {
+          // extract partial indexes from compound index
+          // { name: 1, age: 1, salary: 1} -> [{name:1}, {name:1, age:1}, {name:1, age:1, salary:1}]
+          Object.keys(idxFields).forEach((fieldName) => {
+            partialIndexes[fieldName] = idxFields[fieldName];
+            indexedFields.push(Object.assign({}, partialIndexes));
+          });
+        }
       }
     });
   }