graphql 1.9.0 → 2.1.1

data/lib/graphql/schema/addition.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Addition
+      attr_reader :directives, :possible_types, :types, :union_memberships, :references, :arguments_with_default_values
+
+      def initialize(schema:, own_types:, new_types:)
+        @schema = schema
+        @own_types = own_types
+        @directives = Set.new
+        @possible_types = {}
+        @types = {}
+        @union_memberships = {}
+        @references = Hash.new { |h, k| h[k] = [] }
+        @arguments_with_default_values = []
+        add_type_and_traverse(new_types)
+      end
+
+      private
+
+      def references_to(thing, from:)
+        @references[thing] << from
+      end
+
+      def get_type(name)
+        local_type = @types[name]
+        # This isn't really sophisticated, but
+        # I think it's good enough to support the current usage of LateBoundTypes
+        if local_type.is_a?(Array)
+          local_type = local_type.first
+        end
+        local_type || @schema.get_type(name)
+      end
+
+      # Lookup using `own_types` here because it's ok to override
+      # inherited types by name
+      def get_local_type(name)
+        @types[name] || @own_types[name]
+      end
+
+      def add_directives_from(owner)
+        if (dir_instances = owner.directives).any?
+          dirs = dir_instances.map(&:class)
+          @directives.merge(dirs)
+          add_type_and_traverse(dirs)
+        end
+      end
+
+      def add_type_and_traverse(new_types)
+        late_types = []
+        path = []
+        new_types.each do |t|
+          path.push(t.graphql_name)
+          add_type(t, owner: nil, late_types: late_types, path: path)
+          path.pop
+        end
+        missed_late_types = 0
+        while (late_type_vals = late_types.shift)
+          type_owner, lt = late_type_vals
+          if lt.is_a?(String)
+            type = Member::BuildType.constantize(lt)
+            # Reset the counter, since we might succeed next go-round
+            missed_late_types = 0
+            update_type_owner(type_owner, type)
+            add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+          elsif lt.is_a?(LateBoundType)
+            if (type = get_type(lt.name))
+              # Reset the counter, since we might succeed next go-round
+              missed_late_types = 0
+              update_type_owner(type_owner, type)
+              add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+            else
+              missed_late_types += 1
+              # Add it back to the list, maybe we'll be able to resolve it later.
+              late_types << [type_owner, lt]
+              if missed_late_types == late_types.size
+                # We've looked at all of them and haven't resolved one.
+                raise UnresolvedLateBoundTypeError.new(type: lt)
+              else
+                # Try the next one
+              end
+            end
+          else
+            raise ArgumentError, "Unexpected late type: #{lt.inspect}"
+          end
+        end
+        nil
+      end
+
+      def update_type_owner(owner, type)
+        case owner
+        when Module
+          if owner.kind.union?
+            # 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
+          elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
+            new_interfaces = []
+            owner.interfaces.each do |int_t|
+              if int_t.is_a?(String) && int_t == type.graphql_name
+                new_interfaces << type
+              elsif int_t.is_a?(LateBoundType) && int_t.graphql_name == type.graphql_name
+                new_interfaces << type
+              else
+                # Don't re-add proper interface definitions,
+                # they were probably already added, maybe with options.
+              end
+            end
+            owner.implements(*new_interfaces)
+            new_interfaces.each do |int|
+              pt = @possible_types[int.graphql_name] ||= []
+              if !pt.include?(owner) && owner.is_a?(Class)
+                pt << owner
+              end
+              int.interfaces.each do |indirect_int|
+                if indirect_int.is_a?(LateBoundType) && (indirect_int_type = get_type(indirect_int.graphql_name))
+                  update_type_owner(owner, indirect_int_type)
+                end
+              end
+            end
+          end
+        when nil
+          # It's a root type
+          @types[type.graphql_name] = type
+        when GraphQL::Schema::Field, GraphQL::Schema::Argument
+          orig_type = owner.type
+          # Apply list/non-null wrapper as needed
+          if orig_type.respond_to?(:of_type)
+            transforms = []
+            while (orig_type.respond_to?(:of_type))
+              if orig_type.kind.non_null?
+                transforms << :to_non_null_type
+              elsif orig_type.kind.list?
+                transforms << :to_list_type
+              else
+                raise "Invariant: :of_type isn't non-null or list"
+              end
+              orig_type = orig_type.of_type
+            end
+            transforms.reverse_each { |t| type = type.public_send(t) }
+          end
+          owner.type = type
+        else
+          raise "Unexpected update: #{owner.inspect} #{type.inspect}"
+        end
+      end
+
+      def add_type(type, owner:, late_types:, path:)
+        if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+          late_types << [owner, type]
+          return
+        end
+
+        if owner.is_a?(Class) && owner < GraphQL::Schema::Union
+          um = @union_memberships[type.graphql_name] ||= []
+          um << owner
+        end
+
+        if (prev_type = get_local_type(type.graphql_name)) && (prev_type == type || (prev_type.is_a?(Array) && prev_type.include?(type)))
+          # No need to re-visit
+        elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
+          @directives << type
+          type.all_argument_definitions.each do |arg|
+            arg_type = arg.type.unwrap
+            references_to(arg_type, from: arg)
+            path.push(arg.graphql_name)
+            add_type(arg_type, owner: arg, late_types: late_types, path: path)
+            path.pop
+            if arg.default_value?
+              @arguments_with_default_values << arg
+            end
+          end
+        else
+          prev_type = @types[type.graphql_name]
+          if prev_type.nil?
+            @types[type.graphql_name] = type
+          elsif prev_type.is_a?(Array)
+            prev_type << type
+          else
+            @types[type.graphql_name] = [prev_type, type]
+          end
+
+          add_directives_from(type)
+          if type.kind.fields?
+            type.all_field_definitions.each do |field|
+              name = field.graphql_name
+              field_type = field.type.unwrap
+              references_to(field_type, from: field)
+              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)
+                path.push(arg.graphql_name)
+                add_type(arg_type, owner: arg, late_types: late_types, path: path)
+                path.pop
+                if arg.default_value?
+                  @arguments_with_default_values << arg
+                end
+              end
+              path.pop
+            end
+          end
+          if type.kind.input_object?
+            type.all_argument_definitions.each do |arg|
+              add_directives_from(arg)
+              arg_type = arg.type.unwrap
+              references_to(arg_type, from: arg)
+              path.push(arg.graphql_name)
+              add_type(arg_type, owner: arg, late_types: late_types, path: path)
+              path.pop
+              if arg.default_value?
+                @arguments_with_default_values << arg
+              end
+            end
+          end
+          if type.kind.union?
+            @possible_types[type.graphql_name] = 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)
+            end
+            path.pop
+          end
+          if type.kind.interface?
+            path.push("orphan_types")
+            type.orphan_types.each do |t|
+              add_type(t, owner: type, late_types: late_types, path: path)
+            end
+            path.pop
+          end
+          if type.kind.object?
+            possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
+            possible_types_for_this_name << type
+          end
+
+          if type.kind.object? || type.kind.interface?
+            path.push("implements")
+            type.interface_type_memberships.each do |interface_type_membership|
+              case interface_type_membership
+              when Schema::TypeMembership
+                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
+                end
+              when String, Schema::LateBoundType
+                interface_type = interface_type_membership
+              else
+                raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
+              end
+              add_type(interface_type, owner: type, late_types: late_types, path: path)
+            end
+            path.pop
+          end
+
+          if type.kind.enum?
+            type.all_enum_value_definitions.each do |value_definition|
+              add_directives_from(value_definition)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/always_visible.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class AlwaysVisible
+      def self.use(schema, **opts)
+        schema.warden_class = GraphQL::Schema::Warden::NullWarden
+      end
+    end
+  end
+end

