graphql 1.9.17 → 1.9.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0486697e594e11affbd5f7d0a661023e2a649abfa654e8faa26b5849fce0b473'
-  data.tar.gz: 3943f0dcdeb83dc593ddf675cee9143180d61ea25f454ac1ba6e8f098f4bfaf3
+  metadata.gz: dac791a669cb749de7dbbadbff748e28661e952b13a39ca288d94dd062a6f091
+  data.tar.gz: 4b95ab1279ba396004a3e0c1e3093ebbd45cdb07f3080e3445eb5c1d9a055741
 SHA512:
-  metadata.gz: 5075b2a02ca5dc3d219736b64b768ef6bbb46f09cebb92aac5ab5d3249b4675b229cb058fe44a328543328497f91658078919e04019857802f42e219585d11fa
-  data.tar.gz: 8236278511482220a05461616be330b7c629241f2cb092b67392412d4710c6f5ab2c8e75d342c598bb64bec0fa02b003972d9b1af971562ccaf765daac444492
+  metadata.gz: ee1e35c609f8cb231bbcddf1349f74911f0979a5811046de0172912ea984bd20b2034173be2e3722bcf323b582b0bf072fb1849e5c4bfa0d141a24006b412a5f
+  data.tar.gz: 91b97da692780076730ff580cfb5281f6116ee85ea097b1d7eaeed16c9f57f4ea936b6da9bc20c1015d8a63638eb054c096e47c2e802afea06ce76956e5753eb

data/lib/graphql/argument.rb

@@ -134,9 +134,9 @@ module GraphQL
       end
 
       if type_or_argument.is_a?(GraphQL::Argument)
-        type_or_argument.redefine(kwargs, &block)
+        type_or_argument.redefine(**kwargs, &block)
       else
-        GraphQL::Argument.define(kwargs, &block)
+        GraphQL::Argument.define(**kwargs, &block)
       end
     end
 

data/lib/graphql/define/assign_object_field.rb

@@ -28,9 +28,9 @@ module GraphQL
         end
 
         obj_field = if base_field
-          base_field.redefine(kwargs, &block)
+          base_field.redefine(**kwargs, &block)
         else
-          GraphQL::Field.define(kwargs, &block)
+          GraphQL::Field.define(**kwargs, &block)
         end
 
 

data/lib/graphql/define/defined_object_proxy.rb

@@ -32,10 +32,16 @@ module GraphQL
       end
 
       # Lookup a function from the dictionary and call it if it's found.
-      def method_missing(name, *args, &block)
+      def method_missing(name, *args, **kwargs, &block)
         definition = @dictionary[name]
         if definition
-          definition.call(@target, *args, &block)
+          # Avoid passing `kwargs` when it's not used.
+          # Ruby 2.7 does fine here, but older Rubies receive too many arguments.
+          if kwargs.any?
+            definition.call(@target, *args, **kwargs, &block)
+          else
+            definition.call(@target, *args, &block)
+          end
         else
           msg = "#{@target.class.name} can't define '#{name}'"
           raise NoDefinitionError, msg, caller

data/lib/graphql/define/instance_definable.rb

@@ -154,7 +154,12 @@ module GraphQL
             defn_proxy = DefinedObjectProxy.new(self)
             # Apply definition from `define(...)` kwargs
             defn.define_keywords.each do |keyword, value|
-              defn_proxy.public_send(keyword, value)
+              # Don't splat string hashes, which blows up on Rubies before 2.7
+              if value.is_a?(Hash) && value.each_key.all? { |k| k.is_a?(Symbol) }
+                defn_proxy.public_send(keyword, **value)
+              else
+                defn_proxy.public_send(keyword, value)
+              end
             end
             # and/or apply definition from `define { ... }` block
             if defn.define_proc

data/lib/graphql/execution/execute.rb

@@ -20,7 +20,7 @@ module GraphQL
 
       def execute(ast_operation, root_type, query)
         result = resolve_root_selection(query)
-        lazy_resolve_root_selection(result, {query: query})
+        lazy_resolve_root_selection(result, **{query: query})
         GraphQL::Execution::Flatten.call(query.context)
       end
 

