graphql 1.0.0 → 1.1.0

data/lib/graphql/schema/possible_types.rb

@@ -14,7 +14,7 @@ module GraphQL
       def initialize(schema)
         @object_types = schema.types.values.select { |type| type.kind.object? }
 
-        @storage = Hash.new do |hash, key|
+        @interface_implementers = Hash.new do |hash, key|
           hash[key] = @object_types.select { |type| type.interfaces.include?(key) }.sort_by(&:name)
         end
       end
@@ -24,7 +24,9 @@ module GraphQL
         when GraphQL::UnionType
           type_defn.possible_types
         when GraphQL::InterfaceType
-          @storage[type_defn]
+          @interface_implementers[type_defn]
+        when GraphQL::ObjectType
+          [type_defn]
         else
           raise "#{type_defn} doesn't have possible types"
         end

data/lib/graphql/schema/printer.rb

@@ -162,7 +162,7 @@ module GraphQL
           include ArgsPrinter
           include DescriptionPrinter
           def print_fields(type)
-            type.all_fields.map.with_index{ |field, i|
+            type.all_fields.map.with_index { |field, i|
               "#{print_description(field, '  ', i == 0)}"\
               "  #{field.name}#{print_args(field, '  ')}: #{field.type}#{print_deprecated(field)}"
             }.join("\n")

data/lib/graphql/schema/type_expression.rb

@@ -1,17 +1,17 @@
 module GraphQL
   class Schema
     module TypeExpression
-      def self.build_type(schema, ast_node)
+      def self.build_type(types, ast_node)
         case ast_node
         when GraphQL::Language::Nodes::TypeName
           type_name = ast_node.name
-          schema.types[type_name]
+          types[type_name]
         when GraphQL::Language::Nodes::NonNullType
           ast_inner_type = ast_node.of_type
-          build_type(schema, ast_inner_type).to_non_null_type
+          build_type(types, ast_inner_type).to_non_null_type
         when GraphQL::Language::Nodes::ListType
           ast_inner_type = ast_node.of_type
-          build_type(schema, ast_inner_type).to_list_type
+          build_type(types, ast_inner_type).to_list_type
         end
       end
     end

data/lib/graphql/schema/type_map.rb

@@ -8,7 +8,7 @@ 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, :to_h, :fetch
+      def_delegators :@storage, :key?, :keys, :values, :to_h, :fetch, :each, :each_value
 
       def initialize
         @storage = {}

data/lib/graphql/schema/validation.rb

@@ -99,6 +99,10 @@ module GraphQL
         ARGUMENTS_ARE_VALID =  Rules.assert_named_items_are_valid("argument", ->(type) { type.arguments.values })
 
         DEFAULT_VALUE_IS_VALID_FOR_TYPE = ->(type) {
+          if !type.default_value.nil? && type.type.is_a?(NonNullType)
+            return %Q(Variable #{type.name} of type "#{type.type}" is required and will not use the default value. Perhaps you meant to use type "#{type.type.of_type}".)
+          end
+
           if !type.default_value.nil?
             coerced_value = begin
               type.type.coerce_result(type.default_value)

data/lib/graphql/schema/warden.rb

@@ -0,0 +1,114 @@
+module GraphQL
+  class Schema
+    # Restrict access to a {GraphQL::Schema} with a user-defined mask.
+    #
+    # The mask is object that responds to `#visible?(schema_member)`.
+    #
+    # When validating and executing a query, all access to schema members
+    # should go through a warden. If you access the schema directly,
+    # you may show a client something that it shouldn't be allowed to see.
+    #
+    # Masks can be provided in {Schema#execute} (or {Query#initialize}) with the `mask:` keyword.
+    #
+    # @example Hidding private fields
+    #   private_members = -> (member) { member.metadata[:private] }
+    #   result = Schema.execute(query_string, except: private_members)
+    #
+    # @example Custom mask implementation
+    #   # It must respond to `#call(member)`.
+    #   class MissingRequiredFlags
+    #     def initialize(user)
+    #       @user = user
+    #     end
+    #
+    #     # Return `false` if any required flags are missing
+    #     def call(member)
+    #       member.metadata[:required_flags].any? do |flag|
+    #         !@user.has_flag?(flag)
+    #       end
+    #     end
+    #   end
+    #
+    #   # Then, use the custom filter in query:
+    #   missing_required_flags = MissingRequiredFlags.new(current_user)
+    #
+    #   # This query can only access members which match the user's flags
+    #   result = Schema.execute(query_string, except: missing_required_flags)
+    #
+    class Warden
+      # @param schema [GraphQL::Schema]
+      # @param mask [<#call(member)>] Objects are hidden when `.call(member)` returns true
+      def initialize(schema, mask)
+        @mask = mask
+        @schema = schema
+      end
+
+      # @return [Array<GraphQL::BaseType>] Visible types in the schema
+      def types
+        @schema.types.each_value.select { |t| visible?(t) }
+      end
+
+      # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)
+      def get_type(type_name)
+        type_defn = @schema.types.fetch(type_name, nil)
+        if type_defn && visible?(type_defn)
+          type_defn
+        else
+          nil
+        end
+      end
+
+      # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`, if it exists
+      def get_field(parent_type, field_name)
+        field_defn = @schema.get_field(parent_type, field_name)
+        if field_defn && visible_field?(field_defn)
+          field_defn
+        else
+          nil
+        end
+      end
+
+      # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
+      def possible_types(type_defn)
+        @schema.possible_types(type_defn).select { |t| visible?(t) }
+      end
+
+      # @param type_defn [GraphQL::ObjectType, GraphQL::InterfaceType]
+      # @return [Array<GraphQL::Field>] Fields on `type_defn`
+      def fields(type_defn)
+        type_defn.all_fields.select { |f| visible_field?(f) }
+      end
+
+      # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
+      # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
+      def arguments(argument_owner)
+        argument_owner.arguments.each_value.select { |a| visible_field?(a) }
+      end
+
+      # @return [Array<GraphQL::EnumType::EnumValue>] Visible members of `enum_defn`
+      def enum_values(enum_defn)
+        enum_defn.values.each_value.select { |enum_value_defn| visible?(enum_value_defn) }
+      end
+
+      # @return [Array<GraphQL::InterfaceType>] Visible interfaces implemented by `obj_type`
+      def interfaces(obj_type)
+        obj_type.interfaces.select { |t| visible?(t) }
+      end
+
+      # @return [Array<GraphQL::Field>] Visible input fields on `input_obj_type`
+      def input_fields(input_obj_type)
+        input_obj_type.arguments.each_value.select { |f| visible_field?(f) }
+      end
+
+      private
+
+      def visible_field?(field_defn)
+        visible?(field_defn) && visible?(field_defn.type.unwrap)
+      end
+
+      def visible?(member)
+        !@mask.call(member)
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/literal_validator.rb

@@ -2,6 +2,10 @@ module GraphQL
   module StaticValidation
     # Test whether `ast_value` is a valid input for `type`
     class LiteralValidator
+      def initialize(warden:)
+        @warden = warden
+      end
+
       def validate(ast_value, type)
         if type.kind.non_null?
           (!ast_value.nil?) && validate(ast_value, type.of_type)
@@ -9,9 +13,9 @@ module GraphQL
           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)
-          type.valid_input?(ast_value)
+          type.valid_input?(ast_value, @warden)
         elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-          type.valid_input?(ast_value.name)
+          type.valid_input?(ast_value.name, @warden)
         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)
@@ -27,8 +31,7 @@ module GraphQL
 
 
       def required_input_fields_are_present(type, ast_node)
-        required_field_names = type.input_fields
-          .values
+        required_field_names = @warden.input_fields(type)
           .select { |f| f.type.kind.non_null? }
           .map(&:name)
         present_field_names = ast_node.arguments.map(&:name)
@@ -37,10 +40,10 @@ module GraphQL
       end
 
       def present_input_field_values_are_valid(type, ast_node)
-        fields = type.input_fields
+        field_map = @warden.input_fields(type).reduce({}) { |m, f| m[f.name] = f; m}
         ast_node.arguments.all? do |value|
-          field = fields[value.name]
-          field ? validate(value.value, field.type) : true
+          field = field_map[value.name]
+          field && validate(value.value, field.type)
         end
       end
 

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

@@ -3,11 +3,9 @@ module GraphQL
     class ArgumentLiteralsAreCompatible < GraphQL::StaticValidation::ArgumentsValidator
       def validate_node(parent, node, defn, context)
         return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-        validator = GraphQL::StaticValidation::LiteralValidator.new
         arg_defn = defn.arguments[node.name]
         return unless arg_defn
-        valid = validator.validate(node.value, arg_defn.type)
-        if !valid
+        if !context.valid_literal?(node.value, arg_defn.type)
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)
           context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'.", parent, context: context)

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

