graphql 1.10.2 → 1.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a34f1cf03ff3b9db3635c9380be3bfc1dde1c36827afe3e39526fac966220991
-  data.tar.gz: e1202b5ec6a0fc79e4ce8d3b953959ec834b47f569b2e2bccc78abfe5b3227d5
+  metadata.gz: fe0e22214a3e9457d34ff1cd9aa506abec6431d6dad443f87d297a8c88bbfb0d
+  data.tar.gz: 194b1ce3ee16b95b880f7488ea7cfa44a977330f7d218d591a6a2d076aed049e
 SHA512:
-  metadata.gz: df151b5b38a43ae0da73d4c7b23eb0651c70417c822394d40b4e1a19cea06d681e7072d63a9c7888d3c415de575fffc3f3b6ecad13dc639f7cbac291781510e7
-  data.tar.gz: 7c5a7c2522fb30d951b8f43ea7c182e0cb1ab9793a6b1697537cd9128ae72765bbafdb895cd7c8931319f639f61037e98d391ce84f48f8136c3b0c9ac62fab03
+  metadata.gz: 58a7a7149f8f36e42689aa746ecc18d2567ca8fde473dd152c785f26207d750cbc8f1e770d59fa4fdca87cb9d05948afa89a783419fc2accaeacdd29e5a36ab9
+  data.tar.gz: 59baab3d2e8c20050ac3378b5f9749e4989e28086609717c406134e299bf7804ff0207c8d67646e36ac7fd572db1cf6b8b6cca62a88e0133cfd7f5071ab0c046

data/lib/generators/graphql/core.rb

@@ -48,11 +48,19 @@ module Graphql
           if options[:schema]
             options[:schema]
           else
-            require File.expand_path("config/application", destination_root)
-            "#{Rails.application.class.parent_name}Schema"
+            "#{parent_name}Schema"
           end
         end
       end
+
+      def parent_name
+        require File.expand_path("config/application", destination_root)
+        if Rails.application.class.respond_to?(:module_parent_name)
+          Rails.application.class.module_parent_name
+        else
+          Rails.application.class.parent_name
+        end
+      end
     end
   end
 end

data/lib/generators/graphql/templates/schema.erb

@@ -3,6 +3,7 @@ class <%= schema_name %> < GraphQL::Schema
 
   # Opt in to the new runtime (default in future graphql-ruby versions)
   use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
 
   # Add built-in connections for pagination
   use GraphQL::Pagination::Connections

data/lib/graphql/define/defined_object_proxy.rb

@@ -34,7 +34,6 @@ module GraphQL
       end
 
       # Lookup a function from the dictionary and call it if it's found.
-      ruby2_keywords
       def method_missing(name, *args, &block)
         definition = @dictionary[name]
         if definition
@@ -44,6 +43,7 @@ module GraphQL
           raise NoDefinitionError, msg, caller
         end
       end
+      ruby2_keywords :method_missing
 
       def respond_to_missing?(name, include_private = false)
         @dictionary[name] || super

data/lib/graphql/define/instance_definable.rb

@@ -200,10 +200,10 @@ module GraphQL
         # Even though we're just using the first value here,
         # We have to add a splat here to use `ruby2_keywords`,
         # so that it will accept a `[{}]` input from the caller.
-        ruby2_keywords
         def call(defn, *value)
           defn.public_send(@attr_assign_method, value.first)
         end
+        ruby2_keywords :call
       end
     end
   end

data/lib/graphql/execution/interpreter.rb

@@ -3,6 +3,7 @@ require "graphql/execution/interpreter/execution_errors"
 require "graphql/execution/interpreter/hash_response"
 require "graphql/execution/interpreter/runtime"
 require "graphql/execution/interpreter/resolve"
+require "graphql/execution/interpreter/handles_raw_value"
 
 module GraphQL
   module Execution
@@ -22,6 +23,8 @@ module GraphQL
         schema_class.query_execution_strategy(GraphQL::Execution::Interpreter)
         schema_class.mutation_execution_strategy(GraphQL::Execution::Interpreter)
         schema_class.subscription_execution_strategy(GraphQL::Execution::Interpreter)
+
+        GraphQL::Schema::Object.include(HandlesRawValue)
       end
 
       def self.begin_multiplex(multiplex)

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      # Wrapper for raw values
+      class RawValue
+        def initialize(obj = nil)
+          @object = obj
+        end
+
+        def resolve
+          @object
+        end
+      end
+
+      # Allows to return "raw" value from the resolver
+      module HandlesRawValue
+        def raw_value(obj)
+          RawValue.new(obj)
+        end
+      end
+    end
+  end
+end

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

@@ -146,7 +146,6 @@ module GraphQL
                 raise "Invariant: no field for #{owner_type}.#{field_name}"
               end
             end
