graphql_rails 2.2.0 → 2.4.0

data/lib/graphql_rails/attributes/attribute_configurable.rb

@@ -17,6 +17,7 @@ module GraphqlRails
 
         chainable_option :description
         chainable_option :options, default: {}
+        chainable_option :extras, default: []
         chainable_option :type
       end
 
@@ -32,6 +33,14 @@ module GraphqlRails
         groups(*args)
       end
 
+      def hidden_in_groups(new_groups = ChainableOptions::NOT_SET)
+        @hidden_in_groups ||= []
+        return @hidden_in_groups if new_groups == ChainableOptions::NOT_SET
+
+        @hidden_in_groups = Array(new_groups).map(&:to_s)
+        self
+      end
+
       def required(new_value = true) # rubocop:disable Style/OptionalBooleanParameter
         @required = new_value
         self
@@ -40,6 +49,21 @@ module GraphqlRails
       def optional(new_value = true) # rubocop:disable Style/OptionalBooleanParameter
         required(!new_value)
       end
+
+      def deprecated(reason = 'Deprecated')
+        @deprecation_reason = \
+          if [false, nil].include?(reason)
+            nil
+          else
+            reason.is_a?(String) ? reason : 'Deprecated'
+          end
+
+        self
+      end
+
+      def deprecation_reason
+        @deprecation_reason
+      end
     end
   end
 end

data/lib/graphql_rails/attributes/attribute_name_parser.rb

@@ -3,7 +3,7 @@
 module GraphqlRails
   module Attributes
     # Parses attribute name and can generates graphql scalar type,
-    # grapqhl name and etc. based on that
+    # graphql name and etc. based on that
     class AttributeNameParser
       def initialize(original_name, options: {})
         @original_name = original_name.to_s
@@ -13,9 +13,9 @@ module GraphqlRails
       def field_name
         @field_name ||= \
           if original_format?
-            preprocesed_name
+            preprocessed_name
           else
-            preprocesed_name.camelize(:lower)
+            preprocessed_name.camelize(:lower)
           end
       end
 
@@ -47,7 +47,7 @@ module GraphqlRails
         options[:input_format] == :original || options[:attribute_name_format] == :original
       end
 
-      def preprocesed_name
+      def preprocessed_name
         if name.end_with?('?')
           "is_#{name.remove(/\?\Z/)}"
         else

data/lib/graphql_rails/attributes/input_attribute.rb

@@ -12,6 +12,7 @@ module GraphqlRails
 
       chainable_option :subtype
       chainable_option :enum
+      chainable_option :default_value
 
       def initialize(name, config:)
         @config = config
@@ -25,7 +26,15 @@ module GraphqlRails
       end
 
       def input_argument_options
-        { required: required?, description: description, camelize: false, groups: groups }
+        {
+          required: required?,
+          description: description,
+          camelize: false,
+          groups: groups,
+          hidden_in_groups: hidden_in_groups,
+          **default_value_option,
+          **deprecation_reason_params
+        }
       end
 
       def paginated?
@@ -36,12 +45,20 @@ module GraphqlRails
 
       attr_reader :initial_name, :config
 
+      def default_value_option
+        { default_value: default_value }.compact
+      end
+
       def attribute_name_parser
         @attribute_name_parser ||= AttributeNameParser.new(
           initial_name, options: attribute_naming_options
         )
       end
 
+      def deprecation_reason_params
+        { deprecation_reason: deprecation_reason }.compact
+      end
+
       def attribute_naming_options
         options.slice(:input_format)
       end
@@ -63,7 +80,7 @@ module GraphqlRails
       end
 
       def raw_input_type
-        return type if type.is_a?(GraphQL::InputObjectType)
+        return type if type.is_a?(GraphQL::Schema::InputObject)
         return type.graphql_input_type if type.is_a?(Model::Input)
       end
     end

data/lib/graphql_rails/attributes/type_parseable.rb

@@ -42,14 +42,13 @@ module GraphqlRails
       WRAPPER_TYPES = [
         GraphQL::Schema::List,
         GraphQL::Schema::NonNull,
-        GraphQL::NonNullType,
-        GraphQL::ListType
+        GraphQL::Language::Nodes::NonNullType,
+        GraphQL::Language::Nodes::ListType
       ].freeze
 
       GRAPHQL_BASE_TYPES = [
-        GraphQL::BaseType,
-        GraphQL::ObjectType,
-        GraphQL::InputObjectType
+        GraphQL::Schema::Object,
+        GraphQL::Schema::InputObject
       ].freeze
 
       RAW_GRAPHQL_TYPES = (WRAPPER_TYPES + GRAPHQL_BASE_TYPES).freeze

