graphql_rails 0.6.0 → 1.2.0

data/lib/graphql_rails/controller/build_controller_action_resolver/controller_action_resolver.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/controller/request'
+
+module GraphqlRails
+  class Controller
+    class BuildControllerActionResolver
+      # Resolver which includes controller specific methods.
+      # Used to simplify resolver build for each controller action
+      class ControllerActionResolver < GraphQL::Schema::Resolver
+        def self.controller(controller_class = nil)
+          @controller = controller_class if controller_class
+          @controller
+        end
+
+        def self.controller_action_name(name = nil)
+          @controller_action_name = name if name
+          @controller_action_name
+        end
+
+        def resolve(**inputs)
+          request = Request.new(object, inputs, context)
+          self.class.controller.new(request).call(self.class.controller_action_name)
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/controller/configuration.rb

@@ -1,17 +1,22 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/string/inflections'
-require 'graphql_rails/attribute'
 require 'graphql_rails/controller/action_configuration'
 require 'graphql_rails/controller/action_hook'
+require 'graphql_rails/errors/error'
 
 module GraphqlRails
   class Controller
     # stores all graphql_rails contoller specific config
     class Configuration
+      class InvalidActionConfiguration < GraphqlRails::Error; end
+
+      LIB_REGEXP = %r{/graphql_rails/lib/}
+
       attr_reader :action_by_name
 
-      def initialize
+      def initialize(controller)
+        @controller = controller
         @hooks = {
           before: {},
           after: {},
@@ -19,6 +24,7 @@ module GraphqlRails
         }
 
         @action_by_name = {}
+        @action_default = nil
       end
 
       def initialize_copy(other)
@@ -32,6 +38,12 @@ module GraphqlRails
         end
       end
 
+      def dup_with(controller:)
+        dup.tap do |new_config|
+          new_config.instance_variable_set(:@controller, controller)
+        end
+      end
+
       def action_hooks_for(hook_type, action_name)
         hooks[hook_type].values.select { |hook| hook.applicable_for?(action_name) }
       end
@@ -44,13 +56,53 @@ module GraphqlRails
           ActionHook.new(name: hook_name, **options, &block)
       end
 
+      def action_default
+        @action_default ||= ActionConfiguration.new(name: :default, controller: nil)
+        yield(@action_default) if block_given?
+        @action_default
+      end
+
       def action(method_name)
-        @action_by_name[method_name.to_s] ||= ActionConfiguration.new
+        action_name = method_name.to_s.underscore
+        @action_by_name[action_name] ||= action_default.dup_with(
+          name: action_name,
+          controller: controller,
+          defined_at: dynamic_source_location
+        )
+        yield(@action_by_name[action_name]) if block_given?
+        @action_by_name[action_name]
+      end
+
+      def action_config(method_name)
+        action_name = method_name.to_s.underscore
+        @action_by_name.fetch(action_name) { raise_invalid_config_error(action_name) }
+      end
+
+      def model(model = nil)
+        action_default.model(model)
       end
 
       private
 
-      attr_reader :hooks
+      attr_reader :hooks, :controller
+
+      def dynamic_source_location
+        project_trace = \
+          caller
+          .dup
+          .drop_while { |path| !path.match?(LIB_REGEXP) }
+          .drop_while { |path| path.match?(LIB_REGEXP) }
+
+        project_trace.first
+      end
+
+      def raise_invalid_config_error(action_name)
+        error_message = \
+          "Missing action configuration for #{controller}##{action_name}. " \
+          "Please define it with `action(:#{action_name})`."
+
+        raise InvalidActionConfiguration, error_message
+      end
     end
   end
 end

