graphql 1.8.4 → 1.8.5

data/lib/graphql/schema/validation.rb

@@ -131,7 +131,7 @@ module GraphQL
         }
 
         SCHEMA_CAN_RESOLVE_TYPES = ->(schema) {
-          if schema.types.values.any? { |type| type.kind.resolves? } && schema.resolve_type_proc.nil?
+          if schema.types.values.any? { |type| type.kind.abstract? } && schema.resolve_type_proc.nil?
             "schema contains Interfaces or Unions, so you must define a `resolve_type -> (obj, ctx) { ... }` function"
           else
             # :+1:

data/lib/graphql/static_validation/message.rb

@@ -33,7 +33,11 @@ module GraphQL
       private
 
       def locations
-        @nodes.map{|node| {"line" => node.line, "column" => node.col}}
+        @nodes.map do |node|
+          h = {"line" => node.line, "column" => node.col}
+          h["filename"] = node.filename if node.filename
+          h
+        end
       end
     end
   end

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

@@ -12,6 +12,7 @@ module GraphQL
         }
 
         visitor = context.visitor
+
         visitor[GraphQL::Language::Nodes::DirectiveDefinition] << register_node
         visitor[GraphQL::Language::Nodes::SchemaDefinition] << register_node
         visitor[GraphQL::Language::Nodes::ScalarTypeDefinition] << register_node
@@ -21,6 +22,14 @@ module GraphQL
         visitor[GraphQL::Language::Nodes::UnionTypeDefinition] << register_node
         visitor[GraphQL::Language::Nodes::EnumTypeDefinition] << register_node
 
