6981 update of relationship properties via set operation does not work in update mutations (#6986)

* test for 6981

* fix set hardcoded on node

* improve test expect for list in different order

* add changeset

* fix includesamemembers on wrong level in jest expect

* added wrapper over toIncludeSameMembers, hopefully the expect passes now..

---------

Co-authored-by: angrykoala <angrykoala@outlook.es>

Author: a-alle

.changeset/afraid-mugs-cheer.md

@@ -0,0 +1,5 @@
+---
+"@neo4j/graphql": patch
+---
+
+Fix set properties always targeting nodes

packages/graphql/src/translate/queryAST/factory/Operations/UpdateFactory.ts

@@ -667,7 +667,7 @@ export class UpdateFactory {
         switch (operator) {
             case "set":
                 return new ParamInputField({
-                    attachedTo: "node",
+                    attachedTo,
                     attribute,
                     inputValue: value,
                 });

packages/graphql/tests/integration/issues/6981.int.test.ts

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { UniqueType } from "../../utils/graphql-types";
+import { TestHelper } from "../../utils/tests-helper";
+
+describe("https://github.com/neo4j/graphql/issues/6981", () => {
+    let TypeCodePlaceholder: UniqueType;
+    let TypeCodeValue: UniqueType;
+
+    const testHelper = new TestHelper();
+
+    beforeAll(async () => {
+        TypeCodePlaceholder = testHelper.createUniqueType("TypeCodePlaceholder");
+        TypeCodeValue = testHelper.createUniqueType("TypeCodeValue");
+
+        const typeDefs = /* GraphQL */ `
+            type ${TypeCodePlaceholder} @mutation(operations: [CREATE, UPDATE, DELETE]) @node @subscription(events: []) {
+                id: String!
+                values: [${TypeCodeValue}!]!
+                    @relationship(
+                        type: "TYPECODEPLACEHOLDER_HAS_TYPECODEVALUE"
+                        properties: "TypecodeplaceholderHasTypecodevalueProperties"
+                        direction: OUT
+                        nestedOperations: [CREATE, UPDATE, DELETE, CONNECT, DISCONNECT]
+                        queryDirection: DIRECTED
+                    )
+                    @settable(onCreate: true, onUpdate: true)
+            }
+
+            type ${TypeCodeValue} @mutation(operations: [CREATE, UPDATE, DELETE]) @node @subscription(events: []) {
+                id: String!
+            }
+
+            type TypecodeplaceholderHasTypecodevalueProperties @relationshipProperties {
+                order: Int!
+            }
+        `;
+
+        await testHelper.initNeo4jGraphQL({
+            typeDefs,
+        });
+
+        await testHelper.executeCypher(`
+            CREATE (tcp:${TypeCodePlaceholder} {id: "A"})
+            CREATE (tcp)-[:TYPECODEPLACEHOLDER_HAS_TYPECODEVALUE {order: 1}]->(:${TypeCodeValue} {id: "B"})
+            CREATE (tcp)-[:TYPECODEPLACEHOLDER_HAS_TYPECODEVALUE {order: 2}]->(:${TypeCodeValue} {id: "C"})
+
+        `);
+    });
+
+    afterAll(async () => {
+        await testHelper.close();
+    });
+
+    test("should match 1 edge by node filter, aggregate count 1", async () => {
+        const query = /* GraphQL */ `
+            mutation {
+                ${TypeCodePlaceholder.operations.update}(
+                    where: { id: { eq: "A" } }
+                    update: {
+                        values: [
+                            { update: { where: { node: { id: { eq: "B" } } }, edge: { order: { set: 2 } } } }
+                            { update: { where: { node: { id: { eq: "C" } } }, edge: { order: { set: 1 } } } }
+                        ]
+                    }
+                ) {
+                    ${TypeCodePlaceholder.plural} {
+                        valuesConnection {
+                            edges {
+                                properties {
+                                    order
+                                }
+                                node {
+                                    id
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+
+        const result = await testHelper.executeGraphQL(query);
+        expect(result.errors).toBeUndefined();
+
+        expect(result.data).toEqual({
+            [TypeCodePlaceholder.operations.update]: {
+                [TypeCodePlaceholder.plural]: [
+                    {
+                        valuesConnection: {
+                            edges: expect.toIncludeSameMembers([
+                                {
+                                    properties: {
+                                        order: 2,
+                                    },
+                                    node: {
+                                        id: "B",
+                                    },
+                                },
+                                {
+                                    properties: {
+                                        order: 1,
+                                    },
+                                    node: {
+                                        id: "C",
+                                    },
+                                },
+                            ]),
+                        },
+                    },
+                ],
+            },
+        });
+
+        await testHelper.expectRelationship(TypeCodePlaceholder, TypeCodeValue).toIncludeSameMembers([
+            {
+                from: {
+                    id: "A",
+                },
+                relationship: {
+                    order: 2,
+                },
+                to: {
+                    id: "B",
+                },
+            },
+            {
+                from: {
+                    id: "A",
+                },
+                relationship: {
+                    order: 1,
+                },
+                to: {
+                    id: "C",
+                },
+            },
+        ]);
+    });
+});

packages/graphql/tests/utils/neo-expect/expect-relationship.ts

@@ -56,6 +56,18 @@ export class NeoExpectRelationship extends NeoExpect {
         }
     }
 
+    /** Use this if expectation is a list an elements order does not matter */
+    public async toIncludeSameMembers(expectation: any[]): Promise<void> {
+        const result = await this.getAll();
+        try {
+            expect(result).toIncludeSameMembers(expectation);
+        } catch (err: any) {
+            const typeStr = this.type ? `[${this.type}]` : "-";
+            err.message = `Error on ${this.from} ${typeStr} ${this.to}\n\n ${err.message}`;
+            throw err;
+        }
+    }
+
     public async count(expected: number): Promise<void> {
         const count = await this.getCount();
         if (count !== expected) {