graphql 1.7.6 → 1.8.0

data/lib/graphql/schema.rb

@@ -3,7 +3,10 @@ require "graphql/schema/base_64_encoder"
 require "graphql/schema/catchall_middleware"
 require "graphql/schema/default_parse_error"
 require "graphql/schema/default_type_error"
+require "graphql/schema/finder"
 require "graphql/schema/invalid_type_error"
+require "graphql/schema/introspection_system"
+require "graphql/schema/late_bound_type"
 require "graphql/schema/middleware_chain"
 require "graphql/schema/null_mask"
 require "graphql/schema/possible_types"
@@ -16,6 +19,23 @@ require "graphql/schema/validation"
 require "graphql/schema/warden"
 require "graphql/schema/build_from_definition"
 
+
+require "graphql/schema/member"
+require "graphql/schema/list"
+require "graphql/schema/non_null"
+require "graphql/schema/argument"
+require "graphql/schema/enum_value"
+require "graphql/schema/enum"
+require "graphql/schema/field"
+require "graphql/schema/input_object"
+require "graphql/schema/interface"
+require "graphql/schema/resolver"
+require "graphql/schema/mutation"
+require "graphql/schema/relay_classic_mutation"
+require "graphql/schema/object"
+require "graphql/schema/scalar"
+require "graphql/schema/union"
+
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
   #
@@ -49,6 +69,7 @@ module GraphQL
   #   end
   #
   class Schema
+    extend GraphQL::Schema::Member::AcceptsDefinition
     include GraphQL::Define::InstanceDefinable
     accepts_definitions \
       :query, :mutation, :subscription,
@@ -80,7 +101,9 @@ module GraphQL
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
-      :raise_definition_error
+      :ast_node,
+      :raise_definition_error,
+      :introspection_namespace
 
     # Single, long-lived instance of the provided subscriptions class, if there is one.
     # @return [GraphQL::Subscriptions]
@@ -93,6 +116,10 @@ module GraphQL
     # @see {Query.new} for query-specific filters with `except:`
     attr_accessor :default_mask
 
+    # @see {GraphQL::Query::Context} The parent class of these classes
+    # @return [Class] Instantiated for each query
+    attr_accessor :context_class
+
     class << self
       attr_accessor :default_execution_strategy
     end
@@ -137,6 +164,9 @@ module GraphQL
       @subscription_execution_strategy = self.class.default_execution_strategy
       @default_mask = GraphQL::Schema::NullMask
       @rebuilding_artifacts = false
+      @context_class = GraphQL::Query::Context
+      @introspection_namespace = nil
+      @introspection_system = nil
     end
 
     def initialize_copy(other)
@@ -164,6 +194,7 @@ module GraphQL
       # This will be rebuilt when it's requested
       # or during a later `define` call
       @types = nil
+      @introspection_system = nil
     end
 
     def rescue_from(*args, &block)
@@ -174,6 +205,9 @@ module GraphQL
       rescue_middleware.remove_handler(*args, &block)
     end
 
+    # For forwards-compatibility with Schema classes
+    alias :graphql_definition :itself
+
     # Validate a query string according to this schema.
     # @param string_or_document [String, GraphQL::Language::Nodes::Document]
     # @return [Array<GraphQL::StaticValidation::Message>]
@@ -239,6 +273,14 @@ module GraphQL
       end
     end
 
+    # @api private
+    def introspection_system
+      @introspection_system ||= begin
+        rebuild_artifacts
+        @introspection_system
+      end
+    end
+
     # Returns a list of Arguments and Fields referencing a certain type
     # @param type_name [String]
     # @return [Hash]
@@ -300,6 +342,19 @@ module GraphQL
       }
     end
 
+    # Search for a schema member using a string path
+    # @example Finding a Field
+    # Schema.find("Ensemble.musicians")
+    #
+    # @see {GraphQL::Schema::Finder} for more examples
+    # @param path [String] A dot-separated path to the member
+    # @raise [Schema::Finder::MemberNotFoundError] if path could not be found
+    # @return [GraphQL::BaseType, GraphQL::Field, GraphQL::Argument, GraphQL::Directive] A GraphQL Schema Member
+    def find(path)
+      rebuild_artifacts unless defined?(@finder)
+      @find_cache[path] ||= @finder.find(path)
+    end
+
     # Resolve field named `field_name` for type `parent_type`.
     # Handles dynamic fields `__typename`, `__type` and `__schema`, too
     # @param parent_type [String, GraphQL::BaseType]
