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 java.io.IOException
23 
24 import caliban.CalibanError.ExecutionError
25 import caliban.InputValue
26 import caliban.Value.{EnumValue, StringValue => CalibanString}
27 import caliban.introspection.adt.{__EnumValue, __Type, __TypeKind}
28 import caliban.schema.{ArgBuilder, PureStep, Schema, Step}
29 import caliban._
30 import caliban.CalibanError._
31 import caliban.wrappers.Wrapper.OverallWrapper
32 import grizzled.slf4j.Logging
33 import enumeratum.values.{NoSuchMember, StringEnum, StringEnumEntry, ValueEnumEntry}
34 import org.make.core.StringValue
35 import zio.console.Console
36 import zio.query.Request
37 import zio.{IO, UIO, ULayer, ZIO, ZLayer}
38 
39 object GraphQLUtils extends Logging {
40 
41   val debugPrint: OverallWrapper[Console] =
42     new OverallWrapper[Console] {
43       def wrap[R <: Console](
44         process: GraphQLRequest => ZIO[R, Nothing, GraphQLResponse[CalibanError]]
45       ): GraphQLRequest => ZIO[R, Nothing, GraphQLResponse[CalibanError]] =
46         (request: GraphQLRequest) => IO.effectTotal(logger.debug(request.toString)) *> process(request)
47     }
48 
49   object ConsoleLoggingService {
50     val live: ULayer[Console] =
51       ZLayer.succeed(new Console.Service {
52         override def putStr(line: String): UIO[Unit] =
53           IO.succeed(logger.info(line))
54 
55         override def putStrErr(line: String): UIO[Unit] =
56           IO.succeed(logger.error(line))
57 
58         override def putStrLn(line: String): UIO[Unit] =
59           IO.succeed(logger.info(line))
60 
61         override def putStrLnErr(line: String): UIO[Unit] =
62           IO.succeed(logger.error(line))
63 
64         override val getStrLn: IO[IOException, String] =
65           IO.fail(new IOException("not supported"))
66       })
67   }
68 
69   implicit def stringValueStringSchema[T <: StringValue]: Schema[Any, T] =
70     Schema.stringSchema.contramap(_.value)
71 
72   implicit def enumSchema[T <: StringEnumEntry](implicit helper: StringEnum[T]): Schema[Any, T] =
73     new Schema[Any, T] {
74       private def sanitizeName(name: String): String = {
75         if (name.endsWith("$")) {
76           name.dropRight(1).mkString
77         } else {
78           name
79         }
80       }
81 
82       override protected[this] def toType(isInput: Boolean, isSubscription: Boolean): __Type = __Type(
83         kind = __TypeKind.ENUM,
84         name = Some(sanitizeName(helper.getClass.getSimpleName)),
85         description = None,
86         fields = _      => None,
87         interfaces = () => None,
88         possibleTypes = None,
89         enumValues = _ =>
90           Some(
91             helper.values
92               .map(v => __EnumValue(name = v.value, description = None, isDeprecated = false, deprecationReason = None))
93               .toList
94           ),
95         inputFields = None,
96         ofType = None,
97         directives = None,
98         origin = None
99       )
100       override def resolve(value: T): Step[Any] = PureStep(EnumValue(value.value))
101 
102     }
103 
104   implicit def enumArgBuilder[T <: StringEnumEntry](implicit helper: StringEnum[T]): ArgBuilder[T] = {
105     def parseEnumValue(value: String): Either[ExecutionError, T] = {
106       val parsedValue: Either[NoSuchMember[String, ValueEnumEntry[String]], T] =
107         helper.withValueEither(value)
108 
109       parsedValue.left.map { e =>
110         ExecutionError(s"${e.notFoundValue} is not a valid value, use ${e.enumValues.mkString(", ")}")
111       }
112     }
113 
114     (input: InputValue) => {
115       input match {
116         case EnumValue(value)     => parseEnumValue(value)
117         case CalibanString(value) => parseEnumValue(value)
118         case other                => Left(ExecutionError(s"cannot parse $other"))
119       }
120     }
121 
122   }
123 
124 }
125 
126 trait IdsRequest[F[_], T <: StringValue, U] extends Request[Throwable, F[U]] {
127   val ids: F[T]
128 }