graphql 0.12.1 → 0.13.0

data/lib/graphql/schema/type_expression.rb

@@ -5,6 +5,7 @@ module GraphQL
         @schema = schema
         @ast_node = ast_node
       end
+
       def type
         @type ||= build_type(@schema, @ast_node)
       end

data/lib/graphql/schema/type_map.rb

@@ -8,14 +8,10 @@ module GraphQL
     # If you want a type, but want to handle the undefined case, use {#fetch}.
     class TypeMap
       extend Forwardable
-      def_delegators :@storage, :key?, :keys, :values, :fetch, :to_h
-
-      # Used for detecting deprecated interface member inferrance
-      attr_accessor :safely_discovered_types
+      def_delegators :@storage, :key?, :keys, :values
 
       def initialize
         @storage = {}
-        @safely_discovered_types = []
       end
 
       def [](key)
@@ -30,11 +26,8 @@ module GraphQL
         end
       end
 
-      def warnings
-        interface_only_types = @storage.values - safely_discovered_types
-        interface_only_types.map do |unsafe_type|
-          "Type \"#{unsafe_type}\" was inferred from an interface's #possible_types. This won't be supported in the next version of GraphQL. Pass this type with the `types:` argument to `Schema.new` instead!"
-        end
+      def fetch(key, fallback_value)
+        @storage.key?(key) ? @storage[key] : fallback_value
       end
     end
   end

data/lib/graphql/schema/type_reducer.rb

@@ -1,95 +1,79 @@
-# Starting from a given type, discover other types in the system by
-# traversing that type's fields, possible_types, etc
-class GraphQL::Schema::TypeReducer
-  attr_reader :type, :existing_type_hash
+module GraphQL
+  class Schema
+    # Starting from a given type, discover other types in the system by
+    # traversing that type's fields, possible_types, etc
+    class TypeReducer
+      attr_reader :type, :existing_type_hash
 
-  def initialize(type, existing_type_hash)
-    validate_type(type)
-    if type.respond_to?(:name) && existing_type_hash.fetch(type.name, nil).equal?(type)
-      @result = existing_type_hash
-    else
-      @type = type
-    end
-    @existing_type_hash = existing_type_hash
-  end
-
-  def result
-    @result ||= find_types(type, existing_type_hash)
-  end
-
-  # Reduce all of `types` and return the combined result
-  def self.find_all(types)
-    type_map = GraphQL::Schema::TypeMap.new
-    types.reduce(type_map) do |memo, type|
-      type_map.safely_discovered_types << type
-      self.new(type.unwrap, memo).result
-    end
-    type_map.warnings.each do |warning|
-      warn(warning)
-    end
-    type_map
-  end
-
-  private
-
-  def find_types(type, type_hash)
-    type_hash[type.name] = type
-    if type.kind.fields?
-      type.all_fields.each do |field|
-        reduce_type(field.type, type_hash)
-        field.arguments.each do |name, argument|
-          reduce_type(argument.type, type_hash)
-          safely_discovered(type_hash, argument.type)
+      def initialize(type, existing_type_hash)
+        validate_type(type)
+        if type.respond_to?(:name) && existing_type_hash.fetch(type.name, nil).equal?(type)
+          @result = existing_type_hash
+        else
+          @type = type
         end
-        safely_discovered(type_hash, field.type)
+        @existing_type_hash = existing_type_hash
       end
-    end
-    if type.kind.object?
-      type.interfaces.each do |interface|
-        reduce_type(interface, type_hash)
-        safely_discovered(type_hash, interface)
+
+      def result
+        @result ||= find_types(type, existing_type_hash)
       end
-    end
-    if type.kind.resolves?
-      type.possible_types.each do |possible_type|
-        reduce_type(possible_type, type_hash)
-        if type.kind.union?
-          safely_discovered(type_hash, possible_type)
+
+      # Reduce all of `types` and return the combined result
+      def self.find_all(types)
+        type_map = GraphQL::Schema::TypeMap.new
+        types.reduce(type_map) do |memo, type|
+          self.new(type, memo).result
         end
       end
-    end
-    if type.kind.input_object?
-      type.input_fields.each do |name, input_field|
-        reduce_type(input_field.type, type_hash)
-        safely_discovered(type_hash, input_field.type)
-      end
-    end
 
-    type_hash
-  end
+      private
 
-  def reduce_type(type, type_hash)
-    if type.is_a?(GraphQL::BaseType)
-      self.class.new(type.unwrap, type_hash).result
-    else
-      raise GraphQL::Schema::InvalidTypeError.new(type, ["Must be a GraphQL::BaseType"])
-    end
-  end
+      def find_types(type, type_hash)
+        type_hash[type.name] = type
+        if type.kind.fields?
+          type.all_fields.each do |field|
+            reduce_type(field.type, type_hash, "Field #{type.name}.#{field.name}")
+            field.arguments.each do |name, argument|
+              reduce_type(argument.type, type_hash, "Argument #{name} on #{type.name}.#{field.name}")
+            end
+          end
+        end
+        if type.kind.object?
+          type.interfaces.each do |interface|
+            reduce_type(interface, type_hash, "Interface on #{type.name}")
+          end
+        end
+        if type.kind.union?
+          type.possible_types.each do |possible_type|
+            reduce_type(possible_type, type_hash, "Possible type for #{type.name}")
+          end
+        end
+        if type.kind.input_object?
+          type.input_fields.each do |name, input_field|
+            reduce_type(input_field.type, type_hash, "Input field #{type.name}.#{name}")
+          end
+        end
 
-  def validate_type(type)
-    errors = []
-    type_validator = GraphQL::Schema::TypeValidator.new
-    type_validator.validate(type, errors)
-    if errors.any?
-      raise GraphQL::Schema::InvalidTypeError.new(type, errors)
-    end
-  end
+        type_hash
+      end
 
-  def safely_discovered(type_hash, type)
-    inner_type = type.unwrap
-    if !type_hash.safely_discovered_types.include?(inner_type)
+      def reduce_type(type, type_hash, name = nil)
+        if type.is_a?(GraphQL::BaseType)
+          self.class.new(type.unwrap, type_hash).result
+        else
+          raise GraphQL::Schema::InvalidTypeError.new(type, name)
+        end
+      end
 
-      type_hash.safely_discovered_types << inner_type
+      def validate_type(type)
+        errors = []
+        type_validator = GraphQL::Schema::TypeValidator.new
+        type_validator.validate(type, errors)
+        if errors.any?
+          raise GraphQL::Schema::InvalidTypeError.new(type, errors)
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/type_validator.rb

@@ -1,54 +1,58 @@
-class GraphQL::Schema::TypeValidator
-  def validate(type, errors)
-    own_errors = []
-    implementation = GraphQL::Schema::ImplementationValidator.new(type, as: "Type", errors: own_errors)
-    implementation.must_respond_to(:name)
-    implementation.must_respond_to(:kind)
-    if own_errors.any? # if no name or kind, abort!
-      errors.push(*own_errors)
-      return
-    end
+module GraphQL
+  class Schema
+    class TypeValidator
+      def validate(type, errors)
+        own_errors = []
+        implementation = GraphQL::Schema::ImplementationValidator.new(type, as: "Type", errors: own_errors)
+        implementation.must_respond_to(:name)
+        implementation.must_respond_to(:kind)
+        if own_errors.any? # if no name or kind, abort!
+          errors.push(*own_errors)
+          return
+        end
 
-    type_name = type.name
-    kind_name = type.kind.name
+        type_name = type.name
+        kind_name = type.kind.name
 
-    implementation.must_respond_to(:description, as: kind_name)
-    each_item_validator = GraphQL::Schema::EachItemValidator.new(own_errors)
+        implementation.must_respond_to(:description, as: kind_name)
+        each_item_validator = GraphQL::Schema::EachItemValidator.new(own_errors)
 
-    if type.kind.fields?
-      field_validator = GraphQL::Schema::FieldValidator.new
-      implementation.must_respond_to(:fields, as: kind_name) do |fields|
-        each_item_validator.validate(fields.keys, as: "#{type.name}.fields keys", must_be: "Strings") { |k| k.is_a?(String) }
+        if type.kind.fields?
+          field_validator = GraphQL::Schema::FieldValidator.new
+          implementation.must_respond_to(:fields, as: kind_name) do |fields|
+            each_item_validator.validate(fields.keys, as: "#{type.name}.fields keys", must_be: "Strings") { |k| k.is_a?(String) }
 
-        fields.values.each do |field|
-          field_validator.validate(field, own_errors)
+            fields.values.each do |field|
+              field_validator.validate(field, own_errors)
+            end
+          end
         end
-      end
-    end
 
-    if type.kind.resolves?
-      implementation.must_respond_to(:resolve_type)
-      implementation.must_respond_to(:possible_types, as: kind_name) do |possible_types|
-        each_item_validator.validate(possible_types, as: "#{type_name}.possible_types", must_be: "objects") { |t| t.kind.object? }
-      end
-    end
+        if type.kind.union?
+          implementation.must_respond_to(:resolve_type)
+          implementation.must_respond_to(:possible_types, as: kind_name) do |possible_types|
+            each_item_validator.validate(possible_types, as: "#{type_name}.possible_types", must_be: "objects") { |t| t.kind.object? }
+          end
+        end
 
-    if type.kind.object?
-      implementation.must_respond_to(:interfaces, as: kind_name) do |interfaces|
-        each_item_validator.validate(interfaces, as: "#{type_name}.interfaces", must_be: "interfaces") { |t| t.kind.interface? }
-      end
-    end
+        if type.kind.object?
+          implementation.must_respond_to(:interfaces, as: kind_name) do |interfaces|
+            each_item_validator.validate(interfaces, as: "#{type_name}.interfaces", must_be: "interfaces") { |t| t.kind.interface? }
+          end
+        end
 
-    if type.kind.input_object?
-      implementation.must_respond_to(:input_fields, as: kind_name)
-    end
+        if type.kind.input_object?
+          implementation.must_respond_to(:input_fields, as: kind_name)
+        end
 
-    if type.kind.union?
-      union_types = type.possible_types
-      if union_types.none?
-        own_errors << "Union #{type_name} must be defined with 1 or more types, not 0!"
+        if type.kind.union?
+          union_types = type.possible_types
+          if union_types.none?
+            own_errors << "Union #{type_name} must be defined with 1 or more types, not 0!"
+          end
+        end
+        errors.push(*own_errors)
       end
     end
-    errors.push(*own_errors)
   end
 end

data/lib/graphql/static_validation.rb

@@ -1,16 +1,14 @@
-module GraphQL::StaticValidation
-end
+require "graphql/static_validation/message"
+require "graphql/static_validation/arguments_validator"
+require "graphql/static_validation/type_stack"
+require "graphql/static_validation/validator"
+require "graphql/static_validation/validation_context"
+require "graphql/static_validation/literal_validator"
 
-require 'graphql/static_validation/message'
-require 'graphql/static_validation/arguments_validator'
-require 'graphql/static_validation/type_stack'
-require 'graphql/static_validation/validator'
-require 'graphql/static_validation/validation_context'
-require 'graphql/static_validation/literal_validator'
 
 rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)
 Dir.glob(rules_glob).each do |file|
   require(file)
 end
 
-require 'graphql/static_validation/all_rules'
+require "graphql/static_validation/all_rules"

data/lib/graphql/static_validation/all_rules.rb

@@ -1,24 +1,29 @@
-# Default rules for {GraphQL::StaticValidation::Validator}
-#
-# Order is important here. Some validators return {GraphQL::Language::Visitor::SKIP}
-# which stops the visit on that node. That way it doesn't try to find fields on types that
-# don't exist, etc.
-GraphQL::StaticValidation::ALL_RULES = [
-  GraphQL::StaticValidation::DirectivesAreDefined,
-  GraphQL::StaticValidation::FragmentsAreFinite,
-  GraphQL::StaticValidation::FragmentTypesExist,
-  GraphQL::StaticValidation::FragmentsAreOnCompositeTypes,
-  GraphQL::StaticValidation::FragmentSpreadsArePossible,
-  GraphQL::StaticValidation::FragmentsAreUsed,
-  GraphQL::StaticValidation::FieldsAreDefinedOnType,
-  GraphQL::StaticValidation::FieldsWillMerge,
-  GraphQL::StaticValidation::FieldsHaveAppropriateSelections,
-  GraphQL::StaticValidation::ArgumentsAreDefined,
-  GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
-  GraphQL::StaticValidation::RequiredArgumentsArePresent,
-  GraphQL::StaticValidation::VariablesAreInputTypes,
-  GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped,
-  GraphQL::StaticValidation::VariablesAreUsedAndDefined,
-  GraphQL::StaticValidation::VariableUsagesAreAllowed,
-  GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth,
-]
+module GraphQL
+  module StaticValidation
+    # Default rules for {GraphQL::StaticValidation::Validator}
+    #
+    # Order is important here. Some validators return {GraphQL::Language::Visitor::SKIP}
+    # which stops the visit on that node. That way it doesn't try to find fields on types that
+    # don't exist, etc.
+    ALL_RULES = [
+      GraphQL::StaticValidation::DirectivesAreDefined,
+      GraphQL::StaticValidation::DirectivesAreInValidLocations,
+      GraphQL::StaticValidation::FragmentsAreFinite,
+      GraphQL::StaticValidation::FragmentsAreUsed,
+      GraphQL::StaticValidation::FragmentTypesExist,
+      GraphQL::StaticValidation::FragmentsAreOnCompositeTypes,
+      GraphQL::StaticValidation::FragmentSpreadsArePossible,
+      GraphQL::StaticValidation::FieldsAreDefinedOnType,
+      GraphQL::StaticValidation::FieldsWillMerge,
+      GraphQL::StaticValidation::FieldsHaveAppropriateSelections,
+      GraphQL::StaticValidation::ArgumentsAreDefined,
+      GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
+      GraphQL::StaticValidation::RequiredArgumentsArePresent,
+      GraphQL::StaticValidation::VariablesAreInputTypes,
+      GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped,
+      GraphQL::StaticValidation::VariablesAreUsedAndDefined,
+      GraphQL::StaticValidation::VariableUsagesAreAllowed,
+      GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth,
+    ]
+  end
+end

data/lib/graphql/static_validation/arguments_validator.rb

@@ -1,44 +1,48 @@
-# Implement validate_node
-class GraphQL::StaticValidation::ArgumentsValidator
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    # Implement validate_node
+    class ArgumentsValidator
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  def validate(context)
-    visitor = context.visitor
-    visitor[GraphQL::Language::Nodes::Argument] << -> (node, parent) {
-      if parent.is_a?(GraphQL::Language::Nodes::InputObject)
-        arg_defn = context.argument_definition
-        if arg_defn.nil?
-          return
-        else
-          parent_defn = arg_defn.type.unwrap
-          if parent_defn.is_a?(GraphQL::ScalarType)
+      def validate(context)
+        visitor = context.visitor
+        visitor[GraphQL::Language::Nodes::Argument] << -> (node, parent) {
+          if parent.is_a?(GraphQL::Language::Nodes::InputObject)
+            arg_defn = context.argument_definition
+            if arg_defn.nil?
+              return
+            else
+              parent_defn = arg_defn.type.unwrap
+              if parent_defn.is_a?(GraphQL::ScalarType)
+                return
+              end
+            end
+          elsif context.skip_field?(parent.name)
             return
+          elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
+            parent_defn = context.schema.directives[parent.name]
+          else
+            parent_defn = context.field_definition
           end
-        end
-      elsif context.skip_field?(parent.name)
-        return
-      elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
-        parent_defn = context.schema.directives[parent.name]
-      else
-        parent_defn = context.field_definition
+          validate_node(parent, node, parent_defn, context)
+        }
       end
-      validate_node(parent, node, parent_defn, context)
-    }
-  end
 
-  private
+      private
 
-  def parent_name(parent, type_defn)
-    field_name = if parent.is_a?(GraphQL::Language::Nodes::Field)
-      parent.alias || parent.name
-    elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-      type_defn.name
-    else
-      parent.name
-    end
-  end
+      def parent_name(parent, type_defn)
+        field_name = if parent.is_a?(GraphQL::Language::Nodes::Field)
+          parent.alias || parent.name
+        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
+          type_defn.name
+        else
+          parent.name
+        end
+      end
 
-  def node_type(parent)
-    parent.class.name.split("::").last
+      def node_type(parent)
+        parent.class.name.split("::").last
+      end
+    end
   end
 end