graphql_rails 2.1.0 → 2.3.0

data/docs/components/routes.md

@@ -73,14 +73,15 @@ end
 
 This will generate `userDetails` field on GraphQL side.
 
-## _query_ and _mutation_
+## _query_ and _mutation_ & _subscription_
 
-in case you want to have non-CRUD controller with custom actions you can define your own `query`/`mutation` actions like this:
+in case you want to have non-CRUD controller with custom actions you can define your own `query`/`mutation`/`subscription` actions like this:
 
 ```ruby
 MyGraphqlSchema = GraphqlRails::Router.draw do
   mutation :logIn, to: 'sessions#login'
-  query :me, to 'users#current_user'
+  query :me, to: 'users#current_user'
+  subscribtion :new_message, to: 'messages#created'
 end
 ```
 
@@ -88,18 +89,54 @@ end
 
 ### _module_ options
 
-currently `scope` method accepts single option: `module`. `module` allows to specify controller namespace. So you can use scoped controllers, like so:
+If you want to want to route everything to controllers, located at `controllers/admin/top_secret`, you can use scope with `module` param:
 
 ```ruby
-MyGraphqlSchema = GraphqlRails::Router.draw do
-  scope module: 'admin/top_secret' do
-    mutation :logIn, to: 'sessions#login' # this will trigger Admin::TopSecret::SessionsController
-  end
+scope module: 'admin/top_secret' do
+  mutation :logIn, to: 'sessions#login' # this will trigger Admin::TopSecret::SessionsController
+end
+```
+
+### Named scope
 
+If you want to nest some routes under some other node, you can use named scope:
+
+```ruby
+scope :admin do
   mutation :logIn, to: 'sessions#login' # this will trigger ::SessionsController
 end
 ```
 
+This action will be accessible via:
+
+```graphql
+mutation {
+  admin {
+    logIn(email: 'john@example.com') { ... }
+  }
+}
+```
+
+## _namespace_
+
+You may wish to organize groups of controllers under a namespace. Most commonly, you might group a number of administrative controllers under an `Admin::` namespace, and place these controllers under the app/controllers/admin directory. You can route to such a group by using a namespace block:
+
+```ruby
+  namespace :admin do
+    resources :articles, only: :show
+  end
+```
+
+On GraphQL side, you can reach such route with the following query:
+
+```graphql
+query {
+  admin {
+    article(id: '123') { ... }
+  }
+}
+```
+
 ## _group_
 
 You can have multiple routers / schemas. In order to add resources or query only to specific schema, you need wrap it with `group` method, like this:

data/lib/graphql_rails/attributes/attribute.rb

@@ -32,8 +32,8 @@ module GraphqlRails
         [
           field_name,
           type_parser.type_arg,
-          *description
-        ]
+          description
+        ].compact
       end
 
       def field_options
@@ -41,21 +41,11 @@ module GraphqlRails
           method: property.to_sym,
           null: optional?,
           camelize: camelize?,
-          groups: groups
+          groups: groups,
+          **deprecation_reason_params
         }
       end
 
-      def argument_args
-        [
-          field_name,
-          type_parser.type_arg,
-          {
-            description: description,
-            required: required?
-          }
-        ]
-      end
-
       protected
 
       attr_reader :initial_name
@@ -65,6 +55,10 @@ module GraphqlRails
       def camelize?
         options[:input_format] != :original && options[:attribute_name_format] != :original
       end
+
+      def deprecation_reason_params
+        { deprecation_reason: deprecation_reason }.compact
+      end
     end
   end
 end

data/lib/graphql_rails/attributes/attribute_configurable.rb

@@ -40,6 +40,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/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,14 @@ module GraphqlRails
       end
 
       def input_argument_options
-        { required: required?, description: description, camelize: false, groups: groups }
+        {
+          required: required?,
+          description: description,
+          camelize: false,
+          groups: groups,
+          **default_value_option,
+          **deprecation_reason_params
+        }
       end
 
       def paginated?
@@ -36,12 +44,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

data/lib/graphql_rails/attributes/type_parseable.rb

@@ -52,12 +52,6 @@ module GraphqlRails
         GraphQL::InputObjectType
       ].freeze
 
