graphql 1.13.19 → 2.0.19

data/lib/graphql/schema/input_object.rb

@@ -2,7 +2,6 @@
 module GraphQL
   class Schema
     class InputObject < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend Forwardable
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader
@@ -13,49 +12,28 @@ module GraphQL
 
       # @return [GraphQL::Query::Context] The context for this query
       attr_reader :context
-      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
+      # @return [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:)
+      def initialize(arguments, ruby_kwargs:, context:, defaults_used:)
         @context = context
-        if ruby_kwargs
-          @ruby_style_hash = ruby_kwargs
-          @arguments = arguments
-        else
-          @arguments = self.class.arguments_class.new(arguments, context: context, defaults_used: defaults_used)
-          # Symbolized, underscored hash:
-          @ruby_style_hash = @arguments.to_kwargs
-        end
+        @ruby_style_hash = ruby_kwargs
+        @arguments = arguments
         # Apply prepares, not great to have it duplicated here.
-        maybe_lazies = []
         self.class.arguments(context).each_value do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
-
           if @ruby_style_hash.key?(ruby_kwargs_key)
-            loads = arg_defn.loads
-            # Resolvers do this loading themselves;
-            # With the interpreter, it's done during `coerce_arguments`
-            if loads && !arg_defn.from_resolver? && !context.interpreter?
-              value = @ruby_style_hash[ruby_kwargs_key]
-              loaded_value = arg_defn.load_and_authorize_value(self, value, context)
-              maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
-                overwrite_argument(ruby_kwargs_key, loaded_value)
-              end
-            end
-
             # Weirdly, procs are applied during coercion, but not methods.
             # Probably because these methods require a `self`.
-            if arg_defn.prepare.is_a?(Symbol) || context.nil? || !context.interpreter?
+            if arg_defn.prepare.is_a?(Symbol) || context.nil?
               prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
               overwrite_argument(ruby_kwargs_key, prepared_value)
             end
           end
         end
-
-        @maybe_lazies = maybe_lazies
       end
 
       def to_h
@@ -68,12 +46,10 @@ module GraphQL
 
       def prepare
         if @context
-          @context.schema.after_any_lazies(@maybe_lazies) do
-            object = @context[:current_object]
-            # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
-            Schema::Validator.validate!(self.class.validators, object, @context, @ruby_style_hash, as: self.class)
-            self
-          end
+          object = @context[:current_object]
+          # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
+          Schema::Validator.validate!(self.class.validators, object, @context, @ruby_style_hash, as: self.class)
+          self
         else
           self
         end
@@ -83,7 +59,6 @@ module GraphQL
         # Authorize each argument (but this doesn't apply if `prepare` is implemented):
         if value.respond_to?(:key?)
           arguments(ctx).each do |_name, input_obj_arg|
-            input_obj_arg = input_obj_arg.type_class
             if value.key?(input_obj_arg.keyword) &&
               !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
               return false
@@ -94,6 +69,19 @@ module GraphQL
         true
       end
 
+      def self.one_of
+        if !one_of?
+          if all_argument_definitions.any? { |arg| arg.type.non_null? }
+            raise ArgumentError, "`one_of` may not be used with required arguments -- add `required: false` to argument definitions to use `one_of`"
+          end
+          directive(GraphQL::Schema::Directive::OneOf)
+        end
+      end
+
+      def self.one_of?
+        directives.any? { |d| d.is_a?(GraphQL::Schema::Directive::OneOf) }
+      end
+
       def unwrap_value(value)
         case value
         when Array
@@ -132,11 +120,16 @@ module GraphQL
       end
 
       class << self
-        # @return [Class<GraphQL::Arguments>]
-        attr_accessor :arguments_class
-
         def argument(*args, **kwargs, &block)
           argument_defn = super(*args, **kwargs, &block)
+          if one_of?
+            if argument_defn.type.non_null?
+              raise ArgumentError, "Argument '#{argument_defn.path}' must be nullable because it is part of a OneOf type, add `required: false`."
+            end
+            if argument_defn.default_value?
+              raise ArgumentError, "Argument '#{argument_defn.path}' cannot have a default value because it is part of a OneOf type, remove `default_value: ...`."
+            end
+          end
           # Add a method access
           method_name = argument_defn.keyword
           class_eval <<-RUBY, __FILE__, __LINE__
@@ -147,25 +140,6 @@ module GraphQL
           argument_defn
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::InputObjectType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.metadata[:type_class] = self
-          type_defn.mutation = mutation
-          type_defn.ast_node = ast_node
-          all_argument_definitions.each do |arg|
-            type_defn.arguments[arg.graphql_definition(silence_deprecation_warning: true).name] = arg.graphql_definition(silence_deprecation_warning: true) # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-          end
-          # Make a reference to a classic-style Arguments class
-          self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn)
-          # But use this InputObject class at runtime
-          type_defn.arguments_class = self
-          type_defn
-        end
-
         def kind
           GraphQL::TypeKinds::INPUT_OBJECT
         end
