graphql_rails 0.5.2 → 1.1.0

data/lib/graphql_rails/concerns/service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # includes all service object related logic
+  module Service
+    require 'active_support/concern'
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def call(*args, **kwargs, &block)
+        if kwargs.present?
+          new(*args, **kwargs).call(&block)
+        else
+          new(*args).call(&block)
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/controller.rb

@@ -1,37 +1,49 @@
 # frozen_string_literal: true
 
 require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
 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'
+require 'graphql_rails/errors/system_error'
 
 module GraphqlRails
   # base class for all graphql_rails controllers
   class Controller
     class << self
-      def inherited(sublass)
-        sublass.instance_variable_set(:@controller_configuration, controller_configuration.dup)
+      def inherited(subclass)
+        super
+        new_config = controller_configuration.dup_with(controller: subclass)
+        subclass.instance_variable_set(:@controller_configuration, new_config)
       end
 
-      def before_action(*args, &block)
-        controller_configuration.add_action_hook(:before, *args, &block)
+      def before_action(*args, **kwargs, &block)
+        controller_configuration.add_action_hook(:before, *args, **kwargs, &block)
       end
 
-      def around_action(*args, &block)
-        controller_configuration.add_action_hook(:around, *args, &block)
+      def around_action(*args, **kwargs, &block)
+        controller_configuration.add_action_hook(:around, *args, **kwargs, &block)
       end
 
-      def after_action(*args, &block)
-        controller_configuration.add_action_hook(:after, *args, &block)
+      def after_action(*args, **kwargs, &block)
+        controller_configuration.add_action_hook(:after, *args, **kwargs, &block)
       end
 
       def action(action_name)
         controller_configuration.action(action_name)
       end
 
+      def action_default
+        controller_configuration.action_default
+      end
+
+      def model(*args)
+        controller_configuration.model(*args)
+      end
+
       def controller_configuration
-        @controller_configuration ||= Controller::Configuration.new
+        @controller_configuration ||= Controller::Configuration.new(self)
       end
     end
 
@@ -43,14 +55,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
+        graphql_request.object_to_return
+      end
     ensure
       @action_name = nil
     end
@@ -68,18 +76,22 @@ module GraphqlRails
     end
 
     def params
-      @params = HashWithIndifferentAccess.new(graphql_request.params)
+      @params ||= graphql_request.params.deep_transform_keys { |key| key.to_s.underscore }.with_indifferent_access
     end
 
     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) }
 
       render response if graphql_request.no_object_to_return?
     rescue StandardError => error
-      render error: error
+      if error.is_a?(GraphQL::ExecutionError)
+        render error: error
+      else
+        render error: SystemError.new(error.message)
+      end
     end
 
     def graphql_errors_from_render_params(rendering_params)
@@ -87,7 +99,17 @@ module GraphqlRails
       return [] if rendering_params.keys.count != 1
 
       errors = rendering_params[:error] || rendering_params[:errors]
-      Array(errors)
+      errors.is_a?(Enumerable) ? 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
   end
 end

data/lib/graphql_rails/controller/action.rb

@@ -9,14 +9,14 @@ module GraphqlRails
   class Controller
     # analyzes route and extracts controller action related data
     class Action
-      class MissingConfigurationError < GraphqlRails::Error; end
+      delegate :relative_path, to: :route
 
       def initialize(route)
         @route = route
       end
 
       def return_type
-        action_config.return_type || default_type
+        action_config.return_type
       end
 
       def arguments
@@ -28,56 +28,29 @@ module GraphqlRails
       end
 
       def name
-        @name ||= action_relative_path.split('#').last
+        @name ||= relative_path.split('#').last
       end
 
       def description
         action_config.description
       end
 
-      private
-
-      attr_reader :route
-
-      def default_inner_return_type
-        raise_missing_return_type_error if model_graphql_type.nil?
-
-        if action_config.can_return_nil?
-          model_graphql_type
-        else
-          model_graphql_type.to_non_null_type
-        end
+      def type_args
+        [type_parser.type_arg]
       end
 
