graphql 1.9.5 → 1.13.19

data/lib/graphql/tracing.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 require "graphql/tracing/active_support_notifications_tracing"
 require "graphql/tracing/platform_tracing"
+require "graphql/tracing/appoptics_tracing"
 require "graphql/tracing/appsignal_tracing"
 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)
@@ -15,15 +17,13 @@ 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
-  #   GraphQL::Tracing.trace("my_custom_event", { ... }) do
+  #   query.trace("my_custom_event", { ... }) do
   #     # do stuff ...
   #   end
   #
   # @example Adding a tracer to a schema
-  #  MySchema = GraphQL::Schema.define do
+  #  class MySchema < GraphQL::Schema
   #    tracer MyTracer # <= responds to .trace(key, data, &block)
   #  end
   #
@@ -42,8 +42,12 @@ module GraphQL
   # execute_multiplex | `{ multiplex: GraphQL::Execution::Multiplex }`
   # execute_query | `{ query: GraphQL::Query }`
   # execute_query_lazy | `{ query: GraphQL::Query?, multiplex: GraphQL::Execution::Multiplex? }`
-  # execute_field | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, query: GraphQL::Query?, path: Array<String, Integer>?}`
-  # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, query: GraphqL::Query?, path: Array<String, Integer>?}`
+  # execute_field | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
+  # execute_field_lazy | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
+  # authorized | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # authorized_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # resolve_type | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # resolve_type_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
   #
   # Note that `execute_field` and `execute_field_lazy` receive different data in different settings:
   #
@@ -58,8 +62,9 @@ module GraphQL
       # @param key [String] The name of the event in GraphQL internals
       # @param metadata [Hash] Event-related metadata (can be anything)
       # @return [Object] Must return the value of the block
-      def trace(key, metadata)
-        call_tracers(0, key, metadata) { yield }
+      def trace(key, metadata, &block)
+        return yield if @tracers.empty?
+        call_tracers(0, key, metadata, &block)
       end
 
       private
@@ -71,39 +76,14 @@ module GraphQL
       # @param key [String] The current event name
       # @param metadata [Object] The current event object
       # @return Whatever the block returns
-      def call_tracers(idx, key, metadata)
+      def call_tracers(idx, key, metadata, &block)
         if idx == @tracers.length
           yield
         else
-          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata) { yield } }
-        end
-      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
+          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata, &block) }
         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

data/lib/graphql/types/big_int.rb

@@ -6,7 +6,7 @@ module GraphQL
       description "Represents non-fractional signed whole numeric values. Since the value may exceed the size of a 32-bit integer, it's encoded as a string."
 
       def self.coerce_input(value, _ctx)
-        Integer(value)
+        value && parse_int(value)
       rescue ArgumentError
         nil
       end
@@ -14,6 +14,10 @@ module GraphQL
       def self.coerce_result(value, _ctx)
         value.to_i.to_s
       end
+
+      def self.parse_int(value)
+        value.is_a?(Numeric) ? value : Integer(value, 10)
+      end
     end
   end
 end

data/lib/graphql/types/int.rb

@@ -9,8 +9,15 @@ module GraphQL
       MIN = -(2**31)
       MAX = (2**31) - 1
 
-      def self.coerce_input(value, _ctx)
-        value.is_a?(Numeric) ? value.to_i : nil
+      def self.coerce_input(value, ctx)
+        return if !value.is_a?(Integer)
+
+        if value >= MIN && value <= MAX
+          value
+        else
+          err = GraphQL::IntegerDecodingError.new(value)
+          ctx.schema.type_error(err, ctx)
+        end
       end
 
       def self.coerce_result(value, ctx)
@@ -18,7 +25,7 @@ module GraphQL
         if value >= MIN && value <= MAX
           value
         else
-          err = GraphQL::IntegerEncodingError.new(value)
+          err = GraphQL::IntegerEncodingError.new(value, context: ctx)
           ctx.schema.type_error(err, ctx)
         end
       end

