feat: nested aliases are now supported for filter, projection & lean

Author: nodkz

src/__tests__/github_issues/271-test.ts

@@ -175,4 +175,57 @@ describe('nested projections with aliases - issue #271', () => {
       data: { booksMany: [{ author: { isAbove100: 'yes' }, bookSize: 'big' }] },
     });
   });
+
+  it('check filter with alias', async () => {
+    // firstly check mongoose query
+    expect(await BookModel.find({ pc: 1168 }).lean()).toEqual([
+      {
+        __v: 0,
+        _id: 1,
+        a: { ag: 115, isAlive: false, name: 'Ayn Rand' },
+        pc: 1168,
+        title: 'Atlas Shrugged',
+      },
+    ]);
+
+    // check that aliases correctly applied to filter
+    const result = await graphql.graphql({
+      schema,
+      source: `
+        query {
+          booksMany(filter: { pageCount: 1168 }) {
+            title
+            pageCount
+          }
+        }`,
+      contextValue: {},
+    });
+    expect(result).toEqual({ data: { booksMany: [{ pageCount: 1168, title: 'Atlas Shrugged' }] } });
+  });
+
+  it('check nested filter with alias', async () => {
+    // firstly check mongoose query
+    expect(await BookModel.find({ 'a.ag': 115 }).lean()).toEqual([
+      {
+        __v: 0,
+        _id: 1,
+        a: { ag: 115, isAlive: false, name: 'Ayn Rand' },
+        pc: 1168,
+        title: 'Atlas Shrugged',
+      },
+    ]);
+
+    const result = await graphql.graphql({
+      schema,
+      source: `
+        query {
+          booksMany(filter: { author: { age: 115 } }) {
+            title
+            pageCount
+          }
+        }`,
+      contextValue: {},
+    });
+    expect(result).toEqual({ data: { booksMany: [{ pageCount: 1168, title: 'Atlas Shrugged' }] } });
+  });
 });

src/resolvers/count.ts

@@ -1,6 +1,11 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { filterHelper, filterHelperArgs, prepareAliases, FilterHelperArgsOpts } from './helpers';
+import {
+  filterHelper,
+  filterHelperArgs,
+  FilterHelperArgsOpts,
+  prepareNestedAliases,
+} from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelper } from './helpers/beforeQueryHelper';
 
@@ -28,7 +33,7 @@ export function count<TSource = any, TContext = any, TDoc extends Document = any
     throw new Error('Second arg for Resolver count() should be instance of ObjectTypeComposer.');
   }
 
-  const aliases = prepareAliases(model);
+  const aliases = prepareNestedAliases(model.schema);
 
   return tc.schemaComposer.createResolver<TSource, TArgs>({
     type: 'Int',

src/resolvers/dataLoader.ts

@@ -1,7 +1,12 @@
 import { toInputType } from 'graphql-compose';
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { projectionHelper, prepareAliases, prepareAliasesReverse, replaceAliases } from './helpers';
+import {
+  projectionHelper,
+  prepareNestedAliases,
+  prepareAliasesReverse,
+  replaceAliases,
+} from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelper, beforeQueryHelperLean } from './helpers/beforeQueryHelper';
 import { getDataLoader } from './helpers/dataLoaderHelper';
@@ -41,8 +46,8 @@ export function dataLoader<TSource = any, TContext = any, TDoc extends Document
     );
   }
 
-  const aliases = prepareAliases(model);
-  const aliasesReverse = prepareAliasesReverse(model);
+  const aliases = prepareNestedAliases(model.schema);
+  const aliasesReverse = prepareAliasesReverse(model.schema);
 
   return tc.schemaComposer.createResolver<TSource, TArgs>({
     type: tc,

src/resolvers/dataLoaderMany.ts

@@ -1,7 +1,12 @@
 import { toInputType } from 'graphql-compose';
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { projectionHelper, prepareAliases, prepareAliasesReverse, replaceAliases } from './helpers';
+import {
+  projectionHelper,
+  prepareNestedAliases,
+  prepareAliasesReverse,
+  replaceAliases,
+} from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelper, beforeQueryHelperLean } from './helpers/beforeQueryHelper';
 import { getDataLoader } from './helpers/dataLoaderHelper';
@@ -43,8 +48,8 @@ export function dataLoaderMany<TSource = any, TContext = any, TDoc extends Docum
     );
   }
 
-  const aliases = prepareAliases(model);
-  const aliasesReverse = prepareAliasesReverse(model);
+  const aliases = prepareNestedAliases(model.schema);
+  const aliasesReverse = prepareAliasesReverse(model.schema);
 
   return tc.schemaComposer.createResolver<TSource, TArgs>({
     type: tc.List.NonNull,

src/resolvers/findById.ts

@@ -1,7 +1,12 @@
 import { toInputType } from 'graphql-compose';
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { projectionHelper, prepareAliases, prepareAliasesReverse, replaceAliases } from './helpers';
+import {
+  projectionHelper,
+  prepareNestedAliases,
+  prepareAliasesReverse,
+  replaceAliases,
+} from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelper, beforeQueryHelperLean } from './helpers/beforeQueryHelper';
 
@@ -38,8 +43,8 @@ export function findById<TSource = any, TContext = any, TDoc extends Document =
     throw new Error('Second arg for Resolver findById() should be instance of ObjectTypeComposer.');
   }
 