@@ -174,18 +148,15 @@ module GraphQL
         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, max_errors: nil)
-          result = GraphQL::Query::InputValidationResult.new
           warden = ctx.warden
 
           if input.is_a?(Array)
-            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-            return result
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
           if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
             # We're not sure it'll act like a hash, so reject it:
-            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-            return result
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
           # Inject missing required arguments
@@ -197,18 +168,36 @@ module GraphQL
             m
           end
 
-
+          result = nil
           [input, missing_required_inputs].each do |args_to_validate|
             args_to_validate.each do |argument_name, value|
               argument = warden.get_argument(self, argument_name)
               # Items in the input that are unexpected
-              unless argument
+              if argument.nil?
+                result ||= Query::InputValidationResult.new
                 result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-                next
+              else
+                # Items in the input that are expected, but have invalid values
+                argument_result = argument.type.validate_input(value, ctx)
+                result ||= Query::InputValidationResult.new
+                if !argument_result.valid?
+                  result.merge_result!(argument_name, argument_result)
+                end
               end
-              # Items in the input that are expected, but have invalid values
-              argument_result = argument.type.validate_input(value, ctx)
-              result.merge_result!(argument_name, argument_result) unless argument_result.valid?
+            end
+          end
+
+          if one_of?
+            if input.size == 1
+              input.each do |name, value|
+                if value.nil?
+                  result ||= Query::InputValidationResult.new
+                  result.add_problem("'#{graphql_name}' requires exactly one argument, but '#{name}' was `null`.")
+                end
+              end
+            else
+              result ||= Query::InputValidationResult.new
+              result.add_problem("'#{graphql_name}' requires exactly one argument, but #{input.size} were provided.")
             end
           end
 

data/lib/graphql/schema/interface.rb

@@ -4,8 +4,6 @@ module GraphQL
     module Interface
       include GraphQL::Schema::Member::GraphQLTypeNames
       module DefinitionMethods
-        include GraphQL::Schema::Member::CachedGraphQLDefinition
-        include GraphQL::Relay::TypeExtensions
         include GraphQL::Schema::Member::BaseDSLMethods
         # ConfigurationExtension's responsibilities are in `def included` below
         include GraphQL::Schema::Member::TypeSystemHelpers
@@ -30,16 +28,6 @@ module GraphQL
           true
         end
 
-        # The interface is accessible if any of its possible types are accessible
-        def accessible?(context)
-          context.schema.possible_types(self, context).each do |type|
-            if context.schema.accessible?(type, context)
-              return true
-            end
-          end
-          false
-        end
-
         def type_membership_class(membership_class = nil)
           if membership_class
             @type_membership_class = membership_class
@@ -100,34 +88,11 @@ module GraphQL
           end
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::InterfaceType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.orphan_types = orphan_types
-          type_defn.type_membership_class = self.type_membership_class
-          type_defn.ast_node = ast_node
-          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-            field_defn = field_inst.graphql_definition(silence_deprecation_warning: true)
-            type_defn.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-          end
-          type_defn.metadata[:type_class] = self
-          if respond_to?(:resolve_type)
-            type_defn.resolve_type = method(:resolve_type)
-          end
-          type_defn
-        end
-
         def kind
           GraphQL::TypeKinds::INTERFACE
         end
       end
 
-      # Extend this _after_ `DefinitionMethods` is defined, so it will be used
-      extend GraphQL::Schema::Member::AcceptsDefinition
-
       extend DefinitionMethods
 
       def unwrap

data/lib/graphql/schema/introspection_system.rb

@@ -89,9 +89,9 @@ module GraphQL
         case late_bound_type
         when GraphQL::Schema::LateBoundType
           @schema.get_type(late_bound_type.name)
-        when GraphQL::Schema::List, GraphQL::ListType
+        when GraphQL::Schema::List
           resolve_late_binding(late_bound_type.of_type).to_list_type
-        when GraphQL::Schema::NonNull, GraphQL::NonNullType
+        when GraphQL::Schema::NonNull
           resolve_late_binding(late_bound_type.of_type).to_non_null_type
         when Module
           # It's a normal type -- no change required
@@ -103,12 +103,7 @@ module GraphQL
 
       def load_constant(class_name)
         const = @custom_namespace.const_get(class_name)
-        if @class_based
-          dup_type_class(const)
-        else
-          # Use `.to_graphql` to get a freshly-made version, not shared between schemas
-          const.deprecated_to_graphql
-        end
+        dup_type_class(const)
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared
         dup_type_class(@built_in_namespace.const_get(class_name))

data/lib/graphql/schema/late_bound_type.rb

@@ -9,6 +9,8 @@ module GraphQL
       alias :graphql_name :name
       def initialize(local_name)
         @name = local_name
+        @to_non_null_type = nil
+        @to_list_type = nil
       end
 
       def unwrap
@@ -16,17 +18,21 @@ module GraphQL
       end
 
       def to_non_null_type
