Avoid wildcard for enum-based dynamic relationships.

Use the available enum values to create a more restrictive path query pattern.

Author: meistermeier

src/main/java/org/springframework/data/neo4j/core/mapping/CypherGenerator.java

@@ -23,6 +23,7 @@
 import static org.neo4j.cypherdsl.core.Cypher.parameter;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
@@ -532,7 +533,7 @@ private String[] collectFirstLevelRelationshipTypes(Collection<RelationshipDescr
 				continue;
 			}
 			if (relationshipDescription.isDynamic()) {
-				relationshipTypes.clear();
+				handleDynamicRelationship(relationshipTypes, (DefaultRelationshipDescription) relationshipDescription);
 				continue;
 			}
 			relationshipTypes.add(relationshipType);
@@ -546,7 +547,7 @@ private String[] collectAllRelationshipTypes(Collection<RelationshipDescription>
 		for (RelationshipDescription relationshipDescription : relationshipDescriptions) {
 			String relationshipType = relationshipDescription.getType();
 			if (relationshipDescription.isDynamic()) {
-				relationshipTypes.clear();
+				handleDynamicRelationship(relationshipTypes, (DefaultRelationshipDescription) relationshipDescription);
 				continue;
 			}
 			relationshipTypes.add(relationshipType);
@@ -555,6 +556,16 @@ private String[] collectAllRelationshipTypes(Collection<RelationshipDescription>
 		return relationshipTypes.toArray(new String[0]);
 	}
 
+	private void handleDynamicRelationship(Set<String> relationshipTypes, DefaultRelationshipDescription relationshipDescription) {
+		Class<?> componentType = relationshipDescription.getInverse().getComponentType();
+		if (componentType != null && componentType.isEnum()) {
+			Arrays.stream(componentType.getEnumConstants())
+					.forEach(constantName -> relationshipTypes.add(constantName.toString()));
+		} else {
+			relationshipTypes.clear();
+		}
+	}
+
 	private void collectAllRelationshipTypes(NodeDescription<?> nodeDescription, Set<String> relationshipTypes,
 											 Collection<RelationshipDescription> processedRelationshipDescriptions) {
 

src/test/java/org/springframework/data/neo4j/core/mapping/CypherGeneratorTest.java

@@ -20,8 +20,10 @@
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.when;
 
+import java.util.Collections;
 import java.util.Map;
 import java.util.Optional;
+import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
 import org.junit.Assert;
@@ -30,6 +32,7 @@
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Mockito;
+import org.neo4j.cypherdsl.core.Cypher;
 import org.neo4j.cypherdsl.core.Statement;
 import org.neo4j.cypherdsl.core.renderer.Renderer;
 import org.springframework.data.domain.Sort;
@@ -139,6 +142,44 @@ void shouldCreateRelationshipRemoveQueryWithoutUsingInternalIds() {
 		Assert.assertEquals(expectedQuery, Renderer.getDefaultRenderer().render(statement));
 	}
 
+	@Test
+	void shouldCreateDynamicRelationshipPathQueryForEnumsWithoutWildcardRelationships() {
+		Neo4jPersistentEntity<?> persistentEntity = new Neo4jMappingContext()
+				.getPersistentEntity(CyclicEntityWithEnumeratedDynamicRelationship1.class);
+
+		org.neo4j.cypherdsl.core.Node rootNode = Cypher.anyNode(Constants.NAME_OF_ROOT_NODE);
+		Statement statement = CypherGenerator.INSTANCE.createPathMatchWithCondition(null, persistentEntity,
+				Collections.emptyList(), null, rootNode).returning(rootNode).build();
+
+		// we want to ensure that the pattern occurs three times but do not care about the order
+		// of the relationship types
+		Pattern pattern = Pattern.compile(
+				"\\[:(`CORNERED`\\|`ROUND`|`ROUND`\\|`CORNERED`)\\*.*" +
+				"\\[:(`CORNERED`\\|`ROUND`|`ROUND`\\|`CORNERED`)\\*.*" +
+				"\\[:(`CORNERED`\\|`ROUND`|`ROUND`\\|`CORNERED`)\\*");
+
+		String renderedStatement = Renderer.getDefaultRenderer().render(statement);
+		assertThat(renderedStatement).containsPattern(pattern);
+	}
+
+	@Test
+	void shouldCreateDynamicRelationshipPathQueryForStringsWithWildcardRelationships() {
+		Neo4jPersistentEntity<?> persistentEntity = new Neo4jMappingContext()
+				.getPersistentEntity(CyclicEntityWithStringDynamicRelationship1.class);
+
+		org.neo4j.cypherdsl.core.Node rootNode = Cypher.anyNode(Constants.NAME_OF_ROOT_NODE);
+		Statement statement = CypherGenerator.INSTANCE.createPathMatchWithCondition(null, persistentEntity,
+				Collections.emptyList(), null, rootNode).returning(rootNode).build();
+
+		Pattern pattern = Pattern.compile(
+				"\\[\\*0\\.\\.1].*" +
+				"\\[\\*0\\.\\.1].*" +
+				"\\[\\*0\\.\\.].*");
+
+		String renderedStatement = Renderer.getDefaultRenderer().render(statement);
+		assertThat(renderedStatement).containsPattern(pattern);
+	}
+
 	private static Stream<Arguments> pageables() {
 		return Stream.of(
 				Arguments.of(Sort.by("a", "b").and(
@@ -219,4 +260,41 @@ private static class MultipleLabelEntity2 {
 		private Map<String, MultipleLabelEntity2> dynamicRelationships;
 	}
 
+	enum CyclicRelationship {
+		ROUND,
+		CORNERED
+	}
+
+	@Node
+	private static class CyclicEntityWithEnumeratedDynamicRelationship1 {
+
+		@Id private Long id;
+
+		private Map<CyclicRelationship, CyclicEntityWithEnumeratedDynamicRelationship2> dynamicRelationship;
+	}
+
+	@Node
+	private static class CyclicEntityWithEnumeratedDynamicRelationship2 {
+
+		@Id private Long id;
+
+		private Map<CyclicRelationship, CyclicEntityWithEnumeratedDynamicRelationship1> dynamicRelationship;
+	}
+
+	@Node
+	private static class CyclicEntityWithStringDynamicRelationship1 {
+
+		@Id private Long id;
+
+		private Map<String, CyclicEntityWithStringDynamicRelationship2> dynamicRelationship;
+	}
+
+	@Node
+	private static class CyclicEntityWithStringDynamicRelationship2 {
+
+		@Id private Long id;
+
+		private Map<String, CyclicEntityWithStringDynamicRelationship1> dynamicRelationship;
+	}
+
 }