graphql 1.9.21 → 1.10.0.pre1

data/lib/graphql/query/variable_validation_error.rb

@@ -8,7 +8,7 @@ module GraphQL
         @value = value
         @validation_result = validation_result
 
-        msg = "Variable #{variable_ast.name} of type #{type} was provided invalid value"
+        msg = "Variable $#{variable_ast.name} of type #{type.to_type_signature} was provided invalid value"
 
         if problem_fields.any?
           msg += " for #{problem_fields.join(", ")}"

data/lib/graphql/query/variables.rb

@@ -21,7 +21,7 @@ module GraphQL
           # - First, use the value provided at runtime
           # - Then, fall back to the default value from the query string
           # If it's still nil, raise an error if it's required.
-          variable_type = schema.type_from_ast(ast_variable.type)
+          variable_type = schema.type_from_ast(ast_variable.type, context: ctx)
           if variable_type.nil?
             # Pass -- it will get handled by a validator
           else
@@ -35,9 +35,7 @@ module GraphQL
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = schema.error_handler.with_error_handling(context) do
-                    variable_type.coerce_input(provided_value, ctx)
-                  end
+                  memo[variable_name] = variable_type.coerce_input(provided_value, ctx)
                 elsif default_value != nil
                   # Add the variable if it wasn't provided but it has a default value (including `null`)
                   memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)

data/lib/graphql/relay/base_connection.rb

@@ -25,6 +25,10 @@ module GraphQL
         # @param nodes [Object] A collection of nodes (eg, Array, AR::Relation)
         # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
         def connection_for_nodes(nodes)
+          # If it's a new-style connection object, it's already ready to go
+          if nodes.is_a?(GraphQL::Pagination::Connection)
+            return nodes
+          end
           # Check for class _names_ because classes can be redefined in Rails development
           nodes.class.ancestors.each do |ancestor|
             conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
@@ -139,7 +143,7 @@ module GraphQL
 
       # An opaque operation which returns a connection-specific cursor.
       def cursor_from_node(object)
-        raise GraphQL::RequiredImplementationMissingError, "must return a cursor for this object/connection pair"
+        raise NotImplementedError, "must return a cursor for this object/connection pair"
       end
 
       def inspect
@@ -161,11 +165,11 @@ module GraphQL
       end
 
       def paged_nodes
-        raise GraphQL::RequiredImplementationMissingError, "must return nodes for this connection after paging"
+        raise NotImplementedError, "must return nodes for this connection after paging"
       end
 
       def sliced_nodes
-        raise GraphQL::RequiredImplementationMissingError, "must return  all nodes for this connection after chopping off first and last"
+        raise NotImplementedError, "must return  all nodes for this connection after chopping off first and last"
       end
     end
   end

data/lib/graphql/relay/edges_instrumentation.rb

@@ -31,7 +31,7 @@ module GraphQL
           if ctx.schema.lazy?(nodes)
             nodes
           else
-            nodes.map { |item| @edge_class.new(item, parent) }
+            nodes.map { |item| item.is_a?(GraphQL::Pagination::Connection::Edge) ? item : @edge_class.new(item, parent) }
           end
         end
       end

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/relay/relation_connection.rb

@@ -25,16 +25,12 @@ module GraphQL
 
       def has_next_page
         if first
-          if defined?(ActiveRecord::Relation) && nodes.is_a?(ActiveRecord::Relation)
-            initial_offset = after ? offset_from_cursor(after) : 0
-            return paged_nodes.length >= first && nodes.offset(first + initial_offset).exists?
-          end
-          return paged_nodes.length >= first && sliced_nodes_count > first
-        end
-        if GraphQL::Relay::ConnectionType.bidirectional_pagination && last
-          return sliced_nodes_count >= last
+          paged_nodes.length >= first && sliced_nodes_count > first
+        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && last
+          sliced_nodes_count >= last
+        else
+          false
         end
-        false
       end
 
       def has_previous_page

data/lib/graphql/schema.rb

@@ -40,7 +40,6 @@ require "graphql/schema/directive/include"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/transform"
-require "graphql/schema/type_membership"
 
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
@@ -82,6 +81,7 @@ module GraphQL
   class Schema
     extend Forwardable
     extend GraphQL::Schema::Member::AcceptsDefinition
+    extend GraphQL::Schema::Member::HasAstNode
     include GraphQL::Define::InstanceDefinable
     extend GraphQL::Schema::FindInheritedValue
 
