graphql 2.0.32 → 2.5.22

data/lib/graphql/schema/addition.rb

@@ -12,7 +12,7 @@ module GraphQL
         @possible_types = {}
         @types = {}
         @union_memberships = {}
-        @references = Hash.new { |h, k| h[k] = [] }
+        @references = Hash.new { |h, k| h[k] = Set.new }
         @arguments_with_default_values = []
         add_type_and_traverse(new_types)
       end
@@ -20,7 +20,7 @@ module GraphQL
       private
 
       def references_to(thing, from:)
-        @references[thing] << from
+        @references[thing].add(from)
       end
 
       def get_type(name)
@@ -40,7 +40,7 @@ module GraphQL
       end
 
       def add_directives_from(owner)
-        if (dir_instances = owner.directives).any?
+        if !(dir_instances = owner.directives).empty?
           dirs = dir_instances.map(&:class)
           @directives.merge(dirs)
           add_type_and_traverse(dirs)
@@ -95,7 +95,7 @@ module GraphQL
             # It's a union with possible_types
             # Replace the item by class name
             owner.assign_type_membership_object_type(type)
-            @possible_types[owner.graphql_name] = owner.possible_types
+            @possible_types[owner] = owner.possible_types
           elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
             new_interfaces = []
             owner.interfaces.each do |int_t|
@@ -110,7 +110,7 @@ module GraphQL
             end
             owner.implements(*new_interfaces)
             new_interfaces.each do |int|
-              pt = @possible_types[int.graphql_name] ||= []
+              pt = @possible_types[int] ||= []
               if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
@@ -126,6 +126,7 @@ module GraphQL
           @types[type.graphql_name] = type
         when GraphQL::Schema::Field, GraphQL::Schema::Argument
           orig_type = owner.type
+          unwrapped_t = type
           # Apply list/non-null wrapper as needed
           if orig_type.respond_to?(:of_type)
             transforms = []
@@ -142,6 +143,7 @@ module GraphQL
             transforms.reverse_each { |t| type = type.public_send(t) }
           end
           owner.type = type
+          references_to(unwrapped_t, from: owner)
         else
           raise "Unexpected update: #{owner.inspect} #{type.inspect}"
         end
@@ -164,7 +166,9 @@ module GraphQL
           @directives << type
           type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
-            references_to(arg_type, from: arg)
+            if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+              references_to(arg_type, from: arg)
+            end
             path.push(arg.graphql_name)
             add_type(arg_type, owner: arg, late_types: late_types, path: path)
             path.pop
@@ -185,16 +189,21 @@ module GraphQL
           add_directives_from(type)
           if type.kind.fields?
             type.all_field_definitions.each do |field|
+              field.ensure_loaded
               name = field.graphql_name
               field_type = field.type.unwrap
-              references_to(field_type, from: field)
+              if !field_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(field_type, from: field)
+              end
               path.push(name)
               add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
-                references_to(arg_type, from: arg)
+                if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                  references_to(arg_type, from: arg)
+                end
                 path.push(arg.graphql_name)
                 add_type(arg_type, owner: arg, late_types: late_types, path: path)
                 path.pop
@@ -209,7 +218,9 @@ module GraphQL
             type.all_argument_definitions.each do |arg|
               add_directives_from(arg)
               arg_type = arg.type.unwrap
-              references_to(arg_type, from: arg)
+              if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(arg_type, from: arg)
+              end
               path.push(arg.graphql_name)
               add_type(arg_type, owner: arg, late_types: late_types, path: path)
               path.pop
@@ -219,7 +230,7 @@ module GraphQL
             end
           end
           if type.kind.union?
-            @possible_types[type.graphql_name] = type.all_possible_types
+            @possible_types[type] = type.all_possible_types
             path.push("possible_types")
             type.all_possible_types.each do |t|
               add_type(t, owner: type, late_types: late_types, path: path)
@@ -234,7 +245,7 @@ module GraphQL
             path.pop
           end
           if type.kind.object?
