Remove deprecated directed argument

.changeset/healthy-swans-shave.md

@@ -0,0 +1,5 @@
+---
+"@neo4j/graphql": major
+---
+
+The deprecated `directed` argument has been removed, and `queryDirection` now only accepts two possible values - `DIRECTED` (default) and `UNDIRECTED`.

packages/graphql/src/constants.ts

@@ -73,10 +73,6 @@ export const LOGICAL_OPERATORS = ["AND", "OR", "NOT"] as const;
 export const AGGREGATION_COMPARISON_OPERATORS = ["EQUAL", "GT", "GTE", "LT", "LTE"] as const;
 
 export enum RelationshipQueryDirectionOption {
-    DEFAULT_DIRECTED = "DEFAULT_DIRECTED",
-    DEFAULT_UNDIRECTED = "DEFAULT_UNDIRECTED",
-    DIRECTED_ONLY = "DIRECTED_ONLY",
-    UNDIRECTED_ONLY = "UNDIRECTED_ONLY",
     DIRECTED = "DIRECTED",
     UNDIRECTED = "UNDIRECTED",
 }

packages/graphql/src/graphql/directives/arguments/enums/RelationshipQueryDirection.ts

@@ -23,20 +23,6 @@ import { RelationshipQueryDirectionOption } from "../../../../constants";
 export const RelationshipQueryDirectionEnum = new GraphQLEnumType({
     name: "RelationshipQueryDirection",
     values: {
-        [RelationshipQueryDirectionOption.DEFAULT_DIRECTED]: {
-            deprecationReason:
-                "DEFAULT_DIRECTED is deprecated without alternative and it will be removed in future versions, this is following the deprecation of the generated `directed` argument",
-        },
-        [RelationshipQueryDirectionOption.DEFAULT_UNDIRECTED]: {
-            deprecationReason:
-                "DEFAULT_UNDIRECTED is deprecated without alternative and it will be removed in future versions, this is following the deprecation of the generated `directed` argument",
-        },
-        [RelationshipQueryDirectionOption.DIRECTED_ONLY]: {
-            deprecationReason: "DIRECTED_ONLY is deprecated, please use DIRECTED.",
-        },
-        [RelationshipQueryDirectionOption.UNDIRECTED_ONLY]: {
-            deprecationReason: "UNDIRECTED_ONLY is deprecated, please use UNDIRECTED.",
-        },
         [RelationshipQueryDirectionOption.DIRECTED]: {},
         [RelationshipQueryDirectionOption.UNDIRECTED]: {},
     },

packages/graphql/src/graphql/directives/relationship.ts

@@ -50,8 +50,8 @@ export const relationshipDirective = new GraphQLDirective({
         },
         queryDirection: {
             type: RelationshipQueryDirectionEnum,
-            defaultValue: RelationshipQueryDirectionOption.DEFAULT_DIRECTED,
-            description: "Valid and default directions for this relationship.",
+            defaultValue: RelationshipQueryDirectionOption.DIRECTED,
+            description: "Directions to query this relationship.",
         },
         direction: {
             type: new GraphQLNonNull(RelationshipDirectionEnum),

packages/graphql/src/schema-model/generate-model.test.ts

@@ -393,7 +393,7 @@ describe("Relationship", () => {
         expect(accounts).toBeDefined();
         expect(accounts?.type).toBe("HAS_ACCOUNT");
         expect(accounts?.direction).toBe("OUT");
-        expect(accounts?.queryDirection).toBe("DEFAULT_DIRECTED");
+        expect(accounts?.queryDirection).toBe("DIRECTED");
         expect(accounts?.nestedOperations).toEqual([
             "CREATE",
             "UPDATE",
@@ -427,7 +427,7 @@ describe("Relationship", () => {
         expect(actors).toBeDefined();
         expect(actors?.type).toBe("STARED_IN");
         expect(actors?.direction).toBe("OUT");
-        expect(actors?.queryDirection).toBe("DEFAULT_DIRECTED");
+        expect(actors?.queryDirection).toBe("DIRECTED");
         expect(actors?.nestedOperations).toEqual([
             "CREATE",
             "UPDATE",

packages/graphql/src/schema-model/relationship/Relationship.ts

@@ -26,10 +26,10 @@ import type { Attribute } from "../attribute/Attribute";
 import type { Entity } from "../entity/Entity";
 
 export type RelationshipDirection = "IN" | "OUT";
+// "DIRECTED" | "UNDIRECTED";
 export type QueryDirection = keyof typeof RelationshipQueryDirectionOption;
-// "DEFAULT_DIRECTED" | "DEFAULT_UNDIRECTED" | "DIRECTED_ONLY" | "UNDIRECTED_ONLY" | "DIRECTED" | "UNDIRECTED";
-export type NestedOperation = keyof typeof RelationshipNestedOperationsOption;
 // "CREATE" | "UPDATE" | "DELETE" | "CONNECT" | "DISCONNECT" | "CONNECT_OR_CREATE";
+export type NestedOperation = keyof typeof RelationshipNestedOperationsOption;
 
 export class Relationship {
     public readonly name: string; // name of the relationship field, e.g. friends

packages/graphql/src/schema-model/relationship/model-adapters/RelationshipAdapter.test.ts

@@ -88,7 +88,7 @@ describe("RelationshipAdapter", () => {
             direction: "OUT",
             isList: Boolean(false),
             attributes: [accountAlias],
-            queryDirection: "DEFAULT_DIRECTED",
+            queryDirection: "DIRECTED",
             nestedOperations: ["CREATE", "UPDATE", "DELETE", "CONNECT", "DISCONNECT", "CONNECT_OR_CREATE"],
             aggregate: false,
             description: "",

packages/graphql/src/schema-model/relationship/model-adapters/RelationshipAdapter.ts

@@ -156,8 +156,8 @@ export class RelationshipAdapter {
      * @param directed the direction asked during the query, for instance "friends(directed: true)"
      * @returns the direction to use in the CypherBuilder
      **/
-    public getCypherDirection(directed?: boolean): "left" | "right" | "undirected" {
-        if (directed === false || this.queryDirection === "UNDIRECTED_ONLY" || this.queryDirection === "UNDIRECTED") {
+    public getCypherDirection(): "left" | "right" | "undirected" {
+        if (this.queryDirection === "UNDIRECTED") {
             return "undirected";
         }
         return this.cypherDirectionFromRelDirection();

packages/graphql/src/schema/create-relationship-fields/create-relationship-fields.ts

@@ -29,7 +29,6 @@ import { RelationshipAdapter } from "../../schema-model/relationship/model-adapt
 import { RelationshipDeclarationAdapter } from "../../schema-model/relationship/model-adapters/RelationshipDeclarationAdapter";
 import type { Neo4jFeaturesSettings } from "../../types";
 import { FieldAggregationComposer } from "../aggregations/field-aggregation-composer";
-import { addDirectedArgument } from "../directed-argument";
 import {
     augmentObjectOrInterfaceTypeWithConnectionField,
     augmentObjectOrInterfaceTypeWithRelationshipField,
@@ -264,13 +263,11 @@ export function createRelationshipFields({
                 where: relationshipTarget.operations.whereInputTypeName,
             };
 
-            const aggregationFieldsArgs = addDirectedArgument(aggregationFieldsBaseArgs, relationshipAdapter, features);
-
             if (relationshipAdapter.aggregate) {
                 composeNode.addFields({
                     [relationshipAdapter.operations.aggregateTypeName]: {
                         type: aggregationTypeObject,
-                        args: aggregationFieldsArgs,
+                        args: aggregationFieldsBaseArgs,
                         directives: deprecatedDirectives,
                     },
                 });