✨ Added tree ops for directives

aexol · aexol · commit b53431140449 · 2023-01-27T16:35:46.000+01:00
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "graphql-js-tree",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "private": false,
   "license": "MIT",
   "description": "GraphQL Parser providing simplier structure",
diff --git a/src/TreeOperations/directive.ts b/src/TreeOperations/directive.ts
@@ -0,0 +1,97 @@
+import { Options, ParserField } from '@/Models';
+import { checkValueType } from '@/TreeOperations/tree';
+
+export const recursivelyDeleteDirectiveNodes = (nodes: ParserField[], directiveName: string) => {
+  nodes.forEach((n) => {
+    if (n.directives) {
+      n.directives = n.directives.filter((d) => d.name !== directiveName);
+    }
+    recursivelyDeleteDirectiveNodes(n.args, directiveName);
+  });
+};
+
+export const recursivelyRenameDirectiveNodes = (
+  nodes: ParserField[],
+  oldDirectiveName: string,
+  newDirectiveName: string,
+) => {
+  nodes.forEach((n) => {
+    if (n.directives) {
+      n.directives = n.directives.map((d) =>
+        d.name !== oldDirectiveName
+          ? d
+          : {
+              ...d,
+              name: newDirectiveName,
+              type: {
+                fieldType: {
+                  name: newDirectiveName,
+                  type: Options.name,
+                },
+              },
+            },
+      );
+    }
+    recursivelyRenameDirectiveNodes(n.args, oldDirectiveName, newDirectiveName);
+  });
+};
+
+export const recursivelyUpdateDirectiveArgument = (
+  nodes: ParserField[],
+  directiveName: string,
+  oldField: ParserField,
+  newField: ParserField,
+  allNodes: ParserField[],
+) => {
+  nodes.forEach((n) => {
+    if (n.directives.length > 0) {
+      const remappedDirectives = n.directives.map((d) => {
+        if (d.name !== directiveName) return d;
+        const remappedArgs = d.args.map((a) =>
+          a.name === oldField.name
+            ? {
+                ...a,
+                name: newField.name,
+                value: {
+                  value: a.value?.value,
+                  type: checkValueType(newField, allNodes),
+                },
+                type: {
+                  fieldType: {
+                    ...a.type.fieldType,
+                    name: newField.name,
+                  },
+                },
+              }
+            : a,
+        );
+        return {
+          ...d,
+          args: remappedArgs,
+        };
+      });
+      n.directives = remappedDirectives;
+    }
+    recursivelyUpdateDirectiveArgument(n.args, directiveName, oldField, newField, allNodes);
+  });
+};
+
+export const recursivelyDeleteDirectiveArgument = (
+  nodes: ParserField[],
+  directiveName: string,
+  argumentField: ParserField,
+) => {
+  nodes.forEach((n) => {
+    if (n.directives) {
+      n.directives = n.directives.map((d) =>
+        d.name !== directiveName
+          ? d
+          : {
+              ...d,
+              args: d.args.filter((a) => a.name !== argumentField.name),
+            },
+      );
+    }
+    recursivelyDeleteDirectiveArgument(n.args, directiveName, argumentField);
+  });
+};
diff --git a/src/TreeOperations/tree.ts b/src/TreeOperations/tree.ts
@@ -10,6 +10,12 @@ import {
   ValueDefinition,
 } from '@/Models';
 import { getTypeName } from '@/shared';
