graphql_rails 0.7.0 → 0.8.0

data/lib/graphql_rails/attributes/input_type_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+module GraphqlRails
+  module Attributes
+    # converts string value in to GraphQL type
+    class InputTypeParser < TypeParser
+      def initialize(unparsed_type, subtype:)
+        super(unparsed_type)
+        @subtype = subtype
+      end
+
+      def graphql_type
+        return nil if unparsed_type.nil?
+
+        partly_parsed_type || parsed_type
+      end
+
+      def nullable_type
+        return nil if unparsed_type.nil?
+
+        partly_parsed_type || parsed_nullable_type
+      end
+
+      protected
+
+      def partly_parsed_type
+        return unparsed_type if raw_graphql_type?
+        return unparsed_type.graphql_input_type if unparsed_type.is_a?(GraphqlRails::Model::Input)
+      end
+
+      def parsed_nullable_type
+        if list?
+          parsed_inner_type.to_list_type
+        else
+          type_by_name
+        end
+      end
+
+      def parsed_type
+        if list?
+          parsed_list_type
+        else
+          parsed_inner_type
+        end
+      end
+
+      def raw_graphql_type?
+        unparsed_type.is_a?(GraphQL::InputObjectType) || super
+      end
+
+      def dynamicly_defined_type
+        type_class = graphql_model
+        return unless type_class
+
+        type_class.graphql.input(*subtype).graphql_input_type
+      end
+
+      def parsed_list_type
+        list_type = parsed_inner_type.to_list_type
+
+        if required_list?
+          list_type = list_type.to_graphql if list_type.respond_to?(:to_graphql)
+          list_type.to_non_null_type
+        else
+          list_type
+        end
+      end
+
+      def parsed_inner_type
+        if required_inner_type?
+          type_by_name.to_non_null_type
+        else
+          type_by_name
+        end
+      end
+
+      private
+
+      attr_reader :subtype
+    end
+  end
+end

data/lib/graphql_rails/attributes/type_name_info.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Attributes
+    # checks various attributes based on graphql type name
+    class TypeNameInfo
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def nullable_inner_name
+        inner_name[/[^!]+/]
+      end
+
+      def inner_name
+        name[/[^!\[\]]+!?/]
+      end
+
+      def required_inner_type?
+        inner_name.include?('!')
+      end
+
+      def list?
+        name.include?(']')
+      end
+
+      def required?
+        name.end_with?('!')
+      end
+
+      def required_list?
+        required? && list?
+      end
+    end
+  end
+end

data/lib/graphql_rails/attributes/type_parser.rb

@@ -6,6 +6,8 @@ module GraphqlRails
   module Attributes
     # converts string value in to GraphQL type
     class TypeParser
+      require_relative './type_name_info'
+
       class UnknownTypeError < ArgumentError; end
 
       TYPE_MAPPING = {
@@ -28,6 +30,13 @@ module GraphqlRails
         'decimal' => GraphQL::FLOAT_TYPE
       }.freeze
 
+      RAW_GRAPHQL_TYPES = [
+        GraphQL::Schema::List,
+        GraphQL::BaseType,
+        GraphQL::ObjectType,
+        GraphQL::InputObjectType
+      ].freeze
+
       def initialize(unparsed_type)
         @unparsed_type = unparsed_type
       end
@@ -43,20 +52,31 @@ module GraphqlRails
       end
 
       def graphql_model
-        type_class = inner_type_name.safe_constantize
+        type_class = nullable_inner_name.safe_constantize
         return unless type_class.respond_to?(:graphql)
 
         type_class
       end
 
+      protected
+
+      def dynamicly_defined_type
+        type_class = graphql_model
+        return unless type_class
+
+        type_class.graphql.graphql_type
+      end
+
       private
 
+      delegate :list?, :required_inner_type?, :required_list?, :nullable_inner_name, to: :type_name_info
+
       attr_reader :unparsed_type
 
       def parsed_list_type
         list_type = parsed_inner_type.to_list_type
 
-        if required_list_type?
+        if required_list?
           list_type.to_non_null_type
         else
           list_type
@@ -71,31 +91,20 @@ module GraphqlRails
         end
       end
 
-      def required_inner_type?
-        !!unparsed_type[/\w!/] # rubocop:disable Style/DoubleNegation
-      end
-
-      def list?
-        unparsed_type.to_s.include?(']')
-      end
-
-      def required_list_type?
-        unparsed_type.to_s.include?(']!')
-      end
-
       def raw_graphql_type?
