graphql_rails 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd207ff4c895c9024b121bb5de205b289d8d2e54266022cfcc8e167fae2af097
-  data.tar.gz: c95bc639ce9adecf31ebc3c11e70a8214de31663c41be1aa539e70b1a04350f7
+  metadata.gz: 233cb42d66f27e1bd3b18d5530977285e84358897d9fa4cde2230a811b4712b1
+  data.tar.gz: 773ff5c8223431e2b606c522fbcc5275157d7255b6348bf475a0aa9c76282926
 SHA512:
-  metadata.gz: 272d3e7b1ddad299aa58fc2fff01a2e9e336771495e04e5e279ead269ac3ac7a003621a1d7e81fcdb822b82ad61d07138b38443fe1b128403058b607a9175dad
-  data.tar.gz: 5b237e8afd7d7c9c098e3d0ab62e388ed09469bfb1b86874fa1c7c6ea05d9f7199bb430853f9dce81999567bfd197856a5c4514267a3d1fe5adfd6cf914fce5a
+  metadata.gz: c1034a92ab82fb88dfb94b2eb6502b51e2d97ef4f04e6804abd6cb3a8900117682f6cc717576d5aa16008d3486a8182dc2f503d5d307ad9184177e7968d13467
+  data.tar.gz: d44a9b5d7ad5d3a2663bc40edcef96240e7525e2060ca57d360b6b8640af03ebfd3dc13eae97e11ac77d07d1d283a9480bd567e84aa0f7dc8960e35d6ad329a1

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
 
+## [0.8.0] (2019-09-03)
+
+* Added: permit_input action config with extended list of permitted input options
+* Added: model decorators
+* Added: controller action instrumentation [@povilasjurcys](https://github.com/povilasjurcys)
+* Added: sentry and lograge integrations
+* Added: required: true flag for permitted attributes, inputs and model attributes
+
 ## 0.7.0 (2019-05-15)
 
 * Added: input type now accepts `enum` param which allows create enum fields

data/Gemfile.lock

@@ -1,19 +1,49 @@
 PATH
   remote: .
   specs:
-    graphql_rails (0.7.0)
+    graphql_rails (0.8.0)
       activesupport (>= 4)
       graphql (~> 1)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    actioncable (5.2.2.1)
+      actionpack (= 5.2.2.1)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailer (5.2.2.1)
+      actionpack (= 5.2.2.1)
+      actionview (= 5.2.2.1)
+      activejob (= 5.2.2.1)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (5.2.2.1)
+      actionview (= 5.2.2.1)
+      activesupport (= 5.2.2.1)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.2.2.1)
+      activesupport (= 5.2.2.1)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activejob (5.2.2.1)
+      activesupport (= 5.2.2.1)
+      globalid (>= 0.3.6)
     activemodel (5.2.2.1)
       activesupport (= 5.2.2.1)
     activerecord (5.2.2.1)
       activemodel (= 5.2.2.1)
       activesupport (= 5.2.2.1)
       arel (>= 9.0)
+    activestorage (5.2.2.1)
+      actionpack (= 5.2.2.1)
+      activerecord (= 5.2.2.1)
+      marcel (~> 0.3.1)
     activesupport (5.2.2.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
@@ -22,6 +52,7 @@ GEM
     arel (9.0.0)
     ast (2.4.0)
     bson (4.4.2)
+    builder (3.2.3)
     byebug (11.0.1)
     codecov (0.1.14)
       json
@@ -29,20 +60,37 @@ GEM
       url
     coderay (1.1.2)
     concurrent-ruby (1.1.5)
+    crass (1.0.4)
     diff-lcs (1.3)
     docile (1.3.1)
-    graphql (1.9.4)
+    erubi (1.8.0)
+    globalid (0.4.2)
+      activesupport (>= 4.2.0)
+    graphql (1.9.7)
     i18n (1.6.0)
       concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.2)
     json (2.2.0)
