graphql 1.10.6 → 1.10.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b006fe34754dbc2e3ee7ef459e05bdf325755538e013efd96c9eef3990af9a7
-  data.tar.gz: b655b349e59ea3a34d6ed71fb3870af1cc91afc75bf7147cb0d9b436b78a97c8
+  metadata.gz: dffbc22cc92ab7e74cf26f0a6e916ae1f03014722e350318af8ee367c9eb6f40
+  data.tar.gz: 8b98748a98c2a7b5d471542989245a16d148b44519c69aa51cec062649357b31
 SHA512:
-  metadata.gz: 9a07c35f18dfdb53924fc9ff8466c3255c7235f855d5ea7380738e4cde90c47c6cd12aaa505a27ee1c3ec3bee84a8a82ed9ec113cbbd362ef152a8b1ec6cdf38
-  data.tar.gz: 23e61762fd23870cb651334aa84a9e83bb9dda486b114ea8bb2b937eeb77705bac200255b321983caf4f81d6efd0b231a992b618563b86d6446b68585ec429bc
+  metadata.gz: bf169d1fe41d60ad045e0faae46cfa263d4b5f2bffd56bdd527b940702e9a6e44996d7b8402a6a213a593e68adcd1b885b3ba8d7240b236db1383ae9d9073f6c
+  data.tar.gz: 24293245691980f79e316977fe24a6dfc6025f25d7d46806d6e46a8cc44ce9d1f84a7217487fd147209d6bef4a4ffdb0d67645fb87506850e420683a745aa90a

data/lib/graphql/execution/interpreter/runtime.rb

@@ -347,9 +347,15 @@ module GraphQL
                   end
                 end
               end
-            rescue NoMethodError
-              # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
-              raise ListResultFailedError.new(value: value, field: field, path: path)
+            rescue NoMethodError => err
+              # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
+              if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
+                # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
+                raise ListResultFailedError.new(value: value, field: field, path: path)
+              else
+                # This was some other NoMethodError -- let it bubble to reveal the real error.
+                raise
+              end
             end
 
             response_list

data/lib/graphql/language/document_from_schema_definition.rb

@@ -49,7 +49,7 @@ module GraphQL
           subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
           # This only supports directives from parsing,
           # use a custom printer to add to this list.
-          directives: @schema.ast_node ? @schema.ast_node.directives : [],
+          directives: ast_directives(@schema),
         )
       end
 
@@ -59,32 +59,26 @@ module GraphQL
           interfaces: warden.interfaces(object_type).sort_by(&:graphql_name).map { |iface| build_type_name_node(iface) },
           fields: build_field_nodes(warden.fields(object_type)),
           description: object_type.description,
+          directives: ast_directives(object_type),
         )
       end
 
       def build_field_node(field)
-        field_node = GraphQL::Language::Nodes::FieldDefinition.new(
+        GraphQL::Language::Nodes::FieldDefinition.new(
           name: field.graphql_name,
           arguments: build_argument_nodes(warden.arguments(field)),
           type: build_type_name_node(field.type),
           description: field.description,
+          directives: ast_directives(field),
         )
-
-        if field.deprecation_reason
-          field_node = field_node.merge_directive(
-            name: GraphQL::Directive::DeprecatedDirective.graphql_name,
-            arguments: [GraphQL::Language::Nodes::Argument.new(name: "reason", value: field.deprecation_reason)]
-          )
-        end
-
-        field_node
       end
 
       def build_union_type_node(union_type)
         GraphQL::Language::Nodes::UnionTypeDefinition.new(
           name: union_type.graphql_name,
           description: union_type.description,
-          types: warden.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) }
+          types: warden.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
+          directives: ast_directives(union_type),
         )
       end
 
