graphql 1.12.12 → 2.4.8

data/lib/graphql/schema/enum.rb

@@ -1,68 +1,146 @@
 # frozen_string_literal: true
 
 module GraphQL
-  # Extend this class to define GraphQL enums in your schema.
-  #
-  # By default, GraphQL enum values are translated into Ruby strings.
-  # You can provide a custom value with the `value:` keyword.
-  #
-  # @example
-  #   # equivalent to
-  #   # enum PizzaTopping {
-  #   #   MUSHROOMS
-  #   #   ONIONS
-  #   #   PEPPERS
-  #   # }
-  #   class PizzaTopping < GraphQL::Enum
-  #     value :MUSHROOMS
-  #     value :ONIONS
-  #     value :PEPPERS
-  #   end
   class Schema
+    # Extend this class to define GraphQL enums in your schema.
+    #
+    # By default, GraphQL enum values are translated into Ruby strings.
+    # You can provide a custom value with the `value:` keyword.
+    #
+    # @example
+    #   # equivalent to
+    #   # enum PizzaTopping {
+    #   #   MUSHROOMS
+    #   #   ONIONS
+    #   #   PEPPERS
+    #   # }
+    #   class PizzaTopping < GraphQL::Schema::Enum
+    #     value :MUSHROOMS
+    #     value :ONIONS
+    #     value :PEPPERS
+    #   end
     class Enum < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
-      class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+      # This is raised when either:
+      #
+      # - A resolver returns a value which doesn't match any of the enum's configured values;
+      # - Or, the resolver returns a value which matches a value, but that value's `authorized?` check returns false.
+      #
+      # In either case, the field should be modified so that the invalid value isn't returned.
+      #
+      # {GraphQL::Schema::Enum} subclasses get their own subclass of this error, so that bug trackers can better show where they came from.
+      class UnresolvedValueError < GraphQL::Error
+        def initialize(value:, enum:, context:, authorized:)
+          fix_message = if authorized == false
+            ", but this value was unauthorized. Update the field or resolver to return a different value in this case (or return `nil`)."
+          else
+            ", but this isn't a valid value for `#{enum.graphql_name}`. Update the field or resolver to return one of `#{enum.graphql_name}`'s values instead."
+          end
+          message = if (cp = context[:current_path]) && (cf = context[:current_field])
+            "`#{cf.path}` returned `#{value.inspect}` at `#{cp.join(".")}`#{fix_message}"
+          else
+            "`#{value.inspect}` was returned for `#{enum.graphql_name}`#{fix_message}"
+          end
+          super(message)
+        end
+      end
+
+      # Raised when a {GraphQL::Schema::Enum} is defined to have no values.
+      # This can also happen when all values return false for `.visible?`.
+      class MissingValuesError < GraphQL::Error
+        def initialize(enum_type)
+          @enum_type = enum_type
+          super("Enum types require at least one value, but #{enum_type.graphql_name} didn't provide any for this query. Make sure at least one value is defined and visible for this query.")
+        end
       end
 
       class << self
         # Define a value for this enum
-        # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
-        # @param description [String], the GraphQL description for this value, present in documentation
-        # @param value [Object], the translated Ruby value for this object (defaults to `graphql_name`)
-        # @param deprecation_reason [String] if this object is deprecated, include a message here
+        # @option kwargs [String, Symbol] :graphql_name the GraphQL value for this, usually `SCREAMING_CASE`
+        # @option kwargs [String] :description, the GraphQL description for this value, present in documentation
+        # @option kwargs [String] :comment, the GraphQL comment for this value, present in documentation
+        # @option kwargs [::Object] :value the translated Ruby value for this object (defaults to `graphql_name`)
+        # @option kwargs [String] :deprecation_reason if this object is deprecated, include a message here
         # @return [void]
         # @see {Schema::EnumValue} which handles these inputs by default
         def value(*args, **kwargs, &block)
           kwargs[:owner] = self
           value = enum_value_class.new(*args, **kwargs, &block)