+        visitor[GraphQL::Language::Nodes::SchemaExtension] << register_node
+        visitor[GraphQL::Language::Nodes::ScalarTypeExtension] << register_node
+        visitor[GraphQL::Language::Nodes::ObjectTypeExtension] << register_node
+        visitor[GraphQL::Language::Nodes::InputObjectTypeExtension] << register_node
+        visitor[GraphQL::Language::Nodes::InterfaceTypeExtension] << register_node
+        visitor[GraphQL::Language::Nodes::UnionTypeExtension] << register_node
+        visitor[GraphQL::Language::Nodes::EnumTypeExtension] << register_node
+
         visitor[GraphQL::Language::Nodes::Document].leave << ->(node, _p) {
           if schema_definition_nodes.any?
             context.errors << message(%|Query cannot contain schema definitions|, schema_definition_nodes, context: context)

data/lib/graphql/type_kinds.rb

@@ -5,18 +5,21 @@ module GraphQL
     # These objects are singletons, eg `GraphQL::TypeKinds::UNION`, `GraphQL::TypeKinds::SCALAR`.
     class TypeKind
       attr_reader :name, :description
-      def initialize(name, resolves: false, fields: false, wraps: false, input: false, description: nil)
+      def initialize(name, abstract: false, fields: false, wraps: false, input: false, description: nil)
         @name = name
-        @resolves = resolves
+        @abstract = abstract
         @fields = fields
         @wraps = wraps
         @input = input
-        @composite = fields? || resolves?
+        @composite = fields? || abstract?
         @description = description
       end
 
       # Does this TypeKind have multiple possible implementors?
-      def resolves?;  @resolves;  end
+      # @deprecated Use `abstract?` instead of `resolves?`.
+      def resolves?;  @abstract;  end
+      # Is this TypeKind abstract?
+      def abstract?; @abstract; end
       # Does this TypeKind have queryable fields?
       def fields?;    @fields;    end
       # Does this TypeKind modify another type?
@@ -31,8 +34,8 @@ module GraphQL
     TYPE_KINDS = [
       SCALAR =        TypeKind.new("SCALAR", input: true, description: 'Indicates this type is a scalar.'),
       OBJECT =        TypeKind.new("OBJECT", fields: true, description: 'Indicates this type is an object. `fields` and `interfaces` are valid fields.'),
-      INTERFACE =     TypeKind.new("INTERFACE", resolves: true, fields: true, description: 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.'),
-      UNION =         TypeKind.new("UNION", resolves: true, description: 'Indicates this type is a union. `possibleTypes` is a valid field.'),
+      INTERFACE =     TypeKind.new("INTERFACE", abstract: true, fields: true, description: 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.'),
+      UNION =         TypeKind.new("UNION", abstract: true, description: 'Indicates this type is a union. `possibleTypes` is a valid field.'),
       ENUM =          TypeKind.new("ENUM", input: true, description: 'Indicates this type is an enum. `enumValues` is a valid field.'),
       INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT", input: true, description: 'Indicates this type is an input object. `inputFields` is a valid field.'),
       LIST =          TypeKind.new("LIST", wraps: true, description: 'Indicates this type is a list. `ofType` is a valid field.'),

data/lib/graphql/types.rb

@@ -3,5 +3,6 @@ require "graphql/types/boolean"
 require "graphql/types/float"
 require "graphql/types/id"
 require "graphql/types/int"
+require "graphql/types/iso_8601_date_time"
 require "graphql/types/string"
 require "graphql/types/relay"

data/lib/graphql/types/iso_8601_date_time.rb

@@ -4,11 +4,7 @@ module GraphQL
     # This scalar takes `DateTime`s and transmits them as strings,
     # using ISO 8601 format.
     #
-    # To use it, require it in your project:
-    #
-    #     require "graphql/types/iso_8601_date_time"
-    #
-    # Then use it for fields or arguments:
+    # Use it for fields or arguments as follows:
     #
     #     field :created_at, GraphQL::Types::ISO8601DateTime, null: false
     #

data/lib/graphql/unauthorized_error.rb

@@ -10,11 +10,16 @@ module GraphQL
     # @return [GraphQL::Query::Context] the context for the current query
     attr_reader :context
 
-    def initialize(object:, type:, context:)
+    def initialize(message = nil, object: nil, type: nil, context: nil)
+      if message.nil? && object.nil?
+        raise ArgumentError, "#{self.class.name} requires either a message or keywords"
+      end
+
       @object = object
       @type = type
       @context = context
-      super("An instance of #{object.class} failed #{type.name}'s authorization check")
+      message ||= "An instance of #{object.class} failed #{type.name}'s authorization check"
+      super(message)
     end
   end
 end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.8.4"
+  VERSION = "1.8.5"
 end

data/spec/generators/graphql/install_generator_spec.rb

@@ -129,7 +129,7 @@ RUBY
     assert_file "app/controllers/graphql_controller.rb", /CustomSchema\.execute/
   end
 
-  EXPECTED_GRAPHQLS_CONTROLLER = <<-RUBY
+  EXPECTED_GRAPHQLS_CONTROLLER = <<-'RUBY'
 class GraphqlController < ApplicationController
   def execute
     variables = ensure_hash(params[:variables])
@@ -141,6 +141,9 @@ class GraphqlController < ApplicationController
     }
     result = DummySchema.execute(query, variables: variables, context: context, operation_name: operation_name)
     render json: result
+  rescue => e
+    raise e unless Rails.env.development?
+    handle_error_in_development e
   end
 
   private
@@ -159,9 +162,16 @@ class GraphqlController < ApplicationController
     when nil
       {}
     else
-      raise ArgumentError, "Unexpected parameter: \#{ambiguous_param}"
+      raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
     end
   end
+
+  def handle_error_in_development(e)
+    logger.error e.message
+    logger.error e.backtrace.join("\n")
+
+    render json: { error: { message: e.message, backtrace: e.backtrace }, data: {} }, status: 500
+  end
 end
 RUBY
 

data/spec/graphql/authorization_spec.rb

@@ -208,6 +208,26 @@ describe GraphQL::Authorization do
       edge_type(IntegerObjectEdge)
     end
 
+    # This object responds with `replaced => false`,
+    # but if its replacement value is used, it gives `replaced => true`
+    class Replaceable
+      def replacement
+        { replaced: true }
+      end
+
+      def replaced
+        false
+      end
+    end
+
+    class ReplacedObject < BaseObject
+      def self.authorized?(obj, ctx)
+        super && !ctx[:replace_me]
+      end
+
+      field :replaced, Boolean, null: false
+    end
+
     class LandscapeFeature < BaseEnum
       value "MOUNTAIN"
       value "STREAM", role: :unauthorized
@@ -284,6 +304,12 @@ describe GraphQL::Authorization do
         argument :value, String, required: true
       end
 
+      field :unauthorized_lazy_list_interface, [UnauthorizedInterface, null: true], null: true
+
+      def unauthorized_lazy_list_interface
+        ["z", Box.new(value: Box.new(value: "z2")), "a", Box.new(value: "a")]
+      end
+
       field :integers, IntegerObjectConnection, null: false
 
       def integers
@@ -295,6 +321,11 @@ describe GraphQL::Authorization do
       def lazy_integers
         Box.new(value: Box.new(value: [1,2,3]))
       end
+
+      field :replaced_object, ReplacedObject, null: false
+      def replaced_object
+        Replaceable.new
+      end
     end
 
     class DoHiddenStuff < GraphQL::Schema::RelayClassicMutation
@@ -303,6 +334,12 @@ describe GraphQL::Authorization do
       end
     end
 
+    class DoHiddenStuff2 < GraphQL::Schema::Mutation
+      def self.visible?(ctx)
+        super && !ctx[:hidden_mutation]
+      end
+    end
+
     class DoInaccessibleStuff < GraphQL::Schema::RelayClassicMutation
       def self.accessible?(ctx)
         super && (ctx[:inaccessible_mutation] ? false : true)
@@ -317,6 +354,7 @@ describe GraphQL::Authorization do
 
     class Mutation < BaseObject
       field :do_hidden_stuff, mutation: DoHiddenStuff
+      field :do_hidden_stuff2, mutation: DoHiddenStuff2
       field :do_inaccessible_stuff, mutation: DoInaccessibleStuff
       field :do_unauthorized_stuff, mutation: DoUnauthorizedStuff
     end
@@ -328,7 +366,11 @@ describe GraphQL::Authorization do
       lazy_resolve(Box, :value)
 
       def self.unauthorized_object(err)
-        raise GraphQL::ExecutionError, "Unauthorized #{err.type.graphql_name}: #{err.object}"
+        if err.object.respond_to?(:replacement)
+          err.object.replacement
+        else
+          raise GraphQL::ExecutionError, "Unauthorized #{err.type.graphql_name}: #{err.object}"
+        end
       end
 
       # use GraphQL::Backtrace
@@ -387,6 +429,17 @@ describe GraphQL::Authorization do
       assert_equal "DoHiddenStuffPayload", visible_introspection_res["data"]["t2"]["name"]
     end
 
+    it "works with Schema::Mutation" do
+      query = "mutation { doHiddenStuff2 { __typename } }"
+      res = auth_execute(query, context: { hidden_mutation: true })
+      assert_equal ["Field 'doHiddenStuff2' doesn't exist on type 'Mutation'"], res["errors"].map { |e| e["message"] }
+
+      # `#resolve` isn't implemented, so this errors out:
+      assert_raises NotImplementedError do
+        auth_execute(query)
+      end
+    end
+
     it "uses the base type for edges and connections" do
       query = <<-GRAPHQL
       {
@@ -680,5 +733,31 @@ describe GraphQL::Authorization do
       res2 = auth_execute(query, variables: { value: "b"})
       assert_equal "b", res2["data"]["unauthorizedInterface"]["value"]
     end
+
+    it "works with lazy values / lists of interfaces" do
+      query = <<-GRAPHQL
+      {
+        unauthorizedLazyListInterface {
+          ... on UnauthorizedCheckBox {
+            value
+          }
+        }
+      }
+      GRAPHQL
+
+      res = auth_execute(query)
+      # An error from two, values from the others
+      assert_equal ["Unauthorized UnauthorizedCheckBox: a", "Unauthorized UnauthorizedCheckBox: a"], res["errors"].map { |e| e["message"] }
+      assert_equal [{"value" => "z"}, {"value" => "z2"}, nil, nil], res["data"]["unauthorizedLazyListInterface"]
+    end
+
+    it "replaces objects from the unauthorized_object hook" do
+      query = "{ replacedObject { replaced } }"
+      res = auth_execute(query, context: { replace_me: true })
+      assert_equal true, res["data"]["replacedObject"]["replaced"]
+
+      res = auth_execute(query, context: { replace_me: false })
+      assert_equal false, res["data"]["replacedObject"]["replaced"]
+    end
   end
 end

data/spec/graphql/directive_spec.rb

@@ -48,6 +48,48 @@ describe GraphQL::Directive do
       end
     end
 
+    describe "when directive uses argument with default value" do
+      describe "with false" do
+        let(:query_string) { <<-GRAPHQL
+          query($f: Boolean = false) {
+            cheese(id: 1) {
+              dontIncludeFlavor: flavor @include(if: $f)
+              dontSkipFlavor: flavor @skip(if: $f)
+            }
+          }
+        GRAPHQL
+        }
+
+        it "is not included" do
+          assert !result["data"]["cheese"].key?("dontIncludeFlavor")
+        end
+
+        it "is not skipped" do
+          assert result["data"]["cheese"].key?("dontSkipFlavor")
+        end
+      end
+
+      describe "with true" do
+        let(:query_string) { <<-GRAPHQL
+          query($t: Boolean = true) {
+            cheese(id: 1) {
+              includeFlavor: flavor @include(if: $t)
+              skipFlavor: flavor @skip(if: $t)
+            }
+          }
+        GRAPHQL
+        }
+
+        it "is included" do
+          assert result["data"]["cheese"].key?("includeFlavor")
+        end
+
+        it "is skipped" do
+          assert !result["data"]["cheese"].key?("skipFlavor")
+        end
+      end
+    end
+
     it "intercepts fields" do
       expected = { "data" =>{
         "cheese" => {

data/spec/graphql/execution_error_spec.rb

@@ -137,7 +137,7 @@ describe GraphQL::ExecutionError do
             },
           ]
         }
-      assert_equal(expected_result, result)
+      assert_equal(expected_result, result.to_h)
     end
   end
 

data/spec/graphql/query_spec.rb

@@ -638,6 +638,20 @@ describe GraphQL::Query do
     end
   end
 
+  describe "validating with optional arguments and variables: nil" do
+    it "works" do
+      query_str = <<-GRAPHQL
+      query($expiresAfter: Time) {
+        searchDairy(expiresAfter: $expiresAfter) {
+          __typename
+        }
+      }
+      GRAPHQL
+      query = GraphQL::Query.new(schema, query_str, variables: nil)
+      assert query.valid?
+    end
+  end
+
   describe 'NullValue type arguments' do
     let(:schema_definition) {
       <<-GRAPHQL

data/spec/graphql/schema/interface_spec.rb

@@ -161,6 +161,12 @@ describe GraphQL::Schema::Interface do
   describe ':DefinitionMethods' do
     module InterfaceA
       include GraphQL::Schema::Interface
+
+      definition_methods do
+        def some_method
+          42
+        end
+      end
     end
 
     module InterfaceB
@@ -171,6 +177,10 @@ describe GraphQL::Schema::Interface do
       include GraphQL::Schema::Interface
     end
 
+    class ObjectA < GraphQL::Schema::Object
+      implements InterfaceA
+    end
+
     it "doesn't overwrite them when including multiple interfaces" do
       def_methods = InterfaceC::DefinitionMethods
 
@@ -181,5 +191,9 @@ describe GraphQL::Schema::Interface do
 
       assert_equal(InterfaceC::DefinitionMethods, def_methods)
     end
+
+    it "extends classes with the defined methods" do
+      assert_equal(ObjectA.some_method, InterfaceA.some_method)
+    end
   end
 end

data/spec/graphql/schema/object_spec.rb

@@ -41,6 +41,30 @@ describe GraphQL::Schema::Object do
       assert_equal object_class.description, new_subclass_2.description
     end
 
+    it "does not inherit singleton methods from base interface when implementing base interface" do
+      object_type = Class.new(GraphQL::Schema::Object)
+      methods = object_type.singleton_methods
+      method_defs = Hash[methods.zip(methods.map{|method| object_type.method(method.to_sym)})]
+
+      object_type.implements(GraphQL::Schema::Interface)
+      new_method_defs = Hash[methods.zip(methods.map{|method| object_type.method(method.to_sym)})]
+      assert_equal method_defs, new_method_defs
+    end
+
+    it "does not inherit singleton methods from base interface when implementing another interface" do
+      object_type = Class.new(GraphQL::Schema::Object)
+      methods = object_type.singleton_methods
+      method_defs = Hash[methods.zip(methods.map{|method| object_type.method(method.to_sym)})]
+
+      module InterfaceType
+        include GraphQL::Schema::Interface
+      end
+
+      object_type.implements(InterfaceType)
+      new_method_defs = Hash[methods.zip(methods.map{|method| object_type.method(method.to_sym)})]
+      assert_equal method_defs, new_method_defs
+    end
+
     it "should take Ruby name (without Type suffix) as default graphql name" do
       TestingClassType = Class.new(GraphQL::Schema::Object)
       assert_equal "TestingClass", TestingClassType.graphql_name
@@ -83,7 +107,23 @@ describe GraphQL::Schema::Object do
     end
   end
 
-  describe ".to_graphql_type" do
+  describe "wrapping `nil`" do
+    it "doesn't wrap nil in lists" do
+      query_str = <<-GRAPHQL
+      {
+        namedEntities {
+          name
+        }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      expected_items = [{"name" => "Bela Fleck and the Flecktones"}, nil]
+      assert_equal expected_items, res["data"]["namedEntities"]
+    end
+  end
+
+  describe ".to_graphql" do
     let(:obj_type) { Jazz::Ensemble.to_graphql }
     it "returns a matching GraphQL::ObjectType" do
       assert_equal "Ensemble", obj_type.name