graphql 1.12.25 → 1.13.0

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

@@ -34,16 +34,16 @@ module GraphQL
         parent_type = get_parent_type(context, parent)
         return unless parent_type && parent_type.kind.input_object?
 
-        required_fields = parent_type.arguments
-          .select{|k,v| v.type.kind.non_null?}
-          .keys
+        required_fields = context.warden.arguments(parent_type)
+          .select{|arg| arg.type.kind.non_null?}
+          .map(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)
         missing_fields = required_fields - present_fields
 
         missing_fields.each do |missing_field|
           path = [*context.path, missing_field]
-          missing_field_type = parent_type.arguments[missing_field].type
+          missing_field_type = context.warden.get_argument(parent_type, missing_field).type
           add_error(RequiredInputObjectAttributesArePresentError.new(
             "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
             argument_name: missing_field,

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

@@ -22,15 +22,15 @@ module GraphQL
         node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
 
         if node_values.any?
-          arguments = case parent
+          argument_owner = case parent
           when GraphQL::Language::Nodes::Field
-            context.field_definition.arguments
+            context.field_definition
           when GraphQL::Language::Nodes::Directive
-            context.directive_definition.arguments
+            context.directive_definition
           when GraphQL::Language::Nodes::InputObject
             arg_type = context.argument_definition.type.unwrap
             if arg_type.kind.input_object?
-              arguments = arg_type.arguments
+              arg_type
             else
               # This is some kind of error
               nil
@@ -43,7 +43,7 @@ module GraphQL
             var_defn_ast = @declared_variables[node_value.name]
             # Might be undefined :(
             # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
-            var_defn_ast && arguments && validate_usage(arguments, node, var_defn_ast)
+            var_defn_ast && argument_owner && validate_usage(argument_owner, node, var_defn_ast)
           end
         end
         super
@@ -51,7 +51,7 @@ module GraphQL
 
       private
 
-      def validate_usage(arguments, arg_node, ast_var)
+      def validate_usage(argument_owner, arg_node, ast_var)
         var_type = context.schema.type_from_ast(ast_var.type, context: context)
         if var_type.nil?
           return
@@ -65,7 +65,7 @@ module GraphQL
           end
         end
 
-        arg_defn = arguments[arg_node.name]
+        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
         arg_defn_type = arg_defn.type
 
         var_inner_type = var_type.unwrap

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -170,10 +170,12 @@ module GraphQL
               first_subscription_id = first_event.context.fetch(:subscription_id)
               object ||= load_action_cable_message(message, first_event.context)
               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)
+              if !result.nil?
+                # 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
           end

data/lib/graphql/subscriptions/event.rb

@@ -23,15 +23,23 @@ module GraphQL
         @arguments = arguments
         @context = context
         field ||= context.field
-        scope_val = scope || (context && field.subscription_scope && context[field.subscription_scope])
+        scope_key = field.subscription_scope
+        scope_val = scope || (context && scope_key && context[scope_key])
+        if scope_key &&
+            (subscription = field.resolver) &&
+            (subscription.respond_to?(:subscription_scope_optional?)) &&
+            !subscription.subscription_scope_optional? &&
+            scope_val.nil?
+          raise Subscriptions::SubscriptionScopeMissingError, "#{field.path} (#{subscription}) requires a `scope:` value to trigger updates (Set `subscription_scope ..., optional: true` to disable this requirement)"
+        end
 
-        @topic = self.class.serialize(name, arguments, field, scope: scope_val)
+        @topic = self.class.serialize(name, arguments, field, scope: scope_val, context: context)
       end
 
       # @return [String] an identifier for this unit of subscription
-      def self.serialize(_name, arguments, field, scope:)
+      def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext)
         subscription = field.resolver || GraphQL::Schema::Subscription
-        normalized_args = stringify_args(field, arguments.to_h)
+        normalized_args = stringify_args(field, arguments.to_h, context)
         subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
       end
 
@@ -83,7 +91,7 @@ module GraphQL
           end
         end
 
-        def stringify_args(arg_owner, args)
+        def stringify_args(arg_owner, args, context)
           arg_owner = arg_owner.respond_to?(:unwrap) ? arg_owner.unwrap : arg_owner # remove list and non-null wrappers
           case args
           when Hash
@@ -91,13 +99,13 @@ module GraphQL
             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)
+              arg_defn = get_arg_definition(arg_owner, camelized_arg_name, context)
 
               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)
+                arg_defn = get_arg_definition(arg_owner, normalized_arg_name, context)
               end
               arg_base_type = arg_defn.type.unwrap
               # In the case where the value being emitted is seen as a "JSON"
@@ -113,22 +121,22 @@ module GraphQL
                 end
                 next_args[normalized_arg_name] = sorted_value.respond_to?(:to_json) ? sorted_value.to_json : sorted_value
               else
-                next_args[normalized_arg_name] = stringify_args(arg_base_type, v)
+                next_args[normalized_arg_name] = stringify_args(arg_base_type, v, context)
               end
             end
             # Make sure they're deeply sorted
             next_args.sort.to_h
           when Array
-            args.map { |a| stringify_args(arg_owner, a) }
+            args.map { |a| stringify_args(arg_owner, a, context) }
           when GraphQL::Schema::InputObject
-            stringify_args(arg_owner, args.to_h)
+            stringify_args(arg_owner, args.to_h, context)
           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 }
+        def get_arg_definition(arg_owner, arg_name, context)
+          arg_owner.get_argument(arg_name, context) || arg_owner.arguments(context).each_value.find { |v| v.keyword.to_s == arg_name }
         end
       end
     end

data/lib/graphql/subscriptions.rb

@@ -16,6 +16,13 @@ module GraphQL
     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
