graphql 1.11.4 → 1.11.5

data/lib/graphql/schema/directive/deprecated.rb

@@ -4,7 +4,7 @@ module GraphQL
     class Directive < GraphQL::Schema::Member
       class Deprecated < GraphQL::Schema::Directive
         description "Marks an element of a GraphQL schema as no longer supported."
-        locations(GraphQL::Schema::Directive::FIELD_DEFINITION, GraphQL::Schema::Directive::ENUM_VALUE)
+        locations(GraphQL::Schema::Directive::FIELD_DEFINITION, GraphQL::Schema::Directive::ENUM_VALUE, GraphQL::Schema::Directive::ARGUMENT_DEFINITION, GraphQL::Schema::Directive::INPUT_FIELD_DEFINITION)
 
         reason_description = "Explains why this element was deprecated, usually also including a "\
         "suggestion for how to access supported similar data. Formatted "\

data/lib/graphql/schema/field.rb

@@ -203,7 +203,7 @@ module GraphQL
       # @param broadcastable [Boolean] Whether or not this field can be distributed in subscription broadcasts
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -250,7 +250,7 @@ module GraphQL
         method_name = method || hash_key || name_s
         resolver_method ||= name_s.to_sym
 
-        @method_str = method_name.to_s
+        @method_str = -method_name.to_s
         @method_sym = method_name.to_sym
         @resolver_method = resolver_method
         @complexity = complexity
@@ -274,7 +274,7 @@ module GraphQL
           if arg.is_a?(Hash)
             argument(name: name, **arg)
           else
-            own_arguments[name] = arg
+            add_argument(arg)
           end
         end
 
@@ -282,7 +282,7 @@ module GraphQL
         @subscription_scope = subscription_scope
 
         # Do this last so we have as much context as possible when initializing them:
-        @extensions = []
+        @extensions = EMPTY_ARRAY
         if extensions.any?
           self.extensions(extensions)
         end
@@ -343,6 +343,9 @@ module GraphQL
           # Read the value
           @extensions
         else
+          if @extensions.frozen?
+            @extensions = @extensions.dup
+          end
           new_extensions.each do |extension|
             if extension.is_a?(Hash)
               extension = extension.to_a[0]
@@ -380,6 +383,9 @@ module GraphQL
           # Read the value
           @extras
         else
+          if @extras.frozen?
+            @extras = @extras.dup
+          end
           # Append to the set of extras on this field
           @extras.concat(new_extras)
         end

data/lib/graphql/schema/input_object.rb

@@ -126,9 +126,11 @@ module GraphQL
           argument_defn = super(*args, **kwargs, &block)
           # Add a method access
           method_name = argument_defn.keyword
-          define_method(method_name) do
-            self[method_name]
-          end
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
         end
 
         def to_graphql

data/lib/graphql/schema/interface.rb

@@ -30,7 +30,7 @@ module GraphQL
 
         # The interface is accessible if any of its possible types are accessible
         def accessible?(context)
-          context.schema.possible_types(self).each do |type|
+          context.schema.possible_types(self, context).each do |type|
             if context.schema.accessible?(type, context)
               return true
             end

data/lib/graphql/schema/late_bound_type.rb

@@ -16,11 +16,11 @@ module GraphQL
       end
 
       def to_non_null_type
-        GraphQL::NonNullType.new(of_type: self)
+        @to_non_null_type ||= GraphQL::NonNullType.new(of_type: self)
       end
 
       def to_list_type
-        GraphQL::ListType.new(of_type: self)
+        @to_list_type ||= GraphQL::ListType.new(of_type: self)
       end
 
       def inspect

data/lib/graphql/schema/loader.rb

