graphql 1.10.0.pre3 → 1.10.0.pre4

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/scalar_type.rb

@@ -1,63 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  # # GraphQL::ScalarType
-  #
-  # Scalars are plain values. They are leaf nodes in a GraphQL query tree.
-  #
-  # ## Built-in Scalars
-  #
-  # `GraphQL` comes with standard built-in scalars:
-  #
-  # |Constant | `.define` helper|
-  # |-------|--------|
-  # |`GraphQL::STRING_TYPE` | `types.String`|
-  # |`GraphQL::INT_TYPE` | `types.Int`|
-  # |`GraphQL::FLOAT_TYPE` | `types.Float`|
-  # |`GraphQL::ID_TYPE` | `types.ID`|
-  # |`GraphQL::BOOLEAN_TYPE` | `types.Boolean`|
-  #
-  # (`types` is an instance of `GraphQL::Definition::TypeDefiner`; `.String`, `.Float`, etc are methods which return built-in scalars.)
-  #
-  # ## Custom Scalars
-  #
-  # You can define custom scalars for your GraphQL server. It requires some special functions:
-  #
-  # - `coerce_input` is used to prepare incoming values for GraphQL execution. (Incoming values come from variables or literal values in the query string.)
-  # - `coerce_result` is used to turn Ruby values _back_ into serializable values for query responses.
-  #
-  # @example defining a type for Time
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value, ctx) { Time.at(Float(value)) }
-  #     coerce_result ->(value, ctx) { value.to_f }
-  #   end
-  #
-  #
-  # You can customize the error message for invalid input values by raising a `GraphQL::CoercionError` within `coerce_input`:
-  #
-  # @example raising a custom error message
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value, ctx) do
-  #       begin
-  #         Time.at(Float(value))
-  #       rescue ArgumentError
-  #         raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to Float"
-  #       end
-  #     end
-  #
-  #     coerce_result ->(value, ctx) { value.to_f }
-  #   end
-  #
-  # This will result in the message of the `GraphQL::CoercionError` being used in the error response:
-  #
-  # @example custom error response
-  #   {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
-  #
+  # @api deprecated
   class ScalarType < GraphQL::BaseType
     accepts_definitions :coerce, :coerce_input, :coerce_result
     ensure_defined :coerce_non_null_input, :coerce_result

data/lib/graphql/schema.rb

@@ -104,6 +104,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.graphql_name] = d; m } },
       directive: ->(schema, directive) { schema.directives[directive.graphql_name] = directive },
       instrument: ->(schema, type, instrumenter, after_built_ins: false) {
@@ -163,6 +165,20 @@ module GraphQL
       !!@disable_introspection_entry_points
     end
 
+    # [Boolean] True if this object disables the __schema introspection entry point field
+    attr_accessor :disable_schema_introspection_entry_point
+
+    def disable_schema_introspection_entry_point?
+      !!@disable_schema_introspection_entry_point
+    end
+
+    # [Boolean] True if this object disables the __type introspection entry point field
+    attr_accessor :disable_type_introspection_entry_point
+
+    def disable_type_introspection_entry_point?
+      !!@disable_type_introspection_entry_point
+    end
+
     class << self
       attr_writer :default_execution_strategy
     end
@@ -213,6 +229,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}
@@ -282,7 +300,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
@@ -730,9 +748,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}.
@@ -835,13 +856,13 @@ module GraphQL
         GraphQL::StaticValidation::Validator.new(schema: self)
       end
 
-      def use(plugin, options = {})
-        if options.any?
-          plugin.use(self, options)
+      def use(plugin, **kwargs)
+        if kwargs.any?
+          plugin.use(self, **kwargs)
         else
           plugin.use(self)
         end
-        own_plugins << [plugin, options]
+        own_plugins << [plugin, kwargs]
       end
 
       def plugins
@@ -860,6 +881,8 @@ module GraphQL
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types.map(&:graphql_definition)
         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}
@@ -1202,6 +1225,18 @@ module GraphQL
         @introspection_system = nil
       end
 
+      def disable_schema_introspection_entry_point
+        @disable_schema_introspection_entry_point = true
+        # TODO: this clears the cache made in `def types`. But this is not a great solution.
+        @introspection_system = nil
+      end
+
+      def disable_type_introspection_entry_point
+        @disable_type_introspection_entry_point = true
+        # TODO: this clears the cache made in `def types`. But this is not a great solution.
+        @introspection_system = nil
+      end
+
       def disable_introspection_entry_points?
         if instance_variable_defined?(:@disable_introspection_entry_points)
           @disable_introspection_entry_points
@@ -1210,6 +1245,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?
           new_orphan_types = new_orphan_types.flatten
@@ -1292,11 +1343,11 @@ module GraphQL
       end
 
       def visible?(member, ctx)
-        member.visible?(ctx)
+        member.type_class.visible?(ctx)
       end
 
       def accessible?(member, ctx)
-        member.accessible?(ctx)
+        member.type_class.accessible?(ctx)
       end
 
       # This hook is called when a client tries to access one or more

data/lib/graphql/schema/build_from_definition.rb

@@ -129,7 +129,11 @@ module GraphQL
             end
 
             using.each do |plugin, options|
-              use(plugin, options)
+              if options
+                use(plugin, **options)
+              else
+                use(plugin)
+              end
             end
           end
         end
@@ -196,6 +200,7 @@ module GraphQL
           builder = self
           type_def = nil
           typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
+
           Class.new(GraphQL::Schema::Object) do
             type_def = self
             graphql_name(object_type_definition.name)

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/enum_value.rb

@@ -26,6 +26,7 @@ module GraphQL
     #     enum_value_class CustomEnumValue
     #   end
     class EnumValue < GraphQL::Schema::Member
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode

data/lib/graphql/schema/introspection_system.rb

@@ -34,7 +34,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/list.rb

@@ -36,12 +36,16 @@ module GraphQL
       end
 
       def coerce_input(value, ctx)
-        Array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+        if value.nil?
+          nil
+        else
+          ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+        end
       end
 
       def validate_non_null_input(value, ctx)
         result = GraphQL::Query::InputValidationResult.new
-        Array(value).each_with_index do |item, index|
+        ensure_array(value).each_with_index do |item, index|
           item_result = of_type.validate_input(item, ctx)
           if !item_result.valid?
             result.merge_result!(index, item_result)
@@ -49,6 +53,17 @@ module GraphQL
         end
         result
       end
+
+      private
+
+      def ensure_array(value)
+        # `Array({ a: 1 })` makes `[[:a, 1]]`, so do it manually
+        if value.is_a?(Array)
+          value
+        else
+          [value]
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/loader.rb

@@ -124,14 +124,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/object.rb

@@ -57,13 +57,9 @@ module GraphQL
                 else
                   nil
                 end
-              # rescue GraphQL::ExecutionError => err
-              #   err
               end
             end
           end
-        # rescue GraphQL::ExecutionError => err
-        #   err
         end
       end
 

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

@@ -28,7 +28,7 @@ module GraphQL
       defn.instrument(:query, instrumentation)
       defn.instrument(:field, instrumentation)
       options[:schema] = schema
-      schema.subscriptions = self.new(options)
+      schema.subscriptions = self.new(**options)
       nil
     end
 
@@ -95,7 +95,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,