graphql 1.8.6 → 1.8.7

data/lib/graphql/relay/mutation.rb

@@ -101,7 +101,8 @@ module GraphQL
         return_field: GraphQL::Define::AssignObjectField,
         function: GraphQL::Define::AssignMutationFunction,
       )
-      attr_accessor :name, :description, :fields, :arguments, :return_type, :return_interfaces
+      attr_accessor :name, :description, :fields, :arguments
+      attr_writer :return_type, :return_interfaces
 
       ensure_defined(
         :input_fields, :return_fields, :name, :description,

data/lib/graphql/schema.rb

@@ -21,6 +21,7 @@ require "graphql/schema/build_from_definition"
 
 
 require "graphql/schema/member"
+require "graphql/schema/wrapper"
 require "graphql/schema/list"
 require "graphql/schema/non_null"
 require "graphql/schema/argument"
@@ -122,7 +123,7 @@ module GraphQL
     attr_accessor :context_class
 
     class << self
-      attr_accessor :default_execution_strategy
+      attr_writer :default_execution_strategy
     end
 
     def default_filter
@@ -654,7 +655,7 @@ module GraphQL
         # Execution
         :execute, :multiplex,
         :static_validator, :introspection_system,
-        :query_analyzers, :middleware, :tracers, :instrumenters,
+        :query_analyzers, :tracers, :instrumenters,
         :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
         :validate, :multiplex_analyzers, :lazy?, :lazy_method_name, :after_lazy,
         # Configuration
@@ -663,7 +664,7 @@ module GraphQL
         :default_mask,
         :default_filter, :redefine,
         :id_from_object_proc, :object_from_id_proc,
-        :id_from_object=, :object_from_id=, :type_error,
+        :id_from_object=, :object_from_id=,
         :remove_handler,
         # Members
         :types, :get_fields, :find,
@@ -671,7 +672,7 @@ module GraphQL
         :subscriptions,
         :union_memberships,
         :get_field, :root_types, :references_to, :type_from_ast,
-        :possible_types, :get_field
+        :possible_types
 
       def graphql_definition
         @graphql_definition ||= to_graphql

data/lib/graphql/schema/base_64_bp.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+# backport from ruby v2.5 to v2.2 that has no `padding` things
+# @api private
+module Base64Bp
+  extend Base64
+
+  module_function
+
+  def urlsafe_encode64(bin, padding:)
+    str = strict_encode64(bin).tr("+/", "-_")
+    str = str.delete("=") unless padding
+    str
+  end
+
+  def urlsafe_decode64(str)
+    str = str.tr("-_", "+/")
+    if !str.end_with?("=") && str.length % 4 != 0
+      str = str.ljust((str.length + 3) & ~3, "=")
+    end
+    strict_decode64(str)
+  end
+end

data/lib/graphql/schema/base_64_encoder.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'graphql/schema/base_64_bp'
+
 module GraphQL
   class Schema
     # @api private
@@ -8,7 +11,8 @@ module GraphQL
       end
 
       def self.decode(ciphertext, nonce: false)
-        Base64.decode64(ciphertext)
+        # urlsafe_decode64 is for forward compatibility
+        Base64Bp.urlsafe_decode64(ciphertext)
       end
     end
   end

data/lib/graphql/schema/field.rb

@@ -11,8 +11,7 @@ module GraphQL
       attr_reader :name
       alias :graphql_name :name
 
-      # @return [String]
-      attr_accessor :description
+      attr_writer :description
 
       # @return [String, nil] If present, the field is marked as deprecated with this documentation
       attr_accessor :deprecation_reason
@@ -77,6 +76,34 @@ module GraphQL
         new(**kwargs, &block)
       end
 
+      # Can be set with `connection: true|false` or inferred from a type name ending in `*Connection`
+      # @return [Boolean] if true, this field will be wrapped with Relay connection behavior
+      def connection?
+        if @connection.nil?
+          # Provide default based on type name
+          return_type_name = if (contains_type = @field || @function)
+            Member::BuildType.to_type_name(contains_type.type)
+          elsif @return_type_expr
+            Member::BuildType.to_type_name(@return_type_expr)
+          else
+            raise "No connection info possible"
+          end
+          @connection = return_type_name.end_with?("Connection")
+        else
+          @connection
+        end
+      end
+
+      # @return [Boolean] if true, the return type's `.scope_items` method will be applied to this field's return value
+      def scoped?
+        if !@scope.nil?
+          # The default was overridden
+          @scope
+        else
+          @return_type_expr && type.unwrap.respond_to?(:scope_items) && (connection? || type.list?)
+        end
+      end
+
       # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
       # @param return_type_expr [Class, GraphQL::BaseType, Array] The return type of this field
       # @param desc [String] Field description
@@ -96,13 +123,14 @@ module GraphQL
       # @param arguments [{String=>GraphQL::Schema::Argument, Hash}] Arguments for this field (may be added in the block, also)
       # @param camelize [Boolean] If true, the field name will be camelized when building the schema
       # @param complexity [Numeric] When provided, set the complexity for this field
+      # @param scope [Boolean] If true, the return type's `.scope_items` method will be called on the return value
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], resolver_class: nil, subscription_scope: nil, arguments: {}, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, scope: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], resolver_class: nil, subscription_scope: nil, arguments: {}, &definition_block)
 
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
-        if !(field || function || mutation || resolver)
+        if !(field || function || resolver_class)
           if type.nil?
             raise ArgumentError, "missing second `type` argument or keyword `type:`"
           end