@@ -92,7 +86,8 @@ module GraphQL
         GraphQL::Language::Nodes::InterfaceTypeDefinition.new(
           name: interface_type.graphql_name,
           description: interface_type.description,
-          fields: build_field_nodes(warden.fields(interface_type))
+          fields: build_field_nodes(warden.fields(interface_type)),
+          directives: ast_directives(interface_type),
         )
       end
 
@@ -103,29 +98,23 @@ module GraphQL
             build_enum_value_node(enum_value)
           end,
           description: enum_type.description,
+          directives: ast_directives(enum_type),
         )
       end
 
       def build_enum_value_node(enum_value)
-        enum_value_node = GraphQL::Language::Nodes::EnumValueDefinition.new(
+        GraphQL::Language::Nodes::EnumValueDefinition.new(
           name: enum_value.graphql_name,
           description: enum_value.description,
+          directives: ast_directives(enum_value),
         )
-
-        if enum_value.deprecation_reason
-          enum_value_node = enum_value_node.merge_directive(
-            name: GraphQL::Directive::DeprecatedDirective.graphql_name,
-            arguments: [GraphQL::Language::Nodes::Argument.new(name: "reason", value: enum_value.deprecation_reason)]
-          )
-        end
-
-        enum_value_node
       end
 
       def build_scalar_type_node(scalar_type)
         GraphQL::Language::Nodes::ScalarTypeDefinition.new(
           name: scalar_type.graphql_name,
           description: scalar_type.description,
+          directives: ast_directives(scalar_type),
         )
       end
 
@@ -141,6 +130,7 @@ module GraphQL
           description: argument.description,
           type: build_type_name_node(argument.type),
           default_value: default_value,
+          directives: ast_directives(argument),
         )
 
         argument_node
@@ -151,6 +141,7 @@ module GraphQL
           name: input_object.graphql_name,
           fields: build_argument_nodes(warden.arguments(input_object)),
           description: input_object.description,
+          directives: ast_directives(input_object),
         )
       end
 
@@ -292,6 +283,34 @@ module GraphQL
         (schema.subscription.nil? || schema.subscription.graphql_name == 'Subscription')
       end
 
+      def ast_directives(member)
+        ast_directives = member.ast_node ? member.ast_node.directives : []
+
+        # If this schema was built from IDL, it will already have `@deprecated` in `ast_node.directives`
+        if member.respond_to?(:deprecation_reason) &&
+            (reason = member.deprecation_reason) &&
+            ast_directives.none? { |d| d.name == "deprecated" }
+
+          arguments = []
+
+          if reason != GraphQL::Schema::Directive::DEFAULT_DEPRECATION_REASON
+            arguments << GraphQL::Language::Nodes::Argument.new(
+              name: "reason",
+              value: reason
+            )
+          end
+
+          ast_directives += [
+            GraphQL::Language::Nodes::Directive.new(
+              name: GraphQL::Directive::DeprecatedDirective.graphql_name,
+              arguments: arguments
+            )
+          ]
+        end
+
+        ast_directives
+      end
+
       attr_reader :schema, :warden, :always_include_schema,
         :include_introspection_types, :include_built_in_directives, :include_built_in_scalars
     end

data/lib/graphql/schema.rb

@@ -555,8 +555,17 @@ module GraphQL
     # @param context [GraphQL::Query::Context] The context for the current query
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
     def possible_types(type_defn, context = GraphQL::Query::NullContext)
-      @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
-      @possible_types.possible_types(type_defn, context)
+      if context == GraphQL::Query::NullContext
+        @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
+        @possible_types.possible_types(type_defn, context)
+      else
+        # Use the incoming context to cache this instance --
+        # if it were cached on the schema, we'd have a memory leak
+        # https://github.com/rmosolgo/graphql-ruby/issues/2878
+        ns = context.namespace(:possible_types)
+        per_query_possible_types = ns[:possible_types] ||= GraphQL::Schema::PossibleTypes.new(self)
+        per_query_possible_types.possible_types(type_defn, context)
+      end
     end
 
     # @see [GraphQL::Schema::Warden] Resticted access to root types

