pass tests

ardatan · ardatan · commit c997bb0acdaa · 2021-06-17T14:02:41.000+03:00
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,14 +53,12 @@ function resolveRelevantMappings<Resolvers extends Record<string, any> = Record<
     }
 
     if (fieldName === '*') {
-      const endpoints = resolvers[typeName];
-      if (!endpoints) {
-          return []
+      const fieldMap = resolvers[typeName];
+      if (!fieldMap) {
+        return [];
       }
       return flatten(
-        Object.keys(endpoints).map(field =>
-          resolveRelevantMappings(resolvers, `${typeName}.${field}`, allMappings)
-        )
+        Object.keys(fieldMap).map(field => resolveRelevantMappings(resolvers, `${typeName}.${field}`, allMappings))
       ).filter(mapItem => !allMappings[mapItem]);
     } else {
       const paths = [];
@@ -81,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)
       )
     );
@@ -106,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;
@@ -292,40 +293,20 @@ describe('Resolvers composition', () => {
 
   it('should handle nullish properties correctly', async () => {
     const getFoo = () => 'FOO';
-    const typeDefs = gql`
-      type Query {
-        foo: String
-        bar: String
-      }
-    `;
-    const resolvers = {
+    const resolvers: IResolvers = {
       Query: {
-        foo: async () => getFoo()
+        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': null,
+      'Query.bar': undefined
     };
-    const composedResolvers = composeResolvers(resolvers, resolversComposition);
-    const schema = makeExecutableSchema({
-      typeDefs,
-      resolvers: composedResolvers,
-    });
-
-    const result = await execute({
-      schema,
-
-      document: gql`
-        query {
-          foo
-        }
-      `,
-    });
-    expect(result.errors).toBeFalsy();
-    expect(result.data.foo).toBe('FOOFOO');
+    expect(() => composeResolvers(resolvers, resolversComposition)).not.toThrow();
   })
 });