+import {
+  recursivelyDeleteDirectiveArgument,
+  recursivelyDeleteDirectiveNodes,
+  recursivelyRenameDirectiveNodes,
+  recursivelyUpdateDirectiveArgument,
+} from '@/TreeOperations/directive';
 import {
   changeInterfaceField,
   updateInterfaceNodeAddField,
@@ -59,6 +65,10 @@ export const mutate = (tree: ParserTree, allNodes: ParserField[]) => {
 
   const updateFieldOnNode = (node: ParserField, i: number, updatedField: ParserField) => {
     regenerateId(updatedField);
+    if (node.data.type === TypeSystemDefinition.DirectiveDefinition) {
+      const oldField: ParserField = JSON.parse(JSON.stringify(node.args[i]));
+      recursivelyUpdateDirectiveArgument(allNodes, node.name, oldField, updatedField, allNodes);
+    }
     if (node.data.type === TypeDefinition.InterfaceTypeDefinition) {
       const oldField: ParserField = JSON.parse(JSON.stringify(node.args[i]));
       changeInterfaceField(tree.nodes, node, oldField, updatedField);
@@ -81,6 +91,9 @@ export const mutate = (tree: ParserTree, allNodes: ParserField[]) => {
     if (isError) {
       return;
     }
+    if (node.data.type === TypeSystemDefinition.DirectiveDefinition) {
+      recursivelyRenameDirectiveNodes(allNodes, node.name, newName);
+    }
     if (node.data.type === TypeDefinition.InterfaceTypeDefinition) {
       const oldName = node.name;
       tree.nodes
@@ -121,6 +134,9 @@ export const mutate = (tree: ParserTree, allNodes: ParserField[]) => {
     if (node.data.type === ValueDefinition.InputValueDefinition) {
       const parent = allNodes.find((parentNode) => parentNode.args.includes(node));
       if (parent) {
+        if (parent.data.type === TypeSystemDefinition.DirectiveDefinition) {
+          recursivelyDeleteDirectiveArgument(allNodes, parent.name, node);
+        }
         const index = parent.args.indexOf(node);
         deleteFieldFromNode(parent, index);
       } else {
@@ -142,10 +158,13 @@ export const mutate = (tree: ParserTree, allNodes: ParserField[]) => {
       return;
     }
     if (node.data.type === Instances.Directive) {
-      throw new Error('Directives should be removed on node directly not using this function');
+      throw new Error('Directive Instances should be removed on node directly not using this function');
     }
     if (node.data.type === Instances.Argument) {
-      throw new Error('Directive Arguments should be removed on node directly not using this function');
+      throw new Error('Directive Instance Arguments should be removed on node directly not using this function');
+    }
+    if (node.data.type === TypeSystemDefinition.DirectiveDefinition) {
+      recursivelyDeleteDirectiveNodes(allNodes, node.name);
     }
     const deletedNode = tree.nodes.findIndex((n) => n === node);
     if (deletedNode === -1) throw new Error('Error deleting a node');
@@ -224,7 +243,7 @@ export const mutate = (tree: ParserTree, allNodes: ParserField[]) => {
   };
 };
 
-const checkValueType = (node: ParserField, nodes: ParserField[]) => {
+export const checkValueType = (node: ParserField, nodes: ParserField[]) => {
   const isArray = isArrayType(node.type.fieldType);
   if (isArray) return Value.ListValue;
   const tName = getTypeName(node.type.fieldType);
diff --git a/src/__tests__/TreeOperations/tree.remove.spec.ts b/src/__tests__/TreeOperations/tree.remove.spec.ts
@@ -19,6 +19,13 @@ describe('Tree Operations - node removal tests', () => {
     expect(treeMock.nodes[0].interfaces).not.toContainEqual('Node');
     expect(treeMock.nodes[0].args).not.toContainEqual(copyOfArg);
   });
+  test('Delete directive node from tree', () => {
+    const treeMock = createMock();
+    const directiveNode = JSON.parse(JSON.stringify(treeMock.nodes[5]));
+    mutate(treeMock, treeMock.nodes).removeNode(treeMock.nodes[5]);
+    expect(treeMock.nodes).not.toContainEqual(directiveNode);
+    expect(treeMock.nodes[0].directives).toHaveLength(0);
+  });
   test('Delete field from root node', () => {
     const treeMock = createMock();
     const oldPersonNodeId = treeMock.nodes[0].id;
@@ -68,4 +75,11 @@ describe('Tree Operations - node removal tests', () => {
     mutate(treeMock, treeMock.nodes).removeNode(treeMock.nodes[3].args[0]);
     expect(treeMock.nodes[3].args).not.toContainEqual(oldArgument);
   });
+  test('Delete directive field from directive definition node', () => {
+    const treeMock = createMock();
+    const oldArgument = JSON.parse(JSON.stringify(treeMock.nodes[5].args[0]));
+    mutate(treeMock, treeMock.nodes).removeNode(treeMock.nodes[5].args[0]);
+    expect(treeMock.nodes[5].args).not.toContainEqual(oldArgument);
+    expect(treeMock.nodes[0].directives[0].args).toHaveLength(0);
+  });
 });
diff --git a/src/__tests__/TreeOperations/tree.rename.spec.ts b/src/__tests__/TreeOperations/tree.rename.spec.ts
@@ -1,3 +1,4 @@
+import { Options, ParserField, ScalarTypes, Value } from '@/Models';
 import { createParserField, getTypeName } from '@/shared';
 import { mutate } from '@/TreeOperations/tree';
 import { createMock, createInterfaceMock } from '@/__tests__/TreeOperations/mocks';
@@ -19,6 +20,15 @@ describe('Tree Operations tests - rename operations', () => {
     expect(treeMock.nodes[1].interfaces).toContainEqual('Alien');
     expect(treeMock.nodes[1].args[0].fromInterface).toContainEqual('Alien');
   });
+  test(`Change directive node name`, () => {
+    const treeMock = createMock();
+    const oldDirectiveNodeId = treeMock.nodes[5].id;
+    mutate(treeMock, treeMock.nodes).renameRootNode(treeMock.nodes[5], 'alien');
+    expect(treeMock.nodes[5].id).not.toEqual(oldDirectiveNodeId);
+    expect(treeMock.nodes[5].name).toEqual('alien');
+    expect(getTypeName(treeMock.nodes[0].directives[0].type.fieldType)).toEqual('alien');
+    expect(treeMock.nodes[0].directives[0].name).toEqual('alien');
+  });
   test('Update field name on field node', () => {
     const treeMock = createMock();
     const oldPersonNodeId = treeMock.nodes[0].id;
@@ -47,6 +57,39 @@ describe('Tree Operations tests - rename operations', () => {
       fromInterface: [treeMock.nodes[0].name],
     });
   });
+  test('Update field name on directive definition', () => {
+    const treeMock = createMock();
+    const updatedField = createParserField({
+      ...treeMock.nodes[5].args[0],
+      name: 'firstName',
+      type: {
+        fieldType: {
+          type: Options.name,
+          name: ScalarTypes.String,
+        },
+      },
+    });
+    const argumentCopy = JSON.parse(JSON.stringify(treeMock.nodes[0].directives[0].args[0])) as ParserField;
+
+    mutate(treeMock, treeMock.nodes).updateFieldOnNode(treeMock.nodes[5], 0, updatedField);
+    expect(treeMock.nodes[5].args).toContainEqual({
+      ...updatedField,
+    });
+    expect(treeMock.nodes[0].directives[0].args).toContainEqual({
+      ...argumentCopy,
+      name: 'firstName',
+      value: {
+        type: Value.StringValue,
+        value: argumentCopy.value?.value,
+      },
+      type: {
+        fieldType: {
+          name: 'firstName',
+          type: Options.name,
+        },
+      },
+    });
+  });
   test('Update input value name on input value node', () => {
     const treeMock = createMock();
     const oldQueryId = treeMock.nodes[1].id;

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "graphql-js-tree",`
`3`		`- "version": "0.2.7",`
	`3`	`+ "version": "0.2.8",`
`4`	`4`	`"private": false,`
`5`	`5`	`"license": "MIT",`
`6`	`6`	`"description": "GraphQL Parser providing simplier structure",`