How to set depth to 1 in Neo4j Spring Data - spring

Question

How can I set the depth/limit the number of hops in Spring Data?
I'm using Neo4j DB with SDN, and since I have a cycle I keep getting an infinite loop.
I'm trying to retrieve all my nodes with the related relationships and target nodes with a depth of 1 (only one hop) with the following query:
MATCH p = (u1:User)-[r]->(u2:User) WITH *, relationships(p) AS r RETURN u1, collect(r), collect(u2)
My model is as follow:
#Node
public class User {
#Id
#GeneratedValue
private Long id;
#Property
private String name;
#Relationship(type="RELATED")
private List<Relationship> relationship;
//constructor, getter and setters
}
#RelationshipProperties
public class Relationship{
#Id
#GeneratedValue
private Long id;
#Property
private String role;
#TargetNode
private User user;
//constructor, getter and setters
}
I understood that to set the depth to 1 I should add *1 to the relation as below:
MATCH (u1:User})-[r*1]->(u2:User) RETURN u1, collect(r), collect(u2)
Neo4J flag that solution (adding *n) as deprecated an I should operate with a path, so I wrote the following query:
MATCH p = (u1:User)-[r]->(u2:User) WITH *, relationships(p) AS r RETURN u1, collect(r), collect(u2)
The previous query seems to work as intended if I try to execute it in Neo4J Browser but if executed in Spring Data I get an infinite loop
This is the query in my repository
#Query("MATCH p = (u1:User)-[r]->(u2:User) WITH *, relationships(p) AS r RETURN u1, collect(r), collect(u2)")
Collection<User> getAllUser();
This are the dependencies I'm working with:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-neo4j</artifactId>
<version>2.6.1</version>
</dependency>
<dependency>
<groupId>org.neo4j</groupId>
<artifactId>neo4j-ogm-bolt-driver</artifactId>
<version>3.2.28</version>
</dependency>

Answer 1

Your assumption regarding the query is wrong.
I understood that to set the depth to 1 I should add *1 to the relation as below:
MATCH (u1:User})-[r*1]->(u2:User) RETURN u1, collect(r), collect(u2)
For MATCH (n)-[r]->(m) the r is exactly one relationship (like your query with *1. Downside of this query style is that every n (in your case the User) has to fulfill this pattern. If there is a User without a relationship, it won't get returned.
Because start and end of your relationship have the same label (User), you could use MATCH p = (u1:User)-[*0..1]->(:User) RETURN u1, collect(relationships(p)), collect(nodes(p))
Another approach, if you have multiple use cases demanding this reduced view, is to use projection:
interface UserWithDepthOne { // *
String getName();
List<RelationshipProjection> getRelationship();
interface RelationshipProjection {
String getRoles();
UserWithoutRelationship getUser();
interface UserWithoutRelationship {
String getName();
}
}
}
(*The projections don't have to be nested, here just for the overview)
And in your repository:
Collection<UserWithDepthOne> getAllUser();
More on projections can be found here.