GH-2860 - Add explicit transaction boundaries.

If no transactional boundaries were set by the user,
Spring Data Neo4j would create new transactions (default read/write)
for the underlying database operations.

In cases where multiple statements are required to execute
a SDN operation this would mean that multiple transaction
would have been created.

This commit fixes this problem and creates new transaction if no
transaction was defined around the invocation of those units-of-work.

The change will introduce a breaking change:
All pure read operations in SDN (like Neo4jTemplate#findAll) will
now happen in read-only transactions.
If they contain custom statements with write operations,
they need to get wrapped in an explicit write transaction.

Closes #2860

Co-authored-by: Michael Simons <[email protected]>

Author: meistermeier

src/main/java/org/springframework/data/neo4j/config/Neo4jCdiConfigurationSupport.java

@@ -75,10 +75,12 @@ public Configuration cypherDslConfiguration() {
 	public Neo4jOperations neo4jOperations(
 			@Any Instance<Neo4jClient> neo4jClient,
 			@Any Instance<Neo4jMappingContext> mappingContext,
-			@Any Instance<Configuration> cypherDslConfiguration
+			@Any Instance<Configuration> cypherDslConfiguration,
+			@Any Instance<PlatformTransactionManager> transactionManager
 	) {
 		Neo4jTemplate neo4jTemplate = new Neo4jTemplate(resolve(neo4jClient), resolve(mappingContext));
 		neo4jTemplate.setCypherRenderer(Renderer.getRenderer(resolve(cypherDslConfiguration)));
+		neo4jTemplate.setTransactionManager(resolve(transactionManager));
 		return neo4jTemplate;
 	}
 

src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java

@@ -246,7 +246,7 @@ public void setApplicationContext(ApplicationContext applicationContext) throws
 
 		// Otherwise we open a session and synchronize it.
 		Session session = driver.session(Neo4jTransactionUtils.defaultSessionConfig(targetDatabase, asUser));
-		Transaction transaction = session.beginTransaction(TransactionConfig.empty());
+		Transaction transaction = session.beginTransaction(Neo4jTransactionUtils.createTransactionConfigFrom(TransactionDefinition.withDefaults(), -1));
 		// Manually create a new synchronization
 		connectionHolder = new Neo4jTransactionHolder(new Neo4jTransactionContext(targetDatabase, asUser), session, transaction);
 		connectionHolder.setSynchronizedWithTransaction(true);

src/main/java/org/springframework/data/neo4j/core/ReactiveNeo4jTemplate.java

@@ -215,7 +215,7 @@ public static Mono<ReactiveTransaction> retrieveReactiveTransaction(
 					return Mono.defer(() -> {
 
 						ReactiveSession session = driver.session(ReactiveSession.class, Neo4jTransactionUtils.defaultSessionConfig(targetDatabase, asUser));
-						return Mono.fromDirect(session.beginTransaction(TransactionConfig.empty())).map(tx -> {
+						return Mono.fromDirect(session.beginTransaction(Neo4jTransactionUtils.createTransactionConfigFrom(TransactionDefinition.withDefaults(), -1))).map(tx -> {
 
 							ReactiveNeo4jTransactionHolder newConnectionHolder = new ReactiveNeo4jTransactionHolder(
 									new Neo4jTransactionContext(targetDatabase, asUser), session, tx);

src/main/java/org/springframework/data/neo4j/core/transaction/Neo4jTransactionManager.java

@@ -49,6 +49,7 @@
 import org.springframework.data.neo4j.test.Neo4jIntegrationTest;
 import org.springframework.transaction.PlatformTransactionManager;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.springframework.transaction.support.TransactionTemplate;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -880,20 +881,22 @@ void saveWeirdHierarchy() {
 	}
 
 	@Test
-	void updatingFindShouldWork() {
+	void updatingFindShouldWork(@Autowired PlatformTransactionManager transactionManager) {
 		Map<String, Object> params = new HashMap<>();
 		params.put("wrongName", "Siemons");
 		params.put("correctName", "Simons");
-		Optional<Person> optionalResult = neo4jTemplate
-				.findOne("MERGE (p:Person {lastName: $wrongName}) ON MATCH set p.lastName = $correctName RETURN p",
-						params, Person.class);
-
-		assertThat(optionalResult).hasValueSatisfying(
-				updatedPerson -> {
-					assertThat(updatedPerson.getLastName()).isEqualTo("Simons");
-					assertThat(updatedPerson.getAddress()).isNull(); // We didn't fetch it
-				}
-		);
+		new TransactionTemplate(transactionManager).executeWithoutResult(tx -> {
+			Optional<Person> optionalResult = neo4jTemplate
+					.findOne("MERGE (p:Person {lastName: $wrongName}) ON MATCH set p.lastName = $correctName RETURN p",
+							params, Person.class);
+
+			assertThat(optionalResult).hasValueSatisfying(
+					updatedPerson -> {
+						assertThat(updatedPerson.getLastName()).isEqualTo("Simons");
+						assertThat(updatedPerson.getAddress()).isNull(); // We didn't fetch it
+					}
+			);
+		});
 	}
 
 	@Test

src/main/java/org/springframework/data/neo4j/core/transaction/ReactiveNeo4jTransactionManager.java

@@ -499,10 +499,12 @@ void aggregateThroughQueryIntoCustomObjectDTOShouldWork(@Autowired PersonReposit
 		}
 
 		@Test  // DATAGRAPH-1429
-		void queryAggregatesShouldWorkWithTheTemplate(@Autowired Neo4jTemplate template) {
+		void queryAggregatesShouldWorkWithTheTemplate(@Autowired Neo4jTemplate template, @Autowired PlatformTransactionManager transactionManager) {
+			new TransactionTemplate(transactionManager).executeWithoutResult(tx -> {
 
-			List<Person> people = template.findAll("unwind range(1,5) as i with i create (p:Person {firstName: toString(i)}) return p", Person.class);
-			assertThat(people).extracting(Person::getFirstName).containsExactly("1", "2", "3", "4", "5");
+				List<Person> people = template.findAll("unwind range(1,5) as i with i create (p:Person {firstName: toString(i)}) return p", Person.class);
+				assertThat(people).extracting(Person::getFirstName).containsExactly("1", "2", "3", "4", "5");
+			});
 		}
 
 		@Test

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

@@ -57,6 +57,7 @@
 import org.springframework.data.neo4j.test.Neo4jReactiveTestConfiguration;
 import org.springframework.transaction.ReactiveTransactionManager;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.springframework.transaction.reactive.TransactionalOperator;
 import reactor.core.publisher.Flux;
 import reactor.test.StepVerifier;
 
@@ -533,9 +534,10 @@ void saveAllProjectionShouldWork(@Autowired ReactiveNeo4jTemplate template) {
 	}
 
 	@Test
-	void saveAllAsWithOpenProjectionShouldWork(@Autowired ReactiveNeo4jTemplate template) {
+	void saveAllAsWithOpenProjectionShouldWork(@Autowired ReactiveNeo4jTemplate template, @Autowired ReactiveTransactionManager transactionManager) {
 
 		// Using a query on purpose so that the address is null
+		TransactionalOperator.create(transactionManager).transactional(
 		template.findOne("MATCH (p:Person {lastName: $lastName}) RETURN p",
 						Collections.singletonMap("lastName", "Siemons"), Person.class)
 				.zipWith(template.findOne("MATCH (p:Person {lastName: $lastName}) RETURN p",
@@ -550,7 +552,7 @@ void saveAllAsWithOpenProjectionShouldWork(@Autowired ReactiveNeo4jTemplate temp
 					p2.setFirstName("Helga");
 					p2.setLastName("Schneider");
 					return template.saveAllAs(Arrays.asList(p1, p2), OpenProjection.class);
-				})
+				}))
 				.map(OpenProjection::getFullName)
 				.sort()
 				.as(StepVerifier::create)
@@ -832,13 +834,15 @@ void saveAllAsWithClosedProjectionShouldWork(@Autowired ReactiveNeo4jTemplate te
 	}
 
 	@Test
-	void updatingFindShouldWork() {
+	void updatingFindShouldWork(@Autowired ReactiveTransactionManager transactionManager) {
 		Map<String, Object> params = new HashMap<>();
 		params.put("wrongName", "Siemons");
 		params.put("correctName", "Simons");
-		neo4jTemplate
-				.findOne("MERGE (p:Person {lastName: $wrongName}) ON MATCH set p.lastName = $correctName RETURN p",
-						params, Person.class)
+		TransactionalOperator.create(transactionManager)
+				.transactional(
+						neo4jTemplate
+								.findOne("MERGE (p:Person {lastName: $wrongName}) ON MATCH set p.lastName = $correctName RETURN p",
+										params, Person.class))
 				.as(StepVerifier::create)
 				.consumeNextWith(updatedPerson -> {
 

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

@@ -702,9 +702,9 @@ void aggregateThroughQueryIntoListShouldWork(@Autowired ReactivePersonRepository
 		}
 
 		@Test // DATAGRAPH-1429
-		void queryAggregatesShouldWorkWithTheTemplate(@Autowired ReactiveNeo4jTemplate template) {
+		void queryAggregatesShouldWorkWithTheTemplate(@Autowired ReactiveNeo4jTemplate template, @Autowired ReactiveTransactionManager reactiveTransactionManager) {
 
-			Flux<Person> people = template.findAll("unwind range(1,5) as i with i create (p:Person {firstName: toString(i)}) return p", Person.class);
+			Flux<Person> people = TransactionalOperator.create(reactiveTransactionManager).transactional(template.findAll("unwind range(1,5) as i with i create (p:Person {firstName: toString(i)}) return p", Person.class));
 
 			StepVerifier.create(people.map(Person::getFirstName))
 					.expectNext("1", "2", "3", "4", "5")