Interface Visibility

[timlkelly]

I'm using visibility to hide portions of the schema. I've added .visible? to the BaseType, which allows me to hide the majority of the schema. However, both Interfaces and Unions are still present in the Schema when they're listed as fields on the QueryType.

If I understand the documentation correctly, this is working as intended, and is called out at the bottom of the guide on Visibility:

Previously, Warden hid interface and union types which had no possible types. Visibility doesn’t check possible types (in order to support performance improvements), so those types must return false for visible? in the same cases where all possible types were hidden. Otherwise, that interface or union type will be visible but have no possible types.

As suggested, I've been able to hide Union fields where all possible types are hidden using something like this:

class BaseUnion < GraphQL::Schema::Union
  def self.visible?(context)
    super && possible_types.any? do |type|
      type.visible_apps.include?(context[:visibility_profile])
    end
  end
end

However, I'm not sure how to accomplish the same goal with an Interface. I was looking at GraphQL::Schema::Member::HasInterfaces#interface_type_memberships but this is always empty when I view it from the Interface's .visible?

Here's a rough example to detail the setup, and I am using version 2.5.11.

class QueryType < GraphQL::Schema::Object
  field :post, resolver: Resolvers::Post
end

module Resolvers
  class Post < BaseResolver
    type Types::Post, null: true

    def resolve; end
  end
end

module Types
  module BaseInterface
    include GraphQL::Schema::Interface

    definition_methods do
      def visible?(context)
        # return true if any of the Interface implementations are visible; else false
        super
      end
    end
  end
end

module Types
  module Post
    include Types::BaseInterface

    field :foo, String
  end
end

module Types
  class Image < Types::BaseObject
    implements Types::Post
  end
end

module Types
  class Text < Types::BaseObject
    implements Types::Post
  end
end

Am I understanding Union and Interface Visibility correctly? And if so, how can I check if all of the Interface implementations are visible to hide the Interface itself from the Schema?

[rmosolgo]

Hey, yes, it sounds to me like you understand it correctly.

The thing about an interface's interface_type_memberships is that it would contain other interfaces which this interface implements, not the objects that implement this interface.

Instead of referencing other GraphQL types inside .visible?, could you call the same code that those object types call in their .visible? methods? For example, if Types::Text checks can_see_text? and Types::Image checks can_see_images?, then Types::Post could check can_see_text? || can_see_images?.

(For background, interfaces don't store lists of their implementers because it would force them to all be eager-loaded in development -- but GraphQL-Ruby supports lazy-loading types as they're necessary, so that would be "bug".)

[timlkelly]

Okay, got it, that makes sense. I was hoping to find a way to declare the visibility setting within the Interface Implementations and then programmatically determine Visibility from the BaseInterface to avoid needing to explicitly declare all of the visibility checks in each Interface because it'll be very easy for developers to forget to update the Interface's .visible? method when they add a new Interface Implementation.

I'm looking to use Visibility to create separate Schemas for the different applications that use this GraphQL API. Currently, only one application uses this API. I am now trying to introduce additional applications and only expose the relevant portions of the Schema to each application. I was hoping that Visibility could allow me to exclude portions of the schemas where there is no overlap between the different apps, but also allow us to share Types, Fields, Mutations, etc., across schemas when there is commonality.

I'm curious if you have any feedback on this usage of Visibility. I've been able to set this up for BaseType, here's a code snippet which might provide more context. But as you've mentioned, it sounds like any attempt to do this programmatically for Interfaces would require tracking details of every object that implements an Interface, and that will have performance implications. So, for now it's probably best to ensure that every Interface Module defines the .visibile?.

class Schema < GraphQL::Schema
  use GraphQL::Schema::Visibility, profiles: {
    app_one: {},
    app_two: {},
    app_three: {}
  }
end

module Types
  class BaseType < GraphQL::Schema::Object 
    def self.visible_apps(*args)
      if args.any?
        @visible_apps = Array.wrap(args)
      else
        @visible_apps.presence || [:app_one] # default app during transition
      end
    end

    def self.visible?(context)
      super && visible_apps.include?(context[:visibility_profile])
    end
  end
end

module Types
  module BaseInterface
    include GraphQL::Schema::Interface

    definition_methods do
      def visible?(context)
        # return true if any of the Interface implementations are visible; else false
        super
      end
    end
  end
end

class BaseUnion < GraphQL::Schema::Union
  def self.visible?(context)
    super && possible_types.any? do |type|
      type.visible_apps.include?(context[:visibility_profile])
    end
  end
end

class QueryType < GraphQL::Schema::Object
  field :post, [Types::Post]
  field :foo, Types::Foo
  field :my_union, [Types::MyUnion]
end

module Types
  module Post
    include Types::BaseInterface

    field :blah, String
  end
end

module Types
  class Image < Types::BaseType
    implements Types::Post

    visible_apps :app_two
  end
end

module Types
  class Text < Types::BaseType
    implements Types::Post

    visible_apps :app_two
  end
end


module Types
  class Foo < Types::BaseType
    visible_apps :app_two

    field :id, ID
    field :cake, String
  end
end

module Types
  class Bar < Types::BaseType
    visible_apps :app_one, :app_two

    field :blah, String
  end
end

module Types
  class Baz < Types::BaseType
    visible_apps :app_two

    field :asdf, String
  end
end

module Types
  class MyUnion < BaseUnion
    possible_types(Types::Bar, Types::Baz)
  end
end