DATACOUCH-963 - Scope and Collection API.

Draft of changes for scope and collection API to share with Michael Nitschinger.
Some of the mechanisms in this change-set have been ruled out (the proliferation
of all the method signatures, for instance).

Closes #963.
Original pull request: #1071.

Author: mikereiche

src/main/java/org/springframework/data/couchbase/SimpleCouchbaseClientFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2020 the original author or authors
+ * Copyright 2012-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.

src/main/java/org/springframework/data/couchbase/core/CouchbaseTemplate.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2020 the original author or authors
+ * Copyright 2012-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.
@@ -28,6 +28,7 @@
 import org.springframework.data.couchbase.core.mapping.CouchbaseMappingContext;
 import org.springframework.data.couchbase.core.mapping.CouchbasePersistentEntity;
 import org.springframework.data.couchbase.core.mapping.CouchbasePersistentProperty;
+import org.springframework.data.couchbase.core.support.PseudoArgs;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.lang.Nullable;
 
@@ -60,14 +61,14 @@ public CouchbaseTemplate(final CouchbaseClientFactory clientFactory, final Couch
 		this.converter = converter;
 		this.templateSupport = new CouchbaseTemplateSupport(converter, translationService);
 		this.reactiveCouchbaseTemplate = new ReactiveCouchbaseTemplate(clientFactory, converter, translationService);
-		
+
 		this.mappingContext = this.converter.getMappingContext();
- 		if (mappingContext instanceof CouchbaseMappingContext) {
- 			CouchbaseMappingContext cmc = (CouchbaseMappingContext) mappingContext;
- 			if (cmc.isAutoIndexCreation()) {
- 				indexCreator = new CouchbasePersistentEntityIndexCreator(cmc, this);
- 			}
- 		}
+		if (mappingContext instanceof CouchbaseMappingContext) {
+			CouchbaseMappingContext cmc = (CouchbaseMappingContext) mappingContext;
+			if (cmc.isAutoIndexCreation()) {
+				indexCreator = new CouchbasePersistentEntityIndexCreator(cmc, this);
+			}
+		}
 	}
 
 	@Override
@@ -180,4 +181,12 @@ private void prepareIndexCreator(final ApplicationContext context) {
 			}
 		}
 	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public void setThreadLocalArgs(PseudoArgs pseudoArgs) {
+		reactiveCouchbaseTemplate.setThreadLocalArgs(pseudoArgs);
+	}
+
 }

src/main/java/org/springframework/data/couchbase/core/ExecutableExistsByIdOperation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2020 the original author or authors
+ * Copyright 2012-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.
@@ -18,8 +18,12 @@
 import java.util.Collection;
 import java.util.Map;
 
+import org.springframework.data.couchbase.core.support.InCollection;
+import org.springframework.data.couchbase.core.support.InScope;
 import org.springframework.data.couchbase.core.support.OneAndAllExists;