data/lib/graphql_rails/controller/action_configuration.rb

@@ -7,7 +7,7 @@ require 'graphql_rails/errors/error'
 
 module GraphqlRails
   class Controller
-    # stores all graphql_rails contoller specific config
+    # stores all graphql_rails controller specific config
     class ActionConfiguration
       class MissingConfigurationError < GraphqlRails::Error; end
       class DeprecatedDefaultModelError < GraphqlRails::Error; end

data/lib/graphql_rails/controller/build_controller_action_resolver.rb

@@ -19,6 +19,8 @@ module GraphqlRails
         action = build_action
 
         Class.new(ControllerActionResolver) do
+          graphql_name("ControllerActionResolver#{SecureRandom.hex}")
+
           type(*action.type_args, **action.type_options)
           description(action.description)
           controller(action.controller)

data/lib/graphql_rails/controller/configuration.rb

@@ -7,7 +7,7 @@ require 'graphql_rails/errors/error'
 
 module GraphqlRails
   class Controller
-    # stores all graphql_rails contoller specific config
+    # stores all graphql_rails controller specific config
     class Configuration
       class InvalidActionConfiguration < GraphqlRails::Error; end
 

data/lib/graphql_rails/controller/request/format_errors.rb

@@ -8,7 +8,7 @@ require 'graphql_rails/errors/custom_execution_error'
 module GraphqlRails
   class Controller
     class Request
-      # Converts user provided free-form errors in to meaningfull graphql error classes
+      # Converts user provided free-form errors in to meaningful graphql error classes
       class FormatErrors
         include Service
 

data/lib/graphql_rails/controller/request.rb

@@ -7,11 +7,12 @@ module GraphqlRails
       require 'graphql_rails/controller/request/format_errors'
 
       attr_accessor :object_to_return
-      attr_reader :errors, :context
+      attr_reader :errors, :context, :lookahead
 
       def initialize(graphql_object, inputs, context)
         @graphql_object = graphql_object
-        @inputs = inputs
+        @inputs = inputs.except(:lookahead)
+        @lookahead = inputs[:lookahead]
         @context = context
       end
 

data/lib/graphql_rails/controller.rb

@@ -90,7 +90,7 @@ module GraphqlRails
       if error.is_a?(GraphQL::ExecutionError)
         render error: error
       else
-        render error: SystemError.new(error.message)
+        render error: SystemError.new(error)
       end
     end
 

data/lib/graphql_rails/decorator/relation_decorator.rb

@@ -2,50 +2,51 @@
 
 module GraphqlRails
   module Decorator
-    # wrapps active record relation and returns decorated object instead
+    # wraps active record relation and returns decorated object instead
     class RelationDecorator
       delegate :map, :each, to: :to_a
-      delegate :limit_value, :offset_value, :count, :size, :empty?, to: :relation
+      delegate :limit_value, :offset_value, :count, :size, :empty?, :loaded?, to: :relation
 
       def self.decorates?(object)
         (defined?(ActiveRecord) && object.is_a?(ActiveRecord::Relation)) ||
           defined?(Mongoid) && object.is_a?(Mongoid::Criteria)
       end
 
-      def initialize(decorator:, relation:, decorator_args: [])
+      def initialize(decorator:, relation:, decorator_args: [], decorator_kwargs: {})
         @relation = relation
         @decorator = decorator
         @decorator_args = decorator_args
+        @decorator_kwargs = decorator_kwargs
       end
 
       %i[where limit order group offset from select having all unscope].each do |method_name|
-        define_method method_name do |*args, &block|
-          chainable_method(method_name, *args, &block)
+        define_method method_name do |*args, **kwargs, &block|
+          chainable_method(method_name, *args, **kwargs, &block)
         end
       end
 
       %i[first second last find find_by].each do |method_name|
-        define_method method_name do |*args, &block|
-          decoratable_object_method(method_name, *args, &block)
+        define_method method_name do |*args, **kwargs, &block|
+          decoratable_object_method(method_name, *args, **kwargs, &block)
         end
       end
 
       %i[find_each].each do |method_name|
-        define_method method_name do |*args, &block|
-          decoratable_block_method(method_name, *args, &block)
+        define_method method_name do |*args, **kwargs, &block|
+          decoratable_block_method(method_name, *args, **kwargs, &block)
         end
       end
 
       def to_a
-        @to_a ||= relation.to_a.map { |it| decorator.new(it, *decorator_args) }
+        @to_a ||= relation.to_a.map { |it| decorator.new(it, *decorator_args, **decorator_kwargs) }
       end
 
       private
 
-      attr_reader :relation, :decorator, :decorator_args
+      attr_reader :relation, :decorator, :decorator_args, :decorator_kwargs
 
-      def decoratable_object_method(method_name, *args, &block)
-        object = relation.public_send(method_name, *args, &block)
+      def decoratable_object_method(method_name, *args, **kwargs, &block)
+        object = relation.public_send(method_name, *args, **kwargs, &block)
         decorate(object)
       end
 
@@ -53,22 +54,25 @@ module GraphqlRails
         return object_or_list if object_or_list.blank?
 
         if object_or_list.is_a?(Array)
-          object_or_list.map { |it| decorator.new(it, *decorator_args) }
+          object_or_list.map { |it| decorator.new(it, *decorator_args, **decorator_kwargs) }
         else
-          decorator.new(object_or_list, *decorator_args)
+          decorator.new(object_or_list, *decorator_args, **decorator_kwargs)
         end
       end
 
-      def decoratable_block_method(method_name, *args)
-        relation.public_send(method_name, *args) do |object, *other_args|
+      def decoratable_block_method(method_name, *args, **kwargs)
+        relation.public_send(method_name, *args, **kwargs) do |object, *other_args|
           decorated_object = decorate(object)
           yield(decorated_object, *other_args)
         end
       end
 
-      def chainable_method(method_name, *args, &block)
-        new_relation = relation.public_send(method_name, *args, &block)
-        self.class.new(decorator: decorator, relation: new_relation, decorator_args: decorator_args)
+      def chainable_method(method_name, *args, **kwargs, &block)
+        new_relation = relation.public_send(method_name, *args, **kwargs, &block)
+        self.class.new(
+          decorator: decorator, relation: new_relation,
+          decorator_args: decorator_args, decorator_kwargs: decorator_kwargs
+        )
       end
     end
   end

data/lib/graphql_rails/decorator.rb

@@ -25,17 +25,25 @@ module GraphqlRails
     extend ActiveSupport::Concern
 
     class_methods do
-      def decorate(object, *args)
+      def decorate(object, *args, **kwargs)
         if Decorator::RelationDecorator.decorates?(object)
-          Decorator::RelationDecorator.new(relation: object, decorator: self, decorator_args: args)
+          decorate_with_relation_decorator(object, args, kwargs)
         elsif object.nil?
           nil
         elsif object.is_a?(Array)
-          object.map { |item| new(item, *args) }
+          object.map { |item| new(item, *args, **kwargs) }
         else
-          new(object, *args)
+          new(object, *args, **kwargs)
         end
       end
+
+      private
+
+      def decorate_with_relation_decorator(object, args, kwargs)
+        Decorator::RelationDecorator.new(
+          relation: object, decorator: self, decorator_args: args, decorator_kwargs: kwargs
+        )
+      end
     end
   end
 end

data/lib/graphql_rails/errors/custom_execution_error.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module GraphqlRails
-  # base class which is returned in case something bad happens. Contains all error rendering tructure
+  # base class which is returned in case something bad happens. Contains all error rendering structure
   class CustomExecutionError < ExecutionError
     attr_reader :extra_graphql_data
 

data/lib/graphql_rails/errors/execution_error.rb

@@ -3,7 +3,7 @@
 module GraphqlRails
   require 'graphql'
 
-  # base class which is returned in case something bad happens. Contains all error rendering tructure
+  # base class which is returned in case something bad happens. Contains all error rendering structure
   class ExecutionError < GraphQL::ExecutionError
     def to_h
       super.merge(extra_graphql_data)

data/lib/graphql_rails/errors/system_error.rb

@@ -1,8 +1,18 @@
 # frozen_string_literal: true
 
 module GraphqlRails
