DATAES-785 - Various entity callbacks implementation improvements.

Original PR: #431

src/main/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplate.java

@@ -463,23 +463,23 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
 	// endregion
 
 	// region Entity callbacks
-	protected <T> T maybeCallbackBeforeConvert(T entity) {
+	protected <T> T maybeCallbackBeforeConvert(T entity, IndexCoordinates index) {
 
 		if (entityCallbacks != null) {
-			return entityCallbacks.callback(BeforeConvertCallback.class, entity);
+			return entityCallbacks.callback(BeforeConvertCallback.class, entity, index);
 		}
 
 		return entity;
 	}
 
-	protected void maybeCallbackBeforeConvertWithQuery(Object query) {
+	protected void maybeCallbackBeforeConvertWithQuery(Object query, IndexCoordinates index) {
 
 		if (query instanceof IndexQuery) {
 			IndexQuery indexQuery = (IndexQuery) query;
 			Object queryObject = indexQuery.getObject();
 
 			if (queryObject != null) {
-				queryObject = maybeCallbackBeforeConvert(queryObject);
+				queryObject = maybeCallbackBeforeConvert(queryObject, index);
 				indexQuery.setObject(queryObject);
 			}
 		}
@@ -487,27 +487,27 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
 
 	// this can be called with either a List<IndexQuery> or a List<UpdateQuery>; these query classes
 	// don't have a common base class, therefore the List<?> argument
-	protected void maybeCallbackBeforeConvertWithQueries(List<?> queries) {
+	protected void maybeCallbackBeforeConvertWithQueries(List<?> queries, IndexCoordinates index) {
-		queries.forEach(this::maybeCallbackBeforeConvertWithQuery);
+		queries.forEach(query -> maybeCallbackBeforeConvertWithQuery(query, index));
 	}
 
-	protected <T> T maybeCallbackAfterSave(T entity) {
+	protected <T> T maybeCallbackAfterSave(T entity, IndexCoordinates index) {
 
 		if (entityCallbacks != null) {
-			return entityCallbacks.callback(AfterSaveCallback.class, entity);
+			return entityCallbacks.callback(AfterSaveCallback.class, entity, index);
 		}
 
 		return entity;
 	}
 
-	protected void maybeCallbackAfterSaveWithQuery(Object query) {
+	protected void maybeCallbackAfterSaveWithQuery(Object query, IndexCoordinates index) {
 
 		if (query instanceof IndexQuery) {
 			IndexQuery indexQuery = (IndexQuery) query;
 			Object queryObject = indexQuery.getObject();
 
 			if (queryObject != null) {
-				queryObject = maybeCallbackAfterSave(queryObject);
+				queryObject = maybeCallbackAfterSave(queryObject, index);
 				indexQuery.setObject(queryObject);
 			}
 		}
@@ -515,8 +515,8 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
 
 	// this can be called with either a List<IndexQuery> or a List<UpdateQuery>; these query classes
 	// don't have a common base class, therefore the List<?> argument
-	protected void maybeCallbackAfterSaveWithQueries(List<?> queries) {
+	protected void maybeCallbackAfterSaveWithQueries(List<?> queries, IndexCoordinates index) {
-		queries.forEach(this::maybeCallbackAfterSaveWithQuery);
+		queries.forEach(query -> maybeCallbackAfterSaveWithQuery(query, index));
 	}
 
 	protected <T> T maybeCallbackAfterConvert(T entity, Document document, IndexCoordinates index) {

src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchRestTemplate.java

@@ -136,7 +136,7 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate {
 	@Override
 	public String index(IndexQuery query, IndexCoordinates index) {
 
-		maybeCallbackBeforeConvertWithQuery(query);
+		maybeCallbackBeforeConvertWithQuery(query, index);
 
 		IndexRequest request = requestFactory.indexRequest(query, index);
 		String documentId = execute(client -> client.index(request, RequestOptions.DEFAULT).getId());
@@ -147,7 +147,7 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate {
 			setPersistentEntityId(queryObject, documentId);
 		}
 
-		maybeCallbackAfterSaveWithQuery(query);
+		maybeCallbackAfterSaveWithQuery(query, index);
 
 		return documentId;
 	}
@@ -232,11 +232,11 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate {
 	}
 
 	private List<String> doBulkOperation(List<?> queries, BulkOptions bulkOptions, IndexCoordinates index) {
-		maybeCallbackBeforeConvertWithQueries(queries);
+		maybeCallbackBeforeConvertWithQueries(queries, index);
 		BulkRequest bulkRequest = requestFactory.bulkRequest(queries, bulkOptions, index);
 		List<String> ids = checkForBulkOperationFailure(
 				execute(client -> client.bulk(bulkRequest, RequestOptions.DEFAULT)));
-		maybeCallbackAfterSaveWithQueries(queries);
+		maybeCallbackAfterSaveWithQueries(queries, index);
 		return ids;
 	}
 	// endregion

src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplate.java

@@ -142,7 +142,7 @@ public class ElasticsearchTemplate extends AbstractElasticsearchTemplate {
 	@Override
 	public String index(IndexQuery query, IndexCoordinates index) {
 
-		maybeCallbackBeforeConvertWithQuery(query);
+		maybeCallbackBeforeConvertWithQuery(query, index);
 
 		IndexRequestBuilder indexRequestBuilder = requestFactory.indexRequestBuilder(client, query, index);
 		String documentId = indexRequestBuilder.execute().actionGet().getId();
@@ -153,7 +153,7 @@ public class ElasticsearchTemplate extends AbstractElasticsearchTemplate {
 			setPersistentEntityId(queryObject, documentId);
 		}
 
-		maybeCallbackAfterSaveWithQuery(query);
+		maybeCallbackAfterSaveWithQuery(query, index);
 
 		return documentId;
 	}
@@ -196,7 +196,7 @@ public class ElasticsearchTemplate extends AbstractElasticsearchTemplate {
 
 		List<String> ids = doBulkOperation(queries, bulkOptions, index);
 
-		maybeCallbackAfterSaveWithQueries(queries);
+		maybeCallbackAfterSaveWithQueries(queries, index);
 
 		return ids;
 	}
@@ -245,7 +245,7 @@ public class ElasticsearchTemplate extends AbstractElasticsearchTemplate {
 	}
 
 	private List<String> doBulkOperation(List<?> queries, BulkOptions bulkOptions, IndexCoordinates index) {
-		maybeCallbackBeforeConvertWithQueries(queries);
+		maybeCallbackBeforeConvertWithQueries(queries, index);
 		BulkRequestBuilder bulkRequest = requestFactory.bulkRequestBuilder(client, queries, bulkOptions, index);
 		return checkForBulkOperationFailure(bulkRequest.execute().actionGet());
 	}

src/main/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplate.java

@@ -19,12 +19,12 @@ import static org.elasticsearch.index.VersionType.*;
 
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+import reactor.util.function.Tuple2;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -187,12 +187,15 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera
 
 		Assert.notNull(entity, "Entity must not be null!");
 
-		AdaptibleEntity<T> adaptableEntity = operations.forEntity(entity, converter.getConversionService());
+		return maybeCallBeforeConvert(entity, index)
-
+				.flatMap(entityAfterBeforeConversionCallback -> doIndex(entityAfterBeforeConversionCallback, index)) //
-		return doIndex(entity, adaptableEntity, index) //
 				.map(it -> {
-					return adaptableEntity.populateIdIfNecessary(it.getId());
+					T savedEntity = it.getT1();
-				}).flatMap(this::maybeCallAfterSave);
+					IndexResponse indexResponse = it.getT2();
+					AdaptibleEntity<T> adaptableEntity = operations.forEntity(savedEntity, converter.getConversionService());
+					return adaptableEntity.populateIdIfNecessary(indexResponse.getId());
+				})
+				.flatMap(saved -> maybeCallAfterSave(saved, index));
 	}
 
 	@Override
@@ -201,32 +204,35 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera
 	}
 
 	@Override
-	public <T> Flux<T> saveAll(Mono<? extends Collection<? extends T>> entities, IndexCoordinates index) {
+	public <T> Flux<T> saveAll(Mono<? extends Collection<? extends T>> entitiesPublisher, IndexCoordinates index) {
 
-		Assert.notNull(entities, "Entities must not be null!");
+		Assert.notNull(entitiesPublisher, "Entities must not be null!");
 
-		return entities.flatMapMany(entityList -> {
+		return entitiesPublisher
+				.flatMapMany(entities -> {
+					return Flux.fromIterable(entities) //
+							.concatMap(entity -> maybeCallBeforeConvert(entity, index));
+				})
+				.collectList()
+				.map(Entities::new)
+				.flatMapMany(entities -> {
+					if (entities.isEmpty()) {
+						return Flux.empty();
+					}
 
-			List<AdaptibleEntity<? extends T>> adaptibleEntities = entityList.stream() //
+					return doBulkOperation(entities.indexQueries(), BulkOptions.defaultOptions(), index) //
-					.map(e -> operations.forEntity(e, converter.getConversionService())) //
+							.index()
-					.collect(Collectors.toList());
+							.flatMap(indexAndResponse -> {
+								T savedEntity = entities.entityAt(indexAndResponse.getT1());
+								BulkItemResponse bulkItemResponse = indexAndResponse.getT2();
 
-			if (adaptibleEntities.isEmpty()) {
+								AdaptibleEntity<T> adaptibleEntity = operations.forEntity(savedEntity,
-				return Flux.empty();
+										converter.getConversionService());
-			}
+								adaptibleEntity.populateIdIfNecessary(bulkItemResponse.getResponse().getId());
 
-			Iterator<AdaptibleEntity<? extends T>> iterator = adaptibleEntities.iterator();
+								return maybeCallAfterSave(savedEntity, index);
-			List<IndexQuery> indexRequests = adaptibleEntities.stream() //
+							});
-					.map(e -> getIndexQuery(e.getBean(), e)) //
+				});
-					.collect(Collectors.toList());
-			return doBulkOperation(indexRequests, BulkOptions.defaultOptions(), index) //
-					.flatMap(bulkItemResponse -> {
-
-						AdaptibleEntity<? extends T> mappedEntity = iterator.next();
-						mappedEntity.populateIdIfNecessary(bulkItemResponse.getResponse().getId());
-						return maybeCallAfterSave(mappedEntity.getBean());
-					});
-		});
 	}
 
 	@Override
@@ -332,13 +338,12 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera
 				.onErrorReturn(NoSuchIndexException.class, false);
 	}
 
-	private Mono<IndexResponse> doIndex(Object value, AdaptibleEntity<?> entity, IndexCoordinates index) {
+	private <T> Mono<Tuple2<T, IndexResponse>> doIndex(T entity, IndexCoordinates index) {
 
-		return maybeCallBeforeConvert(value).flatMap(it -> {
+		AdaptibleEntity<?> adaptibleEntity = operations.forEntity(entity, converter.getConversionService());
-			IndexRequest request = getIndexRequest(value, entity, index);
+		IndexRequest request = getIndexRequest(entity, adaptibleEntity, index);
-			request = prepareIndexRequest(value, request);
+		request = prepareIndexRequest(entity, request);
-			return doIndex(request);
+		return Mono.just(entity).zipWith(doIndex(request));
-		});
 	}
 
 	private IndexRequest getIndexRequest(Object value, AdaptibleEntity<?> entity, IndexCoordinates index) {
@@ -361,7 +366,9 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera
 		return request;
 	}
 
-	private IndexQuery getIndexQuery(Object value, AdaptibleEntity<?> entity) {
+	private IndexQuery getIndexQuery(Object value) {
+		AdaptibleEntity<?> entity = operations.forEntity(value, converter.getConversionService());
+
 		Object id = entity.getId();
 		IndexQuery query = new IndexQuery();
 		if (id != null) {
@@ -912,19 +919,19 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera
 	}
 
 	// region callbacks
-	protected <T> Mono<T> maybeCallBeforeConvert(T entity) {
+	protected <T> Mono<T> maybeCallBeforeConvert(T entity, IndexCoordinates index) {
 
 		if (null != entityCallbacks) {
-			return entityCallbacks.callback(ReactiveBeforeConvertCallback.class, entity);
+			return entityCallbacks.callback(ReactiveBeforeConvertCallback.class, entity, index);
 		}
 
 		return Mono.just(entity);
 	}
 
-	protected <T> Mono<T> maybeCallAfterSave(T entity) {
+	protected <T> Mono<T> maybeCallAfterSave(T entity, IndexCoordinates index) {
 
 		if (null != entityCallbacks) {
-			return entityCallbacks.callback(ReactiveAfterSaveCallback.class, entity);
+			return entityCallbacks.callback(ReactiveAfterSaveCallback.class, entity, index);
 		}
 
 		return Mono.just(entity);
@@ -995,4 +1002,30 @@ public class ReactiveElasticsearchTemplate implements ReactiveElasticsearchOpera
 					.map(entity -> SearchHitMapping.mappingFor(type, converter.getMappingContext()).mapHit(response, entity));
 		}
 	}
+
+	private class Entities<T> {
+		private final List<T> entities;
+
+		private Entities(List<T> entities) {
+			Assert.notNull(entities, "entities cannot be null");
+
+			this.entities = entities;
+		}
+
+		private boolean isEmpty() {
+			return entities.isEmpty();
+		}
+
+		private List<IndexQuery> indexQueries() {
+			return entities.stream()
+					.map(ReactiveElasticsearchTemplate.this::getIndexQuery)
+					.collect(Collectors.toList());
+		}
+
+		private T entityAt(long index) {
+			// it's safe to cast to int because the original indexed colleciton was fitting in memory
+			int intIndex = (int) index;
+			return entities.get(intIndex);
+		}
+	}
 }

src/main/java/org/springframework/data/elasticsearch/core/event/AfterSaveCallback.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.elasticsearch.core.event;
 
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.mapping.callback.EntityCallback;
 import org.springframework.data.mapping.callback.EntityCallbacks;
 
@@ -33,7 +34,8 @@ public interface AfterSaveCallback<T> extends EntityCallback<T> {
 	 * the domain object.
 	 *
 	 * @param entity the domain object that was saved.
+	 * @param index must not be {@literal null}.
 	 * @return the domain object that was persisted.
 	 */
-	T onAfterSave(T entity);
+	T onAfterSave(T entity, IndexCoordinates index);
 }

src/main/java/org/springframework/data/elasticsearch/core/event/AuditingEntityCallback.java

@@ -18,6 +18,7 @@ package org.springframework.data.elasticsearch.core.event;
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.core.Ordered;
 import org.springframework.data.auditing.IsNewAwareAuditingHandler;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.mapping.callback.EntityCallback;
 import org.springframework.util.Assert;
 
@@ -25,6 +26,7 @@ import org.springframework.util.Assert;
  * {@link EntityCallback} to populate auditing related fields on an entity about to be saved.
  *
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  * @since 4.0
  */
 public class AuditingEntityCallback implements BeforeConvertCallback<Object>, Ordered {
@@ -45,7 +47,7 @@ public class AuditingEntityCallback implements BeforeConvertCallback<Object>, Or
 	}
 
 	@Override
-	public Object onBeforeConvert(Object entity) {
+	public Object onBeforeConvert(Object entity, IndexCoordinates index) {
 		return auditingHandlerFactory.getObject().markAudited(entity);
 	}
 

src/main/java/org/springframework/data/elasticsearch/core/event/BeforeConvertCallback.java

@@ -15,12 +15,14 @@
  */
 package org.springframework.data.elasticsearch.core.event;
 
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.mapping.callback.EntityCallback;
 
 /**
  * Callback being invoked before a domain object is converted to be persisted.
  *
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  * @since 4.0
  */
 @FunctionalInterface
@@ -31,7 +33,8 @@ public interface BeforeConvertCallback<T> extends EntityCallback<T> {
 	 * the domain entity class.
 	 * 
 	 * @param entity the entity being converted
+	 * @param index must not be {@literal null}.
 	 * @return the entity to be converted
 	 */
-	T onBeforeConvert(T entity);
+	T onBeforeConvert(T entity, IndexCoordinates index);
 }

src/main/java/org/springframework/data/elasticsearch/core/event/ReactiveAfterSaveCallback.java

@@ -16,6 +16,7 @@
 package org.springframework.data.elasticsearch.core.event;
 
 import org.reactivestreams.Publisher;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.mapping.callback.EntityCallback;
 import org.springframework.data.mapping.callback.ReactiveEntityCallbacks;
 
@@ -34,7 +35,8 @@ public interface ReactiveAfterSaveCallback<T> extends EntityCallback<T> {
 	 * the domain object.
 	 *
 	 * @param entity the domain object that was saved.
+	 * @param index must not be {@literal null}.
 	 * @return a {@link Publisher} emitting the domain object to be returned to the caller.
 	 */
-	Publisher<T> onAfterSave(T entity);
+	Publisher<T> onAfterSave(T entity, IndexCoordinates index);
 }

src/main/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallback.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.elasticsearch.core.event;
 
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import reactor.core.publisher.Mono;
 
 import org.springframework.beans.factory.ObjectFactory;
@@ -27,6 +28,7 @@ import org.springframework.util.Assert;
  * {@link EntityCallback} to populate auditing related fields on an entity about to be saved.
  *
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  * @since 4.0
  */
 public class ReactiveAuditingEntityCallback implements ReactiveBeforeConvertCallback<Object>, Ordered {
@@ -47,7 +49,7 @@ public class ReactiveAuditingEntityCallback implements ReactiveBeforeConvertCall
 	}
 
 	@Override
-	public Mono<Object> onBeforeConvert(Object entity) {
+	public Mono<Object> onBeforeConvert(Object entity, IndexCoordinates index) {
 		return Mono.just(auditingHandlerFactory.getObject().markAudited(entity));
 	}
 

src/main/java/org/springframework/data/elasticsearch/core/event/ReactiveBeforeConvertCallback.java

@@ -16,12 +16,14 @@
 package org.springframework.data.elasticsearch.core.event;
 
 import org.reactivestreams.Publisher;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.mapping.callback.EntityCallback;
 
 /**
  * Callback being invoked before a domain object is converted to be persisted.
  *
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  * @since 4.0
  */
 @FunctionalInterface
@@ -32,7 +34,8 @@ public interface ReactiveBeforeConvertCallback<T> extends EntityCallback<T> {
 	 * the domain entity class.
 	 * 
 	 * @param entity the entity being converted
+	 * @param index must not be {@literal null}.
 	 * @return the entity to be converted
 	 */
-	Publisher<T> onBeforeConvert(T entity);
+	Publisher<T> onBeforeConvert(T entity, IndexCoordinates index);
 }

src/test/java/org/springframework/data/elasticsearch/config/AuditingIntegrationTest.java

@@ -31,12 +31,14 @@ import org.springframework.data.annotation.LastModifiedDate;
 import org.springframework.data.domain.AuditorAware;
 import org.springframework.data.domain.Persistable;
 import org.springframework.data.elasticsearch.core.event.BeforeConvertCallback;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
 import org.springframework.data.mapping.callback.EntityCallbacks;
 import org.springframework.lang.Nullable;
 
 /**
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  */
 public abstract class AuditingIntegrationTest {
 
@@ -64,7 +66,7 @@ public abstract class AuditingIntegrationTest {
 
 		Entity entity = new Entity();
 		entity.setId("1");
-		entity = callbacks.callback(BeforeConvertCallback.class, entity);
+		entity = callbacks.callback(BeforeConvertCallback.class, entity, IndexCoordinates.of("index"));
 
 		assertThat(entity.getCreated()).isNotNull();
 		assertThat(entity.getModified()).isEqualTo(entity.created);
@@ -73,7 +75,7 @@ public abstract class AuditingIntegrationTest {
 
 		Thread.sleep(10);
 
-		entity = callbacks.callback(BeforeConvertCallback.class, entity);
+		entity = callbacks.callback(BeforeConvertCallback.class, entity, IndexCoordinates.of("index"));
 
 		assertThat(entity.getCreated()).isNotNull();
 		assertThat(entity.getModified()).isNotEqualTo(entity.created);

src/test/java/org/springframework/data/elasticsearch/config/ReactiveAuditingIntegrationTest.java

@@ -33,6 +33,7 @@ import org.springframework.data.annotation.LastModifiedDate;
 import org.springframework.data.domain.AuditorAware;
 import org.springframework.data.domain.Persistable;
 import org.springframework.data.elasticsearch.core.event.ReactiveBeforeConvertCallback;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
 import org.springframework.data.elasticsearch.junit.jupiter.ReactiveElasticsearchRestTemplateConfiguration;
 import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
@@ -42,6 +43,7 @@ import org.springframework.test.context.ContextConfiguration;
 
 /**
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  */
 @SpringIntegrationTest
 @ContextConfiguration(classes = { ReactiveAuditingIntegrationTest.Config.class })
@@ -81,7 +83,7 @@ public class ReactiveAuditingIntegrationTest {
 
 		Entity entity = new Entity();
 		entity.setId("1");
-		entity = callbacks.callback(ReactiveBeforeConvertCallback.class, entity).block();
+		entity = callbacks.callback(ReactiveBeforeConvertCallback.class, entity, IndexCoordinates.of("index")).block();
 
 		assertThat(entity.getCreated()).isNotNull();
 		assertThat(entity.getModified()).isEqualTo(entity.created);
@@ -90,7 +92,7 @@ public class ReactiveAuditingIntegrationTest {
 
 		Thread.sleep(10);
 
-		entity = callbacks.callback(ReactiveBeforeConvertCallback.class, entity).block();
+		entity = callbacks.callback(ReactiveBeforeConvertCallback.class, entity, IndexCoordinates.of("index")).block();
 
 		assertThat(entity.getCreated()).isNotNull();
 		assertThat(entity.getModified()).isNotEqualTo(entity.created);

src/test/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplateCallbackTests.java

@@ -40,6 +40,7 @@ import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
 import org.springframework.data.elasticsearch.core.document.Document;
 import org.springframework.data.elasticsearch.core.event.AfterConvertCallback;
 import org.springframework.data.elasticsearch.core.event.AfterSaveCallback;
+import org.springframework.data.elasticsearch.core.event.BeforeConvertCallback;
 import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.elasticsearch.core.query.BulkOptions;
 import org.springframework.data.elasticsearch.core.query.GetQuery;
@@ -66,11 +67,10 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 
 	@Spy private ValueCapturingAfterSaveCallback afterSaveCallback = new ValueCapturingAfterSaveCallback();
 	@Spy private ValueCapturingAfterConvertCallback afterConvertCallback = new ValueCapturingAfterConvertCallback();
+	@Spy private ValueCapturingBeforeConvertCallback beforeConvertCallback = new ValueCapturingBeforeConvertCallback();
 
 	protected final void initTemplate(AbstractElasticsearchTemplate template) {
 		this.template = template;
-
-		this.template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback, afterConvertCallback));
 	}
 
 	protected final org.elasticsearch.search.SearchHits nSearchHits(int count) {
@@ -82,78 +82,90 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 	@Test // DATAES-771
 	void saveOneShouldInvokeAfterSaveCallbacks() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
+
 		Person entity = new Person("init", "luke");
 
 		Person saved = template.save(entity);
 
-		verify(afterSaveCallback).onAfterSave(eq(entity));
+		verify(afterSaveCallback).onAfterSave(eq(entity), any());
-		assertThat(saved.id).isEqualTo("after-save");
+		assertThat(saved.firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveWithIndexCoordinatesShouldInvokeAfterSaveCallbacks() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
+
 		Person entity = new Person("init", "luke");
 
 		Person saved = template.save(entity, index);
 
-		verify(afterSaveCallback).onAfterSave(eq(entity));
+		verify(afterSaveCallback).onAfterSave(eq(entity), eq(index));
-		assertThat(saved.id).isEqualTo("after-save");
+		assertThat(saved.firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveArrayShouldInvokeAfterSaveCallbacks() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
+
 		Person entity1 = new Person("init1", "luke1");
 		Person entity2 = new Person("init2", "luke2");
 
 		Iterable<Person> saved = template.save(entity1, entity2);
 
-		verify(afterSaveCallback, times(2)).onAfterSave(any());
+		verify(afterSaveCallback, times(2)).onAfterSave(any(), any());
 		Iterator<Person> savedIterator = saved.iterator();
-		assertThat(savedIterator.next().getId()).isEqualTo("after-save");
+		assertThat(savedIterator.next().firstname).isEqualTo("after-save");
-		assertThat(savedIterator.next().getId()).isEqualTo("after-save");
+		assertThat(savedIterator.next().firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveIterableShouldInvokeAfterSaveCallbacks() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
+
 		Person entity1 = new Person("init1", "luke1");
 		Person entity2 = new Person("init2", "luke2");
 
 		Iterable<Person> saved = template.save(Arrays.asList(entity1, entity2));
 
-		verify(afterSaveCallback, times(2)).onAfterSave(any());
+		verify(afterSaveCallback, times(2)).onAfterSave(any(), any());
 		Iterator<Person> savedIterator = saved.iterator();
-		assertThat(savedIterator.next().getId()).isEqualTo("after-save");
+		assertThat(savedIterator.next().firstname).isEqualTo("after-save");
-		assertThat(savedIterator.next().getId()).isEqualTo("after-save");
+		assertThat(savedIterator.next().firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveIterableWithIndexCoordinatesShouldInvokeAfterSaveCallbacks() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
+
 		Person entity1 = new Person("init1", "luke1");
 		Person entity2 = new Person("init2", "luke2");
 
 		Iterable<Person> saved = template.save(Arrays.asList(entity1, entity2), index);
 
-		verify(afterSaveCallback, times(2)).onAfterSave(any());
+		verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
 		Iterator<Person> savedIterator = saved.iterator();
-		assertThat(savedIterator.next().getId()).isEqualTo("after-save");
+		assertThat(savedIterator.next().firstname).isEqualTo("after-save");
-		assertThat(savedIterator.next().getId()).isEqualTo("after-save");
+		assertThat(savedIterator.next().firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void indexShouldInvokeAfterSaveCallbacks() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
+
 		Person entity = new Person("init", "luke");
 
 		IndexQuery indexQuery = indexQueryForEntity(entity);
 		template.index(indexQuery, index);
 
-		verify(afterSaveCallback).onAfterSave(eq(entity));
+		verify(afterSaveCallback).onAfterSave(eq(entity), eq(index));
 		Person savedPerson = (Person) indexQuery.getObject();
-		assertThat(savedPerson.id).isEqualTo("after-save");
+		assertThat(savedPerson.firstname).isEqualTo("after-save");
 	}
 
 	private IndexQuery indexQueryForEntity(Person entity) {
@@ -165,6 +177,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 	@Test // DATAES-771
 	void bulkIndexShouldInvokeAfterSaveCallbacks() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
+
 		Person entity1 = new Person("init1", "luke1");
 		Person entity2 = new Person("init2", "luke2");
 
@@ -172,16 +186,18 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 		IndexQuery query2 = indexQueryForEntity(entity2);
 		template.bulkIndex(Arrays.asList(query1, query2), index);
 
-		verify(afterSaveCallback, times(2)).onAfterSave(any());
+		verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
 		Person savedPerson1 = (Person) query1.getObject();
 		Person savedPerson2 = (Person) query2.getObject();
-		assertThat(savedPerson1.getId()).isEqualTo("after-save");
+		assertThat(savedPerson1.firstname).isEqualTo("after-save");
-		assertThat(savedPerson2.getId()).isEqualTo("after-save");
+		assertThat(savedPerson2.firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void bulkIndexWithOptionsShouldInvokeAfterSaveCallbacks() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
+
 		Person entity1 = new Person("init1", "luke1");
 		Person entity2 = new Person("init2", "luke2");
 
@@ -189,20 +205,22 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 		IndexQuery query2 = indexQueryForEntity(entity2);
 		template.bulkIndex(Arrays.asList(query1, query2), BulkOptions.defaultOptions(), index);
 
-		verify(afterSaveCallback, times(2)).onAfterSave(any());
+		verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
 		Person savedPerson1 = (Person) query1.getObject();
 		Person savedPerson2 = (Person) query2.getObject();
-		assertThat(savedPerson1.getId()).isEqualTo("after-save");
+		assertThat(savedPerson1.firstname).isEqualTo("after-save");
-		assertThat(savedPerson2.getId()).isEqualTo("after-save");
+		assertThat(savedPerson2.firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-772
 	void getShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		Person result = template.get("init", Person.class);
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(result.id).isEqualTo("after-convert");
+		assertThat(result.firstname).isEqualTo("after-convert");
 	}
 
 	private Document lukeDocument() {
@@ -212,31 +230,37 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 	@Test // DATAES-772
 	void getWithCoordinatesShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		Person result = template.get("init", Person.class, index);
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
-		assertThat(result.id).isEqualTo("after-convert");
+		assertThat(result.firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void getViaQueryShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		@SuppressWarnings("deprecation") // we know what we test
 		Person result = template.get(new GetQuery("init"), Person.class, index);
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
-		assertThat(result.id).isEqualTo("after-convert");
+		assertThat(result.firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void multiGetShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		List<Person> results = template.multiGet(queryForTwo(), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.get(0).id).isEqualTo("after-convert");
+		assertThat(results.get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).id).isEqualTo("after-convert");
+		assertThat(results.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	private Query queryForTwo() {
@@ -246,13 +270,15 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 	@Test // DATAES-772
 	void queryForObjectShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		doReturn(nSearchHits(1)).when(searchResponse).getHits();
 
 		@SuppressWarnings("deprecation") // we know what we test
 		Person result = template.queryForObject(queryForOne(), Person.class, index);
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
-		assertThat(result.id).isEqualTo("after-convert");
+		assertThat(result.firstname).isEqualTo("after-convert");
 	}
 
 	private Query queryForOne() {
@@ -262,31 +288,37 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 	@Test // DATAES-772
 	void queryForPageShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		@SuppressWarnings("deprecation") // we know what we test
 		AggregatedPage<Person> results = template.queryForPage(queryForTwo(), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.getContent().get(0).id).isEqualTo("after-convert");
+		assertThat(results.getContent().get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.getContent().get(1).id).isEqualTo("after-convert");
+		assertThat(results.getContent().get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void queryForPageWithMultipleQueriesAndSameEntityClassShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		@SuppressWarnings("deprecation") // we know what we test
 		List<Page<Person>> results = template.queryForPage(singletonList(queryForTwo()), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
 		List<Person> persons = results.get(0).getContent();
-		assertThat(persons.get(0).id).isEqualTo("after-convert");
+		assertThat(persons.get(0).firstname).isEqualTo("after-convert");
-		assertThat(persons.get(1).id).isEqualTo("after-convert");
+		assertThat(persons.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void queryForPageWithMultipleQueriesAndEntityClassesShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		@SuppressWarnings("deprecation") // we know what we test
 		List<AggregatedPage<?>> results = template.queryForPage(singletonList(queryForTwo()), singletonList(Person.class),
 				index);
@@ -294,29 +326,33 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
 		List<Person> persons = results.get(0).getContent().stream().map(Person.class::cast).collect(Collectors.toList());
-		assertThat(persons.get(0).id).isEqualTo("after-convert");
+		assertThat(persons.get(0).firstname).isEqualTo("after-convert");
-		assertThat(persons.get(1).id).isEqualTo("after-convert");
+		assertThat(persons.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void streamShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		CloseableIterator<Person> results = template.stream(queryForTwo(), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.next().id).isEqualTo("after-convert");
+		assertThat(results.next().firstname).isEqualTo("after-convert");
-		assertThat(results.next().id).isEqualTo("after-convert");
+		assertThat(results.next().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchScrollContinueShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		CloseableIterator<Person> results = template.stream(queryForTwo(), Person.class, index);
 
 		skipItemsFromScrollStart(results);
-		assertThat(results.next().id).isEqualTo("after-convert");
+		assertThat(results.next().firstname).isEqualTo("after-convert");
-		assertThat(results.next().id).isEqualTo("after-convert");
+		assertThat(results.next().firstname).isEqualTo("after-convert");
 
 		verify(afterConvertCallback, times(4)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
@@ -330,51 +366,59 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 	@Test // DATAES-772
 	void queryForListShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		@SuppressWarnings("deprecation") // we know what we test
 		List<Person> results = template.queryForList(queryForTwo(), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.get(0).id).isEqualTo("after-convert");
+		assertThat(results.get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).id).isEqualTo("after-convert");
+		assertThat(results.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void queryForListWithMultipleQueriesAndSameEntityClassShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		@SuppressWarnings("deprecation") // we know what we test
 		List<List<Person>> results = template.queryForList(singletonList(queryForTwo()), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
 		List<Person> persons = results.get(0);
-		assertThat(persons.get(0).id).isEqualTo("after-convert");
+		assertThat(persons.get(0).firstname).isEqualTo("after-convert");
-		assertThat(persons.get(1).id).isEqualTo("after-convert");
+		assertThat(persons.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void queryForListWithMultipleQueriesAndEntityClassesShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		@SuppressWarnings("deprecation") // we know what we test
 		List<List<?>> results = template.queryForList(singletonList(queryForTwo()), singletonList(Person.class), index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
 		List<Person> persons = results.get(0).stream().map(Person.class::cast).collect(Collectors.toList());
-		assertThat(persons.get(0).id).isEqualTo("after-convert");
+		assertThat(persons.get(0).firstname).isEqualTo("after-convert");
-		assertThat(persons.get(1).id).isEqualTo("after-convert");
+		assertThat(persons.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void moreLikeThisShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		@SuppressWarnings("deprecation") // we know what we test
 		AggregatedPage<Person> results = template.moreLikeThis(moreLikeThisQuery(), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.getContent().get(0).id).isEqualTo("after-convert");
+		assertThat(results.getContent().get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.getContent().get(1).id).isEqualTo("after-convert");
+		assertThat(results.getContent().get(1).firstname).isEqualTo("after-convert");
 	}
 
 	private MoreLikeThisQuery moreLikeThisQuery() {
@@ -387,115 +431,164 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 	@Test // DATAES-772
 	void searchOneShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		doReturn(nSearchHits(1)).when(searchResponse).getHits();
 
 		SearchHit<Person> result = template.searchOne(queryForOne(), Person.class);
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(result.getContent().id).isEqualTo("after-convert");
+		assertThat(result.getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchOneWithIndexCoordinatesShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		doReturn(nSearchHits(1)).when(searchResponse).getHits();
 
 		SearchHit<Person> result = template.searchOne(queryForOne(), Person.class, index);
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
-		assertThat(result.getContent().id).isEqualTo("after-convert");
+		assertThat(result.getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void multiSearchShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		List<SearchHits<Person>> results = template.multiSearch(singletonList(queryForTwo()), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
 		List<SearchHit<Person>> hits = results.get(0).getSearchHits();
-		assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void multiSearchWithMultipleEntityClassesShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		List<SearchHits<?>> results = template.multiSearch(singletonList(queryForTwo()), singletonList(Person.class),
 				index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
 		List<? extends SearchHit<?>> hits = results.get(0).getSearchHits();
-		assertThat(((Person) hits.get(0).getContent()).id).isEqualTo("after-convert");
+		assertThat(((Person) hits.get(0).getContent()).firstname).isEqualTo("after-convert");
-		assertThat(((Person) hits.get(1).getContent()).id).isEqualTo("after-convert");
+		assertThat(((Person) hits.get(1).getContent()).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		SearchHits<Person> results = template.search(queryForTwo(), Person.class);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
 		List<SearchHit<Person>> hits = results.getSearchHits();
-		assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchWithIndexCoordinatesShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		SearchHits<Person> results = template.search(queryForTwo(), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
 		List<SearchHit<Person>> hits = results.getSearchHits();
-		assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchViaMoreLikeThisShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		SearchHits<Person> results = template.search(moreLikeThisQuery(), Person.class);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
 		List<SearchHit<Person>> hits = results.getSearchHits();
-		assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchViaMoreLikeThisWithIndexCoordinatesShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		SearchHits<Person> results = template.search(moreLikeThisQuery(), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
 		List<SearchHit<Person>> hits = results.getSearchHits();
-		assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchForStreamShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		SearchHitsIterator<Person> results = template.searchForStream(queryForTwo(), Person.class);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(results.next().getContent().id).isEqualTo("after-convert");
+		assertThat(results.next().getContent().firstname).isEqualTo("after-convert");
-		assertThat(results.next().getContent().id).isEqualTo("after-convert");
+		assertThat(results.next().getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchForStreamWithIndexCoordinatesShouldInvokeAfterConvertCallback() {
 
+		template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
+
 		SearchHitsIterator<Person> results = template.searchForStream(queryForTwo(), Person.class, index);
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.next().getContent().id).isEqualTo("after-convert");
+		assertThat(results.next().getContent().firstname).isEqualTo("after-convert");
-		assertThat(results.next().getContent().id).isEqualTo("after-convert");
+		assertThat(results.next().getContent().firstname).isEqualTo("after-convert");
+	}
+
+	@Test // DATAES-785
+	void saveOneShouldInvokeBeforeConvertCallbacks() {
+
+		template.setEntityCallbacks(EntityCallbacks.create(beforeConvertCallback));
+
+		Person entity = new Person("init1", "luke1");
+
+		Person saved = template.save(entity, index);
+
+		verify(beforeConvertCallback).onBeforeConvert(any(), eq(index));
+		assertThat(saved.firstname).isEqualTo("before-convert");
+	}
+
+	@Test // DATAES-785
+	void saveAllShouldInvokeBeforeConvertCallbacks() {
+
+		template.setEntityCallbacks(EntityCallbacks.create(beforeConvertCallback));
+
+		Person entity1 = new Person("init1", "luke1");
+		Person entity2 = new Person("init2", "luke2");
+
+		Iterable<Person> saved = template.save(Arrays.asList(entity1, entity2), index);
+
+		verify(beforeConvertCallback, times(2)).onBeforeConvert(any(), eq(index));
+		Iterator<Person> iterator = saved.iterator();
+		assertThat(iterator.next().firstname).isEqualTo("before-convert");
+		assertThat(iterator.next().firstname).isEqualTo("before-convert");
 	}
 
 	@Data
@@ -530,13 +623,13 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 			implements AfterSaveCallback<Person> {
 
 		@Override
-		public Person onAfterSave(Person entity) {
+		public Person onAfterSave(Person entity, IndexCoordinates index) {
 
 			capture(entity);
 			return new Person() {
 				{
-					id = "after-save";
+					id = entity.id;
-					firstname = entity.firstname;
+					firstname = "after-save";
 				}
 			};
 		}
@@ -551,8 +644,24 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
 			capture(entity);
 			return new Person() {
 				{
-					id = "after-convert";
+					id = entity.id;
-					firstname = entity.firstname;
+					firstname = "after-convert";
+				}
+			};
+		}
+	}
+
+	static class ValueCapturingBeforeConvertCallback extends ValueCapturingEntityCallback<Person>
+			implements BeforeConvertCallback<Person> {
+
+		@Override
+		public Person onBeforeConvert(Person entity, IndexCoordinates indexCoordinates) {
+
+			capture(entity);
+			return new Person() {
+				{
+					id = entity.id;
+					firstname = "before-convert";
 				}
 			};
 		}

src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateCallbackTests.java

@@ -46,6 +46,7 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
+import org.mockito.Spy;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
 import org.mockito.quality.Strictness;
@@ -55,6 +56,7 @@ import org.springframework.data.elasticsearch.client.reactive.ReactiveElasticsea
 import org.springframework.data.elasticsearch.core.document.Document;
 import org.springframework.data.elasticsearch.core.event.ReactiveAfterConvertCallback;
 import org.springframework.data.elasticsearch.core.event.ReactiveAfterSaveCallback;
+import org.springframework.data.elasticsearch.core.event.ReactiveBeforeConvertCallback;
 import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
 import org.springframework.data.elasticsearch.core.query.Query;
@@ -82,6 +84,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 
 	private final IndexCoordinates index = IndexCoordinates.of("index");
 
+	@Spy private ValueCapturingAfterSaveCallback afterSaveCallback = new ValueCapturingAfterSaveCallback();
+	@Spy private ValueCapturingAfterConvertCallback afterConvertCallback = new ValueCapturingAfterConvertCallback();
+	@Spy private ValueCapturingBeforeConvertCallback beforeConvertCallback = new ValueCapturingBeforeConvertCallback();
+
 	@BeforeEach
 	public void setUp() {
 		template = new ReactiveElasticsearchTemplate(client);
@@ -122,104 +128,90 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 	@Test // DATAES-771
 	void saveOneShouldInvokeAfterSaveCallbacks() {
 
-		ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
 
 		Person entity = new Person("init", "luke");
 
 		Person saved = template.save(entity).block(Duration.ofSeconds(1));
 
-		verify(afterSaveCallback).onAfterSave(eq(entity));
+		verify(afterSaveCallback).onAfterSave(eq(entity), any());
-		assertThat(saved.id).isEqualTo("after-save");
+		assertThat(saved.firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveOneFromPublisherShouldInvokeAfterSaveCallbacks() {
 
-		ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
 
 		Person entity = new Person("init", "luke");
 
 		Person saved = template.save(Mono.just(entity)).block(Duration.ofSeconds(1));
 
-		verify(afterSaveCallback).onAfterSave(eq(entity));
+		verify(afterSaveCallback).onAfterSave(eq(entity), any());
-		assertThat(saved.id).isEqualTo("after-save");
+		assertThat(saved.firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveWithIndexCoordinatesShouldInvokeAfterSaveCallbacks() {
 
-		ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
 
 		Person entity = new Person("init", "luke");
 
-		Person saved = template.save(entity, IndexCoordinates.of("index")).block(Duration.ofSeconds(1));
+		Person saved = template.save(entity, index).block(Duration.ofSeconds(1));
 
-		verify(afterSaveCallback).onAfterSave(eq(entity));
+		verify(afterSaveCallback).onAfterSave(eq(entity), eq(index));
-		assertThat(saved.id).isEqualTo("after-save");
+		assertThat(saved.firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveFromPublisherWithIndexCoordinatesShouldInvokeAfterSaveCallbacks() {
 
-		ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
 
 		Person entity = new Person("init", "luke");
 
-		Person saved = template.save(Mono.just(entity), IndexCoordinates.of("index")).block(Duration.ofSeconds(1));
+		Person saved = template.save(Mono.just(entity), index).block(Duration.ofSeconds(1));
 
-		verify(afterSaveCallback).onAfterSave(eq(entity));
+		verify(afterSaveCallback).onAfterSave(eq(entity), eq(index));
-		assertThat(saved.id).isEqualTo("after-save");
+		assertThat(saved.firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveAllShouldInvokeAfterSaveCallbacks() {
 
-		ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
 
 		Person entity1 = new Person("init1", "luke1");
 		Person entity2 = new Person("init2", "luke2");
 
-		List<Person> saved = template.saveAll(Arrays.asList(entity1, entity2), IndexCoordinates.of("index")).toStream()
+		List<Person> saved = template.saveAll(Arrays.asList(entity1, entity2), index).toStream()
 				.collect(Collectors.toList());
 
-		verify(afterSaveCallback, times(2)).onAfterSave(any());
+		verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
-		assertThat(saved.get(0).getId()).isEqualTo("after-save");
+		assertThat(saved.get(0).firstname).isEqualTo("after-save");
-		assertThat(saved.get(1).getId()).isEqualTo("after-save");
+		assertThat(saved.get(1).firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-771
 	void saveFromMonoAllShouldInvokeAfterSaveCallbacks() {
 
-		ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
 
 		Person entity1 = new Person("init1", "luke1");
 		Person entity2 = new Person("init2", "luke2");
 
-		List<Person> saved = template.saveAll(Mono.just(Arrays.asList(entity1, entity2)), IndexCoordinates.of("index"))
+		List<Person> saved = template.saveAll(Mono.just(Arrays.asList(entity1, entity2)), index)
 				.toStream().collect(Collectors.toList());
 
-		verify(afterSaveCallback, times(2)).onAfterSave(any());
+		verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
-		assertThat(saved.get(0).getId()).isEqualTo("after-save");
+		assertThat(saved.get(0).firstname).isEqualTo("after-save");
-		assertThat(saved.get(1).getId()).isEqualTo("after-save");
+		assertThat(saved.get(1).firstname).isEqualTo("after-save");
 	}
 
 	@Test // DATAES-772
 	void multiGetShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		List<Person> results = template.multiGet(pagedQueryForTwo(), Person.class, index).timeout(Duration.ofSeconds(1))
@@ -227,69 +219,59 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.get(0).id).isEqualTo("after-convert");
+		assertThat(results.get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).id).isEqualTo("after-convert");
+		assertThat(results.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void findByIdShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		@SuppressWarnings("deprecation") // we know what we test
 		Person result = template.findById("init", Person.class).block(Duration.ofSeconds(1));
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(result.id).isEqualTo("after-convert");
+		assertThat(result.firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void findByIdWithIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		@SuppressWarnings("deprecation") // we know what we test
 		Person result = template.findById("init", Person.class, index).block(Duration.ofSeconds(1));
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
-		assertThat(result.id).isEqualTo("after-convert");
+		assertThat(result.firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void getShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		Person result = template.get("init", Person.class).block(Duration.ofSeconds(1));
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(result.id).isEqualTo("after-convert");
+		assertThat(result.firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void getWithIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		Person result = template.get("init", Person.class, index).block(Duration.ofSeconds(1));
 
 		verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
-		assertThat(result.id).isEqualTo("after-convert");
+		assertThat(result.firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void findUsingPageableShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		@SuppressWarnings("deprecation") // we know what we test
@@ -297,8 +279,8 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 				.collect(Collectors.toList());
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(results.get(0).id).isEqualTo("after-convert");
+		assertThat(results.get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).id).isEqualTo("after-convert");
+		assertThat(results.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	private Query pagedQueryForTwo() {
@@ -313,8 +295,6 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 	@Test // DATAES-772
 	void findUsingScrollShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		@SuppressWarnings("deprecation") // we know what we test
@@ -322,8 +302,8 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 				.collect(Collectors.toList());
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(results.get(0).id).isEqualTo("after-convert");
+		assertThat(results.get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).id).isEqualTo("after-convert");
+		assertThat(results.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	private Query scrollingQueryForTwo() {
@@ -333,8 +313,6 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 	@Test // DATAES-772
 	void findWithIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		@SuppressWarnings("deprecation") // we know what we test
@@ -343,15 +321,13 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.get(0).id).isEqualTo("after-convert");
+		assertThat(results.get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).id).isEqualTo("after-convert");
+		assertThat(results.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void findWithReturnTypeShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		@SuppressWarnings("deprecation") // we know what we test
@@ -359,15 +335,13 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 				.toStream().collect(Collectors.toList());
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(results.get(0).id).isEqualTo("after-convert");
+		assertThat(results.get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).id).isEqualTo("after-convert");
+		assertThat(results.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void findWithReturnTypeAndIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		@SuppressWarnings("deprecation") // we know what we test
@@ -376,30 +350,26 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.get(0).id).isEqualTo("after-convert");
+		assertThat(results.get(0).firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).id).isEqualTo("after-convert");
+		assertThat(results.get(1).firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class).timeout(Duration.ofSeconds(1))
 				.toStream().collect(Collectors.toList());
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(results.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(results.get(1).getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchWithIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class, index)
@@ -407,30 +377,26 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(results.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(results.get(1).getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchWithResultTypeShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class, Person.class)
 				.timeout(Duration.ofSeconds(1)).toStream().collect(Collectors.toList());
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
-		assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(results.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(results.get(1).getContent().firstname).isEqualTo("after-convert");
 	}
 
 	@Test // DATAES-772
 	void searchWithResultTypeAndIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
 
-		ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
-
 		template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
 
 		List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class, Person.class, index)
@@ -438,8 +404,37 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 
 		verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
 				eq(index));
-		assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
+		assertThat(results.get(0).getContent().firstname).isEqualTo("after-convert");
-		assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
+		assertThat(results.get(1).getContent().firstname).isEqualTo("after-convert");
+	}
+
+	@Test // DATAES-785
+	void saveOneShouldInvokeBeforeConvertCallbacks() {
+
+		template.setEntityCallbacks(ReactiveEntityCallbacks.create(beforeConvertCallback));
+
+		Person entity = new Person("init1", "luke1");
+
+		Person saved = template.save(entity, index).block(Duration.ofSeconds(1));
+
+		verify(beforeConvertCallback).onBeforeConvert(any(), eq(index));
+		assertThat(saved.firstname).isEqualTo("before-convert");
+	}
+
+	@Test // DATAES-785
+	void saveAllShouldInvokeBeforeConvertCallbacks() {
+
+		template.setEntityCallbacks(ReactiveEntityCallbacks.create(beforeConvertCallback));
+
+		Person entity1 = new Person("init1", "luke1");
+		Person entity2 = new Person("init2", "luke2");
+
+		List<Person> saved = template.saveAll(Arrays.asList(entity1, entity2), index).toStream()
+				.collect(Collectors.toList());
+
+		verify(beforeConvertCallback, times(2)).onBeforeConvert(any(), eq(index));
+		assertThat(saved.get(0).firstname).isEqualTo("before-convert");
+		assertThat(saved.get(1).firstname).isEqualTo("before-convert");
 	}
 
 	@Data
@@ -474,14 +469,14 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 			implements ReactiveAfterSaveCallback<Person> {
 
 		@Override
-		public Mono<Person> onAfterSave(Person entity) {
+		public Mono<Person> onAfterSave(Person entity, IndexCoordinates index) {
 
 			return Mono.defer(() -> {
 				capture(entity);
 				Person newPerson = new Person() {
 					{
-						id = "after-save";
+						id = entity.id;
-						firstname = entity.firstname;
+						firstname = "after-save";
 					}
 				};
 				return Mono.just(newPerson);
@@ -499,8 +494,27 @@ public class ReactiveElasticsearchTemplateCallbackTests {
 				capture(entity);
 				Person newPerson = new Person() {
 					{
-						id = "after-convert";
+						id = entity.id;
-						firstname = entity.firstname;
+						firstname = "after-convert";
+					}
+				};
+				return Mono.just(newPerson);
+			});
+		}
+	}
+
+	static class ValueCapturingBeforeConvertCallback extends ValueCapturingEntityCallback<Person>
+			implements ReactiveBeforeConvertCallback<Person> {
+
+		@Override
+		public Mono<Person> onBeforeConvert(Person entity, IndexCoordinates index) {
+
+			return Mono.defer(() -> {
+				capture(entity);
+				Person newPerson = new Person() {
+					{
+						id = entity.id;
+						firstname = "before-convert";
 					}
 				};
 				return Mono.just(newPerson);

src/test/java/org/springframework/data/elasticsearch/core/event/AuditingEntityCallbackTests.java

@@ -30,12 +30,14 @@ import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.LastModifiedDate;
 import org.springframework.data.auditing.IsNewAwareAuditingHandler;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
 import org.springframework.data.mapping.context.PersistentEntities;
 import org.springframework.lang.Nullable;
 
 /**
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  */
 @ExtendWith(MockitoExtension.class)
 class AuditingEntityCallbackTests {
@@ -66,7 +68,7 @@ class AuditingEntityCallbackTests {
 	void shouldCallHandler() {
 		Sample entity = new Sample();
 		entity.setId("42");
-		callback.onBeforeConvert(entity);
+		callback.onBeforeConvert(entity, IndexCoordinates.of("index"));
 
 		verify(handler).markAudited(eq(entity));
 	}
@@ -79,7 +81,7 @@ class AuditingEntityCallbackTests {
 		sample2.setId("2");
 		doReturn(sample2).when(handler).markAudited(any());
 
-		Sample result = (Sample) callback.onBeforeConvert(sample1);
+		Sample result = (Sample) callback.onBeforeConvert(sample1, IndexCoordinates.of("index"));
 
 		assertThat(result).isSameAs(sample2);
 	}

src/test/java/org/springframework/data/elasticsearch/core/event/ElasticsearchOperationsCallbackTest.java

@@ -26,10 +26,12 @@ import org.springframework.data.annotation.Id;
 import org.springframework.data.elasticsearch.annotations.Document;
 import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
 import org.springframework.data.elasticsearch.core.IndexOperations;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.stereotype.Component;
 
 /**
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  */
 abstract class ElasticsearchOperationsCallbackTest {
 
@@ -41,7 +43,7 @@ abstract class ElasticsearchOperationsCallbackTest {
 		@Component
 		static class SampleEntityBeforeConvertCallback implements BeforeConvertCallback<SampleEntity> {
 			@Override
-			public SampleEntity onBeforeConvert(SampleEntity entity) {
+			public SampleEntity onBeforeConvert(SampleEntity entity, IndexCoordinates index) {
 				entity.setText("converted");
 				return entity;
 			}

src/test/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallbackTests.java

@@ -18,6 +18,7 @@ package org.springframework.data.elasticsearch.core.event;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import reactor.test.StepVerifier;
 
 import java.time.LocalDateTime;
@@ -38,6 +39,7 @@ import org.springframework.lang.Nullable;
 
 /**
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  */
 @ExtendWith(MockitoExtension.class)
 class ReactiveAuditingEntityCallbackTests {
@@ -68,7 +70,7 @@ class ReactiveAuditingEntityCallbackTests {
 	void shouldCallHandler() {
 		Sample entity = new Sample();
 		entity.setId("42");
-		callback.onBeforeConvert(entity);
+		callback.onBeforeConvert(entity, IndexCoordinates.of("index"));
 
 		verify(handler).markAudited(eq(entity));
 	}
@@ -81,7 +83,7 @@ class ReactiveAuditingEntityCallbackTests {
 		sample2.setId("2");
 		doReturn(sample2).when(handler).markAudited(any());
 
-		callback.onBeforeConvert(sample1) //
+		callback.onBeforeConvert(sample1, IndexCoordinates.of("index")) //
 				.as(StepVerifier::create) //
 				.consumeNextWith(it -> { //
 					assertThat(it).isSameAs(sample2); //

src/test/java/org/springframework/data/elasticsearch/core/event/ReactiveElasticsearchOperationsCallbackTest.java

@@ -31,6 +31,7 @@ import org.springframework.data.elasticsearch.annotations.Document;
 import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
 import org.springframework.data.elasticsearch.core.IndexOperations;
 import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
+import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
 import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
 import org.springframework.data.elasticsearch.junit.jupiter.ReactiveElasticsearchRestTemplateConfiguration;
 import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
@@ -39,6 +40,7 @@ import org.springframework.test.context.ContextConfiguration;
 
 /**
  * @author Peter-Josef Meisch
+ * @author Roman Puchkovskiy
  */
 @SpringIntegrationTest
 @ContextConfiguration(classes = { ReactiveElasticsearchOperationsCallbackTest.Config.class })
@@ -50,7 +52,7 @@ public class ReactiveElasticsearchOperationsCallbackTest {
 		@Component
 		static class SampleEntityBeforeConvertCallback implements ReactiveBeforeConvertCallback<SampleEntity> {
 			@Override
-			public Mono<SampleEntity> onBeforeConvert(SampleEntity entity) {
+			public Mono<SampleEntity> onBeforeConvert(SampleEntity entity, IndexCoordinates index) {
 				entity.setText("reactive-converted");
 				return Mono.just(entity);
 			}