graphql_rails 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6960308081875563c429085033503f5f6eb4f5078eb610c0a96e95edb4879e6f
-  data.tar.gz: 84b19c7d4811f988ba4caf14eee6f3beb04b460ed92fc39b2d428ef219b44d38
+  metadata.gz: e2bd0f0c9f6aaa1808567914c7a1440302a8b7dc828e97937a264dc33cbdd0d5
+  data.tar.gz: eac8327fdf61cbd8bedb9301f261448a48ebeaf0d14ce78a6fd986d5aa752eb9
 SHA512:
-  metadata.gz: 36cc14d59e7df9f050844e9406596d69bbf97411ec192d1081b630277dc1de5f18706006f5c41072ccc1983aa23d2638d4a96fb7ed10ec7955e5ed0acee28bdc
-  data.tar.gz: 9136375cc875cd7db7d29fd7aac2507cca4364f1504432d7328d629b86e795422a2a48239ea1d98915d3217c7f355c74aa598d9133dc49277dda2cb78fdeb3dc
+  metadata.gz: e9df5b2875fc19b6a61259938ea99397edb51282c964f7bd511b1709c6625352e7c3d22428eac5ade6617b4a54244fb4b4ffa1574951b8368079fd7428cc5d68
+  data.tar.gz: bb8c01ac692e2137f9f0d3ab39a1b7a562ba337145ea0f90a0dd3325a5a67caf523d9f97c0536008adce4815ad15adda1ae036d8ded6f970c16bd761bc7c9a19

data/.rubocop.yml

@@ -12,6 +12,9 @@ Metrics/LineLength:
 Metrics/BlockLength:
   Exclude:
     - spec/**/*.rb
+Metrics/ModuleLength:
+  Exclude:
+    - spec/**/*_spec.rb
 
 Lint/AmbiguousBlockAssociation:
   Exclude:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql_rails (0.3.2)
+    graphql_rails (0.3.3)
       activesupport (>= 4)
       graphql (~> 1)
 

data/README.md

@@ -1,7 +1,7 @@
 # GraphqlRails
 
-[![Build Status](https://travis-ci.org/povilasjurcys/graphql_rails.svg?branch=master)](https://travis-ci.org/povilasjurcys/graphql_rails)
-[![codecov](https://codecov.io/gh/povilasjurcys/graphql_rails/branch/master/graph/badge.svg)](https://codecov.io/gh/povilasjurcys/graphql_rails)
+[![Build Status](https://travis-ci.org/samesystem/graphql_rails.svg?branch=master)](https://travis-ci.org/samesystem/graphql_rails)
+[![codecov](https://codecov.io/gh/samesystem/graphql_rails/branch/master/graph/badge.svg)](https://codecov.io/gh/samesystem/graphql_rails)
 
 Rails style structure for GrapQL API.
 

data/docs/README.md

@@ -0,0 +1,188 @@
+# GraphqlRails
+
+
+Rails style structure for GrapQL API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphql_rails'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install graphql_rails
+
+## Usage
+
+### Define GraphQL schema as RoR routes
+
+```ruby
+MyGraphqlSchema = GraphqlRails::Router.draw do
+  # will create createUser, updateUser, deleteUser 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, type: :string
+    c.attribute :surname, type: :string
+  end
+end
+```
+
+### Define controller
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  # 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
+```
+
+## Routes
+
+```ruby
+MyGraphqlSchema = 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 handeled by `Admin::TranslationsController`
+    mutation :updateTranslations, to: 'translations#update'
+
+    # all :groups routes will be handeled by `Admin::GroupsController`
+    resources :groups
+  end
+end
+```
+
+## Testing your GrapqhlRails::Controller in RSpec
+
+### Setup
+
+Add those lines in your `spec/spec_helper.rb` file
+
+```ruby
+# spec/spec_helper.rb
+require 'graphql_rails/rspec_controller_helpers'
+
+RSpec.configure do |config|
+  config.include(GraphqlRails::RSpecControllerHelpers, type: :graphql_controller)
+  # ... your other configuration ...
+end
+```
+
+### Helper methods
+
+There are 3 helper methods:
+
+* `mutation(:your_controller_action_name, params: {}, context: {})`. `params` and `context` are optional
+* `query(:your_controller_action_name, params: {}, context: {})`. `params` and `context` are optional
+* `response`. Response is set only after you call `mutation` or `query`
+
+### Test examples
+
+```ruby
+class MyGraphqlController
+  def index
+    "Called from index: #{params[:message]}"
+  end
+
+  action(:create_user).permit(:full_name, :email)
+  def create_user
+    User.create!(params)
+  end
+end
+
+RSpec.describe MyGraphqlController, type: :graphql_controller do
+  describe '#index' do
+    it 'is successful' do
+      query(:index)
+      expect(response).to be_successful
+    end
+
+    it 'returns correct message' do
+      query(:index, params: { message: 'Hello world!' })
+      expect(response.result).to eq "Called from index: Hello world!"
+    end
+  end
+
+  describe '#create_user' do
+    context 'when bad email is given' do
+      it 'fails' do
+        mutation(:create_user, params { email: 'bad' })
+        expect(response).to be_failure
+      end
+
+      it 'contains errors' do
+        mutation(:create_user, params { email: 'bad' })
+        expect(response.errors).not_to be_empty
+      end
+    end
+  end
+end
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/graphql_rails. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the GraphqlRails project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/graphql_rails/blob/master/CODE_OF_CONDUCT.md).

data/docs/_sidebar.md

@@ -0,0 +1,9 @@
+* [Home](README)
+* Getting started
+  * [Setup](getting_started/setup)
+  * [Quick start](getting_started/quick_start)
+* Components
+  * [Routes](components/routes)
+  * [Model](components/model)
+  * [Controller](components/controller)
+* [Testing](testing/testing)

data/docs/components/controller.md

@@ -0,0 +1,152 @@
+# Controller
+
+Each controller should inherit from `GraphqlRails::Controller`. It is handy to have `ApplicationGraphqlController`:
+
+```ruby
+class ApplicationGraphqlController < GraphqlRails::Controller
+  # write your shared code here
+end
+```
+
+## *action*
+
+to specify details about each controller action, you need to call method `action` inside controller. For example:
+
+```ruby
+class ApplicationGraphqlController < GraphqlRails::Controller
+  # write your shared code here
+end
+```
+
+### *permit*
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:create).describe('Creates user')
+
+  def create
+    User.create(params)
+  end
+end
+```
+
+### *can_return_nil*
+
+By default it is expected that each controller action returns model or array of models. `nil` is not allowed. You can change that by adding `can_return_nil` like this:
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:show).permit(:email).can_return_nil
+
+  def show
+    user = User.find_by(email: params[:email])
+    return nil if user.blank?
+    user
+  end
+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)
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:index).paginated
+
+  def index
+    User.all
+  end
+end
+```
+
+#### *max_page_size*
+
+Allows to specify max items count per request
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:index).paginated(max_page_size: 10) # add max items limit
+
+  def index
+    User.all # it will render 10 users even you have more
+  end
+end
+```
+
+### *returns*
+
+By default return type is determined by controller name. When you want to return some custom object, you can specify that with `returns` method:
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:last_order).permit(:id).returns(Order)
+
+  def last_order
+    user = User.find(params[:id]).orders.last
+  end
+end
+```
+
+### *describe*
+
+If you want to improve graphql documentation, you can add description for each action. To do so, use `describe` method:
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:create).describe('Creates user')
+
+  def create
+    User.create(params)
+  end
+end
+```
+
+## *before_action*
+
+You can add `before_action` to run some filters before calling your controller action. Here is an example:
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  before_action :require_auth_token
+
+  def create
+    User.create(params)
+  end
+
+  private
+
+  def require_auth_token # will run before `UsersController#create` action
+    raise 'Not authenticated' unless User.where(token: params[:token]).exist?
+  end
+end
+```
+
+### *only* and *except* option
+
+`UsersController.before_action` accepts `only` or `except` options which allows to skip filters for some actions.
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  before_action :require_auth_token, except: :show
+  before_action :require_admin_token, only: %i[update destroy]
+
+  def create
+    User.create(params)
+  end
+
+  def destroy
+    User.create(params)
+  end
+
+  private
+
+  def require_auth_token
+    raise 'Not authenticated' unless User.where(token: params[:token]).exist?
+  end
+
+  def require_auth_token
+    raise 'Admin not authenticated' unless Admin.where(token: params[:admin_token]).exist?
+  end
+end
+```

data/docs/components/model.md

@@ -0,0 +1,123 @@
+# Model
+
+To make your model graphql-firendly, you need to inlcude `GraphqlRails::Model`. Your model can be any ruby class (PORO, ActiveRecord::Base or anything else)
+
+Also you need to define which attributes can be exposed via graphql. To do so, use `graphql` method inside your model body. Example:
+
+```ruby
+class User # works with any class including ActiveRecord
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.attribute :id
+    c.full_name, type: :string
+  end
+end
+```
+
+## _graphql_
+
+This method must be called inside your model body. `grapqhl` is used for making your model convertible to graphql type.
+
+### _attribute_
+
+Most commonly you will use `attribute` to make your model methods and attributes visible via graphql endpoint.
+
+#### _type_
+
+Some types can be determined by attribute name, so you can skip this attribute:
+
+* attributes which ends with name `*_id` has `ID` type
+* attributes which ends with `?` has `Boolean` type
+* all other attributes without type are considered to be `String`
+
+available types are:
+
+* ID: `'id'`
+* String: `'string'`, `'str'`, `'text'`
+* Boolean: `'bool'`, `'boolean'`
+* Float: `'float'`, `'double'`, `'decimal'`
+
+usage example:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.attribute :shop_id # ID type
+    c.attribute :full_name # String type
+    c.attribute :admin? # Boolean type
+    c.attribute :level, type: 'integer'
+    c.attribute :money, type: 'float'
+  end
+end
+```
+
+#### _property_
+
+By default graphql attribute names are expected to be same as model methods/attributes, but if you want to use different name on grapqhl side, you can use `propery` option:
+
+```
+class User
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.attribute :shop_id, property: :department_id
+  end
+
+  def department_id
+    456
+  end
+end
+```
+
+#### _description_
+
+You can also describe each attribute and make graphql documentation even more readable. To do so, add `description` option:
+
+```
+class User
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.attribute :shop_id, description: 'references to shop'
+  end
+end
+```
+
+### _name_
+
+By default grapqhl type name will be same as model name, but you can change it via `name` method
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.name 'Employee'
+  end
+end
+```
+
+### _description_
+
+To improve grapqhl documentation, you can description for your graphql type:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.description 'Users are awesome!'
+  end
+end
+```
+
+### *graphql_type*
+
+Sometimes it's handy to get raw graphql type. To do so you can call:
+
+```ruby
+YourModel.graphql.grapqhl_type
+```

data/docs/components/routes.md

@@ -0,0 +1,87 @@
+# Routes
+
+Routes are generated via `GraphqlRails::Router.draw` method. It is very similar to rails router, except that instead of `match`, `get`, `post` actions you have `query` and `mutation` actions. In most cases you will use `resources` action. It works same as in rails router.
+
+Here is simple router example:
+
+```ruby
+MyGraphqlSchema = 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 handeled by `Admin::TranslationsController`
+    mutation :updateTranslations, to: 'translations#update'
+
+    # all :groups routes will be handeled by `Admin::GroupsController`
+    resources :groups
+  end
+end
+```
+
+## _resources_
+
+`resources` method generates routes to `index`, `show`, `create`, `update` and `destroy` controller actions.
+
+### _only_ and _except_ option
+
+If you want to exclude some actions you can use `only` or `except` options.
+
+```ruby
+MyGraphqlSchema = GraphqlRails::Router.draw do
+  resouces :users
+  resouces :friends, only: :index
+  resouces :posts, except: [:destroy, :index]
+end
+```
+
+### custom actions
+
+Sometimes it's handy so have non-CRUD actions in your controller. To define such route you can call `resources` with a block:
+
+```ruby
+MyGraphqlSchema = GraphqlRails::Router.draw do
+  resouces :users do
+    mutation :changePassword, on: :member
+    query :active, on: :collection
+  end
+end
+```
+
+## _query_ and _mutation_
+
+in case you want to have non-CRUD controller with custom actions you can define your own `query`/`mutation` actions like this:
+
+```ruby
+MyGraphqlSchema = GraphqlRails::Router.draw do
+  mutation :logIn, to: 'sessions#login'
+  query :me, to 'users#current_user'
+end
+```
+
+## _scope_
+
+### _module_ options
+
+currently `scope` method accepts single option: `module`. `module` allows to specify controller namespace. So you can use scoped controllers, like so:
+
+```ruby
+MyGraphqlSchema = GraphqlRails::Router.draw do
+  scope module: 'admin/top_secret' do
+    mutation :logIn, to: 'sessions#login' # this will trigger Admin::TopSecret::SessionsController
+  end
+
+  mutation :logIn, to: 'sessions#login' # this will trigger ::SessionsController
+end
+```

data/docs/getting_started/quick_start.md

@@ -0,0 +1,55 @@
+# Quick Start
+
+## Define GraphQL schema as RoR routes
+
+```ruby
+MyGraphqlSchema = GraphqlRails::Router.draw do
+  # will create createUser, updateUser, deleteUser 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 < GraphqlRails::Controller
+  # 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!

data/docs/getting_started/setup.md

@@ -0,0 +1,16 @@
+## Setup
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphql_rails'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install graphql_rails
+

data/docs/index.html

@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Document</title>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+  <meta name="description" content="Description">
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+  <link rel="stylesheet" href="https://unpkg.com/docsify/lib/themes/vue.css">
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    function parseQueryString (queryString) {
+      var params = {};
+      var temp;
+      // Split into key/value pairs
+      queries = queryString.split("&");
+      // Convert the array of strings into an object
+      for (var i = 0, l = queries.length; i < l; i++ ) {
+        temp = queries[i].split('=');
+        params[temp[0]] = temp[1];
+      }
+      return params;
+    };
+
+    function getJsonFromUrl() {
+      return parseQueryString(location.search.substr(1));
+    }
+
+    window.$docsify = {
+      auto2top: true,
+      name: 'GraphqlRails',
+      repo: 'https://github.com/samesystem/graphql_rails',
+      subMaxLevel: 3,
+      loadSidebar: true,
+      formatUpdated: '{MM}/{DD} {HH}:{mm}',
+      branchBasePath: 'https://raw.githubusercontent.com/samesystem/graphql_rails/',
+      plugins: [
+        function (hook, vm) { // reasign any config value by param attribute
+          Object.assign(window.$docsify, getJsonFromUrl());
+        },
+
+        function (hook, vm) { // allow to change branch
+          if (!window.$docsify.branchBasePath || !window.$docsify.branch) {
+            return;
+          }
+
+          var branch = window.$docsify.branch;
+          var basePath = window.$docsify.branchBasePath + branch;
+          window.$docsify.basePath = basePath;
+        },
+
+        function (hook, vm) { // add edit page link
+          hook.beforeEach(function (html) {
+            var branch = window.$docsify.branch || 'master'
+            var url = 'https://github.com/samesystem/graphql_rails/edit/' + branch + '/docs/' + vm.route.file
+            var editHtml = '[:memo: Edit Document](' + url + ')\n'
+            return html
+              + '\n\n----\n\n'
+              + editHtml
+          })
+        }
+      ]
+    }
+  </script>
+  <script src="https://unpkg.com/docsify/lib/docsify.js"></script>
+  <script src="https://unpkg.com/docsify/lib/plugins/search.min.js"></script>
+</body>
+</html>

data/docs/testing/testing.md

@@ -0,0 +1,68 @@
+# Testing
+
+## Testing graphql controllers in RSpec
+
+### Setup
+
+Add those lines in your `spec/spec_helper.rb` file
+
+```ruby
+# spec/spec_helper.rb
+require 'graphql_rails/rspec_controller_helpers'
+
+RSpec.configure do |config|
+  config.include(GraphqlRails::RSpecControllerHelpers, type: :graphql_controller)
+  # ... your other configuration ...
+end
+```
+
+### Helper methods
+
+There are 3 helper methods:
+
+* `mutation(:your_controller_action_name, params: {}, context: {})`. `params` and `context` are optional
+* `query(:your_controller_action_name, params: {}, context: {})`. `params` and `context` are optional
+* `response`. Response is set only after you call `mutation` or `query`
+
+### Test examples
+
+```ruby
+class MyGraphqlController
+  def index
+    "Called from index: #{params[:message]}"
+  end
+
+  action(:create_user).permit(:full_name, :email)
+  def create_user
+    User.create!(params)
+  end
+end
+
+RSpec.describe MyGraphqlController, type: :graphql_controller do
+  describe '#index' do
+    it 'is successful' do
+      query(:index)
+      expect(response).to be_successful
+    end
+
+    it 'returns correct message' do
+      query(:index, params: { message: 'Hello world!' })
+      expect(response.result).to eq "Called from index: Hello world!"
+    end
+  end
+
+  describe '#create_user' do
+    context 'when bad email is given' do
+      it 'fails' do
+        mutation(:create_user, params { email: 'bad' })
+        expect(response).to be_failure
+      end
+
+      it 'contains errors' do
+        mutation(:create_user, params { email: 'bad' })
+        expect(response.errors).not_to be_empty
+      end
+    end
+  end
+end
+```

data/lib/graphql_rails/controller.rb

@@ -9,12 +9,12 @@ module GraphqlRails
   # base class for all graphql_rails controllers
   class Controller
     class << self
-      def before_action(action_name)
-        controller_configuration.add_before_action(action_name)
+      def before_action(*args)
+        controller_configuration.add_before_action(*args)
       end
 
-      def action(method_name)
-        controller_configuration.action(method_name)
+      def action(action_name)
+        controller_configuration.action(action_name)
       end
 
       def controller_configuration
@@ -55,9 +55,11 @@ module GraphqlRails
 
     private
 
-    def call_with_rendering(method_name)
-      self.class.controller_configuration.before_actions.each { |action_name| send(action_name) }
-      response = public_send(method_name)
+    def call_with_rendering(action_name)
+      before_actions = self.class.controller_configuration.before_actions_for(action_name)
+      before_actions.each { |before_action| send(before_action.name) }
+      response = public_send(action_name)
+
       render response if graphql_request.no_object_to_return?
     rescue StandardError => error
       render error: error

data/lib/graphql_rails/controller/before_action_filter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  class Controller
+    # stores information about controller filter
+    class BeforeActionFilter
+      attr_reader :name
+
+      def initialize(name, only: [], except: [])
+        @name = name
+        @only_actions = Array(only).map(&:to_sym)
+        @except_actions = Array(except).map(&:to_sym)
+      end
+
+      def applicable_for?(action_name)
+        if only_actions.any?
+          only_actions.include?(action_name.to_sym)
+        elsif except_actions.any?
+          !except_actions.include?(action_name.to_sym)
+        else
+          true
+        end
+      end
+
+      private
+
+      attr_reader :only_actions, :except_actions
+    end
+  end
+end

data/lib/graphql_rails/controller/configuration.rb

@@ -3,21 +3,25 @@
 require 'active_support/core_ext/string/inflections'
 require 'graphql_rails/attribute'
 require 'graphql_rails/controller/action_configuration'
+require 'graphql_rails/controller/before_action_filter'
 
 module GraphqlRails
   class Controller
     # stores all graphql_rails contoller specific config
     class Configuration
-      attr_reader :before_actions
-
       def initialize(controller)
         @controller = controller
-        @before_actions = Set.new
+        @before_actions = {}
         @action_by_name = {}
       end
 
-      def add_before_action(name)
-        before_actions << name
+      def before_actions_for(action_name)
+        before_actions.values.select { |action| action.applicable_for?(action_name) }
+      end
+
+      def add_before_action(name, **options)
+        symbolized_name = name.to_sym
+        before_actions[symbolized_name] = BeforeActionFilter.new(symbolized_name, **options)
       end
 
       def action(method_name)
@@ -26,7 +30,7 @@ module GraphqlRails
 
       private
 
-      attr_reader :controller
+      attr_reader :controller, :before_actions
     end
   end
 end

data/lib/graphql_rails/model/configuration.rb

@@ -9,6 +9,12 @@ module GraphqlRails
     class Configuration
       attr_reader :attributes
 
+      COUNT_TOTAL_ITEMS = lambda do |obj, _args, _ctx|
+        obj_nodes = obj.nodes
+        obj_nodes = obj_nodes.except(:offset) if obj_nodes.is_a?(ActiveRecord::Relation)
+        obj_nodes.size
+      end
+
       def initialize(model_class)
         @model_class = model_class
         @attributes = {}
@@ -42,7 +48,7 @@ module GraphqlRails
       def connection_type
         @connection_type ||= begin
           graphql_type.define_connection do
-            field :total, types.Int, resolve: ->(obj, _args, _ctx) { obj.nodes.size }
+            field :total, types.Int, resolve: COUNT_TOTAL_ITEMS
           end
         end
       end

data/lib/graphql_rails/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql_rails
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Povilas Jurčys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-20 00:00:00.000000000 Z
+date: 2018-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -101,6 +101,16 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- docs/.nojekyll
+- docs/README.md
+- docs/_sidebar.md
+- docs/components/controller.md
+- docs/components/model.md
+- docs/components/routes.md
+- docs/getting_started/quick_start.md
+- docs/getting_started/setup.md
+- docs/index.html
+- docs/testing/testing.md
 - graphql_rails.gemspec
 - lib/graphql_rails.rb
 - lib/graphql_rails/attribute.rb
@@ -108,6 +118,7 @@ files:
 - lib/graphql_rails/controller.rb
 - lib/graphql_rails/controller/action.rb
 - lib/graphql_rails/controller/action_configuration.rb
+- lib/graphql_rails/controller/before_action_filter.rb
 - lib/graphql_rails/controller/configuration.rb
 - lib/graphql_rails/controller/controller_function.rb
 - lib/graphql_rails/controller/format_results.rb