1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2020 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.api.technical.graphql
21 
22 import cats.data.Validated.Valid
23 import cats.data.{NonEmptyList, Validated}
24 import cats.implicits._
25 import cats.{Id, Show, Traverse}
26 import org.make.core.StringValue
27 import zio.query.{CompletedRequestMap, DataSource}
28 import zio.{Chunk, Task}
29 
30 import scala.concurrent.{ExecutionContext, Future}
31 
32 object DataSourceHelper {
33   def createDataSource[F[_]: Traverse, EntityId <: StringValue, Entity, Request <: IdsRequest[F, EntityId, Entity]](
34     name: String,
35     findFromIds: Seq[EntityId] => ExecutionContext => Future[Map[EntityId, Entity]]
36   ): DataSource[Any, Request] = {
37     DataSource.Batched.make(name) { chunk =>
38       val resultMap = CompletedRequestMap.empty
39       val ids: Chunk[EntityId] = chunk.flatMap(_.ids.toIterable)
40       val entities: Task[Map[EntityId, Entity]] = Task.fromFuture(ec => findFromIds(ids)(ec))
41       implicit val showId: Show[EntityId] = Show.show[EntityId](_.value)
42 
43       entities.fold(
44         err => chunk.foldLeft(resultMap) { case (map, req) => map.insert(req)(Left(err)) }, { result =>
45           chunk.foldLeft(resultMap) {
46             case (map, req) =>
47               val res: Either[Exception, F[Entity]] = Traverse[F]
48                 .traverse(req.ids) { id =>
49                   result.get(id) match {
50                     case Some(value) => Valid(value)
51                     case None        => Validated.invalidNel(id)
52                   }
53                 }
54                 .toEither
55                 .leftMap(invalids => DataSourceIdsNotFound(name, invalids))
56               map.insert(req)(res)
57           }
58         }
59       )
60     }
61   }
62 
63   def one[EntityId <: StringValue, Entity, Request <: IdsRequest[Id, EntityId, Entity]](
64     name: String,
65     findFromIds: Seq[EntityId] => ExecutionContext => Future[Map[EntityId, Entity]]
66   ): DataSource[Any, Request] = {
67     createDataSource[Id, EntityId, Entity, Request](name, findFromIds)
68   }
69 
70   def seq[EntityId <: StringValue, Entity, Request <: IdsRequest[List, EntityId, Entity]](
71     name: String,
72     findFromIds: Seq[EntityId] => ExecutionContext => Future[Map[EntityId, Entity]]
73   ): DataSource[Any, Request] = {
74     createDataSource[List, EntityId, Entity, Request](name, findFromIds)
75   }
76 
77 }
78 
79 final case class DataSourceIdsNotFound[EntityId: Show](name: String, idsNotFound: NonEmptyList[EntityId])
80     extends Exception(s"DataSource $name could not find entities with ids: ${idsNotFound.mkString_(", ")}")