Keep API compatible after DBSelection changes.

Deprecate old constuctors and throw an exception if there is
a mismatch of the provided DatabaseSelectionProviders.

Author: meistermeier

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

@@ -54,8 +54,8 @@ public abstract class AbstractReactiveNeo4jConfig extends Neo4jConfigurationSupp
 	 * @return A reactive Neo4j client.
 	 */
 	@Bean(ReactiveNeo4jRepositoryConfigurationExtension.DEFAULT_NEO4J_CLIENT_BEAN_NAME)
-	public ReactiveNeo4jClient neo4jClient(Driver driver) {
-		return ReactiveNeo4jClient.create(driver);
+	public ReactiveNeo4jClient neo4jClient(Driver driver, ReactiveDatabaseSelectionProvider databaseNameProvider) {
+		return ReactiveNeo4jClient.create(driver, databaseNameProvider);
 	}
 
 	@Bean(ReactiveNeo4jRepositoryConfigurationExtension.DEFAULT_NEO4J_TEMPLATE_BEAN_NAME)

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

@@ -129,6 +129,11 @@ public <T> OngoingDelegation<T> delegateTo(Function<QueryRunner, Optional<T>> ca
 		return new DefaultRunnableDelegation<>(callback);
 	}
 
+	@Override
+	public DatabaseSelectionProvider getDatabaseSelectionProvider() {
+		return databaseSelectionProvider;
+	}
+
 	/**
 	 * Basically a holder of a cypher template supplier and a set of named parameters. It's main purpose is to orchestrate
 	 * the running of things with a bit of logging.
@@ -262,17 +267,27 @@ class DefaultRecordFetchSpec<T> implements RecordFetchSpec<T>, MappingSpec<T> {
 
 		private BiFunction<TypeSystem, Record, T> mappingFunction;
 
-		DefaultRecordFetchSpec(String targetDatabase, RunnableStatement runnableStatement,
+		DefaultRecordFetchSpec(String parameterTargetDatabase, RunnableStatement runnableStatement,
 				BiFunction<TypeSystem, Record, T> mappingFunction) {
-			this.targetDatabase = targetDatabase != null
-					? targetDatabase
-					: databaseSelectionProvider != null
-						? databaseSelectionProvider.getDatabaseSelection().getValue()
-						: null;
+
+			this.targetDatabase = resolveTargetDatabaseName(parameterTargetDatabase);
 			this.runnableStatement = runnableStatement;
 			this.mappingFunction = mappingFunction;
 		}
 
+		private String resolveTargetDatabaseName(@Nullable String parameterTargetDatabase) {
+			if (parameterTargetDatabase != null) {
+				return parameterTargetDatabase;
+			}
+			if (databaseSelectionProvider != null) {
+				String databaseSelectionProviderValue = databaseSelectionProvider.getDatabaseSelection().getValue();
+				if (databaseSelectionProviderValue != null) {
+					return databaseSelectionProviderValue;
+				}
+			}
+			return DatabaseSelectionProvider.getDefaultSelectionProvider().getDatabaseSelection().getValue();
+		}
+
 		@Override
 		public RecordFetchSpec<T> mappedBy(
 				@SuppressWarnings("HiddenField") BiFunction<TypeSystem, Record, T> mappingFunction) {

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

@@ -105,6 +105,11 @@ public <T> OngoingDelegation<T> delegateTo(Function<RxQueryRunner, Mono<T>> call
 		return new DefaultRunnableDelegation<>(callback);
 	}
 
+	@Override
+	public ReactiveDatabaseSelectionProvider getDatabaseSelectionProvider() {
+		return databaseSelectionProvider;
+	}
+
 	class DefaultRunnableSpec implements RunnableSpec {
 
 		private final Supplier<String> cypherSupplier;
@@ -193,18 +198,16 @@ class DefaultRecordFetchSpec<T> implements RecordFetchSpec<T>, MappingSpec<T> {
 			this(targetDatabase, cypherSupplier, parameters, null);
 		}
 
-		DefaultRecordFetchSpec(@Nullable String targetDatabase, Supplier<String> cypherSupplier, NamedParameters parameters,
+		DefaultRecordFetchSpec(@Nullable String parameterTargetDatabase, Supplier<String> cypherSupplier, NamedParameters parameters,
 				@Nullable BiFunction<TypeSystem, Record, T> mappingFunction) {
 
-			this.targetDatabase = Mono.defer(() -> {
-				if (targetDatabase != null) {
-					return ReactiveDatabaseSelectionProvider.createStaticDatabaseSelectionProvider(targetDatabase)
-							.getDatabaseSelection();
-				} else if (databaseSelectionProvider != null) {
-					return databaseSelectionProvider.getDatabaseSelection();
-				}
-				return Mono.just(DatabaseSelection.undecided());
-			});
+			this.targetDatabase = Mono.defer(() -> Mono
+					.justOrEmpty(parameterTargetDatabase)
+					.flatMap(db -> ReactiveDatabaseSelectionProvider.createStaticDatabaseSelectionProvider(db).getDatabaseSelection())
+					.switchIfEmpty(databaseSelectionProvider == null
+							? Mono.empty()
+							: databaseSelectionProvider.getDatabaseSelection())
+					.switchIfEmpty(Mono.just(DatabaseSelection.undecided())));
 			this.cypherSupplier = cypherSupplier;
 			this.parameters = parameters;
 			this.mappingFunction = mappingFunction;

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

@@ -48,7 +48,7 @@ public interface Neo4jClient {
 
 	static Neo4jClient create(Driver driver) {
 
-		return new DefaultNeo4jClient(driver, null);
+		return new DefaultNeo4jClient(driver, DatabaseSelectionProvider.getDefaultSelectionProvider());
 	}
 
 	static Neo4jClient create(Driver driver, DatabaseSelectionProvider databaseSelectionProvider) {
@@ -85,6 +85,13 @@ static Neo4jClient create(Driver driver, DatabaseSelectionProvider databaseSelec
 	 */
 	<T> OngoingDelegation<T> delegateTo(Function<QueryRunner, Optional<T>> callback);
 
+	/**
+	 * Returns the assigned database selection provider.
+	 *
+	 * @return The database selection provider - can be null
+	 */
+	DatabaseSelectionProvider getDatabaseSelectionProvider();
+
 	/**
 	 * Contract for a runnable query that can be either run returning it's result, run without results or be
 	 * parameterized.

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

@@ -98,12 +98,35 @@ public final class Neo4jTemplate implements Neo4jOperations, BeanFactoryAware {
 
 	private EventSupport eventSupport;
 
+	@Deprecated
+	public Neo4jTemplate(Neo4jClient neo4jClient, Neo4jMappingContext neo4jMappingContext,
+						 DatabaseSelectionProvider databaseSelectionProvider) {
+
+		this(neo4jClient, neo4jMappingContext, EntityCallbacks.create());
+
+		if (databaseSelectionProvider != neo4jClient.getDatabaseSelectionProvider()) {
+			throw new IllegalStateException(
+					"The provided database selection provider differs from the Neo4jClient's one.");
+		}
+	}
+
+	@Deprecated
+	public Neo4jTemplate(Neo4jClient neo4jClient, Neo4jMappingContext neo4jMappingContext,
+						 DatabaseSelectionProvider databaseSelectionProvider, EntityCallbacks entityCallbacks) {
+
+		this(neo4jClient, neo4jMappingContext, entityCallbacks);
+
+		if (databaseSelectionProvider != neo4jClient.getDatabaseSelectionProvider()) {
+			throw new IllegalStateException(
+					"The provided database selection provider differs from the Neo4jClient's one.");
+		}
+	}
+
 	public Neo4jTemplate(Neo4jClient neo4jClient) {
 		this(neo4jClient, new Neo4jMappingContext());
 	}
 
 	public Neo4jTemplate(Neo4jClient neo4jClient, Neo4jMappingContext neo4jMappingContext) {
-
 		this(neo4jClient, neo4jMappingContext, EntityCallbacks.create());
 	}
 

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

@@ -85,6 +85,12 @@ static ReactiveNeo4jClient create(Driver driver, ReactiveDatabaseSelectionProvid
 	 */
 	<T> OngoingDelegation<T> delegateTo(Function<RxQueryRunner, Mono<T>> callback);
 
+	/**
+	 * Returns the assigned database selection provider.
+	 *
+	 * @return The database selection provider - can be null
+	 */
+	ReactiveDatabaseSelectionProvider getDatabaseSelectionProvider();
 	/**
 	 * @param <T> The resulting type of this mapping
 	 * @since 6.0

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

@@ -98,6 +98,16 @@ public final class ReactiveNeo4jTemplate implements ReactiveNeo4jOperations, Bea
 
 	private ReactiveEventSupport eventSupport;
 
+	@Deprecated
+	public ReactiveNeo4jTemplate(ReactiveNeo4jClient neo4jClient, Neo4jMappingContext neo4jMappingContext,
+								 ReactiveDatabaseSelectionProvider databaseSelectionProvider) {
+
+		this(neo4jClient, neo4jMappingContext);
+		if (databaseSelectionProvider != neo4jClient.getDatabaseSelectionProvider()) {
+			throw new IllegalStateException("The provided database selection provider differs from the ReactiveNeo4jClient's one.");
+		}
+	}
+
 	public ReactiveNeo4jTemplate(ReactiveNeo4jClient neo4jClient, Neo4jMappingContext neo4jMappingContext) {
 
 		Assert.notNull(neo4jClient, "The Neo4jClient is required");