feat(toMongoDottedObject): convert arrays without using element index

* feat: convert inner array without using element index

* feat: add toMongoFilterDottedObject and keep toMongoDottedObject

Author: davidpicarra

src/resolvers/helpers/filter.js

@@ -4,7 +4,7 @@
 import type { TypeComposer, ComposeFieldConfigArgumentMap } from 'graphql-compose';
 import type { MongooseModel } from 'mongoose';
 import GraphQLMongoID from '../../types/mongoid';
-import { isObject, toMongoDottedObject, getIndexedFieldNamesForGraphQL } from '../../utils';
+import { isObject, toMongoFilterDottedObject, getIndexedFieldNamesForGraphQL } from '../../utils';
 import type { ExtendedResolveParams } from '../index';
 import {
   type FilterOperatorsOpts,
@@ -112,7 +112,7 @@ export function filterHelper(resolveParams: ExtendedResolveParams): void {
     });
     if (Object.keys(clearedFilter).length > 0) {
       // eslint-disable-next-line
-      resolveParams.query = resolveParams.query.where(toMongoDottedObject(clearedFilter));
+      resolveParams.query = resolveParams.query.where(toMongoFilterDottedObject(clearedFilter));
     }
 
     processFilterOperators(filter, resolveParams);

src/resolvers/updateMany.js

@@ -14,7 +14,7 @@ import {
   sortHelper,
   sortHelperArgs,
 } from './helpers';
-import toMongoDottedObject from '../utils/toMongoDottedObject';
+import { toMongoDottedObject } from '../utils/toMongoDottedObject';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 
 export default function updateMany(

src/utils/__tests__/toMongoDottedObject-test.js

@@ -1,7 +1,7 @@
 /* @flow */
 
 import { Types } from 'mongoose';
-import toMongoDottedObject from '../toMongoDottedObject';
+import { toMongoDottedObject, toMongoFilterDottedObject } from '../toMongoDottedObject';
 
 describe('toMongoDottedObject()', () => {
   it('should dot nested objects', () => {
@@ -51,4 +51,62 @@ describe('toMongoDottedObject()', () => {
       'a.someField': id,
     });
   });
+
+  it('should dot array without index', () => {
+    expect(toMongoDottedObject({ a: [{ b: 1 }, { c: 2 }] })).toEqual({ 'a.0.b': 1, 'a.1.c': 2 });
+  });
+});
+
+describe('toMongoFilterDottedObject()', () => {
+  it('should dot nested objects', () => {
+    expect(toMongoFilterDottedObject({ a: { b: { c: 1 } } })).toEqual({ 'a.b.c': 1 });
+  });
+
+  it('should not dot query operators started with $', () => {
+    expect(toMongoFilterDottedObject({ a: { $in: [1, 2, 3] } })).toEqual({
+      a: { $in: [1, 2, 3] },
+    });
+    expect(toMongoFilterDottedObject({ a: { b: { $in: [1, 2, 3] } } })).toEqual({
+      'a.b': { $in: [1, 2, 3] },
+    });
+    expect(toMongoFilterDottedObject({ $or: [{ age: 1 }, { age: 2 }] })).toEqual({
+      $or: [{ age: 1 }, { age: 2 }],
+    });
+  });
+
+  it('should mix query operators started with $', () => {
+    expect(toMongoFilterDottedObject({ a: { $in: [1, 2, 3], $exists: true } })).toEqual({
+      a: { $in: [1, 2, 3], $exists: true },
+    });
+  });
+
+  it('should not mix query operators started with $ and regular fields', () => {
+    expect(toMongoFilterDottedObject({ a: { $exists: true, b: 3 } })).toEqual({
+      a: { $exists: true },
+      'a.b': 3,
+    });
+  });
+
+  it('should handle date object values as scalars', () => {
+    expect(toMongoFilterDottedObject({ dateField: new Date(100) })).toEqual({
+      dateField: new Date(100),
+    });
+  });
+
+  it('should handle date object values when nested', () => {
+    expect(toMongoFilterDottedObject({ a: { dateField: new Date(100) } })).toEqual({
+      'a.dateField': new Date(100),
+    });
+  });
+
+  it('should keep BSON ObjectId untouched', () => {
+    const id = new Types.ObjectId();
+    expect(toMongoFilterDottedObject({ a: { someField: id } })).toEqual({
+      'a.someField': id,
+    });
+  });
+
+  it('should dot array without index', () => {
+    expect(toMongoFilterDottedObject({ a: [{ b: 1 }, { c: 2 }] })).toEqual({ 'a.b': 1, 'a.c': 2 });
+  });
 });

src/utils/index.d.ts

@@ -1,3 +1,3 @@
 export { isObject, upperFirst } from 'graphql-compose';
-export { default as toMongoDottedObject } from './toMongoDottedObject';
+export { toMongoDottedObject, toMongoFilterDottedObject } from './toMongoDottedObject';
 export * from './getIndexesFromModel';

src/utils/index.js

@@ -1,7 +1,7 @@
 /* @flow */
 
 import { isObject, upperFirst } from 'graphql-compose';
-import toMongoDottedObject from './toMongoDottedObject';
+import { toMongoDottedObject, toMongoFilterDottedObject } from './toMongoDottedObject';
 
-export { toMongoDottedObject, isObject, upperFirst };
+export { toMongoDottedObject, toMongoFilterDottedObject, isObject, upperFirst };
 export * from './getIndexesFromModel';

src/utils/toMongoDottedObject.d.ts

@@ -1,4 +1,10 @@
-export default function toMongoDottedObject(
+export function toMongoDottedObject(
+  obj: object,
+  target?: object,
+  path?: string[],
+): { [dottedPath: string]: any };
+
+export function toMongoFilterDottedObject(
   obj: object,
   target?: object,
   path?: string[],

src/utils/toMongoDottedObject.js

@@ -4,25 +4,7 @@ import { Types } from 'mongoose';
 
 const ObjectId = Types.ObjectId;
 
-/**
- * Convert object to dotted-key/value pair
- * { a: { b: { c: 1 }}} ->  { 'a.b.c': 1 }
- * { a: { $in: [ 1, 2, 3] }} ->  { 'a': { $in: [ 1, 2, 3] } }
- * { a: { b: { $in: [ 1, 2, 3] }}} ->  { 'a.b': { $in: [ 1, 2, 3] } }
- * Usage:
- *   var dotObject(obj)
- *   or
- *   var target = {}; dotObject(obj, target)
- *
- * @param {Object} obj source object
- * @param {Object} target target object
- * @param {Array} path path array (internal)
- */
-export default function toMongoDottedObject(
-  obj: Object,
-  target?: Object = {},
-  path?: string[] = []
-): { [dottedPath: string]: mixed } {
+function _toMongoDottedObject(obj, target = {}, path = [], filter = false) {
   const objKeys = Object.keys(obj);
 
   /* eslint-disable */
@@ -37,7 +19,7 @@ export default function toMongoDottedObject(
          };
        }
      } else if (Object(obj[key]) === obj[key] && !(obj[key] instanceof ObjectId)) {
-       toMongoDottedObject(obj[key], target, path.concat(key));
+       _toMongoDottedObject(obj[key], target, Array.isArray(obj) && filter ? path : path.concat(key), filter);
      } else {
        target[path.concat(key).join('.')] = obj[key];
      }
@@ -50,3 +32,49 @@ export default function toMongoDottedObject(
    return target;
    /* eslint-enable */
 }
+
+/**
+ * Convert object to dotted-key/value pair
+ * { a: { b: { c: 1 }}} ->  { 'a.b.c': 1 }
+ * { a: { $in: [ 1, 2, 3] }} ->  { 'a': { $in: [ 1, 2, 3] } }
+ * { a: { b: { $in: [ 1, 2, 3] }}} ->  { 'a.b': { $in: [ 1, 2, 3] } }
+ * { a: [ { b: 1 }, { c: 2 }]} -> { 'a.0.b': 1, 'a.1.c': 2 }
+ * Usage:
+ *   var toMongoDottedObject(obj)
+ *   or
+ *   var target = {}; toMongoDottedObject(obj, target)
+ *
+ * @param {Object} obj source object
+ * @param {Object} target target object
+ * @param {Array} path path array (internal)
+ */
+export function toMongoDottedObject(
+  obj: Object,
+  target?: Object = {},
+  path?: string[] = []
+): { [dottedPath: string]: mixed } {
+  return _toMongoDottedObject(obj, target, path);
+}
+
+/**
+ * Convert object to dotted-key/value pair
+ * { a: { b: { c: 1 }}} ->  { 'a.b.c': 1 }
+ * { a: { $in: [ 1, 2, 3] }} ->  { 'a': { $in: [ 1, 2, 3] } }
+ * { a: { b: { $in: [ 1, 2, 3] }}} ->  { 'a.b': { $in: [ 1, 2, 3] } }
+ * { a: [ { b: 1 }, { c: 2 }]} -> { 'a.b': 1, 'a.c': 2 }
+ * Usage:
+ *   var toMongoFilterDottedObject(obj)
+ *   or
+ *   var target = {}; toMongoFilterDottedObject(obj, target)
+ *
+ * @param {Object} obj source object
+ * @param {Object} target target object
+ * @param {Array} path path array (internal)
+ */
+export function toMongoFilterDottedObject(
+  obj: Object,
+  target?: Object = {},
+  path?: string[] = []
+): { [dottedPath: string]: mixed } {
+  return _toMongoDottedObject(obj, target, path, true);
+}