@@ -320,12 +375,10 @@ module GraphQL
         defined_field = @instrumented_field_map[parent_type_name][field_name]
         if defined_field
           defined_field
-        elsif field_name == "__typename"
-          GraphQL::Introspection::TypenameField
-        elsif field_name == "__schema" && parent_type == query
-          GraphQL::Introspection::SchemaField
-        elsif field_name == "__type" && parent_type == query
-          GraphQL::Introspection::TypeByNameField
+        elsif parent_type == query && (entry_point_field = introspection_system.entry_point(name: field_name))
+          entry_point_field
+        elsif (dynamic_field = introspection_system.dynamic_field(name: field_name))
+          dynamic_field
         else
           nil
         end
@@ -386,6 +439,18 @@ module GraphQL
     # @param ctx [GraphQL::Query::Context] The context for the current query
     # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
     def resolve_type(type, object, ctx = :__undefined__)
+      check_resolved_type(type, object, ctx) do |ok_type, ok_object, ok_ctx|
+        if @resolve_type_proc.nil?
+          raise(NotImplementedError, "Can't determine GraphQL type for: #{ok_object.inspect}, define `resolve_type (type, obj, ctx) -> { ... }` inside `Schema.define`.")
+        end
+        @resolve_type_proc.call(ok_type, ok_object, ok_ctx)
+      end
+    end
+
+    # This is a compatibility hack so that instance-level and class-level
+    # methods can get correctness checks without calling one another
+    # @api private
+    def check_resolved_type(type, object, ctx = :__undefined__)
       if ctx == :__undefined__
         # Old method signature
         ctx = object
@@ -393,15 +458,20 @@ module GraphQL
         type = nil
       end
 
+      if object.is_a?(GraphQL::Schema::Object)
+        object = object.object
+      end
+
       # Prefer a type-local function; fall back to the schema-level function
       type_proc = type && type.resolve_type_proc
       type_result = if type_proc
         type_proc.call(object, ctx)
       else
-        if @resolve_type_proc.nil?
-          raise(NotImplementedError, "Can't determine GraphQL type for: #{object.inspect}, define `resolve_type (type, obj, ctx) -> { ... }` inside `Schema.define`.")
-        end
-        @resolve_type_proc.call(type, object, ctx)
+        yield(type, object, ctx)
+      end
+
+      if type_result.respond_to?(:graphql_definition)
+        type_result = type_result.graphql_definition
       end
 
       if type_result.nil?
@@ -542,13 +612,19 @@ module GraphQL
       GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
     end
 
+    # Return the GraphQL::Language::Document IDL AST for the schema
+    # @return [GraphQL::Language::Document]
+    def to_document
+      GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
+    end
+
     # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
     # @param context [Hash]
     # @param only [<#call(member, ctx)>]
     # @param except [<#call(member, ctx)>]
     # @return [Hash] GraphQL result
     def as_json(only: nil, except: nil, context: {})
-      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context)
+      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context).to_h
     end
 
     # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
@@ -558,6 +634,295 @@ module GraphQL
       JSON.pretty_generate(as_json(*args))
     end
 
+    class << self
+      extend Forwardable
+      # For compatibility, these methods all:
+      # - Cause the Schema instance to be created, if it hasn't been created yet
+      # - Delegate to that instance
+      # Eventually, the methods will be moved into this class, removing the need for the singleton.
+      def_delegators :graphql_definition,
+        # Schema structure
+        :as_json, :to_json, :to_document, :to_definition,
+        # Execution
+        :execute, :multiplex,
+        :static_validator, :introspection_system,
+        :query_analyzers, :middleware, :tracers, :instrumenters,
+        :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
+        :validate, :multiplex_analyzers, :lazy?, :lazy_method_name,
+        # Configuration
+        :max_complexity=, :max_depth=,
+        :metadata,
+        :default_filter, :redefine,
+        :id_from_object_proc, :object_from_id_proc,
+        :id_from_object=, :object_from_id=, :type_error,
+        :remove_handler,
+        # Members
+        :types, :get_fields, :find,
+        :root_type_for_operation,
+        :subscriptions,
+        :union_memberships,
+        :get_field, :root_types, :references_to, :type_from_ast,
+        :possible_types, :get_field
+
+      def graphql_definition
+        @graphql_definition ||= to_graphql
+      end
+
+      def use(plugin, options = {})
+        plugins << [plugin, options]
+      end
+
+      def plugins
+        @plugins ||= []
+      end
+
+      def to_graphql
+        schema_defn = self.new
+        schema_defn.raise_definition_error = true
+        schema_defn.query = query
+        schema_defn.mutation = mutation
+        schema_defn.subscription = subscription
+        schema_defn.max_complexity = max_complexity
+        schema_defn.max_depth = max_depth
+        schema_defn.default_max_page_size = default_max_page_size
+        schema_defn.orphan_types = orphan_types
+        schema_defn.directives = directives
+        schema_defn.introspection_namespace = introspection
+        schema_defn.resolve_type = method(:resolve_type)
+        schema_defn.object_from_id = method(:object_from_id)
+        schema_defn.id_from_object = method(:id_from_object)
+        schema_defn.type_error = method(:type_error)
+        schema_defn.context_class = context_class
+        schema_defn.cursor_encoder = cursor_encoder
+        schema_defn.tracers.concat(defined_tracers)
+        schema_defn.query_analyzers.concat(defined_query_analyzers)
+        schema_defn.middleware.concat(defined_middleware)
+        schema_defn.multiplex_analyzers.concat(defined_multiplex_analyzers)
+        defined_instrumenters.each do |step, insts|
+          insts.each do |inst|
+            schema_defn.instrumenters[step] << inst
+          end
+        end
+        schema_defn.instrumenters[:query] << GraphQL::Schema::Member::Instrumentation
+        lazy_classes.each do |lazy_class, value_method|
+          schema_defn.lazy_methods.set(lazy_class, value_method)
+        end
+        if @rescues
+          @rescues.each do |err_class, handler|
+            schema_defn.rescue_from(err_class, &handler)
+          end
+        end
+
+        if plugins.any?
+          schema_plugins = plugins
+          # TODO don't depend on .define
+          schema_defn = schema_defn.redefine do
+            schema_plugins.each do |plugin, options|
+              if options.any?
+                use(plugin, **options)
+              else
+                use(plugin)
+              end
+            end
+          end
+        end
+        schema_defn.send(:rebuild_artifacts)
+
+        schema_defn
+      end
+
+      def query(new_query_object = nil)
+        if new_query_object
+          @query_object = new_query_object
+        else
+          @query_object.respond_to?(:graphql_definition) ? @query_object.graphql_definition : @query_object
+        end
+      end
+
+      def mutation(new_mutation_object = nil)
+        if new_mutation_object
+          @mutation_object = new_mutation_object
+        else
+          @mutation_object.respond_to?(:graphql_definition) ? @mutation_object.graphql_definition : @mutation_object
+        end
+      end
+
+      def subscription(new_subscription_object = nil)
+        if new_subscription_object
+          @subscription_object = new_subscription_object
+        else
+          @subscription_object.respond_to?(:graphql_definition) ? @subscription_object.graphql_definition : @subscription_object
+        end
+      end
+
+      def introspection(new_introspection_namespace = nil)
+        if new_introspection_namespace
+          @introspection = new_introspection_namespace
+        else
+          @introspection
+        end
+      end
+
+      def cursor_encoder(new_encoder = nil)
+        if new_encoder
+          @cursor_encoder = new_encoder
+        end
+        @cursor_encoder || Base64Encoder
+      end
+
+      def default_max_page_size(new_default_max_page_size = nil)
+        if new_default_max_page_size
+          @default_max_page_size = new_default_max_page_size
+        else
+          @default_max_page_size
+        end
+      end
+
+      def max_complexity(max_complexity = nil)
+        if max_complexity
+          @max_complexity = max_complexity
+        else
+          @max_complexity
+        end
+      end
+
+      def max_depth(new_max_depth = nil)
+        if new_max_depth
+          @max_depth = new_max_depth
+        else
+          @max_depth
+        end
+      end
+
+      def orphan_types(*new_orphan_types)
+        if new_orphan_types.any?
+          @orphan_types = new_orphan_types.flatten
+        else
+          @orphan_types || []
+        end
+      end
+
+      def default_execution_strategy
+        if superclass <= GraphQL::Schema
+          superclass.default_execution_strategy
+        else
+          @default_execution_strategy
+        end
+      end
+
+      def context_class(new_context_class = nil)
+        if new_context_class
+          @context_class = new_context_class
+        else
+          @context_class || GraphQL::Query::Context
+        end
+      end
+
+      def rescue_from(err_class, &handler_block)
+        @rescues ||= {}
+        @rescues[err_class] = handler_block
+      end
+
+      def resolve_type(type, obj, ctx)
+        raise NotImplementedError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
+      end
+
+      def object_from_id(node_id, ctx)
+        raise NotImplementedError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to use the `node` field (tried to load from id `#{node_id}`)"
+      end
+
+      def id_from_object(object, type, ctx)
+        raise NotImplementedError, "#{self.name}.id_from_object(object, type, ctx) must be implemented to create global ids (tried to create an id for `#{object.inspect}`)"
+      end
+
+      def type_error(type_err, ctx)
+        DefaultTypeError.call(type_err, ctx)
+      end
+
+      def lazy_resolve(lazy_class, value_method)
+        lazy_classes[lazy_class] = value_method
+      end
+
+      def instrument(instrument_step, instrumenter, options = {})
+        step = if instrument_step == :field && options[:after_built_ins]
+          :field_after_built_ins
+        else
+          instrument_step
+        end
+        defined_instrumenters[step] << instrumenter
+      end
+
+      def directives(new_directives = nil)
+        if new_directives
+          @directives = new_directives.reduce({}) { |m, d| m[d.name] = d; m }
+        end
+
+        @directives ||= directives(DIRECTIVES)
+      end
+
+      def tracer(new_tracer)
+        defined_tracers << new_tracer
+      end
+
+      def query_analyzer(new_analyzer)
+        defined_query_analyzers << new_analyzer
+      end
+
+      def middleware(new_middleware = nil)
+        if new_middleware
+          defined_middleware << new_middleware
+        else
+          graphql_definition.middleware
+        end
+      end
+
+      def multiplex_analyzer(new_analyzer)
+        defined_multiplex_analyzers << new_analyzer
+      end
+
+      private
+
+      def lazy_classes
+        @lazy_classes ||= {}
+      end
+
+      def defined_instrumenters
+        @defined_instrumenters ||= Hash.new { |h,k| h[k] = [] }
+      end
+
+      def defined_tracers
+        @defined_tracers ||= []
+      end
+
+      def defined_query_analyzers
+        @defined_query_analyzers ||= []
+      end
+
+      def defined_middleware
+        @defined_middleware ||= []
+      end
+
+      def defined_multiplex_analyzers
+        @defined_multiplex_analyzers ||= []
+      end
+    end
+
+
+    def self.inherited(child_class)
+      child_class.singleton_class.class_eval do
+        prepend(MethodWrappers)
+      end
+    end
+
+    module MethodWrappers
+      # Wrap the user-provided resolve-type in a correctness check
+      def resolve_type(type, obj, ctx = :__undefined__)
+        graphql_definition.check_resolved_type(type, obj, ctx) do |ok_type, ok_obj, ok_ctx|
+          super(ok_type, ok_obj, ok_ctx)
+        end
+      end
+    end
+
     protected
 
     def rescues?
@@ -578,6 +943,7 @@ module GraphQL
       GraphQL::Relay::ConnectionInstrumentation,
       GraphQL::Relay::EdgesInstrumentation,
       GraphQL::Relay::Mutation::Instrumentation,
+      GraphQL::Schema::Member::Instrumentation,
     ]
 
     def rebuild_artifacts
@@ -585,12 +951,15 @@ module GraphQL
         raise CyclicalDefinitionError, "Part of the schema build process re-triggered the schema build process, causing an infinite loop. Avoid using Schema#types, Schema#possible_types, and Schema#get_field during schema build."
       else
         @rebuilding_artifacts = true
+        @introspection_system = Schema::IntrospectionSystem.new(self)
         traversal = Traversal.new(self)
         @types = traversal.type_map
         @root_types = [query, mutation, subscription]
         @instrumented_field_map = traversal.instrumented_field_map
         @type_reference_map = traversal.type_reference_map
         @union_memberships = traversal.union_memberships
+        @find_cache = {}
+        @finder = Finder.new(self)
       end
     ensure
       @rebuilding_artifacts = false

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -103,7 +103,7 @@ module GraphQL
       end
 
       class NodeWithPath
-        extend GraphQL::Delegate
+        extend Forwardable
         attr_reader :node, :path
         def initialize(node, path)
           @node = node

data/lib/graphql/static_validation/literal_validator.rb