@@ -76,7 +83,8 @@ module GraphQL
       end
 
       # Normalize symbol-keyed args to strings, try camelizing them
-      normalized_args = normalize_arguments(normalized_event_name, field, args)
+      # 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,
@@ -151,16 +159,6 @@ module GraphQL
     # @param object [Object]
     # @return [void]
     def execute_all(event, object)
-      each_subscription_id(event) do |subscription_id|
-        execute(subscription_id, event, object)
-      end
-    end
-
-    # Get each `subscription_id` subscribed to `event.topic` and yield them
-    # @param event [GraphQL::Subscriptions::Event]
-    # @yieldparam subscription_id [String]
-    # @return [void]
-    def each_subscription_id(event)
       raise GraphQL::RequiredImplementationMissingError
     end
 
@@ -233,7 +231,7 @@ module GraphQL
     # @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)
+    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?
@@ -244,19 +242,19 @@ module GraphQL
         missing_arg_names = []
         args.each do |k, v|
           arg_name = k.to_s
-          arg_defn = arg_owner.arguments[arg_name]
+          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.arguments[normalized_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)
+            normalized = normalize_arguments(event_name, arg_defn.type, v, context)
             normalized_args[normalized_arg_name] = normalized
           else
             # Couldn't find a matching argument definition
@@ -266,12 +264,12 @@ module GraphQL
 
         # Backfill default values so that trigger arguments
         # match query arguments.
-        arg_owner.arguments.each do |name, arg_defn|
+        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: GraphQL::Query::NullContext)
+            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: context)
           end
         end
 
@@ -290,9 +288,9 @@ module GraphQL
 
         normalized_args
       when GraphQL::ListType, GraphQL::Schema::List
-        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
+        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)
+        normalize_arguments(event_name, arg_owner.of_type, args, context)
       else
         args
       end

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

@@ -22,7 +22,7 @@ module GraphQL
 
           def field_block
             Proc.new {
-              argument :id, "ID!", required: true,
+              argument :id, "ID!",
                 description: "ID of the object."
 
               def resolve(obj, args, ctx)

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

@@ -22,7 +22,7 @@ module GraphQL
 
           def field_block
             Proc.new {
-              argument :ids, "[ID!]!", required: true,
+              argument :ids, "[ID!]!",
                 description: "IDs of the objects."
 
               def resolve(obj, args, ctx)

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -55,31 +55,6 @@ module GraphQL
   def self.scan_with_ragel(graphql_string)
     GraphQL::Language::Lexer.tokenize(graphql_string)
   end
-
-  # Support Ruby 2.2 by implementing `-"str"`. If we drop 2.2 support, we can remove this backport.
-  if !String.method_defined?(:-@)
-    module StringDedupBackport
-      refine String do
-        def -@
-          if frozen?
-            self
-          else
-            self.dup.freeze
-          end
-        end
-      end
-    end
-  end
-
-  if !String.method_defined?(:match?)
-    module StringMatchBackport
-      refine String do
-        def match?(pattern)
-          self =~ pattern
-        end
-      end
-    end
-  end
 end
 
 # Order matters for these:
@@ -125,10 +100,13 @@ require "graphql/execution"
 require "graphql/pagination"
 require "graphql/schema"
 require "graphql/query"
+require "graphql/types"
+require "graphql/dataloader"
+require "graphql/filter"
+require "graphql/internal_representation"
 require "graphql/directive"
+require "graphql/static_validation"
 require "graphql/execution"
-require "graphql/types"
-require "graphql/relay"
 require "graphql/boolean_type"
 require "graphql/float_type"
 require "graphql/id_type"
@@ -137,11 +115,8 @@ require "graphql/string_type"
 require "graphql/schema/built_in_types"
 require "graphql/schema/loader"
 require "graphql/schema/printer"
-require "graphql/filter"
-require "graphql/internal_representation"
-require "graphql/static_validation"
-require "graphql/dataloader"
 require "graphql/introspection"
+require "graphql/relay"
 
 require "graphql/version"
 require "graphql/compatibility"
@@ -156,6 +131,9 @@ require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
 require "graphql/deprecation"
+require "graphql/directive/include_directive"
+require "graphql/directive/skip_directive"
+require "graphql/directive/deprecated_directive"
 
 module GraphQL
   # Ruby has `deprecate_constant`,

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.12.25
+  version: 1.13.0
 platform: ruby
 authors:
 - Robert Mosolgo
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-12 00:00:00.000000000 Z
+date: 2021-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -127,14 +128,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.68'
+        version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.68'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
@@ -466,6 +467,10 @@ files:
 - lib/graphql/relay/range_add.rb
 - lib/graphql/relay/relation_connection.rb
 - lib/graphql/relay/type_extensions.rb
+- lib/graphql/rubocop.rb
+- lib/graphql/rubocop/graphql/base_cop.rb
+- lib/graphql/rubocop/graphql/default_null_true.rb
+- lib/graphql/rubocop/graphql/default_required_true.rb
 - lib/graphql/runtime_type_error.rb
 - lib/graphql/scalar_type.rb
 - lib/graphql/schema.rb
@@ -513,6 +518,7 @@ files:
 - lib/graphql/schema/member/has_deprecation_reason.rb
 - lib/graphql/schema/member/has_directives.rb
 - lib/graphql/schema/member/has_fields.rb
+- lib/graphql/schema/member/has_interfaces.rb
 - lib/graphql/schema/member/has_path.rb
 - lib/graphql/schema/member/has_unresolved_type_error.rb
 - lib/graphql/schema/member/has_validators.rb
@@ -686,6 +692,7 @@ metadata:
   source_code_uri: https://github.com/rmosolgo/graphql-ruby
   bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
   mailing_list_uri: https://tinyletter.com/graphql-ruby
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -693,14 +700,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []