graphql_rails 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1909c3b76c9addab63bcc0337232c147ceebde0d1f2252da93606b48d1843c64
-  data.tar.gz: 6b405941e4bae0e98abbcc07b93ac1a95fa22bcbdfcaa962d241740a15453ba7
+  metadata.gz: 9f06459a3c8c16e40dffd181d7c08128558e2bdca598845b9e94f51852681e61
+  data.tar.gz: 1a4ddc9e11a4c5ef22240f7e36b3070bcf89b712c561cad12e41ede1dc18fbc3
 SHA512:
-  metadata.gz: f5292647cd5c49c51bec7f9f1df33be882637ac83bd54fb23259fc2b5c6d8f351f3501c5db23f0ff7c10daafafed531b4026ff3790ff281cfd71890ff2b2c007
-  data.tar.gz: 054adf43e83c54be23fb33547ee521e17ae8f180f5f4c05bf3a7b78f554367e6531483d9bf66af75fe4567940f2931c56f93c2adc6af412efba8e644043af8bc
+  metadata.gz: 23e0d160c19e3c56c00a474cb77eff10c6a86c3ce1c63f3cdb87f4c374f3c10da79b5f2529a14a026f81e6f3b2c32e9b2fecd671bd7b38066e07d020c65fa93a
+  data.tar.gz: a0ade6d1ce611baf97ab0a631770273c98953b04eb3991e3234c12a12f21e893962b62a1785ba5da48de7193c366129d29732c7121fbe6c4404d5e1f05cedda2

data/.github/workflows/ruby.yml

@@ -4,7 +4,7 @@ jobs:
   specs:
     strategy:
       matrix:
-        ruby-version: ['2.6', '2.7', '3.0']
+        ruby-version: ['2.7', '3.0', '3.1']
 
     runs-on: ubuntu-latest
     env:

data/.ruby-version

@@ -1 +1 @@
-3.0.1
+3.1.2

data/CHANGELOG.md

@@ -9,6 +9,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Added/Changed/Deprecated/Removed/Fixed/Security: YOUR CHANGE HERE
 
+## [2.3.0](2022-11-25)
+
+* Added support for Ruby 3.1.2, keyword arguments for decorators support included
+* Added: error backtrace to SystemError
+* Fixed: skip "base" field name in validation error messages
+* Added: router namespaces and named scopes
+* Added: `deprecate` method/option for attributes and input attributes
+
 ## [2.2.0](2022-01-25)
 
 * Added: support for subscription type

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql_rails (2.2.0)
+    graphql_rails (2.3.0)
       activesupport (>= 4)
       graphql (~> 1.12, >= 1.12.4)
 
@@ -81,10 +81,10 @@ GEM
     erubi (1.10.0)
     globalid (1.0.0)
       activesupport (>= 5.0)
-    graphql (1.13.6)
+    graphql (1.13.17)
     i18n (1.8.11)
       concurrent-ruby (~> 1.0)
