graphql 1.2.6 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2550713a1eb62110904f3370fc77ce4f9d829efa
-  data.tar.gz: d70c9b62e551278f6764e5aa4a5a3cdcb973c7be
+  metadata.gz: 0019d58e7660531d537f4318a9f77df48ee6c501
+  data.tar.gz: b1b229e62437f03ce0f5003a92c2546b733121ad
 SHA512:
-  metadata.gz: 86120c08fcf5598c0672ff0a035939ec44a450509d57dcf6ca5627f35c3bb8efcfd1b3be063fa5ea194c40e652390a22a20eb32b2e347026e87ce28100551a96
-  data.tar.gz: 83692323da75a39f24439aefdf0280d1a64240f332bef934207753dc672edb7fc4da81b8900aeeccbf463409df2497ef25243b98595604bc7676abaa0df775c1
+  metadata.gz: 7d9f28b11005ac84e02b4528cd6c75ace38368c7bed476bc08a7c8b5b88e6a2643a2e5a3779da11babcf983aacc30bcc4bf6a69e53da83cc8e0b4ecac042a5f9
+  data.tar.gz: 22249283811a82bda630d4d5f24149cfbdea7ad2a7aa9a4583810a318f054093c077b87d6f84550c129e3d431f3a504fa0b97ad109c65b1b89dd0f6e7716e256

data/lib/graphql.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "json"
 require "set"
 require "singleton"
@@ -67,6 +68,7 @@ require "graphql/directive"
 require "graphql/introspection"
 require "graphql/language"
 require "graphql/analysis"
+require "graphql/execution"
 require "graphql/schema"
 require "graphql/schema/loader"
 require "graphql/schema/printer"
@@ -74,6 +76,7 @@ require "graphql/schema/printer"
 # Order does not matter for these:
 
 require "graphql/analysis_error"
+require "graphql/runtime_type_error"
 require "graphql/invalid_null_error"
 require "graphql/unresolved_type_error"
 require "graphql/query"
@@ -81,5 +84,4 @@ require "graphql/internal_representation"
 require "graphql/static_validation"
 require "graphql/version"
 require "graphql/relay"
-require "graphql/execution"
 require "graphql/compatibility"

data/lib/graphql/analysis.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "graphql/analysis/max_query_complexity"
 require "graphql/analysis/max_query_depth"
 require "graphql/analysis/query_complexity"

data/lib/graphql/analysis/analyze_query.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Analysis
     module_function

data/lib/graphql/analysis/field_usage.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Analysis
     # A query reducer for tracking both field usage and deprecated field usage.

data/lib/graphql/analysis/max_query_complexity.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative "./query_complexity"
 module GraphQL
   module Analysis

data/lib/graphql/analysis/max_query_depth.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative "./query_depth"
 module GraphQL
   module Analysis

data/lib/graphql/analysis/query_complexity.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Analysis
     # Calculate the complexity of a query, using {Field#complexity} values.

data/lib/graphql/analysis/query_depth.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Analysis
     # A query reducer for measuring the depth of a given query.

data/lib/graphql/analysis/reducer_state.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Analysis
     class ReducerState

data/lib/graphql/analysis_error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class AnalysisError < GraphQL::ExecutionError
   end

data/lib/graphql/argument.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # Used for defined arguments ({Field}, {InputObjectType})
   #

data/lib/graphql/base_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # The parent for all type classes.
   class BaseType
@@ -8,14 +9,20 @@ module GraphQL
         global_id_field: GraphQL::Define::AssignGlobalIdField,
       }
 
-    attr_accessor :name, :description
     ensure_defined(:name, :description)
 
-    # @!attribute name
-    #   @return [String] the name of this type, must be unique within a Schema
+    def initialize_copy(other)
+      super
+      # Reset these derived defaults
+      @connection_type = nil
+      @edge_type = nil
+    end
+
+    # @return [String] the name of this type, must be unique within a Schema
+    attr_accessor :name
 
-    # @!attribute description
-    #  @return [String, nil] a description for this type
+    # @return [String, nil] a description for this type
+    attr_accessor :description
 
     # @param other [GraphQL::BaseType] compare to this object
     # @return [Boolean] are these types equivalent? (incl. non-null, list)
