graphql_rails 0.8.0 → 1.2.2

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

@@ -3,14 +3,20 @@
 require 'active_support/core_ext/string/inflections'
 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: {},
@@ -18,6 +24,7 @@ module GraphqlRails
         }
 
         @action_by_name = {}
+        @action_default = nil
       end
 
       def initialize_copy(other)
@@ -31,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
@@ -43,15 +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
-        yield(@action_by_name[method_name.to_s]) if block_given?
-        @action_by_name[method_name.to_s]
+        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

@@ -6,13 +6,13 @@ 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 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
@@ -51,8 +51,7 @@ module GraphqlRails
             params
           else
             filter_options = Rails.configuration.filter_parameters
-            parametter_filter = ActionDispatch::Http::ParameterFilter.new(filter_options)
-            parametter_filter.filter(params)
+            parameter_filter_class.new(filter_options).filter(params)
           end
       end
 
@@ -61,6 +60,12 @@ module GraphqlRails
 
         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/relation_decorator.rb

@@ -37,7 +37,7 @@ module GraphqlRails
       end
 
       def to_a
-        @to_a ||= relation.to_a.map { |it| decorator.new(it) }
+        @to_a ||= relation.to_a.map { |it| decorator.new(it, *decorator_args) }
       end
 
       private
@@ -71,9 +71,5 @@ module GraphqlRails
         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/errors/custom_execution_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # base class which is returned in case something bad happens. Contains all error rendering tructure
+  class CustomExecutionError < ExecutionError
+    attr_reader :extra_graphql_data
+
+    def self.accepts?(error)
+      error.is_a?(Hash) &&
+        (error.key?(:message) || error.key?('message'))
+    end
+
+    def initialize(message, extra_graphql_data = {})
+      super(message)
+      @extra_graphql_data = extra_graphql_data.stringify_keys
+    end
+
+    def to_h
+      super
+    end
+  end
+end

data/lib/graphql_rails/errors/execution_error.rb

@@ -6,15 +6,14 @@ module GraphqlRails
   # base class which is returned in case something bad happens. Contains all error rendering tructure
   class ExecutionError < GraphQL::ExecutionError
     def to_h
-      super.except('locations').merge('type' => type, 'http_status_code' => http_status_code)
+      super.merge(extra_graphql_data)
     end
 
-    def type
-      'system_error'
-    end
-
-    def http_status_code
-      500
+    def extra_graphql_data
+      {}.tap do |data|
+        data['type'] = type if respond_to?(:type) && type
+        data['code'] = type if respond_to?(:code) && code
+      end
     end
   end
 end

data/lib/graphql_rails/errors/system_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # base class which is returned in case something bad happens. Contains all error rendering tructure
+  class SystemError < ExecutionError
+    def to_h
+      super.except('locations')
+    end
+
+    def type
+      'system_error'
+    end
+  end
+end

data/lib/graphql_rails/errors/validation_error.rb

@@ -6,7 +6,7 @@ module GraphqlRails
     attr_reader :short_message, :field
 
     def initialize(short_message, field)
-      super([field.presence, short_message].compact.join(' '))
+      super([field.presence&.to_s&.humanize, short_message].compact.join(' '))
       @short_message = short_message
       @field = field
     end
@@ -15,10 +15,6 @@ module GraphqlRails
       'validation_error'
     end
 
-    def http_status_code
-      422
-    end
-
     def to_h
       super.merge('field' => field, 'short_message' => short_message)
     end

data/lib/graphql_rails/input_configurable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # contains configuration options related with inputs
+  module InputConfigurable
+    def permit(*no_type_attributes, **typed_attributes)
+      no_type_attributes.each { |attribute| permit_input(attribute) }
+      typed_attributes.each { |attribute, type| permit_input(attribute, type: type) }
+      self
+    end
+
+    def permit_input(name, **input_options)
+      field_name = name.to_s.remove(/!\Z/)
+
+      attributes[field_name] = build_input_attribute(name.to_s, **input_options)
+      self
+    end
+
+    def paginated(pagination_options = {})
+      pagination_options = {} if pagination_options == true
+      pagination_options = nil if pagination_options == false
+
+      @pagination_options = pagination_options
+      permit(:before, :after, first: :int, last: :int)
+    end
+
+    def paginated?
+      !pagination_options.nil?
+    end
+
+    def pagination_options
+      @pagination_options
+    end
+
+    def input_attribute_options
+      @input_attribute_options || {}
+    end
+
+    def build_input_attribute(name, options: {}, **other_options)
+      Attributes::InputAttribute.new(
+        name.to_s,
+        options: input_attribute_options.merge(options),
+        **other_options
+      )
+    end
+  end
+end