@@ -99,8 +99,6 @@ 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) {
@@ -156,12 +154,6 @@ 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
@@ -211,8 +203,6 @@ 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 +272,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
@@ -292,13 +282,13 @@ module GraphQL
       ensure_defined
       # Assert that all necessary configs are present:
       validation_error = Validation.validate(self)
-      validation_error && raise(GraphQL::RequiredImplementationMissingError, validation_error)
+      validation_error && raise(NotImplementedError, validation_error)
       rebuild_artifacts
 
       @definition_error = nil
       nil
     rescue StandardError => err
-      if @raise_definition_error || err.is_a?(CyclicalDefinitionError) || err.is_a?(GraphQL::RequiredImplementationMissingError)
+      if @raise_definition_error || err.is_a?(CyclicalDefinitionError)
         raise
       else
         # Raise this error _later_ to avoid messing with Rails constant loading
@@ -453,17 +443,16 @@ module GraphQL
       @instrumented_field_map[type.graphql_name]
     end
 
-    def type_from_ast(ast_node)
+    def type_from_ast(ast_node, context:)
       GraphQL::Schema::TypeExpression.build_type(self.types, ast_node)
     end
 
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
-    # @param context [GraphQL::Query::Context] The context for the current query
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
-    def possible_types(type_defn, context = GraphQL::Query::NullContext)
+    def possible_types(type_defn)
       @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
-      @possible_types.possible_types(type_defn, context)
+      @possible_types.possible_types(type_defn)
     end
 
     # @see [GraphQL::Schema::Warden] Resticted access to root types
@@ -504,7 +493,7 @@ module GraphQL
     def resolve_type(type, object, ctx = :__undefined__)
       check_resolved_type(type, object, ctx) do |ok_type, ok_object, ok_ctx|
         if @resolve_type_proc.nil?
-          raise(GraphQL::RequiredImplementationMissingError, "Can't determine GraphQL type for: #{ok_object.inspect}, define `resolve_type (type, obj, ctx) -> { ... }` inside `Schema.define`.")
+          raise(NotImplementedError, "Can't determine GraphQL type for: #{ok_object.inspect}, define `resolve_type (type, obj, ctx) -> { ... }` inside `Schema.define`.")
         end
         @resolve_type_proc.call(ok_type, ok_object, ok_ctx)
       end
@@ -565,7 +554,7 @@ module GraphQL
     # @return [Any] The application object identified by `id`
     def object_from_id(id, ctx)
       if @object_from_id_proc.nil?
-        raise(GraphQL::RequiredImplementationMissingError, "Can't fetch an object for id \"#{id}\" because the schema's `object_from_id (id, ctx) -> { ... }` function is not defined")
+        raise(NotImplementedError, "Can't fetch an object for id \"#{id}\" because the schema's `object_from_id (id, ctx) -> { ... }` function is not defined")
       else
         @object_from_id_proc.call(id, ctx)
       end
@@ -609,7 +598,6 @@ module GraphQL
     alias :_schema_class :class
     def_delegators :_schema_class, :visible?, :accessible?, :authorized?, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
-    def_delegators :_schema_class, :error_handler
 
     # A function to call when {#execute} receives an invalid query string
     #
@@ -633,7 +621,7 @@ module GraphQL
     # @return [String] a unique identifier for `object` which clients can use to refetch it
     def id_from_object(object, type, ctx)
       if @id_from_object_proc.nil?
-        raise(GraphQL::RequiredImplementationMissingError, "Can't generate an ID for #{object.inspect} of type #{type}, schema's `id_from_object` must be defined")
+        raise(NotImplementedError, "Can't generate an ID for #{object.inspect} of type #{type}, schema's `id_from_object` must be defined")
       else
         @id_from_object_proc.call(object, type, ctx)
       end
@@ -689,12 +677,9 @@ 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(only: nil, except: nil, context: {})
-      GraphQL::Language::DocumentFromSchemaDefinition.new(self, only: only, except: except, context: context).document
+    def to_document
+      GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
     end
 
     # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
@@ -713,6 +698,12 @@ module GraphQL
       JSON.pretty_generate(as_json(*args))
     end
 
+    def new_connections?
+      !!connections
+    end
+
+    attr_accessor :connections
+
     class << self
       extend Forwardable
       # For compatibility, these methods all:
@@ -721,7 +712,7 @@ module GraphQL
       # Eventually, the methods will be moved into this class, removing the need for the singleton.
       def_delegators :graphql_definition,
         # Schema structure
-        :as_json, :to_json, :to_document, :to_definition, :ast_node,
+        :as_json, :to_json, :to_document, :to_definition,
         # Execution
         :execute, :multiplex,
         :static_validator, :introspection_system,
@@ -745,15 +736,13 @@ module GraphQL
         :union_memberships,
         :get_field, :root_types, :references_to, :type_from_ast,
         :possible_types,
-        :disable_introspection_entry_points=,
-        :disable_schema_introspection_entry_point=,
-        :disable_type_introspection_entry_point=
+        :disable_introspection_entry_points=
 
       def graphql_definition
         @graphql_definition ||= to_graphql
       end
 
-      def use(plugin, **options)
+      def use(plugin, options = {})
         own_plugins << [plugin, options]
       end
 
@@ -773,8 +762,6 @@ 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}
@@ -828,6 +815,9 @@ module GraphQL
         schema_defn
       end
 
