graphql 2.2.17 → 2.5.16

data/lib/graphql/schema/subscription.rb

@@ -19,13 +19,22 @@ module GraphQL
       # propagate null.
       null false
 
+      # @api private
       def initialize(object:, context:, field:)
         super
         # Figure out whether this is an update or an initial subscription
         @mode = context.query.subscription_update? ? :update : :subscribe
+        @subscription_written = false
+        @original_arguments = nil
+        if (subs_ns = context.namespace(:subscriptions)) &&
+          (sub_insts = subs_ns[:subscriptions])
+          sub_insts[context.current_path] = self
+        end
       end
 
+      # @api private
       def resolve_with_support(**args)
+        @original_arguments = args # before `loads:` have been run
         result = nil
         unsubscribed = true
         unsubscribed_result = catch :graphql_subscription_unsubscribed do
@@ -46,7 +55,9 @@ module GraphQL
         end
       end
 
-      # Implement the {Resolve} API
+      # Implement the {Resolve} API.
+      # You can implement this if you want code to run for _both_ the initial subscription
+      # and for later updates. Or, implement {#subscribe} and {#update}
       def resolve(**args)
         # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
         # have an unexpected `@mode`
@@ -54,8 +65,9 @@ module GraphQL
       end
 
       # Wrap the user-defined `#subscribe` hook
+      # @api private
       def resolve_subscribe(**args)
-        ret_val = args.any? ? subscribe(**args) : subscribe
+        ret_val = !args.empty? ? subscribe(**args) : subscribe
         if ret_val == :no_response
           context.skip
         else
@@ -71,8 +83,9 @@ module GraphQL
       end
 
       # Wrap the user-provided `#update` hook
+      # @api private
       def resolve_update(**args)
-        ret_val = args.any? ? update(**args) : update
+        ret_val = !args.empty? ? update(**args) : update
         if ret_val == NO_UPDATE
           context.namespace(:subscriptions)[:no_update] = true
           context.skip
@@ -106,14 +119,13 @@ module GraphQL
         throw :graphql_subscription_unsubscribed, update_value
       end
 
-      READING_SCOPE = ::Object.new
       # Call this method to provide a new subscription_scope; OR
       # call it without an argument to get the subscription_scope
       # @param new_scope [Symbol]
       # @param optional [Boolean] If true, then don't require `scope:` to be provided to updates to this subscription.
       # @return [Symbol]
-      def self.subscription_scope(new_scope = READING_SCOPE, optional: false)
-        if new_scope != READING_SCOPE
+      def self.subscription_scope(new_scope = NOT_CONFIGURED, optional: false)
+        if new_scope != NOT_CONFIGURED
           @subscription_scope = new_scope
           @subscription_scope_optional = optional
         elsif defined?(@subscription_scope)
@@ -150,6 +162,40 @@ module GraphQL
       def self.topic_for(arguments:, field:, scope:)
         Subscriptions::Serialize.dump_recursive([scope, field.graphql_name, arguments])
       end
+
+      # Calls through to `schema.subscriptions` to register this subscription with the backend.
+      # This is automatically called by GraphQL-Ruby after a query finishes successfully,
+      # but if you need to commit the subscription during `#subscribe`, you can call it there.
+      # (This method also sets a flag showing that this subscription was already written.)
+      #
+      # If you call this method yourself, you may also need to {#unsubscribe}
+      # or call `subscriptions.delete_subscription` to clean up the database if the query crashes with an error
+      # later in execution.
+      # @return [void]
+      def write_subscription
+        if subscription_written?
+          raise GraphQL::Error, "`write_subscription` was called but `#{self.class}#subscription_written?` is already true. Remove a call to `write subscription`."
+        else
+          @subscription_written = true
+          context.schema.subscriptions.write_subscription(context.query, [event])
+        end
+        nil
+      end
+
+      # @return [Boolean] `true` if {#write_subscription} was called already
+      def subscription_written?
+        @subscription_written
+      end
+
+      # @return [Subscriptions::Event] This object is used as a representation of this subscription for the backend
+      def event
+        @event ||= Subscriptions::Event.new(
+          name: field.name,
+          arguments: @original_arguments,
+          context: context,
+          field: field,
+        )
+      end
     end
   end
 end

