fix(Filter): Do not dotten internals of mongo query operators, like , , and others

Closes graphql-compose/graphql-compose#30

Author: nodkz

.eslintrc

@@ -5,6 +5,7 @@
     "no-underscore-dangle": 0,
     "no-unused-expressions": 0,
     "arrow-body-style": 0,
+    "arrow-parens": 0,
     "import/no-extraneous-dependencies": ["error", {"devDependencies": true}],
     "comma-dangle": ["error", {
       "arrays": "always-multiline",

src/resolvers/helpers/filter.js

@@ -10,7 +10,7 @@ import {
 import { TypeComposer, InputTypeComposer } from 'graphql-compose';
 import { getIndexesFromModel } from '../../utils/getIndexesFromModel';
 import { isObject } from '../../utils/is';
-import { toDottedObject, upperFirst } from '../../utils';
+import { toMongoDottedObject, upperFirst } from '../../utils';
 import typeStorage from '../../typeStorage';
 import type {
   GraphQLFieldConfigArgumentMap,
@@ -23,24 +23,27 @@ import type {
 
 export const OPERATORS_FIELDNAME = '_operators';
 
-
 export const filterHelperArgs = (
   typeComposer: TypeComposer,
   model: MongooseModelT,
-  opts: filterHelperArgsOpts
+  opts: filterHelperArgsOpts,
 ): GraphQLFieldConfigArgumentMap => {
   if (!(typeComposer instanceof TypeComposer)) {
-    throw new Error('First arg for filterHelperArgs() should be instance of TypeComposer.');
+    throw new Error(
+      'First arg for filterHelperArgs() should be instance of TypeComposer.',
+    );
   }
 
   if (!model || !model.modelName || !model.schema) {
     throw new Error(
-      'Second arg for filterHelperArgs() should be instance of MongooseModel.'
+      'Second arg for filterHelperArgs() should be instance of MongooseModel.',
     );
   }
 
   if (!opts || !opts.filterTypeName) {
-    throw new Error('You should provide non-empty `filterTypeName` in options.');
+    throw new Error(
+      'You should provide non-empty `filterTypeName` in options.',
+    );
   }
 
   const removeFields = [];
@@ -54,28 +57,32 @@ export const filterHelperArgs = (
 
   if (opts.onlyIndexed) {
     const indexedFieldNames = getIndexedFieldNames(model);
-    Object.keys(typeComposer.getFields()).forEach((fieldName) => {
+    Object.keys(typeComposer.getFields()).forEach(fieldName => {
       if (indexedFieldNames.indexOf(fieldName) === -1) {
         removeFields.push(fieldName);
       }
     });
   }
 
   const filterTypeName: string = opts.filterTypeName;
-  const inputComposer = typeComposer.getInputTypeComposer().clone(filterTypeName);
+  const inputComposer = typeComposer
+    .getInputTypeComposer()
+    .clone(filterTypeName);
   inputComposer.removeField(removeFields);
 
   if (opts.requiredFields) {
     inputComposer.makeRequired(opts.requiredFields);
   }
 
-  if (!{}.hasOwnProperty.call(opts, 'operators') || opts.operators !== false) {
+  if (
+    !({}).hasOwnProperty.call(opts, 'operators') || opts.operators !== false
+  ) {
     addFieldsWithOperator(
       // $FlowFixMe
       `Operators${opts.filterTypeName}`,
       inputComposer,
       model,
-      opts.operators || {}
+      opts.operators || {},
     );
   }
 
@@ -102,25 +109,28 @@ export function filterHelper(resolveParams: ExtendedResolveParams): void {
   if (filter && typeof filter === 'object' && Object.keys(filter).length > 0) {
     const modelFields = resolveParams.query.schema.paths;
     const clearedFilter = {};
-    Object.keys(filter).forEach((key) => {
+    Object.keys(filter).forEach(key => {
       if (modelFields[key]) {
         clearedFilter[key] = filter[key];
       }
     });
     if (Object.keys(clearedFilter).length > 0) {
-      resolveParams.query = resolveParams.query.where(toDottedObject(clearedFilter)); // eslint-disable-line
+      resolveParams.query = resolveParams.query.where(
+        toMongoDottedObject(clearedFilter),
+      ); // eslint-disable-line
     }
 
     if (filter[OPERATORS_FIELDNAME]) {
       const operatorFields = filter[OPERATORS_FIELDNAME];
-      Object.keys(operatorFields).forEach((fieldName) => {
+      Object.keys(operatorFields).forEach(fieldName => {
         const fieldOperators = Object.assign({}, operatorFields[fieldName]);
         const criteria = {};
-        Object.keys(fieldOperators).forEach((operatorName) => {
+        Object.keys(fieldOperators).forEach(operatorName => {
           criteria[`$${operatorName}`] = fieldOperators[operatorName];
         });
         if (Object.keys(criteria).length > 0) {
-          resolveParams.query = resolveParams.query.where({ // eslint-disable-line
+          resolveParams.query = resolveParams.query.where({
+            // eslint-disable-line
             [fieldName]: criteria,
           });
         }
@@ -129,18 +139,19 @@ export function filterHelper(resolveParams: ExtendedResolveParams): void {
   }
 
   if (isObject(resolveParams.rawQuery)) {
-    resolveParams.query = resolveParams.query.where( // eslint-disable-line
-      // $FlowFixMe
-      resolveParams.rawQuery
-    );
+    resolveParams.query = resolveParams.query
+      .where( // eslint-disable-line
+        // $FlowFixMe
+        resolveParams.rawQuery,
+      );
   }
 }
 
 export function getIndexedFieldNames(model: MongooseModelT): string[] {
   const indexes = getIndexesFromModel(model);
 
   const fieldNames = [];
-  indexes.forEach((indexData) => {
+  indexes.forEach(indexData => {
     const keys = Object.keys(indexData);
     const clearedName = keys[0].replace(/[^_a-zA-Z0-9]/i, '__');
     fieldNames.push(clearedName);
@@ -153,32 +164,39 @@ export function addFieldsWithOperator(
   typeName: string,
   inputComposer: InputTypeComposer,
   model: MongooseModelT,
-  operatorsOpts: filterOperatorsOpts
+  operatorsOpts: filterOperatorsOpts,
 ): InputTypeComposer {
   const operatorsComposer = new InputTypeComposer(
     typeStorage.getOrSet(
       typeName,
       new GraphQLInputObjectType({
         name: typeName,
         fields: {},
-      })
-    )
+      }),
+    ),
   );
 
-  const availableOperators: filterOperatorNames[]
-    = ['gt', 'gte', 'lt', 'lte', 'ne', 'in[]', 'nin[]'];
+  const availableOperators: filterOperatorNames[] = [
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'ne',
+    'in[]',
+    'nin[]',
+  ];
 
   // if `opts.resolvers.[resolverName].filter.operators` is empty and not disabled via `false`
   // then fill it up with indexed fields
   const indexedFields = getIndexedFieldNames(model);
   if (operatorsOpts !== false && Object.keys(operatorsOpts).length === 0) {
-    indexedFields.forEach((fieldName) => {
+    indexedFields.forEach(fieldName => {
       operatorsOpts[fieldName] = availableOperators; // eslint-disable-line
     });
   }
 
   const existedFields = inputComposer.getFields();
-  Object.keys(existedFields).forEach((fieldName) => {
+  Object.keys(existedFields).forEach(fieldName => {
     if (operatorsOpts[fieldName] && operatorsOpts[fieldName] !== false) {
       const fields = {};
       let operators;
@@ -187,7 +205,7 @@ export function addFieldsWithOperator(
       } else {
         operators = availableOperators;
       }
-      operators.forEach((operatorName) => {
+      operators.forEach(operatorName => {
         // unwrap from GraphQLNonNull and GraphQLList, if present
         const namedType = getNamedType(existedFields[fieldName].type);
         if (namedType) {
@@ -214,7 +232,7 @@ export function addFieldsWithOperator(
             new GraphQLInputObjectType({
               name: operatorTypeName,
               fields,
-            })
+            }),
           ),
           description: 'Filter value by operator(s)',
         });

src/resolvers/updateMany.js

@@ -8,28 +8,27 @@ import { skipHelperArgs, skipHelper } from './helpers/skip';
 import { limitHelperArgs, limitHelper } from './helpers/limit';
 import { filterHelperArgs, filterHelper } from './helpers/filter';
 import { sortHelperArgs, sortHelper } from './helpers/sort';
-import toDottedObject from '../utils/toDottedObject';
+import toMongoDottedObject from '../utils/toMongoDottedObject';
 import typeStorage from '../typeStorage';
 import type {
   MongooseModelT,
   ExtendedResolveParams,
   genResolverOpts,
 } from '../definition';
 
-
 export default function updateMany(
   model: MongooseModelT,
   typeComposer: TypeComposer,
-  opts?: genResolverOpts
+  opts?: genResolverOpts,
 ): Resolver {
   if (!model || !model.modelName || !model.schema) {
     throw new Error(
-      'First arg for Resolver updateMany() should be instance of Mongoose Model.'
+      'First arg for Resolver updateMany() should be instance of Mongoose Model.',
     );
   }
   if (!(typeComposer instanceof TypeComposer)) {
     throw new Error(
-      'Second arg for Resolver updateMany() should be instance of TypeComposer.'
+      'Second arg for Resolver updateMany() should be instance of TypeComposer.',
     );
   }
 
@@ -44,15 +43,15 @@ export default function updateMany(
           description: 'Affected documents number',
         },
       },
-    })
+    }),
   );
 
   const resolver = new Resolver({
     name: 'updateMany',
     kind: 'mutation',
-    description: 'Update many documents without returning them: '
-               + 'Use Query.update mongoose method. '
-               + 'Do not apply mongoose defaults, setters, hooks and validation. ',
+    description: 'Update many documents without returning them: ' +
+      'Use Query.update mongoose method. ' +
+      'Do not apply mongoose defaults, setters, hooks and validation. ',
     type: outputType,
     args: {
       ...recordHelperArgs(typeComposer, {
@@ -77,14 +76,18 @@ export default function updateMany(
     },
     // $FlowFixMe
     resolve: (resolveParams: ExtendedResolveParams) => {
-      const recordData = (resolveParams.args && resolveParams.args.record) || {};
+      const recordData = (resolveParams.args && resolveParams.args.record) || {
+      };
 
-      if (!(typeof recordData === 'object')
-        || Object.keys(recordData).length === 0
+      if (
+        !(typeof recordData === 'object') ||
+        Object.keys(recordData).length === 0
       ) {
         return Promise.reject(
-          new Error(`${typeComposer.getTypeName()}.updateMany resolver requires `
-                  + 'at least one value in args.record')
+          new Error(
+            `${typeComposer.getTypeName()}.updateMany resolver requires ` +
+              'at least one value in args.record',
+          ),
         );
       }
 
@@ -99,18 +102,17 @@ export default function updateMany(
       limitHelper(resolveParams);
 
       resolveParams.query = resolveParams.query.setOptions({ multi: true }); // eslint-disable-line
-      resolveParams.query.update({ $set: toDottedObject(recordData) });
+      resolveParams.query.update({ $set: toMongoDottedObject(recordData) });
 
-      return (
-        // `beforeQuery` is experemental feature, if you want to use it
-        // please open an issue with your use case, cause I suppose that
-        // this option is excessive
-        // $FlowFixMe
-        resolveParams.beforeQuery
-          ? Promise.resolve(resolveParams.beforeQuery(resolveParams.query, resolveParams))
-          : resolveParams.query.exec()
-        )
-        .then((res) => {
+      // `beforeQuery` is experemental feature, if you want to use it
+      // please open an issue with your use case, cause I suppose that
+      // this option is excessive
+      // $FlowFixMe
+      return (resolveParams.beforeQuery
+        ? Promise.resolve(
+            resolveParams.beforeQuery(resolveParams.query, resolveParams),
+          )
+        : resolveParams.query.exec()).then(res => {
           if (res.ok) {
             return {
               numAffected: res.nModified,

src/utils/__tests__/toMongoDottedObject-test.js

@@ -0,0 +1,32 @@
+import { expect } from 'chai';
+import toMongoDottedObject from '../toMongoDottedObject';
+
+describe('toMongoDottedObject()', () => {
+  it('should dot nested objects', () => {
+    expect(toMongoDottedObject({ a: { b: { c: 1 } } })).to.eql({ 'a.b.c': 1 });
+  });
+
+  it('should not dot query operators started with $', () => {
+    expect(toMongoDottedObject({ a: { $in: [1, 2, 3] } })).to.eql({
+      a: { $in: [1, 2, 3] },
+    });
+    expect(toMongoDottedObject({ a: { b: { $in: [1, 2, 3] } } })).to.eql({
+      'a.b': { $in: [1, 2, 3] },
+    });
+  });
+
+  it('should mix query operators started with $', () => {
+    expect(
+      toMongoDottedObject({ a: { $in: [1, 2, 3], $exists: true } }),
+    ).to.eql({
+      a: { $in: [1, 2, 3], $exists: true },
+    });
+  });
+
+  it('should not mix query operators started with $ and regular fields', () => {
+    expect(toMongoDottedObject({ a: { $exists: true, b: 3 } })).to.eql({
+      a: { $exists: true },
+      'a.b': 3,
+    });
+  });
+});

src/utils/index.js

@@ -1,9 +1,9 @@
 /* @flow */
-import toDottedObject from './toDottedObject';
+import toMongoDottedObject from './toMongoDottedObject';
 import { isObject } from './is';
 
 export {
-  toDottedObject,
+  toMongoDottedObject,
   isObject,
 };