Update by aggregation doesn't work

[MacondoExpress]

Describe the bug
Update by aggregation doesn't work as expected.

Type definitions

    type User {
        name: String!
        likedPosts: [Post!]! @relationship(type: "LIKES", direction: OUT, properties: "likeProperties")
    }

    type Post {
        id: ID
        content: String!
        likes: [User!]! @relationship(type: "LIKES", direction: IN, properties: "likeProperties")
    }
    
    interface likeProperties{
        likedAt: DateTime
    }

To Reproduce

Dataset:

CREATE (u:User {name: "username"})
CREATE (u2:User {name: "username2"})
CREATE (u3:User {name: "username3"})
CREATE (u4:User {name: "username4"})
CREATE (u)-[:LIKES]->(p:Post {id: "postID1"})
CREATE (u2)-[:LIKES]->(p2:Post {id: "postID2"})
CREATE (u3)-[:LIKES]->(p2)
CREATE (p3:Post {id: "postID3"})
CREATE (u2)-[:LIKES]->(p3)
CREATE (u3)-[:LIKES]->(p3)
CREATE (p4:Post {id: "postID4"})
CREATE (u2)-[:LIKES]->(p4)
CREATE (u3)-[:LIKES]->(p4)
CREATE (u4)-[:LIKES]->(p4)
CREATE (p5:Post {id: "postID5"})
CREATE (u2)-[:LIKES]->(p5)
CREATE (u3)-[:LIKES]->(p5)
CREATE (u4)-[:LIKES]->(p5)
CREATE (p6:Post {id: "postID6"})
CREATE (u2)-[:LIKES]->(p6)
CREATE (u3)-[:LIKES]->(p6)
CREATE (u4)-[:LIKES]->(p6)

mutation:

mutation {
    updateUsers (
        update: {
            likedPosts: {
                connect: {
                    where: {
                        node: {
                            likesAggregate: {
                                count_LTE: 2
                            }
                        }
                    }
                }
            }
    }) {
        users  {
            name
            likedPosts {
                id
            }
        }
    }
}

produces:

{
  "data": {
    "updateUsers": {
      "users": [
        {
          "name": "username",
          "likedPosts": [
            {
              "id": "postID2"
            },
            {
              "id": "postID3"
            },
            {
              "id": "postID1"
            }
          ]
        },
        {
          "name": "username2",
          "likedPosts": [
            {
              "id": "postID1"
            },
            {
              "id": "postID2"
            },
            {
              "id": "postID6"
            },
            {
              "id": "postID5"
            },
            {
              "id": "postID4"
            },
            {
              "id": "postID3"
            }
          ]
        },
        {
          "name": "username3",
          "likedPosts": [
            {
              "id": "postID1"
            },
            {
              "id": "postID2"
            },
            {
              "id": "postID6"
            },
            {
              "id": "postID5"
            },
            {
              "id": "postID4"
            },
            {
              "id": "postID3"
            }
          ]
        },
        {
          "name": "username4",
          "likedPosts": [
            {
              "id": "postID6"
            },
            {
              "id": "postID5"
            },
            {
              "id": "postID4"
            }
          ]
        }
      ]
    }
  }
}

Expected behavior

the initial dataset could be represented as:

postID1 HAS 1 likes FROM [username1]
postID2 HAS 2 likes FROM [username2, username3]
postID3 HAS 2 likes FROM [username2, username3]
postID4 HAS 3 likes FROM [username2, username3, username4]
postID5 HAS 3 likes FROM [username2, username3, username4]
postID6 HAS 3 likes FROM [username2, username3, username4]

or visually:

graph TD;
    username1-->postID1;

    username2-->postID2;
    username2-->postID3;
    username2-->postID4;
    username2-->postID5;
    username2-->postID6;
    
    username3-->postID2;
    username3-->postID3;
    username3-->postID4;
    username3-->postID5;
    username3-->postID6;
    
    username4-->postID4;
    username4-->postID5;
    username4-->postID6;

Loading

The mutation should connect all the users with posts with less than or equal two like, this means that the username4 should be connected to all the Posts not only postID4, postID5, postID6.

[neo4j-team-graphql]

Many thanks for raising this bug report @MacondoExpress. 🐛 We will now attempt to reproduce the bug based on the steps you have provided.

Please ensure that you've provided the necessary information for a minimal reproduction, including but not limited to:

• Type definitions
• Resolvers
• Query and/or Mutation (or multiple) needed to reproduce

If you have a support agreement with Neo4j, please link this GitHub issue to a new or existing Zendesk ticket.

Thanks again! 🙏

[neo4j-team-graphql]

Many thanks for raising this bug report @MacondoExpress. 🐛 We will now attempt to reproduce the bug based on the steps you have provided.

Please ensure that you've provided the necessary information for a minimal reproduction, including but not limited to:

• Type definitions
• Resolvers
• Query and/or Mutation (or multiple) needed to reproduce

If you have a support agreement with Neo4j, please link this GitHub issue to a new or existing Zendesk ticket.

Thanks again! 🙏

[neo4j-team-graphql]

We've been able to confirm this bug using the steps to reproduce that you provided - many thanks @MacondoExpress! 🙏 We will now prioritise the bug and address it appropriately.

