graphql_rails 0.8.0 → 1.0.0

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,25 @@ 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
-      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_args
+        [type_parser.type_arg, 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 +54,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

@@ -2,50 +2,54 @@
 
 require 'active_support/core_ext/string/filters'
 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_input(attribute) }
-        typed_attributes.each { |attribute, type| permit_input(attribute, type: type) }
-        self
-      end
+      def options(action_options = nil)
+        @input_attribute_options ||= {}
+        return @input_attribute_options if action_options.nil?
 
-      def permit_input(name, type: nil, options: {}, **input_options)
-        field_name = name.to_s.remove(/!\Z/)
+        @input_attribute_options[:input_format] = action_options[:input_format] if action_options[:input_format]
 
-        attributes[field_name] = Attributes::InputAttribute.new(
-          name.to_s, type,
-          options: action_options.merge(options),
-          **input_options
-        )
         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)
@@ -57,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
@@ -94,8 +114,24 @@ module GraphqlRails
         end
       end
 
-      def type_parser
-        Attributes::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 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)
+          description(action.description)
+          controller(action.controller)
+          controller_action_name(action.name)
+
+          action.arguments.each do |attribute|
+            argument(*attribute.input_argument_args)
+          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

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