BugFix: Handle parsing endpoints when there are no mutations (#3076)

* BugFix: Handle parsing endpoints when there are no mutations * changeset and test * pass tests Co-authored-by: itai <itaimain@gmail.com> Co-authored-by: Arda TANRIKULU <ardatanrikulu@gmail.com>
ardatan · Jun 17, 2021 · 6dc34ff · 6dc34ff
1 parent 50be397
commit 6dc34ff
Show file tree

Hide file tree

Showing 3 changed files with 44 additions and 8 deletions.
diff --git a/.changeset/grumpy-months-nail.md b/.changeset/grumpy-months-nail.md
@@ -0,0 +1,5 @@
+---
+'@graphql-tools/resolvers-composition': patch
+---
+
+BugFix: Handle parsing endpoints when there are no mutations #3076
diff --git a/packages/resolvers-composition/src/resolvers-composition.ts b/packages/resolvers-composition/src/resolvers-composition.ts
@@ -42,6 +42,9 @@ function resolveRelevantMappings<Resolvers extends Record<string, any> = Record<
     const fieldName = split[1];
 
     if (typeName === '*') {
+      if (!resolvers) {
+        return [];
+      }
       return flatten(
         Object.keys(resolvers).map(typeName =>
           resolveRelevantMappings(resolvers, `${typeName}.${fieldName}`, allMappings)
@@ -50,10 +53,12 @@ function resolveRelevantMappings<Resolvers extends Record<string, any> = Record<
     }
 
     if (fieldName === '*') {
+      const fieldMap = resolvers[typeName];
+      if (!fieldMap) {
+        return [];
+      }
       return flatten(
-        Object.keys(resolvers[typeName]).map(field =>
-          resolveRelevantMappings(resolvers, `${typeName}.${field}`, allMappings)
-        )
+        Object.keys(fieldMap).map(field => resolveRelevantMappings(resolvers, `${typeName}.${field}`, allMappings))
       ).filter(mapItem => !allMappings[mapItem]);
     } else {
       const paths = [];
@@ -77,8 +82,13 @@ function resolveRelevantMappings<Resolvers extends Record<string, any> = Record<
   } else if (split.length === 1) {
     const typeName = split[0];
 
+    const fieldMap = resolvers[typeName];
+    if (!fieldMap) {
+      return [];
+    }
+
     return flatten(
-      Object.keys(resolvers[typeName]).map(fieldName =>
+      Object.keys(fieldMap).map(fieldName =>
         resolveRelevantMappings(resolvers, `${typeName}.${fieldName}`, allMappings)
       )
     );
@@ -102,15 +112,16 @@ export function composeResolvers<Resolvers extends Record<string, any>>(
   const mappingResult: { [path: string]: ((...args: any[]) => any)[] } = {};
 
   Object.keys(mapping).forEach((resolverPath: string) => {
-    if (mapping[resolverPath] instanceof Array || typeof mapping[resolverPath] === 'function') {
-      const composeFns = mapping[resolverPath] as ResolversComposition | ResolversComposition[];
+    const resolverPathMapping = mapping[resolverPath];
+    if (resolverPathMapping instanceof Array || typeof resolverPathMapping === 'function') {
+      const composeFns = resolverPathMapping as ResolversComposition | ResolversComposition[];
       const relevantFields = resolveRelevantMappings(resolvers, resolverPath, mapping);
 
       relevantFields.forEach((path: string) => {
         mappingResult[path] = asArray(composeFns);
       });
-    } else {
-      Object.keys(mapping[resolverPath]).forEach(fieldName => {
+    } else if (resolverPathMapping) {
+      Object.keys(resolverPathMapping).forEach(fieldName => {
         const composeFns = mapping[resolverPath][fieldName];
         const relevantFields = resolveRelevantMappings(resolvers, resolverPath + '.' + fieldName, mapping);
 

diff --git a/packages/resolvers-composition/tests/resolvers-composition.spec.ts b/packages/resolvers-composition/tests/resolvers-composition.spec.ts
@@ -2,6 +2,7 @@ import gql from 'graphql-tag';
 import { composeResolvers, ResolversComposerMapping } from '../src';
 import { makeExecutableSchema } from '@graphql-tools/schema';
 import { execute, GraphQLScalarType, Kind } from 'graphql';
+import { IResolvers } from 'packages/graphql-tools/src';
 
 function createAsyncIterator<T>(array: T[]): AsyncIterator<T, T, T> {
   let i = 0;
@@ -289,4 +290,23 @@ describe('Resolvers composition', () => {
     expect(functionsCalled).not.toContain('parseLiteral');
 
   });
+
+  it('should handle nullish properties correctly', async () => {
+    const getFoo = () => 'FOO';
+    const resolvers: IResolvers = {
+      Query: {
+        foo: async () => getFoo(),
+        bar: undefined,
+      },
+      Mutation: undefined
+    };
+    const resolversComposition: ResolversComposerMapping = {
+      'Query.foo': (next: (arg0: any, arg1: any, arg2: any, arg3: any) => void) => async (root: any, args: any, context: any, info: any) => {
+        const prevResult = await next(root, args, context, info);
+        return getFoo() + prevResult;
+      },
+      'Query.bar': undefined
+    };
+    expect(() => composeResolvers(resolvers, resolversComposition)).not.toThrow();
+  })
 });