+    loofah (2.2.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (0.3.3)
+      mimemagic (~> 0.3.2)
     method_source (0.9.2)
+    mimemagic (0.3.3)
+    mini_mime (1.0.1)
+    mini_portile2 (2.4.0)
     minitest (5.11.3)
     mongo (2.8.0)
       bson (>= 4.4.2, < 5.0.0)
     mongoid (7.0.2)
       activemodel (>= 5.1, < 6.0.0)
       mongo (>= 2.5.1, < 3.0.0)
+    nio4r (2.3.1)
+    nokogiri (1.10.4)
+      mini_portile2 (~> 2.4.0)
     parallel (1.16.0)
     parser (2.6.2.0)
       ast (~> 2.4.0)
@@ -53,6 +101,33 @@ GEM
       byebug (~> 11.0)
       pry (~> 0.10)
     psych (3.1.0)
+    rack (2.0.7)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails (5.2.2.1)
+      actioncable (= 5.2.2.1)
+      actionmailer (= 5.2.2.1)
+      actionpack (= 5.2.2.1)
+      actionview (= 5.2.2.1)
+      activejob (= 5.2.2.1)
+      activemodel (= 5.2.2.1)
+      activerecord (= 5.2.2.1)
+      activestorage (= 5.2.2.1)
+      activesupport (= 5.2.2.1)
+      bundler (>= 1.3.0)
+      railties (= 5.2.2.1)
+      sprockets-rails (>= 2.0.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.4)
+      loofah (~> 2.2, >= 2.2.2)
+    railties (5.2.2.1)
+      actionpack (= 5.2.2.1)
+      activesupport (= 5.2.2.1)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.19.0, < 2.0)
     rainbow (3.0.0)
     rake (10.5.0)
     rspec (3.8.0)
@@ -84,11 +159,22 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
+    sprockets (3.7.2)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.2.1)
+      actionpack (>= 4.0)
+      activesupport (>= 4.0)
+      sprockets (>= 3.0.0)
+    thor (0.20.3)
     thread_safe (0.3.6)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
     unicode-display_width (1.5.0)
     url (0.3.2)
+    websocket-driver (0.7.1)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.4)
 
 PLATFORMS
   ruby
@@ -100,6 +186,7 @@ DEPENDENCIES
   graphql_rails!
   mongoid
   pry-byebug
+  rails (~> 5)
   rake (~> 10.0)
   rspec (~> 3.0)
   rubocop

data/docs/README.md

@@ -171,6 +171,22 @@ RSpec.describe MyGraphqlController, type: :graphql_controller do
 end
 ```
 
+### Integrating GraphqlRails with other tools
+
+In order to make GraphqlRails work with tools such as lograge or sentry, you need to enable them. In Ruby on Rails, you can add initializer:
+
+```ruby
+# config/initializers/graphql_rails.rb
+GraphqlRails::Integrations.enable(:lograge, :sentry)
+```
+
+At the moment, GraphqlRails supports following integrations:
+
+* lograge
+* sentry
+
+If you need to build something custom, check [logging_and_monitoring documentation](logging_and_monitoring/logging_and_monitoring.md) for more details.
+
 ## Detailed documentation
 
 Check https://samesystem.github.io/graphql_rails for more details

data/docs/_sidebar.md

@@ -6,4 +6,6 @@
   * [Routes](components/routes)
   * [Model](components/model)
   * [Controller](components/controller)
+  * [Decorator](components/decorator)
+* [Logging and monitoring](logging_and_monitoring/logging_and_monitoring)
 * [Testing](testing/testing)

data/docs/components/controller.md

@@ -66,6 +66,95 @@ class UsersController < GraphqlRails::Controller
 end
 ```
 
+### *permit_input*
+
+Allows to permit single input field. It allows to set additional options for each field.
+
+#### *type*
+
+Specifies input type:
+
+```ruby
+class OrderController < GraphqlRails::Controller
+  action(:create)
+    .permit_input(:price, type: :integer!)
+    # Same as `.permit(amount: :integer!)`
+end
+```
+
+#### required type
+
+There are few ways how to mark field as required.
+
+1. Adding exclamation mark at the end of type name:
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:create).permit_input(:some_field, type: :int!)
+end
+```
+
+2. Adding exclamation mark at the end of name
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:create).permit_input(:some_field!)
+end
+```
+
+3. Adding `required: true` options
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:create).permit_input(:some_field, type: :bool, required: true)
+end
+```
+
+#### *description*
+
+You can describe each input by adding `description` keyword argument:
+
+```ruby
+class OrderController < GraphqlRails::Controller
+  action(:create)
+    .permit_input(:price, type: :integer!, description: 'Price in Euro cents')
+end
+```
+
+#### *subtype*
+
+`subtype` allows to specify which named input should be used. Here is an example:
+
+Let's say you have user with two input types
+
+```ruby
+class User
+  graphql.input do |c|
+    c.attribute :full_name
+    c.attribute :email
+  end
+
+  graphql.input(:change_password) do |c|
+    c.attribute :password
+    c.attribute :password_confirmation
+  end
+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
+  # this is the input with email and full_name:
+  action(:create)
+    .permit_input(:input, type: 'User!')
+
+  # this is the input with password and password_confirmation:
+  action(:update_password)
+    .permit_input(:input, type: 'User!', subtype: :change_password)
+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:
@@ -96,6 +185,8 @@ class UsersController < GraphqlRails::Controller
 end
 ```
 
+Also check ['decorating controller responses']('components/decorator') for more details about working with active record and decorators.
+
 #### *max_page_size*
 
 Allows to specify max items count per request
@@ -153,6 +244,24 @@ class UsersController < GraphqlRails::Controller
 end
 ```
 