data/lib/graphql/schema/argument.rb

@@ -2,11 +2,12 @@
 module GraphQL
   class Schema
     class Argument
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
-
-      NO_DEFAULT = :__no_default__
+      include GraphQL::Schema::Member::HasAstNode
+      include GraphQL::Schema::Member::HasDirectives
+      include GraphQL::Schema::Member::HasDeprecationReason
+      include GraphQL::Schema::Member::HasValidators
+      include GraphQL::EmptyObjects
 
       # @return [String] the GraphQL name for this argument, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -15,32 +16,76 @@ module GraphQL
       # @return [GraphQL::Schema::Field, Class] The field or input object this argument belongs to
       attr_reader :owner
 
-      # @return [Symbol] A method to call to transform this value before sending it to field resolution method
-      attr_reader :prepare
+      # @param new_prepare [Method, Proc]
+      # @return [Symbol] A method or proc to call to transform this value before sending it to field resolution method
+      def prepare(new_prepare = NOT_CONFIGURED)
+        if new_prepare != NOT_CONFIGURED
+          @prepare = new_prepare
+        end
+        @prepare
+      end
 
       # @return [Symbol] This argument's name in Ruby keyword arguments
       attr_reader :keyword
 
+      # @return [Class, Module, nil] If this argument should load an application object, this is the type of object to load
+      attr_reader :loads
+
+      # @return [Boolean] true if a resolver defined this argument
+      def from_resolver?
+        @from_resolver
+      end
+
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
-      # @param required [Boolean] if true, this argument is non-null; if false, this argument is nullable
+      # @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 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
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
+      # @param from_resolver [Boolean] if true, a Resolver class defined this argument
+      # @param directives [Hash{Class => Hash}]
+      # @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)
         arg_name ||= name