-        unparsed_type.is_a?(GraphQL::BaseType) ||
-          unparsed_type.is_a?(GraphQL::ObjectType) ||
-          unparsed_type.is_a?(GraphQL::InputObjectType) ||
-          (defined?(GraphQL::Schema::Member) && unparsed_type.is_a?(Class) && unparsed_type < GraphQL::Schema::Member)
+        return true if RAW_GRAPHQL_TYPES.detect { |raw_type| unparsed_type.is_a?(raw_type) }
+
+        defined?(GraphQL::Schema::Member) &&
+          unparsed_type.is_a?(Class) &&
+          unparsed_type < GraphQL::Schema::Member
       end
 
-      def inner_type_name
-        unparsed_type.to_s.tr('[]!', '')
+      def type_name_info
+        @type_name_info ||= TypeNameInfo.new(unparsed_type.to_s)
       end
 
       def type_by_name
-        TYPE_MAPPING.fetch(inner_type_name.downcase) do
+        TYPE_MAPPING.fetch(nullable_inner_name.downcase) do
           dynamicly_defined_type || raise(
             UnknownTypeError,
             "Type #{unparsed_type.inspect} is not supported. Supported scalar types are: #{TYPE_MAPPING.keys}." \
@@ -103,13 +112,6 @@ module GraphqlRails
           )
         end
       end
-
-      def dynamicly_defined_type
-        type_class = graphql_model
-        return unless type_class
-
-        type_class.graphql.graphql_type
-      end
     end
   end
 end

data/lib/graphql_rails/controller/action_configuration.rb

@@ -26,8 +26,19 @@ module GraphqlRails
       end
 
       def permit(*no_type_attributes, **typed_attributes)
-        no_type_attributes.each { |attribute| permit_attribute(attribute) }
-        typed_attributes.each { |attribute, type| permit_attribute(attribute, type) }
+        no_type_attributes.each { |attribute| permit_input(attribute) }
+        typed_attributes.each { |attribute, type| permit_input(attribute, type: type) }
+        self
+      end
+
+      def permit_input(name, type: nil, options: {}, **input_options)
+        field_name = name.to_s.remove(/!\Z/)
+
+        attributes[field_name] = Attributes::InputAttribute.new(
+          name.to_s, type,
+          options: action_options.merge(options),
+          **input_options
+        )
         self
       end
 
@@ -86,11 +97,6 @@ module GraphqlRails
       def type_parser
         Attributes::TypeParser.new(custom_return_type)
       end
-
-      def permit_attribute(name, type = nil)
-        field_name = name.to_s.remove(/!\Z/)
-        attributes[field_name] = Attributes::InputAttribute.new(name.to_s, type, options: action_options)
-      end
     end
   end
 end

data/lib/graphql_rails/controller/configuration.rb

@@ -45,6 +45,8 @@ module GraphqlRails
 
       def action(method_name)
         @action_by_name[method_name.to_s] ||= ActionConfiguration.new
+        yield(@action_by_name[method_name.to_s]) if block_given?
+        @action_by_name[method_name.to_s]
       end
 
       private

data/lib/graphql_rails/controller/log_controller_action.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/errors/execution_error'
+
+module GraphqlRails
+  class Controller
+    # logs controller start and end times
+    class LogControllerAction
+      START_PROCESSING_KEY = 'start_processing.graphql_action_controller'
+      PROCESS_ACTION_KEY = 'process_action.graphql_action_controller'
+
+      def self.call(**kwargs, &block)
+        new(**kwargs).call(&block)
+      end
+
+      def initialize(controller_name:, action_name:, params:, graphql_request:)
+        @controller_name = controller_name
+        @action_name = action_name
+        @params = params
+        @graphql_request = graphql_request
+      end
+
+      def call
+        ActiveSupport::Notifications.instrument(START_PROCESSING_KEY, default_payload)
+        ActiveSupport::Notifications.instrument(PROCESS_ACTION_KEY, default_payload) do |payload|
+          yield.tap do
+            payload[:status] = status
+          end
+        end
+      end
+
+      private
+
+      attr_reader :controller_name, :action_name, :params, :graphql_request
+
+      def default_payload
+        {
+          controller: controller_name,
+          action: action_name,
+          params: filtered_params
+        }
+      end
+
+      def status
+        graphql_request.errors.present? ? 500 : 200
+      end
+
+      def filtered_params
+        @filtered_params ||=
+          if filter_parameters.empty?
+            params
+          else
+            filter_options = Rails.configuration.filter_parameters
+            parametter_filter = ActionDispatch::Http::ParameterFilter.new(filter_options)
+            parametter_filter.filter(params)
+          end
+      end
+
+      def filter_parameters
+        return [] if !defined?(Rails) || Rails.application.nil?
+
+        Rails.application.config.filter_parameters || []
+      end
+    end
+  end
+end