+### configuring action with a block
+
+If you do not like chainable methods, you can use "block" style action configuration:
+
+```ruby
+class UsersController < GraphqlRails::Controller
+  action(:index) do |action|
+    action.paginated
+    action.permit(limit: :int!)
+    action.returns '[User!]!'
+  end
+
+  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:
@@ -263,3 +372,7 @@ class UsersController < GraphqlRails::Controller
   end
 end
 ```
+
+## decorating objects
+
+See ['Decorating controller responses']('components/decorator') for various options how you can decorate paginated responses

data/docs/components/decorator.md

@@ -0,0 +1,69 @@
+# Decorator
+
+Decorator is mostly used whit paginated results, because it can wrap ActiveRecord relations in a "pagination-friendly" way
+
+## Passing extra options to decorator
+
+Let's say you want to decorate `comment`, but you also need `user` in order to print some details. Here is decorator for such comment:
+
+```ruby
+class CommentDecorator < SimpleDelegator
+  include GraphqlRails::Decorator
+
+  def initialize(comment, current_user)
+    @comment = comment
+    @current_user = user
+  end
+
+  def author_name
+    if @current_user.can_see_author_name?(@comment)
+      @comment.author_name
+    else
+      'secret author'
+    end
+  end
+end
+```
+
+In order to decorate object with exra arguments, simply pass them to `.decorate` method. Like this:
+
+```ruby
+CommentDecorator.decorate(comment, current_user)
+```
+
+The only requirement is that first object should be the object which you are decorating. Other arguments are treated as extra data and they are not modified
+
+## Decorating controller responses
+
+If you want to decorate your controller response you can use `GraphqlRails::Decorator` module. It can decorate simple objects and ActiveRecord::Relation objects. This is very handy when you need to decorated paginated actions:
+
+```ruby
+class User < ActiveRecord::Base
+  # it's not GraphqlRails::Model !
+end
+
+class UserDecorator < SimpleDelegator
+  include GraphqlRails::Model
+  include GraphqlRails::Decorator
+
+  graphql_rails do
+    # some setup, attributes, etc...
+  end
+
+  def initialize(user); end
+end
+
+class UsersController < GraphqlRails::Controller
+  action(:index).paginated.returns('[UserDecorator!]!')
+
+  def index
+    users = User.where(active: true)
+    UserDecorator.decorate(users)
+  end
+
+  def create
+    user = User.create(params)
+    UserDecorator.decorate(user)
+  end
+end
+```

data/docs/components/model.md

@@ -58,7 +58,7 @@ end
 
 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:
 
-```
+```ruby
 class User
   include GraphqlRails::Model
 
@@ -76,7 +76,7 @@ end
 
 You can also describe each attribute and make graphql documentation even more readable. To do so, add `description` option:
 
-```
+```ruby
 class User
   include GraphqlRails::Model
 
@@ -86,6 +86,39 @@ class User
 end
 ```
 
+### "attribute" configuration with chainable methods
+
+If your attribute definition is complex, you can define attribute in more eye-friendly chainable way with:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.attribute(:shop_id)
+      .type('ID!')
+      .description('references to shop')
+  end
+end
+```
+
+### "attribute" configuration with a block
+
+You can also use block in order to specify attribute configuration:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql do |c|
+    c.attribute(:shop_id) do |attr|
+      attr.type 'ID!'
+      attr.description 'references to shop'
+    end
+  end
+end
+```
+
 ## name
 
 By default grapqhl type name will be same as model name, but you can change it via `name` method
@@ -171,6 +204,34 @@ class User
 end
 ```
 
+#### required type
+
+There are few ways how to mark field as required.
+
+1. Adding exclamation mark at the end of type name:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql.input do |c|
+    c.attribute :friends_count, type: :integer!
+  end
+end
+```
+
+2. Adding `required: true` value
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql.input do |c|
+    c.attribute :friends_count, type: :integer, required: true
+  end
+end
+```
+
 #### input enum type
 
 You can specify your input attribute as enum:
@@ -185,6 +246,18 @@ class User
 end
 ```
 
+By default enum type is not required. To make it required add `required: true`:
+
+```ruby
+class User
+  include GraphqlRails::Model
+
+  graphql.input do |c|
+    c.attribute :favorite_fruit, required: true, enum: %i[apple orange]
+  end
+end
+```
+
 #### input attribute description
 
 To improve graphql endpoint documentation, you can add description for each input attribute:

data/docs/logging_and_monitoring/logging_and_monitoring.md

@@ -0,0 +1,35 @@
+# Logging and monitoring
+
+GraphqlRails behaves similar as Ruby on Rails. This allows to use existing monitoring and logging tools. Here we will add some examples on how to setup various tools for GraphqlRails
+
+## Integrating GraphqlRails with other tools
+
+In order to make GraphqlRails work with tools such as lograge or sentry, you need to enable them. In Ruby on Rails, you can add initializer:
+
+```ruby
+# config/initializers/graphql_rails.rb
+GraphqlRails::Integrations.enable(:lograge, :sentry)
+```
+
+At the moment, GraphqlRails supports following integrations:
+
+* lograge
+* sentry
+
+## Instrumentation
+
+GraphqlRails uses same instrumentation tool (`ActiveSupport::Notifications`) as Ruby on Rails. At the moment there are two notification types:
+
+* `process_action.graphql_action_controller`
+* `start_action.graphql_action_controller`
+
+you can watch those actions using with `ActiveSupport::Notifications#subscribe` like this:
+
+```ruby
+key = 'process_action.graphql_action_controller'
+ActiveSupport::Notifications.subscribe(key) do |*_, payload|
+  YourLogger.do_something(payload)
+end
+```
+
+or you can do the same with `ActiveSupport::LogSubscriber`. More details about it [here](https://api.rubyonrails.org/classes/ActiveSupport/LogSubscriber.html).

data/graphql_rails.gemspec

@@ -28,4 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'activerecord'
   spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rails', '~> 5'
 end

data/lib/graphql_rails/attributes/attributable.rb

@@ -21,7 +21,11 @@ module GraphqlRails
       end
 
       def required?
-        attribute_name_parser.required? || !initial_type.to_s[/!$/].nil?
+        if @required.nil?
+          attribute_name_parser.required? || !initial_type.to_s[/!$/].nil?
+        else
+          @required
+        end
       end
 
       def graphql_model

data/lib/graphql_rails/attributes/attribute.rb

@@ -9,17 +9,44 @@ module GraphqlRails
     class Attribute
       include Attributable
 
-      attr_reader :property, :description
-
-      def initialize(name, type = nil, description: nil, property: name)
+      def initialize(name, type = nil, description: nil, property: name, required: nil)
         @initial_type = type
         @initial_name = name
         @description = description
         @property = property.to_s
+        @required = required
+      end
+
+      def type(new_type = nil)
+        return @initial_type if new_type.nil?
+
+        @initial_type = new_type
+        self
+      end
+
+      def description(new_description = nil)
+        return @description if new_description.nil?
+
+        @description = new_description
+        self
+      end
+
+      def property(new_property = nil)
+        return @property if new_property.nil?
+
+        @property = new_property.to_s
+        self
       end
 
       def field_args
-        [field_name, graphql_field_type, { property: property.to_sym, description: description }]
+        [
+          field_name,
+          graphql_field_type,
+          {
+            property: property.to_sym,
+            description: description
+          }
+        ]
       end
 
       protected

data/lib/graphql_rails/attributes/input_attribute.rb

@@ -4,44 +4,48 @@ module GraphqlRails
   module Attributes
     # contains info about single graphql input attribute
     class InputAttribute
+      require_relative './input_type_parser'
       include Attributable
 
       attr_reader :description
 
-      def initialize(name, type = nil, description: nil, options: {})
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(name, type = nil, description: nil, subtype: nil, required: nil, options: {})
         @initial_name = name
         @initial_type = type
         @description = description
         @options = options
+        @subtype = subtype
+        @required = required
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def function_argument_args
         [field_name, graphql_input_type, { description: description }]
       end
 
       def input_argument_args
-        type = raw_input_type || model_input_type || nullable_type
+        type = raw_input_type || input_type_parser.nullable_type || nullable_type
+
         [field_name, type, { required: required?, description: description }]
       end
 
       def graphql_input_type
-        raw_input_type || model_input_type || graphql_field_type
+        raw_input_type || input_type_parser.graphql_type || graphql_field_type
       end
 
       private
 
-      attr_reader :initial_name, :initial_type, :options
+      attr_reader :initial_name, :initial_type, :options, :subtype
+
+      def input_type_parser
+        @input_type_parser ||= InputTypeParser.new(initial_type, subtype: subtype)
+      end
 
       def raw_input_type
         return initial_type if initial_type.is_a?(GraphQL::InputObjectType)
         return initial_type.graphql_input_type if initial_type.is_a?(Model::Input)
       end
-
-      def model_input_type
-        return unless graphql_model
-
-        graphql_model.graphql.input.graphql_input_type
-      end
     end
   end
 end