graphql 1.8.6 → 1.8.7

data/lib/graphql/schema/non_null.rb

@@ -2,20 +2,19 @@
 
 module GraphQL
   class Schema
+    # Represents a non null type in the schema.
     # Wraps a {Schema::Member} when it is required.
     # @see {Schema::Member::TypeSystemHelpers#to_non_null_type}
-    class NonNull
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::TypeSystemHelpers
-      attr_reader :of_type
-      def initialize(of_type)
-        @of_type = of_type
-      end
-
+    class NonNull < GraphQL::Schema::Wrapper
       def to_graphql
         @of_type.graphql_definition.to_non_null_type
       end
 
+       # @return [GraphQL::TypeKinds::NON_NULL]
+      def kind
+        GraphQL::TypeKinds::NON_NULL
+      end
+
       # @return [true]
       def non_null?
         true
@@ -25,15 +24,7 @@ module GraphQL
       def list?
         @of_type.list?
       end
-
-      def kind
-        GraphQL::TypeKinds::NON_NULL
-      end
-
-      def unwrap
-        @of_type.unwrap
-      end
-
+      
       def to_type_signature
         "#{@of_type.to_type_signature}!"
       end

data/lib/graphql/schema/resolver.rb

@@ -48,25 +48,50 @@ module GraphQL
       # the user-defined `#resolve` method.
       # @api private
       def resolve_with_support(**args)
-        # First call the before_prepare hook which may raise
-        before_prepare_val = if args.any?
-          before_prepare(**args)
+        # First call the ready? hook which may raise
+        ready_val = if args.any?
+          ready?(**args)
         else
-          before_prepare
+          ready?
         end
-        context.schema.after_lazy(before_prepare_val) do
-          # Then call each prepare hook, which may return a different value
-          # for that argument, or may return a lazy object
-          load_arguments_val = load_arguments(args)
-          context.schema.after_lazy(load_arguments_val) do |loaded_args|
-            # Then validate each argument, which may raise or may return a lazy object
-            validate_arguments_val = validate_arguments(loaded_args)
-            context.schema.after_lazy(validate_arguments_val) do |validated_args|
-              # Finally, all the hooks have passed, so resolve it
-              if validated_args.any?
-                public_send(self.class.resolve_method, **validated_args)
+        context.schema.after_lazy(ready_val) do |is_ready, ready_early_return|
+          if ready_early_return
+            if is_ready != false
+              raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{ready_early_return.inspect}]"
+            else
+              ready_early_return
+            end
+          elsif is_ready
+            # Then call each prepare hook, which may return a different value
+            # for that argument, or may return a lazy object
+            load_arguments_val = load_arguments(args)
+            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)
               else
-                public_send(self.class.resolve_method)
+                authorized?
+              end
+              authorized?(loaded_args)
+              context.schema.after_lazy(authorized_val) do |(authorized_result, early_return)|
+                # If the `authorized?` returned two values, `false, early_return`,
+                # then use the early return value instead of continuing
+                if early_return
+                  if authorized_result == false
+                    early_return
+                  else
+                    raise "Unexpected result from #authorized? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{early_return.inspect}]"
+                  end
+                elsif authorized_result
+                  # Finally, all the hooks have passed, so resolve it
+                  if loaded_args.any?
+                    public_send(self.class.resolve_method, **loaded_args)
+                  else
+                    public_send(self.class.resolve_method)
+                  end
+                else
+                  nil
+                end
               end
             end
           end
@@ -88,7 +113,20 @@ module GraphQL
       # @param args [Hash] The input arguments, if there are any
       # @raise [GraphQL::ExecutionError] To add an error to the response
       # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
-      def before_prepare(**args)
+      # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
+      def ready?(**args)
+        true
+      end
+
+      # Called after arguments are loaded, but before resolving.
+      #
+      # Override it to check everything before calling the mutation.
+      # @param args [Hash] The input arguments
+      # @raise [GraphQL::ExecutionError] To add an error to the response
+      # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
+      # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
+      def authorized?(**args)
+        true
       end
 
       private
@@ -124,31 +162,6 @@ module GraphQL
         public_send("load_#{name}", value)
       end
 
-      # TODO dedup with load_arguments
-      def validate_arguments(args)
-        validate_lazies = []
-        args.each do |key, value|
-          arg_defn = @arguments_by_keyword[key]
-          if arg_defn
-            validate_return = validate_argument(key, value)
-            if context.schema.lazy?(validate_return)
-              validate_lazies << context.schema.after_lazy(validate_return).then { "no-op" }
-            end
-          end
-        end
-
-        # Avoid returning a lazy if none are needed
-        if validate_lazies.any?
-          GraphQL::Execution::Lazy.all(validate_lazies).then { args }
-        else
-          args
-        end
-      end
-
-      def validate_argument(name, value)
-        public_send("validate_#{name}", value)
-      end
-
       class LoadApplicationObjectFailedError < GraphQL::ExecutionError
         # @return [GraphQL::Schema::Argument] the argument definition for the argument that was looked up
         attr_reader :argument
@@ -164,43 +177,58 @@ module GraphQL
         end
       end
 
+      # Look up the corresponding object for a provided ID.
+      # By default, it uses Relay-style {Schema.object_from_id},
+      # override this to find objects another way.
+      #
+      # @param type [Class, Module] A GraphQL type definition
+      # @param id [String] A client-provided to look up
+      # @param context [GraphQL::Query::Context] the current context
+      def object_from_id(type, id, context)
+        context.schema.object_from_id(id, context)
+      end
+
       def load_application_object(arg_kwarg, id)
         argument = @arguments_by_keyword[arg_kwarg]
-        # See if any object can be found for this ID
-        application_object = context.schema.object_from_id(id, context)
-        if application_object.nil?
-          raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-        end
-        # Double-check that the located object is actually of this type
-        # (Don't want to allow arbitrary access to objects this way)
         lookup_as_type = @arguments_loads_as_type[arg_kwarg]
-        application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
-        possible_object_types = context.schema.possible_types(lookup_as_type)
-        if !possible_object_types.include?(application_object_type)
-          raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-        else
-          # This object was loaded successfully
-          # and resolved to the right type,
-          # now apply the `.authorized?` class method if there is one
-          if (class_based_type = application_object_type.metadata[:type_class])
-            context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
-              if authed
-                application_object
+        # See if any object can be found for this ID
+        loaded_application_object = object_from_id(lookup_as_type, id, context)
+        context.schema.after_lazy(loaded_application_object) do |application_object|
+          begin
+            if application_object.nil?
+              raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+            end
+            # Double-check that the located object is actually of this type
+            # (Don't want to allow arbitrary access to objects this way)
+            application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
+            possible_object_types = context.schema.possible_types(lookup_as_type)
+            if !possible_object_types.include?(application_object_type)
+              raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+            else
+              # This object was loaded successfully
+              # and resolved to the right type,
+              # now apply the `.authorized?` class method if there is one
+              if (class_based_type = application_object_type.metadata[:type_class])
+                context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
+                  if authed
+                    application_object
+                  else
+                    raise GraphQL::UnauthorizedError.new(
+                      object: application_object,
+                      type: class_based_type,
+                      context: context,
+                    )
+                  end
+                end
               else
-                raise GraphQL::UnauthorizedError.new(
-                  object: application_object,
-                  type: class_based_type,
-                  context: context,
-                )
+                application_object
               end
             end
-          else
-            application_object
+          rescue LoadApplicationObjectFailedError => err
+            # pass it to a handler
+            load_application_object_failed(err)
           end
         end
-      rescue LoadApplicationObjectFailedError => err
-        # pass it to a handler
-        load_application_object_failed(err)
       end
 
       def load_application_object_failed(err)
@@ -315,11 +343,6 @@ module GraphQL
             RUBY
           end
 
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def validate_#{arg_defn.keyword}(value)
-            # No-op
-          end
-          RUBY
           arg_defn
         end
 

data/lib/graphql/schema/unique_within_type.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require 'graphql/schema/base_64_bp'
+
 module GraphQL
   class Schema
     module UniqueWithinType
@@ -25,7 +27,8 @@ module GraphQL
       # @param node_id [String] A unique ID generated by {.encode}
       # @return [Array<(String, String)>] The type name & value passed to {.encode}
       def decode(node_id, separator: self.default_id_separator)