-  const aliases = prepareAliases(model);
-  const aliasesReverse = prepareAliasesReverse(model);
+  const aliases = prepareNestedAliases(model.schema);
+  const aliasesReverse = prepareAliasesReverse(model.schema);
 
   return tc.schemaComposer.createResolver<TSource, TArgs>({
     type: tc,

src/resolvers/findByIds.ts

@@ -7,7 +7,7 @@ import {
   sortHelper,
   sortHelperArgs,
   projectionHelper,
-  prepareAliases,
+  prepareNestedAliases,
   prepareAliasesReverse,
   replaceAliases,
   LimitHelperArgsOpts,
@@ -54,8 +54,8 @@ export function findByIds<TSource = any, TContext = any, TDoc extends Document =
     );
   }
 
-  const aliases = prepareAliases(model);
-  const aliasesReverse = prepareAliasesReverse(model);
+  const aliases = prepareNestedAliases(model.schema);
+  const aliasesReverse = prepareAliasesReverse(model.schema);
 
   return tc.schemaComposer.createResolver<TSource, TArgs>({
     type: tc.NonNull.List.NonNull,

src/resolvers/findMany.ts

@@ -10,7 +10,7 @@ import {
   sortHelper,
   sortHelperArgs,
   projectionHelper,
-  prepareAliases,
+  prepareNestedAliases,
   prepareAliasesReverse,
   replaceAliases,
   FilterHelperArgsOpts,
@@ -62,8 +62,8 @@ export function findMany<TSource = any, TContext = any, TDoc extends Document =
     throw new Error('Second arg for Resolver findMany() should be instance of ObjectTypeComposer.');
   }
 
-  const aliases = prepareAliases(model);
-  const aliasesReverse = prepareAliasesReverse(model);
+  const aliases = prepareNestedAliases(model.schema);
+  const aliasesReverse = prepareAliasesReverse(model.schema);
 
   return tc.schemaComposer.createResolver<TSource, TArgs>({
     type: tc.NonNull.List.NonNull,

src/resolvers/findOne.ts

@@ -8,7 +8,7 @@ import {
   sortHelper,
   sortHelperArgs,
   projectionHelper,
-  prepareAliases,
+  prepareNestedAliases,
   prepareAliasesReverse,
   replaceAliases,
   FilterHelperArgsOpts,
@@ -57,8 +57,8 @@ export function findOne<TSource = any, TContext = any, TDoc extends Document = a
     throw new Error('Second arg for Resolver findOne() should be instance of ObjectTypeComposer.');
   }
 
-  const aliases = prepareAliases(model);
-  const aliasesReverse = prepareAliasesReverse(model);
+  const aliases = prepareNestedAliases(model.schema);
+  const aliasesReverse = prepareAliasesReverse(model.schema);
 
   return tc.schemaComposer.createResolver<TSource, TArgs>({
     type: tc,

src/resolvers/helpers/__tests__/filter-test.ts

@@ -8,11 +8,11 @@ import { filterHelperArgs, filterHelper } from '../filter';
 import { OPERATORS_FIELDNAME } from '../filterOperators';
 import { UserModel } from '../../../__mocks__/userModel';
 import { convertModelToGraphQL } from '../../../fieldsConverter';
-import { prepareAliases } from '../aliases';
+import { prepareNestedAliases } from '../aliases';
 
 describe('Resolver helper `filter` ->', () => {
   let UserTC: ObjectTypeComposer<any, any>;
-  const aliases = prepareAliases(UserModel);
+  const aliases = prepareNestedAliases(UserModel.schema);
 
   beforeEach(() => {
     schemaComposer.clear();

src/resolvers/helpers/__tests__/projection-test.ts

@@ -15,7 +15,7 @@ describe('Resolver helper `projection` ->', () => {
     });
 
     it('should not call query.select if projection is empty', () => {
-      projectionHelper(resolveParams, false);
+      projectionHelper(resolveParams);
       expect(spyFn).not.toBeCalled();
     });
 
@@ -31,29 +31,35 @@ describe('Resolver helper `projection` ->', () => {
       expect(spyFn).toBeCalledWith({ 'n.first': true, 'n.last': true });
     });
 
+    it('should make projection fields flat with nested aliases', () => {
+      resolveParams.projection = { name: { first: 1, last: 1 } };
+      projectionHelper(resolveParams, { name: { __selfAlias: 'n', first: 'f', last: 'l' } });
+      expect(spyFn).toBeCalledWith({ 'n.f': true, 'n.l': true });
+    });
+
     it('should not call query.select if projection has * key', () => {
       resolveParams.projection = { '*': true };
-      projectionHelper(resolveParams, false);
+      projectionHelper(resolveParams);
       expect(spyFn).not.toBeCalled();
     });
 
     describe('projection operators', () => {
       // see more details here https://docs.mongodb.com/v3.2/reference/operator/projection/meta/
-      it('should pass $meta unflatted', () => {
+      it('should pass $meta non-flatten', () => {
         resolveParams.projection = { score: { $meta: 'textScore' } };
-        projectionHelper(resolveParams, false);
+        projectionHelper(resolveParams);
         expect(spyFn).toBeCalledWith({ score: { $meta: 'textScore' } });
       });
 
-      it('should pass $slice unflatted', () => {
+      it('should pass $slice non-flatten', () => {
         resolveParams.projection = { comments: { $slice: 5 } };
-        projectionHelper(resolveParams, false);
+        projectionHelper(resolveParams);
         expect(spyFn).toBeCalledWith({ comments: { $slice: 5 } });
       });
 
-      it('should pass $elemMatch unflatted', () => {
+      it('should pass $elemMatch non-flatten', () => {
         resolveParams.projection = { students: { $elemMatch: { school: 102 } } };
-        projectionHelper(resolveParams, false);
+        projectionHelper(resolveParams);
         expect(spyFn).toBeCalledWith({ students: { $elemMatch: { school: 102 } } });
       });
     });