graphql 1.8.0 → 1.12.12

data/lib/graphql/static_validation/validator.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "timeout"
+
 module GraphQL
   module StaticValidation
     # Initialized with a {GraphQL::Schema}, then it can validate {GraphQL::Language::Nodes::Documents}s based on that schema.
@@ -20,33 +22,71 @@ module GraphQL
 
       # Validate `query` against the schema. Returns an array of message hashes.
       # @param query [GraphQL::Query]
+      # @param validate [Boolean]
+      # @param timeout [Float] Number of seconds to wait before aborting validation. Any positive number may be used, including Floats to specify fractional seconds.
       # @return [Array<Hash>]
-      def validate(query, validate: true)
+      def validate(query, validate: true, timeout: nil)
         query.trace("validate", { validate: validate, query: query }) do
-          context = GraphQL::StaticValidation::ValidationContext.new(query)
-          rewrite = GraphQL::InternalRepresentation::Rewrite.new
+          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
+          errors = if validate == false && can_skip_rewrite
+            []
+          else
+            rules_to_use = validate ? @rules : []
+            visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
+
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
 
-          # Put this first so its enters and exits are always called
-          rewrite.validate(context)
+            begin
+              # CAUTION: Usage of the timeout module makes the assumption that validation rules are stateless Ruby code that requires no cleanup if process was interrupted. This means no blocking IO calls, native gems, locks, or `rescue` clauses that must be reached.
+              # A timeout value of 0 or nil will execute the block without any timeout.
+              Timeout::timeout(timeout) do
+                # 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)
+                      GraphQL::Deprecation.warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
+                      GraphQL::Deprecation.warn "  -> Legacy validator: #{rule_class_or_module}"
+                      rule_class_or_module.new.validate(context)
+                    end
+                  end
+                end
 
-          # If the caller opted out of validation, don't attach these
-          if validate
-            @rules.each do |rules|
-              rules.new.validate(context)
+                context.visitor.visit
+              end
+            rescue Timeout::Error
+              handle_timeout(query, context)
             end
+
+            context.errors
           end
 
-          context.visitor.visit
-          # Post-validation: allow validators to register handlers on rewritten query nodes
-          rewrite_result = rewrite.document
-          GraphQL::InternalRepresentation::Visit.visit_each_node(rewrite_result.operation_definitions, context.each_irep_node_handlers)
+          irep = if errors.empty? && context
+            # Only return this if there are no errors and validation was actually run
+            context.visitor.rewrite_document
+          else
+            nil
+          end
 
           {
-            errors: context.errors,
-            # If there were errors, the irep is garbage
-            irep: context.errors.any? ? nil : rewrite_result,
+            errors: errors,
+            irep: irep,
           }
         end
+      rescue GraphQL::ExecutionError => e
+        {
+          errors: [e],
+          irep: nil,
+        }
+      end
+
+      # Invoked when static validation times out.
+      # @param query [GraphQL::Query]
+      # @param context [GraphQL::StaticValidation::ValidationContext]
+      def handle_timeout(query, context)
+        context.errors << GraphQL::StaticValidation::ValidationTimeoutError.new(
+          "Timeout on validation of query"
+        )
       end
     end
   end

data/lib/graphql/static_validation.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
-require "graphql/static_validation/message"
-require "graphql/static_validation/arguments_validator"
+require "graphql/static_validation/error"
 require "graphql/static_validation/definition_dependencies"
 require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"
+require "graphql/static_validation/validation_timeout_error"
 require "graphql/static_validation/literal_validator"
-
+require "graphql/static_validation/base_visitor"
+require "graphql/static_validation/no_validate_visitor"
 
 rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)
 Dir.glob(rules_glob).each do |file|
@@ -14,3 +15,5 @@ Dir.glob(rules_glob).each do |file|
 end
 
 require "graphql/static_validation/all_rules"
+require "graphql/static_validation/default_visitor"
+require "graphql/static_validation/interpreter_visitor"

data/lib/graphql/string_type.rb

@@ -1,18 +1,2 @@
 # frozen_string_literal: true
-GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
-  name "String"
-  description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
-
-  coerce_result ->(value, ctx) {
-    begin
-      str = value.to_s
-      str.encoding == Encoding::UTF_8 ? str : str.encode(Encoding::UTF_8)
-    rescue EncodingError
-      err = GraphQL::StringEncodingError.new(str)
-      ctx.schema.type_error(err, ctx)
-    end
-  }
-
-  coerce_input ->(value, _ctx) { value.is_a?(String) ? value : nil }
-  default_scalar true
-end
+GraphQL::STRING_TYPE = GraphQL::Types::String.graphql_definition

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -4,13 +4,14 @@ 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?})
+    # - Avoid the async ActionCable adapter and use the redis or PostgreSQL adapters instead. Otherwise calling #trigger won't work from background jobs or the Rails console.
     #
     # @example Adding ActionCableSubscriptions to your schema
-    #   MySchema = GraphQL::Schema.define do
+    #   class MySchema < GraphQL::Schema
     #     # ...
     #     use GraphQL::Subscriptions::ActionCableSubscriptions
     #   end
@@ -26,27 +27,29 @@ module GraphQL
     #       variables = ensure_hash(data["variables"])
     #       operation_name = data["operationName"]
     #       context = {
-    #         current_user: current_user,
+    #         # Re-implement whatever context methods you need
+    #         # in this channel or ApplicationCable::Channel
+    #         # current_user: current_user,
     #         # Make sure the channel is in the context
     #         channel: self,
     #       }
     #
-    #       result = MySchema.execute({
+    #       result = MySchema.execute(
     #         query: query,
     #         context: context,
     #         variables: variables,
     #         operation_name: operation_name
-    #       })
+    #       )
     #
     #       payload = {
-    #         result: result.subscription? ? {data: nil} : result.to_h,
+    #         result: result.to_h,
     #         more: result.subscription?,
     #       }
     #
     #       # Track the subscription here so we can remove it
     #       # on unsubscribe.
     #       if result.context[:subscription_id]
-    #         @subscription_ids << context[:subscription_id]
+    #         @subscription_ids << result.context[:subscription_id]
     #       end
     #
     #       transmit(payload)
@@ -54,9 +57,28 @@ module GraphQL
     #
     #     def unsubscribed
     #       @subscription_ids.each { |sid|
-    #         CardsSchema.subscriptions.delete_subscription(sid)
+    #         MySchema.subscriptions.delete_subscription(sid)
     #       }
     #     end
+    #
+    #     private
+    #
+    #       def ensure_hash(ambiguous_param)
+    #         case ambiguous_param
+    #         when String
+    #           if ambiguous_param.present?
+    #             ensure_hash(JSON.parse(ambiguous_param))
+    #           else
+    #             {}
+    #           end
+    #         when Hash, ActionController::Parameters
+    #           ambiguous_param
+    #         when nil
+    #           {}
+    #         else
+    #           raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+    #         end
+    #       end
     #   end
     #
     class ActionCableSubscriptions < GraphQL::Subscriptions
@@ -64,27 +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.
@@ -92,33 +119,98 @@ module GraphQL
       # It will receive notifications when events come in
       # and re-evaluate the query locally.
       def write_subscription(query, events)
-        channel = query.context[:channel]
+        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|
-          channel.stream_from(EVENT_PREFIX + event.topic, coder: ActiveSupport::JSON) do |message|
-            execute(subscription_id, event, @serializer.load(message))
-            nil
+          # Setup a new listener to run all events with this topic in this process
+          setup_stream(channel, event)
+          # Add this event to the list of events to be updated
+          @events[event.topic][event.fingerprint] << event
+        end
+      end
+
+      # Every subscribing channel is listening here, but only one of them takes any action.
+      # This is so we can reuse payloads when possible, and make one payload to send to
+      # all subscribers.
+      #
+      # But the problem is, any channel could close at any time, so each channel has to
+      # be ready to take over the primary position.
+      #
+      # To make sure there's always one-and-only-one channel building payloads,
+      # let the listener belonging to the first event on the list be
+      # the one to build and publish payloads.
+      #
+      def setup_stream(channel, initial_event)
+        topic = initial_event.topic
+        channel.stream_from(stream_event_name(initial_event), coder: @action_cable_coder) do |message|
+          events_by_fingerprint = @events[topic]
+          object = nil
+          events_by_fingerprint.each do |_fingerprint, events|
+            if events.any? && events.first == initial_event
+              # The fingerprint has told us that this response should be shared by all subscribers,
+              # so just run it once, then deliver the result to every subscriber
+              first_event = events.first
+              first_subscription_id = first_event.context.fetch(:subscription_id)
+              object ||= @serializer.load(message)
+              result = execute_update(first_subscription_id, first_event, object)
+              # Having calculated the result _once_, send the same payload to all subscribers
+              events.each do |event|
+                subscription_id = event.context.fetch(:subscription_id)
+                deliver(subscription_id, result)
+              end
+            end
           end
