graphql 1.10.7 → 1.10.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dffbc22cc92ab7e74cf26f0a6e916ae1f03014722e350318af8ee367c9eb6f40
-  data.tar.gz: 8b98748a98c2a7b5d471542989245a16d148b44519c69aa51cec062649357b31
+  metadata.gz: 840c0d49f547bfb3a44878e0631df87f3b287179a077806169480a8d2820b30b
+  data.tar.gz: 498c331da5d7f3818054def18b1a964f1ff97699b79b7be1635eefbad0dcc946
 SHA512:
-  metadata.gz: bf169d1fe41d60ad045e0faae46cfa263d4b5f2bffd56bdd527b940702e9a6e44996d7b8402a6a213a593e68adcd1b885b3ba8d7240b236db1383ae9d9073f6c
-  data.tar.gz: 24293245691980f79e316977fe24a6dfc6025f25d7d46806d6e46a8cc44ce9d1f84a7217487fd147209d6bef4a4ffdb0d67645fb87506850e420683a745aa90a
+  metadata.gz: 0cc7bdbeff9a1c70f28c50ffa93740020173a969d34e9aa8872073f721555ebe1c67fa74e13d012d6c547bc4aa6515ab7dafe173dd75bfdea9fe0c4a2b256ac8
+  data.tar.gz: a466d22dd0e14f95b7273faedc68d3ff214e0f72411e491f454d037b1b74034a67b1eb6334cd567334cf5856c1b91e65a38024955426079c317c43eee47557c7

data/lib/generators/graphql/object_generator.rb

@@ -15,20 +15,62 @@ module Graphql
       desc "Create a GraphQL::ObjectType with the given name and fields"
       source_root File.expand_path('../templates', __FILE__)
 
-      argument :fields,
-        type: :array,
-        default: [],
-        banner: "name:type name:type ...",
-        desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+      argument :custom_fields,
+               type: :array,
+               default: [],
+               banner: "name:type name:type ...",
+               desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
 
       class_option :node,
-        type: :boolean,
-        default: false,
-        desc: "Include the Relay Node interface"
+                   type: :boolean,
+                   default: false,
+                   desc: "Include the Relay Node interface"
 
       def create_type_file
         template "object.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
       end
+
+      def fields
+        columns = []
+        columns += klass.columns.map { |c| generate_column_string(c) } if class_exists?
+        columns + custom_fields
+      end
+
+      def self.normalize_type_expression(type_expression, mode:, null: true)
+        case type_expression
+        when "Text"
+          ["String", null]
+        when "DateTime", "Datetime"
+          ["GraphQL::Types::ISO8601DateTime", null]
+        when "Date"
+          ["GraphQL::Types::ISO8601Date", null]
+        else
+          super
+        end
+      end
+
+      private
+
+      def generate_column_string(column)
+        name = column.name
+        required = column.null ? "" : "!"
+        type = column_type_string(column)
+        "#{name}:#{required}#{type}"
+      end
+
+      def column_type_string(column)
+        column.name == "id" ? "ID" : column.type.to_s.camelize
+      end
+
+      def class_exists?
+        klass.is_a?(Class) && klass.ancestors.include?(ActiveRecord::Base)
+      rescue NameError
+        return false
+      end
+
+      def klass
+        @klass ||= Module.const_get(type_name.camelize)
+      end
     end
   end
 end

data/lib/graphql.rb

@@ -89,12 +89,15 @@ require "graphql/name_validator"
 require "graphql/language"
 require "graphql/analysis"
 require "graphql/tracing"
-require "graphql/execution"
 require "graphql/dig"
+require "graphql/execution"
 require "graphql/schema"
 require "graphql/query"
 require "graphql/directive"
 require "graphql/execution"
+require "graphql/runtime_type_error"
+require "graphql/unresolved_type_error"
+require "graphql/invalid_null_error"
 require "graphql/types"
 require "graphql/relay"
 require "graphql/boolean_type"
@@ -109,10 +112,7 @@ require "graphql/introspection"
 
 require "graphql/analysis_error"
 require "graphql/coercion_error"
-require "graphql/runtime_type_error"
-require "graphql/invalid_null_error"
 require "graphql/invalid_name_error"
-require "graphql/unresolved_type_error"
 require "graphql/integer_encoding_error"
 require "graphql/string_encoding_error"
 require "graphql/internal_representation"

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -54,7 +54,7 @@ module GraphQL
             case defined_complexity
             when Proc
               arguments = @query.arguments_for(@node, @field_definition)
-              defined_complexity.call(@query.context, arguments, child_complexity)
+              defined_complexity.call(@query.context, arguments.keyword_arguments, child_complexity)
             when Numeric
               defined_complexity + child_complexity
             else

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -43,8 +43,8 @@ module GraphQL
             @storage = storage
           end
 
-          def each
-            @storage.each { |i| yield(i) }
+          def each(&block)
+            @storage.each(&block)
           end
         end
 

data/lib/graphql/execution/instrumentation.rb

@@ -77,7 +77,7 @@ module GraphQL
         end
 
         def call_after_hooks(instrumenters, object, after_hook_name, ex)
-          instrumenters.reverse.each do |instrumenter|
+          instrumenters.reverse_each do |instrumenter|
             begin
               instrumenter.public_send(after_hook_name, object)
             rescue => e

data/lib/graphql/execution/interpreter.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "graphql/execution/interpreter/argument_value"
+require "graphql/execution/interpreter/arguments"
 require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
 require "graphql/execution/interpreter/hash_response"

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      # A container for metadata regarding arguments present in a GraphQL query.
+      # @see Interpreter::Arguments#argument_values for a hash of these objects.
+      class ArgumentValue
+        def initialize(definition:, value:, default_used:)
+          @definition = definition
+          @value = value
+          @default_used = default_used
+        end
+
+        # @return [Object] The Ruby-ready value for this Argument
+        attr_reader :value
+
+        # @return [GraphQL::Schema::Argument] The definition instance for this argument
+        attr_reader :definition
+
+        # @return [Boolean] `true` if the schema-defined `default_value:` was applied in this case. (No client-provided value was present.)
+        def default_used?
+          @default_used
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      # A wrapper for argument hashes in GraphQL queries.
+      #
+      # @see GraphQL::Query#arguments_for to get access to these objects.
+      class Arguments
+        extend Forwardable
+        include GraphQL::Dig
+
+        # The Ruby-style arguments hash, ready for a resolver.
+        # This hash is the one used at runtime.
+        #
+        # @return [Hash<Symbol, Object>]
+        attr_reader :keyword_arguments
+
+        def initialize(keyword_arguments:, argument_values:)
+          @keyword_arguments = keyword_arguments
+          @argument_values = argument_values
+        end
+
+        # @return [Hash{Symbol => ArgumentValue}]
+        attr_reader :argument_values
+
+        def_delegators :@keyword_arguments, :key?, :[], :keys, :each, :values
+        def_delegators :@argument_values, :each_value
+
+        def inspect
+          "#<#{self.class} @keyword_arguments=#{keyword_arguments.inspect}>"
+        end
+      end
+    end
+  end
+end

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

@@ -14,13 +14,9 @@ module GraphQL
                 # Then call into the schema to coerce those incoming values
                 args = arg_owner.coerce_arguments(parent_object, args_hash, query.context)
 
-                h3[parent_object] = if args.is_a?(GraphQL::Execution::Lazy)
-                  args.then { |resolved_args|
-                    # when this promise is resolved, update the cache with the resolved value
-                    h3[parent_object] = resolved_args
-                  }
-                else
-                  args
+                h3[parent_object] = @query.schema.after_lazy(args) do |resolved_args|
+                  # when this promise is resolved, update the cache with the resolved value
+                  h3[parent_object] = resolved_args
                 end
               end
             end

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

@@ -174,9 +174,14 @@ module GraphQL
               next
             end
 
-            after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |kwarg_arguments|
-              # It might turn out that making arguments for every field is slow.
-              # If we have to cache them, we'll need a more subtle approach here.
+            after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |resolved_arguments|
+              if resolved_arguments.is_a? GraphQL::ExecutionError
+                continue_value(next_path, resolved_arguments, field_defn, return_type.non_null?, ast_node)
+                next
+              end
+
+              kwarg_arguments = resolved_arguments.keyword_arguments
+
               field_defn.extras.each do |extra|
                 case extra
                 when :ast_node
@@ -194,6 +199,8 @@ module GraphQL
                     ast_nodes: field_ast_nodes,
                     field: field_defn,
                   )
+                when :argument_details
+                  kwarg_arguments[:argument_details] = resolved_arguments
                 else
                   kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
                 end
@@ -247,7 +254,7 @@ module GraphQL
         def continue_value(path, value, field, is_non_null, ast_node)
           if value.nil?
             if is_non_null
-              err = GraphQL::InvalidNullError.new(field.owner, field, value)
+              err = field.owner::InvalidNullError.new(field.owner, field, value)
               write_invalid_null_in_response(path, err)
             else
               write_in_response(path, nil)
@@ -297,18 +304,21 @@ module GraphQL
             write_in_response(path, r)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy = resolve_type(type, value, path)
+            resolved_type_or_lazy, resolved_value = resolve_type(type, value, path)
+            resolved_value ||= value
+
             after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
               possible_types = query.possible_types(type)
 
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner
-                type_error = GraphQL::UnresolvedTypeError.new(value, field, parent_type, resolved_type, possible_types)
+                err_class = type::UnresolvedTypeError
+                type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
                 schema.type_error(type_error, context)
                 write_in_response(path, nil)
                 nil
               else
-                continue_field(path, value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
+                continue_field(path, resolved_value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
               end
             end
           when "OBJECT"
@@ -369,11 +379,12 @@ module GraphQL
           end
         end
 
-        def resolve_with_directives(object, ast_node)
-          run_directive(object, ast_node, 0) { yield }
+        def resolve_with_directives(object, ast_node, &block)
+          return yield if ast_node.directives.empty?
+          run_directive(object, ast_node, 0, &block)
         end
 
-        def run_directive(object, ast_node, idx)
+        def run_directive(object, ast_node, idx, &block)
           dir_node = ast_node.directives[idx]
           if !dir_node
             yield
@@ -382,9 +393,9 @@ module GraphQL
             if !dir_defn.is_a?(Class)
               dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
             end
-            dir_args = arguments(nil, dir_defn, dir_node)
+            dir_args = arguments(nil, dir_defn, dir_node).keyword_arguments
             dir_defn.resolve(object, dir_args, context) do
-              run_directive(object, ast_node, idx + 1) { yield }
+              run_directive(object, ast_node, idx + 1, &block)
             end
           end
         end
@@ -393,7 +404,7 @@ module GraphQL
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
             dir_defn = schema.directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
-            args = arguments(graphql_object, dir_defn, dir_node)
+            args = arguments(graphql_object, dir_defn, dir_node).keyword_arguments
             if !dir_defn.include?(graphql_object, args, context)
               return false
             end
@@ -407,7 +418,7 @@ module GraphQL
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @param trace [Boolean] If `false`, don't wrap this with field tracing
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
-        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false, trace: true)
+        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false, trace: true, &block)
           @interpreter_context[:current_object] = owner_object
           @interpreter_context[:current_arguments] = arguments
           @interpreter_context[:current_path] = path
@@ -432,11 +443,9 @@ module GraphQL
                   end
                 end
                 rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
-                  yield(err)
-              end
-              after_lazy(inner_obj, owner: owner, field: field, path: path, scoped_context: context.scoped_context, owner_object: owner_object, arguments: arguments, eager: eager) do |really_inner_obj|
-                yield(really_inner_obj)
+                  err
               end
+              after_lazy(inner_obj, owner: owner, field: field, path: path, scoped_context: context.scoped_context, owner_object: owner_object, arguments: arguments, eager: eager, trace: trace, &block)
             end
 
             if eager
@@ -451,7 +460,13 @@ module GraphQL
         end
 
         def arguments(graphql_object, arg_owner, ast_node)
-          query.arguments_for(ast_node, arg_owner, parent_object: graphql_object)
+          # Don't cache arguments if field extras are requested since extras mutate the argument data structure
+          if arg_owner.arguments_statically_coercible? && (!arg_owner.is_a?(GraphQL::Schema::Field) || arg_owner.extras.empty?)
+            query.arguments_for(ast_node, arg_owner)
+          else
+            # The arguments must be prepared in the context of the given object
+            query.arguments_for(ast_node, arg_owner, parent_object: graphql_object)
+          end
         end
 
         def write_invalid_null_in_response(path, invalid_null_error)
@@ -491,23 +506,11 @@ module GraphQL
         # at previous parts of the response.
         # This hash matches the response
         def type_at(path)
-          t = @types_at_paths
-          path.each do |part|
-            t = t[part] || (raise("Invariant: #{part.inspect} not found in #{t}"))
-          end
-          t = t[:__type]
-          t
+          @types_at_paths.fetch(path)
         end
 
         def set_type_at_path(path, type)
-          types = @types_at_paths
-          path.each do |part|
-            types = types[part] ||= {}
-          end
-          # Use this magic key so that the hash contains:
-          # - string keys for nested fields
-          # - :__type for the object type of a selection
-          types[:__type] ||= type
+          @types_at_paths[path] = type
           nil
         end
 
@@ -537,7 +540,7 @@ module GraphQL
 
         def resolve_type(type, value, path)
           trace_payload = { context: context, type: type, object: value, path: path }
-          resolved_type = query.trace("resolve_type", trace_payload) do
+          resolved_type, resolved_value = query.trace("resolve_type", trace_payload) do
             query.resolve_type(type, value)
           end
 
@@ -548,7 +551,7 @@ module GraphQL
               end
             end
           else
-            resolved_type
+            [resolved_type, resolved_value]
           end
         end
 

data/lib/graphql/execution/lookahead.rb

@@ -55,7 +55,9 @@ module GraphQL
           @arguments
         else
           @arguments = if @field
-            @query.arguments_for(@ast_nodes.first, @field)
+            @query.schema.after_lazy(@query.arguments_for(@ast_nodes.first, @field)) do |args|
+              args.is_a?(Execution::Interpreter::Arguments) ? args.keyword_arguments : args
+            end
           else
             nil
           end

data/lib/graphql/internal_representation/scope.rb

@@ -66,11 +66,11 @@ module GraphQL
       # Call the block for each type in `self`.
       # This uses the simplest possible expression of `self`,
       # so if this scope is defined by an abstract type, it gets yielded.
-      def each
+      def each(&block)
         if @abstract_type
           yield(@type)
         else
-          @types.each { |t| yield(t) }
+          @types.each(&block)
         end
       end
 

data/lib/graphql/internal_representation/visit.rb

@@ -23,11 +23,11 @@ module GraphQL
 
       # Traverse a node in a rewritten query tree,
       # visiting the node itself and each of its typed children.
-      def each_node(node)
+      def each_node(node, &block)
         yield(node)
         node.typed_children.each do |obj_type, children|
           children.each do |name, node|
-            each_node(node) { |n| yield(n) }
+            each_node(node, &block)
           end
         end
       end