The GraphQL Ruby documentation shows how to define a union type:
class Types::CommentSubject < Types::BaseUnion
description "Objects which may be commented on"
possible_types Types::Post, Types::Image
# Optional: if this method is defined, it will override `Schema.resolve_type`
def self.resolve_type(object, context)
if object.is_a?(BlogPost)
Types::Post
else
Types::Image
end
end
end
and it shows how to declare that a field is a list outside of a union:
# A field returning a list type:
# Equivalent to `aliases: [String!]` above
field :aliases, [String]
# An argument which accepts a list type:
argument :categories, [Types::PostCategory], required: false
but I can't for the life of me figure out how to use a list as a possible type that a union member could be.
My code looks something like this:
class Types::ArgumentValueType < Types::BaseUnion
possible_types GraphQL::Types::String, GraphQL::Types::Boolean, GraphQL::Types::Int
def self.resolve_type(object, _context)
if object.is_a?(String)
GraphQL::Types::String
elsif object.is_a?(Array)
[GraphQL::Types::String]
elsif object.is_a?(FalseClass)
GraphQL::Types::Boolean
elsif object.is_a?(TrueClass)
GraphQL::Types::Boolean
elsif object.is_a?(Integer)
GraphQL::Types::Int
end
end
end
… which sort of works, except that when it's an array, this value comes back as a string. In GraphiQL it looks like this (we're looking at the value field):
{
"name": "top_box",
"type": "Array",
"description": "The chosen values of the scale which should be combined",
"position": 2,
"optional": false,
"value": "[\"8\", \"9\", \"10\"]"
}
We could potentially parse that in the client but ideally I'd like it to be an array of strings, like this:
{
"name": "top_box",
"type": "Array",
"description": "The chosen values of the scale which should be combined",
"position": 2,
"optional": false,
"value": [
"8",
"9",
"10"
]
},
But I can't see how to define that and the only information I could find anywhere is a brief comment in this answer to ‘GraphQL Union within Union’ which seems to suggest that it may not be possible.
Errors
If I try adding [GraphQL::Types::String] to possible_types, I get
undefined method `graphql_name' for [GraphQL::Types::String]:Array
If I try adding GraphQL::Schema::List.new(GraphQL::Types::String) to possible_types, I get
undefined method `directives' for #<GraphQL::Schema::List:0x000000010f690950 #of_type=GraphQL::Types::String>
and if I try replacing [GraphQL::Types::String] (under elsif object.is_a?(Array)) with GraphQL::Schema::List.new(GraphQL::Types::String), then I get
.resolve_type should return a type definition, but got #<GraphQL::Schema::List:0x000000010f9fd6b0
#of_type=GraphQL::Types::String> (GraphQL::Schema::List) from `resolve_type(Types::ArgumentValueType,
[\"8\", \"9\", \"10\"], #<GraphQL::Query::Context:0x000000010f8ed018>)`
Update
I managed to make an improvement by adding a wrapper class:
# frozen_string_literal: true
module Types
class ListOfStringsType < Types::BaseObject
field :values, [String]
end
end
Then, with a GraphQL query that looks a bit like this
arguments {
name
type
description
position
optional
value {
... on ListOfStrings {
values
}
}
}
It produces output like this
"arguments": [
{
"name": "top_box",
"type": "Array",
"description": "The chosen values of the scale which should be combined",
"position": 2,
"optional": false,
"value": {
"values": [
"8",
"9",
"10"
]
}
},
{
"name": "measure",
"type": "Measure",
"description": "The name of the measure to be \"top-boxed\"",
"position": 1,
"optional": false,
"value": "unique_and_different"
}
]
This is kind of okay, except that it has one extra level of indirection which I would prefer to avoid.
A colleague has pointed me at the following code, which works, but I'm afraid I still don't fully understand everything that's going on. But I will do my best to explain.
Use a Scalar
As I understand it, the idea with scalar types is that if you have your own fundamental type (normally not a complex object but just a single datum) which is none of the basic built-ins, you can define that as a scalar. (You can get a sense of examples of scalars from the graphql-scalars project). Ultimately everything is a string over the wire, of course, but in your backend you will define how to serialize your type, and in the frontend you will define how to unserialize it, and vice versa for writes of course.
So, you replace the contents of your argument_value_type.rb file up there with the following.
class Types::ArgumentValueType < Types::BaseScalar
description "A value"
def self.coerce_input(input_value, _context)
input_value
end
def self.coerce_result(ruby_value, _context)
ruby_value
end
end
As we can see from the Scalars reference:
self.coerce_input takes a GraphQL input and converts it into a Ruby value
self.coerce_result takes the return value of a field and prepares it for the GraphQL response JSON
… in other words, no conversion either way.
Then you can shove anything in there and it just comes out as-is. Assuming it's representable in JSON.
GraphQL Query
Your query is super-simple:
arguments {
name
type
description
position
optional
value // <-- this is the relevant bit
}
and you just get all the values back in whatever type they may be. Your front-end will have to handle it!
Future Improvements
Probably this could be improved to narrow it down a bit as to where it will break when an unexpected type is encountered.
Related
Consider the following json:
{
"id": "5ffhj4ksWRyt",
"name": "some name",
"custom_fields": [
"randomFieldName1": "a",
"randomFieldName2": "b"
]
id and name fields are always known, but custom_fields names are dynamic and can have any key name. Is it possible to write a schema that will take that into account ?
You can define custom_fields as a map
https://avro.apache.org/docs/current/spec.html#Maps
I am trying to retrieve only 5 first records from my query and I saw that there was the keyword "first" to do that onGraphQL. I tried and it says undefined argument. Since it is a GraphQL keyword why it does not recognize it? I am using Ruby on Rails as back-end.
This is the query
{
users(first: 5) {
id
firstName
}
}
and here is my resolver
module Queries
class User< Queries::BaseQuery
argument :id, ID, required: false
description 'Return current user'
type [OutputTypes::UserType], null: false
def resolve(id: nil)
if id
::User.where(id: id)
else
::User.all
end
end
end
end
When I try to run the query I get this error:
{
"errors": [
{
"message": "Field 'users' doesn't accept argument 'first'",
"locations": [
{
"line": 2,
"column": 9
}
],
"path": [
"query",
"users",
"first"
],
"extensions": {
"code": "argumentNotAccepted",
"name": "users",
"typeName": "Field",
"argumentName": "first"
}
}
]
}
first is not a keyword in GraphQL. GraphQL has no built-in methods for pagination, filtering, sorting, etc. -- it's up to the individual service to implement those features. Using first, last, after and before as arguments is a common pattern for doing pagination that's outlined in the Relay Cursor Connection Specification. However, this is not the only (or necessarily the best) way of doing pagination in GraphQL. You can implement whatever pattern makes sense for your specific application. However, whatever pattern you utilize, you'll need to add the appropriate arguments to your field and also implement the logic inside your resolver that makes use of those arguments' values.
I have a Rails 5 app in which I use the gem active_model_serializers(https://github.com/rails-api/active_model_serializers). In my app I have a simplified data model that looks something like this:
# LocalizedString.rb
has_many :translations
# Translation.rb
belongs_to :localized_string
I'm trying to follow the best practices from JSON API, I have configured active_model_serializers like this:
ActiveModelSerializers.config.adapter = :json_api
When a user of the API requests translations (http://[root]/api/apps/117/translations) I currently get the following result:
{
"data": [
{
"id": "152",
"type": "translations",
"attributes": {
"value": "Test",
},
"relationships": {
"language": {
"data": {
"id": "1",
"type": "languages"
}
},
"localized-string": {
"data": {
"id": "162",
"type": "localized-strings"
}
}
}
},
[...]
From my localised-string I also want to include another attribute that is critical for the consumer of the API, and I don't want to have to make another API call to get the value of the attribute. I wonder what is the best / recommended way to do this that also follows json_api if possible.
Something like this could work:
"localized-string": {
"data": {
"id": "162",
"key": "my key value", # the attribute I need.
"type": "localized-strings"
}
}
But I'm not sure how to achieve that using active_model_serializers or if it is another recommended way of doing what I want with [json_api][1].
For completion, my relevant serialiser files looks lik this:
class TranslationSerializer < ActiveModel::Serializer
attributes :id, :value, :created_at, :updated_at
has_one :language
has_one :localized_string, serializer: LocalizedStringParentSerializer
end
class LocalizedStringParentSerializer < ActiveModel::Serializer
# I want to include the key attribute in my relationship object, but this doesn't work.
attributes :id, :key
end
So, any ideas on what I need to do to achieve what I want?
Per spec, relationships are represented by resource object identifiers. To include more than just the id and type, you'll want to use the include param. In AMS, I think that would be 'include: [:localizations], fields: { localizations: [:key]}' (not at computer now, but is approx right)
I was wondering whether Grape Entity would work for rendering arrays of hashes, I thought I remebered it worked but somehow I cannot get it to work right now, am I doing some obvious mistake? Here's my Entity:
class V1::Entities::Searchresult < Grape::Entity
expose :_type, as: :type
expose :_id, as: :id
expose :_score, as: :score
expose :highlight
end
In my API I call the rendering like this:
present result['hits']['hits'], with: V1::Entities::Searchresult, :params => params
The 'result['hits']['hits']' is filled with 10 hashes that contain the data. The data is present. However when I look at the result I get:
[
{
"type": null,
"id": null,
"score": null,
"highlight": null
},
{
"type": null,
"id": null,
"score": null,
"highlight": null
},
......
Am I doing something wrong, or is this simply not possible. I can't seem to dig up any documentation on the array toppic.
Cheers
Tom
I found the error, Grape::Entity::Delegator::HashObject fails to work with hashes that have string keys and not symbols. It cannot extract the values.
data = []
result['hits']['hits'].each do |item|
data << item.symbolize_keys
end
present data, with: V1::Entities::Searchresult, :params => params
This workaround ommits the problem. I will also open a github Issue for a fix since a simple
object[attribute] || object[attribute.to_s]
would solve the whole problem instead of only using
object[attribute]
to read the attribute.
When using accepts_nested_attributes_for, instead of having to pass "child_attributes", I'd like to pass "child". I'm pretty sure if I put a lot of the logic in my controller to create the the records and children, I could accomplish this. However, in an effort to keep my controllers clean and logic where it should be, the model in this case, I'd like to know how to switch rails 3 around to use this syntax when doing a POST or PUT.
{
"name": "test",
"child_attributes": [
{
"id": 1,
"name": "test_child_update"
},
{
"name": "test_child_create"
}
}
Rather
{
"name": "test",
"child": [
{
"id": 1,
"name": "test_child_update"
},
{
"name": "test_child_create"
}
}
Evidently, this can't be done.
The _attributes suffix adds no value to JSON requests and responses, but to get rid of it in the model layer, you would have to monkey patch ActiveRecord. Everyone hates monkey-patching ActiveRecord relations.
How about doing it in the controller layer?
#comment = Comment.new(attributify(:comment))
# snip
# ApplicationController
def attributify()
# Now I'll go and write this!
end
Edit: Done. The controller mixin is here: https://gist.github.com/johncant/6056036