+          nil
         end
       end
 
       # Return the query from "storage" (in memory)
       def read_subscription(subscription_id)
         query = @subscriptions[subscription_id]
-        {
-          query_string: query.query_string,
-          variables: query.provided_variables,
-          context: query.context.to_h,
-          operation_name: query.operation_name,
-        }
+        if query.nil?
+          # This can happen when a subscription is triggered from an unsubscribed channel,
+          # see https://github.com/rmosolgo/graphql-ruby/issues/2478.
+          # (This `nil` is handled by `#execute_update`)
+          nil
+        else
+          {
+            query_string: query.query_string,
+            variables: query.provided_variables,
+            context: query.context.to_h,
+            operation_name: query.operation_name,
+          }
+        end
       end
 
       # The channel was closed, forget about it.
       def delete_subscription(subscription_id)
-        @subscriptions.delete(subscription_id)
+        query = @subscriptions.delete(subscription_id)
+        # This can be `nil` when `.trigger` happens inside an unsubscribed ActionCable channel,
+        # see https://github.com/rmosolgo/graphql-ruby/issues/2478
+        if query
+          events = query.context.namespace(:subscriptions)[:events]
+          events.each do |event|
+            ev_by_fingerprint = @events[event.topic]
+            ev_for_fingerprint = ev_by_fingerprint[event.fingerprint]
+            ev_for_fingerprint.delete(event)
+            if ev_for_fingerprint.empty?
+              ev_by_fingerprint.delete(event.fingerprint)
+            end
+          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

data/lib/graphql/subscriptions/broadcast_analyzer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Subscriptions
+    # Detect whether the current operation:
+    # - Is a subscription operation
+    # - Is completely broadcastable
+    #
+    # Assign the result to `context.namespace(:subscriptions)[:subscription_broadcastable]`
+    # @api private
+    # @see Subscriptions#broadcastable? for a public API
+    class BroadcastAnalyzer < GraphQL::Analysis::AST::Analyzer
+      def initialize(subject)
+        super
+        @default_broadcastable = subject.schema.subscriptions.default_broadcastable
+        # Maybe this will get set to false while analyzing
+        @subscription_broadcastable = true
+      end
+
+      # Only analyze subscription operations
+      def analyze?
+        @query.subscription?
+      end
+
+      def on_enter_field(node, parent, visitor)
+        if (@subscription_broadcastable == false) || visitor.skipping?
+          return
+        end
+
+        current_field = visitor.field_definition
+        apply_broadcastable(current_field)
+
+        current_type = visitor.parent_type_definition
+        if current_type.kind.interface?
+          pt = @query.possible_types(current_type)
+          pt.each do |object_type|
+            ot_field = @query.get_field(object_type, current_field.graphql_name)
+            # Inherited fields would be exactly the same object;
+            # only check fields that are overrides of the inherited one
+            if ot_field && ot_field != current_field
+              apply_broadcastable(ot_field)
+            end
+          end
+        end
+      end
+
+      # Assign the result to context.
+      # (This method is allowed to return an error, but we don't need to)
+      # @return [void]
+      def result
+        query.context.namespace(:subscriptions)[:subscription_broadcastable] = @subscription_broadcastable
+        nil
+      end
+
+      private
+
+      # Modify `@subscription_broadcastable` based on `field_defn`'s configuration (and/or the default value)
+      def apply_broadcastable(field_defn)
+        current_field_broadcastable = field_defn.introspection? || field_defn.broadcastable?
+        case current_field_broadcastable
+        when nil
+          # If the value wasn't set, mix in the default value:
+          # - If the default is false and the current value is true, make it false
+          # - If the default is true and the current value is true, it stays true
+          # - If the default is false and the current value is false, keep it false
+          # - If the default is true and the current value is false, keep it false
+          @subscription_broadcastable = @subscription_broadcastable && @default_broadcastable
+        when false
+          # One non-broadcastable field is enough to make the whole subscription non-broadcastable
+          @subscription_broadcastable = false
+        when true
+          # Leave `@broadcastable_query` true if it's already true,
+          # but don't _set_ it to true if it was set to false by something else.
+          # Actually, just leave it!
+        else
+          raise ArgumentError, "Unexpected `.broadcastable?` value for #{field_defn.path}: #{current_field_broadcastable}"
+        end
+      end
+    end
+  end
+end

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

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # This thing can be:
     # - 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