-
             return_type = field_defn.type
 
             next_path = path.dup
@@ -222,7 +221,10 @@ module GraphQL
               end
               after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
-                if HALT != continue_value
+                if RawValue === continue_value
+                  # Write raw value directly to the response without resolving nested objects
+                  write_in_response(next_path, continue_value.resolve)
+                elsif HALT != continue_value
                   continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
                 end
               end
@@ -336,8 +338,7 @@ module GraphQL
               set_type_at_path(next_path, inner_type)
               # This will update `response_list` with the lazy
               after_lazy(inner_value, owner: inner_type, path: next_path, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
-                # reset `is_non_null` here and below, because the inner type will have its own nullability constraint
-                continue_value = continue_value(next_path, inner_inner_value, field, false, ast_node)
+                continue_value = continue_value(next_path, inner_inner_value, field, inner_type.non_null?, ast_node)
                 if HALT != continue_value
                   continue_field(next_path, continue_value, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
                 end
@@ -435,133 +436,48 @@ module GraphQL
           end
         end
 
-        def each_argument_pair(ast_args_or_hash)
-          case ast_args_or_hash
-          when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
-            ast_args_or_hash.arguments.each do |arg|
-              yield(arg.name, arg.value)
-            end
-          when Hash
-            ast_args_or_hash.each do |key, value|
-              normalized_name = GraphQL::Schema::Member::BuildType.camelize(key.to_s)
-              yield(normalized_name, value)
-            end
-          else
-            raise "Invariant, unexpected #{ast_args_or_hash.inspect}"
-          end
-        end
+        NO_VALUE_GIVEN = Object.new
 
-        def arguments(graphql_object, arg_owner, ast_node_or_hash)
-          kwarg_arguments = {}
-          arg_defns = arg_owner.arguments
-          each_argument_pair(ast_node_or_hash) do |arg_name, arg_value|
-            arg_defn = arg_defns[arg_name]
-            # Need to distinguish between client-provided `nil`
-            # and nothing-at-all
-            is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_value, already_arguments: false)
-            if is_present
-              # This doesn't apply to directives, which are legacy
-              # Can remove this when Skip and Include use classes or something.
-              if graphql_object
-                value = arg_defn.prepare_value(graphql_object, value)
-              end
-              kwarg_arguments[arg_defn.keyword] = value
-            end
-          end
-          arg_defns.each do |name, arg_defn|
-            if arg_defn.default_value? && !kwarg_arguments.key?(arg_defn.keyword)
-              _is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_defn.default_value, already_arguments: false)
-              kwarg_arguments[arg_defn.keyword] = value
-            end
-          end
-          kwarg_arguments
-        end
-
-        # TODO CAN THIS USE `.coerce_input` ???
-
-        # Get a Ruby-ready value from a client query.
-        # @param graphql_object [Object] The owner of the field whose argument this is
-        # @param arg_type [Class, GraphQL::Schema::NonNull, GraphQL::Schema::List]
-        # @param ast_value [GraphQL::Language::Nodes::VariableIdentifier, String, Integer, Float, Boolean]
-        # @param already_arguments [Boolean] if true, don't re-coerce these with `arguments(...)`
-        # @return [Array(is_present, value)]
-        def arg_to_value(graphql_object, arg_type, ast_value, already_arguments:)
-          if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-            # If it's not here, it will get added later
-            if query.variables.key?(ast_value.name)
-              variable_value = query.variables[ast_value.name]
-              arg_to_value(graphql_object, arg_type, variable_value, already_arguments: true)
-            else
-              return false, nil
+        def prepare_args_hash(ast_arg_or_hash_or_value)
+          case ast_arg_or_hash_or_value
+          when Hash
+            args_hash = {}
+            ast_arg_or_hash_or_value.each do |k, v|
+              args_hash[k] = prepare_args_hash(v)
             end
-          elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
-            return true, nil
-          elsif arg_type.is_a?(GraphQL::Schema::NonNull)
-            arg_to_value(graphql_object, arg_type.of_type, ast_value, already_arguments: already_arguments)
-          elsif arg_type.is_a?(GraphQL::Schema::List)
-            if ast_value.nil?
-              return true, nil
-            else
-              # Treat a single value like a list
-              arg_value = Array(ast_value)
-              list = []
-              arg_value.map do |inner_v|
-                _present, value = arg_to_value(graphql_object, arg_type.of_type, inner_v, already_arguments: already_arguments)
-                list << value
+            args_hash
+          when Array
+            ast_arg_or_hash_or_value.map { |v| prepare_args_hash(v) }
+          when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
+            args_hash = {}
+            ast_arg_or_hash_or_value.arguments.each do |arg|
+              v = prepare_args_hash(arg.value)
+              if v != NO_VALUE_GIVEN
+                args_hash[arg.name] = v
               end
-              return true, list
             end
-          elsif arg_type.is_a?(Class) && arg_type < GraphQL::Schema::InputObject
-            if already_arguments
-              # This came from a variable, already prepared.
-              # But replace `nil` with `{}` like we would for `arg_type`
-              if ast_value.nil?
-                return false, nil
-              else
-                return true, ast_value
-              end
+            args_hash
+          when GraphQL::Language::Nodes::VariableIdentifier
+            if query.variables.key?(ast_arg_or_hash_or_value.name)
+              variable_value = query.variables[ast_arg_or_hash_or_value.name]
+              prepare_args_hash(variable_value)
             else
-              # For these, `prepare` is applied during `#initialize`.
-              # Pass `nil` so it will be skipped in `#arguments`.
-              # What a mess.
-              args = arguments(nil, arg_type, ast_value)
-            end
-
-            input_obj = query.with_error_handling do
-              # We're not tracking defaults_used, but for our purposes
-              # we compare the value to the default value.
-              arg_type.new(ruby_kwargs: args, context: context, defaults_used: nil)
+              NO_VALUE_GIVEN
             end
-            return true, input_obj
+          when GraphQL::Language::Nodes::Enum
+            ast_arg_or_hash_or_value.name
+          when GraphQL::Language::Nodes::NullValue
+            nil
           else
-            flat_value = if already_arguments
-              # It was coerced by variable handling
-              ast_value
-            else
-              v = flatten_ast_value(ast_value)
-              arg_type.coerce_input(v, context)
-            end
-            return true, flat_value
+            ast_arg_or_hash_or_value
           end
         end
 
-        def flatten_ast_value(v)
-          case v
-          when GraphQL::Language::Nodes::Enum
-            v.name
-          when GraphQL::Language::Nodes::InputObject
-            h = {}
-            v.arguments.each do |arg|
-              h[arg.name] = flatten_ast_value(arg.value)
-            end
-            h
-          when Array
-            v.map { |v2| flatten_ast_value(v2) }
-          when GraphQL::Language::Nodes::VariableIdentifier
-            flatten_ast_value(query.variables[v.name])
-          else
-            v
-          end
+        def arguments(graphql_object, arg_owner, ast_node_or_hash)
+          # First, normalize all AST or Ruby values to a plain Ruby hash
+          args_hash = prepare_args_hash(ast_node_or_hash)
+          # Then call into the schema to coerce those incoming values
+          arg_owner.coerce_arguments(graphql_object, args_hash, context)
         end
 
         def write_invalid_null_in_response(path, invalid_null_error)

data/lib/graphql/field.rb

@@ -154,7 +154,7 @@ module GraphQL
     end
 
     def name=(new_name)
-      old_name = @name
+      old_name = defined?(@name) ? @name : nil
       @name = new_name
 
       if old_name != new_name && @resolve_proc.is_a?(Field::Resolve::NameResolve)

data/lib/graphql/language/nodes.rb

@@ -65,9 +65,8 @@ module GraphQL
           @query_string = nil
         end
 
-        # @return [Symbol] the method to call on {Language::Visitor} for this node
-        def visit_method
-          raise GraphQL::RequiredImplementationMissingError, "#{self.class.name}#visit_method shold return a symbol"
+        def children_method_name
+          self.class.children_method_name
         end
 
         def position
@@ -147,9 +146,10 @@ module GraphQL
                 :on_#{name_underscored}
               end
 
-              def children_method_name
-                :#{name_underscored}s
+              class << self
+                attr_accessor :children_method_name
               end
+              self.children_method_name = :#{name_underscored}s
             RUBY
           end
 
@@ -161,7 +161,7 @@ module GraphQL
           # - Add a persistent update method to add a child
           # - Generate a `#children` method
           def children_methods(children_of_type)
-            if @children_methods
+            if defined?(@children_methods)
               raise "Can't re-call .children_methods for #{self} (already have: #{@children_methods})"
             else
               @children_methods = children_of_type
@@ -204,7 +204,11 @@ module GraphQL
             end
 
             if defined?(@scalar_methods)
-              generate_initialize_node
+              if !method_defined?(:initialize_node)
+                generate_initialize_node
+              else
+                # This method was defined manually
+              end
             else
               raise "Can't generate_initialize_node because scalar_methods wasn't called; call it before children_methods"
             end
@@ -214,7 +218,7 @@ module GraphQL
           # - Add reader methods
           # - Add a `#scalars` method
           def scalar_methods(*method_names)
-            if @scalar_methods
+            if defined?(@scalar_methods)
               raise "Can't re-call .scalar_methods for #{self} (already have: #{@scalar_methods})"
             else
               @scalar_methods = method_names
@@ -373,19 +377,11 @@ module GraphQL
         end
 
         # Override this because default is `:fields`
