hi everybody! Could you please help me. I have graphql query and schema. What is the best way to analyze query and retrieve all requested fileds with proper type? For example in recursive structure:
sealed trait GraphQlFieldType {
val typeName: String
}
final case class GraphQlField(name: String, fieldType: GraphQlFieldType, isArray: Boolean = false)
final case class GraphQlFieldTypeDataClass(typeName: String,
fields: List[GraphQlField]) extends GraphQlFieldType
how do you handle transactions for subscriptions? For normal grahql requests I use a single transaction for queries and mutations. This transaction is part of the context. Using this same mechanism for subscriptions is insane. Do you create a separate
SubscriptionContext without transactions or do you guys have another suggestion?
Actions?
I have a use case where I accept multiple ids in a fetcher and want to return partial results in case fetcher couldn't give data for some of the IDs. For ex:
Schema : Car { id: int}
And let's say my input has 3 ids: 000,111,222 and out of those 2 were not found
I want response something like(basically to let the user know what happened with 2 ids which are not in data result):
"data": {
"getCar:[
{
"car": {
“id”: “111”
}
}
]
},
"errors": [
{
"message": “Couldn’t find data for car”
"code":"404"
“fields” : ”000,222”
}
]
}Is something like this possible in Sangria? Any help is greatly appreciated
2 replies
Suppose I have the following schema:
lazy val ParentType = ObjectType(
"Parent",
collect[...](
Public(
Field("child", ChildType,
resolve = _.value.child
)
)
)
)
lazy val ChildType = ObjectType(
"Child",
collect[...](
Public(
Field("something", StringType,
resolve = ...
)
)
)
)Is there a way to reference a field in the parent value/type within the resolve method of the ChildType's "something" resolve field.
I'm trying to do some custom instrumentation in New Relic similar to their recent graphql-java instrumentation:
https://github.com/newrelic/newrelic-java-agent/blob/5a035c11d3b0226655468d780c38342a60e790a7/instrumentation/graphql-java-16.2/src/main/java/com/nr/instrumentation/graphql/GraphQLSpanUtil.java#L39
What would be the equivalent of graphql-java's graphql.execution.ExecutionStrategyParameters? Can I derive it from sangria.ast.Document
https://github.com/graphql-java/graphql-java/blob/master/src/main/java/graphql/execution/ExecutionStrategyParameters.java
https://twitter.com/simon_yann/status/1499401657276252164
The only thing that is sort of holding me back: Scala 3 is out. It's shiney, new and much better than Scala 2.13. I saw that Sangria is not released for Scala 3 yet, correct?
Is there a timeline for this?
NoClassDefFoundError: sangria/parser/DeliveryScheme https://gist.github.com/jgillich/3e8d90dde7526d47a5f5fe496aae9889Source is very simple: https://github.com/graphql-crystal/benchmarks/tree/main/sangria
Any ideas? Wondering if it's related to sangria-akka-http-circe
can someone help me with the mutation?
Schema
implicit val inComercioType = deriveObjectType[DataRepo, comercio]()
val ComercioInObject = {
InputObjectType(
name = "Insert Comercio",
description = "",
List(
InputField(
name = "condicion",
fieldType = StringType),
InputField(
name = "laltitud",
fieldType = BigDecimalType),
InputField(
name = "longitud",
fieldType = BigDecimalType),
InputField(
name = "distancia",
fieldType = IntType),
)
)
}
val Condicion: Argument[String] = Argument("condicion", StringType)
val Latitud: Argument[BigDecimal] = Argument("latitud", BigDecimalType)
val Longitud: Argument[BigDecimal] = Argument("longitud", BigDecimalType)
val Distancia: Argument[Int] = Argument("distancia", IntType)
val MutationType =
ObjectType(
"Mutation",
fields[DataRepo, Unit](
Field(
name ="addComercios",
fieldType = ComercioOutObject,
arguments = Condicion :: Latitud :: Longitud :: Distancia :: Nil,
resolve = c => c.ctx.gqlAddComercios(c.arg(Condicion),c.arg(Latitud) ,c.arg(Longitud),c.arg(Distancia))
),
)
)
val SchemaDefinition: Schema[DataRepo, Unit] = Schema(QueryType,Some(MutationType))Datarepo
def gqlAddComercios(condicion: String,latitud:BigDecimal,longitud:BigDecimal,distancia:Int=250):List[getComercio] = comercio(condicion,latitud,longitud,distancia,token).insertContent
Hello,
I have the following field relation:
Field("setups",
fieldType = ListType(TransportSetup.toGraphType),
arguments = fetchTransportSetupArgs.createGraphTypeArgs,
resolve = ctx => setupFetcher.deferRelSeq(linkSetupByRouteId, ctx.value.getId)
),I would like to pass the arguments of the field to my fetcher, i tried to make work deferred resolver but no luck so far
Any help welcome here ;)
ID. You can define it to what type you need.If you need more control, you can go lower level, and use
DeferredValueand DeferredResolver.In my company, we are using both, and we combine them with
DeferredResolver.fetchersWithFallback.
As I understand it: if you have n different values from n branches, this method is used to know what to do with those n values.
For example, in the MeasureComplexity:
def reduceAlternatives(alternatives: Seq[Acc]) = alternatives.maxIn TagCollector, we collect all tags:
def reduceAlternatives(alternatives: Seq[Acc]) = alternatives.toVector.flatten
I've been trying to dig into Sangria Fetchers (Data Loaders) and couldn't quite figure out if they go across requests or if they only act per-request. I found this PR mentioning that the caching is per-request, but haven't found anything to confirm if the batching/data loader part is as well 🤔 sangria-graphql/sangria#447
For example, imagine this scenario:
- Request A: Get ID 2 via Fetcher
- Request B: Get ID 2 via Fetcher
Would this result in 1 database calls (so, it works across requests) or 2 database calls (it's per-request)?
profession(id: "123456"){
resultList{
name
description
professionType
address
engineer(domain : "Software",skill: "Scala"){
department
domain
country
skills
}
doctor(speciality: "Ortho"){
hospital
speciality
yearsOfExperience
}
}
}
}
Yes, it's possible to have arguments on any field.
Example:
Field(
"field_name",
arguments = IncludeKeys :: ExcludeKeys :: Limit :: Offset :: SortArg :: Nil,
resolve = ctx => {
val includes = ctx.arg(IncludeKeys)
val excludes = ctx.arg(ExcludeKeys)
val limit = ctx.arg(Limit)
val offset = ctx.arg(Offset)