ReactiveCrudRepository implementation (#1846)

ReactiveCrudRepository implementation ; fixes #1831

Author: dmitry-s

spring-cloud-gcp-data-firestore/src/main/java/org/springframework/cloud/gcp/data/firestore/FirestoreReactiveOperations.java

@@ -32,31 +32,89 @@ public interface FirestoreReactiveOperations {
 	 * update).
 	 * @param <T> the type of the object to save.
 	 * @param instance the instance to save.
-	 * @return the instance that was saved.
+	 * @return {@link Mono} emitting the saved entity.
 	 */
 	<T> Mono<T> save(T instance);
 
 	/**
 	 * Saves multiple objects to Cloud Firestore. Not atomic. Behaves as insert or update.
 	 * @param instances the objects to save.
 	 * @param <T> the type of the objects to save.
-	 * @return a {@link Flux} of the instances that were saved
+	 * @return {@link Flux} emitting the saved entities.
 	 */
 	<T> Flux<T> saveAll(Publisher<T> instances);
 
 	/**
 	 * Get all the entities of the given domain type.
 	 * @param <T> the type param of the domain type.
 	 * @param entityClass the domain type to get.
-	 * @return the entities that were found.
+	 * @return {@link Mono} emitting the found entities.
 	 */
 	<T> Flux<T> findAll(Class<T> entityClass);
 
 	/**
 	 * Delete all entities of a given domain type.
 	 * @param <T> the type param of the domain type.
 	 * @param entityClass the domain type to delete from Cloud Datastore.
-	 * @return the number of entities that were deleted.
+	 * @return {@link Mono} emitting the number of deleted entities.
 	 */
 	<T> Mono<Long> deleteAll(Class<T> entityClass);
+
+	/**
+	 * Test if the entity of the given domain type with a given id exists.
+	 * Uses the first emitted element to perform the query.
+	 * @param <T> the type param of the domain type.
+	 * @param entityClass the domain type of the entity.
+	 * @param idPublisher publisher that provides an id.
+	 * @return {@link Mono} emitting {@code true} if an entity with the given id exists, {@code false} otherwise.
+	 */
+	<T> Mono<Boolean> existsById(Publisher<String> idPublisher, Class<T> entityClass);
+
+	/**
+	 * Get an entity of the given domain type by id.
+	 * Uses the first emitted element to perform the query.
+	 * @param <T> the type param of the domain type.
+	 * @param idPublisher publisher that provides an id.
+	 * @param entityClass the domain type of the entity.
+	 * @return {@link Mono} emitting the found entity.
+	 */
+	<T> Mono<T> findById(Publisher<String> idPublisher, Class<T> entityClass);
+
+	/**
+	 * Get an entity of the given domain type by id.
+	 * @param <T> the type param of the domain type.
+	 * @param idPublisher publisher that provides ids.
+	 * @param entityClass the domain type of the entity.
+	 * @return {@link Flux} emitting the found entities.
+	 */
+	<T> Flux<T> findAllById(Publisher<String> idPublisher, Class<T> entityClass);
+
+	/**
+	 * Count entities of the given domain.
+	 * Note that Firestore doesn't support "count" operation natively,
+	 * so id query will be executed and all ids will be retrieved so they could be counted.
+	 * @param <T> the type param of the domain type.
+	 * @param entityClass the domain type of entities.
+	 * @return {@link Mono} emitting the number of entities.
+	 */
+	<T> Mono<Long> count(Class<T> entityClass);
+
+	/**
+	 * Delete entities provided by publisher.
+	 * @param <T> the type param of the domain type.
+	 * @param entityPublisher publisher that provides entities to be removed.
+	 * @return {@link Mono} signaling when operation has completed.
+	 */
+	<T> Mono<Void> delete(Publisher<T> entityPublisher);
+
+	/**
+	 * Delete entities of a given domain type using ids published by producer.
+	 * @param <T> the type param of the domain type.
+	 * @param idPublisher publisher that provides ids of entities to be removed.
+	 * @param entityClass the domain type of entities.
+	 * @return {@link Mono} signaling when operation has completed.
+	 */
+	<T> Mono<Void> deleteById(Publisher<String> idPublisher, Class entityClass);
+
+
 }

spring-cloud-gcp-data-firestore/src/main/java/org/springframework/cloud/gcp/data/firestore/FirestoreReactiveRepository.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2019-2019 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.gcp.data.firestore;
+
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+
+/**
+ * @author Dmitry Solomakha
+ *
+ * @since 1.2
+ */
+public class FirestoreReactiveRepository<T> implements ReactiveCrudRepository<T, String> {
+
+	private FirestoreTemplate firestoreTemplate;
+
+	private Class type;
+
+	public FirestoreReactiveRepository(FirestoreTemplate firestoreTemplate, Class type) {
+		this.firestoreTemplate = firestoreTemplate;
+		this.type = type;
+	}
+
+	@Override
+	public <S extends T> Mono<S> save(S entity) {
+		return this.firestoreTemplate.save(entity);
+	}
+
+	@Override
+	public <S extends T> Flux<S> saveAll(Iterable<S> entities) {
+		return this.firestoreTemplate.saveAll(Flux.fromIterable(entities));
+	}
+
+	@Override
+	public <S extends T> Flux<S> saveAll(Publisher<S> entityStream) {
+		return this.firestoreTemplate.saveAll(entityStream);
+	}
+
+	@Override
+	public Mono<T> findById(String id) {
+		return findById(Mono.just(id));
+	}
+
+	@Override
+	public Mono<T> findById(Publisher<String> idPublisher) {
+		return this.firestoreTemplate.findById(idPublisher, this.type);
+	}
+
+	@Override
+	public Mono<Boolean> existsById(String id) {
+		return existsById(Mono.just(id));
+	}
+
+	@Override
+	public Mono<Boolean> existsById(Publisher idPublisher) {
+		return this.firestoreTemplate.existsById(idPublisher, this.type);
+	}
+
+	@Override
+	public Flux<T> findAll() {
+		return this.firestoreTemplate.findAll(this.type);
+	}
+
+	@Override
+	public Flux<T> findAllById(Iterable<String> iterable) {
+		return findAllById(Flux.fromIterable(iterable));
+	}
+
+	@Override
+	public Flux<T> findAllById(Publisher<String> idStream) {
+		return this.firestoreTemplate.findAllById(idStream, this.type);
+	}
+
+	@Override
+	public Mono<Long> count() {
+		return this.firestoreTemplate.count(this.type);
+	}
+
+	@Override
+	public Mono<Void> deleteById(String id) {
+		return deleteById(Mono.just(id));
+	}
+
+	@Override
+	public Mono<Void> deleteById(Publisher idPublisher) {
+		return this.firestoreTemplate.deleteById(idPublisher, this.type);
+	}
+
+	@Override
+	public Mono<Void> delete(Object entity) {
+		return this.firestoreTemplate.delete(Mono.just(entity));
+	}
+
+	@Override
+	public Mono<Void> deleteAll(Iterable entities) {
+		return this.firestoreTemplate.delete(Flux.fromIterable(entities));
+	}
+
+	@Override
+	public Mono<Void> deleteAll(Publisher entityStream) {
+		return this.firestoreTemplate.delete(entityStream);
+	}
+
+	@Override
+	public Mono<Void> deleteAll() {
+		return this.firestoreTemplate.deleteAll(this.type);
+	}
+}