graphql 1.10.13 → 1.11.3

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module GraphQL
+  class Subscriptions
+    class DefaultSubscriptionResolveExtension < GraphQL::Subscriptions::SubscriptionRoot::Extension
+      def resolve(context:, object:, arguments:)
+        has_override_implementation = @field.resolver ||
+          object.respond_to?(@field.resolver_method)
+
+        if !has_override_implementation
+          if context.query.subscription_update?
+            object.object
+          else
+            context.skip
+          end
+        else
+          yield(object, arguments)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions/event.rb

@@ -6,7 +6,6 @@ module GraphQL
     # - Subscribed to by `subscription { ... }`
     # - Triggered by `MySchema.subscriber.trigger(name, arguments, obj)`
     #
-    # An array of `Event`s are passed to `store.register(query, events)`.
     class Event
       # @return [String] Corresponds to the Subscription root field name
       attr_reader :name
@@ -53,6 +52,22 @@ module GraphQL
         Serialize.dump_recursive([scope, name, sorted_h])
       end
 
+      # @return [String] a logical identifier for this event. (Stable when the query is broadcastable.)
+      def fingerprint
+        @fingerprint ||= begin
+          # When this query has been flagged as broadcastable,
+          # use a generalized, stable fingerprint so that
+          # duplicate subscriptions can be evaluated and distributed in bulk.
+          # (`@topic` includes field, args, and subscription scope already.)
+          if @context.namespace(:subscriptions)[:subscription_broadcastable]
+            "#{@topic}/#{@context.query.fingerprint}"
+          else
+            # not broadcastable, build a unique ID for this event
+            @context.schema.subscriptions.build_id
+          end
+        end
+      end
+
       class << self
         private
         def stringify_args(arg_owner, args)

data/lib/graphql/subscriptions/serialize.rb

@@ -9,6 +9,9 @@ module GraphQL
       GLOBALID_KEY = "__gid__"
       SYMBOL_KEY = "__sym__"
       SYMBOL_KEYS_KEY = "__sym_keys__"
+      TIMESTAMP_KEY = "__timestamp__"
+      TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S.%N%Z" # eg '2020-01-01 23:59:59.123456789+05:00'
+      OPEN_STRUCT_KEY = "__ostruct__"
 
       module_function
 
@@ -55,10 +58,20 @@ module GraphQL
           if value.is_a?(Array)
             value.map{|item| load_value(item)}
           elsif value.is_a?(Hash)
-            if value.size == 1 && value.key?(GLOBALID_KEY)
-              GlobalID::Locator.locate(value[GLOBALID_KEY])
-            elsif value.size == 1 && value.key?(SYMBOL_KEY)
-              value[SYMBOL_KEY].to_sym
+            if value.size == 1
+              case value.keys.first # there's only 1 key
+              when GLOBALID_KEY
+                GlobalID::Locator.locate(value[GLOBALID_KEY])
+              when SYMBOL_KEY
+                value[SYMBOL_KEY].to_sym
+              when TIMESTAMP_KEY
+                timestamp_class_name, timestamp_s = value[TIMESTAMP_KEY]
+                timestamp_class = Object.const_get(timestamp_class_name)
+                timestamp_class.strptime(timestamp_s, TIMESTAMP_FORMAT)
+              when OPEN_STRUCT_KEY
+                ostruct_values = load_value(value[OPEN_STRUCT_KEY])
+                OpenStruct.new(ostruct_values)
+              end
             else
               loaded_h = {}
               sym_keys = value.fetch(SYMBOL_KEYS_KEY, [])
@@ -101,6 +114,11 @@ module GraphQL
             { SYMBOL_KEY => obj.to_s }
           elsif obj.respond_to?(:to_gid_param)
             {GLOBALID_KEY => obj.to_gid_param}
+          elsif obj.is_a?(Date) || obj.is_a?(Time)
+            # DateTime extends Date; for TimeWithZone, call `.utc` first.
+            { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
+          elsif obj.is_a?(OpenStruct)
+            { OPEN_STRUCT_KEY => dump_value(obj.to_h) }
           else
             obj
           end

data/lib/graphql/subscriptions/subscription_root.rb

@@ -2,9 +2,11 @@
 
 module GraphQL
   class Subscriptions
-    # Extend this module in your subscription root when using {GraphQL::Execution::Interpreter}.
+    # @api private
+    # @deprecated This module is no longer needed.
     module SubscriptionRoot
       def self.extended(child_cls)
+        warn "`extend GraphQL::Subscriptions::SubscriptionRoot` is no longer required; you can remove it from your Subscription type (#{child_cls})"
         child_cls.include(InstanceMethods)
       end
 

data/lib/graphql/tracing.rb

@@ -7,6 +7,7 @@ require "graphql/tracing/data_dog_tracing"
 require "graphql/tracing/new_relic_tracing"
 require "graphql/tracing/scout_tracing"
 require "graphql/tracing/skylight_tracing"
+require "graphql/tracing/statsd_tracing"
 require "graphql/tracing/prometheus_tracing"
 
 if defined?(PrometheusExporter::Server)
@@ -16,8 +17,6 @@ end
 module GraphQL
   # Library entry point for performance metric reporting.
   #
-  # __Warning:__ Installing/uninstalling tracers is not thread-safe. Do it during application boot only.
-  #
   # @example Sending custom events
   #   query.trace("my_custom_event", { ... }) do
   #     # do stuff ...
@@ -86,31 +85,6 @@ module GraphQL
       end
     end
 
-    class << self
-      # Install a tracer to receive events.
-      # @param tracer [<#trace(key, metadata)>]
-      # @return [void]
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def install(tracer)
-        warn("GraphQL::Tracing.install is deprecated, add it to the schema with `tracer(my_tracer)` instead.")
-        if !tracers.include?(tracer)
-          @tracers << tracer
-        end
-      end
-
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def uninstall(tracer)
-        @tracers.delete(tracer)
-      end
-
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def tracers
-        @tracers ||= []
-      end
-    end
-    # Initialize the array
-    tracers
-
     module NullTracer
       module_function
       def trace(k, v)

data/lib/graphql/tracing/platform_tracing.rb

@@ -32,17 +32,19 @@ module GraphQL
             trace_field = true # implemented with instrumenter
           else
             field = data[:field]
-            cache = platform_key_cache(data.fetch(:query).context)
-            platform_key = cache.fetch(field) do
-              cache[field] = platform_field_key(data[:owner], field)
-            end
-
             return_type = field.type.unwrap
             trace_field = if return_type.kind.scalar? || return_type.kind.enum?
               (field.trace.nil? && @trace_scalars) || field.trace
             else
               true
             end
+
+            platform_key = if trace_field
+              context = data.fetch(:query).context
+              cached_platform_key(context, field) { platform_field_key(data[:owner], field) }
+            else
+              nil
+            end
           end
 
           if platform_key && trace_field
@@ -53,20 +55,16 @@ module GraphQL
             yield
           end
         when "authorized", "authorized_lazy"
-          cache = platform_key_cache(data.fetch(:context))
           type = data.fetch(:type)
-          platform_key = cache.fetch(type) do
-            cache[type] = platform_authorized_key(type)
-          end
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type) { platform_authorized_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
         when "resolve_type", "resolve_type_lazy"
-          cache = platform_key_cache(data.fetch(:context))
           type = data.fetch(:type)
-          platform_key = cache.fetch(type) do
-            cache[type] = platform_resolve_type_key(type)
-          end
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type) { platform_resolve_type_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
@@ -119,8 +117,20 @@ module GraphQL
 
       attr_reader :options
 
-      def platform_key_cache(ctx)
-        ctx.namespace(self.class)[:platform_key_cache] ||= {}
+      # Different kind of schema objects have different kinds of keys:
+      #
+      # - Object types: `.authorized`
+      # - Union/Interface types: `.resolve_type`
+      # - Fields: execution
+      #
+      # So, they can all share one cache.
+      #
+      # If the key isn't present, the given block is called and the result is cached for `key`.
+      #
+      # @return [String]
+      def cached_platform_key(ctx, key)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+        cache.fetch(key) { cache[key] = yield }
       end
     end
   end

data/lib/graphql/tracing/statsd_tracing.rb

@@ -11,7 +11,7 @@ module GraphQL
         'analyze_multiplex' => "graphql.analyze_multiplex",
         'execute_multiplex' => "graphql.execute_multiplex",
         'execute_query' => "graphql.execute_query",
-        'execute_query_lazy' => "graphql.execute_query",
+        'execute_query_lazy' => "graphql.execute_query_lazy",
       }
 
       # @param statsd [Object] A statsd client
@@ -20,23 +20,23 @@ module GraphQL
         super(**rest)
       end
 
-
-    def platform_trace(platform_key, key, data)
-      @statsd.time(platform_key) do
-        yield
+      def platform_trace(platform_key, key, data)
+        @statsd.time(platform_key) do
+          yield
+        end
       end
-    end
 
-    def platform_field_key(type, field)
-      "graphql.#{type.graphql_name}.#{field.graphql_name}"
-    end
+      def platform_field_key(type, field)
+        "graphql.#{type.graphql_name}.#{field.graphql_name}"
+      end
 
-    def platform_authorized_key(type)
-      "graphql.authorized.#{type.graphql_name}"
-    end
+      def platform_authorized_key(type)
+        "graphql.authorized.#{type.graphql_name}"
+      end
 
-    def platform_resolve_type_key(type)
-      "graphql.resolve_type.#{type.graphql_name}"
+      def platform_resolve_type_key(type)
+        "graphql.resolve_type.#{type.graphql_name}"
+      end
     end
   end
 end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.13
+  version: 1.11.3
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-16 00:00:00.000000000 Z
+date: 2020-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -681,6 +681,8 @@ files:
 - lib/graphql/string_type.rb
 - lib/graphql/subscriptions.rb
 - lib/graphql/subscriptions/action_cable_subscriptions.rb
+- lib/graphql/subscriptions/broadcast_analyzer.rb
+- lib/graphql/subscriptions/default_subscription_resolve_extension.rb
 - lib/graphql/subscriptions/event.rb
 - lib/graphql/subscriptions/instrumentation.rb
 - lib/graphql/subscriptions/serialize.rb