-          if own_values.key?(value.graphql_name)
-            raise ArgumentError, "#{value.graphql_name} is already defined for #{self.graphql_name}, please remove one of the definitions."
+          key = value.graphql_name
+          prev_value = own_values[key]
+          case prev_value
+          when nil
+            own_values[key] = value
+          when GraphQL::Schema::EnumValue
+            own_values[key] = [prev_value, value]
+          when Array
+            prev_value << value
+          else
+            raise "Invariant: Unexpected enum value for #{key.inspect}: #{prev_value.inspect}"
           end
-          own_values[value.graphql_name] = value
-          nil
+          value
         end
 
-        # @return [Hash<String => GraphQL::Schema::Enum::Value>] Possible values of this enum, keyed by name
-        def values
-          inherited_values = superclass <= GraphQL::Schema::Enum ? superclass.values : {}
-          # Local values take precedence over inherited ones
-          inherited_values.merge(own_values)
+        # @return [Array<GraphQL::Schema::EnumValue>] Possible values of this enum
+        def enum_values(context = GraphQL::Query::NullContext.instance)
+          inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
+          visible_values = []
+          types = Warden.types_from_context(context)
+          own_values.each do |key, values_entry|
+            visible_value = nil
+            if values_entry.is_a?(Array)
+              values_entry.each do |v|
+                if types.visible_enum_value?(v, context)
+                  if visible_value.nil?
+                    visible_value = v
+                    visible_values << v
+                  else
+                    raise DuplicateNamesError.new(
+                      duplicated_name: v.path, duplicated_definition_1: visible_value.inspect, duplicated_definition_2: v.inspect
+                    )
+                  end
+                end
+              end
+            elsif types.visible_enum_value?(values_entry, context)
+              visible_values << values_entry
+            end
+          end
+
+          if inherited_values
+            # Local values take precedence over inherited ones
+            inherited_values.each do |i_val|
+              if !visible_values.any? { |v| v.graphql_name == i_val.graphql_name }
+                visible_values << i_val
+              end
+            end
+          end
+
+          visible_values
         end
 
-        # @return [GraphQL::EnumType]
-        def to_graphql
-          enum_type = GraphQL::EnumType.new
-          enum_type.name = graphql_name
-          enum_type.description = description
-          enum_type.introspection = introspection
-          enum_type.ast_node = ast_node
-          values.each do |name, val|
-            enum_type.add_value(val.to_graphql)
+        # @return [Array<Schema::EnumValue>] An unfiltered list of all definitions
+        def all_enum_value_definitions
+          all_defns = if superclass.respond_to?(:all_enum_value_definitions)
+            superclass.all_enum_value_definitions
+          else
+            []
+          end
+
+          @own_values && @own_values.each do |_key, value|
+            if value.is_a?(Array)
+              all_defns.concat(value)
+            else
+              all_defns << value
+            end
           end
-          enum_type.metadata[:type_class] = self
-          enum_type
+
+          all_defns
+        end
+
+        # @return [Hash<String => GraphQL::Schema::EnumValue>] Possible values of this enum, keyed by name.
+        def values(context = GraphQL::Query::NullContext.instance)
+          enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 
         # @return [Class] for handling `value(...)` inputs and building `GraphQL::Enum::EnumValue`s out of them
@@ -80,46 +158,63 @@ module GraphQL
           GraphQL::TypeKinds::ENUM
         end
 
-        def validate_non_null_input(value_name, ctx)
-          result = GraphQL::Query::InputValidationResult.new
-
-          allowed_values = ctx.warden.enum_values(self)
+        def validate_non_null_input(value_name, ctx, max_errors: nil)
+          allowed_values = ctx.types.enum_values(self)
           matching_value = allowed_values.find { |v| v.graphql_name == value_name }
 
           if matching_value.nil?