@@ -110,8 +138,8 @@ module GraphQL
             raise ArgumentError, "missing keyword argument null:"
           end
         end
-        if (field || function || resolve || mutation) && extras.any?
-          raise ArgumentError, "keyword `extras:` may only be used with method-based resolve, please remove `field:`, `function:`, `resolve:`, or `mutation:`"
+        if (field || function || resolve) && extras.any?
+          raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
         end
         @name = camelize ? Member::BuildType.camelize(name.to_s) : name.to_s
         @description = description
@@ -140,6 +168,7 @@ module GraphQL
         @introspection = introspection
         @extras = extras
         @resolver_class = resolver_class
+        @scope = scope
 
         # Override the default from HasArguments
         @own_arguments = {}
@@ -163,6 +192,8 @@ module GraphQL
         end
       end
 
+      # @param text [String]
+      # @return [String]
       def description(text = nil)
         if text
           @description = text
@@ -211,18 +242,6 @@ module GraphQL
           field_defn.type = -> { type }
         end
 
-        if @connection.nil?
-          # Provide default based on type name
-          return_type_name = if @field || @function
-            Member::BuildType.to_type_name(field_defn.type)
-          elsif @return_type_expr
-            Member::BuildType.to_type_name(@return_type_expr)
-          else
-            raise "No connection info possible"
-          end
-          @connection = return_type_name.end_with?("Connection")
-        end
-
         if @description
           field_defn.description = @description
         end
@@ -239,14 +258,14 @@ module GraphQL
         end
 
         field_defn.resolve = self.method(:resolve_field)
-        field_defn.connection = @connection
+        field_defn.connection = connection?
         field_defn.connection_max_page_size = @max_page_size
         field_defn.introspection = @introspection
         field_defn.complexity = @complexity
         field_defn.subscription_scope = @subscription_scope
 
         # apply this first, so it can be overriden below
-        if @connection
+        if connection?
           # TODO: this could be a bit weird, because these fields won't be present
           # after initialization, only in the `to_graphql` response.
           # This calculation _could_ be moved up if need be.
@@ -316,7 +335,7 @@ module GraphQL
           inner_obj = after_obj && after_obj.object
           if authorized?(inner_obj, query_ctx) && arguments.each_value.all? { |a| a.authorized?(inner_obj, query_ctx) }
             # Then if it passed, resolve the field
-            if @resolve_proc
+            v = if @resolve_proc
               # Might be nil, still want to call the func in that case
               @resolve_proc.call(inner_obj, args, ctx)
             elsif @resolver_class
@@ -325,6 +344,7 @@ module GraphQL
             else
               public_send_field(after_obj, args, ctx)
             end
+            apply_scope(v, ctx)
           else
             nil
           end
@@ -370,6 +390,16 @@ module GraphQL
 
       private
 
+      def apply_scope(value, ctx)
+        if scoped?
+          ctx.schema.after_lazy(value) do |inner_value|
+            @type.unwrap.scope_items(inner_value, ctx)
+          end
+        else
+          value
+        end
+      end
+
       NO_ARGS = {}.freeze
 
       def public_send_field(obj, graphql_args, field_ctx)
@@ -384,7 +414,7 @@ module GraphQL
             end
           end
 
-          if @connection
+          if connection?
             # Remove pagination args before passing it to a user method
             ruby_kwargs.delete(:first)
             ruby_kwargs.delete(:last)

data/lib/graphql/schema/interface.rb

@@ -9,6 +9,8 @@ module GraphQL
         include GraphQL::Schema::Member::BaseDSLMethods
         include GraphQL::Schema::Member::TypeSystemHelpers
         include GraphQL::Schema::Member::HasFields
+        include GraphQL::Schema::Member::RelayShortcuts
+        include GraphQL::Schema::Member::Scoped
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface

data/lib/graphql/schema/list.rb

@@ -5,29 +5,17 @@ module GraphQL
     # Represents a list type in the schema.
     # Wraps a {Schema::Member} as a list type.
     # @see {Schema::Member::TypeSystemHelpers#to_list_type}
-    class List
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::TypeSystemHelpers
-
-      # @return [Class, Module] The inner type of this list, the type of which one or more objects may be present.
-      attr_reader :of_type
-
-      def initialize(of_type)
-        @of_type = of_type
-      end
-
+    class List < GraphQL::Schema::Wrapper
       def to_graphql
         @of_type.graphql_definition.to_list_type
       end
 
