graphql 1.12.8 → 1.12.14

data/lib/graphql/schema/argument.rb

@@ -240,60 +240,79 @@ module GraphQL
       def coerce_into_values(parent_object, values, context, argument_values)
         arg_name = graphql_name
         arg_key = keyword
-        has_value = false
         default_used = false
+
         if values.key?(arg_name)
-          has_value = true
           value = values[arg_name]
         elsif values.key?(arg_key)
-          has_value = true
           value = values[arg_key]
         elsif default_value?
-          has_value = true
           value = default_value
           default_used = true
+        else
+          # no value at all
+          owner.validate_directive_argument(self, nil)
+          return
         end
 
-        if has_value
-          loaded_value = nil
-          coerced_value = context.schema.error_handler.with_error_handling(context) do
-            type.coerce_input(value, context)
-          end
+        loaded_value = nil
+        coerced_value = context.schema.error_handler.with_error_handling(context) do
+          type.coerce_input(value, context)
+        end
 
-          # TODO this should probably be inside after_lazy
-          if loads && !from_resolver?
-            loaded_value = if type.list?
-              loaded_values = coerced_value.map { |val| owner.load_application_object(self, loads, val, context) }
-              context.schema.after_any_lazies(loaded_values) { |result| result }
-            else
+        # TODO this should probably be inside after_lazy
+        if loads && !from_resolver?
+          loaded_value = if type.list?
+            loaded_values = coerced_value.map { |val| owner.load_application_object(self, loads, val, context) }
+            context.schema.after_any_lazies(loaded_values) { |result| result }
+          else
+            context.query.with_error_handling do
               owner.load_application_object(self, loads, coerced_value, context)
             end
           end
+        end
 
-          coerced_value = if loaded_value
-            loaded_value
-          else
-            coerced_value
+        coerced_value = if loaded_value
+          loaded_value
+        else
+          coerced_value
+        end
+
+        # If this isn't lazy, then the block returns eagerly and assigns the result here
+        # If it _is_ lazy, then we write the lazy to the hash, then update it later
+        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |coerced_value|
+          owner.validate_directive_argument(self, coerced_value)
+          prepared_value = context.schema.error_handler.with_error_handling(context) do
+            prepare_value(parent_object, coerced_value, context: context)
           end
 
-          # If this isn't lazy, then the block returns eagerly and assigns the result here
-          # If it _is_ lazy, then we write the lazy to the hash, then update it later
-          argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |coerced_value|
-            owner.validate_directive_argument(self, coerced_value)
-            prepared_value = context.schema.error_handler.with_error_handling(context) do
-              prepare_value(parent_object, coerced_value, context: context)
-            end
+          # TODO code smell to access such a deeply-nested constant in a distant module
+          argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+            value: prepared_value,
+            definition: self,
+            default_used: default_used,
+          )
+        end
+      end
 
-            # TODO code smell to access such a deeply-nested constant in a distant module
-            argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
-              value: prepared_value,
-              definition: self,
-              default_used: default_used,
-            )
-          end
-        else
-          # has_value is false
-          owner.validate_directive_argument(self, nil)
+      # @api private
+      def validate_default_value
+        coerced_default_value = begin
+          type.coerce_isolated_result(default_value) unless default_value.nil?
+        rescue GraphQL::Schema::Enum::UnresolvedValueError
+          # It raises this, which is helpful at runtime, but not here...
+          default_value
+        end
+        res = type.valid_isolated_input?(coerced_default_value)
+        if !res
+          raise InvalidDefaultValueError.new(self)
+        end
+      end
+
+      class InvalidDefaultValueError < GraphQL::Error
+        def initialize(argument)
+          message = "`#{argument.path}` has an invalid default value: `#{argument.default_value.inspect}` isn't accepted by `#{argument.type.to_type_signature}`; update the default value or the argument type."
+          super(message)
         end
       end
 

data/lib/graphql/schema/build_from_definition.rb

@@ -47,10 +47,16 @@ module GraphQL
           # _while_ building the schema.
           # It will dig for a type if it encounters a custom type. This could be a problem if there are cycles.
           directive_type_resolver = nil
-          directive_type_resolver = build_resolve_type(GraphQL::Schema::BUILT_IN_TYPES, directives, ->(type_name) {
+          directive_type_resolver = build_resolve_type(types, directives, ->(type_name) {
             types[type_name] ||= begin
               defn = document.definitions.find { |d| d.respond_to?(:name) && d.name == type_name }
-              build_definition_from_node(defn, directive_type_resolver, default_resolve)
+              if defn
+                build_definition_from_node(defn, directive_type_resolver, default_resolve)
+              elsif (built_in_defn = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+                built_in_defn
+              else
+                raise "No definition for #{type_name.inspect} found in schema document or built-in types. Add a definition for it or remove it."
+              end
             end
           })
 

data/lib/graphql/schema/directive/transform.rb

@@ -39,7 +39,19 @@ module GraphQL
           transform_name = arguments[:by]
           if TRANSFORMS.include?(transform_name) && return_value.respond_to?(transform_name)
             return_value = return_value.public_send(transform_name)
-            context.namespace(:interpreter)[:runtime].write_in_response(path, return_value)
+            response = context.namespace(:interpreter)[:runtime].final_result
+            *keys, last = path
+            keys.each do |key|
+              if response && (response = response[key])
+                next
+              else
+                break
+              end
+            end
+            if response
+              response[last] = return_value
+            end
+            nil
           end
         end
       end

data/lib/graphql/schema/enum.rb

@@ -24,6 +24,15 @@ module GraphQL
       extend GraphQL::Schema::Member::ValidatesInput
 
       class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+        def initialize(value:, enum:, context:)
+          fix_message = ", but this isn't a valid value for `#{enum.graphql_name}`. Update the field or resolver to return one of `#{enum.graphql_name}`'s values instead."
+          message = if (cp = context[:current_path]) && (cf = context[:current_field])
+            "`#{cf.path}` returned `#{value.inspect}` at `#{cp.join(".")}`#{fix_message}"
+          else
+            "`#{value.inspect}` was returned for `#{enum.graphql_name}`#{fix_message}"
+          end
+          super(message)
+        end
       end
 
       class << self
@@ -100,7 +109,7 @@ module GraphQL
           if enum_value
             enum_value.graphql_name
           else
-            raise(self::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
+            raise self::UnresolvedValueError.new(enum: self, value: value, context: ctx)
           end
         end
 

data/lib/graphql/schema/input_object.rb

@@ -11,6 +11,14 @@ module GraphQL
 
       include GraphQL::Dig
 
+      # @return [GraphQL::Query::Context] The context for this query
+      attr_reader :context
+      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
+      attr_reader :arguments
+
+      # Ruby-like hash behaviors, read-only
+      def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
+
       def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context
         if ruby_kwargs
@@ -54,19 +62,8 @@ module GraphQL
         @maybe_lazies = maybe_lazies
       end
 
-      # @return [GraphQL::Query::Context] The context for this query
-      attr_reader :context
-
-      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
-      attr_reader :arguments
-
-      # Ruby-like hash behaviors, read-only
-      def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
-
       def to_h
-        @ruby_style_hash.inject({}) do |h, (key, value)|
-          h.merge(key => unwrap_value(value))
-        end
+        unwrap_value(@ruby_style_hash)
       end
 
       def to_hash
@@ -91,8 +88,8 @@ module GraphQL
         when Array
           value.map { |item| unwrap_value(item) }
         when Hash
-          value.inject({}) do |h, (key, value)|
-            h.merge(key => unwrap_value(value))
+          value.reduce({}) do |h, (key, value)|
+            h.merge!(key => unwrap_value(value))
           end
         when InputObject
           value.to_h
@@ -162,7 +159,6 @@ module GraphQL
         # @api private
         INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
 
-
         def validate_non_null_input(input, ctx)
           result = GraphQL::Query::InputValidationResult.new
 
@@ -226,8 +222,8 @@ module GraphQL
         # It's funny to think of a _result_ of an input object.
         # This is used for rendering the default value in introspection responses.
         def coerce_result(value, ctx)
-          # Allow the application to provide values as :symbols, and convert them to the strings
-          value = value.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
+          # Allow the application to provide values as :snake_symbols, and convert them to the camelStrings
+          value = value.reduce({}) { |memo, (k, v)| memo[Member::BuildType.camelize(k.to_s)] = v; memo }
 
           result = {}
 

data/lib/graphql/schema/loader.rb

@@ -169,6 +169,12 @@ module GraphQL
         def build_fields(type_defn, fields, type_resolver)
           loader = self
           fields.each do |field_hash|
+            unwrapped_field_hash = field_hash
+            while (of_type = unwrapped_field_hash["ofType"])
+              unwrapped_field_hash = of_type
+            end
+            type_name = unwrapped_field_hash["name"]
+
             type_defn.field(
               field_hash["name"],
               type: type_resolver.call(field_hash["type"]),
@@ -176,6 +182,8 @@ module GraphQL
               deprecation_reason: field_hash["deprecationReason"],
               null: true,
               camelize: false,
+              connection_extension: nil,
+              connection: type_name.end_with?("Connection"),
             ) do
               if field_hash["args"].any?
                 loader.build_arguments(self, field_hash["args"], type_resolver)

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -113,27 +113,15 @@ module GraphQL
         end
 
         def visible?(context)
-          if @mutation
-            @mutation.visible?(context)
-          else
-            true
-          end
+          true
         end
 
         def accessible?(context)
-          if @mutation
-            @mutation.accessible?(context)
-          else
-            true
-          end
+          true
         end
 
         def authorized?(object, context)
-          if @mutation
-            @mutation.authorized?(object, context)
-          else
-            true
-          end
+          true
         end
       end
     end

data/lib/graphql/schema/member/build_type.rb

@@ -124,6 +124,7 @@ module GraphQL
         end
 
         def camelize(string)
+          return string if string == '_'
           return string unless string.include?("_")
           camelized = string.split('_').map(&:capitalize).join
           camelized[0] = camelized[0].downcase

data/lib/graphql/schema/object.rb

@@ -48,12 +48,26 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          auth_val = context.query.with_error_handling do
-            begin
-              authorized?(object, context)
-            rescue GraphQL::UnauthorizedError => err
-              context.schema.unauthorized_object(err)
+          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
+
+          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
+            context.query.with_error_handling do
+              begin
+                authorized?(object, context)
+              rescue GraphQL::UnauthorizedError => err
+                context.schema.unauthorized_object(err)
+              end
+            end
+          end
+
+          auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
+            GraphQL::Execution::Lazy.new do
+              context.query.trace("authorized_lazy", trace_payload) do
+                context.schema.sync_lazy(maybe_lazy_auth_val)
+              end
             end
+          else
+            maybe_lazy_auth_val
           end
 
           context.schema.after_lazy(auth_val) do |is_authorized|

data/lib/graphql/schema/printer.rb

@@ -4,37 +4,32 @@ module GraphQL
     # Used to convert your {GraphQL::Schema} to a GraphQL schema string
     #
     # @example print your schema to standard output (via helper)
-    #   MySchema = GraphQL::Schema.define(query: QueryType)
     #   puts GraphQL::Schema::Printer.print_schema(MySchema)
     #
     # @example print your schema to standard output
-    #   MySchema = GraphQL::Schema.define(query: QueryType)
     #   puts GraphQL::Schema::Printer.new(MySchema).print_schema
     #
     # @example print a single type to standard output
-    #   query_root = GraphQL::ObjectType.define do
-    #     name "Query"
+    #   class Types::Query < GraphQL::Schema::Object
     #     description "The query root of this schema"
     #
-    #     field :post do
-    #       type post_type
-    #       resolve ->(obj, args, ctx) { Post.find(args["id"]) }
-    #     end
+    #     field :post, Types::Post, null: true
     #   end
     #
-    #   post_type = GraphQL::ObjectType.define do
-    #     name "Post"
+    #   class Types::Post < GraphQL::Schema::Object
     #     description "A blog post"
     #
-    #     field :id, !types.ID
-    #     field :title, !types.String
-    #     field :body, !types.String
+    #     field :id, ID, null: false
+    #     field :title, String, null: false
+    #     field :body, String, null: false
     #   end
     #
-    #   MySchema = GraphQL::Schema.define(query: query_root)
+    #   class MySchema < GraphQL::Schema
+    #     query(Types::Query)
+    #   end
     #
     #   printer = GraphQL::Schema::Printer.new(MySchema)
-    #   puts printer.print_type(post_type)
+    #   puts printer.print_type(Types::Post)
     #
     class Printer < GraphQL::Language::Printer
       attr_reader :schema, :warden
@@ -87,7 +82,7 @@ module GraphQL
 
       # Return a GraphQL schema string for the defined types in the schema
       def print_schema
-        print(@document)
+        print(@document) + "\n"
       end
 
       def print_type(type)

data/lib/graphql/schema/resolver.rb

@@ -307,10 +307,15 @@ module GraphQL
             arguments: arguments,
             null: null,
             complexity: complexity,
-            extensions: extensions,
             broadcastable: broadcastable?,
           }
 
+          # If there aren't any, then the returned array is `[].freeze`,
+          # but passing that along breaks some user code.
+          if (exts = extensions).any?
+            field_opts[:extensions] = exts
+          end
+
           if has_max_page_size?
             field_opts[:max_page_size] = max_page_size
           end
@@ -333,30 +338,32 @@ module GraphQL
           arg_defn = super(*args, from_resolver: true, **kwargs)
           own_arguments_loads_as_type[arg_defn.keyword] = loads if loads
 
-          if loads && arg_defn.type.list?
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(values)
-              argument = @arguments_by_keyword[:#{arg_defn.keyword}]
-              lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
-              context.schema.after_lazy(values) do |values2|
-                GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value, context) })
+          if !method_defined?(:"load_#{arg_defn.keyword}")
+            if loads && arg_defn.type.list?
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(values)
+                argument = @arguments_by_keyword[:#{arg_defn.keyword}]
+                lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
+                context.schema.after_lazy(values) do |values2|
+                  GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value, context) })
+                end
               end
+              RUBY
+            elsif loads
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(value)
+                argument = @arguments_by_keyword[:#{arg_defn.keyword}]
+                lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
+                load_application_object(argument, lookup_as_type, value, context)
+              end
+              RUBY
+            else
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{arg_defn.keyword}(value)
+                value
+              end
+              RUBY
             end
-            RUBY
-          elsif loads
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(value)
-              argument = @arguments_by_keyword[:#{arg_defn.keyword}]
-              lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
-              load_application_object(argument, lookup_as_type, value, context)
-            end
-            RUBY
-          else
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def load_#{arg_defn.keyword}(value)
-              value
-            end
-            RUBY
           end
 
           arg_defn
@@ -372,16 +379,36 @@ module GraphQL
         # @param extension [Class] Extension class
         # @param options [Hash] Optional extension options
         def extension(extension, **options)
-          extensions << {extension => options}
+          @own_extensions ||= []
+          @own_extensions << {extension => options}
         end
 
         # @api private
         def extensions
-          @extensions ||= []
+          own_exts = @own_extensions
+          # Jump through some hoops to avoid creating arrays when we don't actually need them
+          if superclass.respond_to?(:extensions)
+            s_exts = superclass.extensions
+            if own_exts
+              if s_exts.any?
+                own_exts + s_exts
+              else
+                own_exts
+              end
+            else
+              s_exts
+            end
+          else
+            own_exts || EMPTY_ARRAY
+          end
         end
 
         private
 
+        def own_extensions
+          @own_extensions
+        end
+
         def own_arguments_loads_as_type
           @own_arguments_loads_as_type ||= {}
         end