-            possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
+            possible_types_for_this_name = @possible_types[type] ||= []
             possible_types_for_this_name << type
           end
 
@@ -246,8 +257,10 @@ module GraphQL
                 interface_type = interface_type_membership.abstract_type
                 # We can get these now; we'll have to get late-bound types later
                 if interface_type.is_a?(Module) && type.is_a?(Class)
-                  implementers = @possible_types[interface_type.graphql_name] ||= []
-                  implementers << type
+                  implementers = @possible_types[interface_type] ||= []
+                  if !implementers.include?(type)
+                    implementers << type
+                  end
                 end
               when String, Schema::LateBoundType
                 interface_type = interface_type_membership

data/lib/graphql/schema/always_visible.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 module GraphQL
   class Schema
-    class AlwaysVisible
+    module AlwaysVisible
       def self.use(schema, **opts)
-        schema.warden_class = GraphQL::Schema::Warden::NullWarden
+        schema.use(GraphQL::Schema::Visibility, profiles: { nil => {} })
+        schema.extend(self)
+      end
+
+      def visible?(_member, _context)
+        true
       end
     end
   end

data/lib/graphql/schema/argument.rb

@@ -4,6 +4,7 @@ module GraphQL
     class Argument
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
+      include GraphQL::Schema::Member::HasAuthorization
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
       include GraphQL::Schema::Member::HasValidators
@@ -39,9 +40,14 @@ module GraphQL
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
+      # @param type [Class, Array<Class>] Input type; positional argument also accepted
+      # @param name [Symbol] positional argument also accepted        # @param loads [Class, Array<Class>] A GraphQL type to load for the given ID when one is present
+      # @param definition_block [Proc] Called with the newly-created {Argument}
+      # @param owner [Class] Private, used by GraphQL-Ruby during schema definition
       # @param required [Boolean, :nullable] if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`.
       # @param description [String]
       # @param default_value [Object]
+      # @param loads [Class, Array<Class>] A GraphQL type to load for the given ID when one is present
       # @param as [Symbol] Override the keyword name when passed to a method
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
@@ -50,12 +56,15 @@ module GraphQL
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
       # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
+      # @param comment [String] Private, used by GraphQL-Ruby when parsing GraphQL schema files
+      # @param ast_node [GraphQL::Language::Nodes::InputValueDefinition] Private, used by GraphQL-Ruby when parsing schema files
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, comment: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         NameValidator.validate!(@name)
         @type_expr = type_expr || type
         @description = desc || description
+        @comment = comment
         @null = required != true
         @default_value = default_value
         if replace_null_with_default
@@ -127,6 +136,17 @@ module GraphQL
         end
       end
 
+      attr_writer :comment
+
+      # @return [String] Comment for this argument
+      def comment(text = nil)
+        if text
+          @comment = text
+        else
+          @comment
+        end
+      end
+
       # @return [String] Deprecation reason for this argument
       def deprecation_reason(text = nil)
         if text
@@ -145,6 +165,10 @@ module GraphQL
         true
       end
 
+      def authorizes?(_context)
+        self.method(:authorized?).owner != GraphQL::Schema::Argument
+      end
+
       def authorized?(obj, value, ctx)
         authorized_as_type?(obj, value, ctx, as_type: type)
       end
@@ -200,12 +224,17 @@ module GraphQL
         @statically_coercible = !requires_parent_object
       end
 
+      def freeze
+        statically_coercible?
+        super
+      end
+
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private
       def prepare_value(obj, value, context: nil)
-        if value.is_a?(GraphQL::Schema::InputObject)
-          value = value.prepare
+        if type.unwrap.kind.input_object?
+          value = recursively_prepare_input_object(value, type, context)
         end
 
         Schema::Validator.validate!(validators, obj, context, value)
@@ -219,8 +248,13 @@ module GraphQL
             #
             # This will have to be called later, when the runtime object _is_ available.
             value
-          else
+          elsif obj.respond_to?(@prepare)
             obj.public_send(@prepare, value)
+          elsif owner.respond_to?(@prepare)
+            owner.public_send(@prepare, value, context || obj.context)
+          else
+            raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}. "\
+              "Could not find prepare method #{@prepare} on #{obj.class} or #{owner}."
           end
         elsif @prepare.respond_to?(:call)
           @prepare.call(value, context || obj.context)
@@ -283,6 +317,7 @@ module GraphQL
             # TODO code smell to access such a deeply-nested constant in a distant module
             argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
               value: resolved_loaded_value,
+              original_value: resolved_coerced_value,
               definition: self,
               default_used: default_used,
             )
@@ -304,10 +339,15 @@ module GraphQL
           context.query.after_lazy(custom_loaded_value) do |custom_value|
             if loads
               if type.list?
-                loaded_values = custom_value.each_with_index.map { |custom_val, idx|
-                  id = coerced_value[idx]
-                  load_method_owner.authorize_application_object(self, id, context, custom_val)
-                }
+                loaded_values = []
+                context.dataloader.run_isolated do
+                  custom_value.each_with_index.map { |custom_val, idx|
+                    id = coerced_value[idx]
+                    context.dataloader.append_job do
+                      loaded_values[idx] = load_method_owner.authorize_application_object(self, id, context, custom_val)
+                    end
+                  }
+                end
                 context.schema.after_any_lazies(loaded_values, &:itself)
               else
                 load_method_owner.authorize_application_object(self, coerced_value, context, custom_loaded_value)
@@ -318,7 +358,16 @@ module GraphQL
           end
         elsif loads
           if type.list?
-            loaded_values = coerced_value.map { |val| load_method_owner.load_and_authorize_application_object(self, val, context) }
+            loaded_values = []
+            # We want to run these list items all together,
+            # but we also need to wait for the result so we can return it :S
+            context.dataloader.run_isolated do
+              coerced_value.each_with_index { |val, idx|
+                context.dataloader.append_job do
+                  loaded_values[idx] = load_method_owner.load_and_authorize_application_object(self, val, context)
+                end
+              }
+            end
             context.schema.after_any_lazies(loaded_values, &:itself)
           else
             load_method_owner.load_and_authorize_application_object(self, coerced_value, context)
@@ -330,6 +379,7 @@ module GraphQL
 
       # @api private
       def validate_default_value
+        return unless default_value?
         coerced_default_value = begin
           # This is weird, but we should accept single-item default values for list-type arguments.
           # If we used `coerce_isolated_input` below, it would do this for us, but it's not really
@@ -365,6 +415,22 @@ module GraphQL
 
       private
 
+      def recursively_prepare_input_object(value, type, context)
+        if type.non_null?
+          type = type.of_type
+        end
+
+        if type.list? && !value.nil?
+          inner_type = type.of_type
+          value.map { |v| recursively_prepare_input_object(v, inner_type, context) }
+        elsif value.is_a?(GraphQL::Schema::InputObject)
+          value.validate_for(context)
+          value.prepare
+        else
+          value
+        end
+      end
+
       def validate_input_type(input_type)
         if input_type.is_a?(String) || input_type.is_a?(GraphQL::Schema::LateBoundType)
           # Do nothing; assume this will be validated later

data/lib/graphql/schema/base_64_encoder.rb

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
-
-require 'graphql/schema/base_64_bp'
-
+require "base64"
 module GraphQL
   class Schema
     # @api private
     module Base64Encoder
       def self.encode(unencoded_text, nonce: false)
-        Base64Bp.urlsafe_encode64(unencoded_text, padding: false)
+        Base64.urlsafe_encode64(unencoded_text, padding: false)
       end
 
       def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
-        Base64Bp.urlsafe_decode64(encoded_text)
+        Base64.urlsafe_decode64(encoded_text)
       rescue ArgumentError
         raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
       end