🚧 WIP Arrays

Author: aexol

src/Models/Options.ts

@@ -1,19 +1,17 @@
-import { Options } from './Options';
-import { Directive, OperationType } from './Spec';
+import { Directive, OperationType, FieldType } from './Spec';
 import { GraphQLNodeParams } from './Types';
 
 export interface ParserField {
   name: string;
   type: {
-    name: string;
-    options?: Options[];
+    fieldType: FieldType;
     operations?: OperationType[];
     directiveOptions?: Directive[];
   };
   data: GraphQLNodeParams;
-  args?: ParserField[];
-  interfaces?: string[];
-  directives?: ParserField[];
+  args: ParserField[];
+  interfaces: string[];
+  directives: ParserField[];
   description?: string;
 }
 

src/Models/ParserTree.ts

@@ -91,3 +91,11 @@ export enum Helpers {
   Extend = 'Extend',
   Comment = 'Comment',
 }
+
+export enum Options {
+  array = 'array',
+  required = 'required',
+  name = 'name',
+}
+
+export type FieldType = { type: Options; nest?: FieldType; name?: string };

src/Models/Spec.ts

@@ -1,5 +1,4 @@
 export * from './ParserTree';
-export * from './Options';
 export * from './Types';
 export * from './Spec';
 export * from './DisplayMap';

src/Models/index.ts

@@ -1,11 +1,5 @@
 import { ParserField, TypeDefinition, TypeExtension } from '@/Models';
 
-const compareArrays = (a1: any[] = [], a2: any[] = []): boolean =>
-  a1.length === a2.length &&
-  a1.sort().every((value, index) => {
-    return value === a2.sort()[index];
-  });
-
 const extensionMap: Record<TypeExtension, TypeDefinition> = {
   EnumTypeExtension: TypeDefinition.EnumTypeDefinition,
   InputObjectTypeExtension: TypeDefinition.InputObjectTypeDefinition,
@@ -18,51 +12,6 @@ const extensionMap: Record<TypeExtension, TypeDefinition> = {
  * Class used mainly for comparison of ParserFields
  */
 export class ParserUtils {
-  /**
-   * Compare two parserFields
-   */
-  static compareParserFields = (node1: ParserField, node2: ParserField): boolean => {
-    if (
-      node1.name !== node2.name ||
-      node1.type.name !== node2.type.name ||
-      !compareArrays(node1.type.directiveOptions, node2.type.directiveOptions) ||
-      !compareArrays(node1.type.operations, node2.type.operations) ||
-      !compareArrays(node1.type.options, node2.type.options) ||
-      !compareArrays(node1.interfaces, node2.interfaces) ||
-      !ParserUtils.compareParserTreesNodes(node1.directives, node2.directives) ||
-      !ParserUtils.compareParserTreesNodes(node1.args, node2.args)
-    ) {
-      return false;
-    }
-    return true;
-  };
-  /**
-   * Compare parserfields arrays
-   */
-  static compareParserTreesNodes = (t1: ParserField[] | undefined, t2: ParserField[] | undefined): boolean => {
-    if (!t1) {
-      if (!t2) {
-        return true;
-      }
-      if (t2.length === 0) {
-        return true;
-      }
-      return false;
-    }
-    if (!t2) {
-      if (t1.length === 0) {
-        return true;
-      }
-      return false;
-    }
-    for (const node1 of t1) {
-      const compareResult = t2.find((node2) => ParserUtils.compareParserFields(node1, node2));
-      if (!compareResult) {
-        return false;
-      }
-    }
-    return true;
-  };
   static isExtensionOf = (extensionNode: ParserField, extendedNode: ParserField): boolean => {
     if (extendedNode.name !== extensionNode.name) {
       return false;

src/Parser/ParserUtils.ts

@@ -7,7 +7,7 @@ import {
   isTypeSystemExtensionNode,
   parse,
 } from 'graphql';
-import { AllTypes, ParserField, ParserTree, TypeDefinitionDisplayMap } from '@/Models';
+import { AllTypes, ParserField, ParserTree, TypeDefinitionDisplayMap, Options } from '@/Models';
 import { Directive, Helpers, OperationType, TypeDefinition, TypeExtension } from '@/Models/Spec';
 import { TypeResolver } from './typeResolver';
 import { ParserUtils } from './ParserUtils';
@@ -36,18 +36,19 @@ export class Parser {
           type:
             d.kind === 'DirectiveDefinition'
               ? {
-                  name: TypeDefinitionDisplayMap[d.kind],
+                  fieldType: { name: TypeDefinitionDisplayMap[d.kind], type: Options.name },
                   directiveOptions: d.locations.map((l) => l.value as Directive),
                 }
               : {
-                  name: TypeDefinitionDisplayMap[d.kind],
+                  fieldType: { name: TypeDefinitionDisplayMap[d.kind], type: Options.name },
                 },
           data: {
             type: d.kind as AllTypes,
           },
-          description: 'description' in d && d.description ? d.description.value : '',
-          interfaces: 'interfaces' in d && d.interfaces ? d.interfaces.map((i) => i.name.value) : undefined,
-          directives: 'directives' in d && d.directives ? TypeResolver.iterateDirectives(d.directives) : undefined,
+
+          ...('description' in d && d.description?.value ? { description: d.description.value } : {}),
+          interfaces: 'interfaces' in d && d.interfaces ? d.interfaces.map((i) => i.name.value) : [],
+          directives: 'directives' in d && d.directives ? TypeResolver.iterateDirectives(d.directives) : [],
           args: TypeResolver.resolveFieldsFromDefinition(d),
         };
       }
@@ -94,19 +95,22 @@ export class Parser {
       .filter((t) => 'name' in t && t.name && !excludeRoots.includes(t.name.value))
       .map(Parser.documentDefinitionToSerializedNodeTree)
       .filter((d) => !!d) as ParserField[];
-    const comments: ParserField[] = Parser.findComments(schema).map(
-      (description) =>
-        ({
+    const comments: ParserField[] = Parser.findComments(schema).map((description) => ({
+      name: Helpers.Comment,
+      type: {
+        fieldType: {
           name: Helpers.Comment,
-          type: {
-            name: Helpers.Comment,
-          },
-          data: {
-            type: Helpers.Comment,
-          },
-          description,
-        } as ParserField),
-    );
+          type: Options.name,
+        },
+      },
+      args: [],
+      directives: [],
+      interfaces: [],
+      data: {
+        type: Helpers.Comment,
+      },
+      description,
+    }));
     const nodeTree: ParserTree = {
       nodes: [...comments, ...nodes],
     };
@@ -137,15 +141,9 @@ export class Parser {
       if (!extendedNode) {
         throw new Error(`Invalid extension node`);
       }
-      if (e.directives) {
-        extendedNode.directives = [...(extendedNode.directives || []), ...e.directives];
-      }
-      if (e.interfaces) {
-        extendedNode.interfaces = [...(extendedNode.interfaces || []), ...e.interfaces];
-      }
-      if (e.args) {
-        extendedNode.args = [...(extendedNode.args || []), ...e.args];
-      }
+      extendedNode.directives = [...(extendedNode.directives || []), ...e.directives];
+      extendedNode.interfaces = [...(extendedNode.interfaces || []), ...e.interfaces];
+      extendedNode.args = [...(extendedNode.args || []), ...e.args];
     });
 
     return { nodes };