-  # base class which is returned in case something bad happens. Contains all error rendering tructure
+  # Base class which is returned in case something bad happens. Contains all error rendering structure
   class SystemError < ExecutionError
+    delegate :backtrace, to: :original_error
+
+    attr_reader :original_error
+
+    def initialize(original_error)
+      super(original_error.message)
+
+      @original_error = original_error
+    end
+
     def to_h
       super.except('locations')
     end

data/lib/graphql_rails/errors/validation_error.rb

@@ -3,10 +3,12 @@
 module GraphqlRails
   # GraphQL error that is raised when invalid data is given
   class ValidationError < ExecutionError
+    BASE_FIELD_NAME = 'base'
+
     attr_reader :short_message, :field
 
     def initialize(short_message, field)
-      super([field.presence&.to_s&.humanize, short_message].compact.join(' '))
+      super([humanized_field(field), short_message].compact.join(' '))
       @short_message = short_message
       @field = field
     end
@@ -18,5 +20,16 @@ module GraphqlRails
     def to_h
       super.merge('field' => field, 'short_message' => short_message)
     end
+
+    private
+
+    def humanized_field(field)
+      return if field.blank?
+
+      stringified_field = field.to_s
+      return if stringified_field == BASE_FIELD_NAME
+
+      stringified_field.humanize
+    end
   end
 end