-    loofah (2.13.0)
+    loofah (2.18.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     mail (2.7.1)
@@ -92,7 +92,7 @@ GEM
     marcel (1.0.2)
     method_source (1.0.0)
     mini_mime (1.1.2)
-    mini_portile2 (2.7.1)
+    mini_portile2 (2.8.0)
     minitest (5.15.0)
     mongo (2.17.0)
       bson (>= 4.8.2, < 5.0.0)
@@ -101,8 +101,8 @@ GEM
       mongo (>= 2.10.5, < 3.0.0)
       ruby2_keywords (~> 0.0.5)
     nio4r (2.5.8)
-    nokogiri (1.13.1)
-      mini_portile2 (~> 2.7.0)
+    nokogiri (1.13.9)
+      mini_portile2 (~> 2.8.0)
       racc (~> 1.4)
     parallel (1.21.0)
     parser (3.1.0.0)
@@ -114,7 +114,7 @@ GEM
       byebug (~> 11.0)
       pry (~> 0.13.0)
     racc (1.6.0)
-    rack (2.2.3)
+    rack (2.2.3.1)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rails (6.1.4.4)
@@ -135,7 +135,7 @@ GEM
     rails-dom-testing (2.0.3)
       activesupport (>= 4.2.0)
       nokogiri (>= 1.6)
-    rails-html-sanitizer (1.4.2)
+    rails-html-sanitizer (1.4.3)
       loofah (~> 2.3)
     railties (6.1.4.4)
       actionpack (= 6.1.4.4)

data/docs/README.md

@@ -42,11 +42,12 @@ GraphqlRails::Router.draw do
   resources :users
 
   # if you want custom queries or mutation
-  query 'searchLogs', to: 'logs#search' # redirects request to LogsController
-  mutation 'changeUserPassword', to: 'users#change_password'
+  query 'searchLogs', to: 'logs#search' # action is handled by LogsController#search
 end
 ```
 
+See [Routes docs](components/routes.md) for more info.
+
 ### Define your Graphql model
 
 ```ruby
@@ -56,67 +57,42 @@ class User # works with any class including ActiveRecord
 
   graphql do |c|
     # most common attributes, like :id, :name, :title has default type, so you don't have to specify it (but you can!)
-    c.attribute :id
+    c.attribute(:id)
 
-    c.attribute :email, type: :string
-    c.attribute :surname, type: :string
+    c.attribute(:email).type('String')
+    c.attribute(:surname).type('String')
   end
 end
 ```
 
+See [Model docs](components/model.md) for more info.
+
 ### Define controller
 
 ```ruby
 # app/controllers/graphql/users_controller.rb
 class Graphql::UsersController < GraphqlApplicationController
-  # graphql requires to describe which attributes controller action accepts and which returns
-  action(:change_user_password)
-    .permit(:password!, :id!) # Bang (!) indicates that attribute is required
-    .returns('User!')
+  model('User') # specify that all actions returns User by default
 
-  def change_user_password
-    user = User.find(params[:id])
-    user.update!(password: params[:password])
+  # DRUD actions description
+  action(:index).permit(id: 'ID!').returns_many
+  action(:show).permit(id: 'ID!').returns_single
+  action(:create).permit(email: 'String!').returns_single
+  action(:update).permit(id: 'ID!', email: 'String!').returns_single
+  action(:destroy).permit(id: 'ID!').returns_single
 
-    # returned value needs to have all methods defined in model `graphql do` part
-    user # or SomeDecorator.new(user)
+  def index
+    User.all
   end
 
-  action(:search)
-    .permit(search_fields!: SearchFieldsInput) # you can specify your own input fields
-    .returns('[User!]!')
-  def search
+  def show
+    User.find(params[:id])
   end
+  # ... code for create / update / destroy is skipped ...
 end
 ```
 
-## Routes
-
-```ruby
-GraphqlRails::Router.draw do
-  # generates `friend`, `createFriend`, `updateFriend`, `destroyFriend`, `friends` routes
-  resources :friends
-  resources :shops, only: [:show, :index] # generates `shop` and `shops` routes only
-  resources :orders, except: :update # generates all routes except `updateOrder`
-
-  resources :users do
-    # generates `findUser` query
-    query :find, on: :member
-
-    # generates `searchUsers` query
-    query :search, on: :collection
-  end
-
-  # you can use namespaced controllers too:
-  scope module: 'admin' do
-    # `updateTranslations` route will be handled by `Admin::TranslationsController`
-    mutation :updateTranslations, to: 'translations#update'
-
-    # all :groups routes will be handled by `Admin::GroupsController`
-    resources :groups
-  end
-end
-```
+See [Controller docs](components/controlle.md) for more info.
 
 ## Testing your GraphqlRails::Controller in RSpec
 
@@ -134,6 +110,8 @@ RSpec.configure do |config|
 end
 ```
 
+See [Testing docs](testing/testing.md) for more info.
+
 ### Helper methods
 
 There are 3 helper methods:

data/docs/_sidebar.md

@@ -1,7 +1,6 @@
 * [Home](README)
 * Getting started
   * [Setup](getting_started/setup)
-  * [Quick start](getting_started/quick_start)
 * Components
   * [Routes](components/routes)
   * [Model](components/model)

data/docs/components/controller.md

@@ -144,7 +144,7 @@ end
 If you do not specify `subtype` then default (without name) input will be used. You need to specify subtype if you want to use non-default input:
 
 ```ruby
-class OrderController < GraphqlRails::Controller
+class UsersController < GraphqlRails::Controller
   # this is the input with email and full_name:
   action(:create)
     .permit_input(:input, type: 'User!')
@@ -155,6 +155,20 @@ class OrderController < GraphqlRails::Controller
 end
 ```
 
+#### *deprecated*
+
+You can mark input input as deprecated with `deprecated` option:
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:create)
+    .permit_input(:input, type: 'User', deprecated: true)
+
+  action(:update)
+    .permit_input(:input, type: 'User', deprecated: 'use updateBasicUser instead')
+end
+```
+
 ### *paginated*
 
 You can mark collection action as `paginated`. In this case controller will return relay connection type and it will be possible to return only partial results. No need to do anything on controller side (you should always return full list of items)

data/docs/components/decorator.md

@@ -46,7 +46,7 @@ class UserDecorator < SimpleDelegator
   include GraphqlRails::Model
   include GraphqlRails::Decorator
 
-  graphql_rails do
+  graphql do |c|
     # some setup, attributes, etc...
   end
 

data/docs/components/model.md

@@ -131,6 +131,21 @@ class User
 end
 ```
 