-            result.add_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}")
+            GraphQL::Query::InputValidationResult.from_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}")
+          else
+            nil
           end
-
-          result
+        # rescue MissingValuesError
+        #   nil
         end
 
+        # Called by the runtime when a field returns a value to give back to the client.
+        # This method checks that the incoming {value} matches one of the enum's defined values.
+        # @param value [Object] Any value matching the values for this enum.
+        # @param ctx [GraphQL::Query::Context]
+        # @raise [GraphQL::Schema::Enum::UnresolvedValueError] if {value} doesn't match a configured value or if the matching value isn't authorized.
+        # @return [String] The GraphQL-ready string for {value}
         def coerce_result(value, ctx)
-          warden = ctx.warden
-          all_values = warden ? warden.enum_values(self) : values.each_value
+          types = ctx.types
+          all_values = types ? types.enum_values(self) : values.each_value
           enum_value = all_values.find { |val| val.value == value }
-          if enum_value
+          if enum_value && (was_authed = enum_value.authorized?(ctx))
             enum_value.graphql_name
           else
-            raise(self::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
+            raise self::UnresolvedValueError.new(enum: self, value: value, context: ctx, authorized: was_authed)
           end
         end
 
+        # Called by the runtime with incoming string representations from a query.
+        # It will match the string to a configured by name or by Ruby value.
+        # @param value_name [String, Object] A string from a GraphQL query, or a Ruby value matching a `value(..., value: ...)` configuration
+        # @param ctx [GraphQL::Query::Context]
+        # @raise [GraphQL::UnauthorizedEnumValueError] if an {EnumValue} matches but returns false for `.authorized?`. Goes to {Schema.unauthorized_object}.
+        # @return [Object] The Ruby value for the matched {GraphQL::Schema::EnumValue}
         def coerce_input(value_name, ctx)
-          all_values = ctx.warden ? ctx.warden.enum_values(self) : values.each_value
-
-          if v = all_values.find { |val| val.graphql_name == value_name }
-            v.value
-          elsif v = all_values.find { |val| val.value == value_name }
-            # this is for matching default values, which are "inputs", but they're
-            # the Ruby value, not the GraphQL string.
-            v.value
+          all_values = ctx.types ? ctx.types.enum_values(self) : values.each_value
+
+          # This tries matching by incoming GraphQL string, then checks Ruby-defined values
+          if v = (all_values.find { |val| val.graphql_name == value_name } || all_values.find { |val| val.value == value_name })
+            if v.authorized?(ctx)
+              v.value
+            else
+              raise GraphQL::UnauthorizedEnumValueError.new(type: self, enum_value: v, context: ctx)
+            end
           else
             nil
           end
         end
 
         def inherited(child_class)
-          child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
+          if child_class.name
+            # Don't assign a custom error class to anonymous classes
+            # because they would end up with names like `#<Class0x1234>::UnresolvedValueError` which messes up bug trackers
+            child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
+          end
           super
         end
 

data/lib/graphql/schema/enum_value.rb

@@ -13,12 +13,6 @@ module GraphQL
     #       # arguments to `value(...)` in Enum classes are passed here
     #       super
     #     end
-    #
-    #     def to_graphql
-    #       enum_value = super
-    #       # customize the derived GraphQL::EnumValue here
-    #       enum_value
-    #     end
     #   end
     #
     #   class BaseEnum < GraphQL::Schema::Enum
@@ -26,8 +20,6 @@ module GraphQL
     #     enum_value_class CustomEnumValue
     #   end
     class EnumValue < GraphQL::Schema::Member
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasDirectives
@@ -38,11 +30,12 @@ module GraphQL
       # @return [Class] The enum type that owns this value
       attr_reader :owner
 
-      def initialize(graphql_name, desc = nil, owner:, ast_node: nil, directives: nil, description: nil, value: nil, deprecation_reason: nil, &block)
+      def initialize(graphql_name, desc = nil, owner:, ast_node: nil, directives: nil, description: nil, comment: nil, value: NOT_CONFIGURED, deprecation_reason: nil, &block)
         @graphql_name = graphql_name.to_s
         GraphQL::NameValidator.validate!(@graphql_name)
         @description = desc || description
-        @value = value.nil? ? @graphql_name : value
+        @comment = comment
+        @value = value == NOT_CONFIGURED ? @graphql_name : value
         if deprecation_reason
           self.deprecation_reason = deprecation_reason
         end
@@ -66,6 +59,13 @@ module GraphQL
         @description
       end
 
+      def comment(new_comment = nil)
+        if new_comment
+          @comment = new_comment
+        end
+        @comment
+      end
+
       def value(new_val = nil)
         unless new_val.nil?
           @value = new_val
@@ -73,20 +73,11 @@ module GraphQL
         @value
       end
 
-      # @return [GraphQL::EnumType::EnumValue] A runtime-ready object derived from this object
-      def to_graphql
-        enum_value = GraphQL::EnumType::EnumValue.new
-        enum_value.name = @graphql_name
-        enum_value.description = @description
-        enum_value.value = @value
-        enum_value.deprecation_reason = self.deprecation_reason
-        enum_value.metadata[:type_class] = self
-        enum_value.ast_node = ast_node
-        enum_value
+      def inspect
+        "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}#{deprecation_reason ? " @deprecation_reason=#{deprecation_reason.inspect}" : ""}>"
       end
 
       def visible?(_ctx); true; end
-      def accessible?(_ctx); true; end
       def authorized?(_ctx); true; end
     end
   end

data/lib/graphql/schema/field/connection_extension.rb

@@ -26,7 +26,7 @@ module GraphQL
           # rename some inputs to avoid conflicts inside the block
           maybe_lazy = value
           value = nil
-          context.schema.after_lazy(maybe_lazy) do |resolved_value|
+          context.query.after_lazy(maybe_lazy) do |resolved_value|
             value = resolved_value
             if value.is_a? GraphQL::ExecutionError
               # This isn't even going to work because context doesn't have ast_node anymore
@@ -42,31 +42,21 @@ module GraphQL
               value.after_value ||= original_arguments[:after]
               value.last_value ||= original_arguments[:last]
               value.before_value ||= original_arguments[:before]
-              value.arguments ||= original_arguments
+              value.arguments ||= original_arguments # rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
               value.field ||= field
               if field.has_max_page_size? && !value.has_max_page_size_override?
                 value.max_page_size = field.max_page_size
               end
-              if context.schema.new_connections? && (custom_t = context.schema.connections.edge_class_for_field(@field))
+              if field.has_default_page_size? && !value.has_default_page_size_override?
+                value.default_page_size = field.default_page_size
+              end
+              if (custom_t = context.schema.connections.edge_class_for_field(@field))
                 value.edge_class = custom_t
               end
               value
-            elsif context.schema.new_connections?
+            else
               context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
               context.schema.connections.wrap(field, object.object, value, original_arguments, context)
-            else
-              if object.is_a?(GraphQL::Schema::Object)
-                object = object.object
-              end
-              connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(value)
-              connection_class.new(
-                value,
-                original_arguments,
-                field: field,
-                max_page_size: field.max_page_size,
-                parent: object,
-                context: context,
-              )
             end
           end
         end

data/lib/graphql/schema/field/scope_extension.rb

@@ -10,7 +10,14 @@ module GraphQL
           else
             ret_type = @field.type.unwrap
             if ret_type.respond_to?(:scope_items)
-              ret_type.scope_items(value, context)
+              scoped_items = ret_type.scope_items(value, context)
+              if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
+                if (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
+                    (query_runtime_state = current_runtime_state[context.query])
+                  query_runtime_state.was_authorized_by_scope_items = true
+                end
+              end
+              scoped_items
             else
               value
             end