🐛 Design choice: Schema definition from seconf schema should be ignored as it always throws

Author: aexol

src/TreeOperations/merge.ts

@@ -1,4 +1,4 @@
-import { ParserField, ParserTree } from '@/Models';
+import { ParserField, ParserTree, TypeSystemDefinition } from '@/Models';
 import { Parser } from '@/Parser';
 import { isExtensionNode } from '@/TreeOperations/shared';
 import { TreeToGraphQL } from '@/TreeToGraphQL';
@@ -86,7 +86,9 @@ export const mergeTrees = (tree1: ParserTree, tree2: ParserTree) => {
 export const mergeSDLs = (sdl1: string, sdl2: string) => {
   const t1 = Parser.parse(sdl1);
   const t2 = Parser.parse(sdl2);
-  const mergeResult = mergeTrees(t1, t2);
+  const mergeResult = mergeTrees(t1, {
+    nodes: t2.nodes.filter((n) => n.data.type !== TypeSystemDefinition.SchemaDefinition),
+  });
   if (mergeResult.__typename === 'success') {
     const sdl = TreeToGraphQL.parse(mergeResult);
     return {

src/__tests__/Parser/Schema.spec.ts

@@ -1,6 +1,7 @@
 import {
   createParserField,
   createPlainDirectiveImplementation,
+  createPlainField,
   createRootDirectiveField,
   createSchemaDefinition,
   createSchemaExtension,
@@ -274,6 +275,69 @@ describe('Schema base operations', () => {
     };
     expect(tree.nodes).toEqual(expect.arrayContaining(treeMock.nodes));
   });
+  test(`don't override base DDD type with Query`, () => {
+    const schema = `type Query{
+          status: ${ScalarTypes.String}
+      }
+      type DDD {
+        name: String
+      }
+      schema{
+          query: DDD
+      }
+      `;
+    const tree = Parser.parse(schema);
+    const treeMock: ParserTree = {
+      nodes: [
+        createParserField({
+          name: 'Query',
+          type: {
+            fieldType: {
+              name: TypeDefinitionDisplayStrings.type,
+              type: Options.name,
+            },
+          },
+          data: {
+            type: TypeDefinition.ObjectTypeDefinition,
+          },
+
+          args: [
+            createParserField({
+              name: 'status',
+              type: {
+                fieldType: {
+                  name: ScalarTypes.String,
+                  type: Options.name,
+                },
+              },
+              data: {
+                type: TypeSystemDefinition.FieldDefinition,
+              },
+            }),
+          ],
+        }),
+        createParserField({
+          name: 'DDD',
+          type: {
+            fieldType: {
+              name: TypeDefinitionDisplayStrings.type,
+              type: Options.name,
+            },
+          },
+          data: {
+            type: TypeDefinition.ObjectTypeDefinition,
+          },
+          args: [createPlainField({ name: 'name', type: 'String' })],
+        }),
+        createSchemaDefinition({
+          operations: {
+            query: 'DDD',
+          },
+        }),
+      ],
+    };
+    expect(tree.nodes).toEqual(expect.arrayContaining(treeMock.nodes));
+  });
   test(`empty query`, () => {
     const schema = `
       type Query

src/__tests__/TreeOperations/merge.spec.ts

@@ -154,4 +154,39 @@ describe('Merging GraphQL Schemas', () => {
     }`,
     );
   });
+
+  it('Should merge schemas but maintain original schema node', () => {
+    const baseSchema = `
+    type DDD{
+        firstName: String
+        health: String
+    }
+    schema{
+        query: DDD
+    }
+    `;
+
+    const mergingSchema = `
+    type Query{
+        lastName: String
+    }
+    `;
+    const t1 = mergeSDLs(baseSchema, mergingSchema);
+    if (t1.__typename === 'error') throw new Error('Invalid parse');
+    expectTrimmedEqual(
+      t1.sdl,
+      `
+      type DDD{
+          firstName: String
+          health: String
+      }
+      schema{
+          query: DDD
+      }
+      type Query{
+        lastName: String
+    }
+      `,
+    );
+  });
 });

src/__tests__/TreeToGraphQL/Schema.spec.ts

@@ -1,6 +1,7 @@
 import {
   createParserField,
   createPlainDirectiveImplementation,
+  createPlainField,
   createRootDirectiveField,
   createSchemaDefinition,
 } from '@/shared';
@@ -56,6 +57,58 @@ describe('Schema base operations in TreeToGraphQL', () => {
     const graphql = trimGraphQL(TreeToGraphQL.parse(treeMock));
     expect(graphql).toContain(trimGraphQL(`schema{ query: Query}`));
   });
+  test(`query with different name and 'Query' named node`, () => {
+    const treeMock: ParserTree = {
+      nodes: [
+        createParserField({
+          name: 'Query',
+          type: {
+            fieldType: {
+              name: TypeDefinitionDisplayStrings.type,
+              type: Options.name,
+            },
+          },
+          data: {
+            type: TypeDefinition.ObjectTypeDefinition,
+          },
+          args: [
+            createParserField({
+              name: 'status',
+              type: {
+                fieldType: {
+                  name: ScalarTypes.String,
+                  type: Options.name,
+                },
+              },
+              data: {
+                type: TypeSystemDefinition.FieldDefinition,
+              },
+            }),
+          ],
+        }),
+        createParserField({
+          name: 'DDD',
+          type: {
+            fieldType: {
+              name: TypeDefinitionDisplayStrings.type,
+              type: Options.name,
+            },
+          },
+          data: {
+            type: TypeDefinition.ObjectTypeDefinition,
+          },
+          args: [createPlainField({ name: 'name', type: 'String' })],
+        }),
+        createSchemaDefinition({
+          operations: {
+            query: 'DDD',
+          },
+        }),
+      ],
+    };
+    const graphql = trimGraphQL(TreeToGraphQL.parse(treeMock));
+    expect(graphql).toContain(trimGraphQL(`schema{ query: DDD}`));
+  });
   test(`query with directives`, () => {
     const treeMock: ParserTree = {
       nodes: [