Allow interfaces to implement other interfaces

[jturkel]

The next version of the GraphQL spec (which I believe will be released at the end March 2020) allows interfaces to implement other interfaces. See the RFC more details. Any plans to support this in graphql-ruby? I'd be happy to pitch in and help if needed.

[rmosolgo]

Thanks for the update on this change. I think we already support this in implemenation via:

module SomeGeneralInterface 
  include GraphQL::Schema::Interface 
end 

module SomeSpecificInterface 
  include SomeGeneralInterface 
end 

(I think that will give SomeSpecificInterface all the fields from SomeGeneralInterface, along with its own fields.)

But, we could make it first-class graphql with:

• Adding implements(...) to interface definition modules;
• When implements(...) is used, track the parent interface in the child's self.interfaces (just like GraphQL::Schema::Object -- maybe it could be extracted out into GraphQL::Schema::Member::HasInterfaces)
• Make sure that the schema printer and introspection system return interfaces on interfaces

If you want to take a crack at it, go for it!

[sshaw]

The above example does not translate well client-side. (Well, I assume GraphQL's update does accounts for the following, would be a big miss if not!)

If the schema requires a field be of type SomeGeneralInterface, one cannot say implements SomeSpecificInterface and satisfy this.

[vpetkar]

Looks like the spec has been updated to accommodate this!

Although we can side-step the issue by including the interface into another interface, the outputted GraphQL schema is incorrect. We need to support implements within an interface definition module to support the behaviour properly.

E.g.

module Savable
   include(GraphQL::Schema::Interface)
   include(GraphQL::Types::Relay::Node)
   field :is_saved, Boolean, null: false
end

interface Savable {
   id: ID,
   isSaved: Boolean
}

However, it should actually be this:

interface Savable implements Node {
   id: ID,
   isSaved: Boolean
}

[butsjoh]

I would like to know the current status on this and if it is expected to work like this.

I also have an interface with some orphan types

module Graph
  module Types
    module FileInterface
      include ::GraphQL::Schema::Interface
      include ::GraphQL::Types::Relay::Node
      
      graphql_name 'File'

      connection_type_class Graph::BaseConnection
      edge_type_class Types::FileEdgeType

      orphan_types Types::ImageType, Types::AudioType, Types::VideoType, Types::DocumentType
     ...
     end
   end
end

Example orphan type:

module Graph
  module Types
    class DocumentType < GraphQL::Schema::Object
      implements Types::FileInterface

      graphql_name 'Document'
    end
  end
end

But when i then do the node query:

query file($id: ID!) {
  node(id: $id) {
    __typename
    ... on File {
      id
    }
  }
}

i always get:

#<GraphQL::Query::Result @query=... @to_h={"errors"=>[{"message"=>"Fragment on File can't be spread inside Node", "locations"=>[{"line"=>5, "column"=>11}], "path"=>["query file", "node", "... on File"], "extensions"=>{"code"=>"cannotSpreadFragment", "typeName"=>"File", "fragmentName"=>"unknown", "parentName"=>"Node"}}]}>

and indeed in the generated schema it is as follows:

interface File {
  """
  The id of the file
  """
  id: ID!

 ...

I also tried moving implements GraphQL::Types::Relay::Node to each of the orphan types but same errors pop up even if i would do ... on Document. Would like to know what i am doing wrong.

[rmosolgo]

Implementation in the works at #3613