-      PARSEABLE_RAW_GRAPHQL_TYPES = [
-        GraphQL::Schema::Object,
-        GraphQL::Schema::Scalar,
-        GraphQL::Schema::Enum
-      ].freeze
-
       RAW_GRAPHQL_TYPES = (WRAPPER_TYPES + GRAPHQL_BASE_TYPES).freeze
 
       def unwrapped_scalar_type
@@ -103,7 +97,7 @@ module GraphqlRails
       def graphql_type_object?(type_class)
         return false unless type_class.is_a?(Class)
 
-        PARSEABLE_RAW_GRAPHQL_TYPES.any? { |parent_type| type_class < parent_type }
+        type_class < GraphQL::Schema::Member
       end
 
       def applicable_graphql_type?(type)

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

@@ -62,9 +62,14 @@ module GraphqlRails
       end
 
       def parameter_filter_class
-        return ActiveSupport::ParameterFilter if Object.const_defined?('ActiveSupport::ParameterFilter')
+        if ActiveSupport.gem_version.segments.first < 6
+          return ActiveSupport::ParameterFilter if Object.const_defined?('ActiveSupport::ParameterFilter')
 
-        ActionDispatch::Http::ParameterFilter
+          ActionDispatch::Http::ParameterFilter
+        else
+          require 'active_support/parameter_filter'
+          ActiveSupport::ParameterFilter
+        end
       end
     end
   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

@@ -12,40 +12,41 @@ module GraphqlRails
           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/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/input_configurable.rb

@@ -26,7 +26,7 @@ module GraphqlRails
       pagination_options = nil if pagination_options == false
 
       @pagination_options = pagination_options
-      permit(:before, :after, first: :int, last: :int)
+      self
     end
 
     def paginated?

data/lib/graphql_rails/model/find_or_build_graphql_type.rb

@@ -46,11 +46,7 @@ module GraphqlRails
 
       def find_or_build_dynamic_type(attribute)
         graphql_model = attribute.graphql_model
-        if graphql_model
-          find_or_build_graphql_model_type(graphql_model)
-        else
-          AddFieldsToGraphqlType.call(klass: klass, attributes: [attribute])
-        end
+        find_or_build_graphql_model_type(graphql_model) if graphql_model
       end
 
       def find_or_build_graphql_model_type(graphql_model)

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

data/lib/graphql_rails/router/mutation_route.rb

@@ -13,6 +13,10 @@ module GraphqlRails
       def mutation?
         true
       end
+
+      def subscription?
+        false
+      end
     end
   end
 end

data/lib/graphql_rails/router/query_route.rb

@@ -13,6 +13,10 @@ module GraphqlRails
       def mutation?
         false
       end
+
+      def subscription?
+        false
+      end
     end
   end
 end

data/lib/graphql_rails/router/resource_routes_builder.rb

@@ -28,6 +28,10 @@ module GraphqlRails
         routes << build_mutation(*args, **kwargs)
       end
 
+      def subscription(*args, **kwargs)
+        routes << build_subscription(*args, **kwargs)
+      end
+
       private
 
       attr_reader :autogenerated_action_names, :name, :options
@@ -62,6 +66,10 @@ module GraphqlRails
         build_route(QueryRoute, *args, **kwargs)
       end
 
+      def build_subscription(*args, **kwargs)
+        build_route(SubscriptionRoute, *args, **kwargs)
+      end
+
       # rubocop:disable Metrics/ParameterLists
       def build_route(builder, action, prefix: action, suffix: false, on: :member, **custom_options)
         if suffix == true

data/lib/graphql_rails/router/route.rb

@@ -6,15 +6,16 @@ module GraphqlRails
   class Router
     # Generic class for any type graphql action. Should not be used directly
     class Route
-      attr_reader :name, :module_name, :on, :relative_path, :groups
+      attr_reader :name, :module_name, :on, :relative_path, :groups, :scope_names
 
-      def initialize(name, to: '', on:, groups: nil, **options)
+      def initialize(name, on:, to: '', groups: nil, scope_names: [], **options) # rubocop:disable Metrics/ParameterLists
         @name = name.to_s.camelize(:lower)
         @module_name = options[:module].to_s
         @function = options[:function]
         @groups = groups
         @relative_path = to
         @on = on.to_sym
+        @scope_names = scope_names
       end
 
       def path