data/lib/graphql/schema/list.rb

@@ -31,6 +31,11 @@ module GraphQL
         nil
       end
 
+      # Also for implementing introspection
+      def description
+        nil
+      end
+
       def coerce_result(value, ctx)
         value.map { |i| i.nil? ? nil : of_type.coerce_result(i, ctx) }
       end

data/lib/graphql/schema/loader.rb

@@ -5,18 +5,19 @@ module GraphQL
     # to make a schema. This schema is missing some important details like
     # `resolve` functions, but it does include the full type system,
     # so you can use it to validate queries.
+    #
+    # @see GraphQL::Schema.from_introspection for a public API
     module Loader
       extend self
 
       # Create schema with the result of an introspection query.
       # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
-      # @return [GraphQL::Schema] the schema described by `input`
-      # @deprecated Use {GraphQL::Schema.from_introspection} instead
+      # @return [Class] the schema described by `input`
       def load(introspection_result)
         schema = introspection_result.fetch("data").fetch("__schema")
 
         types = {}
-        type_resolver = ->(type) { -> { resolve_type(types, type) } }
+        type_resolver = ->(type) { resolve_type(types, type) }
 
         schema.fetch("types").each do |type|
           next if type.fetch("name").start_with?("__")
@@ -24,18 +25,22 @@ module GraphQL
           types[type["name"]] = type_object
         end
 
-        kargs = { orphan_types: types.values, resolve_type: NullResolveType }
-        [:query, :mutation, :subscription].each do |root|
-          type = schema["#{root}Type"]
-          kargs[root] = types.fetch(type.fetch("name")) if type
-        end
+        Class.new(GraphQL::Schema) do
+          orphan_types(types.values)
 
-        Schema.define(**kargs, raise_definition_error: true)
-      end
+          def self.resolve_type(*)
+            raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
+          end
 
-      NullResolveType = ->(type, obj, ctx) {
-        raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
-      }
+          [:query, :mutation, :subscription].each do |root|
+            type = schema["#{root}Type"]
+            if type
+              type_defn = types.fetch(type.fetch("name"))
+              self.public_send(root, type_defn)
+            end
+          end
+        end
+      end
 
       NullScalarCoerce = ->(val, _ctx) { val }
 
@@ -48,14 +53,14 @@ module GraphQL
             type_name = type.fetch("name")
             type = types[type_name] || Schema::BUILT_IN_TYPES[type_name]
             if type.nil?
-              raise "Type not found: #{type_name.inspect} among #{types.keys.sort}"
+              GraphQL::Schema::LateBoundType.new(type_name)
             else
-              type.graphql_definition
+              type
             end
           when "LIST"
-            ListType.new(of_type: resolve_type(types, type.fetch("ofType")))
+            Schema::List.new(resolve_type(types, type.fetch("ofType")))
           when "NON_NULL"
-            NonNullType.new(of_type: resolve_type(types, type.fetch("ofType")))
+            Schema::NonNull.new(resolve_type(types, type.fetch("ofType")))
           else
             fail GraphQL::RequiredImplementationMissingError, "#{kind} not implemented"
           end
@@ -83,109 +88,108 @@ module GraphQL
         end
 
         def define_type(type, type_resolver)
+          loader = self
           case type.fetch("kind")
           when "ENUM"