-      def raise_missing_return_type_error
-        error_message = \
-          "Return type for #{route.path.inspect} is not defined. " \
-          "To do so, add `action(:#{name}).returns(YourType)` in #{controller.name} " \
-          "or make sure that you have model named #{namespaced_model_name}"
-
-        raise MissingConfigurationError, error_message
+      def type_options
+        { null: !type_parser.required? }
       end
 
-      def default_type
-        return default_collection_type if route.collection?
-
-        default_inner_return_type
-      end
+      private
 
-      def default_collection_type
-        if action_config.paginated?
-          action_model.graphql.connection_type
-        else
-          default_inner_return_type.to_list_type.to_non_null_type
-        end
-      end
+      attr_reader :route
 
-      def action_relative_path
-        route.relative_path
-      end
+      delegate :type_parser, to: :action_config
 
       def action_config
-        controller.controller_configuration.action(name)
+        controller.controller_configuration.action_config(name)
       end
 
       def namespaced_controller_name
@@ -85,40 +58,12 @@ module GraphqlRails
       end
 
       def controller_name
-        @controller_name ||= action_relative_path.split('#').first
-      end
-
-      def action_model
-        namespace = namespaced_model_name.split('::')
-        model_name = namespace.pop
-        model = nil
-
-        while model.nil? && !namespace.empty?
-          model = namespaced_model(namespace, model_name)
-          namespace.pop
-        end
-
-        model || namespaced_model(namespace, model_name)
-      end
-
-      def namespaced_model(namespace, model_name)
-        [namespace, model_name].join('::').constantize
-      rescue NameError => err
-        raise unless err.message.match?(/uninitialized constant/)
-
-        nil
+        @controller_name ||= relative_path.split('#').first
       end
 
       def namespaced_model_name
         namespaced_controller_name.singularize.classify
       end
-
-      def model_graphql_type
-        return unless action_model
-        return unless action_model < GraphqlRails::Model
-
-        action_model.graphql.graphql_type
-      end
     end
   end
 end

data/lib/graphql_rails/controller/action_configuration.rb

@@ -1,42 +1,55 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/string/filters'
-require 'graphql_rails/attribute/type_parser'
-require 'graphql_rails/attribute'
-require 'graphql_rails/model/input_attribute'
+require 'graphql_rails/attributes'
+require 'graphql_rails/input_configurable'
+require 'graphql_rails/errors/error'
 
 module GraphqlRails
   class Controller
     # stores all graphql_rails contoller specific config
     class ActionConfiguration
-      attr_reader :attributes, :pagination_options
+      class MissingConfigurationError < GraphqlRails::Error; end
+      class DeprecatedDefaultModelError < GraphqlRails::Error; end
+
+      include InputConfigurable
+
+      attr_reader :attributes, :pagination_options, :name, :controller, :defined_at
 
       def initialize_copy(other)
         super
         @attributes = other.instance_variable_get(:@attributes).dup.transform_values(&:dup)
+        @action_options = other.instance_variable_get(:@action_options).dup.transform_values(&:dup)
+        @pagination_options = other.instance_variable_get(:@pagination_options)&.dup&.transform_values(&:dup)
       end
 
-      def initialize
+      def initialize(name:, controller:)
+        @name = name
+        @controller = controller
         @attributes = {}
         @action_options = {}
-        @can_return_nil = false
       end
 
-      def options(input_format:)
-        @action_options[:input_format] = input_format
-        self
+      def dup_with(name:, controller:, defined_at:)
+        dup.tap do |new_action|
+          new_action.instance_variable_set(:@defined_at, defined_at)
+          new_action.instance_variable_set(:@name, name)
+          new_action.instance_variable_set(:@controller, controller)
+        end
       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) }
+      def options(action_options = nil)
+        @input_attribute_options ||= {}
+        return @input_attribute_options if action_options.nil?
+
+        @input_attribute_options[:input_format] = action_options[:input_format] if action_options[:input_format]
+
         self
       end
 
-      def paginated(pagination_options = {})
+      def paginated(*args)
         @return_type = nil