+      # @return [GraphQL::Pagination::Connections] if installed
+      attr_accessor :connections
+
       def query(new_query_object = nil)
         if new_query_object
           @query_object = new_query_object
@@ -930,14 +920,6 @@ 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
@@ -946,22 +928,6 @@ 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)
@@ -1000,16 +966,16 @@ module GraphQL
         if type.kind.object?
           type
         else
-          raise GraphQL::RequiredImplementationMissingError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
+          raise NotImplementedError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
         end
       end
 
       def object_from_id(node_id, ctx)
-        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
+        raise NotImplementedError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
       end
 
       def id_from_object(object, type, ctx)
-        raise GraphQL::RequiredImplementationMissingError, "#{self.name}.id_from_object(object, type, ctx) must be implemented to create global ids (tried to create an id for `#{object.inspect}`)"
+        raise NotImplementedError, "#{self.name}.id_from_object(object, type, ctx) must be implemented to create global ids (tried to create an id for `#{object.inspect}`)"
       end
 
       def visible?(member, context)
@@ -1071,13 +1037,6 @@ module GraphQL
         DefaultTypeError.call(type_err, ctx)
       end
 
-      attr_writer :error_handler
-
-      # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
-      def error_handler
-        @error_handler ||= GraphQL::Execution::Errors::NullErrorHandler
-      end
-
       def lazy_resolve(lazy_class, value_method)
         lazy_classes[lazy_class] = value_method
       end

data/lib/graphql/schema/argument.rb

@@ -5,6 +5,7 @@ module GraphQL
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
+      include GraphQL::Schema::Member::HasAstNode
 
       NO_DEFAULT = :__no_default__
 
@@ -93,7 +94,35 @@ module GraphQL
         true
       end
 
-      def authorized?(obj, ctx)
+      def authorized?(obj, value, ctx)
+        authorized_as_type?(obj, value, ctx, as_type: type)
+      end
+
+      def authorized_as_type?(obj, value, ctx, as_type:)
+        if value.nil?
+          return true
+        end
+
+        if as_type.kind.non_null?
+          as_type = as_type.of_type
+        end
+
+        if as_type.kind.list?
+          value.each do |v|
+            if !authorized_as_type?(obj, v, ctx, as_type: as_type.of_type)
+              return false
+            end
+          end
+        elsif as_type.kind.input_object?
+          as_type.arguments.each do |_name, input_obj_arg|
+            input_obj_arg = input_obj_arg.type_class
+            if value.key?(input_obj_arg.keyword) &&  !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
+              return false
+            end
+          end
+        end
+        # None of the early-return conditions were activated,
+        # so this is authorized.
         true
       end
 
@@ -104,6 +133,7 @@ module GraphQL
         argument.description = @description
         argument.metadata[:type_class] = self
         argument.as = @as
+        argument.ast_node = ast_node
         argument.method_access = @method_access
         if NO_DEFAULT != @default_value
           argument.default_value = @default_value
@@ -121,10 +151,6 @@ module GraphQL
       # Used by the runtime.
       # @api private
       def prepare_value(obj, value)
-        if value.is_a?(GraphQL::Schema::InputObject)
-          value = value.prepare
-        end
-
         if @prepare.nil?
           value
         elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)

data/lib/graphql/schema/base_64_bp.rb

@@ -10,9 +10,8 @@ module Base64Bp
   module_function
 
   def urlsafe_encode64(bin, padding:)
-    str = strict_encode64(bin)
-    str.tr!("+/", "-_")
-    str.delete!("=") unless padding
+    str = strict_encode64(bin).tr("+/", "-_")
+    str = str.delete("=") unless padding
     str
   end