-        def children_method_name
-          :selections
-        end
+        self.children_method_name = :selections
       end
 
       # A reusable fragment, defined at document-level.
       class FragmentDefinition < AbstractNode
-        scalar_methods :name, :type
-        children_methods({
-          selections: GraphQL::Language::Nodes::Field,
-          directives: GraphQL::Language::Nodes::Directive,
-        })
-
         # @!attribute name
         #   @return [String] the identifier for this fragment, which may be applied with `...#{name}`
 
@@ -398,9 +394,13 @@ module GraphQL
           @selections = selections
         end
 
-        def children_method_name
-          :definitions
-        end
+        scalar_methods :name, :type
+        children_methods({
+          selections: GraphQL::Language::Nodes::Field,
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+
+        self.children_method_name = :definitions
       end
 
       # Application of a named fragment in a selection
@@ -408,9 +408,7 @@ module GraphQL
         scalar_methods :name
         children_methods(directives: GraphQL::Language::Nodes::Directive)
 
-        def children_method_name
-          :selections
-        end
+        self.children_method_name = :selections
 
         # @!attribute name
         #   @return [String] The identifier of the fragment to apply, corresponds with {FragmentDefinition#name}
@@ -424,9 +422,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
         })
 
-        def children_method_name
-          :selections
-        end
+        self.children_method_name = :selections
 
         # @!attribute type
         #   @return [String, nil] Name of the type this fragment applies to, or `nil` if this fragment applies to any type
@@ -449,9 +445,7 @@ module GraphQL
           end
         end
 
-        def children_method_name
-          :value
-        end
+        self.children_method_name = :value
 
         private
 
@@ -519,9 +513,7 @@ module GraphQL
         # @!attribute name
         #   @return [String, nil] The name for this operation, or `nil` if unnamed
 
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       # A type name, used for variable definitions
@@ -538,9 +530,7 @@ module GraphQL
         children_methods({
           directives: GraphQL::Language::Nodes::Directive,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class SchemaExtension < AbstractNode
@@ -548,9 +538,7 @@ module GraphQL
         children_methods({
           directives: GraphQL::Language::Nodes::Directive,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class ScalarTypeDefinition < AbstractNode
@@ -560,9 +548,7 @@ module GraphQL
         children_methods({
           directives: GraphQL::Language::Nodes::Directive,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class ScalarTypeExtension < AbstractNode
@@ -570,9 +556,7 @@ module GraphQL
         children_methods({
           directives: GraphQL::Language::Nodes::Directive,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class InputValueDefinition < AbstractNode
@@ -582,9 +566,7 @@ module GraphQL
         children_methods({
           directives: GraphQL::Language::Nodes::Directive,
         })
-        def children_method_name
-          :fields
-        end
+        self.children_method_name = :fields
       end
 
       class FieldDefinition < AbstractNode
@@ -595,9 +577,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           arguments: GraphQL::Language::Nodes::InputValueDefinition,
         })
-        def children_method_name
-          :fields
-        end
+        self.children_method_name = :fields
 
         # this is so that `children_method_name` of `InputValueDefinition` works properly
         # with `#replace_child`
@@ -618,9 +598,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::FieldDefinition,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class ObjectTypeExtension < AbstractNode
@@ -629,9 +607,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::FieldDefinition,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class InterfaceTypeDefinition < AbstractNode
@@ -642,9 +618,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::FieldDefinition,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class InterfaceTypeExtension < AbstractNode
@@ -653,9 +627,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::FieldDefinition,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class UnionTypeDefinition < AbstractNode
@@ -665,9 +637,7 @@ module GraphQL
         children_methods({
           directives: GraphQL::Language::Nodes::Directive,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class UnionTypeExtension < AbstractNode
@@ -676,9 +646,7 @@ module GraphQL
         children_methods({
           directives: GraphQL::Language::Nodes::Directive,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class EnumValueDefinition < AbstractNode
@@ -688,9 +656,7 @@ module GraphQL
         children_methods({
           directives: GraphQL::Language::Nodes::Directive,
         })
-        def children_method_name
-          :values
-        end
+        self.children_method_name = :values
       end
 
       class EnumTypeDefinition < AbstractNode
@@ -701,9 +667,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           values: GraphQL::Language::Nodes::EnumValueDefinition,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class EnumTypeExtension < AbstractNode
@@ -712,9 +676,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           values: GraphQL::Language::Nodes::EnumValueDefinition,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class InputObjectTypeDefinition < AbstractNode
@@ -725,9 +687,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::InputValueDefinition,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
 
       class InputObjectTypeExtension < AbstractNode
@@ -736,9 +696,7 @@ module GraphQL
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::InputValueDefinition,
         })
-        def children_method_name
-          :definitions
-        end
+        self.children_method_name = :definitions
       end
     end
   end