-        @pagination_options = pagination_options
-        permit(:before, :after, first: :int, last: :int)
+        super
       end
 
       def description(new_description = nil)
@@ -48,35 +61,51 @@ module GraphqlRails
         end
       end
 
-      def can_return_nil
-        @can_return_nil = true
-        self
-      end
-
       def returns(custom_return_type)
         @return_type = nil
         @custom_return_type = custom_return_type
         self
       end
 
-      def can_return_nil?
-        @can_return_nil
+      def model(model_name = nil)
+        if model_name
+          @model = model_name
+          self
+        else
+          @model || raise_missing_config_error
+        end
       end
 
-      def paginated?
-        !!pagination_options # rubocop:disable Style/DoubleNegation
+      def returns_single(required: true)
+        model_name = model.to_s
+        model_name = "#{model_name}!" if required
+
+        returns(model_name)
+      end
+
+      def returns_list(required_inner: true, required_list: true)
+        model_name = model.to_s
+        model_name = "#{model_name}!" if required_inner
+        list_name = "[#{model_name}]"
+        list_name = "#{list_name}!" if required_list
+
+        returns(list_name)
       end
 
       def return_type
         @return_type ||= build_return_type
       end
 
+      def type_parser
+        @type_parser ||= Attributes::TypeParser.new(custom_return_type, paginated: paginated?)
+      end
+
       private
 
-      attr_reader :custom_return_type, :action_options
+      attr_reader :custom_return_type
 
       def build_return_type
-        return nil if custom_return_type.nil?
+        return raise_deprecation_error if custom_return_type.nil?
 
         if paginated?
           type_parser.graphql_model ? type_parser.graphql_model.graphql.connection_type : nil
@@ -85,13 +114,24 @@ module GraphqlRails
         end
       end
 
-      def type_parser
-        GraphqlRails::Attribute::TypeParser.new(custom_return_type)
+      def raise_deprecation_error
+        message = \
+          'Default return types are deprecated. ' \
+          "You need to manually set something like `action(:#{name}).returns('#{suggested_model_name}')`"
+
+        full_backtrace = ([defined_at] + caller).compact
+        raise DeprecatedDefaultModelError, message, full_backtrace
       end
 
-      def permit_attribute(name, type = nil)
-        field_name = name.to_s.remove(/!\Z/)
-        attributes[field_name] = Model::InputAttribute.new(name.to_s, type, options: action_options)
+      def suggested_model_name
+        controller&.name.to_s.demodulize.sub(/Controller$/, '').singularize
+      end
+
+      def raise_missing_config_error
+        error_message = \
+          'Default model for controller is not defined. To do so add `model(YourModel)`'
+
+        raise MissingConfigurationError, error_message
       end
     end
   end

data/lib/graphql_rails/controller/build_controller_action_resolver.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/controller/action'
+require 'graphql_rails/concerns/service'
+require 'graphql_rails/controller/action_configuration'
+require 'graphql_rails/controller/build_controller_action_resolver/controller_action_resolver'
+
+module GraphqlRails
+  class Controller
+    # graphql resolver which redirects actions to appropriate controller and controller action
+    class BuildControllerActionResolver
+      include ::GraphqlRails::Service
+
+      def initialize(route:)
+        @route = route
+      end
+
+      def call # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        action = build_action
+
+        Class.new(ControllerActionResolver) do
+          type(*action.type_args, **action.type_options)
+          description(action.description)
+          controller(action.controller)
+          controller_action_name(action.name)
+
+          action.arguments.each do |attribute|
+            argument(*attribute.input_argument_args, **attribute.input_argument_options)
+          end
+
+          def self.inspect
+            "ControllerActionResolver(#{controller.name}##{controller_action_name})"
+          end
+        end
+      end
+
+      private
+
+      attr_reader :route
+
+      def build_action
+        Action.new(route).tap do |action|
+          assert_action(action)
+        end
+      end
+
+      def assert_action(action)
+        action.return_type
+      end
+    end
+  end
+end