@@ -189,6 +189,7 @@ module GraphQL
             kwargs = {
               type: type_resolver.call(arg["type"]),
               description: arg["description"],
+              deprecation_reason: arg["deprecationReason"],
               required: false,
               method_access: false,
               camelize: false,

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

@@ -4,6 +4,10 @@ module GraphQL
     class Member
       # @api private
       module BuildType
+        if !String.method_defined?(:match?)
+          using GraphQL::StringMatchBackport
+        end
+
         LIST_TYPE_ERROR = "Use an array of [T] or [T, null: true] for list types; other arrays are not supported"
 
         module_function
@@ -162,10 +166,16 @@ module GraphQL
         end
 
         def underscore(string)
-          string
-            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
-            .gsub(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
-            .downcase
+          if string.match?(/\A[a-z_]+\Z/)
+            return string
+          end
+          string2 = string.dup
+
+          string2.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
+          string2.gsub!(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
+          string2.downcase!
+
+          string2
         end
       end
     end

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

@@ -43,6 +43,7 @@ module GraphQL
         # @param arg_defn [GraphQL::Schema::Argument]
         # @return [GraphQL::Schema::Argument]
         def add_argument(arg_defn)
+          @own_arguments ||= {}
           own_arguments[arg_defn.name] = arg_defn
           arg_defn
         end
@@ -229,8 +230,9 @@ module GraphQL
           end
         end
 
+        NO_ARGUMENTS = {}.freeze
         def own_arguments
-          @own_arguments ||= {}
+          @own_arguments || NO_ARGUMENTS
         end
       end
     end

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

@@ -6,12 +6,12 @@ module GraphQL
       module TypeSystemHelpers
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
-          GraphQL::Schema::NonNull.new(self)
+          @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
         end
 
         # @return [Schema::List] Make a list-type representation of this type
         def to_list_type
-          GraphQL::Schema::List.new(self)
+          @to_list_type ||= GraphQL::Schema::List.new(self)
         end
 
         # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -122,7 +122,9 @@ module GraphQL
             graphql_name("#{mutation_name}Input")
             description("Autogenerated input type of #{mutation_name}")
             mutation(mutation_class)
-            own_arguments.merge!(mutation_args)
+            mutation_args.each do |_name, arg|
+              add_argument(arg)
+            end
             argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
           end
         end

data/lib/graphql/schema/timeout.rb

@@ -7,7 +7,7 @@ module GraphQL
     # to the `errors` key. Any already-resolved fields will be in the `data` key, so
     # you'll get a partial response.
     #
-    # You can subclass `GraphQL::Schema::Timeout` and override the `handle_timeout` method
+    # You can subclass `GraphQL::Schema::Timeout` and override `max_seconds` and/or `handle_timeout`
     # to provide custom logic when a timeout error occurs.
     #
     # Note that this will stop a query _in between_ field resolutions, but
@@ -33,8 +33,6 @@ module GraphQL
     #   end
     #
     class Timeout
-      attr_reader :max_seconds
-
       def self.use(schema, **options)
         tracer = new(**options)
         schema.tracer(tracer)
@@ -48,32 +46,39 @@ module GraphQL
       def trace(key, data)
         case key
         when 'execute_multiplex'
-          timeout_state = {
-            timeout_at: Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) + max_seconds * 1000,
-            timed_out: false
-          }
-
           data.fetch(:multiplex).queries.each do |query|
+            timeout_duration_s = max_seconds(query)
+            timeout_state = if timeout_duration_s == false
+              # if the method returns `false`, don't apply a timeout
+              false
+            else
+              now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+              timeout_at = now + (max_seconds(query) * 1000)
+              {
+                timeout_at: timeout_at,
+                timed_out: false
+              }
+            end
             query.context.namespace(self.class)[:state] = timeout_state
           end
 
           yield
         when 'execute_field', 'execute_field_lazy'
-          query = data[:context] ? data.fetch(:context).query : data.fetch(:query)
-          timeout_state = query.context.namespace(self.class).fetch(:state)
-          if Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+          query_context = data[:context] || data[:query].context
+          timeout_state = query_context.namespace(self.class).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)
             error = if data[:context]
-              context = data.fetch(:context)
-              GraphQL::Schema::Timeout::TimeoutError.new(context.parent_type, context.field)
+              GraphQL::Schema::Timeout::TimeoutError.new(query_context.parent_type, query_context.field)
             else
               field = data.fetch(:field)
               GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
             end
 
             # Only invoke the timeout callback for the first timeout
-            unless timeout_state[:timed_out]
+            if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
-              handle_timeout(error, query)
+              handle_timeout(error, query_context.query)
             end
 
             error
@@ -85,6 +90,15 @@ module GraphQL
         end
       end
 
+      # Called at the start of each query.
+      # The default implementation returns the `max_seconds:` value from installing this plugin.
+      #
+      # @param query [GraphQL::Query] The query that's about to run
+      # @return [Integer, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
+      def max_seconds(query)
+        @max_seconds
+      end
+
       # Invoked when a query times out.
       # @param error [GraphQL::Schema::Timeout::TimeoutError]
       # @param query [GraphQL::Error]

data/lib/graphql/schema/validation.rb

@@ -133,6 +133,12 @@ module GraphQL
           end
         }
 