@@ -102,22 +109,24 @@ module GraphQL
       end
     end
 
-    # Get the default connection type for this object type
+    # @return [GraphQL::ObjectType] The default connection type for this object type
     def connection_type
       @connection_type ||= define_connection
     end
 
     # Define a custom connection type for this object type
+    # @return [GraphQL::ObjectType]
     def define_connection(**kwargs, &block)
       GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
     end
 
-    # Get the default edge type for this object type
+    # @return [GraphQL::ObjectType] The default edge type for this object type
     def edge_type
       @edge_type ||= define_edge
     end
 
     # Define a custom edge type for this object type
+    # @return [GraphQL::ObjectType]
     def define_edge(**kwargs, &block)
       GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
     end

data/lib/graphql/boolean_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
   name "Boolean"
   description "Represents `true` or `false` values."

data/lib/graphql/compatibility.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
 require "graphql/compatibility/execution_specification"
+require "graphql/compatibility/lazy_execution_specification"
 require "graphql/compatibility/query_parser_specification"
 require "graphql/compatibility/schema_parser_specification"

data/lib/graphql/compatibility/execution_specification.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+require "graphql/compatibility/execution_specification/counter_schema"
+require "graphql/compatibility/execution_specification/specification_schema"
+
 module GraphQL
   module Compatibility
     # Test an execution strategy. This spec is not meant as a development aid.
@@ -22,164 +26,22 @@ module GraphQL
     # - Relay features
     #
     module ExecutionSpecification
-      DATA = {
-        "1001" => OpenStruct.new({
-          name: "Fannie Lou Hamer",
-          birthdate: Time.new(1917, 10, 6),
-          organization_ids: [],
-        }),
-        "1002" => OpenStruct.new({
-          name: "John Lewis",
-          birthdate: Time.new(1940, 2, 21),
-          organization_ids: ["2001"],
-        }),
-        "1003" => OpenStruct.new({
-          name: "Diane Nash",
-          birthdate: Time.new(1938, 5, 15),
-          organization_ids: ["2001", "2002"],
-        }),
-        "1004" => OpenStruct.new({
-          name: "Ralph Abernathy",
-          birthdate: Time.new(1926, 3, 11),
-          organization_ids: ["2002"],
-        }),
-        "2001" => OpenStruct.new({
-          name: "SNCC",
-          leader_id: nil, # fail on purpose
-        }),
-        "2002" => OpenStruct.new({
-          name: "SCLC",
-          leader_id: "1004",
-        }),
-      }
-
       # Make a minitest suite for this execution strategy, making sure it
       # fulfills all the requirements of this library.
       # @param execution_strategy [<#new, #execute>] An execution strategy class
       # @return [Class<Minitest::Test>] A test suite for this execution strategy
       def self.build_suite(execution_strategy)
         Class.new(Minitest::Test) do
-          def self.build_schema(execution_strategy)
-            organization_type = nil
-
-            timestamp_type = GraphQL::ScalarType.define do
-              name "Timestamp"
-              coerce_input ->(value) { Time.at(value.to_i) }
-              coerce_result ->(value) { value.to_i }
-            end
-
-            named_entity_interface_type = GraphQL::InterfaceType.define do
-              name "NamedEntity"
-              field :name, !types.String
-            end
-
-            person_type = GraphQL::ObjectType.define do
-              name "Person"
-              interfaces [named_entity_interface_type]
-              field :name, !types.String
-              field :birthdate, timestamp_type
-              field :age, types.Int do
-                argument :on, !timestamp_type
-                resolve ->(obj, args, ctx) {
-                  if obj.birthdate.nil?
-                    nil
-                  else
-                    age_on = args[:on]
-                    age_years = age_on.year - obj.birthdate.year
-                    this_year_birthday = Time.new(age_on.year, obj.birthdate.month, obj.birthdate.day)
-                    if this_year_birthday > age_on
-                      age_years -= 1
-                    end
-                  end
-                  age_years
-                }
-              end
-              field :organizations, types[organization_type] do
-                resolve ->(obj, args, ctx) {
-                  obj.organization_ids.map { |id| DATA[id] }
-                }
-              end
-              field :first_organization, !organization_type do
-                resolve ->(obj, args, ctx) {
-                  DATA[obj.organization_ids.first]
-                }
-              end
-            end
-
-            organization_type = GraphQL::ObjectType.define do
-              name "Organization"
-              interfaces [named_entity_interface_type]
-              field :name, !types.String
-              field :leader, !person_type do
-                resolve ->(obj, args, ctx) {
-                  DATA[obj.leader_id] || (ctx[:return_error] ? ExecutionError.new("Error on Nullable") : nil)
-                }
-              end
-              field :returnedError, types.String do
-                resolve ->(o, a, c) {
-                  GraphQL::ExecutionError.new("This error was returned")
-                }
-              end
-              field :raisedError, types.String do
-                resolve ->(o, a, c) {
-                  raise GraphQL::ExecutionError.new("This error was raised")
-                }
-              end
-
-              field :nodePresence, !types[!types.Boolean] do
-                resolve ->(o, a, ctx) {
-                  [
-                    ctx.irep_node.is_a?(GraphQL::InternalRepresentation::Node),
-                    ctx.ast_node.is_a?(GraphQL::Language::Nodes::AbstractNode),
-                    false, # just testing
-                  ]
-                }
-              end
-            end
-
-            node_union_type = GraphQL::UnionType.define do
-              name "Node"
-              possible_types [person_type, organization_type]
-            end
-
-            query_type = GraphQL::ObjectType.define do
-              name "Query"
-              field :node, node_union_type do
-                argument :id, !types.ID
-                resolve ->(obj, args, ctx) {
-                  obj[args[:id]]
-                }
-              end
-
-              field :organization, !organization_type do
-                argument :id, !types.ID
-                resolve ->(obj, args, ctx) {
-                  args[:id].start_with?("2") && obj[args[:id]]
-                }
-              end
-
-              field :organizations, types[organization_type] do
-                resolve ->(obj, args, ctx) {
-                  [obj["2001"], obj["2002"]]
-                }
-              end
-            end
-
-            GraphQL::Schema.define do
-              query_execution_strategy execution_strategy
-              query query_type
-
-              resolve_type ->(obj, ctx) {
-                obj.respond_to?(:birthdate) ? person_type : organization_type
-              }
-            end
+          class << self
+            attr_accessor :counter_schema, :specification_schema
           end
 
-          @@schema = build_schema(execution_strategy)
+          self.specification_schema = SpecificationSchema.build(execution_strategy)
+          self.counter_schema = CounterSchema.build(execution_strategy)
 
           def execute_query(query_string, **kwargs)
-            kwargs[:root_value] = DATA
-            @@schema.execute(query_string, **kwargs)
+            kwargs[:root_value] = SpecificationSchema::DATA
+            self.class.specification_schema.execute(query_string, **kwargs)
           end
 
           def test_it_fetches_data
@@ -220,6 +82,21 @@ module GraphQL
             assert_equal false, flh.key?("org_n"), "It doesn't apply other type fields"
           end
 
+          def test_it_iterates_over_each
+            query_string = %|
+              query getData($nodeId: ID = "1002") {
+                node(id: $nodeId) {
+                  ... on Person {
+                    organizations { name }
+                  }
+                }
+              }
+            |
+
+            res = execute_query(query_string)
+            assert_equal ["SNCC"], res["data"]["node"]["organizations"].map { |o| o["name"] }
+          end
+
           def test_it_propagates_nulls_to_field
             query_string = %|
             query getOrg($id: ID = "2001"){
@@ -329,7 +206,7 @@ module GraphQL
               }
             }|
 