-        Base64.decode64(node_id).split(separator, 2)
+        # urlsafe_decode64 is for forward compatibility
+        Base64Bp.urlsafe_decode64(node_id).split(separator, 2)
       end
     end
   end

data/lib/graphql/schema/wrapper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Wrapper
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::TypeSystemHelpers
+
+      # @return [Class, Module] The inner type of this wrapping type, the type of which one or more objects may be present.
+      attr_reader :of_type
+
+      def initialize(of_type)
+        @of_type = of_type
+      end
+
+      def to_graphql
+        raise NotImplementedError
+      end
+
+      def unwrap
+        @of_type.unwrap
+      end
+
+      def ==(other)
+        self.class == other.class && of_type == other.of_type
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/validation_context.rb

@@ -14,9 +14,7 @@ module GraphQL
     class ValidationContext
       extend Forwardable
 
-      attr_reader :query, :schema,
-        :document, :errors, :visitor,
-        :warden, :dependencies, :each_irep_node_handlers
+      attr_reader :query, :errors, :visitor, :dependencies, :each_irep_node_handlers
 
       def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -39,7 +39,7 @@ module GraphQL
     #       })
     #
     #       payload = {
-    #         result: result.subscription? ? {data: nil} : result.to_h,
+    #         result: result.subscription? ? nil : result.to_h,
     #         more: result.subscription?,
     #       }
     #

data/lib/graphql/type_kinds.rb

@@ -29,6 +29,38 @@ module GraphQL
       def to_s;       @name;      end
       # Is this TypeKind composed of many values?
       def composite?; @composite; end
+
+      def scalar?
+        self == TypeKinds::SCALAR
+      end
+
+      def object?
+        self == TypeKinds::OBJECT
+      end
+
+      def interface?
+        self == TypeKinds::INTERFACE
+      end
+
+      def union?
+        self == TypeKinds::UNION
+      end
+
+      def enum?
+        self == TypeKinds::ENUM
+      end
+
+      def input_object?
+        self == TypeKinds::INPUT_OBJECT
+      end
+
+      def list?
+        self == TypeKinds::LIST
+      end
+
+      def non_null?
+        self == TypeKinds::NON_NULL
+      end
     end
 
     TYPE_KINDS = [
@@ -41,13 +73,5 @@ module GraphQL
       LIST =          TypeKind.new("LIST", wraps: true, description: 'Indicates this type is a list. `ofType` is a valid field.'),
       NON_NULL =      TypeKind.new("NON_NULL", wraps: true, description: 'Indicates this type is a non-null. `ofType` is a valid field.'),
     ]
-
-    class TypeKind
-      TYPE_KINDS.map(&:name).each do |kind_name|
-        define_method("#{kind_name.downcase}?") do
-          self.name == kind_name
-        end
-      end
-    end
   end
 end

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

@@ -35,9 +35,6 @@ module GraphQL
           # @return [Class]
           attr_reader :node_type
 
-          # @return [Class]
-          attr_reader :edge_type
-
           # Configure this connection to return `edges` and `nodes` based on `edge_type_class`.
           #
           # This method will use the inputs to create:
@@ -66,11 +63,28 @@ module GraphQL
             description("The connection type for #{node_type_name}.")
           end
 
+          # Filter this list according to the way its node type would scope them
+          def scope_items(items, context)
+            node_type.scope_items(items, context)
+          end
+
           # Add the shortcut `nodes` field to this connection and its subclasses
           def nodes_field
             define_nodes_field
           end
 
+          def authorized?(obj, ctx)
+            true # Let nodes be filtered out
+          end
+
+          def accessible?(ctx)
+            node_type.accessible?(ctx)
+          end
+
+          def visible?(ctx)
+            node_type.visible?(ctx)
+          end
+
           private
 
           def define_nodes_field

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

@@ -39,6 +39,18 @@ module GraphQL
             end
             @node_type
           end
+
+          def authorized?(obj, ctx)
+            true
+          end
+
+          def accessible?(ctx)
+            node_type.accessible?(ctx)
+          end
+
+          def visible?(ctx)
+            node_type.visible?(ctx)
+          end
         end
 
 

data/lib/graphql/version.rb

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