+### attribute.deprecated
+
+Attribute can be marked as deprecated with `deprecated` method:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.attribute(:legacy_name).deprecated
+    c.attribute(:legacy_id).deprecated('This is my custom deprecation reason')
+  end
+end
+```
+
 ### attribute.groups
 
 Groups are handy feature when you want to have multiple schemas. For example, you want to have public graphql endpoint and internal graphql endpoint where each group has some unique nodes. If attribute has `groups` set, then this attribute will be visible only in appropriate group schemas.
@@ -263,6 +278,23 @@ class User
 end
 ```
 
+#### *deprecated*
+
+You can mark input input as deprecated with `deprecated` option:
+
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql.attribute(:avatar_url)
+         .permit_input(:size, type: :int!, deprecated: true)
+
+  graphql.attribute(:logo_url)
+         .permit_input(:size, type: :int!, deprecated: 'custom image size is deprecated')
+end
+```
+
 ### attribute.paginated
 
 You can mark collection method as `paginated`. In this case method will return relay connection type and it will be possible to return only partial results. No need to do anything on method side (you should always return full list of items)
@@ -523,6 +555,36 @@ class User
 end
 ```
 
+
+#### input attribute deprecation
+
+You can mark input attribute as deprecated with `deprecated` method:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql.input do |c|
+    c.attribute(:full_name).deprecated('Use firstName and lastName instead')
+    c.attribute(:surname).deprecated
+  end
+end
+```
+
+#### input attribute default value
+
+You can set default value for input attribute:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql.input do |c|
+    c.attribute(:is_admin).type('Boolean').default_value(false)
+  end
+end
+```
+
 ## graphql_context
 
 It's possible to access graphql_context in your model using method `graphql_context`:

data/docs/components/routes.md

@@ -89,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/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.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/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/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

data/lib/graphql_rails/router/schema_builder.rb

@@ -5,6 +5,7 @@ module GraphqlRails
     # builds GraphQL::Schema based on previously defined grahiti data
     class SchemaBuilder
       require_relative './plain_cursor_encoder'
+      require_relative './build_schema_action_type'
 
       attr_reader :queries, :mutations, :subscriptions, :raw_actions
 
@@ -49,23 +50,9 @@ module GraphqlRails
           .uniq(&:name)
           .reverse
 
-        return if group_routes.empty?
+        return if group_routes.empty? && type_name != 'Query'
 
-        build_type(type_name, group_routes)
-      end
-
-      def build_type(type_name, group_routes)
-        Class.new(GraphQL::Schema::Object) do
-          graphql_name(type_name)
-
-          group_routes.each do |route|
-            field(*route.name, **route.field_options)
-          end
-
-          def self.inspect
-            "#{GraphQL::Schema::Object}(#{graphql_name})"
-          end
-        end
+        BuildSchemaActionType.call(type_name: type_name, routes: group_routes)
       end
     end
   end

data/lib/graphql_rails/router.rb

@@ -21,9 +21,10 @@ module GraphqlRails
       end
     end
 
-    attr_reader :routes, :namespace_name, :raw_graphql_actions
+    attr_reader :routes, :namespace_name, :raw_graphql_actions, :scope_names
 
-    def initialize(module_name: '', group_names: [])
+    def initialize(module_name: '', group_names: [], scope_names: [])
+      @scope_names = scope_names
       @module_name = module_name
       @group_names = group_names
       @routes ||= Set.new
@@ -37,13 +38,16 @@ module GraphqlRails
       routes.merge(scoped_router.routes)
     end
 
-    def scope(**options, &block)
-      full_module_name = [module_name, options[:module]].reject(&:empty?).join('/')
-      scoped_router = router_with(module_name: full_module_name)
+    def scope(new_scope_name = nil, **options, &block)
+      scoped_router = router_with_scope_params(new_scope_name, **options)
       scoped_router.instance_eval(&block)
       routes.merge(scoped_router.routes)
     end
 
+    def namespace(namespace_name, &block)
+      scope(path: namespace_name, module: namespace_name, &block)
+    end
+
     def resources(name, **options, &block)
       builder_options = full_route_options(options)
       routes_builder = ResourceRoutesBuilder.new(name, **builder_options)
@@ -87,13 +91,25 @@ module GraphqlRails
 
     attr_reader :module_name, :group_names
 
+    def router_with_scope_params(new_scope_name, **options)
+      new_scope_name ||= options[:path]
+
+      full_module_name = [module_name, options[:module]].select(&:present?).join('/')
+      full_scope_names = [*scope_names, new_scope_name].select(&:present?)
+
+      router_with(module_name: full_module_name, scope_names: full_scope_names)
+    end
+
     def router_with(new_router_options = {})
-      default_options = { module_name: module_name, group_names: group_names }
-      full_options = default_options.merge(new_router_options)
+      full_options = default_router_options.merge(new_router_options)
 
       self.class.new(**full_options)
     end
 
+    def default_router_options
+      { module_name: module_name, group_names: group_names, scope_names: scope_names }
+    end
+
     def add_raw_action(name, *args, &block)
       raw_graphql_actions << { name: name, args: args, block: block }
     end
@@ -111,7 +127,7 @@ module GraphqlRails
     end
 
     def default_route_options
-      { module: module_name, on: :member }
+      { module: module_name, on: :member, scope_names: scope_names }
     end
   end
 end

data/lib/graphql_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GraphqlRails
-  VERSION = '2.2.0'
+  VERSION = '2.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql_rails
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Povilas Jurčys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-25 00:00:00.000000000 Z
+date: 2022-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -156,7 +156,6 @@ files:
 - docs/components/decorator.md
 - docs/components/model.md
 - docs/components/routes.md
-- docs/getting_started/quick_start.md
 - docs/getting_started/setup.md
 - docs/index.html
 - docs/logging_and_monitoring/logging_and_monitoring.md
@@ -220,6 +219,7 @@ files:
 - lib/graphql_rails/query_runner.rb
 - lib/graphql_rails/railtie.rb
 - lib/graphql_rails/router.rb
+- lib/graphql_rails/router/build_schema_action_type.rb
 - lib/graphql_rails/router/mutation_route.rb
 - lib/graphql_rails/router/plain_cursor_encoder.rb
 - lib/graphql_rails/router/query_route.rb
@@ -255,7 +255,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Rails style structure for GraphQL API.

data/docs/getting_started/quick_start.md

@@ -1,62 +0,0 @@
-# Quick Start
-
-## Generate initial code
-
-```bash
-bundle exec rails g graphql_rails:install
-```
-
-## Define GraphQL schema as RoR routes
-
-```ruby
-# config/graphql/routes.rb
-GraphqlRails::Router.draw do
-  # will create createUser, updateUser, destroyUser mutations and user, users queries.
-  # expects that UsersController class exist
-  resources :users
-
-  # if you want custom queries or mutation
-  query 'searchLogs', to: 'logs#search' # redirects request to LogsController
-  mutation 'changeUserPassword', to: 'users#change_password'
-end
-```
-
-## Define your Graphql model
-
-```ruby
-class User # works with any class including ActiveRecord
-  include GraphqlRails::Model
-
-  graphql do |c|
-    # most common attributes, like :id, :name, :title has default type, so you don't have to specify it (but you can!)
-    c.attribute :id
-
-    c.attribute :email, :string
-    c.attribute :surname, :string
-  end
-end
-```
-
-## Define controller
-
-```ruby
-class UsersController < ApplicationGraphqlController
-  # graphql requires to describe which attributes controller action accepts and which returns
-  action(:change_user_password)
-    .permit(:password!, :id!) # Bang (!) indicates that attribute is required
-
-  def change_user_password
-    user = User.find(params[:id])
-    user.update!(password: params[:password])
-
-    # returned value needs to have all methods defined in model `graphql do` part
-    user # or SomeDecorator.new(user)
-  end
-
-  action(:search).permit(search_fields!: SearchFieldsInput) # you can specify your own input fields
-  def search
-  end
-end
-```
-
-Congrats, you are done!