-        @name = camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s
+        @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
         @description = desc || description
-        @null = !required
+        @null = required != true
         @default_value = default_value
+        if replace_null_with_default
+          if !default_value?
+            raise ArgumentError, "`replace_null_with_default: true` requires a default value, please provide one with `default_value: ...`"
+          end
+          @replace_null_with_default = true
+        end
+
         @owner = owner
         @as = as
-        @keyword = as || Schema::Member::BuildType.underscore(@name).to_sym
+        @loads = loads
+        @keyword = as || (arg_name.is_a?(Symbol) ? arg_name : Schema::Member::BuildType.underscore(@name).to_sym)
         @prepare = prepare
+        @ast_node = ast_node
+        @from_resolver = from_resolver
+        self.deprecation_reason = deprecation_reason
+
+        if directives
+          directives.each do |dir_class, dir_options|
+            directive(dir_class, **dir_options)
+          end
+        end
+
+        if validates && !validates.empty?
+          self.validates(validates)
+        end
+
+        if required == :nullable
+          self.owner.validates(required: { argument: arg_name })
+        end
 
         if definition_block
           if definition_block.arity == 1
@@ -51,12 +96,26 @@ module GraphQL
         end
       end
 
+      def inspect
+        "#<#{self.class} #{path}: #{type.to_type_signature}#{description ? " @description=#{description.inspect}" : ""}>"
+      end
+
+      # @param default_value [Object] The value to use when the client doesn't provide one
       # @return [Object] the value used when the client doesn't provide a value for this argument
-      attr_reader :default_value
+      def default_value(new_default_value = NOT_CONFIGURED)
+        if new_default_value != NOT_CONFIGURED
+          @default_value = new_default_value
+        end
+        @default_value
+      end
 
       # @return [Boolean] True if this argument has a default value
       def default_value?
-        @default_value != NO_DEFAULT
+        @default_value != NOT_CONFIGURED
+      end
+
+      def replace_null_with_default?
+        @replace_null_with_default
       end
 
       attr_writer :description
@@ -70,51 +129,261 @@ module GraphQL
         end
       end
 
+      # @return [String] Deprecation reason for this argument
+      def deprecation_reason(text = nil)
+        if text
+          self.deprecation_reason = text
+        else
+          super()
+        end
+      end
+
+      def deprecation_reason=(new_reason)
+        validate_deprecated_or_optional(null: @null, deprecation_reason: new_reason)
+        super
+      end
+
       def visible?(context)
         true
       end
 
-      def accessible?(context)
-        true
+      def authorized?(obj, value, ctx)
+        authorized_as_type?(obj, value, ctx, as_type: type)
       end
 
-      def authorized?(obj, ctx)
+      def authorized_as_type?(obj, value, ctx, as_type:)
+        if value.nil?
+          return true
+        end
+
+        if as_type.kind.non_null?
+          as_type = as_type.of_type
+        end
+
+        if as_type.kind.list?
+          value.each do |v|
+            if !authorized_as_type?(obj, v, ctx, as_type: as_type.of_type)
+              return false
+            end
+          end
+        elsif as_type.kind.input_object?
+          return as_type.authorized?(obj, value, ctx)
+        end
+        # None of the early-return conditions were activated,
+        # so this is authorized.
         true
       end
 
-      def to_graphql
-        argument = GraphQL::Argument.new
-        argument.name = @name
-        argument.type = -> { type }
-        argument.description = @description
-        argument.metadata[:type_class] = self
-        argument.as = @as
-        if NO_DEFAULT != @default_value
-          argument.default_value = @default_value
+      def type=(new_type)
+        validate_input_type(new_type)
+        # This isn't true for LateBoundTypes, but we can assume those will
+        # be updated via this codepath later in schema setup.
+        if new_type.respond_to?(:non_null?)
+          validate_deprecated_or_optional(null: !new_type.non_null?, deprecation_reason: deprecation_reason)
         end
-        argument
+        @type = new_type
       end
 
       def type
-        @type ||= Member::BuildType.parse_type(@type_expr, null: @null)
-      rescue StandardError => err
-        raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+        @type ||= begin
+          parsed_type = begin
+            Member::BuildType.parse_type(@type_expr, null: @null)
+          rescue StandardError => err
+            raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+          end
+          # Use the setter method to get validations
+          self.type = parsed_type
+        end
+      end
+
+      def statically_coercible?
+        return @statically_coercible if defined?(@statically_coercible)
+        requires_parent_object = @prepare.is_a?(String) || @prepare.is_a?(Symbol) || @own_validators
+        @statically_coercible = !requires_parent_object
       end
 
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private
-      def prepare_value(obj, value)
+      def prepare_value(obj, value, context: nil)
+        if value.is_a?(GraphQL::Schema::InputObject)
+          value = value.prepare
+        end
+
+        Schema::Validator.validate!(validators, obj, context, value)
+
         if @prepare.nil?
           value
         elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)
