fix(Projection): Pass top level projections to findMany resolver's projection

It pass more dirty projection to findMany() but simplify hooking connection projections by wrappers.

Author: nodkz

src/__tests__/connectionResolver-test.js

@@ -20,7 +20,7 @@ describe('connectionResolver', () => {
     sort: sortOptions,
   });
 
-  describe('basic checks', () => {
+  describe('definition checks', () => {
     it('should return Resolver', () => {
       expect(connectionResolver).instanceof(Resolver);
     });
@@ -98,6 +98,63 @@ describe('connectionResolver', () => {
     });
   });
 
+  describe('call of findMany resolver', () => {
+    let spyResolveParams;
+    let mockedConnectionResolver;
+
+    beforeEach(() => {
+      const mockedFindMany = userTypeComposer.getResolver('findMany')
+        .wrapResolve((next) => (resolveParams) => {
+          spyResolveParams = resolveParams;
+          return next(resolveParams);
+        });
+      userTypeComposer.setResolver('mockedFindMany', mockedFindMany);
+      mockedConnectionResolver = prepareConnectionResolver(userTypeComposer, {
+        countResolverName: 'count',
+        findResolverName: 'mockedFindMany',
+        sort: sortOptions,
+      });
+    });
+
+    it('should pass args.sort', async () => {
+      const result = await mockedConnectionResolver.resolve({
+        args: {
+          sort: { name: 1 },
+          first: 3,
+        },
+      });
+      expect(spyResolveParams).have.deep.property('args.sort.name', 1);
+    });
+
+    it('should pass projection edges.node on top level', async () => {
+      const result = await mockedConnectionResolver.resolve({
+        args: {},
+        projection: {
+          edges: {
+            node: {
+              name: true,
+              age: true,
+            }
+          }
+        },
+      });
+      expect(spyResolveParams).have.deep.property('projection.name', true);
+      expect(spyResolveParams).have.deep.property('projection.age', true);
+    });
+
+    it('should pass custom projections to top level', async () => {
+      const result = await mockedConnectionResolver.resolve({
+        args: {},
+        projection: {
+          score: { $meta: 'textScore' },
+        },
+      });
+      expect(spyResolveParams).have.deep.property('projection.score');
+      expect(spyResolveParams).have.deep.property('projection.score')
+        .to.deep.equal({ $meta: 'textScore' });
+    });
+  });
+
   describe('prepareRawQuery()', () => {
     const sortConfig = {
       value: { id: 1 },

src/connectionResolver.js

@@ -119,10 +119,15 @@ export function prepareConnectionResolver(
 
 
       if (projection && projection.edges) {
-        // $FlowFixMe
-        findManyParams.projection = projection.edges.node || {};
+        // combine top level projection (maybe somebody add additional fields via resolveParams.projection)
+        // and edges.node (record needed fields)
+        findManyParams.projection = Object.assign(
+          {},
+          projection,
+          projection.edges.node || {}
+        );
       } else {
-        findManyParams.projection = {};
+        findManyParams.projection = Object.assign({}, projection);
       }
 
       if (!first && last) {