✨ added gql parser

Author: aexol

README.md

@@ -6,6 +6,8 @@ Simplier approach to GraphQL parsing. Using graphql-js library and parsing AST t
 
 ## How it works
 
+### SDL GraphQL
+
 It creates very simple `ParserTree` from GraphQL schema
 
 ```js
@@ -27,9 +29,38 @@ const parsedSchema = Parser.parse(schemaFileContents);
 const graphqlString = TreeToGraphQL.parse(parsedSchema);
 ```
 
+### GQL
+
+```js
+import { parseGql } from 'graphql-js-tree';
+
+const schemaFileContents = `
+type Query{
+    hello: String!
+}
+schema{
+    query: Query
+}
+`;
+
+const gqlQuery = `
+    query MyQuery{
+        hello
+    }
+`;
+
+const parsedTrees = parseGql(gqlQuery, schemaFileContents);
+
+// Backwards
+
+const gqlString = parseGqlTrees(parsedTrees);
+```
+
 ## Table of contents
 
 - [How it works](#how-it-works)
+  - [SDL GraphQL](#sdl-graphql)
+  - [GQL](#gql)
 - [Table of contents](#table-of-contents)
 - [License](#license)
 - [Support](#support)

package.json

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

src/GqlParser/GqlParserTreeToGql.ts

@@ -1,14 +1,23 @@
+import { parseGql } from '@/GqlParser';
 import { getValueAsGqlStringNode } from '@/GqlParser/valueNode';
 import { Instances, TypeSystemDefinition } from '@/Models';
 import { GqlParserTree, VariableDefinitionWithoutLoc } from '@/Models/GqlParserTree';
 import { compileType } from '@/shared';
-export const GqlParserTreeToGql = (mainTree: GqlParserTree) => {
+export const parseGqlTree = (mainTree: GqlParserTree) => {
   const generateName = (tree: GqlParserTree): string => {
-    return `${
-      tree.operation
-        ? `${tree.operation}${tree.name ? ` ${tree.name}` : ''}${generateVariableDefinitions(tree)}`
-        : tree.name
-    }`;
+    if (tree.operation) {
+      return `${tree.operation}${tree.name ? ` ${tree.name}` : ''}${generateVariableDefinitions(tree)}`;
+    }
+    if (tree.fragment) {
+      return `fragment ${tree.name} on ${tree.node.name}`;
+    }
+    if (tree.fragmentSpread) {
+      return `...${tree.name}`;
+    }
+    if (tree.inlineFragment) {
+      return `...${tree.name ? ` on ${tree.name}` : ''}`;
+    }
+    return tree.name || '';
   };
   const generateChildren = (tree: GqlParserTree): string => {
     return `${tree.children ? `{\n ${tree.children.map(generateGql).join('\n ')}\n}` : ''}`;
@@ -32,6 +41,10 @@ export const GqlParserTreeToGql = (mainTree: GqlParserTree) => {
   return generateGql(mainTree);
 };
 
+export const parseGqlTrees = (trees: GqlParserTree[]) => {
+  return trees.map(parseGqlTree).join('\n');
+};
+
 export const enrichFieldNodeWithVariables = (
   fieldTree: GqlParserTree,
   variableDefinitionsUpdate: (
@@ -92,3 +105,8 @@ export const enrichWholeTreeWithVars = (mainTree: GqlParserTree): GqlParserTree
   };
   return { ...recursiveEnrich(mainTree), variableDefinitions };
 };
+
+export const enrichGqlQueryWithAllVars = (query: string, schema: string) => {
+  const trees = parseGql(query, schema);
+  return parseGqlTrees(trees.map(enrichWholeTreeWithVars));
+};

src/GqlParser/index.ts

@@ -1,9 +1,9 @@
 import { getValueWithoutLoc } from '@/GqlParser/valueNode';
-import { OperationType, ParserField } from '@/Models';
+import { OperationType, ParserField, TypeDefinition } from '@/Models';
 import { GqlParserTree, VariableDefinitionWithoutLoc } from '@/Models/GqlParserTree';
 import { Parser } from '@/Parser';
 import { TypeResolver } from '@/Parser/typeResolver';
-import { compileType } from '@/shared';
+import { compileType, getTypeName } from '@/shared';
 import {
   DefinitionNode,
   parse,
@@ -13,10 +13,14 @@ import {
   DirectiveNode,
   FieldNode,
   VariableDefinitionNode,
+  FragmentDefinitionNode,
+  FragmentSpreadNode,
+  InlineFragmentNode,
 } from 'graphql';
-export const GqlParser = (gql: string, schema: string) => {
+export const parseGql = (gql: string, schema: string) => {
   const { definitions } = parse(schema + '\n' + gql);
   const ops = definitions.filter(onlyOperations);
+  const frags = definitions.filter(onlyFragments);
   const { nodes } = Parser.parse(schema);
 
   const composeDefinition = (d: OperationDefinitionNode): GqlParserTree => {
@@ -42,7 +46,21 @@ export const GqlParser = (gql: string, schema: string) => {
             variableDefinitions: d.variableDefinitions.map((vd) => composeVariableDefinition(vd)),
           }
         : {}),
-      children: d.selectionSet.selections.filter(onlyFieldNodes).map((s) => composeSelectionNode(s, node)),
+      children: d.selectionSet.selections.map((s) => composeSelectionNode(s, node)),
+    };
+  };
+
+  const composeFragment = (f: FragmentDefinitionNode): GqlParserTree => {
+    const node = nodes.find((n) => n.name == f.typeCondition.name.value);
+    if (!node) {
+      throw new Error(`Type ${f.typeCondition.name.value} does not exist in schema`);
+    }
+    return {
+      node,
+      fragment: true,
+      name: f.name.value,
+      ...(f.directives?.length ? { directives: f.directives.map((a) => composeDirectiveNode(a, node)) } : {}),
+      children: f.selectionSet.selections.map((s) => composeSelectionNode(s, node)),
     };
   };
 
@@ -74,29 +92,66 @@ export const GqlParser = (gql: string, schema: string) => {
     return {
       node,
       name: a.name.value,
-      arguments: a.arguments?.map((a) => composeArgumentNode(a, node)),
+      ...(a.arguments?.length ? { arguments: a.arguments?.map((ar) => composeArgumentNode(ar, node)) } : {}),
     };
   };
 
-  const composeSelectionNode = (s: FieldNode, parentNode: ParserField): GqlParserTree => {
+  const composeFragmentSpread = (f: FragmentSpreadNode, node: ParserField): GqlParserTree => {
+    return {
+      node,
+      name: f.name.value,
+      ...(f.directives?.length ? { directives: f.directives?.map((a) => composeDirectiveNode(a, node)) } : {}),
+      fragmentSpread: true,
+    };
+  };
+  const composeInlineFragment = (f: InlineFragmentNode, node: ParserField): GqlParserTree => {
+    const chosenNode = nodes.find((n) => n.name === f.typeCondition?.name.value);
+    const rightNode = chosenNode || node;
+    return {
+      node: rightNode,
+      name: rightNode.name,
+      ...(f.directives?.length ? { directives: f.directives?.map((a) => composeDirectiveNode(a, rightNode)) } : {}),
+      inlineFragment: true,
+      children: f.selectionSet.selections.map((s) => composeSelectionNode(s, rightNode)),
+    };
+  };
+
+  const composeSelectionNode = (s: SelectionNode, node: ParserField): GqlParserTree => {
+    if (s.kind === 'Field') return composeFieldNode(s, node);
+    if (s.kind === 'FragmentSpread') return composeFragmentSpread(s, node);
+    return composeInlineFragment(s, node);
+  };
+
+  const composeFieldNode = (s: FieldNode, parentNode: ParserField): GqlParserTree => {
     const fieldNode = parentNode.args.find((a) => a.name === s.name.value);
     if (!fieldNode) {
-      throw new Error('Field does not exist in schema');
+      throw new Error(`Field "${s.name.value}" does not exist in "${parentNode.name}" node`);
     }
+    const passParentDown = getTypeName(fieldNode.type.fieldType);
+    const isParentObjectNode = nodes.find(
+      (n) =>
+        n.name === passParentDown &&
+        (n.data.type === TypeDefinition.ObjectTypeDefinition ||
+          n.data.type === TypeDefinition.UnionTypeDefinition ||
+          n.data.type === TypeDefinition.InterfaceTypeDefinition),
+    );
+
     return {
       node: fieldNode,
       name: s.name.value,
-      arguments: s.arguments?.map((a) => composeArgumentNode(a, fieldNode)),
-      directives: s.directives?.map((a) => composeDirectiveNode(a, fieldNode)),
-      children: s.selectionSet?.selections.filter(onlyFieldNodes).map((a) => composeSelectionNode(a, fieldNode)),
+      ...(s.arguments?.length ? { arguments: s.arguments?.map((a) => composeArgumentNode(a, fieldNode)) } : {}),
+      ...(s.directives?.length ? { directives: s.directives?.map((a) => composeDirectiveNode(a, fieldNode)) } : {}),
+      ...(s.selectionSet?.selections.length
+        ? { children: s.selectionSet.selections.map((s) => composeSelectionNode(s, isParentObjectNode || fieldNode)) }
+        : {}),
     } as GqlParserTree;
   };
-  return ops.map((o) => composeDefinition(o));
+  return [...frags.map((f) => composeFragment(f)), ...ops.map((o) => composeDefinition(o))];
 };
 
 const onlyOperations = (definition: DefinitionNode): definition is OperationDefinitionNode => {
   return definition.kind === 'OperationDefinition';
 };
-const onlyFieldNodes = (definition: SelectionNode): definition is FieldNode => {
-  return definition.kind === 'Field';
+const onlyFragments = (definition: DefinitionNode): definition is FragmentDefinitionNode => {
+  return definition.kind === 'FragmentDefinition';
 };

src/Models/GqlParserTree.ts

@@ -38,6 +38,8 @@ export type GqlParserTree = {
   arguments?: GqlParserTree[];
   directives?: GqlParserTree[];
   fragment?: boolean;
+  fragmentSpread?: boolean;
+  inlineFragment?: boolean;
   value?: ValueNodeWithoutLoc;
   operation?: OperationType;
   variableDefinitions?: VariableDefinitionWithoutLoc[];