data/lib/graphql_rails/controller.rb

@@ -6,12 +6,14 @@ require 'graphql_rails/controller/configuration'
 require 'graphql_rails/controller/request'
 require 'graphql_rails/controller/format_results'
 require 'graphql_rails/controller/action_hooks_runner'
+require 'graphql_rails/controller/log_controller_action'
 
 module GraphqlRails
   # base class for all graphql_rails controllers
   class Controller
     class << self
       def inherited(sublass)
+        super
         sublass.instance_variable_set(:@controller_configuration, controller_configuration.dup)
       end
 
@@ -44,14 +46,10 @@ module GraphqlRails
 
     def call(method_name)
       @action_name = method_name
-      call_with_rendering(method_name)
-
-      FormatResults.new(
-        graphql_request.object_to_return,
-        action_config: self.class.action(method_name),
-        params: params,
-        graphql_context: graphql_request.context
-      ).call
+      with_controller_action_logging do
+        call_with_rendering
+        format_controller_results
+      end
     ensure
       @action_name = nil
     end
@@ -74,7 +72,7 @@ module GraphqlRails
 
     private
 
-    def call_with_rendering(action_name)
+    def call_with_rendering
       hooks_runner = ActionHooksRunner.new(action_name: action_name, controller: self)
       response = hooks_runner.call { public_send(action_name) }
 
@@ -90,5 +88,24 @@ module GraphqlRails
       errors = rendering_params[:error] || rendering_params[:errors]
       Array(errors)
     end
+
+    def with_controller_action_logging(&block)
+      LogControllerAction.call(
+        controller_name: self.class.name,
+        action_name: action_name,
+        params: params,
+        graphql_request: graphql_request,
+        &block
+      )
+    end
+
+    def format_controller_results
+      FormatResults.new(
+        graphql_request.object_to_return,
+        action_config: self.class.action(action_name),
+        params: params,
+        graphql_context: graphql_request.context
+      ).call
+    end
   end
 end

data/lib/graphql_rails/decorator/relation_decorator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Decorator
+    # wrapps active record relation and returns decorated object instead
+    class RelationDecorator
+      delegate :map, :each, to: :to_a
+      delegate :limit_value, :offset_value, :count, :size, to: :relation
+
+      def self.decorates?(object)
+        (defined?(ActiveRecord) && object.is_a?(ActiveRecord::Relation)) ||
+          defined?(Mongoid) && object.is_a?(Mongoid::Criteria)
+      end
+
+      def initialize(decorator:, relation:, decorator_args: [])
+        @relation = relation
+        @decorator = decorator
+        @decorator_args = decorator_args
+      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)
+        end
+      end
+
+      %i[first second last].each do |method_name|
+        define_method method_name do |*args, &block|
+          decoratable_object_method(method_name, *args, &block)
+        end
+      end
+
+      %i[find_each].each do |method_name|
+        define_method method_name do |*args, &block|
+          decoratable_block_method(method_name, *args, &block)
+        end
+      end
+
+      def to_a
+        @to_a ||= relation.to_a.map { |it| decorator.new(it) }
+      end
+
+      private
+
+      attr_reader :relation, :decorator, :decorator_args
+
+      def decoratable_object_method(method_name, *args, &block)
+        object = relation.public_send(method_name, *args, &block)
+        decorate(object)
+      end
+
+      def decorate(object_or_list)
+        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) }
+        else
+          decorator.new(object_or_list, *decorator_args)
+        end
+      end
+
+      def decoratable_block_method(method_name, *args)
+        relation.public_send(method_name, *args) 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)
+      end
+    end
+
+    GraphQL::Relay::BaseConnection.register_connection_implementation(
+      RelationDecorator, GraphQL::Relay::RelationConnection
+    )
+  end
+end

data/lib/graphql_rails/decorator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # adds `.decorate` class method to any class. Handy when using with paginated responses
+  #
+  # usage:
+  # class FriendDecorator < SimpleDecorator
+  #   include GraphqlRails::Decorator
+  #
+  #   graphql.attribute :full_name
+  # end
+  #
+  # class User
+  #   has_many :friends
+  #   graphql.attribute :decorated_friends, paginated: true, type: 'FriendDecorator!'
+  #
+  #   def decorated_friends
+  #     FriendDecorator.decorate(friends)
+  #   end
+  # end
+  module Decorator
+    require 'active_support/concern'
+    require 'graphql_rails/decorator/relation_decorator'
+
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def decorate(object, *args)
+        if Decorator::RelationDecorator.decorates?(object)
+          Decorator::RelationDecorator.new(relation: object, decorator: self, decorator_args: args)
+        elsif object.nil?
+          nil
+        elsif object.is_a?(Array)
+          object.map { |item| new(item, *args) }
+        else
+          new(object, *args)
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/integrations/lograge.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Integrations
+    # lograge integration
+    #
+    # usage:
+    # add `GraphqlRails::Integrations::Lograge.enable` in your initializers
+    module Lograge
+      require 'lograge'
+
+      # lograge subscriber for graphql_rails controller events
+      class GraphqlActionControllerSubscriber < ::Lograge::LogSubscribers::Base
+        def process_action(event)
+          process_main_event(event)
+        end
+
+        private
+
+        def initial_data(payload)
+          {
+            controller: payload[:controller],
+            action: payload[:action]
+          }
+        end
+      end
+
+      def self.enable
+        return unless active?
+
+        GraphqlActionControllerSubscriber.attach_to :graphql_action_controller
+      end
+
+      def self.active?
+        !defined?(Rails) || Rails.configuration&.lograge&.enabled
+      end
+    end
+  end
+end

data/lib/graphql_rails/integrations/sentry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Integrations
+    # sentry integration
+    module Sentry
+      require 'active_support/concern'
+
+      # controller extension which logs errors to sentry
+      module SentryLogger
+        extend ActiveSupport::Concern
+
+        included do
+          around_action :log_to_sentry
+
+          protected
+
+          def log_to_sentry
+            Raven.context.transaction.pop
+            Raven.context.transaction.push "#{self.class}##{action_name}"
+            yield
+          rescue Exception => error # rubocop:disable Lint/RescueException
+            Raven.capture_exception(error) unless error.is_a?(GraphQL::ExecutionError)
+            raise error
+          end
+        end
+      end
+
+      def self.enable
+        GraphqlRails::Controller.include(SentryLogger)
+      end
+    end
+  end
+end

data/lib/graphql_rails/integrations.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # allows to enable various integrations
+  module Integrations
+    def self.enable(*integrations)
+      @enabled_integrations ||= []
+
+      to_be_enabled_integrations = integrations.map(&:to_s) - @enabled_integrations
+
+      to_be_enabled_integrations.each do |integration|
+        require_relative "./integrations/#{integration}"
+        Integrations.const_get(integration.classify).enable
+      end
+
+      @enabled_integrations += to_be_enabled_integrations
+    end
+  end
+end

data/lib/graphql_rails/model/configuration.rb

@@ -17,13 +17,26 @@ module GraphqlRails
         @model_class = model_class
       end
 
-      def attribute(attribute_name, type: nil, **attribute_options)
-        attributes[attribute_name.to_s] = \
-          Attributes::Attribute.new(
-            attribute_name,
-            type,
-            attribute_options
-          )
+      def initialize_copy(other)
+        super
+        @connection_type = nil
+        @graphql_type = nil
+        @input = other.instance_variable_get(:@input)&.transform_values(&:dup)
+        @attributes = other.instance_variable_get(:@attributes)&.transform_values(&:dup)
+      end
+
+      def attribute(attribute_name, **attribute_options)
+        key = attribute_name.to_s
+
+        attributes[key] ||= Attributes::Attribute.new(attribute_name)
+
+        attributes[key].tap do |attribute|
+          attribute_options.each do |method_name, args|
+            attribute.public_send(method_name, args)
+          end
+
+          yield(attribute) if block_given?
+        end
       end
 
       def input(input_name = nil)

data/lib/graphql_rails/model/input.rb

@@ -35,7 +35,7 @@ module GraphqlRails
 
       def default_name
         @default_name ||= begin
-          suffix = input_name_suffix ? input_name_suffix.to_s.tableize : ''
+          suffix = input_name_suffix ? input_name_suffix.to_s.camelize : ''
           "#{model_class.name.split('::').last}#{suffix}Input"
         end
       end

data/lib/graphql_rails/model.rb

@@ -23,6 +23,13 @@ module GraphqlRails
 
     # static methods for GraphqlRails::Model
     module ClassMethods
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@graphql, graphql.dup)
+        subclass.graphql.instance_variable_set(:@model_class, self)
+        subclass.graphql.instance_variable_set(:@graphql_type, nil)
+      end
+
       def graphql
         @graphql ||= Model::Configuration.new(self)
         yield(@graphql) if block_given?

data/lib/graphql_rails/version.rb

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