feat(request): Add request options (#394)

src/main/scala/algolia/definitions/ApiKeyDefinition.scala

@@ -26,18 +26,25 @@
 package algolia.definitions
 
 import algolia.http._
-import algolia.objects.ApiKey
+import algolia.objects.{ApiKey, RequestOptions}
 import algolia.responses.{AllKeys, CreateUpdateKey, DeleteKey}
 import algolia.{AlgoliaClient, Executable}
 import org.json4s.Formats
 import org.json4s.native.Serialization._
 
 import scala.concurrent.{ExecutionContext, Future}
 
-case class GetApiKeyDefinition(keyName: String, indexName: Option[String] = None)
+case class GetApiKeyDefinition(keyName: String,
+                               indexName: Option[String] = None,
+                               requestOptions: Option[RequestOptions] = None)
     extends Definition {
 
-  def from(indexName: String) = copy(indexName = Some(indexName))
+  type T = GetApiKeyDefinition
+
+  def from(indexName: String): GetApiKeyDefinition = copy(indexName = Some(indexName))
+
+  override def options(requestOptions: RequestOptions): GetApiKeyDefinition =
+    copy(requestOptions = Some(requestOptions))
 
   override private[algolia] def build(): HttpPayload = {
     val path = if (indexName.isEmpty) {
@@ -49,16 +56,23 @@ case class GetApiKeyDefinition(keyName: String, indexName: Option[String] = None
     HttpPayload(
       GET,
       path,
-      isSearch = false
+      isSearch = false,
+      requestOptions = requestOptions
     )
   }
 }
 
-case class AddApiKeyDefinition(key: ApiKey, indexName: Option[String] = None)(
-    implicit val formats: Formats)
+case class AddApiKeyDefinition(
+    key: ApiKey,
+    indexName: Option[String] = None,
+    requestOptions: Option[RequestOptions] = None)(implicit val formats: Formats)
     extends Definition {
+  type T = AddApiKeyDefinition
+
+  def to(indexName: String): AddApiKeyDefinition = copy(indexName = Some(indexName))
 
-  def to(indexName: String) = copy(indexName = Some(indexName))
+  override def options(requestOptions: RequestOptions): AddApiKeyDefinition =
+    copy(requestOptions = Some(requestOptions))
 
   override private[algolia] def build(): HttpPayload = {
     val path = if (indexName.isEmpty) {
@@ -71,15 +85,23 @@ case class AddApiKeyDefinition(key: ApiKey, indexName: Option[String] = None)(
       POST,
       path,
       body = Some(write(key)),
-      isSearch = false
+      isSearch = false,
+      requestOptions = requestOptions
     )
   }
 }
 
-case class DeleteApiKeyDefinition(keyName: String, indexName: Option[String] = None)
+case class DeleteApiKeyDefinition(keyName: String,
+                                  indexName: Option[String] = None,
+                                  requestOptions: Option[RequestOptions] = None)
     extends Definition {
 
-  def from(indexName: String) = copy(indexName = Some(indexName))
+  type T = DeleteApiKeyDefinition
+
+  def from(indexName: String): DeleteApiKeyDefinition = copy(indexName = Some(indexName))
+
+  override def options(requestOptions: RequestOptions): DeleteApiKeyDefinition =
+    copy(requestOptions = Some(requestOptions))
 
   override private[algolia] def build(): HttpPayload = {
     val path = if (indexName.isEmpty) {
@@ -91,19 +113,27 @@ case class DeleteApiKeyDefinition(keyName: String, indexName: Option[String] = N
     HttpPayload(
       DELETE,
       path,
-      isSearch = false
+      isSearch = false,
+      requestOptions = requestOptions
     )
   }
 }
 
-case class UpdateApiKeyDefinition(keyName: String,
-                                  key: Option[ApiKey] = None,
-                                  indexName: Option[String] = None)(implicit val formats: Formats)
+case class UpdateApiKeyDefinition(
+    keyName: String,
+    key: Option[ApiKey] = None,
+    indexName: Option[String] = None,
+    requestOptions: Option[RequestOptions] = None)(implicit val formats: Formats)
     extends Definition {
 
-  def `with`(key: ApiKey) = copy(key = Some(key))
+  type T = UpdateApiKeyDefinition
+
+  def `with`(key: ApiKey): UpdateApiKeyDefinition = copy(key = Some(key))
 
-  def from(indexName: String) = copy(indexName = Some(indexName))
+  def from(indexName: String): UpdateApiKeyDefinition = copy(indexName = Some(indexName))
+
+  override def options(requestOptions: RequestOptions): UpdateApiKeyDefinition =
+    copy(requestOptions = Some(requestOptions))
 
   override private[algolia] def build(): HttpPayload = {
     val path = if (indexName.isEmpty) {
@@ -116,12 +146,21 @@ case class UpdateApiKeyDefinition(keyName: String,
       PUT,
       path,
       body = Some(write(key)),
-      isSearch = false
+      isSearch = false,
+      requestOptions = requestOptions
     )
   }
 }
 
-case class GetAllApiKeyDefinition(indexName: Option[String] = None) extends Definition {
+case class GetAllApiKeyDefinition(indexName: Option[String] = None,
+                                  requestOptions: Option[RequestOptions] = None)
+    extends Definition {
+
+  type T = GetAllApiKeyDefinition
+
+  override def options(requestOptions: RequestOptions): GetAllApiKeyDefinition =
+    copy(requestOptions = Some(requestOptions))
+
   override private[algolia] def build(): HttpPayload = {
     val path = if (indexName.isEmpty) {
       Seq("1", "keys")
@@ -132,7 +171,8 @@ case class GetAllApiKeyDefinition(indexName: Option[String] = None) extends Defi
     HttpPayload(
       GET,
       path,
-      isSearch = false
+      isSearch = false,
+      requestOptions = requestOptions
     )
   }
 }

src/main/scala/algolia/definitions/BatchDefinition.scala

@@ -27,6 +27,7 @@ package algolia.definitions
 
 import algolia.http.{HttpPayload, POST}
 import algolia.inputs._
+import algolia.objects.RequestOptions
 import algolia.responses.TasksMultipleIndex
 import algolia.{AlgoliaClient, Executable}
 import org.json4s.JsonAST.JValue
@@ -35,45 +36,54 @@ import org.json4s.{Extraction, Formats}
 
 import scala.concurrent.{ExecutionContext, Future}
 
-case class BatchDefinition(definitions: Traversable[Definition])(implicit val formats: Formats)
+case class BatchDefinition(
+    definitions: Traversable[Definition],
+    requestOptions: Option[RequestOptions] = None)(implicit val formats: Formats)
     extends Definition
     with BatchOperationUtils {
 
+  type T = BatchDefinition
+
+  override def options(requestOptions: RequestOptions): BatchDefinition =
+    copy(requestOptions = Some(requestOptions))
+
   override private[algolia] def build(): HttpPayload = {
     HttpPayload(
       POST,
       Seq("1", "indexes", "*", "batch"),
       body = Some(write(BatchOperations(definitions.flatMap(transform)))),
-      isSearch = false
+      isSearch = false,
+      requestOptions = requestOptions
     )
   }
 
   private def transform(definition: Definition): Traversable[BatchOperation[JValue]] = {
     definition match {
-      case IndexingDefinition(index, None, Some(obj)) =>
+      case IndexingDefinition(index, None, Some(obj), _) =>
         hasObjectId(obj) match {
           case (true, o) => Traversable(UpdateObjectOperation(o, Some(index)))
           case (false, o) => Traversable(AddObjectOperation(o, Some(index)))
         }
 
-      case IndexingDefinition(index, Some(objectId), Some(obj)) =>
+      case IndexingDefinition(index, Some(objectId), Some(obj), _) =>
         Traversable(UpdateObjectOperation(addObjectId(obj, objectId), Some(index)))
 
-      case ClearIndexDefinition(index) =>
+      case ClearIndexDefinition(index, _) =>
         Traversable(ClearIndexOperation(index))
 
-      case DeleteObjectDefinition(Some(index), Some(oid)) =>
+      case DeleteObjectDefinition(Some(index), Some(oid), _) =>
         Traversable(DeleteObjectOperation(index, oid))
 
-      case DeleteIndexDefinition(index) =>
+      case DeleteIndexDefinition(index, _) =>
         Traversable(DeleteIndexOperation(index))
 
       case PartialUpdateObjectOperationDefinition(operation,
                                                   index,
                                                   Some(objectId),
                                                   Some(attribute),
                                                   value,
-                                                  true) =>
+                                                  true,
+                                                  _) =>
         val body = Map(
           "objectID" -> objectId,
           attribute -> PartialUpdateObject(operation.name, value)
@@ -85,21 +95,22 @@ case class BatchDefinition(definitions: Traversable[Definition])(implicit val fo
                                                   Some(objectId),
                                                   Some(attribute),
                                                   value,
-                                                  false) =>
+                                                  false,
+                                                  _) =>
         val body = Map(
           "objectID" -> objectId,
           attribute -> PartialUpdateObject(operation.name, value)
         )
         Traversable(PartialUpdateObjectNoCreateOperation(Extraction.decompose(body), index))
 
-      case PartialUpdateObjectDefinition(index, Some(objectId), Some(attribute), value) =>
+      case PartialUpdateObjectDefinition(index, Some(objectId), Some(attribute), value, _) =>
         val body = Map(
           "objectID" -> objectId,
           attribute -> value
         )
         Traversable(PartialUpdateObjectOperation(Extraction.decompose(body), index))
 
-      case IndexingBatchDefinition(_, defs) =>
+      case IndexingBatchDefinition(_, defs, _) =>
         defs.flatMap(transform)
 
     }

src/main/scala/algolia/definitions/BrowseIndexDefinition.scala

@@ -26,30 +26,38 @@
 package algolia.definitions
 
 import algolia.http.{GET, HttpPayload}
-import algolia.objects.Query
+import algolia.objects.{Query, RequestOptions}
 import algolia.responses.{BrowseResult, Task}
 import algolia.{AlgoliaClient, Executable}
 import org.json4s.Formats
 
 import scala.concurrent.{ExecutionContext, Future}
 
-case class BrowseIndexDefinition(source: String,
-                                 query: Option[Query] = None,
-                                 cursor: Option[String] = None)(implicit val formats: Formats)
+case class BrowseIndexDefinition(
+    source: String,
+    query: Option[Query] = None,
+    cursor: Option[String] = None,
+    requestOptions: Option[RequestOptions] = None)(implicit val formats: Formats)
     extends Definition {
 
+  type T = BrowseIndexDefinition
+
   def from(cursor: String): BrowseIndexDefinition = copy(cursor = Some(cursor))
 
   def query(query: Query): BrowseIndexDefinition = copy(query = Some(query))
 
+  override def options(requestOptions: RequestOptions): BrowseIndexDefinition =
+    copy(requestOptions = Some(requestOptions))
+
   override private[algolia] def build(): HttpPayload = {
     val q = query.getOrElse(Query()).copy(cursor = cursor)
 
     HttpPayload(
       GET,
       Seq("1", "indexes", source, "browse"),
       queryParameters = Some(q.toQueryParam),
-      isSearch = true
+      isSearch = true,
+      requestOptions = requestOptions
     )
   }
 }

src/main/scala/algolia/definitions/ClearDefinition.scala

@@ -27,16 +27,26 @@ package algolia.definitions
 
 import algolia.AlgoliaDsl.Of
 import algolia.http.{HttpPayload, POST}
+import algolia.objects.RequestOptions
 import algolia.responses.Task
 import algolia.{AlgoliaClient, Executable}
 import org.json4s.Formats
 
 import scala.concurrent.{ExecutionContext, Future}
 
-case class ClearIndexDefinition(index: String) extends Definition {
+case class ClearIndexDefinition(index: String, requestOptions: Option[RequestOptions] = None)
+    extends Definition {
+
+  type T = ClearIndexDefinition
+
+  override def options(requestOptions: RequestOptions): ClearIndexDefinition =
+    copy(requestOptions = Some(requestOptions))
 
   override private[algolia] def build(): HttpPayload =
-    HttpPayload(POST, Seq("1", "indexes", index, "clear"), isSearch = false)
+    HttpPayload(POST,
+                Seq("1", "indexes", index, "clear"),
+                isSearch = false,
+                requestOptions = requestOptions)
 
 }
 

src/main/scala/algolia/definitions/CopyIndexDefinition.scala

@@ -27,27 +27,37 @@ package algolia.definitions
 
 import algolia.http.{HttpPayload, POST}
 import algolia.inputs.IndexOperation
+import algolia.objects.RequestOptions
 import algolia.responses.Task
 import algolia.{AlgoliaClient, Executable}
 import org.json4s.Formats
 import org.json4s.native.Serialization._
 
 import scala.concurrent.{ExecutionContext, Future}
 
-case class CopyIndexDefinition(source: String, destination: Option[String] = None)(
-    implicit val formats: Formats)
+case class CopyIndexDefinition(
+    source: String,
+    destination: Option[String] = None,
+    requestOptions: Option[RequestOptions] = None)(implicit val formats: Formats)
     extends Definition {
+
+  type T = CopyIndexDefinition
+
   def to(destination: String): CopyIndexDefinition =
     copy(source, Some(destination))
 
+  override def options(requestOptions: RequestOptions): CopyIndexDefinition =
+    copy(requestOptions = Some(requestOptions))
+
   override private[algolia] def build(): HttpPayload = {
     val operation = IndexOperation("copy", destination)
 
     HttpPayload(
       POST,
       Seq("1", "indexes", source, "operation"),
       body = Some(write(operation)),
-      isSearch = false
+      isSearch = false,
+      requestOptions = requestOptions
     )
   }
 }

src/main/scala/algolia/definitions/Definition.scala

@@ -26,7 +26,12 @@
 package algolia.definitions
 
 import algolia.http.HttpPayload
+import algolia.objects.RequestOptions
+
+trait Definition { self =>
+  type T <: Definition
 
-trait Definition {
   private[algolia] def build(): HttpPayload
+
+  def options(requestOptions: RequestOptions): T
 }