graphql 2.0.16 → 2.0.21

data/lib/graphql/schema/warden.rb

@@ -38,7 +38,9 @@ module GraphQL
     # @api private
     class Warden
       def self.from_context(context)
-        (context.respond_to?(:warden) && context.warden) || PassThruWarden
+        context.warden # this might be a hash which won't respond to this
+      rescue
+        PassThruWarden
       end
 
       # @param visibility_method [Symbol] a Warden method to call for this entry
@@ -80,6 +82,8 @@ module GraphQL
           def visible_type?(type, ctx); type.visible?(ctx); end
           def visible_enum_value?(ev, ctx); ev.visible?(ctx); end
           def visible_type_membership?(tm, ctx); tm.visible?(ctx); end
+          def interface_type_memberships(obj_t, ctx); obj_t.interface_type_memberships; end
+          def arguments(owner, ctx); owner.arguments(ctx); end
         end
       end
 
@@ -94,6 +98,13 @@ module GraphQL
         @subscription = @schema.subscription
         @context = context
         @visibility_cache = read_through { |m| filter.call(m, context) }
+        # Initialize all ivars to improve object shape consistency:
+        @types = @visible_types = @reachable_types = @visible_parent_fields =
+          @visible_possible_types = @visible_fields = @visible_arguments = @visible_enum_arrays =
+          @visible_enum_values = @visible_interfaces = @type_visibility = @type_memberships =
+          @visible_and_reachable_type = @unions = @unfiltered_interfaces = @references_to =
+          @reachable_type_set =
+            nil
       end
 
       # @return [Hash<String, GraphQL::BaseType>] Visible types in the schema
@@ -174,14 +185,20 @@ module GraphQL
 
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
-      def arguments(argument_owner)
-        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a) } }
+      def arguments(argument_owner, ctx = nil)
+        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a, @context) } }
         @visible_arguments[argument_owner]
       end
 
       # @return [Array<GraphQL::EnumType::EnumValue>] Visible members of `enum_defn`
       def enum_values(enum_defn)
-        @visible_enum_arrays ||= read_through { |e| e.enum_values(@context) }
+        @visible_enum_arrays ||= read_through { |e|
+          values = e.enum_values(@context)
+          if values.size == 0
+            raise GraphQL::Schema::Enum::MissingValuesError.new(e)
+          end
+          values
+        }
         @visible_enum_arrays[enum_defn]
       end
 
@@ -233,6 +250,13 @@ module GraphQL
         visible?(type_membership)
       end
 
+      def interface_type_memberships(obj_type, _ctx = nil)
+        @type_memberships ||= read_through do |obj_t|
+          obj_t.interface_type_memberships
+        end
+        @type_memberships[obj_type]
+      end
+
       private
 
       def visible_and_reachable_type?(type_defn)
@@ -332,7 +356,7 @@ module GraphQL
       end
 
       def reachable_type_set
-        return @reachable_type_set if defined?(@reachable_type_set)
+        return @reachable_type_set if @reachable_type_set
 
         @reachable_type_set = Set.new
         rt_hash = {}

data/lib/graphql/schema.rb

@@ -62,7 +62,7 @@ module GraphQL
   # Schemas can specify how queries should be executed against them.
   # `query_execution_strategy`, `mutation_execution_strategy` and `subscription_execution_strategy`
   # each apply to corresponding root types.
-  #  #
+  #
   # @example defining a schema
   #   class MySchema < GraphQL::Schema
   #     query QueryType
@@ -143,6 +143,43 @@ module GraphQL
         @subscriptions = new_implementation
       end
 
+      def trace_class(new_class = nil)
+        if new_class
+          trace_mode(:default, new_class)
+          backtrace_class = Class.new(new_class)
+          backtrace_class.include(GraphQL::Backtrace::Trace)
+          trace_mode(:default_backtrace, backtrace_class)
+        end
+        trace_class_for(:default)
+      end
+
+      # @return [Class] Return the trace class to use for this mode, looking one up on the superclass if this Schema doesn't have one defined.
+      def trace_class_for(mode)
+        @trace_modes ||= {}
+        @trace_modes[mode] ||= begin
+          base_class = if superclass.respond_to?(:trace_class_for)
+            superclass.trace_class_for(mode)
+          elsif mode == :default_backtrace
+            GraphQL::Backtrace::DefaultBacktraceTrace
+          else
+            GraphQL::Tracing::Trace
+          end
+          Class.new(base_class)
+        end
+      end
+
+      # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
+      # `:default` is used when no `trace_mode: ...` is requested.
+      # @param mode_name [Symbol]
+      # @param trace_class [Class] subclass of GraphQL::Tracing::Trace
+      # @return void
+      def trace_mode(mode_name, trace_class)
+        @trace_modes ||= {}
+        @trace_modes[mode_name] = trace_class
+        nil
+      end
+
+
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
       # @return [String]