-import org.springframework.data.couchbase.core.support.WithCollection;
+import org.springframework.data.couchbase.core.support.WithExistsOptions;
+
+import com.couchbase.client.java.kv.ExistsOptions;
 
 public interface ExecutableExistsByIdOperation {
 
@@ -48,16 +52,18 @@ interface TerminatingExistsById extends OneAndAllExists {
 
 	}
 
-	interface ExistsByIdWithCollection extends TerminatingExistsById, WithCollection {
+	interface ExistsByIdWithOptions<T> extends TerminatingExistsById, WithExistsOptions<T> {
+		TerminatingExistsById withOptions(ExistsOptions options);
+	}
 
-		/**
-		 * Allows to specify a different collection than the default one configured.
-		 *
-		 * @param collection the collection to use in this scope.
-		 */
-		TerminatingExistsById inCollection(String collection);
+	interface ExistsByIdInCollection<T> extends ExistsByIdWithOptions<T>, InCollection<T> {
+		ExistsByIdWithOptions<T> inCollection(String collection);
+	}
+
+	interface ExistsByIdInScope<T> extends ExistsByIdInCollection<T>, InScope<T> {
+		ExistsByIdInCollection<T> inScope(String scope);
 	}
 
-	interface ExecutableExistsById extends ExistsByIdWithCollection {}
+	interface ExecutableExistsById extends ExistsByIdInScope {}
 
 }

src/main/java/org/springframework/data/couchbase/core/ExecutableExistsByIdOperationSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2020 the original author or authors
+ * Copyright 2012-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.
@@ -15,12 +15,12 @@
  */
 package org.springframework.data.couchbase.core;
 
-import org.springframework.data.couchbase.core.ReactiveExistsByIdOperationSupport.ReactiveExistsByIdSupport;
-
 import java.util.Collection;
 import java.util.Map;
 
-import org.springframework.util.Assert;
+import org.springframework.data.couchbase.core.ReactiveExistsByIdOperationSupport.ReactiveExistsByIdSupport;
+
+import com.couchbase.client.java.kv.ExistsOptions;
 
 public class ExecutableExistsByIdOperationSupport implements ExecutableExistsByIdOperation {
 
@@ -32,17 +32,25 @@ public class ExecutableExistsByIdOperationSupport implements ExecutableExistsByI
 
 	@Override
 	public ExecutableExistsById existsById() {
-		return new ExecutableExistsByIdSupport(template, null);
+		return new ExecutableExistsByIdSupport(template, null, null, null);
 	}
 
 	static class ExecutableExistsByIdSupport implements ExecutableExistsById {
 
 		private final CouchbaseTemplate template;
+		private final String scope;
+		private final String collection;
+		private final ExistsOptions options;
+
 		private final ReactiveExistsByIdSupport reactiveSupport;
 
-		ExecutableExistsByIdSupport(final CouchbaseTemplate template, final String collection) {
+		ExecutableExistsByIdSupport(final CouchbaseTemplate template, final String scope, final String collection,
+				final ExistsOptions options) {
 			this.template = template;
-			this.reactiveSupport = new ReactiveExistsByIdSupport(template.reactive(), collection);
+			this.scope = scope;
+			this.collection = collection;
+			this.options = options;
+			this.reactiveSupport = new ReactiveExistsByIdSupport(template.reactive(), scope, collection, options);
 		}
 
 		@Override
@@ -56,11 +64,19 @@ public Map<String, Boolean> all(final Collection<String> ids) {
 		}
 
 		@Override
-		public TerminatingExistsById inCollection(final String collection) {
-			Assert.hasText(collection, "Collection must not be null nor empty.");
-			return new ExecutableExistsByIdSupport(template, collection);
+		public ExistsByIdWithOptions inCollection(final String collection) {
+			return new ExecutableExistsByIdSupport(template, scope, collection, options);
 		}
 
+		@Override
+		public TerminatingExistsById withOptions(ExistsOptions options) {
+			return new ExecutableExistsByIdSupport(template, scope, collection, options);
+		}
+
+		@Override
+		public ExistsByIdInCollection inScope(String scope) {
+			return new ExecutableExistsByIdSupport(template, scope, collection, options);
+		}
 	}
 
 }

src/main/java/org/springframework/data/couchbase/core/ExecutableFindByAnalyticsOperation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2020 the original author or authors
+ * Copyright 2012-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.
@@ -21,11 +21,15 @@
 
 import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.data.couchbase.core.query.AnalyticsQuery;
+import org.springframework.data.couchbase.core.support.InCollection;
+import org.springframework.data.couchbase.core.support.InScope;
 import org.springframework.data.couchbase.core.support.OneAndAll;
 import org.springframework.data.couchbase.core.support.WithAnalyticsConsistency;
+import org.springframework.data.couchbase.core.support.WithAnalyticsOptions;
 import org.springframework.data.couchbase.core.support.WithAnalyticsQuery;
 import org.springframework.lang.Nullable;
 
+import com.couchbase.client.java.analytics.AnalyticsOptions;
 import com.couchbase.client.java.analytics.AnalyticsScanConsistency;
 
 public interface ExecutableFindByAnalyticsOperation {
@@ -117,8 +121,20 @@ interface FindByAnalyticsWithQuery<T> extends TerminatingFindByAnalytics<T>, Wit
 
 	}
 
+	interface FindByAnalyticsWithOptions<T> extends FindByAnalyticsWithQuery<T>, WithAnalyticsOptions<T> {
+		FindByAnalyticsWithQuery<T> withOptions(AnalyticsOptions options);
+	}
+
+	interface FindByAnalyticsInCollection<T> extends FindByAnalyticsWithOptions<T>, InCollection<T> {
+		FindByAnalyticsWithOptions<T> inCollection(String collection);
+	}
+
+	interface FindByAnalyticsInScope<T> extends FindByAnalyticsInCollection<T>, InScope<T> {
+		FindByAnalyticsInCollection<T> inScope(String scope);
+	}
+
 	@Deprecated
-	interface FindByAnalyticsConsistentWith<T> extends FindByAnalyticsWithQuery<T> {
+	interface FindByAnalyticsConsistentWith<T> extends FindByAnalyticsInScope<T> {
 
 		/**
 		 * Allows to override the default scan consistency.
@@ -141,6 +157,22 @@ interface FindByAnalyticsWithConsistency<T> extends FindByAnalyticsConsistentWit
 
 	}
 
-	interface ExecutableFindByAnalytics<T> extends FindByAnalyticsWithConsistency<T> {}
+	/**
+	 * Result type override (Optional).
+	 */
+	interface FindByAnalyticsWithProjection<T> extends FindByAnalyticsWithConsistency<T> {
+
+		/**
+		 * Define the target type fields should be mapped to. <br />
+		 * Skip this step if you are anyway only interested in the original domain type.
+		 *
+		 * @param returnType must not be {@literal null}.
+		 * @return new instance of {@link ExecutableFindByQueryOperation.FindByQueryWithProjection}.
+		 * @throws IllegalArgumentException if returnType is {@literal null}.
+		 */
+		<R> FindByAnalyticsWithConsistency<R> as(Class<R> returnType);
+	}
+
+	interface ExecutableFindByAnalytics<T> extends FindByAnalyticsWithProjection<T> {}
 
 }

src/main/java/org/springframework/data/couchbase/core/ExecutableFindByAnalyticsOperationSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2020 the original author or authors
+ * Copyright 2012-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.
@@ -21,7 +21,9 @@
 import org.springframework.data.couchbase.core.ReactiveFindByAnalyticsOperationSupport.ReactiveFindByAnalyticsSupport;
 import org.springframework.data.couchbase.core.query.AnalyticsQuery;
 
+import com.couchbase.client.java.analytics.AnalyticsOptions;
 import com.couchbase.client.java.analytics.AnalyticsScanConsistency;
+import org.springframework.util.Assert;
 
 public class ExecutableFindByAnalyticsOperationSupport implements ExecutableFindByAnalyticsOperation {
 
@@ -35,26 +37,34 @@ public ExecutableFindByAnalyticsOperationSupport(final CouchbaseTemplate templat
 
 	@Override
 	public <T> ExecutableFindByAnalytics<T> findByAnalytics(final Class<T> domainType) {
-		return new ExecutableFindByAnalyticsSupport<>(template, domainType, ALL_QUERY,
-				AnalyticsScanConsistency.NOT_BOUNDED);
+		return new ExecutableFindByAnalyticsSupport<>(template, domainType, domainType, ALL_QUERY, null, null, null, null);
 	}
 
 	static class ExecutableFindByAnalyticsSupport<T> implements ExecutableFindByAnalytics<T> {
 
 		private final CouchbaseTemplate template;
-		private final Class<T> domainType;
+		private final Class<?> domainType;
+		private final Class<T> returnType;
 		private final ReactiveFindByAnalyticsSupport<T> reactiveSupport;
 		private final AnalyticsQuery query;
 		private final AnalyticsScanConsistency scanConsistency;
+		private final String scope;
+		private final String collection;
+		private final AnalyticsOptions options;
 
-		ExecutableFindByAnalyticsSupport(final CouchbaseTemplate template, final Class<T> domainType,
-				final AnalyticsQuery query, final AnalyticsScanConsistency scanConsistency) {
+		ExecutableFindByAnalyticsSupport(final CouchbaseTemplate template, final Class<?> domainType,
+				final Class<T> returnType, final AnalyticsQuery query, final AnalyticsScanConsistency scanConsistency,
+				final String scope, final String collection, final AnalyticsOptions options) {
 			this.template = template;
 			this.domainType = domainType;
+			this.returnType = returnType;
 			this.query = query;
-			this.reactiveSupport = new ReactiveFindByAnalyticsSupport<>(template.reactive(), domainType, query,
-					scanConsistency);
+			this.reactiveSupport = new ReactiveFindByAnalyticsSupport<>(template.reactive(), domainType, returnType, query,
+					scanConsistency, scope, collection, options);
 			this.scanConsistency = scanConsistency;
+			this.scope = scope;
+			this.collection = collection;
+			this.options = options;
 		}
 
 		@Override
@@ -74,18 +84,46 @@ public List<T> all() {
 
 		@Override
 		public TerminatingFindByAnalytics<T> matching(final AnalyticsQuery query) {
-			return new ExecutableFindByAnalyticsSupport<>(template, domainType, query, scanConsistency);
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options);
+		}
+
+		@Override
+		public FindByAnalyticsWithQuery<T> withOptions(AnalyticsOptions options) {
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options);
+		}
+
+		@Override
+		public FindByAnalyticsInCollection<T> inScope(String scope) {
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options);
+		}
+
+		@Override
+		public FindByAnalyticsWithConsistency<T> inCollection(final String collection) {
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options);
 		}
 
 		@Override
 		@Deprecated
 		public FindByAnalyticsWithQuery<T> consistentWith(final AnalyticsScanConsistency scanConsistency) {
-			return new ExecutableFindByAnalyticsSupport<>(template, domainType, query, scanConsistency);
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options);
 		}
 
 		@Override
 		public FindByAnalyticsWithConsistency<T> withConsistency(final AnalyticsScanConsistency scanConsistency) {
-			return new ExecutableFindByAnalyticsSupport<>(template, domainType, query, scanConsistency);
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options);
+		}
+
+		@Override
+		public <R> FindByAnalyticsWithConsistency<R> as(final Class<R> returnType) {
+			Assert.notNull(returnType, "returnType must not be null!");
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options);
 		}
 
 		@Override