[mjfwebb]

Confirmed still a bug in version 6.1.0

[angrykoala]

This is still happening in 7.0 alpha with the following setup:

    type Movie @node {
        title: String!
        actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, properties: "ActedIn")
    }



    type ActedIn @relationshipProperties {
        screenTime: Int
    }

    type Actor @node {
        name: String!
        movies: [Movie!]! @relationship(type: "ACTED_IN", direction: OUT, properties: "ActedIn")
    }

mutation {
  updateActors(
    where: {name: {eq: "Keanu"}}
    update: {
      movies: {
        connect: {
          where: {
            node: {
              actorsConnection: { aggregate: { count: { nodes: { eq: 2 } } } }
            }
          }
        }
      }
    }
  ) {
    actors {
      name
      movies {
        title
      }
    }
    info {
      nodesCreated
      nodesDeleted
      relationshipsCreated
      relationshipsDeleted
    }
  }
}

CREATE(a:Actor {name: "Keanu"})-[:ACTED_IN {screenTime: 10}]->(m:Movie {title: "The Matrix"})
CREATE(a2:Actor {name: "Arthur"})-[:ACTED_IN {screenTime: 10}]->(:Movie {title: "Movie1"})
CREATE(a2)-[:ACTED_IN {screenTime: 10}]->(:Movie {title: "Movie2"})

Expected: A connection is created
No connection is created

[MacondoExpress]

@angrykoala I confirmed the issue again on 7.x, however, in the new reproduction steps you proposed, I think there is a flaw as there are no movies with two actors in your dataset.

[MacondoExpress]

Here is other reproduction steps with type definitions that are compatible with version 7:

type User @node {
  name: String!
  likedPosts: [Post!]!
    @relationship(type: "LIKES", direction: OUT, properties: "likeProperties")
}

type Post @node {
  id: ID
  content: String!
  likes: [User!]!
    @relationship(type: "LIKES", direction: IN, properties: "likeProperties")
}

type likeProperties @relationshipProperties {
  likedAt: DateTime
}

In a instance that contains:

CREATE (u:User {name: "username"})
CREATE (u2:User {name: "username2"})
CREATE (u3:User {name: "username3"})
CREATE (u4:User {name: "username4"})
CREATE (u)-[:LIKES]->(p:Post {id: "postID1"})
CREATE (u2)-[:LIKES]->(p2:Post {id: "postID2"})
CREATE (p3:Post {id: "postID3"})
CREATE (u2)-[:LIKES]->(p3)
CREATE (u3)-[:LIKES]->(p3)

The following GraphQL mutation:

mutation {
  updateUsers(
    update: {
      likedPosts: {
        connect: {
          where: {
            node: {
              likesConnection: { aggregate: { count: { nodes: { lte: 2 } } } }
            }
          }
        }
      }
    }
  ) {
    users {
      name
      likedPosts {
        id
      }
    }
  }
}

Produces:

{
  "data": {
    "updateUsers": {
      "users": [
        {
          "name": "username",
          "likedPosts": [
            {
              "id": "postID2"
            },
            {
              "id": "postID3"
            },
            {
              "id": "postID1"
            }
          ]
        },
        {
          "name": "username2",
          "likedPosts": [
            {
              "id": "postID1"
            },
            {
              "id": "postID2"
            },
            {
              "id": "postID3"
            }
          ]
        },
        {
          "name": "username3",
          "likedPosts": [
            {
              "id": "postID1"
            },
            {
              "id": "postID2"
            },
            {
              "id": "postID3"
            }
          ]
        },
        {
          "name": "username4",
          "likedPosts": []
        }
      ]
    }
  }
}

As visible, the User with "username4" is not connected with any of the posts even if, in the initial state, there are no posts with more than two likes.
This is because by the time the "username4" is processed all the other "posts" have more than two likes.
By changing the order in which the data is stored, is possible to see different results, for instance, by creating the user "username4" first, as:

CREATE (u4:User {name: "username4"})
CREATE (u:User {name: "username"})
CREATE (u2:User {name: "username2"})
CREATE (u3:User {name: "username3"})
CREATE (u)-[:LIKES]->(p:Post {id: "postID1"})
CREATE (u2)-[:LIKES]->(p2:Post {id: "postID2"})
CREATE (p3:Post {id: "postID3"})
CREATE (u2)-[:LIKES]->(p3)
CREATE (u3)-[:LIKES]->(p3)

Then the response will look different:

{
  "data": {
    "updateUsers": {
      "users": [
        {
          "name": "username4",
          "likedPosts": [
            {
              "id": "postID3"
            },
            {
              "id": "postID2"
            },
            {
              "id": "postID1"
            }
          ]
        },
        {
          "name": "username",
          "likedPosts": [
            {
              "id": "postID2"
            },
            {
              "id": "postID1"
            }
          ]
        },
        {
          "name": "username2",
          "likedPosts": [
            {
              "id": "postID1"
            },
            {
              "id": "postID2"
            },
            {
              "id": "postID3"
            }
          ]
        },
        {
          "name": "username3",
          "likedPosts": [
            {
              "id": "postID3"
            }
          ]
        }
      ]
    }
  }
}