GH-2164 - Treat id properties correctly in derived finder methods.

This closes #2164.

Author: michael-simons

src/main/java/org/springframework/data/neo4j/repository/query/CypherQueryCreator.java

@@ -15,6 +15,23 @@
  */
 package org.springframework.data.neo4j.repository.query;
 
+import static org.neo4j.cypherdsl.core.Functions.point;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 import org.neo4j.cypherdsl.core.Condition;
 import org.neo4j.cypherdsl.core.Conditions;
 import org.neo4j.cypherdsl.core.Cypher;
@@ -51,23 +68,6 @@
 import org.springframework.lang.NonNull;
 import org.springframework.lang.Nullable;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Queue;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import java.util.function.UnaryOperator;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static org.neo4j.cypherdsl.core.Functions.point;
-
 /**
  * A Cypher-DSL based implementation of the {@link AbstractQueryCreator} that eventually creates Cypher queries as
  * strings to be used by a Neo4j client or driver as statement template.
@@ -534,7 +534,9 @@ private Expression toCypherProperty(PersistentPropertyPath<Neo4jPersistentProper
 		Expression expression;
 
 		if (owner.equals(this.nodeDescription) && path.getLength() == 1) {
-			expression = Cypher.property(Constants.NAME_OF_ROOT_NODE, leafProperty.getPropertyName());
+			expression = leafProperty.isInternalIdProperty() ?
+					Cypher.call("id").withArgs(Constants.NAME_OF_ROOT_NODE).asFunction() :
+					Cypher.property(Constants.NAME_OF_ROOT_NODE, leafProperty.getPropertyName());
 		} else {
 			PropertyPathWrapper propertyPathWrapper = propertyPathWrappers.stream()
 					.filter(rp -> rp.getPropertyPath().equals(path)).findFirst().get();
@@ -545,7 +547,11 @@ private Expression toCypherProperty(PersistentPropertyPath<Neo4jPersistentProper
 			} else {
 				cypherElementName = propertyPathWrapper.getNodeName();
 			}
-			expression = Cypher.property(cypherElementName, leafProperty.getPropertyName());
+			if (leafProperty.isInternalIdProperty()) {
+				expression = Cypher.call("id").withArgs(Cypher.name(cypherElementName)).asFunction();
+			} else {
+				expression = Cypher.property(cypherElementName, leafProperty.getPropertyName());
+			}
 		}
 
 		if (addToLower) {

src/test/java/org/springframework/data/neo4j/integration/imperative/ProjectionIT.java

@@ -20,10 +20,12 @@
 import java.util.AbstractMap;
 import java.util.Collection;
 import java.util.Map;
+import java.util.Optional;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.neo4j.driver.Driver;
+import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.Values;
@@ -40,6 +42,7 @@
 import org.springframework.data.neo4j.integration.shared.common.NamesOnlyDto;
 import org.springframework.data.neo4j.integration.shared.common.Person;
 import org.springframework.data.neo4j.integration.shared.common.PersonSummary;
+import org.springframework.data.neo4j.integration.shared.common.ProjectionTestRoot;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
 import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;
 import org.springframework.data.neo4j.test.Neo4jExtension;
@@ -61,6 +64,8 @@ class ProjectionIT {
 	private static Neo4jExtension.Neo4jConnectionSupport neo4jConnectionSupport;
 
 	private final Driver driver;
+	private Long projectionTestRootId;
+	private Long projectionTestLevel1Id;
 
 	@Autowired
 	ProjectionIT(Driver driver) {
@@ -69,24 +74,39 @@ class ProjectionIT {
 
 	@BeforeEach
 	void setup() {
-		Session session = driver.session();
-		Transaction transaction = session.beginTransaction();
-
-		transaction.run("MATCH (n) detach delete n");
-
-		for (Map.Entry<String, String> person : new Map.Entry[] {
-				new AbstractMap.SimpleEntry(FIRST_NAME, LAST_NAME),
-				new AbstractMap.SimpleEntry(FIRST_NAME2, LAST_NAME),
-		}) {
-			transaction.run(" MERGE (address:Address{city: $city})"
-							+ "CREATE (:Person{firstName: $firstName, lastName: $lastName})"
-							+ "-[:LIVES_AT]-> (address)",
-					Values.parameters("firstName", person.getKey(), "lastName", person.getValue(), "city", CITY));
-		}
 
-		transaction.commit();
-		transaction.close();
-		session.close();
+		try (Session session = driver.session();
+		Transaction transaction = session.beginTransaction();) {
+
+			transaction.run("MATCH (n) detach delete n");
+
+			for (Map.Entry<String, String> person : new Map.Entry[] {
+					new AbstractMap.SimpleEntry(FIRST_NAME, LAST_NAME),
+					new AbstractMap.SimpleEntry(FIRST_NAME2, LAST_NAME),
+			}) {
+				transaction.run(" MERGE (address:Address{city: $city})"
+								+ "CREATE (:Person{firstName: $firstName, lastName: $lastName})"
+								+ "-[:LIVES_AT]-> (address)",
+						Values.parameters("firstName", person.getKey(), "lastName", person.getValue(), "city", CITY));
+			}
+
+			Record result = transaction.run("create (r:ProjectionTestRoot {name: 'root'}) \n"
+									 + "create (l11:ProjectionTestLevel1 {name: 'level11'})\n"
+									 + "create (l12:ProjectionTestLevel1 {name: 'level12'})\n"
+									 + "create (l21:ProjectionTestLevel2 {name: 'level21'})\n"
+									 + "create (l22:ProjectionTestLevel2 {name: 'level22'})\n"
+									 + "create (l23:ProjectionTestLevel2 {name: 'level23'})\n"
+									 + "create (r) - [:LEVEL_1] -> (l11)\n"
+									 + "create (r) - [:LEVEL_1] -> (l12)\n"
+									 + "create (l11) - [:LEVEL_2] -> (l21)\n"
+									 + "create (l11) - [:LEVEL_2] -> (l22)\n"
+									 + "create (l12) - [:LEVEL_2] -> (l23)\n"
+									 + "return id(r), id(l11)").single();
+
+			projectionTestRootId = result.get(0).asLong();
+			projectionTestLevel1Id = result.get(1).asLong();
+			transaction.commit();
+		}
 	}
 
 	@Test
@@ -188,6 +208,29 @@ void projectionsShouldBeSliceable(@Autowired ProjectionPersonRepository reposito
 		assertThat(people).extracting(NamesOnly::getFullName).containsExactly(FIRST_NAME + " " + LAST_NAME);
 	}
 
+	@Test // GH-2164
+	void findByIdWithProjectionShouldWork(@Autowired TreestructureRepository repository) {
+
+		Optional<SimpleProjection> optionalProjection = repository
+				.findById(projectionTestRootId, SimpleProjection.class);
+		assertThat(optionalProjection).map(SimpleProjection::getName).hasValue("root");
+	}
+
+	@Test // GH-2164
+	void findByIdInDerivedFinderMethodInRelatedObjectShouldWork(@Autowired TreestructureRepository repository) {
+
+		Optional<ProjectionTestRoot> optionalProjection = repository.findOneByLevel1Id(projectionTestLevel1Id);
+		assertThat(optionalProjection).map(ProjectionTestRoot::getName).hasValue("root");
+	}
+
+	@Test // GH-2164
+	void findByIdInDerivedFinderMethodInRelatedObjectWithProjectionShouldWork(
+			@Autowired TreestructureRepository repository) {
+
+		Optional<SimpleProjection> optionalProjection = repository.findOneByLevel1Id(projectionTestLevel1Id, SimpleProjection.class);
+		assertThat(optionalProjection).map(SimpleProjection::getName).hasValue("root");
+	}
+
 	interface ProjectionPersonRepository extends Neo4jRepository<Person, Long> {
 
 		Collection<NamesOnly> findByLastName(String lastName);
@@ -203,6 +246,20 @@ interface ProjectionPersonRepository extends Neo4jRepository<Person, Long> {
 		<T> Collection<T> findByLastNameAndFirstName(String lastName, String firstName, Class<T> projectionClass);
 	}
 
+	interface TreestructureRepository extends Neo4jRepository<ProjectionTestRoot, Long> {
+
+		<T> Optional<T> findById(Long id, Class<T> typeOfProjection);
+
+		Optional<ProjectionTestRoot> findOneByLevel1Id(Long idOfLevel1);
+
+		<T> Optional<T> findOneByLevel1Id(Long idOfLevel1, Class<T> typeOfProjection);
+	}
+
+	interface SimpleProjection {
+
+		String getName();
+	}
+
 	@Configuration
 	@EnableNeo4jRepositories(considerNestedRepositories = true)
 	@EnableTransactionManagement

src/test/java/org/springframework/data/neo4j/integration/shared/common/ProjectionTestBase.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2011-2021 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+package org.springframework.data.neo4j.integration.shared.common;
+
+import org.springframework.data.neo4j.core.schema.GeneratedValue;
+import org.springframework.data.neo4j.core.schema.Id;
+
+/**
+ * @author Michael J. Simons
+ */
+public abstract class ProjectionTestBase {
+
+	@Id @GeneratedValue
+	private Long id;
+
+	private String name;
+
+	public Long getId() {
+		return id;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+}

src/test/java/org/springframework/data/neo4j/integration/shared/common/ProjectionTestLevel1.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2011-2021 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+package org.springframework.data.neo4j.integration.shared.common;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.data.neo4j.core.schema.Node;
+
+/**
+ * @author Michael J. Simons
+ */
+@Node
+public class ProjectionTestLevel1 extends ProjectionTestBase {
+
+	private List<ProjectionTestLevel2> level2 = new ArrayList<>();
+
+	public List<ProjectionTestLevel2> getLevel2() {
+		return level2;
+	}
+}

src/test/java/org/springframework/data/neo4j/integration/shared/common/ProjectionTestLevel2.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2011-2021 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+package org.springframework.data.neo4j.integration.shared.common;
+
+import org.springframework.data.neo4j.core.schema.Node;
+
+/**
+ * @author Michael J. Simons
+ */
+@Node
+public class ProjectionTestLevel2 extends ProjectionTestBase {
+}

src/test/java/org/springframework/data/neo4j/integration/shared/common/ProjectionTestRoot.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2011-2021 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+package org.springframework.data.neo4j.integration.shared.common;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.data.neo4j.core.schema.Node;
+
+/**
+ * @author Michael J. Simons
+ */
+@Node
+public class ProjectionTestRoot extends ProjectionTestBase {
+
+	private List<ProjectionTestLevel1> level1 = new ArrayList<>();
+
+	public List<ProjectionTestLevel1> getLevel1() {
+		return level1;
+	}
+}