data/lib/graphql/schema/timeout.rb

@@ -71,15 +71,23 @@ module GraphQL
         def execute_field(query:, field:, **_rest)
           timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
-          if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+          if timeout_state == false
+            super
+          elsif Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
             error = GraphQL::Schema::Timeout::TimeoutError.new(field)
             # Only invoke the timeout callback for the first timeout
             if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
               @timeout.handle_timeout(error, query)
+              timeout_state = query.context.namespace(@timeout).fetch(:state)
             end
 
-            error
+            # `handle_timeout` may have set this to be `false`
+            if timeout_state != false
+              error
+            else
+              super
+            end
           else
             super
           end
@@ -102,6 +110,15 @@ module GraphQL
         # override to do something interesting
       end
 
+      # Call this method (eg, from {#handle_timeout}) to disable timeout tracking
+      # for the given query.
+      # @param query [GraphQL::Query]
+      # @return [void]
+      def disable_timeout(query)
+        query.context.namespace(self)[:state] = false
+        nil
+      end
+
       # This error is raised when a query exceeds `max_seconds`.
       # Since it's a child of {GraphQL::ExecutionError},
       # its message will be added to the response's `errors` key.

data/lib/graphql/schema/type_expression.rb

@@ -5,13 +5,13 @@ module GraphQL
     module TypeExpression
       # Fetch a type from a type map by its AST specification.
       # Return `nil` if not found.
-      # @param type_owner [#get_type] A thing for looking up types by name
+      # @param type_owner [#type] A thing for looking up types by name
       # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
       # @return [Class, GraphQL::Schema::NonNull, GraphQL::Schema:List]
       def self.build_type(type_owner, ast_node)
         case ast_node
         when GraphQL::Language::Nodes::TypeName
-          type_owner.get_type(ast_node.name) # rubocop:disable Development/ContextIsPassedCop -- this is a `context` or `warden`, it's already query-aware
+          type_owner.type(ast_node.name) # rubocop:disable Development/ContextIsPassedCop -- this is a `context` or `warden`, it's already query-aware
         when GraphQL::Language::Nodes::NonNullType
           ast_inner_type = ast_node.of_type
           inner_type = build_type(type_owner, ast_inner_type)

data/lib/graphql/schema/union.rb

@@ -11,7 +11,7 @@ module GraphQL
         end
 
         def possible_types(*types, context: GraphQL::Query::NullContext.instance, **options)
-          if types.any?
+          if !types.empty?
             types.each do |t|
               assert_valid_union_member(t)
               type_memberships << type_membership_class.new(self, t, **options)

data/lib/graphql/schema/validator/all_validator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to validate each member of an array value.
+      #
+      # @example validate format of all strings in an array
+      #
+      #   argument :handles, [String],
+      #     validates: { all: { format: { with: /\A[a-z0-9_]+\Z/ } } }
+      #
+      # @example multiple validators can be combined
+      #
+      #   argument :handles, [String],
+      #     validates: { all: { format: { with: /\A[a-z0-9_]+\Z/ }, length: { maximum: 32 } } }
+      #
+      # @example any type can be used
+      #
+      #   argument :choices, [Integer],
+      #     validates: { all: { inclusion: { in: 1..12 } } }
+      #
+      class AllValidator < Validator
+        def initialize(validated:, allow_blank: false, allow_null: false, **validators)
+          super(validated: validated, allow_blank: allow_blank, allow_null: allow_null)
+
+          @validators = Validator.from_config(validated, validators)
+        end
+
+        def validate(object, context, value)
+          return EMPTY_ARRAY if permitted_empty_value?(value)
+
+          all_errors = EMPTY_ARRAY
+
+          value.each do |subvalue|
+            @validators.each do |validator|
+              errors = validator.validate(object, context, subvalue)
+              if errors &&
+                  (errors.is_a?(Array) && errors != EMPTY_ARRAY) ||
+                  (errors.is_a?(String))
+                if all_errors.frozen? # It's empty
+                  all_errors = []
+                end
+                if errors.is_a?(String)
+                  all_errors << errors
+                else
+                  all_errors.concat(errors)
+                end
+              end
+            end
+          end
+
+          unless all_errors.frozen?
+            all_errors.uniq!
+          end
+
+          all_errors
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validator/required_validator.rb

@@ -8,6 +8,13 @@ module GraphQL
       #
       # (This is for specifying mutually exclusive sets of arguments.)
       #
+      # If you use {GraphQL::Schema::Visibility} to hide all the arguments in a `one_of: [..]` set,
+      # then a developer-facing {GraphQL::Error} will be raised during execution. Pass `allow_all_hidden: true` to
+      # skip validation in this case instead.
+      #
+      # This validator also implements `argument ... required: :nullable`. If an argument has `required: :nullable`
+      # but it's hidden with {GraphQL::Schema::Visibility}, then this validator doesn't run.
+      #
       # @example Require exactly one of these arguments
       #
       #   field :update_amount, IngredientAmount, null: false do
@@ -35,34 +42,64 @@ module GraphQL
       #   end
       #
       class RequiredValidator < Validator
-        # @param one_of [Symbol, Array<Symbol>] An argument, or a list of arguments, that represents a valid set of inputs for this field
+        # @param one_of [Array<Symbol>] A list of arguments, exactly one of which is required for this field
+        # @param argument [Symbol] An argument that is required for this field
+        # @param allow_all_hidden [Boolean] If `true`, then this validator won't run if all the `one_of: ...` arguments have been hidden
         # @param message [String]
-        def initialize(one_of: nil, argument: nil, message: "%{validated} has the wrong arguments", **default_options)
+        def initialize(one_of: nil, argument: nil, allow_all_hidden: nil, message: nil, **default_options)
           @one_of = if one_of
             one_of
           elsif argument
-            [argument]
+            [ argument ]
           else
             raise ArgumentError, "`one_of:` or `argument:` must be given in `validates required: {...}`"
           end
+          @allow_all_hidden = allow_all_hidden.nil? ? !!argument : allow_all_hidden
           @message = message
           super(**default_options)
         end
 
-        def validate(_object, _context, value)
-          matched_conditions = 0
+        def validate(_object, context, value)
+          fully_matched_conditions = 0
+          partially_matched_conditions = 0
+
+          visible_keywords = context.types.arguments(@validated).map(&:keyword)
+          no_visible_conditions = true
 
           if !value.nil?
             @one_of.each do |one_of_condition|
               case one_of_condition
               when Symbol
+                if no_visible_conditions && visible_keywords.include?(one_of_condition)
+                  no_visible_conditions = false
+                end
+
                 if value.key?(one_of_condition)
-                  matched_conditions += 1
+                  fully_matched_conditions += 1
                 end
               when Array
-                if one_of_condition.all? { |k| value.key?(k) }
-                  matched_conditions += 1
-                  break
+                any_match = false
+                full_match = true
+
+                one_of_condition.each do |k|
+                  if no_visible_conditions && visible_keywords.include?(k)
+                    no_visible_conditions = false
+                  end
+                  if value.key?(k)
+                    any_match = true
+                  else
+                    full_match = false
+                  end
+                end
+
+                partial_match = !full_match && any_match
+
+                if full_match
+                  fully_matched_conditions += 1
+                end
+
+                if partial_match
+                  partially_matched_conditions += 1
                 end
               else
                 raise ArgumentError, "Unknown one_of condition: #{one_of_condition.inspect}"
@@ -70,11 +107,55 @@ module GraphQL
             end
           end
 
-          if matched_conditions == 1
+          if no_visible_conditions
+            if @allow_all_hidden
+              return nil
+            else
+              raise GraphQL::Error, <<~ERR
+                #{@validated.path} validates `required: ...` but all required arguments were hidden.
+
+                Update your schema definition to allow the client to see some fields or skip validation by adding `required: { ..., allow_all_hidden: true }`
+              ERR
+            end
+          end
+
+          if fully_matched_conditions == 1 && partially_matched_conditions == 0
             nil # OK
           else
-            @message
+            @message || build_message(context)
+          end
+        end
+
+        def build_message(context)
+          argument_definitions = context.types.arguments(@validated)
+
+          required_names = @one_of.map do |arg_keyword|
+            if arg_keyword.is_a?(Array)
+              names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, arg) }
+              names.compact! # hidden arguments are `nil`
+              "(" + names.join(" and ") + ")"
+            else
+              arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
+            end
           end
+          required_names.compact! # remove entries for hidden arguments
+
+
+          case required_names.size
+          when 0
+            # The required definitions were hidden from the client.
+            # Another option here would be to raise an error in the application....
+            "%{validated} is missing a required argument."
+          when 1
+            "%{validated} must include the following argument: #{required_names.first}."
+          else
+            "%{validated} must include exactly one of the following arguments: #{required_names.join(", ")}."
+          end
+        end
+
+        def arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
+          argument_definition = argument_definitions.find { |defn| defn.keyword == arg_keyword }
+          argument_definition&.graphql_name
         end
       end
     end

data/lib/graphql/schema/validator.rb

@@ -143,7 +143,7 @@ module GraphQL
           end
         end
 
-        if all_errors.any?
+        if !all_errors.empty?
           raise ValidationFailedError.new(errors: all_errors)
         end
         nil
@@ -169,3 +169,5 @@ require "graphql/schema/validator/allow_null_validator"
 GraphQL::Schema::Validator.install(:allow_null, GraphQL::Schema::Validator::AllowNullValidator)
 require "graphql/schema/validator/allow_blank_validator"
 GraphQL::Schema::Validator.install(:allow_blank, GraphQL::Schema::Validator::AllowBlankValidator)
+require "graphql/schema/validator/all_validator"
+GraphQL::Schema::Validator.install(:all, GraphQL::Schema::Validator::AllValidator)