-        @to_non_null_type ||= GraphQL::NonNullType.new(of_type: self)
+        @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
       end
 
       def to_list_type
-        @to_list_type ||= GraphQL::ListType.new(of_type: self)
+        @to_list_type ||= GraphQL::Schema::List.new(self)
       end
 
       def inspect
         "#<LateBoundType @name=#{name}>"
       end
 
+      def non_null?
+        false
+      end
+
       alias :to_s :inspect
     end
   end

data/lib/graphql/schema/list.rb

@@ -8,12 +8,6 @@ module GraphQL
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      def to_graphql
-        @of_type.graphql_definition(silence_deprecation_warning: true).to_list_type
-      end
-
       # @return [GraphQL::TypeKinds::LIST]
       def kind
         GraphQL::TypeKinds::LIST

data/lib/graphql/schema/loader.rb

@@ -142,7 +142,7 @@ module GraphQL
               Class.new(GraphQL::Schema::Scalar) do
                 graphql_name(type["name"])
                 description(type["description"])
-                specified_by_url(type["specifiedByUrl"])
+                specified_by_url(type["specifiedByURL"])
               end
             end
           when "UNION"
@@ -202,7 +202,6 @@ module GraphQL
               description: arg["description"],
               deprecation_reason: arg["deprecationReason"],
               required: false,
-              method_access: false,
               camelize: false,
             }
 

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

@@ -22,14 +22,10 @@ module GraphQL
             GraphQL::NameValidator.validate!(new_name)
             @graphql_name = new_name
           else
-            overridden_graphql_name || default_graphql_name
+            @graphql_name ||= default_graphql_name
           end
         end
 
-        def overridden_graphql_name
-          defined?(@graphql_name) ? @graphql_name : nil
-        end
-
         # Just a convenience method to point out that people should use graphql_name instead
         def name(new_name = nil)
           return super() if new_name.nil?
@@ -60,8 +56,8 @@ module GraphQL
           def inherited(child_class)
             child_class.introspection(introspection)
             child_class.description(description)
-            if overridden_graphql_name
-              child_class.graphql_name(overridden_graphql_name)
+            if defined?(@graphql_name) && (self.name.nil? || graphql_name != default_graphql_name)
+              child_class.graphql_name(graphql_name)
             end
             super
           end
@@ -79,7 +75,7 @@ module GraphQL
         end
 
         def introspection?
-          introspection
+          !!@introspection
         end
 
         # The mutation this type was derived from, if it was derived from a mutation
@@ -94,11 +90,6 @@ module GraphQL
           end
         end
 
-        # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
-        def to_graphql
-          raise GraphQL::RequiredImplementationMissingError
-        end
-
         alias :unwrap :itself
 
         # Creates the default name for a schema member.
@@ -107,21 +98,26 @@ module GraphQL
         def default_graphql_name
           @default_graphql_name ||= begin
             raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
-
-            -name.split("::").last.sub(/Type\Z/, "")
-          end
+            -name.split("::").last.sub(/Type\Z/, "")          end
         end
 
         def visible?(context)
           true
         end
 
-        def accessible?(context)
+        def authorized?(object, context)
           true
         end
 
-        def authorized?(object, context)
-          true
+        protected
+
+        attr_writer :default_graphql_name
+
+        private
+
+        def inherited(subclass)
+          super
+          subclass.default_graphql_name = nil
         end
       end
     end

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

@@ -35,18 +35,16 @@ module GraphQL
             else
               maybe_type = constantize(type_expr)
               case maybe_type
-              when GraphQL::BaseType
-                maybe_type
               when Module
                 # This is a way to check that it's the right kind of module:
-                if maybe_type.respond_to?(:graphql_definition)
+                if maybe_type.respond_to?(:kind)
                   maybe_type
                 else
                   raise ArgumentError, "Unexpected class/module found for GraphQL type: #{type_expr} (must be type definition class/module)"
                 end
               end
             end
-          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+          when GraphQL::Schema::LateBoundType
             type_expr
           when Array
             case type_expr.length
@@ -68,7 +66,7 @@ module GraphQL
             type_expr
           when Module
             # This is a way to check that it's the right kind of module:
-            if type_expr.respond_to?(:graphql_definition)
+            if type_expr.respond_to?(:kind)
               type_expr
             else
               # Eg `String` => GraphQL::Types::String
@@ -100,7 +98,7 @@ module GraphQL
 
         def to_type_name(something)
           case something
-          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+          when GraphQL::Schema::LateBoundType
             something.unwrap.name
           when Array
             to_type_name(something.first)
@@ -122,7 +120,7 @@ module GraphQL
         def camelize(string)
           return string if string == '_'
           return string unless string.include?("_")
-          camelized = string.split('_').map(&:capitalize).join
+          camelized = string.split('_').each(&:capitalize!).join
           camelized[0] = camelized[0].downcase
           if (match_data = string.match(/\A(_+)/))
             camelized = "#{match_data[0]}#{camelized}"