+      # @return [GraphQL::TypeKinds::LIST]
       def kind
         GraphQL::TypeKinds::LIST
       end
 
-      def unwrap
-        @of_type.unwrap
-      end
-
+      # @return [true]
       def list?
         true
       end

data/lib/graphql/schema/member.rb

@@ -3,21 +3,25 @@ require 'graphql/schema/member/accepts_definition'
 require 'graphql/schema/member/base_dsl_methods'
 require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
+require 'graphql/schema/member/relay_shortcuts'
+require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
 require "graphql/relay/type_extensions"
 
 module GraphQL
-  # The base class for things that make up the schema,
-  # eg objects, enums, scalars.
-  #
-  # @api private
   class Schema
+    # The base class for things that make up the schema,
+    # eg objects, enums, scalars.
+    #
+    # @api private
     class Member
       include GraphQLTypeNames
       extend CachedGraphQLDefinition
       extend GraphQL::Relay::TypeExtensions
       extend BaseDSLMethods
       extend TypeSystemHelpers
+      extend Scoped
+      extend RelayShortcuts
     end
   end
 end

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -10,8 +10,7 @@ module GraphQL
         # Call this with a new name to override the default name for this schema member; OR
         # call it without an argument to get the name of this schema member
         #
-        # The default name is the Ruby constant name,
-        # without any namespaces and with any `-Type` suffix removed
+        # The default name is implemented in default_graphql_name
         # @param new_name [String]
         # @return [String]
         def graphql_name(new_name = nil)
@@ -20,10 +19,8 @@ module GraphQL
             @graphql_name = new_name
           when overridden = overridden_graphql_name
             overridden
-          else # Fallback to Ruby constant name
-            raise NotImplementedError, 'Anonymous class should declare an `graphql_name`' if name.nil?
-
-            name.split("::").last.sub(/Type\Z/, "")
+          else
+            default_graphql_name
           end
         end
 
@@ -78,6 +75,15 @@ module GraphQL
           @graphql_name || find_inherited_method(:overridden_graphql_name, nil)
         end
 
+        # Creates the default name for a schema member.
+        # The default name is the Ruby constant name,
+        # without any namespaces and with any `-Type` suffix removed
+        def default_graphql_name
+          raise NotImplementedError, 'Anonymous class should declare a `graphql_name`' if name.nil?
+
+          name.split("::").last.sub(/Type\Z/, "")
+        end
+
         def visible?(context)
           if @mutation
             @mutation.visible?(context)

data/lib/graphql/schema/member/has_arguments.rb

@@ -16,6 +16,13 @@ module GraphQL
         def argument(*args, **kwargs, &block)
           kwargs[:owner] = self
           arg_defn = self.argument_class.new(*args, **kwargs, &block)
+          add_argument(arg_defn)
+        end
+
+        # Register this argument with the class.
+        # @param arg_defn [GraphQL::Schema::Argument]
+        # @return [GraphQL::Schema::Argument]
+        def add_argument(arg_defn)
           own_arguments[arg_defn.name] = arg_defn
           arg_defn
         end

data/lib/graphql/schema/member/relay_shortcuts.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module RelayShortcuts
+        def edge_type_class(new_edge_type_class = nil)
+          if new_edge_type_class
+            @edge_type_class = new_edge_type_class
+          else
+            @edge_type_class || find_inherited_method(:edge_type_class, Types::Relay::BaseEdge)
+          end
+        end
+
+        def connection_type_class(new_connection_type_class = nil)
+          if new_connection_type_class
+            @connection_type_class = new_connection_type_class
+          else
+            @connection_type_class || find_inherited_method(:connection_type_class, Types::Relay::BaseConnection)
+          end
+        end
+
+        def edge_type
+          @edge_type ||= begin
+            edge_name = self.graphql_name + "Edge"
+            node_type_class = self
+            Class.new(edge_type_class) do
+              graphql_name(edge_name)
+              node_type(node_type_class)
+            end
+          end
+        end
+
+        def connection_type
+          @connection_type ||= begin
+            conn_name = self.graphql_name + "Connection"
+            edge_type_class = self.edge_type
+            Class.new(connection_type_class) do
+              graphql_name(conn_name)
+              edge_type(edge_type_class)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/scoped.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module Scoped
+        # This is called when a field has `scope: true`.
+        # The field's return type class receives this call.
+        #
+        # By default, it's a no-op. Override it to scope your objects.
+        #
+        # @param items [Object] Some list-like object (eg, Array, ActiveRecord::Relation)
+        # @param context [GraphQL::Query::Context]
+        # @return [Object] Another list-like object, scoped to the current context
+        def scope_items(items, context)
+          items
+        end
+      end
+    end
+  end
+end