✨ Added schema merging algorithm

Author: aexol

Diff for: package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-js-tree",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "private": false,
   "license": "MIT",
   "description": "GraphQL Parser providing simplier structure",

Diff for: src/TreeOperations/merge.ts

@@ -0,0 +1,92 @@
+import { ParserField, ParserTree } from '@/Models';
+import { Parser } from '@/Parser';
+import { isExtensionNode } from '@/TreeOperations/shared';
+import { TreeToGraphQL } from '@/TreeToGraphQL';
+
+const mergeNode = (n1: ParserField, n2: ParserField) => {
+  const mergedNode = {
+    ...n1,
+    args: [...n1.args, ...n2.args],
+    directives: [...n1.directives, ...n2.directives],
+    interfaces: [...n1.interfaces, ...n2.interfaces],
+  } as ParserField;
+  //dedupe
+  mergedNode.args = mergedNode.args.filter((a, i) => mergedNode.args.findIndex((aa) => aa.name === a.name) === i);
+  mergedNode.directives = mergedNode.directives.filter(
+    (a, i) => mergedNode.directives.findIndex((aa) => aa.name === a.name) === i,
+  );
+  mergedNode.interfaces = mergedNode.interfaces.filter(
+    (a, i) => mergedNode.interfaces.findIndex((aa) => aa === a) === i,
+  );
+  return mergedNode;
+};
+
+export const mergeTrees = (tree1: ParserTree, tree2: ParserTree) => {
+  const mergedNodesT1: ParserField[] = [];
+  const mergedNodesT2: ParserField[] = [];
+  const mergeResultNodes: ParserField[] = [];
+  const errors: Array<{ conflictingNode: string; conflictingField: string }> = [];
+  // merge nodes
+  tree1.nodes.forEach((t1n) => {
+    const matchingNode = tree2.nodes.find((t2n) => t2n.name === t1n.name && t1n.data.type === t2n.data.type);
+    if (matchingNode) {
+      if (isExtensionNode(matchingNode.data.type)) {
+        t1n.args.forEach((t1nA) => {
+          const matchingArg = matchingNode.args.find((mNA) => mNA.name === t1nA.name);
+          if (matchingArg) {
+            if (JSON.stringify(matchingArg) !== JSON.stringify(t1nA)) {
+              errors.push({
+                conflictingField: t1nA.name,
+                conflictingNode: t1n.name,
+              });
+            }
+          }
+        });
+      } else {
+        // Check if arg named same and different typings -> throw
+        mergedNodesT1.push(t1n);
+        mergedNodesT2.push(matchingNode);
+        t1n.args.forEach((t1nA) => {
+          const matchingArg = matchingNode.args.find((mNA) => mNA.name === t1nA.name);
+          if (matchingArg) {
+            if (JSON.stringify(matchingArg) !== JSON.stringify(t1nA)) {
+              errors.push({
+                conflictingField: t1nA.name,
+                conflictingNode: t1n.name,
+              });
+            }
+          }
+        });
+        if (!errors.length) {
+          mergeResultNodes.push(mergeNode(t1n, matchingNode));
+        }
+      }
+    }
+  });
+  if (errors.length) {
+    return {
+      __typename: 'error' as const,
+      errors,
+    };
+  }
+  const t1Nodes = tree1.nodes.filter((t1n) => !mergedNodesT1.find((mtn1) => mtn1 === t1n));
+  const t2Nodes = tree2.nodes.filter((t2n) => !mergedNodesT2.find((mtn2) => mtn2 === t2n));
+  return {
+    __typename: 'success' as const,
+    nodes: [...t1Nodes, ...mergeResultNodes, ...t2Nodes],
+  };
+};
+
+export const mergeSDLs = (sdl1: string, sdl2: string) => {
+  const t1 = Parser.parse(sdl1);
+  const t2 = Parser.parse(sdl2);
+  const mergeResult = mergeTrees(t1, t2);
+  if (mergeResult.__typename === 'success') {
+    const sdl = TreeToGraphQL.parse(mergeResult);
+    return {
+      ...mergeResult,
+      sdl,
+    };
+  }
+  return mergeResult;
+};

Diff for: src/__tests__/TreeOperations/merge.spec.ts

@@ -0,0 +1,125 @@
+import { mergeSDLs } from '@/TreeOperations/merge';
+import { expectTrimmedEqual } from '@/__tests__/TestUtils';
+
+// const mergingErrorSchema = `
+// type Person{
+//     lastName: String
+// }
+// `;
+
+describe('Merging GraphQL Schemas', () => {
+  it('Should merge fields of both nodes', () => {
+    const baseSchema = `
+    type Person{
+        firstName: String
+        health: String
+    }
+    `;
+
+    const mergingSchema = `
+    type Person{
+        lastName: String
+    }
+    `;
+    const t1 = mergeSDLs(baseSchema, mergingSchema);
+    if (t1.__typename === 'error') throw new Error('Invalid parse');
+    expectTrimmedEqual(
+      t1.sdl,
+      `
+    type Person{
+        firstName: String
+        health: String
+        lastName: String
+    }`,
+    );
+  });
+  it('Should generate Conflict', () => {
+    const baseSchema = `
+    type Person{
+        firstName: String
+        health: String
+    }
+    `;
+
+    const mergingSchema = `
+    type Person{
+        lastName: String
+        health: Int
+    }
+    `;
+    const t1 = mergeSDLs(baseSchema, mergingSchema);
+    expect(t1.__typename).toEqual('error');
+  });
+  it('Should not merge extension nodes', () => {
+    const baseSchema = `
+    type Person{
+        firstName: String
+    }
+    extend type Person{
+        lastName: String
+    }
+    `;
+
+    const mergingSchema = `
+    extend type Person{
+        age: String
+    }
+    `;
+    const t1 = mergeSDLs(baseSchema, mergingSchema);
+    if (t1.__typename === 'error') throw new Error('Invalid parse');
+    expectTrimmedEqual(
+      t1.sdl,
+      `
+    type Person{
+        firstName: String
+    }
+    extend type Person{
+        lastName: String
+    } 
+    extend type Person{
+        age: String
+    }`,
+    );
+  });
+  it('Should merge interfaces and implementation of both nodes', () => {
+    const baseSchema = `
+    type Person implements Node{
+        firstName: String
+        health: String
+        _id: String
+    }
+    interface Node {
+        _id: String
+    }
+    `;
+
+    const mergingSchema = `
+    type Person implements Dateable{
+        lastName: String
+        createdAt: String
+    }
+    interface Dateable {
+        createdAt: String
+    }
+    `;
+    const t1 = mergeSDLs(baseSchema, mergingSchema);
+    if (t1.__typename === 'error') throw new Error('Invalid parse');
+    expectTrimmedEqual(
+      t1.sdl,
+      `
+      interface Node {
+          _id: String
+      }
+    type Person implements Node & Dateable{
+        firstName: String
+        health: String
+        _id: String
+        lastName: String
+        createdAt: String
+    }
+    interface Dateable {
+        createdAt: String
+    }`,
+    );
+  });
+});

Diff for: src/index.ts

@@ -3,6 +3,7 @@ export * from './Parser';
 export * from './Models';
 export * from './shared/index';
 export * from './TreeOperations/tree';
+export * from './TreeOperations/merge';
 export * from './GqlParser/index';
 export * from './GqlParser/GqlParserTreeToGql';
 export * from './GqlParser/valueNode';