+        DEPRECATED_ARGUMENTS_ARE_OPTIONAL = ->(argument) {
+          if argument.deprecation_reason && argument.type.non_null?
+            "must be optional because it's deprecated"
+          end
+        }
+
         TYPE_IS_VALID_INPUT_TYPE = ->(type) {
           outer_type = type.type
           inner_type = outer_type.respond_to?(:unwrap) ? outer_type.unwrap : nil
@@ -265,8 +271,10 @@ module GraphQL
           Rules::NAME_IS_STRING,
           Rules::RESERVED_NAME,
           Rules::DESCRIPTION_IS_STRING_OR_NIL,
+          Rules.assert_property(:deprecation_reason, String, NilClass),
           Rules::TYPE_IS_VALID_INPUT_TYPE,
           Rules::DEFAULT_VALUE_IS_VALID_FOR_TYPE,
+          Rules::DEPRECATED_ARGUMENTS_ARE_OPTIONAL,
         ],
         GraphQL::BaseType => [
           Rules::NAME_IS_STRING,

data/lib/graphql/static_validation/validator.rb

@@ -32,10 +32,13 @@ module GraphQL
 
             context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
 
-            # Attach legacy-style rules
-            rules_to_use.each do |rule_class_or_module|
-              if rule_class_or_module.method_defined?(:validate)
-                rule_class_or_module.new.validate(context)
+            # Attach legacy-style rules.
+            # Only loop through rules if it has legacy-style rules
+            unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
+              legacy_rules.each do |rule_class_or_module|
+                if rule_class_or_module.method_defined?(:validate)
+                  rule_class_or_module.new.validate(context)
+                end
               end
             end
 

data/lib/graphql/subscriptions.rb

@@ -4,9 +4,7 @@ require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
 require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
-if defined?(ActionCable)
-  require "graphql/subscriptions/action_cable_subscriptions"
-end
+require "graphql/subscriptions/action_cable_subscriptions"
 require "graphql/subscriptions/subscription_root"
 require "graphql/subscriptions/default_subscription_resolve_extension"
 

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -4,7 +4,7 @@ module GraphQL
     # A subscriptions implementation that sends data
     # as ActionCable broadcastings.
     #
-    # Experimental, some things to keep in mind:
+    # Some things to keep in mind:
     #
     # - No queueing system; ActiveJob should be added
     # - Take care to reload context when re-delivering the subscription. (see {Query#subscription_update?})
@@ -86,28 +86,32 @@ module GraphQL
       EVENT_PREFIX = "graphql-event:"
 
       # @param serializer [<#dump(obj), #load(string)] Used for serializing messages before handing them to `.broadcast(msg)`
-      def initialize(serializer: Serialize, **rest)
+      # @param namespace [string] Used to namespace events and subscriptions (default: '')
+      def initialize(serializer: Serialize, namespace: '', action_cable: ActionCable, action_cable_coder: ActiveSupport::JSON, **rest)
         # A per-process map of subscriptions to deliver.
         # This is provided by Rails, so let's use it
         @subscriptions = Concurrent::Map.new
         @events = Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new { |h2, k2| h2[k2] = Concurrent::Array.new } }
+        @action_cable = action_cable
+        @action_cable_coder = action_cable_coder
         @serializer = serializer
+        @transmit_ns = namespace
         super
       end
 
       # An event was triggered; Push the data over ActionCable.
       # Subscribers will re-evaluate locally.
       def execute_all(event, object)
-        stream = EVENT_PREFIX + event.topic
+        stream = stream_event_name(event)
         message = @serializer.dump(object)
-        ActionCable.server.broadcast(stream, message)
+        @action_cable.server.broadcast(stream, message)
       end
 
       # This subscription was re-evaluated.
       # Send it to the specific stream where this client was waiting.
       def deliver(subscription_id, result)
         payload = { result: result.to_h, more: true }
-        ActionCable.server.broadcast(SUBSCRIPTION_PREFIX + subscription_id, payload)
+        @action_cable.server.broadcast(stream_subscription_name(subscription_id), payload)
       end
 
       # A query was run where these events were subscribed to.
@@ -117,7 +121,7 @@ module GraphQL
       def write_subscription(query, events)
         channel = query.context.fetch(:channel)
         subscription_id = query.context[:subscription_id] ||= build_id
-        stream = query.context[:action_cable_stream] ||= SUBSCRIPTION_PREFIX + subscription_id
+        stream = stream_subscription_name(subscription_id)
         channel.stream_from(stream)
         @subscriptions[subscription_id] = query
         events.each do |event|
@@ -141,7 +145,7 @@ module GraphQL
       #
       def setup_stream(channel, initial_event)
         topic = initial_event.topic
-        channel.stream_from(EVENT_PREFIX + topic, coder: ActiveSupport::JSON) do |message|
+        channel.stream_from(stream_event_name(initial_event), coder: @action_cable_coder) do |message|
           object = @serializer.load(message)
           events_by_fingerprint = @events[topic]
           events_by_fingerprint.each do |_fingerprint, events|
@@ -197,6 +201,16 @@ module GraphQL
           end
         end
       end
+
+      private
+
+      def stream_subscription_name(subscription_id)
+        [SUBSCRIPTION_PREFIX, @transmit_ns, subscription_id].join
+      end
+
+      def stream_event_name(event)
+        [EVENT_PREFIX, @transmit_ns, event.topic].join
+      end
     end
   end
 end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.11.4"
+  VERSION = "1.11.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.11.4
+  version: 1.11.5
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-25 00:00:00.000000000 Z
+date: 2020-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips