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: #0000.

Author: mikereiche

pom.xml

@@ -173,6 +173,7 @@
         <dependency>
             <groupId>io.projectreactor</groupId>
             <artifactId>reactor-test</artifactId>
+            <version>3.1.0.RELEASE</version>
             <scope>test</scope>
         </dependency>
 
@@ -284,6 +285,14 @@
                 <groupId>org.asciidoctor</groupId>
                 <artifactId>asciidoctor-maven-plugin</artifactId>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 </project>

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

@@ -18,6 +18,7 @@
 
 import org.springframework.data.couchbase.CouchbaseClientFactory;
 import org.springframework.data.couchbase.core.convert.CouchbaseConverter;
+import org.springframework.data.couchbase.core.support.PseudoArgs;
 
 /**
  * Defines common operations on the Couchbase data source, most commonly implemented by {@link CouchbaseTemplate}.
@@ -44,4 +45,9 @@ public interface CouchbaseOperations extends FluentCouchbaseOperations {
 	 */
 	CouchbaseClientFactory getCouchbaseClientFactory();
 
+	/**
+	 * @param pseudoArgs - the metaArgs to set on the ThreadLocal field of the CouchbaseOperations
+	 */
+	void setThrdLocalArgs(PseudoArgs<?> pseudoArgs);
+
 }

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

@@ -16,6 +16,7 @@
 
 package org.springframework.data.couchbase.core;
 
+import com.couchbase.client.java.CommonOptions;
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
@@ -25,6 +26,7 @@
 import org.springframework.data.couchbase.core.convert.translation.TranslationService;
 
 import com.couchbase.client.java.Collection;
+import org.springframework.data.couchbase.core.support.PseudoArgs;
 
 /**
  * Implements lower-level couchbase operations on top of the SDK with entity mapping capabilities.
@@ -47,7 +49,7 @@ public CouchbaseTemplate(final CouchbaseClientFactory clientFactory, final Couch
 	}
 
 	public CouchbaseTemplate(final CouchbaseClientFactory clientFactory, final CouchbaseConverter converter,
-		final TranslationService translationService) {
+			final TranslationService translationService) {
 		this.clientFactory = clientFactory;
 		this.converter = converter;
 		this.templateSupport = new CouchbaseTemplateSupport(converter, translationService);
@@ -143,4 +145,13 @@ public void setApplicationContext(final ApplicationContext applicationContext) t
 		templateSupport.setApplicationContext(applicationContext);
 		reactiveCouchbaseTemplate.setApplicationContext(applicationContext);
 	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public void setThrdLocalArgs(PseudoArgs pseudoArgs) {
+		reactiveCouchbaseTemplate.setThrdLocalArgs(pseudoArgs);
+	}
+
 }

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

@@ -18,8 +18,11 @@
 import java.util.Collection;
 import java.util.Map;
 
+import com.couchbase.client.java.kv.GetOptions;
 import org.springframework.data.couchbase.core.support.OneAndAllExists;
 import org.springframework.data.couchbase.core.support.WithCollection;
+import org.springframework.data.couchbase.core.support.WithGetOptions;
+import org.springframework.data.couchbase.core.support.WithScope;
 
 public interface ExecutableExistsByIdOperation {
 
@@ -48,16 +51,18 @@ interface TerminatingExistsById extends OneAndAllExists {
 
 	}
 
-	interface ExistsByIdWithCollection extends TerminatingExistsById, WithCollection {
+	interface ExistsByIdWithOptions<T> extends TerminatingExistsById, WithGetOptions<T> {
+		TerminatingExistsById withOptions(GetOptions 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 ExistsByIdWithCollection<T> extends ExistsByIdWithOptions<T>, WithCollection<T> {
+		ExistsByIdWithOptions<T> inCollection(String collection);
+	}
+
+	interface ExistsByIdWithScope<T> extends ExistsByIdWithCollection<T>, WithScope<T> {
+		ExistsByIdWithCollection<T> inScope(String collection);
 	}
 
-	interface ExecutableExistsById extends ExistsByIdWithCollection {}
+	interface ExecutableExistsById extends ExistsByIdWithScope {}
 
 }

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

@@ -15,13 +15,12 @@
  */
 package org.springframework.data.couchbase.core;
 
+import com.couchbase.client.java.kv.GetOptions;
 import org.springframework.data.couchbase.core.ReactiveExistsByIdOperationSupport.ReactiveExistsByIdSupport;
 
 import java.util.Collection;
 import java.util.Map;
 
-import org.springframework.util.Assert;
-
 public class ExecutableExistsByIdOperationSupport implements ExecutableExistsByIdOperation {
 
 	private final CouchbaseTemplate template;
@@ -32,17 +31,21 @@ 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 String scope;
+		private String collection;
+		private GetOptions options;
+
 		private final ReactiveExistsByIdSupport reactiveSupport;
 
-		ExecutableExistsByIdSupport(final CouchbaseTemplate template, final String collection) {
+		ExecutableExistsByIdSupport(final CouchbaseTemplate template, final String scope, final String collection, final GetOptions options) {
 			this.template = template;
-			this.reactiveSupport = new ReactiveExistsByIdSupport(template.reactive(), collection);
+			this.reactiveSupport = new ReactiveExistsByIdSupport(template.reactive(), scope, collection, options);
 		}
 
 		@Override
@@ -56,11 +59,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(GetOptions options) {
+			return new ExecutableExistsByIdSupport(template, scope, collection, options);
+		}
+
+		@Override
+		public ExistsByIdWithCollection inScope(String collection) {
+			return new ExecutableExistsByIdSupport(template, scope, collection, options);
+		}
 	}
 
 }

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

