build(deps): Upgrade Cypher-DSL to 2024.7.2 in preparation for 2025.0.0 release.

Author: michael-simons

pom.xml

@@ -77,7 +77,7 @@
 		<blockhound.version>1.0.8.RELEASE</blockhound.version>
 		<checkstyle.skip>${skipTests}</checkstyle.skip>
 		<checkstyle.version>10.20.1</checkstyle.version>
-		<cypher-dsl.version>2024.5.1</cypher-dsl.version>
+		<cypher-dsl.version>2024.7.2</cypher-dsl.version>
 		<dist.id>spring-data-neo4j</dist.id>
 		<dist.key>SDNEO4J</dist.key>
 		<flatten-maven-plugin.version>1.7.0</flatten-maven-plugin.version>

src/test/java/org/springframework/data/neo4j/documentation/repositories/custom_queries/DomainResultsImpl.java

@@ -30,7 +30,6 @@
 import static org.neo4j.cypherdsl.core.Cypher.name;
 import static org.neo4j.cypherdsl.core.Cypher.node;
 import static org.neo4j.cypherdsl.core.Cypher.parameter;
-import static org.neo4j.cypherdsl.core.Cypher.shortestPath;
 
 class DomainResultsImpl implements DomainResults {
 
@@ -45,7 +44,7 @@ public List<MovieEntity> findMoviesAlongShortestPath(PersonEntity from, PersonEn
 
 		var p1 = node("Person").withProperties("name", parameter("person1"));
 		var p2 = node("Person").withProperties("name", parameter("person2"));
-		var shortestPath = shortestPath("p").definedBy(p1.relationshipBetween(p2).unbounded());
+		var shortestPath = Cypher.shortestK(1).named("p").definedBy(p1.relationshipBetween(p2).unbounded());
 		var p = shortestPath.getRequiredSymbolicName();
 		var statement = Cypher.match(shortestPath)
 			.with(p, listWith(name("n")).in(Cypher.nodes(shortestPath))

src/test/java/org/springframework/data/neo4j/integration/reactive/ReactiveNeo4jClientIT.java

@@ -17,34 +17,20 @@
 
 import java.util.Collection;
 import java.util.Collections;
-import java.util.List;
 import java.util.Map;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.stream.Stream;
 
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.neo4j.cypherdsl.core.Cypher;
 import org.neo4j.cypherdsl.core.Node;
-import org.neo4j.cypherdsl.core.Statement;
-import org.neo4j.cypherdsl.core.executables.ExecutableResultStatement;
 import org.neo4j.driver.Driver;
-import org.neo4j.driver.Query;
-import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.SimpleQueryRunner;
 import org.neo4j.driver.Transaction;
-import org.neo4j.driver.async.AsyncQueryRunner;
-import org.neo4j.driver.reactivestreams.ReactiveQueryRunner;
 import org.neo4j.driver.reactivestreams.ReactiveResult;
 import org.neo4j.driver.reactivestreams.ReactiveSession;
-import org.neo4j.driver.summary.ResultSummary;
-import org.reactivestreams.Publisher;
 import reactor.blockhound.BlockHound;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -154,15 +140,15 @@ void clientShouldIntegrateWithCypherDSL(@Autowired TransactionalOperator transac
 					Cypher.mapOf("value",
 							Cypher.literalOf(23).multiply(Cypher.literalOf(2)).subtract(Cypher.literalOf(4))))
 			.named("n");
-		NewReactiveExecutableResultStatement statement = new NewReactiveExecutableResultStatement(namedAnswer);
+		var cypher = Cypher.create(namedAnswer).returning(namedAnswer).build().getCypher();
 
 		AtomicLong vanishedId = new AtomicLong();
 		transactionalOperator.execute(transaction -> {
-			Flux<Long> inner = client.getQueryRunner()
-				.flatMapMany(statement::fetchWith)
+			var inner = client.getQueryRunner()
+				.flatMap(qr -> Mono.from(qr.run(cypher)))
+				.flatMapMany(r -> Flux.from(r.records()))
 				.doOnNext(r -> vanishedId.set(TestIdentitySupport.getInternalId(r.get("n").asNode())))
 				.map(record -> record.get("n").get("value").asLong());
-
 			transaction.setRollbackOnly();
 			return inner;
 		}).as(StepVerifier::create).expectNext(42L).verifyComplete();
@@ -221,70 +207,4 @@ public boolean isCypher5Compatible() {
 
 	}
 
-	private static class NewReactiveExecutableResultStatement implements ExecutableResultStatement {
-
-		private final Statement delegate;
-
-		NewReactiveExecutableResultStatement(Node namedAnswer) {
-			this.delegate = Cypher.create(namedAnswer).returning(namedAnswer).build();
-		}
-
-		/**
-		 * This method should move into a future Cypher-DSL version.
-		 * @param reactiveQueryRunner The runner to run the statement with
-		 * @return a publisher of records
-		 */
-		Publisher<Record> fetchWith(ReactiveQueryRunner reactiveQueryRunner) {
-			return Mono.fromCallable(this::createQuery)
-				.flatMapMany(reactiveQueryRunner::run)
-				.flatMap(ReactiveResult::records);
-		}
-
-		@Override
-		public <T> List<T> fetchWith(SimpleQueryRunner queryRunner, Function<Record, T> function) {
-			throw new UnsupportedOperationException();
-		}
-
-		@Override
-		public <T> CompletableFuture<List<T>> fetchWith(AsyncQueryRunner asyncQueryRunner,
-				Function<Record, T> function) {
-			throw new UnsupportedOperationException();
-		}
-
-		@Override
-		public ResultSummary streamWith(SimpleQueryRunner queryRunner, Consumer<Stream<Record>> consumer) {
-			throw new UnsupportedOperationException();
-		}
-
-		@Override
-		public ResultSummary executeWith(SimpleQueryRunner queryRunner) {
-			throw new UnsupportedOperationException();
-		}
-
-		@Override
-		public CompletableFuture<ResultSummary> executeWith(AsyncQueryRunner queryRunner) {
-			throw new UnsupportedOperationException();
-		}
-
-		Query createQuery() {
-			return new Query(this.delegate.getCypher(), this.delegate.getCatalog().getParameters());
-		}
-
-		@Override
-		public Map<String, Object> getParameters() {
-			return this.delegate.getCatalog().getParameters();
-		}
-
-		@Override
-		public Collection<String> getParameterNames() {
-			return this.delegate.getCatalog().getParameterNames();
-		}
-
-		@Override
-		public String getCypher() {
-			return this.delegate.getCypher();
-		}
-
-	}
-
 }