-            assert_raises(GraphQL::UnresolvedTypeError) {
+            err = assert_raises(GraphQL::UnresolvedTypeError) {
               execute_query(query_string, except: no_org)
             }
 
@@ -342,6 +219,11 @@ module GraphQL
 
             assert_equal nil, res["data"]
             assert_equal 1, res["errors"].length
+            assert_equal "SNCC", err.value.name
+            assert_equal GraphQL::Relay::Node.interface, err.field.type
+            assert_equal 1, err.possible_types.length
+            assert_equal "Organization", err.resolved_type.name
+            assert_equal "Query", err.parent_type.name
 
             query_string = %|
             {
@@ -409,47 +291,7 @@ module GraphQL
           end
 
           def test_it_only_resolves_fields_once_on_typed_fragments
-            count = 0
-            counter_type = nil
-
-            has_count_interface = GraphQL::InterfaceType.define do
-              name "HasCount"
-              field :count, types.Int
-              field :counter, ->{ counter_type }
-            end
-
-            counter_type = GraphQL::ObjectType.define do
-              name "Counter"
-              interfaces [has_count_interface]
-              field :count, types.Int, resolve: ->(o,a,c) { count += 1 }
-              field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
-            end
-
-            alt_counter_type = GraphQL::ObjectType.define do
-              name "AltCounter"
-              interfaces [has_count_interface]
-              field :count, types.Int, resolve: ->(o,a,c) { count += 1 }
-              field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
-            end
-
-            has_counter_interface = GraphQL::InterfaceType.define do
-              name "HasCounter"
-              field :counter, counter_type
-            end
-
-            query_type = GraphQL::ObjectType.define do
-              name "Query"
-              interfaces [has_counter_interface]
-              field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
-            end
-
-            schema = GraphQL::Schema.define(
-              query: query_type,
-              resolve_type: ->(o, c) { o == :counter ? counter_type : nil },
-              orphan_types: [alt_counter_type],
-            )
-
-            res = schema.execute("
+            res = self.class.counter_schema.execute("
             {
               counter { count }
               ... on HasCounter {
@@ -462,10 +304,10 @@ module GraphQL
               "counter" => { "count" => 1 }
             }
             assert_equal expected_data, res["data"]
-            assert_equal 1, count
+            assert_equal 1, self.class.counter_schema.metadata[:count]
 
             # Deep typed children are correctly distinguished:
-            res = schema.execute("
+            res = self.class.counter_schema.execute("
             {
               counter {
                 ... on Counter {
@@ -483,6 +325,85 @@ module GraphQL
             }
             assert_equal expected_data, res["data"]
           end
+
+          def test_it_runs_middleware
+            log = []
+            query_string = %|
+            {
+              node(id: "2001") {
+                __typename
+              }
+            }|
+            res = execute_query(query_string, context: {middleware_log: log})
+            assert_equal ["node", "__typename"], log
+          end
+
+          def test_it_uses_type_error_hooks_for_invalid_nulls
+            log = []
+            query_string = %|
+            {
+              node(id: "1001") {
+                ... on Person {
+                  name
+                  first_organization {
+                    leader {
+                      name
+                    }
+                  }
+                }
+              }
+            }|
+
+            res = execute_query(query_string, context: { type_errors: log })
+            assert_equal nil, res["data"]["node"]
+            assert_equal [nil], log
+          end
+
+          def test_it_uses_type_error_hooks_for_failed_type_resolution
+            log = []
+            query_string = %|
+            {
+              node(id: "2003") {
+                __typename
+              }
+            }|
+
+            assert_raises(GraphQL::UnresolvedTypeError) {
+              execute_query(query_string, context: { type_errors: log })
+            }
+
+            assert_equal [SpecificationSchema::BOGUS_NODE], log
+          end
+
+          def test_it_treats_failed_type_resolution_like_nil
+            log = []
+            ctx = { type_errors: log, gobble: true }
+            query_string = %|
+            {
+              node(id: "2003") {
+                __typename
+              }
+            }|
+
+            res = execute_query(query_string, context: ctx)
+
+            assert_equal nil, res["data"]["node"]
+            assert_equal false, res.key?("errors")
+            assert_equal [SpecificationSchema::BOGUS_NODE], log
+
+            query_string_2 = %|
+            {
+              requiredNode(id: "2003") {
+                __typename
+              }
+            }|
+
+            res = execute_query(query_string_2, context: ctx)
+
+            assert_equal nil, res["data"]
+            assert_equal false, res.key?("errors")
+            assert_equal [SpecificationSchema::BOGUS_NODE, SpecificationSchema::BOGUS_NODE], log
+          end
         end
       end
     end