-          obj.public_send(@prepare, value)
+          if obj.nil?
+            # The problem here is, we _used to_ prepare while building variables.
+            # But now we don't have the runtime object there.
+            #
+            # This will have to be called later, when the runtime object _is_ available.
+            value
+          else
+            obj.public_send(@prepare, value)
+          end
         elsif @prepare.respond_to?(:call)
-          @prepare.call(value, obj.context)
+          @prepare.call(value, context || obj.context)
         else
           raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
         end
       end
+
+      # @api private
+      def coerce_into_values(parent_object, values, context, argument_values)
+        arg_name = graphql_name
+        arg_key = keyword
+        default_used = false
+
+        if values.key?(arg_name)
+          value = values[arg_name]
+        elsif values.key?(arg_key)
+          value = values[arg_key]
+        elsif default_value?
+          value = default_value
+          default_used = true
+        else
+          # no value at all
+          owner.validate_directive_argument(self, nil)
+          return
+        end
+
+        if value.nil? && replace_null_with_default?
+          value = default_value
+          default_used = true
+        end
+
+        loaded_value = nil
+        coerced_value = begin
+          type.coerce_input(value, context)
+        rescue StandardError => err
+          context.schema.handle_or_reraise(context, err)
+        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.query.after_lazy(coerced_value) do |resolved_coerced_value|
+          owner.validate_directive_argument(self, resolved_coerced_value)
+          prepared_value = begin
+            prepare_value(parent_object, resolved_coerced_value, context: context)
+          rescue StandardError => err
+            context.schema.handle_or_reraise(context, err)
+          end
+
+          if loads && !from_resolver?
+            loaded_value = begin
+              load_and_authorize_value(owner, prepared_value, context)
+            rescue StandardError => err
+              context.schema.handle_or_reraise(context, err)
+            end
+          end
+
+          maybe_loaded_value = loaded_value || prepared_value
+          context.query.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
+            # 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,
+              definition: self,
+              default_used: default_used,
+            )
+          end
+        end
+      end
+
+      def load_and_authorize_value(load_method_owner, coerced_value, context)
+        if coerced_value.nil?
+          return nil
+        end
+        arg_load_method = "load_#{keyword}"
+        if load_method_owner.respond_to?(arg_load_method)
+          custom_loaded_value = if load_method_owner.is_a?(Class)
+            load_method_owner.public_send(arg_load_method, coerced_value, context)
+          else
+            load_method_owner.public_send(arg_load_method, coerced_value)
+          end
+          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)
+                }
+                context.schema.after_any_lazies(loaded_values, &:itself)
+              else
+                load_method_owner.authorize_application_object(self, coerced_value, context, custom_loaded_value)
+              end
+            else
+              custom_value
+            end
+          end
+        elsif loads
+          if type.list?
+            loaded_values = coerced_value.map { |val| load_method_owner.load_and_authorize_application_object(self, val, context) }
+            context.schema.after_any_lazies(loaded_values, &:itself)
+          else
+            load_method_owner.load_and_authorize_application_object(self, coerced_value, context)
+          end
+        else
+          coerced_value
+        end
+      end
+
+      # @api private
+      def validate_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
+          # the right thing here because we expect default values in application format (Ruby values)
+          # not GraphQL format (scalar values).
+          #
+          # But I don't think Schema::List#coerce_result should apply wrapping to single-item lists.
+          prepped_default_value = if default_value.nil?
+            nil
+          elsif (type.kind.list? || (type.kind.non_null? && type.of_type.list?)) && !default_value.respond_to?(:map)
+            [default_value]
+          else
+            default_value
+          end
+
+          type.coerce_isolated_result(prepped_default_value) unless prepped_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
+
+      private
+
+      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
+        elsif input_type.kind.non_null? || input_type.kind.list?
+          validate_input_type(input_type.unwrap)
+        elsif !input_type.kind.input?
+          raise ArgumentError, "Invalid input type for #{path}: #{input_type.graphql_name}. Must be scalar, enum, or input object, not #{input_type.kind.name}."
+        else
+          # It's an input type, we're OK
+        end
+      end
+
+      def validate_deprecated_or_optional(null:, deprecation_reason:)
+        if deprecation_reason && !null
+          raise ArgumentError, "Required arguments cannot be deprecated: #{path}."
+        end
+      end
     end
   end
 end