@@ -19,11 +19,17 @@
 import java.util.Optional;
 import java.util.stream.Stream;
 
+import com.couchbase.client.java.analytics.AnalyticsOptions;
+import com.couchbase.client.java.query.QueryOptions;
 import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.data.couchbase.core.query.AnalyticsQuery;
 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.data.couchbase.core.support.WithCollection;
+import org.springframework.data.couchbase.core.support.WithQueryOptions;
+import org.springframework.data.couchbase.core.support.WithScope;
 import org.springframework.lang.Nullable;
 
 import com.couchbase.client.java.analytics.AnalyticsScanConsistency;
@@ -117,8 +123,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>, WithCollection<T> {
+		FindByAnalyticsWithOptions<T> inCollection(String collection);
+	}
+
+	interface FindByAnalyticsWithScope<T> extends FindByAnalyticsInCollection<T>, WithScope<T> {
+		FindByAnalyticsInCollection<T> inScope(String collection);
+	}
+
 	@Deprecated
-	interface FindByAnalyticsConsistentWith<T> extends FindByAnalyticsWithQuery<T> {
+	interface FindByAnalyticsConsistentWith<T> extends FindByAnalyticsWithScope<T> {
 
 		/**
 		 * Allows to override the default scan consistency.

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

@@ -16,8 +16,11 @@
 package org.springframework.data.couchbase.core;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Stream;
 
+import com.couchbase.client.java.analytics.AnalyticsOptions;
+import com.couchbase.client.java.query.QueryOptions;
 import org.springframework.data.couchbase.core.ReactiveFindByAnalyticsOperationSupport.ReactiveFindByAnalyticsSupport;
 import org.springframework.data.couchbase.core.query.AnalyticsQuery;
 
@@ -35,26 +38,36 @@ 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, 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;
-
-		ExecutableFindByAnalyticsSupport(final CouchbaseTemplate template, final Class<T> domainType,
-				final AnalyticsQuery query, final AnalyticsScanConsistency scanConsistency) {
+		private final String scope;
+		private final String collection;
+		private final AnalyticsOptions options;
+		private final String[] distinctFields;
+
+		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, String[] distinctFields) {
 			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, distinctFields);
 			this.scanConsistency = scanConsistency;
+			this.scope = scope;
+			this.collection = collection;
+			this.options = options;
+			this.distinctFields = distinctFields;
 		}
 
 		@Override
@@ -74,18 +87,38 @@ 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, distinctFields);
+		}
+
+		@Override
+		public FindByAnalyticsWithQuery<T> withOptions(AnalyticsOptions options) {
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options, distinctFields);
+		}
+
+		@Override
+		public FindByAnalyticsInCollection<T> inScope(String scope) {
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options, distinctFields);
 		}
 
+		@Override
+		public FindByAnalyticsWithConsistency<T> inCollection(final String collection) {
+			return new ExecutableFindByAnalyticsSupport<>(template, domainType, returnType, query, scanConsistency, scope,
+					collection, options, distinctFields);
+		}
 		@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, distinctFields);
 		}
 
 		@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, distinctFields);
 		}
 
 		@Override
@@ -103,6 +136,7 @@ public boolean exists() {
 			return count() > 0;
 		}
 
+
 	}
 
 }

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

@@ -17,9 +17,14 @@
 
 import java.util.Collection;
 
+import com.couchbase.client.java.CommonOptions;
+import com.couchbase.client.java.kv.GetOptions;
 import org.springframework.data.couchbase.core.support.OneAndAllId;
 import org.springframework.data.couchbase.core.support.WithCollection;
+import org.springframework.data.couchbase.core.support.WithGetOptions;
 import org.springframework.data.couchbase.core.support.WithProjectionId;
+import org.springframework.data.couchbase.core.support.WithReplaceOptions;
+import org.springframework.data.couchbase.core.support.WithScope;
 
 public interface ExecutableFindByIdOperation {
 
@@ -50,25 +55,26 @@ interface TerminatingFindById<T> extends OneAndAllId<T> {
 
 	}
 
-	interface FindByIdWithCollection<T> extends TerminatingFindById<T>, WithCollection<T> {
+		interface FindByIdWithOptions<T> extends TerminatingFindById<T>, WithGetOptions<T> {
+			TerminatingFindById<T> withOptions(GetOptions options);
+		}
 
-		/**
-		 * Allows to specify a different collection than the default one configured.
-		 *
-		 * @param collection the collection to use in this scope.
-		 */
-		TerminatingFindById<T> inCollection(String collection);
+		interface FindByIdWithCollection<T> extends FindByIdWithOptions<T>, WithCollection<T> {
+			FindByIdWithOptions<T> inCollection(String collection);
+		}
 
-	}
+		interface FindByIdWithScope<T> extends FindByIdWithCollection<T>, WithScope<T> {
+			FindByIdWithCollection<T> inScope(String collection);
+		}
 
-	interface FindByIdWithProjection<T> extends FindByIdWithCollection<T>, WithProjectionId<T> {
+	interface FindByIdWithProjection<T> extends FindByIdWithScope<T>, WithProjectionId<T> {
 
 		/**
 		 * Load only certain fields for the document.
 		 *
 		 * @param fields the projected fields to load.
 		 */
-		FindByIdWithCollection<T> project(String... fields);
+		FindByIdWithScope<T> project(String... fields);
 
 	}