data/lib/graphql/types/iso_8601_date.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    # This scalar takes `Date`s and transmits them as strings,
+    # using ISO 8601 format.
+    #
+    # Use it for fields or arguments as follows:
+    #
+    #     field :published_at, GraphQL::Types::ISO8601Date, null: false
+    #
+    #     argument :deliver_at, GraphQL::Types::ISO8601Date, null: false
+    #
+    # Alternatively, use this built-in scalar as inspiration for your
+    # own Date type.
+    class ISO8601Date < GraphQL::Schema::Scalar
+      description "An ISO 8601-encoded date"
+
+      # @param value [Date,Time,DateTime,String]
+      # @return [String]
+      def self.coerce_result(value, _ctx)
+        Date.parse(value.to_s).iso8601
+      end
+
+      # @param str_value [String, Date, DateTime, Time]
+      # @return [Date]
+      def self.coerce_input(value, ctx)
+        if value.is_a?(::Date)
+          value
+        elsif value.is_a?(::DateTime)
+          value.to_date
+        elsif value.is_a?(::Time)
+          value.to_date
+        else
+          Date.iso8601(value)
+        end
+      rescue ArgumentError, TypeError
+        err = GraphQL::DateEncodingError.new(value)
+        ctx.schema.type_error(err, ctx)
+      end
+    end
+  end
+end

data/lib/graphql/types/iso_8601_date_time.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
+
+require 'time'
+
 module GraphQL
   module Types
-    # This scalar takes `DateTime`s and transmits them as strings,
+    # This scalar takes `Time`s and transmits them as strings,
     # using ISO 8601 format.
     #
     # Use it for fields or arguments as follows:
@@ -29,19 +32,40 @@ module GraphQL
         @time_precision = value
       end
 
-      # @param value [DateTime]
+      # @param value [Time,Date,DateTime,String]
       # @return [String]
       def self.coerce_result(value, _ctx)
-        value.iso8601(time_precision)
+        case value
+        when Date
+          return value.to_time.iso8601(time_precision)
+        when ::String
+          return Time.parse(value).iso8601(time_precision)
+        else
+          # Time, DateTime or compatible is given:
+          return value.iso8601(time_precision)
+        end
+      rescue StandardError => error
+        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only Times, Dates, DateTimes, and well-formatted Strings are used with this type. (#{error.message})"
       end
 
       # @param str_value [String]
-      # @return [DateTime]
+      # @return [Time]
       def self.coerce_input(str_value, _ctx)
-        DateTime.iso8601(str_value)
-      rescue ArgumentError
-        # Invalid input
-        nil
+        Time.iso8601(str_value)
+      rescue ArgumentError, TypeError
+        begin
+          dt = Date.iso8601(str_value).to_time
+          # For compatibility, continue accepting dates given without times
+          # But without this, it would zero out given any time part of `str_value` (hours and/or minutes)
+          if dt.iso8601.start_with?(str_value)
+            dt
+          else
+            nil
+          end
+        rescue ArgumentError, TypeError
+          # Invalid input
+          nil
+        end
       end
     end
   end

data/lib/graphql/types/relay/base_connection.rb

@@ -24,97 +24,15 @@ module GraphQL
       #   end
       #   class Types::PostConnection < Types::BaseConnection
       #     edge_type(Types::PostEdge)
+      #     edges_nullable(true)
+      #     edge_nullable(true)
+      #     node_nullable(true)
+      #     has_nodes_field(true)
       #   end
       #
       # @see Relay::BaseEdge for edge types
-      class BaseConnection < Types::Relay::BaseObject
-        extend Forwardable
-        def_delegators :@object, :cursor_from_node, :parent
-
-        class << self
-          # @return [Class]
-          attr_reader :node_type
-
-          # @return [Class]
-          attr_reader :edge_class
-
-          # Configure this connection to return `edges` and `nodes` based on `edge_type_class`.
-          #
-          # This method will use the inputs to create:
-          # - `edges` field
-          # - `nodes` field
-          # - description
-          #
-          # It's called when you subclass this base connection, trying to use the
-          # class name to set defaults. You can call it again in the class definition
-          # to override the default (or provide a value, if the default lookup failed).
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: true)
-            # Set this connection's graphql name
-            node_type_name = node_type.graphql_name
-
-            @node_type = node_type
-            @edge_type = edge_type_class
-            @edge_class = edge_class
-
-            field :edges, [edge_type_class, null: true],
-              null: true,
-              description: "A list of edges.",
-              edge_class: edge_class
-
-            define_nodes_field if nodes_field
-
-            description("The connection type for #{node_type_name}.")
-          end
-
-          # Filter this list according to the way its node type would scope them
-          def scope_items(items, context)
-            node_type.scope_items(items, context)
-          end
-
-          # Add the shortcut `nodes` field to this connection and its subclasses
-          def nodes_field
-            define_nodes_field
-          end
-
-          def authorized?(obj, ctx)
-            true # Let nodes be filtered out
-          end
-
-          def accessible?(ctx)
-            node_type.accessible?(ctx)
-          end
-
-          def visible?(ctx)
-            node_type.visible?(ctx)
-          end
-
-          private
-
-          def define_nodes_field
-            field :nodes, [@node_type, null: true],
-              null: true,
-              description: "A list of nodes."
-          end
-        end
-
-        field :page_info, GraphQL::Types::Relay::PageInfo, null: false, description: "Information to aid in pagination."
-
-        # By default this calls through to the ConnectionWrapper's edge nodes method,
-        # but sometimes you need to override it to support the `nodes` field
-        def nodes
-          @object.edge_nodes
-        end
-
-        def edges
-          if context.interpreter?
-            context.schema.after_lazy(object.edge_nodes) do |nodes|
-              nodes.map { |n| self.class.edge_class.new(n, object) }
-            end
-          else
-            # This is done by edges_instrumentation
-            @object.edge_nodes
-          end
-        end
+      class BaseConnection < Schema::Object
+        include ConnectionBehaviors
       end
     end
   end

data/lib/graphql/types/relay/base_edge.rb

@@ -21,43 +21,8 @@ module GraphQL
       #   end
       #
       # @see {Relay::BaseConnection} for connection types
-      class BaseEdge < Types::Relay::BaseObject
-        description "An edge in a connection."
-
-        class << self
-          # Get or set the Object type that this edge wraps.
-          #
-          # @param node_type [Class] A `Schema::Object` subclass
-          # @param null [Boolean]
-          def node_type(node_type = nil, null: true)
-            if node_type
-              @node_type = node_type
-              wrapped_type_name = node_type.graphql_name
-              # Set this to be named like the node type, but suffixed with `Edge`
-              graphql_name("#{wrapped_type_name}Edge")
-              # Add a default `node` field
-              field :node, node_type, null: null, description: "The item at the end of the edge."
-            end
-            @node_type
-          end
-
-          def authorized?(obj, ctx)
-            true
-          end
-
-          def accessible?(ctx)
-            node_type.accessible?(ctx)
-          end
-
-          def visible?(ctx)
-            node_type.visible?(ctx)
-          end
-        end
-
-
-        field :cursor, String,
-          null: false,
-          description: "A cursor for use in pagination."
+      class BaseEdge < GraphQL::Schema::Object
+        include Types::Relay::EdgeBehaviors
       end
     end
   end

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module ConnectionBehaviors
+        extend Forwardable
+        def_delegators :@object, :cursor_from_node, :parent
+
+        def self.included(child_class)
+          child_class.extend(ClassMethods)
+          child_class.extend(Relay::DefaultRelay)
+          child_class.default_relay(true)
+          child_class.has_nodes_field(true)
+          child_class.node_nullable(true)
+          child_class.edges_nullable(true)
+          child_class.edge_nullable(true)
+          add_page_info_field(child_class)
+        end
+
+        module ClassMethods
+          # @return [Class]
+          attr_reader :node_type
+
+          # @return [Class]
+          attr_reader :edge_class
+
+          # Configure this connection to return `edges` and `nodes` based on `edge_type_class`.
+          #
+          # This method will use the inputs to create:
+          # - `edges` field
+          # - `nodes` field
+          # - description
+          #
+          # It's called when you subclass this base connection, trying to use the
+          # class name to set defaults. You can call it again in the class definition
+          # to override the default (or provide a value, if the default lookup failed).
+          # @param field_options [Hash] Any extra keyword arguments to pass to the `field :edges, ...` and `field :nodes, ...` configurations
+          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
+            # Set this connection's graphql name
+            node_type_name = node_type.graphql_name
+
+            @node_type = node_type
+            @edge_type = edge_type_class
+            @edge_class = edge_class
+
+            base_field_options = {
+              name: :edges,
+              type: [edge_type_class, null: edge_nullable],
+              null: edges_nullable,
+              description: "A list of edges.",
+              legacy_edge_class: edge_class, # This is used by the old runtime only, for EdgesInstrumentation
+              connection: false,
+            }
+
+            if field_options
+              base_field_options.merge!(field_options)
+            end
+
+            field(**base_field_options)
+
+            define_nodes_field(node_nullable, field_options: field_options) if nodes_field
+
+            description("The connection type for #{node_type_name}.")
+          end
+
+          # Filter this list according to the way its node type would scope them
+          def scope_items(items, context)
+            node_type.scope_items(items, context)
+          end
+
+          # Add the shortcut `nodes` field to this connection and its subclasses
+          def nodes_field(node_nullable: self.node_nullable, field_options: nil)
+            define_nodes_field(node_nullable, field_options: field_options)
+          end
+
+          def authorized?(obj, ctx)
+            true # Let nodes be filtered out
+          end
+
+          def accessible?(ctx)
+            node_type.accessible?(ctx)
+          end
+
+          def visible?(ctx)
+            # if this is an abstract base class, there may be no `node_type`
+            node_type ? node_type.visible?(ctx) : super
+          end
+
+          # Set the default `node_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `node_nullable(false)` in your base class to make non-null `node` and `nodes` fields.
+          def node_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
+            else
+              @node_nullable = new_value
+            end
+          end
+
+          # Set the default `edges_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `edges_nullable(false)` in your base class to make non-null `edges` fields.
+          def edges_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@edges_nullable) ? @edges_nullable : superclass.edges_nullable
+            else
+              @edges_nullable = new_value
+            end
+          end
+
+          # Set the default `edge_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `edge_nullable(false)` in your base class to make non-null `edge` fields.
+          def edge_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@edge_nullable) ? @edge_nullable : superclass.edge_nullable
+            else
+              @edge_nullable = new_value
+            end
+          end
+
+          # Set the default `nodes_field` for this class and its child classes. (Defaults to `true`.)
+          # Use `nodes_field(false)` in your base class to prevent adding of a nodes field.
+          def has_nodes_field(new_value = nil)
+            if new_value.nil?
+              defined?(@nodes_field) ? @nodes_field : superclass.has_nodes_field
+            else
+              @nodes_field = new_value
+            end
+          end
+
+          private
+
+          def define_nodes_field(nullable, field_options: nil)
+            base_field_options = {
+              name: :nodes,
+              type: [@node_type, null: nullable],
+              null: nullable,
+              description: "A list of nodes.",
+              connection: false,
+            }
+            if field_options
+              base_field_options.merge!(field_options)
+            end
+            field(**base_field_options)
+          end
+        end
+
+        class << self
+          def add_page_info_field(obj_type)
+            obj_type.field :page_info, GraphQL::Types::Relay::PageInfo, null: false, description: "Information to aid in pagination."
+          end
+        end
+
+        # By default this calls through to the ConnectionWrapper's edge nodes method,
+        # but sometimes you need to override it to support the `nodes` field
+        def nodes
+          @object.edge_nodes
+        end
+
+        def edges
+          if @object.is_a?(GraphQL::Pagination::Connection)
+            @object.edges
+          elsif context.interpreter?
+            context.schema.after_lazy(object.edge_nodes) do |nodes|
+              nodes.map { |n| self.class.edge_class.new(n, object) }
+            end
+          else
+            # This is done by edges_instrumentation
+            @object.edge_nodes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/default_relay.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module DefaultRelay
+        def self.extended(child_class)
+          child_class.default_relay(true)
+        end
+
+        def default_relay(new_value)
+          @default_relay = new_value
+        end
+
+        def default_relay?
+          !!@default_relay
+        end
+
+        def to_graphql
+          type_defn = if method(:to_graphql).super_method.arity
+            super(silence_deprecation_warning: true)
+          else
+            super
+          end
+          type_defn.default_relay = default_relay?
+          type_defn
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/edge_behaviors.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module EdgeBehaviors
+        def self.included(child_class)
+          child_class.description("An edge in a connection.")
+          child_class.field(:cursor, String, null: false, description: "A cursor for use in pagination.")
+          child_class.extend(ClassMethods)
+          child_class.node_nullable(true)
+        end
+
+        module ClassMethods
+          # Get or set the Object type that this edge wraps.
+          #
+          # @param node_type [Class] A `Schema::Object` subclass
+          # @param null [Boolean]
+          # @param field_options [Hash] Any extra arguments to pass to the `field :node` configuration
+          def node_type(node_type = nil, null: self.node_nullable, field_options: nil)
+            if node_type
+              @node_type = node_type
+              # Add a default `node` field
+              base_field_options = {
+                name: :node,
+                type: node_type,
+                null: null,
+                description: "The item at the end of the edge.",
+                connection: false,
+              }
+              if field_options
+                base_field_options.merge!(field_options)
+              end
+              field(**base_field_options)
+            end
+            @node_type
+          end
+
+          def authorized?(obj, ctx)
+            true
+          end
+
+          def accessible?(ctx)
+            node_type.accessible?(ctx)
+          end
+
+          def visible?(ctx)
+            node_type.visible?(ctx)
+          end
+
+          # Set the default `node_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `node_nullable(false)` in your base class to make non-null `node` field.
+          def node_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
+            else
+              @node_nullable = new_value
+            end
+          end
+        end
+      end
+    end
+  end
+end