@@ -16,23 +16,35 @@ module GraphQL
         elsif type.kind.list?
           item_type = type.of_type
           ensure_array(ast_value).all? { |val| validate(val, item_type) }
-        elsif type.kind.scalar? && !ast_value.is_a?(GraphQL::Language::Nodes::AbstractNode) && !ast_value.is_a?(Array)
+        elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          true
+        elsif type.kind.scalar? && constant_scalar?(ast_value)
           type.valid_input?(ast_value, @context)
         elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
           type.valid_input?(ast_value.name, @context)
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
           required_input_fields_are_present(type, ast_value) &&
             present_input_field_values_are_valid(type, ast_value)
-        elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          true
         else
           false
         end
       end
 
-
       private
 
+      # The GraphQL grammar supports variables embedded within scalars but graphql.js
+      # doesn't support it so we won't either for simplicity
+      def constant_scalar?(ast_value)
+        if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          false
+        elsif ast_value.is_a?(Array)
+          ast_value.all? { |element| constant_scalar?(element) }
+        elsif ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
+          ast_value.arguments.all? { |arg| constant_scalar?(arg.value) }
+        else
+          true
+        end
+      end
 
       def required_input_fields_are_present(type, ast_node)
         required_field_names = @warden.arguments(type)

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

@@ -16,14 +16,14 @@ module GraphQL
       private
 
       def validate_field(context, ast_field, parent_type, parent)
-        if parent_type.kind.union? && ast_field.name != '__typename'
-          context.errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent, context: context)
-          return GraphQL::Language::Visitor::SKIP
-        end
-
         field = context.warden.get_field(parent_type, ast_field.name)
+
         if field.nil?
-          context.errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", ast_field, context: context)
+          if  parent_type.kind.union?
+            context.errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent, context: context)
+          else
+            context.errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", ast_field, context: context)
+          end
           return GraphQL::Language::Visitor::SKIP
         end
       end

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

@@ -24,7 +24,11 @@ module GraphQL
         msg = if resolved_type.nil?
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
-          "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+          if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.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.name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+          end
         elsif resolved_type.kind.object? && ast_node.selections.none?
           "Objects must have selections (%{node_name} returns #{resolved_type.name} but has no selections)"
         else

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

@@ -2,6 +2,9 @@
 module GraphQL
   module StaticValidation
     class FieldsWillMerge
+      # Special handling for fields without arguments
+      NO_ARGS = {}.freeze
+
       def validate(context)
         context.each_irep_node do |node|
           if node.ast_nodes.size > 1
@@ -16,15 +19,19 @@ module GraphQL
 
             # Check for incompatible / non-identical arguments on this node:
             args = node.ast_nodes.map do |n|
-              n.arguments.reduce({}) do |memo, a|
-                arg_value = a.value
-                memo[a.name] = case arg_value
-                when GraphQL::Language::Nodes::AbstractNode
-                  arg_value.to_query_string
-                else
-                  GraphQL::Language.serialize(arg_value)
+              if n.arguments.any?
+                n.arguments.reduce({}) do |memo, a|
+                  arg_value = a.value
+                  memo[a.name] = case arg_value
+                  when GraphQL::Language::Nodes::AbstractNode
+                    arg_value.to_query_string
+                  else
+                    GraphQL::Language.serialize(arg_value)
+                  end
+                  memo
                 end
-                memo
+              else
+                NO_ARGS
               end
             end
             args.uniq!

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

@@ -102,7 +102,17 @@ module GraphQL
       def follow_spreads(node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
         spreads = spreads_for_context[node] - visited_fragments
         spreads.each do |spread_name|
-          def_node, variables = fragment_definitions.find { |def_node, vars| def_node.name == spread_name }
+          def_node = nil
+          variables = nil
+          # Implement `.find` by hand to avoid Ruby's internal allocations
+          fragment_definitions.each do |frag_def_node, vars|
+            if frag_def_node.name == spread_name
+              def_node = frag_def_node
+              variables = vars
+              break
+            end
+          end
+
           next if !def_node
           visited_fragments << spread_name
           variables.each do |name, child_usage|

data/lib/graphql/static_validation/validation_context.rb

@@ -12,7 +12,7 @@ module GraphQL
     # It also provides limited access to the {TypeStack} instance,
     # which tracks state as you climb in and out of different fields.
     class ValidationContext
-      extend GraphQL::Delegate
+      extend Forwardable
 
       attr_reader :query, :schema,
         :document, :errors, :visitor,