data/lib/graphql_rails/model/find_or_build_graphql_input_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/types/input_object_type'
+require 'graphql_rails/concerns/service'
+require 'graphql_rails/model/find_or_build_graphql_type'
+
+module GraphqlRails
+  module Model
+    # stores information about model specific config, like attributes and types
+    class FindOrBuildGraphqlInputType < FindOrBuildGraphqlType
+      include ::GraphqlRails::Service
+
+      private
+
+      def parent_class
+        GraphqlRails::Types::InputObjectType
+      end
+
+      def add_attributes_batch(attributes)
+        klass.class_eval do
+          attributes.each do |attribute|
+            argument(*attribute.input_argument_args, **attribute.input_argument_options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/model/find_or_build_graphql_type.rb

@@ -19,7 +19,7 @@ module GraphqlRails
       end
 
       def call
-        klass.tap { add_fields_to_graphql_type if new_class? || force_define_attributes }
+        klass.tap { add_attributes if new_class? || force_define_attributes }
       end
 
       private
@@ -28,20 +28,29 @@ module GraphqlRails
 
       delegate :klass, :new_class?, to: :type_class_finder
 
+      def parent_class
+        GraphqlRails::Types::ObjectType
+      end
+
+      def add_attributes_batch(attributes)
+        AddFieldsToGraphqlType.call(klass: klass, attributes: attributes)
+      end
+
       def type_class_finder
         @type_class_finder ||= FindOrBuildGraphqlTypeClass.new(
           name: name,
           type_name: type_name,
-          description: description
+          description: description,
+          parent_class: parent_class
         )
       end
 
-      def add_fields_to_graphql_type
+      def add_attributes
         scalar_attributes, dynamic_attributes = attributes.values.partition(&:scalar_type?)
 
-        AddFieldsToGraphqlType.call(klass: klass, attributes: scalar_attributes)
+        add_attributes_batch(scalar_attributes)
         dynamic_attributes.each { |attribute| find_or_build_dynamic_type(attribute) }
-        AddFieldsToGraphqlType.call(klass: klass, attributes: dynamic_attributes)
+        add_attributes_batch(dynamic_attributes)
       end
 
       def find_or_build_dynamic_type(attribute)

data/lib/graphql_rails/model/find_or_build_graphql_type_class.rb

@@ -9,11 +9,12 @@ module GraphqlRails
 
       include ::GraphqlRails::Service
 
-      def initialize(name:, type_name:, description: nil)
+      def initialize(name:, type_name:, parent_class:, description: nil)
         @name = name
         @type_name = type_name
         @description = description
         @new_class = false
+        @parent_class = parent_class
       end
 
       def klass
@@ -27,13 +28,13 @@ module GraphqlRails
       private
 
       attr_accessor :new_class
-      attr_reader :name, :type_name, :description
+      attr_reader :name, :type_name, :description, :parent_class
 
       def build_graphql_type_klass
         graphql_type_name = name
         graphql_type_description = description
 
-        graphql_type_klass = Class.new(GraphqlRails::Types::ObjectType) do
+        graphql_type_klass = Class.new(parent_class) do
           graphql_name(graphql_type_name)
           description(graphql_type_description)
         end

data/lib/graphql_rails/model/input.rb

@@ -6,7 +6,7 @@ module GraphqlRails
     class Input
       require 'graphql_rails/concerns/chainable_options'
       require 'graphql_rails/model/configurable'
-      require 'graphql_rails/model/build_graphql_input_type'
+      require 'graphql_rails/model/find_or_build_graphql_input_type'
 
       include Configurable
 
@@ -18,8 +18,8 @@ module GraphqlRails
       end
 
       def graphql_input_type
-        @graphql_input_type ||= BuildGraphqlInputType.call(
-          name: name, description: description, attributes: attributes
+        @graphql_input_type ||= FindOrBuildGraphqlInputType.call(
+          name: name, description: description, attributes: attributes, type_name: type_name
         )
       end
 

data/lib/graphql_rails/router/build_schema_action_type.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  class Router
+    # Builds GraphQL type used in graphql schema
+    class BuildSchemaActionType
+      ROUTES_KEY = :__routes__
+
+      # @private
+      class SchemaActionType < GraphQL::Schema::Object
+        def self.inspect
+          "#{GraphQL::Schema::Object}(#{graphql_name})"
+        end
+
+        class << self
+          def fields_for_nested_routes(type_name_prefix:, scoped_routes:)
+            routes_by_scope = scoped_routes.dup
+            unscoped_routes = routes_by_scope.delete(ROUTES_KEY) || []
+
+            scoped_only_fields(type_name_prefix, routes_by_scope)
+            unscoped_routes.each { route_field(_1) }
+          end
+
+          private
+
+          def route_field(route)
+            field(*route.name, **route.field_options)
+          end
+
+          def scoped_only_fields(type_name_prefix, routes_by_scope)
+            routes_by_scope.each_pair do |scope_name, inner_scope_routes|
+              scope_field(scope_name, "#{type_name_prefix}#{scope_name.to_s.camelize}", inner_scope_routes)
+            end
+          end
+
+          def scope_field(scope_name, scope_type_name, scoped_routes)
+            scope_type = build_scope_type_class(
+              type_name: scope_type_name,
+              scoped_routes: scoped_routes
+            )
+
+            field(scope_name.to_s.camelize(:lower), scope_type, null: false)
+            define_method(scope_type_name.underscore) { self }
+          end
+
+          def build_scope_type_class(type_name:, scoped_routes:)
+            Class.new(SchemaActionType) do
+              graphql_name("#{type_name}Scope")
+
+              fields_for_nested_routes(
+                type_name_prefix: type_name,
+                scoped_routes: scoped_routes
+              )
+            end
+          end
+        end
+      end
+
+      def self.call(**kwargs)
+        new(**kwargs).call
+      end
+
+      def initialize(type_name:, routes:)
+        @type_name = type_name
+        @routes = routes
+      end
+
+      def call
+        type_name = self.type_name
+        scoped_routes = self.scoped_routes
+
+        Class.new(SchemaActionType) do
+          graphql_name(type_name)
+
+          fields_for_nested_routes(
+            type_name_prefix: type_name,
+            scoped_routes: scoped_routes
+          )
+        end
+      end
+
+      private
+
+      attr_reader :type_name, :routes
+
+      def scoped_routes
+        routes.each_with_object({}) do |route, result|
+          scope_names = route.scope_names.map { _1.to_s.camelize(:lower) }
+          path_to_routes = scope_names + [ROUTES_KEY]
+          deep_append(result, path_to_routes, route)
+        end
+      end
+
+      # adds array element to nested hash
+      # usage:
+      #   deep_hash =   { a: { b: [1] } }
+      #   deep_append(deep_hash, [:a, :b], 2)
+      #   deep_hash #=> { a: { b: [1, 2] } }
+      def deep_append(hash, keys, value)
+        deepest_hash = hash
+        *other_keys, last_key = keys
+
+        other_keys.each do |key|
+          deepest_hash[key] ||= {}
+          deepest_hash = deepest_hash[key]
+        end
+        deepest_hash[last_key] ||= []
+        deepest_hash[last_key] += [value]
+      end
+    end
+  end
+end