feat: add astMerge(ast1, ast2, ...) method for merging several ast obtained from directoryToAst

Author: nodkz

src/__tests__/__fixtures__/merge/schema1/mutation/createTask.ts

@@ -0,0 +1,4 @@
+export default {
+  type: 'String',
+  description: 'A.mutation.createTask',
+};

src/__tests__/__fixtures__/merge/schema1/query/me.ts

@@ -0,0 +1,4 @@
+export default {
+  type: 'String',
+  description: 'A.query.me',
+};

src/__tests__/__fixtures__/merge/schema1/query/tasks/byId.ts

@@ -0,0 +1,4 @@
+export default {
+  type: 'String',
+  description: 'A.query.tasks.byId',
+};

src/__tests__/__fixtures__/merge/schema1/query/tasks/list.ts

@@ -0,0 +1,4 @@
+export default {
+  type: 'String',
+  description: 'A.query.tasks.list',
+};

src/__tests__/__fixtures__/merge/schema2/query/me.ts

@@ -0,0 +1,4 @@
+export default {
+  type: 'String',
+  description: 'B.query.me',
+};

src/__tests__/__fixtures__/merge/schema2/query/tasks/byId.ts

@@ -0,0 +1,4 @@
+export default {
+  type: 'String',
+  description: 'B.query.tasks.byId',
+};

src/__tests__/__fixtures__/merge/schema2/query/tasks/byIds.ts

@@ -0,0 +1,4 @@
+export default {
+  type: 'String',
+  description: 'B.query.tasks.byIds',
+};

src/__tests__/__fixtures__/merge/schema2/subscription/events.ts

@@ -0,0 +1,4 @@
+export default {
+  type: 'String',
+  description: 'B.subscription.events',
+};

src/__tests__/astMerge-test.ts

@@ -0,0 +1,52 @@
+import { astMerge } from '../astMerge';
+import { directoryToAst, AstRootNode } from '../directoryToAst';
+import { astToSchema } from '../astToSchema';
+
+describe('astMerge', () => {
+  let ast1: AstRootNode;
+  let ast2: AstRootNode;
+
+  beforeEach(() => {
+    ast1 = directoryToAst(module, { relativePath: './__fixtures__/merge/schema1' });
+    ast2 = directoryToAst(module, { relativePath: './__fixtures__/merge/schema2' });
+  });
+
+  it('should merge two schemas', () => {
+    const mergedAst = astMerge(ast1, ast2);
+    const schema = astToSchema(mergedAst);
+
+    expect(schema.toSDL()).toMatchInlineSnapshot(`
+      "type Mutation {
+        \\"\\"\\"A.mutation.createTask\\"\\"\\"
+        createTask: String
+      }
+
+      type Query {
+        \\"\\"\\"B.query.me\\"\\"\\"
+        me: String
+        tasks: QueryTasks
+      }
+
+      type QueryTasks {
+        \\"\\"\\"B.query.tasks.byId\\"\\"\\"
+        byId: String
+
+        \\"\\"\\"A.query.tasks.list\\"\\"\\"
+        list: String
+
+        \\"\\"\\"B.query.tasks.byIds\\"\\"\\"
+        byIds: String
+      }
+
+      \\"\\"\\"
+      The \`String\` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.
+      \\"\\"\\"
+      scalar String
+
+      type Subscription {
+        \\"\\"\\"B.subscription.events\\"\\"\\"
+        events: String
+      }"
+    `);
+  });
+});

src/astMerge.ts

@@ -0,0 +1,76 @@
+import { AstRootNode, AstRootTypeNode, RootTypeNames, AstDirChildren } from './directoryToAst';
+
+export function astMerge(...asts: Array<AstRootNode>): AstRootNode {
+  const mergedAST = {
+    kind: 'root',
+    name: 'merged',
+    absPath: 'merged',
+    children: {},
+  } as AstRootNode;
+
+  asts.forEach((ast) => {
+    mergedAST.name += `; ${ast.name}`;
+    mergedAST.absPath += `; ${ast.absPath}`;
+
+    // merge rootTypes
+    Object.keys(ast.children).forEach((key) => {
+      const rootName = key as RootTypeNames;
+      const rootTypeNode = ast.children[rootName] as AstRootTypeNode;
+
+      let mergedRootTypeAST = mergedAST.children[rootName];
+      if (!mergedRootTypeAST) {
+        mergedRootTypeAST = {
+          kind: 'rootType',
+          name: rootTypeNode.name,
+          absPath: 'merged',
+          children: {},
+        } as AstRootTypeNode;
+        mergedAST.children[rootName] = mergedRootTypeAST;
+      }
+      mergedRootTypeAST.absPath += `; ${rootTypeNode.absPath}`;
+
+      // maybe in future namespaceConfig will be refactored
+      // but now it just take last one
+      if (rootTypeNode.namespaceConfig) {
+        mergedRootTypeAST.namespaceConfig = rootTypeNode.namespaceConfig;
+      }
+
+      mergedRootTypeAST.children = mergeChildren(mergedRootTypeAST.children, rootTypeNode.children);
+    });
+  });
+
+  return mergedAST;
+}
+
+function mergeChildren(target: AstDirChildren, source: AstDirChildren): AstDirChildren {
+  const result = { ...target };
+  Object.keys(source).forEach((key) => {
+    const targetChild = target[key];
+    const sourceChild = source[key];
+    if (!targetChild) {
+      // add new key from source
+      result[key] = sourceChild;
+    } else if (targetChild.kind === 'dir') {
+      if (sourceChild.kind === 'dir') {
+        // merge dirs
+        const mergedDirNode = {
+          ...targetChild,
+          absPath: `merged; ${targetChild.absPath}; ${sourceChild.absPath}`,
+          children: mergeChildren(targetChild.children, sourceChild.children),
+        };
+        if (sourceChild.namespaceConfig) {
+          mergedDirNode.namespaceConfig = sourceChild.namespaceConfig;
+        }
+        result[key] = mergedDirNode;
+      } else if (sourceChild.kind === 'file') {
+        // replace dir by file from source
+        result[key] = sourceChild;
+      }
+    } else if (targetChild.kind === 'file') {
+      // replace file by any source type
+      result[key] = sourceChild;
+    }
+  });
+
+  return result;
+}