graphql_cody 1.13.0

data/lib/graphql/subscriptions/serialize.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+require "set"
+module GraphQL
+  class Subscriptions
+    # Serialization helpers for passing subscription data around.
+    # @api private
+    module Serialize
+      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
+
+      # @param str [String] A serialized object from {.dump}
+      # @return [Object] An object equivalent to the one passed to {.dump}
+      def load(str)
+        parsed_obj = JSON.parse(str)
+        load_value(parsed_obj)
+      end
+
+      # @param obj [Object] Some subscription-related data to dump
+      # @return [String] The stringified object
+      def dump(obj)
+        JSON.generate(dump_value(obj), quirks_mode: true)
+      end
+
+      # This is for turning objects into subscription scopes.
+      # It's a one-way transformation, can't reload this :'(
+      # @param obj [Object]
+      # @return [String]
+      def dump_recursive(obj)
+        case
+        when obj.is_a?(Array)
+          obj.map { |i| dump_recursive(i) }.join(':')
+        when obj.is_a?(Hash)
+          obj.map { |k, v| "#{dump_recursive(k)}:#{dump_recursive(v)}" }.join(":")
+        when obj.is_a?(GraphQL::Schema::InputObject)
+          dump_recursive(obj.to_h)
+        when obj.respond_to?(:to_gid_param)
+          obj.to_gid_param
+        when obj.respond_to?(:to_param)
+          obj.to_param
+        else
+          obj.to_s
+        end
+      end
+
+      class << self
+        private
+
+        # @param value [Object] A parsed JSON object
+        # @return [Object] An object that load Global::Identification recursive
+        def load_value(value)
+          if value.is_a?(Array)
+            is_gids = (v1 = value[0]).is_a?(Hash) && v1.size == 1 && v1[GLOBALID_KEY]
+            if is_gids
+              # Assume it's an array of global IDs
+              ids = value.map { |v| v[GLOBALID_KEY] }
+              GlobalID::Locator.locate_many(ids)
+            else
+              value.map { |item| load_value(item) }
+            end
+          elsif value.is_a?(Hash)
+            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)
+              else
+                key = value.keys.first
+                { key => load_value(value[key]) }
+              end
+            else
+              loaded_h = {}
+              sym_keys = value.fetch(SYMBOL_KEYS_KEY, [])
+              value.each do |k, v|
+                if k == SYMBOL_KEYS_KEY
+                  next
+                end
+                if sym_keys.include?(k)
+                  k = k.to_sym
+                end
+                loaded_h[k] = load_value(v)
+              end
+              loaded_h
+            end
+          else
+            value
+          end
+        end
+
+        # @param obj [Object] Some subscription-related data to dump
+        # @return [Object] The object that converted Global::Identification
+        def dump_value(obj)
+          if obj.is_a?(Array)
+            obj.map{|item| dump_value(item)}
+          elsif obj.is_a?(Hash)
+            symbol_keys = nil
+            dumped_h = {}
+            obj.each do |k, v|
+              dumped_h[k.to_s] = dump_value(v)
+              if k.is_a?(Symbol)
+                symbol_keys ||= Set.new
+                symbol_keys << k.to_s
+              end
+            end
+            if symbol_keys
+              dumped_h[SYMBOL_KEYS_KEY] = symbol_keys.to_a
+            end
+            dumped_h
+          elsif obj.is_a?(Symbol)
+            { 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
+        end
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions/subscription_root.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Subscriptions
+    # @api private
+    # @deprecated This module is no longer needed.
+    module SubscriptionRoot
+      def self.extended(child_cls)
+        GraphQL::Deprecation.warn "`extend GraphQL::Subscriptions::SubscriptionRoot` is no longer required; you can remove it from your Subscription type (#{child_cls})"
+        child_cls.include(InstanceMethods)
+      end
+
+      # This is for maintaining backwards compatibility:
+      # if a subscription field is created without a `subscription:` resolver class,
+      # then implement the method with the previous default behavior.
+      module InstanceMethods
+        def skip_subscription_root(*)
+          if context.query.subscription_update?
+            object
+          else
+            context.skip
+          end
+        end
+      end
+
+      def field(*args, extensions: [], **rest, &block)
+        extensions += [Extension]
+        # Backwards-compat for schemas
+        if !rest[:subscription]
+          name = args.first
+          alias_method(name, :skip_subscription_root)
+        end
+        super(*args, extensions: extensions, **rest, &block)
+      end
+
+      class Extension < GraphQL::Schema::FieldExtension
+        def after_resolve(value:, context:, object:, arguments:, **rest)
+          if value.is_a?(GraphQL::ExecutionError)
+            value
+          elsif (events = context.namespace(:subscriptions)[:events])
+            # This is the first execution, so gather an Event
+            # for the backend to register:
+            event = Subscriptions::Event.new(
+              name: field.name,
+              arguments: arguments_without_field_extras(arguments: arguments),
+              context: context,
+              field: field,
+            )
+            events << event
+            value
+          elsif context.query.subscription_topic == Subscriptions::Event.serialize(
+              field.name,
+              arguments_without_field_extras(arguments: arguments),
+              field,
+              scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
+            )
+            # This is a subscription update. The resolver returned `skip` if it should be skipped,
+            # or else it returned an object to resolve the update.
+            value
+          else
+            # This is a subscription update, but this event wasn't triggered.
+            context.skip
+          end
+        end
+
+        private
+
+        def arguments_without_field_extras(arguments:)
+          arguments.dup.tap do |event_args|
+            field.extras.each { |k| event_args.delete(k) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+require "securerandom"
+require "graphql/subscriptions/broadcast_analyzer"
+require "graphql/subscriptions/event"
+require "graphql/subscriptions/instrumentation"
+require "graphql/subscriptions/serialize"
+require "graphql/subscriptions/action_cable_subscriptions"
+require "graphql/subscriptions/subscription_root"
+require "graphql/subscriptions/default_subscription_resolve_extension"
+
+module GraphQL
+  class Subscriptions
+    # Raised when either:
+    # - the triggered `event_name` doesn't match a field in the schema; or
+    # - one or more arguments don't match the field arguments
+    class InvalidTriggerError < GraphQL::Error
+    end
+
+    # Raised when either:
+    # - An initial subscription didn't have a value for `context[subscription_scope]`
+    # - Or, an update didn't pass `.trigger(..., scope:)`
+    # When raised, the initial subscription or update fails completely.
+    class SubscriptionScopeMissingError < GraphQL::Error
+    end
+
+    # @see {Subscriptions#initialize} for options, concrete implementations may add options.
+    def self.use(defn, options = {})
+      schema = defn.is_a?(Class) ? defn : defn.target
+
+      if schema.subscriptions
+        raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
+      end
+
+      instrumentation = Subscriptions::Instrumentation.new(schema: schema)
+      defn.instrument(:query, instrumentation)
+      if !schema.is_a?(Class)
+        defn.instrument(:field, instrumentation)
+      end
+      options[:schema] = schema
+      schema.subscriptions = self.new(**options)
+      schema.add_subscription_extension_if_necessary
+      nil
+    end
+
+    # @param schema [Class] the GraphQL schema this manager belongs to
+    def initialize(schema:, broadcast: false, default_broadcastable: false, **rest)
+      if broadcast
+        if !schema.using_ast_analysis?
+          raise ArgumentError, "`broadcast: true` requires AST analysis, add `using GraphQL::Analysis::AST` to your schema or see https://graphql-ruby.org/queries/ast_analysis.html."
+        end
+        schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
+      end
+      @default_broadcastable = default_broadcastable
+      @schema = schema
+    end
+
+    # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
+    attr_reader :default_broadcastable
+
+    # Fetch subscriptions matching this field + arguments pair
+    # And pass them off to the queue.
+    # @param event_name [String]
+    # @param args [Hash<String, Symbol => Object]
+    # @param object [Object]
+    # @param scope [Symbol, String]
+    # @return [void]
+    def trigger(event_name, args, object, scope: nil)
+      event_name = event_name.to_s
+
+      # Try with the verbatim input first:
+      field = @schema.get_field(@schema.subscription, event_name)
+
+      if field.nil?
+        # And if it wasn't found, normalize it:
+        normalized_event_name = normalize_name(event_name)
+        field = @schema.get_field(@schema.subscription, normalized_event_name)
+        if field.nil?
+          raise InvalidTriggerError, "No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
+        end
+      else
+        # Since we found a field, the original input was already normalized
+        normalized_event_name = event_name
+      end
+
+      # Normalize symbol-keyed args to strings, try camelizing them
+      # Should this accept a real context somehow?
+      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext)
+
+      event = Subscriptions::Event.new(
+        name: normalized_event_name,
+        arguments: normalized_args,
+        field: field,
+        scope: scope,
+      )
+      execute_all(event, object)
+    end
+
+    # `event` was triggered on `object`, and `subscription_id` was subscribed,
+    # so it should be updated.
+    #
+    # Load `subscription_id`'s GraphQL data, re-evaluate the query and return the result.
+    #
+    # @param subscription_id [String]
+    # @param event [GraphQL::Subscriptions::Event] The event which was triggered
+    # @param object [Object] The value for the subscription field
+    # @return [GraphQL::Query::Result]
+    def execute_update(subscription_id, event, object)
+      # Lookup the saved data for this subscription
+      query_data = read_subscription(subscription_id)
+      if query_data.nil?
+        delete_subscription(subscription_id)
+        return nil
+      end
+
+      # Fetch the required keys from the saved data
+      query_string = query_data.fetch(:query_string)
+      variables = query_data.fetch(:variables)
+      context = query_data.fetch(:context)
+      operation_name = query_data.fetch(:operation_name)
+      result = @schema.execute(
+        query: query_string,
+        context: context,
+        subscription_topic: event.topic,
+        operation_name: operation_name,
+        variables: variables,
+        root_value: object,
+      )
+      subscriptions_context = result.context.namespace(:subscriptions)
+      if subscriptions_context[:no_update]
+        result = nil
+      end
+
+      unsubscribed = subscriptions_context[:unsubscribed]
+
+      if unsubscribed
+        # `unsubscribe` was called, clean up on our side
+        # TODO also send `{more: false}` to client?
+        delete_subscription(subscription_id)
+        result = nil
+      end
+
+      result
+    end
+
+    # Run the update query for this subscription and deliver it
+    # @see {#execute_update}
+    # @see {#deliver}
+    # @return [void]
+    def execute(subscription_id, event, object)
+      res = execute_update(subscription_id, event, object)
+      if !res.nil?
+        deliver(subscription_id, res)
+      end
+    end
+
+    # Event `event` occurred on `object`,
+    # Update all subscribers.
+    # @param event [Subscriptions::Event]
+    # @param object [Object]
+    # @return [void]
+    def execute_all(event, object)
+      raise GraphQL::RequiredImplementationMissingError
+    end
+
+    # The system wants to send an update to this subscription.
+    # Read its data and return it.
+    # @param subscription_id [String]
+    # @return [Hash] Containing required keys
+    def read_subscription(subscription_id)
+      raise GraphQL::RequiredImplementationMissingError
+    end
+
+    # A subscription query was re-evaluated, returning `result`.
+    # The result should be send to `subscription_id`.
+    # @param subscription_id [String]
+    # @param result [Hash]
+    # @return [void]
+    def deliver(subscription_id, result)
+      raise GraphQL::RequiredImplementationMissingError
+    end
+
+    # `query` was executed and found subscriptions to `events`.
+    # Update the database to reflect this new state.
+    # @param query [GraphQL::Query]
+    # @param events [Array<GraphQL::Subscriptions::Event>]
+    # @return [void]
+    def write_subscription(query, events)
+      raise GraphQL::RequiredImplementationMissingError
+    end
+
+    # A subscription was terminated server-side.
+    # Clean up the database.
+    # @param subscription_id [String]
+    # @return void.
+    def delete_subscription(subscription_id)
+      raise GraphQL::RequiredImplementationMissingError
+    end
+
+    # @return [String] A new unique identifier for a subscription
+    def build_id
+      SecureRandom.uuid
+    end
+
+    # Convert a user-provided event name or argument
+    # to the equivalent in GraphQL.
+    #
+    # By default, it converts the identifier to camelcase.
+    # Override this in a subclass to change the transformation.
+    #
+    # @param event_or_arg_name [String, Symbol]
+    # @return [String]
+    def normalize_name(event_or_arg_name)
+      Schema::Member::BuildType.camelize(event_or_arg_name.to_s)
+    end
+
+    # @return [Boolean] if true, then a query like this one would be broadcasted
+    def broadcastable?(query_str, **query_options)
+      query = GraphQL::Query.new(@schema, query_str, **query_options)
+      if !query.valid?
+        raise "Invalid query: #{query.validation_errors.map(&:to_h).inspect}"
+      end
+      GraphQL::Analysis::AST.analyze_query(query, @schema.query_analyzers)
+      query.context.namespace(:subscriptions)[:subscription_broadcastable]
+    end
+
+    private
+
+    # Recursively normalize `args` as belonging to `arg_owner`:
+    # - convert symbols to strings,
+    # - if needed, camelize the string (using {#normalize_name})
+    # @param arg_owner [GraphQL::Field, GraphQL::BaseType]
+    # @param args [Hash, Array, Any] some GraphQL input value to coerce as `arg_owner`
+    # @return [Any] normalized arguments value
+    def normalize_arguments(event_name, arg_owner, args, context)
+      case arg_owner
+      when GraphQL::Field, GraphQL::InputObjectType, GraphQL::Schema::Field, Class
+        if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
+          # it's a type, but not an input object
+          return args
+        end
+        normalized_args = {}
+        missing_arg_names = []
+        args.each do |k, v|
+          arg_name = k.to_s
+          arg_defn = arg_owner.get_argument(arg_name, context)
+          if arg_defn
+            normalized_arg_name = arg_name
+          else
+            normalized_arg_name = normalize_name(arg_name)
+            arg_defn = arg_owner.get_argument(normalized_arg_name, context)
+          end
+
+          if arg_defn
+            if arg_defn.loads
+              normalized_arg_name = arg_defn.keyword.to_s
+            end
+            normalized = normalize_arguments(event_name, arg_defn.type, v, context)
+            normalized_args[normalized_arg_name] = normalized
+          else
+            # Couldn't find a matching argument definition
+            missing_arg_names << arg_name
+          end
+        end
+
+        # Backfill default values so that trigger arguments
+        # match query arguments.
+        arg_owner.arguments(context).each do |_name, arg_defn|
+          if arg_defn.default_value? && !normalized_args.key?(arg_defn.name)
+            default_value = arg_defn.default_value
+            # We don't have an underlying "object" here, so it can't call methods.
+            # This is broken.
+            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: context)
+          end
+        end
+
+        if missing_arg_names.any?
+          arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
+            "Subscription.#{arg_owner.name}"
+          elsif arg_owner.is_a?(GraphQL::Schema::Field)
+            arg_owner.path
+          elsif arg_owner.is_a?(Class)
+            arg_owner.graphql_name
+          else
+            arg_owner.to_s
+          end
+          raise InvalidTriggerError, "Can't trigger Subscription.#{event_name}, received undefined arguments: #{missing_arg_names.join(", ")}. (Should match arguments of #{arg_owner_name}.)"
+        end
+
+        normalized_args
+      when GraphQL::ListType, GraphQL::Schema::List
+        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
+      when GraphQL::NonNullType, GraphQL::Schema::NonNull
+        normalize_arguments(event_name, arg_owner.of_type, args, context)
+      else
+        args
+      end
+    end
+  end
+end

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to ActiveSupport::Notifications
+    # with a `graphql` suffix.
+    #
+    # @see KEYS for event names
+    module ActiveSupportNotificationsTracing
+      # A cache of frequently-used keys to avoid needless string allocations
+      KEYS = {
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_multiplex" => "analyze_multiplex.graphql",
+        "analyze_query" => "analyze_query.graphql",
+        "execute_query" => "execute_query.graphql",
+        "execute_query_lazy" => "execute_query_lazy.graphql",
+        "execute_field" => "execute_field.graphql",
+        "execute_field_lazy" => "execute_field_lazy.graphql",
+        "authorized" => "authorized.graphql",
+        "authorized_lazy" => "authorized_lazy.graphql",
+        "resolve_type" => "resolve_type.graphql",
+        "resolve_type_lazy" => "resolve_type.graphql",
+      }
+
+      def self.trace(key, metadata)
+        prefixed_key = KEYS[key] || "#{key}.graphql"
+        ActiveSupport::Notifications.instrument(prefixed_key, metadata) do
+          yield
+        end
+      end
+    end
+  end
+end