data/lib/graphql/schema/visibility/migration.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Visibility
+      # You can use this to see how {GraphQL::Schema::Warden} and {GraphQL::Schema::Visibility::Profile}
+      # handle `.visible?` differently in your schema.
+      #
+      # It runs the same method on both implementations and raises an error when the results diverge.
+      #
+      # To fix the error, modify your schema so that both implementations return the same thing.
+      # Or, open an issue on GitHub to discuss the difference.
+      #
+      # This plugin adds overhead to runtime and may cause unexpected crashes -- **don't** use it in production!
+      #
+      # This plugin adds two keys to `context` when running:
+      #
+      # - `visibility_migration_running: true`
+      # - For the {Schema::Warden} which it instantiates, it adds `visibility_migration_warden_running: true`.
+      #
+      # Use those keys to modify your `visible?` behavior as needed.
+      #
+      # Also, in a pinch, you can set `skip_visibility_migration_error: true` in context to turn off this behavior per-query.
+      # (In that case, it uses {Profile} directly.)
+      #
+      # @example Adding this plugin
+      #
+      #   use GraphQL::Schema::Visibility, migration_errors: true
+      #
+      class Migration < GraphQL::Schema::Visibility::Profile
+        class RuntimeTypesMismatchError < GraphQL::Error
+          def initialize(method_called, warden_result, profile_result, method_args)
+            super(<<~ERR)
+              Mismatch in types for `##{method_called}(#{method_args.map(&:inspect).join(", ")})`:
+
+              #{compare_results(warden_result, profile_result)}
+
+              Update your `.visible?` implementation to make these implementations return the same value.
+
+              See: https://graphql-ruby.org/authorization/visibility_migration.html
+            ERR
+          end
+
+          private
+          def compare_results(warden_result, profile_result)
+            if warden_result.is_a?(Array) && profile_result.is_a?(Array)
+              all_results = warden_result | profile_result
+              all_results.sort_by!(&:graphql_name)
+
+              entries_text = all_results.map { |entry| "#{entry.graphql_name} (#{entry})"}
+              width = entries_text.map(&:size).max
+              yes = "    ✔   "
+              no =  "        "
+              res = "".dup
+              res << "#{"Result".center(width)} Warden  Profile \n"
+              all_results.each_with_index do |entry, idx|
+                res << "#{entries_text[idx].ljust(width)}#{warden_result.include?(entry) ? yes : no}#{profile_result.include?(entry) ? yes : no}\n"
+              end
+              res << "\n"
+            else
+              "- Warden returned: #{humanize(warden_result)}\n\n- Visibility::Profile returned: #{humanize(profile_result)}"
+            end
+          end
+          def humanize(val)
+            case val
+            when Array
+              "#{val.size}: #{val.map { |v| humanize(v) }.sort.inspect}"
+            when Module
+              if val.respond_to?(:graphql_name)
+                "#{val.graphql_name} (#{val.inspect})"
+              else
+                val.inspect
+              end
+            else
+              val.inspect
+            end
+          end
+        end
+
+        def initialize(context:, schema:, name: nil, visibility:)
+          @name = name
+          @skip_error = context[:skip_visibility_migration_error] || context.is_a?(Query::NullContext) || context.is_a?(Hash)
+          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema, visibility: visibility)
+          if !@skip_error
+            context[:visibility_migration_running] = true
+            warden_ctx_vals = context.to_h.dup
+            warden_ctx_vals[:visibility_migration_warden_running] = true
+            if schema.const_defined?(:WardenCompatSchema, false) # don't use a defn from a superclass
+              warden_schema = schema.const_get(:WardenCompatSchema, false)
+            else
+              warden_schema = Class.new(schema)
+              warden_schema.use_visibility_profile = false
+              # TODO public API
+              warden_schema.send(:add_type_and_traverse, [warden_schema.query, warden_schema.mutation, warden_schema.subscription].compact, root: true)
+              warden_schema.send(:add_type_and_traverse, warden_schema.directives.values + warden_schema.orphan_types, root: false)
+              schema.const_set(:WardenCompatSchema, warden_schema)
+            end
+            warden_ctx = GraphQL::Query::Context.new(query: context.query, values: warden_ctx_vals)
+            warden_ctx.warden = GraphQL::Schema::Warden.new(schema: warden_schema, context: warden_ctx)
+            warden_ctx.warden.skip_warning = true
+            warden_ctx.types = @warden_types = warden_ctx.warden.visibility_profile
+          end
+        end
+
+        def loaded_types
+          @profile_types.loaded_types
+        end
+
+        PUBLIC_PROFILE_METHODS = [
+          :enum_values,
+          :interfaces,
+          :all_types,
+          :all_types_h,
+          :fields,
+          :loadable?,
+          :loadable_possible_types,
+          :type,
+          :arguments,
+          :argument,
+          :directive_exists?,
+          :directives,
+          :field,
+          :query_root,
+          :mutation_root,
+          :possible_types,
+          :subscription_root,
+          :reachable_type?,
+          :visible_enum_value?,
+        ]
+
+        PUBLIC_PROFILE_METHODS.each do |profile_method|
+          define_method(profile_method) do |*args|
+            call_method_and_compare(profile_method, args)
+          end
+        end
+
+        def call_method_and_compare(method, args)
+          res_1 = @profile_types.public_send(method, *args)
+          if @skip_error
+            return res_1
+          end
+
+          res_2 = @warden_types.public_send(method, *args)
+          normalized_res_1 = res_1.is_a?(Array) ? Set.new(res_1) : res_1
+          normalized_res_2 = res_2.is_a?(Array) ? Set.new(res_2) : res_2
+          if !equivalent_schema_members?(normalized_res_1, normalized_res_2)
+            # Raise the errors with the orignally returned values:
+            err = RuntimeTypesMismatchError.new(method, res_2, res_1, args)
+            raise err
+          else
+            res_1
+          end
+        end
+
+        def equivalent_schema_members?(member1, member2)
+          if member1.class != member2.class
+            return false
+          end
+
+          case member1
+          when Set
+            member1_array = member1.to_a.sort_by(&:graphql_name)
+            member2_array = member2.to_a.sort_by(&:graphql_name)
+            member1_array.each_with_index do |inner_member1, idx|
+              inner_member2 = member2_array[idx]
+              equivalent_schema_members?(inner_member1, inner_member2)
+            end
+          when GraphQL::Schema::Field
+            member1.ensure_loaded
+            member2.ensure_loaded
+            if member1.introspection? && member2.introspection?
+              member1.inspect == member2.inspect
+            else
+              member1 == member2
+            end
+          when Module
+            if member1.introspection? && member2.introspection?
+              member1.graphql_name == member2.graphql_name
+            else
+              member1 == member2
+            end
+          else
+            member1 == member2
+          end
+        end
+      end
+    end
+  end
+end