Multiple fragments support

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 * Loosens the apollo-link dependency [PR #765](https://github.com/apollographql/graphql-tools/pull/765)
 * Use `getDescription` from `graphql-js` package [PR #672](https://github.com/apollographql/graphql-tools/pull/672)
+* Add support for overlapping fragments in ReplaceFieldWithFragment. [#894](https://github.com/apollographql/graphql-tools/issues/894)
 
 ### v3.0.5
 

src/test/testTransforms.ts

@@ -17,6 +17,7 @@ import {
   FilterTypes,
   WrapQuery,
   ExtractField,
+  ReplaceFieldWithFragment,
 } from '../transforms';
 
 describe('transforms', () => {
@@ -101,8 +102,8 @@ describe('transforms', () => {
               }
             }
             properties(limit: 1) {
-               __typename
-               id
+              __typename
+              id
             }
             propertyById(id: "p1") {
               ... on Property_Property {
@@ -133,7 +134,7 @@ describe('transforms', () => {
             {
               __typename: 'Property_Property',
               id: 'p1',
-            }
+            },
           ],
           propertyById: {
             id: 'p1',
@@ -478,4 +479,108 @@ describe('transforms', () => {
       });
     });
   });
+
+  describe('replaces field with fragments', () => {
+    let data: any;
+    let schema: GraphQLSchema;
+    let subSchema: GraphQLSchema;
+    before(() => {
+      data = {
+        u1: {
+          id: 'u1',
+          name: 'joh',
+          surname: 'gats',
+        },
+      };
+
+      subSchema = makeExecutableSchema({
+        typeDefs: `
+          type User {
+            id: ID!
+            name: String!
+            surname: String!
+          }
+
+          type Query {
+            userById(id: ID!): User
+          }
+        `,
+        resolvers: {
+          Query: {
+            userById(parent, { id }) {
+              return data[id];
+            },
+          },
+        },
+      });
+
+      schema = makeExecutableSchema({
+        typeDefs: `
+          type User {
+            id: ID!
+            name: String!
+            surname: String!
+            fullname: String!
+          }
+
+          type Query {
+            userById(id: ID!): User
+          }
+        `,
+        resolvers: {
+          Query: {
+            userById(parent, { id }, context, info) {
+              return delegateToSchema({
+                schema: subSchema,
+                operation: 'query',
+                fieldName: 'userById',
+                args: { id },
+                context,
+                info,
+                transforms: [
+                  new ReplaceFieldWithFragment(subSchema, [
+                    {
+                      field: `fullname`,
+                      fragment: `fragment UserName on User { name }`,
+                    },
+                    {
+                      field: `fullname`,
+                      fragment: `fragment UserSurname on User { surname }`,
+                    },
+                  ]),
+                ],
+              });
+            },
+          },
+          User: {
+            fullname(parent, args, context, info) {
+              return `${parent.name} ${parent.surname}`;
+            },
+          },
+        },
+      });
+    });
+    it('should work', async () => {
+      const result = await graphql(
+        schema,
+        `
+          query {
+            userById(id: "u1") {
+              id
+              fullname
+            }
+          }
+        `,
+      );
+
+      expect(result).to.deep.equal({
+        data: {
+          userById: {
+            id: 'u1',
+            fullname: 'joh gats',
+          },
+        },
+      });
+    });
+  });
 });

src/transforms/ReplaceFieldWithFragment.ts

@@ -10,6 +10,7 @@ import {
   parse,
   visit,
   visitWithTypeInfo,
+  SelectionNode,
 } from 'graphql';
 import { Request } from '../Interfaces';
 import { Transform } from './transforms';
@@ -31,7 +32,12 @@ export default class ReplaceFieldWithFragment implements Transform {
       const parsedFragment = parseFragmentToInlineFragment(fragment);
       const actualTypeName = parsedFragment.typeCondition.name.value;
       this.mapping[actualTypeName] = this.mapping[actualTypeName] || {};
-      this.mapping[actualTypeName][field] = parsedFragment;
+
+      if (this.mapping[actualTypeName][field]) {
+        this.mapping[actualTypeName][field].push(parsedFragment);
+      } else {
+        this.mapping[actualTypeName][field] = [parsedFragment];
+      }
     }
   }
 
@@ -49,7 +55,7 @@ export default class ReplaceFieldWithFragment implements Transform {
 }
 
 type FieldToFragmentMapping = {
-  [typeName: string]: { [fieldName: string]: InlineFragmentNode };
+  [typeName: string]: { [fieldName: string]: InlineFragmentNode[] };
 };
 
 function replaceFieldsWithFragments(
@@ -73,8 +79,12 @@ function replaceFieldsWithFragments(
             node.selections.forEach(selection => {
               if (selection.kind === Kind.FIELD) {
                 const name = selection.name.value;
-                const fragment = mapping[parentTypeName][name];
-                if (fragment) {
+                const fragments = mapping[parentTypeName][name];
+                if (fragments && fragments.length > 0) {
+                  const fragment = concatInlineFragments(
+                    parentTypeName,
+                    fragments,
+                  );
                   selections = selections.concat(fragment);
                 }
               }
@@ -119,3 +129,103 @@ function parseFragmentToInlineFragment(
 
   throw new Error('Could not parse fragment');
 }
+
+function concatInlineFragments(
+  type: string,
+  fragments: InlineFragmentNode[],
+): InlineFragmentNode {
+  const fragmentSelections: SelectionNode[] = fragments.reduce(
+    (selections, fragment) => {
+      return selections.concat(fragment.selectionSet.selections);
+    },
+    [],
+  );
+
+  const deduplicatedFragmentSelection: SelectionNode[] = deduplicateSelection(
+    fragmentSelections,
+  );
+
+  return {
+    kind: Kind.INLINE_FRAGMENT,
+    typeCondition: {
+      kind: Kind.NAMED_TYPE,
+      name: {
+        kind: Kind.NAME,
+        value: type,
+      },
+    },
+    selectionSet: {
+      kind: Kind.SELECTION_SET,
+      selections: deduplicatedFragmentSelection,
+    },
+  };
+}
+
+function deduplicateSelection(nodes: SelectionNode[]): SelectionNode[] {
+  const selectionMap = nodes.reduce<{ [key: string]: SelectionNode }>(
+    (map, node) => {
+      switch (node.kind) {
+        case 'Field': {
+          if (node.alias) {
+            if (map.hasOwnProperty(node.alias.value)) {
+              return map;
+            } else {
+              return {
+                ...map,
+                [node.alias.value]: node,
+              };
+            }
+          } else {
+            if (map.hasOwnProperty(node.name.value)) {
+              return map;
+            } else {
+              return {
+                ...map,
+                [node.name.value]: node,
+              };
+            }
+          }
+        }
+        case 'FragmentSpread': {
+          if (map.hasOwnProperty(node.name.value)) {
+            return map;
+          } else {
+            return {
+              ...map,
+              [node.name.value]: node,
+            };
+          }
+        }
+        case 'InlineFragment': {
+          if (map.__fragment) {
+            const fragment = map.__fragment as InlineFragmentNode;
+
+            return {
+              ...map,
+              __fragment: concatInlineFragments(
+                fragment.typeCondition.name.value,
+                [fragment, node],
+              ),
+            };
+          } else {
+            return {
+              ...map,
+              __fragment: node,
+            };
+          }
+        }
+        default: {
+          return map;
+        }
+      }
+    },
+    {},
+  );
+
+  const selection = Object.keys(selectionMap).reduce(
+    (selectionList, node) => selectionList.concat(selectionMap[node]),
+    [],
+  );
+
+  return selection;
+}