@@ -36,18 +34,74 @@ module GraphQL
         when GraphQL::Query::Arguments
           arguments
         when Hash
-          GraphQL::Query::LiteralInput.from_arguments(
-            arguments,
-            field,
-            nil,
-          )
+          if field.is_a?(GraphQL::Schema::Field)
+            stringify_args(field, arguments)
+          else
+            GraphQL::Query::LiteralInput.from_arguments(
+              arguments,
+              field,
+              nil,
+            )
+          end
         else
           raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
         end
 
-        sorted_h = normalized_args.to_h.sort.to_h
+        sorted_h = stringify_args(field, normalized_args.to_h)
         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)
+          case args
+          when Hash
+            next_args = {}
+            args.each do |k, v|
+              arg_name = k.to_s
+              camelized_arg_name = GraphQL::Schema::Member::BuildType.camelize(arg_name)
+              arg_defn = get_arg_definition(arg_owner, camelized_arg_name)
+
+              if arg_defn
+                normalized_arg_name = camelized_arg_name
+              else
+                normalized_arg_name = arg_name
+                arg_defn = get_arg_definition(arg_owner, normalized_arg_name)
+              end
+
+              next_args[normalized_arg_name] = stringify_args(arg_defn.type, v)
+            end
+            # Make sure they're deeply sorted
+            next_args.sort.to_h
+          when Array
+            args.map { |a| stringify_args(arg_owner, a) }
+          when GraphQL::Schema::InputObject
+            stringify_args(arg_owner, args.to_h)
+          else
+            args
+          end
+        end
+
+        def get_arg_definition(arg_owner, arg_name)
+          arg_owner.arguments[arg_name] || arg_owner.arguments.each_value.find { |v| v.keyword.to_s == arg_name }
+        end
+      end
     end
   end
 end

data/lib/graphql/subscriptions/instrumentation.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # Wrap the root fields of the subscription type with special logic for:
@@ -11,7 +10,7 @@ module GraphQL
       end
 
       def instrument(type, field)
-        if type == @schema.subscription
+        if type == @schema.subscription.graphql_definition
           # This is a root field of `subscription`
           subscribing_resolve_proc = SubscriptionRegistrationResolve.new(field.resolve_proc)
           field.redefine(resolve: subscribing_resolve_proc)
@@ -44,7 +43,13 @@ module GraphQL
 
         # Wrap the proc with subscription registration logic
         def call(obj, args, ctx)
+          result = nil
+          if @inner_proc && !@inner_proc.is_a?(GraphQL::Field::Resolve::BuiltInResolve)
+            result = @inner_proc.call(obj, args, ctx)
+          end
+
           events = ctx.namespace(:subscriptions)[:events]
+
           if events
             # This is the first execution, so gather an Event
             # for the backend to register:
@@ -53,10 +58,12 @@ module GraphQL
               arguments: args,
               context: ctx,
             )
-            ctx.skip
+            result
           elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
-            # The root object is _already_ the subscription update:
-            if obj.is_a?(GraphQL::Schema::Object)
+            if !result.nil?
+              result
+            elsif obj.is_a?(GraphQL::Schema::Object)
+              # The root object is _already_ the subscription update:
               obj.object
             else
               obj

data/lib/graphql/subscriptions/serialize.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 require "set"
 module GraphQL
   class Subscriptions
@@ -9,6 +8,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
 
@@ -53,12 +55,32 @@ module GraphQL
         # @return [Object] An object that load Global::Identification recursive
         def load_value(value)
           if value.is_a?(Array)
-            value.map{|item| load_value(item)}
+            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 && 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)
+              else
+                key = value.keys.first
+                { key => load_value(value[key]) }
+              end
             else
               loaded_h = {}
               sym_keys = value.fetch(SYMBOL_KEYS_KEY, [])
@@ -101,6 +123,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