graphql 2.0.32 → 2.5.22

data/lib/graphql/schema/enum.rb

@@ -14,7 +14,7 @@ module GraphQL
     #   #   ONIONS
     #   #   PEPPERS
     #   # }
-    #   class PizzaTopping < GraphQL::Enum
+    #   class PizzaTopping < GraphQL::Schema::Enum
     #     value :MUSHROOMS
     #     value :ONIONS
     #     value :PEPPERS
@@ -22,9 +22,21 @@ module GraphQL
     class Enum < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::ValidatesInput
 
+      # 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:)
-          fix_message = ", 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."
+        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
@@ -34,6 +46,8 @@ module GraphQL
         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
@@ -43,15 +57,23 @@ module GraphQL
 
       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 [::Object] :value_method, the method name to fetch `graphql_name` (defaults to `graphql_name.downcase`)
+        # @option kwargs [String] :deprecation_reason if this object is deprecated, include a message here
+        # @param value_method [Symbol, false] A method to generate for this value, or `false` to skip generation
         # @return [void]
         # @see {Schema::EnumValue} which handles these inputs by default
-        def value(*args, **kwargs, &block)
+        def value(*args, value_method: nil, **kwargs, &block)
           kwargs[:owner] = self
           value = enum_value_class.new(*args, **kwargs, &block)
+
+          if value_method || (value_methods && value_method != false)
+            generate_value_method(value, value_method)
+          end
+
           key = value.graphql_name
           prev_value = own_values[key]
           case prev_value
@@ -68,13 +90,27 @@ module GraphQL
         end
 
         # @return [Array<GraphQL::Schema::EnumValue>] Possible values of this enum
-        def enum_values(context = GraphQL::Query::NullContext)
+        def enum_values(context = GraphQL::Query::NullContext.instance)
           inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
           visible_values = []
-          warden = Warden.from_context(context)
+          types = Warden.types_from_context(context)
           own_values.each do |key, values_entry|
-            if (v = Warden.visible_entry?(:visible_enum_value?, values_entry, context, warden))
-              visible_values << v
+            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
 
@@ -110,7 +146,7 @@ module GraphQL
         end
 
         # @return [Hash<String => GraphQL::Schema::EnumValue>] Possible values of this enum, keyed by name.
-        def values(context = GraphQL::Query::NullContext)
+        def values(context = GraphQL::Query::NullContext.instance)
           enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 
@@ -125,12 +161,24 @@ module GraphQL
           end
         end
 
+        def value_methods(new_value = NOT_CONFIGURED)
+          if NOT_CONFIGURED.equal?(new_value)
+            if @value_methods != nil
+              @value_methods
+            else
+              find_inherited_value(:value_methods, false)
+            end
+          else
+            @value_methods = new_value
+          end
+        end
+
         def kind
           GraphQL::TypeKinds::ENUM
         end
 
         def validate_non_null_input(value_name, ctx, max_errors: nil)
-          allowed_values = ctx.warden.enum_values(self)
+          allowed_values = ctx.types.enum_values(self)
           matching_value = allowed_values.find { |v| v.graphql_name == value_name }
 
           if matching_value.nil?
@@ -138,35 +186,55 @@ module GraphQL
           else
             nil
           end
+        # 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.new(enum: self, value: value, context: ctx)
+            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
+          child_class.class_exec { @value_methods = nil }
           super
         end
 
@@ -175,6 +243,21 @@ module GraphQL
         def own_values
           @own_values ||= {}
         end
+
+        def generate_value_method(value, configured_value_method)
+          return if configured_value_method == false
+
+          value_method_name = configured_value_method || value.graphql_name.downcase
+
+          if respond_to?(value_method_name.to_sym)
+            warn "Failed to define value method for :#{value_method_name}, because " \
+              "#{value.owner.name || value.owner.graphql_name} already responds to that method. Use `value_method:` to override the method name " \
+              "or `value_method: false` to disable Enum value method generation."
+            return
+          end
+
+          define_singleton_method(value_method_name) { value.graphql_name }
+        end
       end
 
       enum_value_class(GraphQL::Schema::EnumValue)

data/lib/graphql/schema/enum_value.rb

@@ -30,10 +30,11 @@ 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: NOT_CONFIGURED, 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
+        @comment = comment
         @value = value == NOT_CONFIGURED ? @graphql_name : value
         if deprecation_reason
           self.deprecation_reason = deprecation_reason
@@ -58,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
@@ -66,7 +74,7 @@ module GraphQL
       end
 
       def inspect
-        "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}>"
+        "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}#{deprecation_reason ? " @deprecation_reason=#{deprecation_reason.inspect}" : ""}>"
       end
 
       def visible?(_ctx); true; end

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

@@ -21,59 +21,25 @@ module GraphQL
           yield(object, next_args, arguments)
         end
 
+        def resolve_next(objects:, arguments:, context:)
+          next_args = arguments.dup
+          next_args.delete(:first)
+          next_args.delete(:last)
+          next_args.delete(:before)
+          next_args.delete(:after)
+          yield(objects, next_args, arguments)
+        end
+
         def after_resolve(value:, object:, arguments:, context:, memo:)
           original_arguments = memo
-          # rename some inputs to avoid conflicts inside the block
-          maybe_lazy = value
-          value = nil
-          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
-              context.add_error(value)
-              nil
-            elsif value.nil?
-              nil
-            elsif value.is_a?(GraphQL::Pagination::Connection)
-              # update the connection with some things that may not have been provided
-              value.context ||= context
-              value.parent ||= object.object
-              value.first_value ||= original_arguments[:first]
-              value.after_value ||= original_arguments[:after]
-              value.last_value ||= original_arguments[:last]
-              value.before_value ||= original_arguments[:before]
-              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 field.has_default_page_size? && !value.has_default_page_size_override?
-                value.default_page_size = field.default_page_size
-              end
-              if context.schema.new_connections? && (custom_t = context.schema.connections.edge_class_for_field(@field))
-                value.edge_class = custom_t
-              end
-              value
-            elsif context.schema.new_connections?
-              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,
-                default_page_size: field.default_page_size,
-                parent: object,
-                context: context,
-              )
-            end
+          context.query.after_lazy(value) do |resolved_value|
+            context.schema.connections.populate_connection(field, object.object, resolved_value, original_arguments, context)
           end
         end
+
+        def after_resolve_next(**kwargs)
+          raise "This should never be called -- it's hardcoded in execution instead."
+        end
       end
     end
   end

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

@@ -5,17 +5,33 @@ module GraphQL
     class Field
       class ScopeExtension < GraphQL::Schema::FieldExtension
         def after_resolve(object:, arguments:, context:, value:, memo:)
-          if value.nil?
-            value
-          else
-            ret_type = @field.type.unwrap
-            if ret_type.respond_to?(:scope_items)
-              ret_type.scope_items(value, context)
-            else
+          if object.is_a?(GraphQL::Schema::Object)
+            if value.nil?
               value
+            else
+              return_type = field.type.unwrap
+              if return_type.respond_to?(:scope_items)
+                scoped_items = return_type.scope_items(value, context)
+                if !scoped_items.equal?(value) && !return_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
             end
+          else
+            # TODO skip this entirely?
+            value
           end
         end
+
+        def after_resolve_next(**kwargs)
+          raise "This should never be called -- it's hardcoded in execution instead."
+        end
       end
     end
   end