@@ -2,7 +2,7 @@ module GraphQL
   module StaticValidation
     class ArgumentsAreDefined < GraphQL::StaticValidation::ArgumentsValidator
       def validate_node(parent, node, defn, context)
-        argument_defn = defn.arguments[node.name]
+        argument_defn = context.warden.arguments(defn).find { |arg| arg.name == node.name }
         if argument_defn.nil?
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)

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

@@ -21,7 +21,7 @@ module GraphQL
           return GraphQL::Language::Visitor::SKIP
         end
 
-        field = context.schema.get_field(parent_type, ast_field.name)
+        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)
           return GraphQL::Language::Visitor::SKIP

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

@@ -23,7 +23,8 @@ module GraphQL
         context.visitor[GraphQL::Language::Nodes::Document].leave << ->(doc_node, parent) {
           spreads_to_validate.each do |frag_spread|
             fragment_child_name = context.fragments[frag_spread.node.name].type.name
-            fragment_child = context.schema.types.fetch(fragment_child_name, nil) # Might be non-existent type name
+            fragment_child = context.warden.get_type(fragment_child_name)
+            # Might be non-existent type name
             if fragment_child
               validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
             end
@@ -38,25 +39,13 @@ module GraphQL
           # It's not a valid fragment type, this error was handled someplace else
           return
         end
-        intersecting_types = get_possible_types(parent_type, context.schema) & get_possible_types(child_type, context.schema)
+        intersecting_types = context.warden.possible_types(parent_type.unwrap) & context.warden.possible_types(child_type.unwrap)
         if intersecting_types.none?
           name = node.respond_to?(:name) ? " #{node.name}" : ""
           context.errors << message("Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}", node, path: path)
         end
       end
 
-      def get_possible_types(type, schema)
-        if type.kind.wraps?
-          get_possible_types(type.of_type, schema)
-        elsif type.kind.object?
-          [type]
-        elsif type.kind.resolves?
-          schema.possible_types(type)
-        else
-          []
-        end
-      end
-
       class FragmentSpread
         attr_reader :node, :parent_type, :path
         def initialize(node:, parent_type:, path:)

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

@@ -19,7 +19,7 @@ module GraphQL
       def validate_type_exists(node, context)
         return unless node.type
         type_name = node.type.name
-        type = context.schema.types.fetch(type_name, nil)
+        type = context.warden.get_type(type_name)
         if type.nil?
           context.errors << message("No such type #{type_name}, so it can't be a fragment condition", node, context: context)
           GraphQL::Language::Visitor::SKIP

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

@@ -24,7 +24,7 @@ module GraphQL
           # Inline fragment on the same type
         else
           type_name = node_type.to_query_string
-          type_def = context.schema.types.fetch(type_name, nil)
+          type_def = context.warden.get_type(type_name)
           if type_def.nil? || !type_def.kind.composite?
             context.errors <<  message("Invalid fragment on type #{type_name} (must be Union, Interface or Object)", node, context: context)
             GraphQL::Language::Visitor::SKIP

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

@@ -4,21 +4,20 @@ module GraphQL
       include GraphQL::StaticValidation::Message::MessageHelper
 
       def validate(context)
-        literal_validator = GraphQL::StaticValidation::LiteralValidator.new
         context.visitor[GraphQL::Language::Nodes::VariableDefinition] << ->(node, parent) {
           if !node.default_value.nil?
-            validate_default_value(node, literal_validator, context)
+            validate_default_value(node, context)
           end
         }
       end
 
-      def validate_default_value(node, literal_validator, context)
+      def validate_default_value(node, context)
         value = node.default_value
         if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
           context.errors << message("Non-null variable $#{node.name} can't have a default value", node, context: context)
         else
           type = context.schema.type_from_ast(node.type)
-          if !literal_validator.validate(value, type)
+          if !context.valid_literal?(value, type)
             context.errors << message("Default value for $#{node.name} doesn't match type #{type}", node, context: context)
           end
         end

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

@@ -13,7 +13,8 @@ module GraphQL
 
       def validate_is_input_type(node, context)
         type_name = get_type_name(node.type)
-        type = context.schema.types.fetch(type_name, nil)
+        type = context.warden.get_type(type_name)
+
         if type.nil?
           context.errors << message("#{type_name} isn't a defined input type (on $#{node.name})", node, context: context)
         elsif !type.kind.input?

data/lib/graphql/static_validation/validation_context.rb

@@ -11,13 +11,14 @@ 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
-      attr_reader :query, :schema, :document, :errors, :visitor, :fragments, :operations
+      attr_reader :query, :schema, :document, :errors, :visitor, :fragments, :operations, :warden
       def initialize(query)
         @query = query
         @schema = query.schema
         @document = query.document
         @fragments = {}
         @operations = {}
+        @warden = query.warden
 
         document.definitions.each do |definition|
           case definition
@@ -69,6 +70,11 @@ module GraphQL
         @type_stack.argument_definitions[-2]
       end
 
+      def valid_literal?(ast_value, type)
+        @literal_validator ||= LiteralValidator.new(warden: @warden)
+        @literal_validator.validate(ast_value, type)
+      end
+
       # Don't try to validate dynamic fields
       # since they aren't defined by the type system
       def skip_field?(field_name)

data/lib/graphql/union_type.rb

@@ -41,9 +41,12 @@ module GraphQL
     def possible_types
       @clean_possible_types ||= begin
         ensure_defined
-        @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
-      rescue
-        @dirty_possible_types
+
+        if @dirty_possible_types.respond_to?(:map)
+          @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
+        else
+          @dirty_possible_types
+        end
       end
     end
   end

data/lib/graphql/unresolved_type_error.rb

@@ -2,8 +2,7 @@ module GraphQL
   # Error raised when the value provided for a field can't be resolved to one of the possible types
   # for the field.
   class UnresolvedTypeError < GraphQL::Error
-    def initialize(field_name, schema, field_type, parent_type, received_type)
-      possible_types = field_type.kind.resolves? ? schema.possible_types(field_type) : [field_type]
+    def initialize(field_name, field_type, parent_type, received_type, possible_types)
       message = %|The value from "#{field_name}" on "#{parent_type}" could not be resolved to "#{field_type}". (Received: #{received_type.inspect}, Expected: [#{possible_types.map(&:inspect).join(", ")}])|
       super(message)
     end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/readme.md

@@ -50,13 +50,10 @@ See "Getting Started" on the [website](https://rmosolgo.github.io/graphql-ruby/)
   - Validators are order-dependent, is this a smell?
   - Tests for interference between validators are poor
   - Maybe this is a candidate for a rewrite?
-- Add Rails-y argument validations, eg `less_than: 100`, `max_length: 255`, `one_of: [...]`
-  - Must be customizable
 - Relay:
   - Reduce duplication in ArrayConnection / RelationConnection
   - Improve API for creating edges (better RANGE_ADD support)
   - If the new edge isn't a member of the connection's objects, raise a nice error
-- Missing Enum value should raise a descriptive error, not "key not found"
 - `args` should whitelist keys -- if you request a key that isn't defined for the field, it should 💥
 - Fix middleware ([discussion](https://github.com/rmosolgo/graphql-ruby/issues/186))
   - Handle out-of-bounds lookup, eg `graphql-batch`
@@ -69,6 +66,5 @@ See "Getting Started" on the [website](https://rmosolgo.github.io/graphql-ruby/)
   - Support working with AST as data
   - Adding fields to selections (`__typename` can go anywhere, others are type-specific)
   - Renaming fragments from local names to unique names
-- Support AST subclasses? This would be hard, I think classes are used as hash keys in many places.
-- Support object deep-copy (schema, type, field, argument)? To support multiple schemas based on the same types. ([discussion](https://github.com/rmosolgo/graphql-ruby/issues/269))
 - Document encrypted & versioned cursors
+- Make it faster

data/spec/graphql/compatibility/execution_specification_spec.rb

@@ -0,0 +1,3 @@
+require "spec_helper"
+
+SerialExecutionSuite = GraphQL::Compatibility::ExecutionSpecification.build_suite(GraphQL::Query::SerialExecution)