-            EnumType.define(
-              name: type["name"],
-              description: type["description"],
-              values: type["enumValues"].map { |enum|
-                EnumType::EnumValue.define(
-                  name: enum["name"],
-                  description: enum["description"],
-                  deprecation_reason: enum["deprecationReason"],
-                  value: enum["name"]
+            Class.new(GraphQL::Schema::Enum) do
+              graphql_name(type["name"])
+              description(type["description"])
+              type["enumValues"].each do |enum_value|
+                value(
+                  enum_value["name"],
+                  description: enum_value["description"],
+                  deprecation_reason: enum_value["deprecation_reason"],
                 )
-              })
+              end
+            end
           when "INTERFACE"
-            InterfaceType.define(
-              name: type["name"],
-              description: type["description"],
-              fields: Hash[(type["fields"] || []).map { |field|
-                [field["name"], define_type(field.merge("kind" => "FIELD"), type_resolver)]
-              }]
-            )
+            Module.new do
+              include GraphQL::Schema::Interface
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_fields(self, type["fields"] || [], type_resolver)
+            end
           when "INPUT_OBJECT"
-            InputObjectType.define(
-              name: type["name"],
-              description: type["description"],
-              arguments: Hash[type["inputFields"].map { |arg|
-                [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
-              }]
-            )
-          when "OBJECT"
-            ObjectType.define(
-              name: type["name"],
-              description: type["description"],
-              interfaces: (type["interfaces"] || []).map { |interface|
-                type_resolver.call(interface)
-              },
-              fields: Hash[type["fields"].map { |field|
-                [field["name"], define_type(field.merge("kind" => "FIELD"), type_resolver)]
-              }]
-            )
-          when "FIELD"
-            defns = {
-              name: type["name"],
-              type: type_resolver.call(type["type"]),
-              description: type["description"],
-            }
-
-            # Avoid passing an empty hash, which warns on Ruby 2.7
-            if type["args"].any?
-              defns[:arguments] = Hash[type["args"].map { |arg|
-                [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
-              }]
+            Class.new(GraphQL::Schema::InputObject) do
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_arguments(self, type["inputFields"], type_resolver)
             end
-
-            GraphQL::Field.define(**defns)
-          when "ARGUMENT"
-            kwargs = {}
-            if type["defaultValue"]
-              kwargs[:default_value] = begin
-                default_value_str = type["defaultValue"]
-
-                dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
-
-                # Returns a `GraphQL::Language::Nodes::Document`:
-                dummy_query_ast = GraphQL.parse(dummy_query_str)
-
-                # Reach into the AST for the default value:
-                input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
-
-                extract_default_value(default_value_str, input_value_ast)
+          when "OBJECT"
+            Class.new(GraphQL::Schema::Object) do
+              graphql_name(type["name"])
+              description(type["description"])
+              if type["interfaces"]
+                type["interfaces"].each do |interface_type|
+                  implements(type_resolver.call(interface_type))
+                end
               end
+              loader.build_fields(self, type["fields"], type_resolver)
             end
-
-            GraphQL::Argument.define(
-              name: type["name"],
-              type: type_resolver.call(type["type"]),
-              description: type["description"],
-              method_access: false,
-              **kwargs
-            )
           when "SCALAR"
             type_name = type.fetch("name")
-            if GraphQL::Schema::BUILT_IN_TYPES[type_name]
-              GraphQL::Schema::BUILT_IN_TYPES[type_name]
+            if (builtin = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+              builtin
             else
-              ScalarType.define(
-                name: type["name"],
-                description: type["description"],
-                coerce: NullScalarCoerce,
-              )
+              Class.new(GraphQL::Schema::Scalar) do
+                graphql_name(type["name"])
+                description(type["description"])
+              end
             end
           when "UNION"
-            UnionType.define(
-              name: type["name"],
-              description: type["description"],
-              possible_types: type["possibleTypes"].map { |possible_type|
-                type_resolver.call(possible_type)
-              }
-            )
+            Class.new(GraphQL::Schema::Union) do
+              graphql_name(type["name"])
+              description(type["description"])
+              possible_types(*(type["possibleTypes"].map { |pt| type_resolver.call(pt) }))
+            end
           else
             fail GraphQL::RequiredImplementationMissingError, "#{type["kind"]} not implemented"
           end
         end
+
+        public
+
+        def build_fields(type_defn, fields, type_resolver)
+          loader = self
+          fields.each do |field_hash|
+            type_defn.field(
+              field_hash["name"],
+              type: type_resolver.call(field_hash["type"]),
+              description: field_hash["description"],
+              null: true,
+            ) do
+              if field_hash["args"].any?
+                loader.build_arguments(self, field_hash["args"], type_resolver)
+              end
+            end
+          end
+        end
+
+        def build_arguments(arg_owner, args, type_resolver)
+          args.each do |arg|
+            kwargs = {
+              type: type_resolver.call(arg["type"]),
+              description: arg["description"],
+              required: false,
+            }
+
+            if arg["defaultValue"]
+              default_value_str = arg["defaultValue"]
+
+              dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
+
+              # Returns a `GraphQL::Language::Nodes::Document`:
+              dummy_query_ast = GraphQL.parse(dummy_query_str)
+
+              # Reach into the AST for the default value:
+              input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
+
+              kwargs[:default_value] = extract_default_value(default_value_str, input_value_ast)
+            end
+
+            arg_owner.argument(arg["name"], **kwargs)
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/non_null.rb

@@ -57,6 +57,11 @@ module GraphQL
       def coerce_result(value, ctx)
         of_type.coerce_result(value, ctx)
       end
+
+      # This is for implementing introspection
+      def description
+        nil
+      end
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -162,7 +162,7 @@ module GraphQL
           obj_type = GraphQL::ObjectType.new
           obj_type.name = graphql_name
           obj_type.description = description
-          obj_type.structural_interface_type_memberships = own_interface_type_memberships
+          obj_type.structural_interface_type_memberships = interface_type_memberships
           obj_type.introspection = introspection
           obj_type.mutation = mutation
           obj_type.ast_node = ast_node

data/lib/graphql/schema/printer.rb

@@ -94,20 +94,6 @@ module GraphQL
         print(node)
       end
 
-      def print_directive(directive)
-        if directive.name == "deprecated"
-          reason = directive.arguments.find { |arg| arg.name == "reason" }
-
-          if reason.value == GraphQL::Schema::Directive::DEFAULT_DEPRECATION_REASON
-            "@deprecated"
-          else
-            "@deprecated(reason: #{reason.value.to_s.inspect})"
-          end
-        else
-          super
-        end
-      end
-
       class IntrospectionPrinter < GraphQL::Language::Printer
         def print_schema_definition(schema)
           "schema {\n  query: Root\n}"

data/lib/graphql/types/iso_8601_date.rb

@@ -15,10 +15,10 @@ module GraphQL
     class ISO8601Date < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded date"
 
-      # @param value [Date]
+      # @param value [Date,DateTime,String]
       # @return [String]
       def self.coerce_result(value, _ctx)
-        value.iso8601
+        Date.parse(value.to_s).iso8601
       end
 
       # @param str_value [String]

data/lib/graphql/types/iso_8601_date_time.rb

@@ -29,12 +29,22 @@ module GraphQL
         @time_precision = value
       end
 
-      # @param value [DateTime]
+      # @param value [Date,DateTime,String]
       # @return [String]
-      def self.coerce_result(value, _ctx)
-        value.iso8601(time_precision)
-      rescue ArgumentError
-        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only DateTimes are used with this type."
+      def self.coerce_result(value, _ctx)\
+        case value
+        when DateTime
+          return value.iso8601(time_precision)
+        when Date
+          return DateTime.parse(value.to_s).iso8601(time_precision)
+        when ::String
+          return DateTime.parse(value).iso8601(time_precision)
+        else
+          # In case some other API-compliant thing is given: 
+          return value.iso8601(time_precision)
+        end 
+      rescue StandardError => error
+        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only Dates, DateTimes, and well-formatted Strings are used with this type. (#{error.message})"
       end
 
       # @param str_value [String]

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.6
+  version: 1.10.7
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-06 00:00:00.000000000 Z
+date: 2020-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips