graphql 2.0.13 → 2.0.15

data/lib/graphql/schema.rb

@@ -31,6 +31,7 @@ require "graphql/schema/union"
 require "graphql/schema/directive"
 require "graphql/schema/directive/deprecated"
 require "graphql/schema/directive/include"
+require "graphql/schema/directive/one_of"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/flagged"
@@ -109,9 +110,10 @@ module GraphQL
       # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
       # @return [Class] the schema described by `document`
       def from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {})
-        # If the file ends in `.graphql`, treat it like a filepath
-        if definition_or_path.end_with?(".graphql")
+        # If the file ends in `.graphql` or `.graphqls`, treat it like a filepath
+        if definition_or_path.end_with?(".graphql") || definition_or_path.end_with?(".graphqls")
           GraphQL::Schema::BuildFromDefinition.from_definition_path(
+            self,
             definition_or_path,
             default_resolve: default_resolve,
             parser: parser,
@@ -119,6 +121,7 @@ module GraphQL
           )
         else
           GraphQL::Schema::BuildFromDefinition.from_definition(
+            self,
             definition_or_path,
             default_resolve: default_resolve,
             parser: parser,
@@ -737,11 +740,10 @@ module GraphQL
       def handle_or_reraise(context, err)
         handler = Execution::Errors.find_handler_for(self, err.class)
         if handler
-          runtime_info = context.namespace(:interpreter) || {}
-          obj = runtime_info[:current_object]
-          args = runtime_info[:current_arguments]
+          obj = context[:current_object]
+          args = context[:current_arguments]
           args = args && args.keyword_arguments
-          field = runtime_info[:current_field]
+          field = context[:current_field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end
@@ -815,6 +817,15 @@ module GraphQL
         member.accessible?(ctx)
       end
 
+      def schema_directive(dir_class, **options)
+        @own_schema_directives ||= []
+        Member::HasDirectives.add_directive(self, @own_schema_directives, dir_class, options)
+      end
+
+      def schema_directives
+        Member::HasDirectives.get_directives(self, @own_schema_directives, :schema_directives)
+      end
+
       # This hook is called when a client tries to access one or more
       # fields that fail the `accessible?` check.
       #
@@ -913,6 +924,7 @@ module GraphQL
           "include" => GraphQL::Schema::Directive::Include,
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
+          "oneOf" => GraphQL::Schema::Directive::OneOf,
         }.freeze
       end
 
@@ -990,7 +1002,7 @@ module GraphQL
       # @param context [Hash] Multiplex-level context
       # @return [Array<Hash>] One result for each query in the input
       def multiplex(queries, **kwargs)
-        GraphQL::Execution::Multiplex.run_all(self, queries, **kwargs)
+        GraphQL::Execution::Interpreter.run_all(self, queries, **kwargs)
       end
 
       def instrumenters

data/lib/graphql/static_validation/all_rules.rb

@@ -36,6 +36,7 @@ module GraphQL
       GraphQL::StaticValidation::QueryRootExists,
       GraphQL::StaticValidation::SubscriptionRootExists,
       GraphQL::StaticValidation::InputObjectNamesAreUnique,
+      GraphQL::StaticValidation::OneOfInputObjectsAreValid,
     ]
   end
 end

data/lib/graphql/static_validation/literal_validator.rb

@@ -108,6 +108,10 @@ module GraphQL
             arg_type = @warden.get_argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
+
+          if type.one_of? && ast_node.arguments.size != 1
+            results << Query::InputValidationResult.from_problem("`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{ast_node.arguments.size})")
+          end
           merge_results(results)
         end
       end

data/lib/graphql/static_validation/rules/one_of_input_objects_are_valid.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module OneOfInputObjectsAreValid
+      def on_input_object(node, parent)
+        return super unless parent.is_a?(GraphQL::Language::Nodes::Argument)
+
+        parent_type = get_parent_type(context, parent)
+        return super unless parent_type && parent_type.kind.input_object? && parent_type.one_of?
+
+        validate_one_of_input_object(node, context, parent_type)
+        super
+      end
+
+      private
+
+      def validate_one_of_input_object(ast_node, context, parent_type)
+        present_fields = ast_node.arguments.map(&:name)
+        input_object_type = parent_type.to_type_signature
+
+        if present_fields.count != 1
+          add_error(
+            OneOfInputObjectsAreValidError.new(
+              "OneOf Input Object '#{input_object_type}' must specify exactly one key.",
+              path: context.path,
+              nodes: ast_node,
+              input_object_type: input_object_type
+            )
+          )
+          return
+        end
+
+        field = present_fields.first
+        value = ast_node.arguments.first.value
+
+        if value.is_a?(GraphQL::Language::Nodes::NullValue)
+          add_error(
+            OneOfInputObjectsAreValidError.new(
+              "Argument '#{input_object_type}.#{field}' must be non-null.",
+              path: [*context.path, field],
+              nodes: ast_node.arguments.first,
+              input_object_type: input_object_type
+            )
+          )
+          return
+        end
+
+        if value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          variable_name = value.name
+          variable_type = @declared_variables[variable_name].type
+
+          unless variable_type.is_a?(GraphQL::Language::Nodes::NonNullType)
+            add_error(
+              OneOfInputObjectsAreValidError.new(
+                "Variable '#{variable_name}' must be non-nullable to be used for OneOf Input Object '#{input_object_type}'.",
+                path: [*context.path, field],
+                nodes: ast_node,
+                input_object_type: input_object_type
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/one_of_input_objects_are_valid_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class OneOfInputObjectsAreValidError < StaticValidation::Error
+      attr_reader :input_object_type
+
+      def initialize(message, path:, nodes:, input_object_type:)
+        super(message, path: path, nodes: nodes)
+        @input_object_type = input_object_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "inputObjectType" => input_object_type
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "invalidOneOfInputObject"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -23,7 +23,7 @@ module GraphQL
                 problems = validation_result.problems
                 first_problem = problems && problems.first
                 if first_problem
-                  error_message = first_problem["message"]
+                  error_message = first_problem["explanation"]
                 end
 
                 error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -75,10 +75,12 @@ module GraphQL
       end
 
       def analytics_enabled?
+        # [Deprecated] options[:analytics_enabled] will be removed in the future
         analytics_available? && Datadog::Contrib::Analytics.enabled?(options.fetch(:analytics_enabled, false))
       end
 
       def analytics_sample_rate
+        # [Deprecated] options[:analytics_sample_rate] will be removed in the future
         options.fetch(:analytics_sample_rate, 1.0)
       end
 

data/lib/graphql/tracing/instrumentation_tracing.rb

@@ -0,0 +1,83 @@
+module GraphQL
+  module Tracing
+    class InstrumentationTracing
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def trace(event, data)
+        instrumenters = nil
+        query_instrumenters = nil
+        case event
+        when "execute_multiplex"
+          instrumenters = @schema.instrumenters
+          multiplex_instrumenters = instrumenters[:multiplex]
+          query_instrumenters = instrumenters[:query]
+          call_hooks(multiplex_instrumenters, data[:multiplex], :before_multiplex, :after_multiplex) {
+            each_query_call_hooks(query_instrumenters, data[:multiplex].queries) {
+              yield
+            }
+          }
+        else
+          yield
+        end
+      end
+
+      private
+
+      # Call the before_ hooks of each query,
+      # Then yield if no errors.
+      # `call_hooks` takes care of appropriate cleanup.
+      def each_query_call_hooks(instrumenters, queries, i = 0)
+        if i >= queries.length
+          yield
+        else
+          query = queries[i]
+          call_hooks(instrumenters, query, :before_query, :after_query) {
+            each_query_call_hooks(instrumenters, queries, i + 1) {
+              yield
+            }
+          }
+        end
+      end
+
+      # Call each before hook, and if they all succeed, yield.
+      # If they don't all succeed, call after_ for each one that succeeded.
+      def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
+        begin
+          successful = []
+          instrumenters.each do |instrumenter|
+            instrumenter.public_send(before_hook_name, object)
+            successful << instrumenter
+          end
+
+          # if any before hooks raise an exception, quit calling before hooks,
+          # but call the after hooks on anything that succeeded but also
+          # raise the exception that came from the before hook.
+        rescue GraphQL::ExecutionError => err
+          object.context.errors << err
+        rescue => e
+          raise call_after_hooks(successful, object, after_hook_name, e)
+        end
+
+        begin
+          yield # Call the user code
+        ensure
+          ex = call_after_hooks(successful, object, after_hook_name, nil)
+          raise ex if ex
+        end
+      end
+
+      def call_after_hooks(instrumenters, object, after_hook_name, ex)
+        instrumenters.reverse_each do |instrumenter|
+          begin
+            instrumenter.public_send(after_hook_name, object)
+          rescue => e
+            ex = e
+          end
+        end
+        ex
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module GraphQL
         end
 
         def default_global_id
-          context.schema.id_from_object(object, self, context)
+          context.schema.id_from_object(object, self.class, context)
         end
       end
     end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.13
+  version: 2.0.15
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-12 00:00:00.000000000 Z
+date: 2022-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -303,7 +303,6 @@ files:
 - lib/graphql/execution.rb
 - lib/graphql/execution/directive_checks.rb
 - lib/graphql/execution/errors.rb
-- lib/graphql/execution/instrumentation.rb
 - lib/graphql/execution/interpreter.rb
 - lib/graphql/execution/interpreter/argument_value.rb
 - lib/graphql/execution/interpreter/arguments.rb
@@ -394,6 +393,7 @@ files:
 - lib/graphql/schema/directive/feature.rb
 - lib/graphql/schema/directive/flagged.rb
 - lib/graphql/schema/directive/include.rb
+- lib/graphql/schema/directive/one_of.rb
 - lib/graphql/schema/directive/skip.rb
 - lib/graphql/schema/directive/transform.rb
 - lib/graphql/schema/enum.rb
@@ -497,6 +497,8 @@ files:
 - lib/graphql/static_validation/rules/mutation_root_exists_error.rb
 - lib/graphql/static_validation/rules/no_definitions_are_present.rb
 - lib/graphql/static_validation/rules/no_definitions_are_present_error.rb
+- lib/graphql/static_validation/rules/one_of_input_objects_are_valid.rb
+- lib/graphql/static_validation/rules/one_of_input_objects_are_valid_error.rb
 - lib/graphql/static_validation/rules/operation_names_are_valid.rb
 - lib/graphql/static_validation/rules/operation_names_are_valid_error.rb
 - lib/graphql/static_validation/rules/query_root_exists.rb
@@ -536,6 +538,7 @@ files:
 - lib/graphql/tracing/appoptics_tracing.rb
 - lib/graphql/tracing/appsignal_tracing.rb
 - lib/graphql/tracing/data_dog_tracing.rb
+- lib/graphql/tracing/instrumentation_tracing.rb
 - lib/graphql/tracing/new_relic_tracing.rb
 - lib/graphql/tracing/notifications_tracing.rb
 - lib/graphql/tracing/platform_tracing.rb
@@ -595,7 +598,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby

data/lib/graphql/execution/instrumentation.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Execution
-    module Instrumentation
-      # This function implements the instrumentation policy:
-      #
-      # - Instrumenters are a stack; the first `before_query` will have the last `after_query`
-      # - If a `before_` hook returned without an error, its corresponding `after_` hook will run.
-      # - If the `before_` hook did _not_ run, the `after_` hook will not be called.
-      #
-      # When errors are raised from `after_` hooks:
-      #   - Subsequent `after_` hooks _are_ called
-      #   - The first raised error is captured; later errors are ignored
-      #   - If an error was capture, it's re-raised after all hooks are finished
-      #
-      # Partial runs of instrumentation are possible:
-      # - If a `before_multiplex` hook raises an error, no `before_query` hooks will run
-      # - If a `before_query` hook raises an error, subsequent `before_query` hooks will not run (on any query)
-      def self.apply_instrumenters(multiplex)
-        schema = multiplex.schema
-        queries = multiplex.queries
-        query_instrumenters = schema.instrumenters[:query]
-        multiplex_instrumenters = schema.instrumenters[:multiplex]
-
-        # First, run multiplex instrumentation, then query instrumentation for each query
-        call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
-          each_query_call_hooks(query_instrumenters, queries) do
-            # Let them be executed
-            yield
-          end
-        end
-      end
-
-      class << self
-        private
-        # Call the before_ hooks of each query,
-        # Then yield if no errors.
-        # `call_hooks` takes care of appropriate cleanup.
-        def each_query_call_hooks(instrumenters, queries, i = 0)
-          if i >= queries.length
-            yield
-          else
-            query = queries[i]
-            call_hooks(instrumenters, query, :before_query, :after_query) {
-              each_query_call_hooks(instrumenters, queries, i + 1) {
-                yield
-              }
-            }
-          end
-        end
-
-        # Call each before hook, and if they all succeed, yield.
-        # If they don't all succeed, call after_ for each one that succeeded.
-        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
-          begin
-            successful = []
-            instrumenters.each do |instrumenter|
-              instrumenter.public_send(before_hook_name, object)
-              successful << instrumenter
-            end
-
-            # if any before hooks raise an exception, quit calling before hooks,
-            # but call the after hooks on anything that succeeded but also
-            # raise the exception that came from the before hook.
-          rescue GraphQL::ExecutionError => err
-            object.context.errors << err
-          rescue => e
-            raise call_after_hooks(successful, object, after_hook_name, e)
-          end
-
-          begin
-            yield # Call the user code
-          ensure
-            ex = call_after_hooks(successful, object, after_hook_name, nil)
-            raise ex if ex
-          end
-        end
-
-        def call_after_hooks(instrumenters, object, after_hook_name, ex)
-          instrumenters.reverse_each do |instrumenter|
-            begin
-              instrumenter.public_send(after_hook_name, object)
-            rescue => e
-              ex = e
-            end
-          end
-          ex
-        end
-      end
-    end
-  end
-end