data/lib/graphql_rails/controller/log_controller_action.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/errors/execution_error'
+
+module GraphqlRails
+  class Controller
+    # logs controller start and end times
+    class LogControllerAction
+      require 'graphql_rails/concerns/service'
+
+      include ::GraphqlRails::Service
+
+      START_PROCESSING_KEY = 'start_processing.graphql_action_controller'
+      PROCESS_ACTION_KEY = 'process_action.graphql_action_controller'
+
+      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
+            parameter_filter_class.new(filter_options).filter(params)
+          end
+      end
+
+      def filter_parameters
+        return [] if !defined?(Rails) || Rails.application.nil?
+
+        Rails.application.config.filter_parameters || []
+      end
+
+      def parameter_filter_class
+        return ActiveSupport::ParameterFilter if Object.const_defined?('ActiveSupport::ParameterFilter')
+
+        ActionDispatch::Http::ParameterFilter
+      end
+    end
+  end
+end

data/lib/graphql_rails/controller/request.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/errors/execution_error'
-
 module GraphqlRails
   class Controller
     # Contains all info related with single request to controller
     class Request
+      require 'graphql_rails/controller/request/format_errors'
+
       attr_accessor :object_to_return
       attr_reader :errors, :context
 
@@ -16,12 +16,9 @@ module GraphqlRails
       end
 
       def errors=(new_errors)
-        @errors = new_errors
+        @errors = FormatErrors.call(not_formatted_errors: new_errors)
 
-        new_errors.each do |error|
-          error_message = error.is_a?(String) ? error : error.message
-          context.add_error(ExecutionError.new(error_message))
-        end
+        @errors.each { |error| context.add_error(error) }
       end
 
       def no_object_to_return?
@@ -29,12 +26,36 @@ module GraphqlRails
       end
 
       def params
-        inputs.to_h
+        deep_transform_values(inputs.to_h) do |val|
+          graphql_object_to_hash(val)
+        end
       end
 
       private
 
       attr_reader :graphql_object, :inputs
+
+      def graphql_object_to_hash(object)
+        if object.is_a?(GraphQL::Dig)
+          object.to_h
+        elsif object.is_a?(Array)
+          object.map { |item| graphql_object_to_hash(item) }
+        else
+          object
+        end
+      end
+
+      def deep_transform_values(hash, &block)
+        return hash unless hash.is_a?(Hash)
+
+        hash.transform_values do |val|
+          if val.is_a?(Hash)
+            deep_transform_values(val, &block)
+          else
+            yield(val)
+          end
+        end
+      end
     end
   end
 end

data/lib/graphql_rails/controller/request/format_errors.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/concerns/service'
+require 'graphql_rails/errors/execution_error'
+require 'graphql_rails/errors/validation_error'
+require 'graphql_rails/errors/custom_execution_error'
+
+module GraphqlRails
+  class Controller
+    class Request
+      # Converts user provided free-form errors in to meaningfull graphql error classes
+      class FormatErrors
+        include Service
+
+        def initialize(not_formatted_errors:)
+          @not_formatted_errors = not_formatted_errors
+        end
+
+        def call
+          if validation_errors?
+            formatted_validation_errors
+          else
+            not_formatted_errors.map { |error| format_error(error) }
+          end
+        end
+
+        private
+
+        attr_reader :not_formatted_errors
+
+        def validation_errors?
+          defined?(ActiveModel) &&
+            defined?(ActiveModel::Errors) &&
+            not_formatted_errors.is_a?(ActiveModel::Errors)
+        end
+
+        def formatted_validation_errors
+          not_formatted_errors.map do |field, message|
+            ValidationError.new(message, field)
+          end
+        end
+
+        def format_error(error)
+          if error.is_a?(String)
+            ExecutionError.new(error)
+          elsif error.is_a?(GraphQL::ExecutionError)
+            error
+          elsif CustomExecutionError.accepts?(error)
+            message = error[:message] || error['message']
+            CustomExecutionError.new(message, error.except(:message, 'message'))
+          elsif error.respond_to?(:message)
+            ExecutionError.new(error.message)
+          end
+        end
+      end
+    end
+  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/decorator/relation_decorator.rb

@@ -0,0 +1,75 @@
+# 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, *decorator_args) }
+      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
+  end
+end