Use module pattern 2.0 (move requests to executor)

modules/example/src/main/scala/example/Main.scala

@@ -23,7 +23,7 @@ import sttp.client3.SttpBackend
 import sttp.client3.httpclient.zio.HttpClientZioBackend
 import zio._
 import zio.config.getConfig
-import zio.elasticsearch.{ElasticConfig, ElasticExecutor, ElasticRequest}
+import zio.elasticsearch.{ElasticConfig, ElasticExecutor}
 import zio.http.{Server, ServerConfig}
 
 import scala.io.Source
@@ -46,14 +46,14 @@ object Main extends ZIOAppDefault {
     val deleteIndex: RIO[ElasticExecutor, Unit] =
       for {
         _ <- ZIO.logInfo(s"Deleting index '$Index'...")
-        _ <- ElasticRequest.deleteIndex(Index).execute
+        _ <- ZIO.serviceWithZIO[ElasticExecutor](_.deleteIndex(Index).execute)
       } yield ()
 
     val createIndex: RIO[ElasticExecutor, Unit] =
       for {
         _       <- ZIO.logInfo(s"Creating index '$Index'...")
         mapping <- ZIO.fromTry(Using(Source.fromURL(getClass.getResource("/mapping.json")))(_.mkString))
-        _       <- ElasticRequest.createIndex(Index, Some(mapping)).execute
+        _       <- ZIO.serviceWithZIO[ElasticExecutor](_.createIndex(Index, Some(mapping)).execute)
       } yield ()
 
     val populate: RIO[SttpBackend[Task, Any] with ElasticExecutor, Unit] =

modules/example/src/main/scala/example/RepositoriesElasticsearch.scala

@@ -18,62 +18,49 @@ package example
 
 import zio._
 import zio.elasticsearch.ElasticQuery.matchAll
-import zio.elasticsearch.{
-  CreationOutcome,
-  DeletionOutcome,
-  DocumentId,
-  ElasticExecutor,
-  ElasticQuery,
-  ElasticRequest,
-  Routing
-}
+import zio.elasticsearch.{CreationOutcome, DeletionOutcome, DocumentId, ElasticExecutor, ElasticQuery, Routing}
 import zio.prelude.Newtype.unsafeWrap
 
 final case class RepositoriesElasticsearch(executor: ElasticExecutor) {
 
   def findAll(): Task[List[GitHubRepo]] =
-    executor.execute(ElasticRequest.search[GitHubRepo](Index, matchAll))
+    executor.search[GitHubRepo](Index, matchAll).execute
 
   def findById(organization: String, id: String): Task[Option[GitHubRepo]] =
     for {
       routing <- routingOf(organization)
-      req      = ElasticRequest.getById[GitHubRepo](Index, DocumentId(id)).routing(routing)
-      res     <- executor.execute(req)
+      res     <- executor.getById[GitHubRepo](Index, DocumentId(id)).routing(routing).execute
     } yield res
 
   def create(repository: GitHubRepo): Task[CreationOutcome] =
     for {
       routing <- routingOf(repository.organization)
-      req      = ElasticRequest.create(Index, DocumentId(repository.id), repository).routing(routing).refreshTrue
-      res     <- executor.execute(req)
+      res     <- executor.create(Index, DocumentId(repository.id), repository).routing(routing).refreshTrue.execute
     } yield res
 
   def createAll(repositories: List[GitHubRepo]): Task[Unit] =
     for {
       routing <- routingOf(organization)
       reqs = repositories.map { repository =>
-               ElasticRequest.create[GitHubRepo](Index, unsafeWrap(DocumentId)(repository.id), repository)
+               executor.create[GitHubRepo](Index, unsafeWrap(DocumentId)(repository.id), repository)
              }
-      bulkReq = ElasticRequest.bulk(reqs: _*).routing(routing)
-      _      <- executor.execute(bulkReq)
+      _ <- executor.bulk(reqs: _*).routing(routing).execute
     } yield ()
 
   def upsert(id: String, repository: GitHubRepo): Task[Unit] =
     for {
       routing <- routingOf(repository.organization)
-      req      = ElasticRequest.upsert(Index, DocumentId(id), repository).routing(routing).refresh(value = true)
-      _       <- executor.execute(req)
+      _       <- executor.upsert(Index, DocumentId(id), repository).routing(routing).refresh(value = true).execute
     } yield ()
 
   def remove(organization: String, id: String): Task[DeletionOutcome] =
     for {
       routing <- routingOf(organization)
-      req      = ElasticRequest.deleteById(Index, DocumentId(id)).routing(routing).refreshFalse
-      res     <- executor.execute(req)
+      res     <- executor.deleteById(Index, DocumentId(id)).routing(routing).refreshFalse.execute
     } yield res
 
   def search(query: ElasticQuery[_]): Task[List[GitHubRepo]] =
-    executor.execute(ElasticRequest.search[GitHubRepo](Index, query))
+    executor.search[GitHubRepo](Index, query).execute
 
   private def routingOf(value: String): IO[IllegalArgumentException, Routing.Type] =
     Routing.make(value).toZIO.mapError(e => new IllegalArgumentException(e))

modules/library/src/it/scala/zio/elasticsearch/IntegrationSpec.scala

@@ -41,8 +41,9 @@ trait IntegrationSpec extends ZIOSpecDefault {
   val createIndexTestName: IndexName = IndexName("create-index-test-name")
 
   val prepareElasticsearchIndexForTests: TestAspect[Nothing, Any, Throwable, Any] = beforeAll((for {
-    _ <- ElasticRequest.createIndex(index, None).execute
-    _ <- ElasticRequest.deleteByQuery(index, matchAll).refreshTrue.execute
+    executor <- ZIO.service[ElasticExecutor]
+    _        <- executor.createIndex(index, None).execute
+    _        <- executor.deleteByQuery(index, matchAll).refreshTrue.execute
   } yield ()).provide(elasticsearchLayer))
 
   def genIndexName: Gen[Any, IndexName] =

modules/library/src/main/scala/zio/elasticsearch/ElasticExecutor.scala

@@ -17,11 +17,36 @@
 package zio.elasticsearch
 
 import sttp.client3.SttpBackend
-import zio.stm.TMap
-import zio.{Task, ULayer, ZLayer}
+import zio.elasticsearch.ElasticRequest.BulkableRequest
+import zio.elasticsearch.ElasticRequestType._
+import zio.schema.Schema
+import zio.{Task, ZLayer}
 
 trait ElasticExecutor {
-  def execute[A](request: ElasticRequest[A, _]): Task[A]
+
+  def bulk(requests: BulkableRequest*): ElasticRequest[Unit, Bulk]
+
+  def create[A: Schema](index: IndexName, doc: A): ElasticRequest[DocumentId, Create]
+
+  def create[A: Schema](index: IndexName, id: DocumentId, doc: A): ElasticRequest[CreationOutcome, CreateWithId]
+
+  def createIndex(name: IndexName, definition: Option[String]): ElasticRequest[CreationOutcome, CreateIndex]
+
+  def deleteById(index: IndexName, id: DocumentId): ElasticRequest[DeletionOutcome, DeleteById]
+
+  def deleteByQuery(index: IndexName, query: ElasticQuery[_]): ElasticRequest[DeletionOutcome, DeleteByQuery]
+
+  def deleteIndex(name: IndexName): ElasticRequest[DeletionOutcome, DeleteIndex]
+
+  def exists(index: IndexName, id: DocumentId): ElasticRequest[Boolean, Exists]
+
+  def getById[A: Schema](index: IndexName, id: DocumentId): ElasticRequest[Option[A], GetById]
+
+  def search[A](index: IndexName, query: ElasticQuery[_])(implicit
+    schema: Schema[A]
+  ): ElasticRequest[List[A], GetByQuery]
+
+  def upsert[A: Schema](index: IndexName, id: DocumentId, doc: A): ElasticRequest[Unit, Upsert]
 }
 
 object ElasticExecutor {
@@ -30,7 +55,4 @@ object ElasticExecutor {
 
   lazy val local: ZLayer[SttpBackend[Task, Any], Throwable, ElasticExecutor] =
     ZLayer.succeed(ElasticConfig.Default) >>> live
-
-  lazy val test: ULayer[TestExecutor] =
-    ZLayer(TMap.empty[IndexName, TMap[DocumentId, Document]].map(TestExecutor).commit)
 }