@@ -207,7 +244,7 @@ module GraphQL
       end
 
       def default_filter
-        GraphQL::Filter.new(except: default_mask)
+        GraphQL::Filter.new(except: default_mask, silence_deprecation_warning: true)
       end
 
       def default_mask(new_mask = nil)
@@ -755,7 +792,7 @@ module GraphQL
         if handler
           obj = context[:current_object]
           args = context[:current_arguments]
-          args = args && args.keyword_arguments
+          args = args && args.respond_to?(:keyword_arguments) ? args.keyword_arguments : nil
           field = context[:current_field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
@@ -785,11 +822,7 @@ module GraphQL
             end
 
             if resolved_type.nil? || (resolved_type.is_a?(Module) && resolved_type.respond_to?(:kind))
-              if resolved_value
-                [resolved_type, resolved_value]
-              else
-                resolved_type
-              end
+              [resolved_type, resolved_value]
             else
               raise ".resolve_type should return a type definition, but got #{resolved_type.inspect} (#{resolved_type.class}) from `resolve_type(#{type}, #{obj}, #{ctx})`"
             end
@@ -826,10 +859,6 @@ module GraphQL
         member.visible?(ctx)
       end
 
-      def accessible?(member, ctx)
-        member.accessible?(ctx)
-      end
-
       def schema_directive(dir_class, **options)
         @own_schema_directives ||= []
         Member::HasDirectives.add_directive(self, @own_schema_directives, dir_class, options)
@@ -839,18 +868,6 @@ module GraphQL
         Member::HasDirectives.get_directives(self, @own_schema_directives, :schema_directives)
       end
 
-      # This hook is called when a client tries to access one or more
-      # fields that fail the `accessible?` check.
-      #
-      # By default, an error is added to the response. Override this hook to
-      # track metrics or return a different error to the client.
-      #
-      # @param error [InaccessibleFieldsError] The analysis error for this check
-      # @return [AnalysisError, nil] Return an error to skip the query
-      def inaccessible_fields(error)
-        error
-      end
-
       # This hook is called when an object fails an `authorized?` check.
       # You might report to your bug tracker here, so you can correct
       # the field resolvers not to return unauthorized objects.
@@ -900,7 +917,7 @@ module GraphQL
       # A function to call when {#execute} receives an invalid query string
       #
       # The default is to add the error to `context.errors`
-      # @param err [GraphQL::ParseError] The error encountered during parsing
+      # @param parse_err [GraphQL::ParseError] The error encountered during parsing
       # @param ctx [GraphQL::Query::Context] The context for the query where the error occurred
       # @return void
       def parse_error(parse_err, ctx)
@@ -942,6 +959,12 @@ module GraphQL
       end
 
       def tracer(new_tracer)
+        if defined?(@trace_modes) && !(trace_class_for(:default) < GraphQL::Tracing::LegacyTrace)
+          raise ArgumentError, "Can't add tracer after configuring a `trace_class`, use GraphQL::Tracing::LegacyTrace to merge legacy tracers into a trace class instead."
+        else
+          trace_mode(:default, Class.new(GraphQL::Tracing::LegacyTrace))
+        end
+
         own_tracers << new_tracer
       end
 
@@ -949,6 +972,34 @@ module GraphQL
         find_inherited_value(:tracers, EMPTY_ARRAY) + own_tracers
       end
 
+      # Mix `trace_mod` into this schema's `Trace` class so that its methods
+      # will be called at runtime.
+      #
+      # @param trace_mod [Module] A module that implements tracing methods
+      # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
+      # @return [void]
+      def trace_with(trace_mod, **options)
+        trace_options.merge!(options)
+        trace_class.include(trace_mod)
+      end
+
+      def trace_options
+        @trace_options ||= superclass.respond_to?(:trace_options) ? superclass.trace_options.dup : {}
+      end
+
+      def new_trace(**options)
+        if defined?(@trace_options)
+          options = trace_options.merge(options)
+        end
+        trace_mode = if (target = options[:query] || options[:multiplex]) && target.context[:backtrace]
+          :default_backtrace
+        else
+          :default
+        end
+        trace = trace_class_for(trace_mode).new(**options)
+        trace
+      end
+
       def query_analyzer(new_analyzer)
         own_query_analyzers << new_analyzer
       end

data/lib/graphql/static_validation/literal_validator.rb

@@ -18,6 +18,19 @@ module GraphQL
 
       private
 
+      def replace_nulls_in(ast_value)
+        case ast_value
+        when Array
+          ast_value.map { |v| replace_nulls_in(v) }
+        when GraphQL::Language::Nodes::InputObject
+          ast_value.to_h
+        when GraphQL::Language::Nodes::NullValue
+          nil
+        else
+          ast_value
+        end
+      end
+
       def recursively_validate(ast_value, type)
         if type.nil?
           # this means we're an undefined argument, see #present_input_field_values_are_valid
@@ -42,7 +55,8 @@ module GraphQL
           @valid_response
         elsif type.kind.scalar? && constant_scalar?(ast_value)
           maybe_raise_if_invalid(ast_value) do
-            type.validate_input(ast_value, @context)
+            ruby_value = replace_nulls_in(ast_value)
+            type.validate_input(ruby_value, @context)
           end
         elsif type.kind.enum?
           maybe_raise_if_invalid(ast_value) do

data/lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb

@@ -26,11 +26,19 @@ module GraphQL
         msg = if resolved_type.nil?
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
-          if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
-          else
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+          selection_strs = ast_node.selections.map do |n|
+            case n
+            when GraphQL::Language::Nodes::InlineFragment
+              "\"... on #{n.type.name} { ... }\""
+            when GraphQL::Language::Nodes::Field
+              "\"#{n.name}\""
+            when GraphQL::Language::Nodes::FragmentSpread
+              "\"#{n.name}\""
+            else
+              raise "Invariant: unexpected selection node: #{n}"
+            end
           end
+          "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
         elsif resolved_type.kind.fields? && ast_node.selections.empty?
           "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -9,7 +9,7 @@ module GraphQL
       # without ambiguity.
       #
       # Original Algorithm: https://github.com/graphql/graphql-js/blob/master/src/validation/rules/OverlappingFieldsCanBeMerged.js
-      NO_ARGS = {}.freeze
+      NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
       Field = Struct.new(:node, :definition, :owner_type, :parents)
       FragmentSpread = Struct.new(:name, :parents)
@@ -323,7 +323,7 @@ module GraphQL
         end
       end
 
-      NO_SELECTIONS = [{}.freeze, [].freeze].freeze
+      NO_SELECTIONS = [GraphQL::EmptyObjects::EMPTY_HASH, GraphQL::EmptyObjects::EMPTY_ARRAY].freeze
 
       def fields_and_fragments_from_selection(node, owner_type:, parents:)
         if node.selections.empty?

data/lib/graphql/static_validation/validator.rb

@@ -27,7 +27,7 @@ module GraphQL
       # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
-        query.trace("validate", { validate: validate, query: query }) do
+        query.current_trace.validate(validate: validate, query: query) do
           errors = if validate == false
             []
           else

data/lib/graphql/subscriptions/event.rb

@@ -100,13 +100,8 @@ module GraphQL
               arg_name = k.to_s
               camelized_arg_name = GraphQL::Schema::Member::BuildType.camelize(arg_name)
               arg_defn = get_arg_definition(arg_owner, camelized_arg_name, context)
-
-              if arg_defn
-                normalized_arg_name = camelized_arg_name
-              else
-                normalized_arg_name = arg_name
-                arg_defn = get_arg_definition(arg_owner, normalized_arg_name, context)
-              end
+              arg_defn ||= get_arg_definition(arg_owner, arg_name, context)
+              normalized_arg_name = arg_defn.graphql_name
               arg_base_type = arg_defn.type.unwrap
               # In the case where the value being emitted is seen as a "JSON"
               # type, treat the value as one atomic unit of serialization

data/lib/graphql/tracing/active_support_notifications_trace.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'graphql/tracing/notifications_trace'
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to ActiveSupport::Notifications
+    # with a `graphql` suffix.
+    module ActiveSupportNotificationsTrace
+      include NotificationsTrace
+      def initialize(engine: ActiveSupport::Notifications, **rest)
+        super
+      end
+    end
+  end
+end

data/lib/graphql/tracing/appoptics_trace.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+
+    # This class uses the AppopticsAPM SDK from the appoptics_apm gem to create
+    # traces for GraphQL.
+    #
+    # There are 4 configurations available. They can be set in the
+    # appoptics_apm config file or in code. Please see:
+    # {https://docs.appoptics.com/kb/apm_tracing/ruby/configure}
+    #
+    #     AppOpticsAPM::Config[:graphql][:enabled] = true|false
+    #     AppOpticsAPM::Config[:graphql][:transaction_name]  = true|false
+    #     AppOpticsAPM::Config[:graphql][:sanitize_query] = true|false
+    #     AppOpticsAPM::Config[:graphql][:remove_comments] = true|false
+    module AppOpticsTrace
+      # These GraphQL events will show up as 'graphql.prep' spans
+      PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
+      # These GraphQL events will show up as 'graphql.execute' spans
+      EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
+
+      # During auto-instrumentation this version of AppOpticsTracing is compared
+      # with the version provided in the appoptics_apm gem, so that the newer
+      # version of the class can be used
+
+      def self.version
+        Gem::Version.new('1.0.0')
+      end
+
+      [
+        'lex',
+        'parse',
+        'validate',
+        'analyze_query',
+        'analyze_multiplex',
+        'execute_multiplex',
+        'execute_query',
+        'execute_query_lazy',
+      ].each do |trace_method|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**data)
+            return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+            layer = span_name("#{trace_method}")
+            kvs = metadata(data, layer)
+            kvs[:Key] = "#{trace_method}" if (PREP_KEYS + EXEC_KEYS).include?("#{trace_method}")
+
+            transaction_name(kvs[:InboundQuery]) if kvs[:InboundQuery] && layer == 'graphql.execute'
+
+            ::AppOpticsAPM::SDK.trace(layer, kvs) do
+              kvs.clear # we don't have to send them twice
+              super
+            end
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key, data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = platform_key
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          yield
+        end
+      end
+
+      def authorized(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_authorized_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def authorized_lazy(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_authorized_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def resolve_type(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_resolve_type_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def resolve_type_lazy(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_resolve_type_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      include PlatformTrace
+
+      def platform_field_key(field)
+        "graphql.#{field.owner.graphql_name}.#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "graphql.authorized.#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "graphql.resolve_type.#{type.graphql_name}"
+      end
+
+      private
+
+      def gql_config
+        ::AppOpticsAPM::Config[:graphql] ||= {}
+      end
+
+      def transaction_name(query)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        split_query = query.strip.split(/\W+/, 3)
+        split_query[0] = 'query' if split_query[0].empty?
+        name = "graphql.#{split_query[0..1].join('.')}"
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def multiplex_transaction_name(names)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        name = "graphql.multiplex.#{names.join('.')}"
+        name = "#{name[0..251]}..." if name.length > 254
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def span_name(key)
+        return 'graphql.prep' if PREP_KEYS.include?(key)
+        return 'graphql.execute' if EXEC_KEYS.include?(key)
+
+        key[/^graphql\./] ? key : "graphql.#{key}"
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def metadata(data, layer)
+        data.keys.map do |key|
+          case key
+          when :context
+            graphql_context(data[key], layer)
+          when :query
+            graphql_query(data[key])
+          when :query_string
+            graphql_query_string(data[key])
+          when :multiplex
+            graphql_multiplex(data[key])
+          when :path
+            [key, data[key].join(".")]
+          else
+            [key, data[key]]
+          end
+        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def graphql_context(context, layer)
+        context.errors && context.errors.each do |err|
+          AppOpticsAPM::API.log_exception(layer, err)
+        end
+
+        [[:Path, context.path.join('.')]]
+      end
+
+      def graphql_query(query)
+        return [] unless query
+
+        query_string = query.query_string
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [[:InboundQuery, query_string],
+         [:Operation, query.selected_operation_name]]
+      end
+
+      def graphql_query_string(query_string)
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [:InboundQuery, query_string]
+      end
+
+      def graphql_multiplex(data)
+        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        multiplex_transaction_name(names) if names.size > 1
+
+        [:Operations, names.join(', ')]
+      end
+
+      def sanitize(query)
+        return unless query
+
+        # remove arguments
+        query.gsub(/"[^"]*"/, '"?"')                 # strings
+          .gsub(/-?[0-9]*\.?[0-9]+e?[0-9]*/, '?') # ints + floats
+          .gsub(/\[[^\]]*\]/, '[?]')              # arrays
+      end
+
+      def remove_comments(query)
+        return unless query
+
+        query.gsub(/#[^\n\r]*/, '')
+      end
+    end
+  end
+end

data/lib/graphql/tracing/appsignal_trace.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module AppsignalTrace
+      include PlatformTrace
+
+      # @param set_action_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_appsignal_action_name]`.
+      def initialize(set_action_name: false, **rest)
+        @set_action_name = set_action_name
+        super
+      end
+
+      {
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_query" => "analyze.graphql",
+        "analyze_multiplex" => "analyze.graphql",
+        "execute_multiplex" => "execute.graphql",
+        "execute_query" => "execute.graphql",
+        "execute_query_lazy" => "execute.graphql",
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**data)
+            #{
+              if trace_method == "execute_query"
+                <<-RUBY
+                set_this_txn_name =  data[:query].context[:set_appsignal_action_name]
+                if set_this_txn_name == true || (set_this_txn_name.nil? && @set_action_name)
+                  Appsignal::Transaction.current.set_action(transaction_name(data[:query]))
+                end
+                RUBY
+              end
+            }
+
+            Appsignal.instrument("#{platform_key}") do
+              super
+            end
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key)
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
+      def platform_authorized(platform_key)
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
+      def platform_resolve_type(platform_key)
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(field)
+        "#{field.owner.graphql_name}.#{field.graphql_name}.graphql"
+      end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized.graphql"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type.graphql"
+      end
+    end
+  end
+end