data/lib/graphql/execution/multiplex.rb

@@ -44,9 +44,9 @@ module GraphQL
       end
 
       class << self
-        def run_all(schema, query_options, *args)
-          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, opts) }
-          run_queries(schema, queries, *args)
+        def run_all(schema, query_options, **kwargs)
+          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, **opts) }
+          run_queries(schema, queries, **kwargs)
         end
 
         # @param schema [GraphQL::Schema]

data/lib/graphql/language/document_from_schema_definition.rb

@@ -23,10 +23,16 @@ module GraphQL
         @include_built_in_scalars = include_built_in_scalars
         @include_built_in_directives = include_built_in_directives
 
+        filter = GraphQL::Filter.new(only: only, except: except)
+        if @schema.respond_to?(:visible?)
+          filter = filter.merge(only: @schema.method(:visible?))
+        end
+
+        schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
         @warden = GraphQL::Schema::Warden.new(
-          GraphQL::Filter.new(only: only, except: except),
+          filter,
           schema: @schema,
-          context: context,
+          context: schema_context,
         )
       end
 
@@ -250,7 +256,7 @@ module GraphQL
         definitions = []
         definitions << build_schema_node if include_schema_node?
         definitions += build_directive_nodes(warden.directives)
-        definitions += build_type_definition_nodes(warden.types)
+        definitions += build_type_definition_nodes(warden.reachable_types)
         definitions
       end
 

data/lib/graphql/language/nodes.rb

@@ -25,7 +25,7 @@ module GraphQL
         # Initialize a node by extracting its position,
         # then calling the class's `initialize_node` method.
         # @param options [Hash] Initial attributes for this node
-        def initialize(options={})
+        def initialize(options = {})
           if options.key?(:position_source)
             position_source = options.delete(:position_source)
             @line = position_source.line
@@ -34,7 +34,7 @@ module GraphQL
 
           @filename = options.delete(:filename)
 
-          initialize_node(options)
+          initialize_node(**options)
         end
 
         # Value equality

data/lib/graphql/query.rb

@@ -134,7 +134,6 @@ module GraphQL
       @executed = false
 
       # TODO add a general way to define schema-level filters
-      # TODO also add this to schema dumps
       if @schema.respond_to?(:visible?)
         merge_filters(only: @schema.method(:visible?))
       end

data/lib/graphql/query/context.rb

@@ -143,9 +143,9 @@ module GraphQL
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
-      def initialize(query:, values: , object:)
+      def initialize(query:, schema: query.schema, values:, object:)
         @query = query
-        @schema = query.schema
+        @schema = schema
         @provided_values = values || {}
         @object = object
         # Namespaced storage, where user-provided values are in `nil` namespace:
@@ -334,6 +334,3 @@ module GraphQL
     end
   end
 end
-
-
-GraphQL::Schema::Context = GraphQL::Query::Context

data/lib/graphql/relay/node.rb

@@ -11,7 +11,7 @@ module GraphQL
         field = GraphQL::Types::Relay::NodeField.graphql_definition
 
         if kwargs.any? || block
-          field = field.redefine(kwargs, &block)
+          field = field.redefine(**kwargs, &block)
         end
 
         field
@@ -21,7 +21,7 @@ module GraphQL
         field = GraphQL::Types::Relay::NodesField.graphql_definition
 
         if kwargs.any? || block
-          field = field.redefine(kwargs, &block)
+          field = field.redefine(**kwargs, &block)
         end
 
         field

data/lib/graphql/schema.rb

@@ -99,6 +99,8 @@ module GraphQL
       mutation: ->(schema, t) { schema.mutation = t.respond_to?(:graphql_definition) ? t.graphql_definition : t },
       subscription: ->(schema, t) { schema.subscription = t.respond_to?(:graphql_definition) ? t.graphql_definition : t },
       disable_introspection_entry_points: ->(schema) { schema.disable_introspection_entry_points = true },
+      disable_schema_introspection_entry_point: ->(schema) { schema.disable_schema_introspection_entry_point = true },
+      disable_type_introspection_entry_point: ->(schema) { schema.disable_type_introspection_entry_point = true },
       directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m } },
       directive: ->(schema, directive) { schema.directives[directive.graphql_name] = directive },
       instrument: ->(schema, type, instrumenter, after_built_ins: false) {
@@ -154,6 +156,12 @@ module GraphQL
     # [Boolean] True if this object disables the introspection entry point fields
     attr_accessor :disable_introspection_entry_points
 
+    # [Boolean] True if this object disables the __schema introspection entry point field
+    attr_accessor :disable_schema_introspection_entry_point
+
+    # [Boolean] True if this object disables the __type introspection entry point field
+    attr_accessor :disable_type_introspection_entry_point
+
     class << self
       attr_writer :default_execution_strategy
     end
@@ -203,6 +211,8 @@ module GraphQL
       @interpreter = false
       @error_bubbling = false
       @disable_introspection_entry_points = false
+      @disable_schema_introspection_entry_point = false
+      @disable_type_introspection_entry_point = false
     end
 
     # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
@@ -272,7 +282,7 @@ module GraphQL
       query = GraphQL::Query.new(self, document: doc, context: context)
       validator_opts = { schema: self }
       rules && (validator_opts[:rules] = rules)
-      validator = GraphQL::StaticValidation::Validator.new(validator_opts)
+      validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
       res = validator.validate(query)
       res[:errors]
     end
@@ -679,9 +689,12 @@ module GraphQL
     end
 
     # Return the GraphQL::Language::Document IDL AST for the schema
+    # @param context [Hash]
+    # @param only [<#call(member, ctx)>]
+    # @param except [<#call(member, ctx)>]
     # @return [GraphQL::Language::Document]
-    def to_document
-      GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
+    def to_document(only: nil, except: nil, context: {})
+      GraphQL::Language::DocumentFromSchemaDefinition.new(self, only: only, except: except, context: context).document
     end
 
     # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
@@ -732,13 +745,15 @@ module GraphQL
         :union_memberships,
         :get_field, :root_types, :references_to, :type_from_ast,
         :possible_types,
-        :disable_introspection_entry_points=
+        :disable_introspection_entry_points=,
+        :disable_schema_introspection_entry_point=,
+        :disable_type_introspection_entry_point=
 
       def graphql_definition
         @graphql_definition ||= to_graphql
       end
 
-      def use(plugin, options = {})
+      def use(plugin, **options)
         own_plugins << [plugin, options]
       end
 
@@ -758,6 +773,8 @@ module GraphQL
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types
         schema_defn.disable_introspection_entry_points = disable_introspection_entry_points?
+        schema_defn.disable_schema_introspection_entry_point = disable_schema_introspection_entry_point?
+        schema_defn.disable_type_introspection_entry_point = disable_type_introspection_entry_point?
 
         prepped_dirs = {}
         directives.each { |k, v| prepped_dirs[k] = v.graphql_definition}
@@ -913,6 +930,14 @@ module GraphQL
         @disable_introspection_entry_points = true
       end
 
+      def disable_schema_introspection_entry_point
+        @disable_schema_introspection_entry_point = true
+      end
+
+      def disable_type_introspection_entry_point
+        @disable_type_introspection_entry_point = true
+      end
+
       def disable_introspection_entry_points?
         if instance_variable_defined?(:@disable_introspection_entry_points)
           @disable_introspection_entry_points
@@ -921,6 +946,22 @@ module GraphQL
         end
       end
 
+      def disable_schema_introspection_entry_point?
+        if instance_variable_defined?(:@disable_schema_introspection_entry_point)
+          @disable_schema_introspection_entry_point
+        else
+          find_inherited_value(:disable_schema_introspection_entry_point?, false)
+        end
+      end
+
+      def disable_type_introspection_entry_point?
+        if instance_variable_defined?(:@disable_type_introspection_entry_point)
+          @disable_type_introspection_entry_point
+        else
+          find_inherited_value(:disable_type_introspection_entry_point?, false)
+        end
+      end
+
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
           own_orphan_types.concat(new_orphan_types.flatten)

data/lib/graphql/schema/build_from_definition.rb

@@ -183,12 +183,16 @@ module GraphQL
         def build_object_type(object_type_definition, type_resolver, default_resolve:)
           type_def = nil
           typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
-          type_def = GraphQL::ObjectType.define(
+          defns = {
             name: object_type_definition.name,
             description: object_type_definition.description,
-            fields: Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)],
             interfaces: object_type_definition.interfaces.map{ |interface_name| type_resolver.call(interface_name) },
-          )
+          }
+          obj_fields = Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)]
+          if obj_fields.any?
+            defns[:fields] = obj_fields
+          end
+          type_def = GraphQL::ObjectType.define(**defns)
           type_def.ast_node = object_type_definition
           type_def
         end
@@ -246,13 +250,19 @@ module GraphQL
         end
 
         def build_directive(directive_definition, type_resolver)
-          directive = GraphQL::Directive.define(
+          directive_args = Hash[build_directive_arguments(directive_definition, type_resolver)]
+
+          defn = {
             name: directive_definition.name,
             description: directive_definition.description,
-            arguments: Hash[build_directive_arguments(directive_definition, type_resolver)],
             locations: directive_definition.locations.map { |location| location.name.to_sym },
-          )
+          }
+
+          if directive_args.any?
+            defn[:arguments] = directive_args
+          end
 
+          directive = GraphQL::Directive.define(**defn)
           directive.ast_node = directive_definition
 
           directive
@@ -317,14 +327,21 @@ module GraphQL
               [argument.name, arg]
             end]
 
-            field = GraphQL::Field.define(
+            field = nil
+
+            defns = {
               name: field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
-              arguments: field_arguments,
               resolve: ->(obj, args, ctx) { default_resolve.call(field, obj, args, ctx) },
               deprecation_reason: build_deprecation_reason(field_definition.directives),
-            )
+            }
+
+            if field_arguments.any?
+              defns[:arguments] = field_arguments
+            end
+
+            field = GraphQL::Field.define(**defns)
 
             field.ast_node = field_definition
 

data/lib/graphql/schema/directive.rb

@@ -9,8 +9,14 @@ module GraphQL
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
       class << self
+        # Return a name based on the class name,
+        # but downcase the first letter.
         def default_graphql_name
-          super.downcase
+          @default_graphql_name ||= begin
+            camelized_name = super
+            camelized_name[0] = camelized_name[0].downcase
+            camelized_name
+          end
         end
 
         def locations(*new_locations)

data/lib/graphql/schema/introspection_system.rb

@@ -22,7 +22,10 @@ module GraphQL
           if schema.disable_introspection_entry_points
             {}
           else
-            get_fields_from_class(class_sym: :EntryPoints)
+            entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
+            entry_point_fields.delete('__schema') if schema.disable_schema_introspection_entry_point
+            entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point
+            entry_point_fields
           end
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
       end

data/lib/graphql/schema/loader.rb

@@ -118,14 +118,20 @@ module GraphQL
               }]
             )
           when "FIELD"
-            GraphQL::Field.define(
+            defns = {
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],
-              arguments: Hash[type["args"].map { |arg|
+            }
+
+            # Avoid passing an empty hash, which warns on Ruby 2.7
+            if type["args"].any?
+              defns[:arguments] = Hash[type["args"].map { |arg|
                 [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
               }]
-            )
+            end
+
+            GraphQL::Field.define(**defns)
           when "ARGUMENT"
             kwargs = {}
             if type["defaultValue"]

data/lib/graphql/schema/mutation.rb

@@ -64,7 +64,7 @@ module GraphQL
 
       class << self
         # Override this method to handle legacy-style usages of `MyMutation.field`
-        def field(*args, &block)
+        def field(*args, **kwargs, &block)
           if args.empty?
             raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
           else

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -61,7 +61,7 @@ module GraphQL
         end
 
         return_value = if input_kwargs.any?
-          super(input_kwargs)
+          super(**input_kwargs)
         else
           super()
         end

data/lib/graphql/schema/resolver.rb

@@ -76,7 +76,7 @@ module GraphQL
             context.schema.after_lazy(load_arguments_val) do |loaded_args|
               # Then call `authorized?`, which may raise or may return a lazy object
               authorized_val = if loaded_args.any?
-                authorized?(loaded_args)
+                authorized?(**loaded_args)
               else
                 authorized?
               end

data/lib/graphql/schema/subscription.rb

@@ -39,12 +39,12 @@ module GraphQL
       def resolve(**args)
         # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
         # have an unexpected `@mode`
-        public_send("resolve_#{@mode}", args)
+        public_send("resolve_#{@mode}", **args)
       end
 
       # Wrap the user-defined `#subscribe` hook
-      def resolve_subscribe(args)
-        ret_val = args.any? ? subscribe(args) : subscribe
+      def resolve_subscribe(**args)
+        ret_val = args.any? ? subscribe(**args) : subscribe
         if ret_val == :no_response
           context.skip
         else
@@ -62,8 +62,8 @@ module GraphQL
       end
 
       # Wrap the user-provided `#update` hook
-      def resolve_update(args)
-        ret_val = args.any? ? update(args) : update
+      def resolve_update(**args)
+        ret_val = args.any? ? update(**args) : update
         if ret_val == :no_update
           raise NoUpdateError
         else

data/lib/graphql/schema/type_membership.rb

@@ -19,7 +19,7 @@ module GraphQL
       # @param abstract_type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
       # @param object_type [Class<GraphQL::Schema::Object>]
       # @param options [Hash] Any options passed to `.possible_types` or `.implements`
-      def initialize(abstract_type, object_type, options)
+      def initialize(abstract_type, object_type, **options)
         @abstract_type = abstract_type
         @object_type = object_type
         @options = options

data/lib/graphql/schema/union.rb

@@ -8,7 +8,7 @@ module GraphQL
         def possible_types(*types, context: GraphQL::Query::NullContext, **options)
           if types.any?
             types.each do |t|
-              type_memberships << type_membership_class.new(self, t, options)
+              type_memberships << type_membership_class.new(self, t, **options)
             end
           else
             visible_types = []

data/lib/graphql/subscriptions.rb

@@ -20,7 +20,7 @@ module GraphQL
     def self.use(defn, options = {})
       schema = defn.target
       options[:schema] = schema
-      schema.subscriptions = self.new(options)
+      schema.subscriptions = self.new(**options)
       instrumentation = Subscriptions::Instrumentation.new(schema: schema)
       defn.instrument(:field, instrumentation)
       defn.instrument(:query, instrumentation)
@@ -90,7 +90,7 @@ module GraphQL
       operation_name = query_data.fetch(:operation_name)
       # Re-evaluate the saved query
       result = @schema.execute(
-        {
+        **{
           query: query_string,
           context: context,
           subscription_topic: event.topic,

data/lib/graphql/union_type.rb

@@ -24,8 +24,15 @@ module GraphQL
   #  }
   #
   class UnionType < GraphQL::BaseType
+    # Rubocop was unhappy about the syntax when this was a proc literal
+    class AcceptPossibleTypesDefinition
+      def self.call(target, possible_types, options = {})
+        target.add_possible_types(possible_types, **options)
+      end
+    end
+
     accepts_definitions :resolve_type, :type_membership_class,
-      possible_types: ->(target, possible_types, options = {}) { target.add_possible_types(possible_types, options) }
+      possible_types: AcceptPossibleTypesDefinition
     ensure_defined :possible_types, :resolve_type, :resolve_type_proc, :type_membership_class
 
     attr_accessor :resolve_type_proc
@@ -72,13 +79,13 @@ module GraphQL
       # This is a re-assignment, so clear the previous values
       @type_memberships = []
       @cached_possible_types = nil
-      add_possible_types(types, {})
+      add_possible_types(types, **{})
     end
 
-    def add_possible_types(types, options)
+    def add_possible_types(types, **options)
       @type_memberships ||= []
       Array(types).each { |t|
-        @type_memberships << self.type_membership_class.new(self, t, options)
+        @type_memberships << self.type_membership_class.new(self, t, **options)
       }
       nil
     end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.9.17
+  version: 1.9.18
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-17 00:00:00.000000000 Z
+date: 2020-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -198,14 +198,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11'
+        version: '12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11'
+        version: '12'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement