graphql_rails 0.8.0 → 1.0.0

data/lib/graphql_rails/attributes/input_type_parser.rb

@@ -5,9 +5,13 @@ require 'graphql'
 module GraphqlRails
   module Attributes
     # converts string value in to GraphQL type
-    class InputTypeParser < TypeParser
+    class InputTypeParser
+      require_relative './type_parseable'
+
+      include TypeParseable
+
       def initialize(unparsed_type, subtype:)
-        super(unparsed_type)
+        @unparsed_type = unparsed_type
         @subtype = subtype
       end
 
@@ -17,68 +21,42 @@ module GraphqlRails
         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
+      def input_type_arg
         if list?
-          parsed_list_type
+          list_type_arg
         else
-          parsed_inner_type
+          unwrapped_type
         end
       end
 
-      def raw_graphql_type?
-        unparsed_type.is_a?(GraphQL::InputObjectType) || super
-      end
+      private
 
-      def dynamicly_defined_type
-        type_class = graphql_model
-        return unless type_class
+      attr_reader :unparsed_type, :subtype
 
-        type_class.graphql.input(*subtype).graphql_input_type
+      def unwrapped_type
+        raw_unwrapped_type || unwrapped_scalar_type || unwrapped_model_input_type || raise_not_supported_type_error
       end
 
-      def parsed_list_type
-        list_type = parsed_inner_type.to_list_type
+      def raw_unwrapped_type
+        return nil unless raw_graphql_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
+        unwrap_type(unparsed_type)
       end
 
-      def parsed_inner_type
+      def list_type_arg
         if required_inner_type?
-          type_by_name.to_non_null_type
+          [unwrapped_type]
         else
-          type_by_name
+          [unwrapped_type, null: true]
         end
       end
 
-      private
+      def unwrapped_model_input_type
+        type_class = graphql_model
+        return unless type_class
 
-      attr_reader :subtype
+        type_class.graphql.input(subtype).graphql_input_type
+      end
     end
   end
 end

data/lib/graphql_rails/attributes/type_parseable.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Attributes
+    # Contains shared parsing logic.
+    # Expects that including class has:
+    #  * method "unparsed_type" which might be Instance of String, Symbol, GraphQL type or so
+    module TypeParseable
+      require_relative './type_name_info'
+
+      class UnknownTypeError < ArgumentError; end
+
+      TYPE_MAPPING = {
+        'id' => GraphQL::ID_TYPE,
+
+        'int' => GraphQL::INT_TYPE,
+        'integer' => GraphQL::INT_TYPE,
+
+        'string' => GraphQL::STRING_TYPE,
+        'str' => GraphQL::STRING_TYPE,
+        'text' => GraphQL::STRING_TYPE,
+        'time' => GraphQL::STRING_TYPE,
+        'date' => GraphQL::STRING_TYPE,
+
+        'bool' => GraphQL::BOOLEAN_TYPE,
+        'boolean' => GraphQL::BOOLEAN_TYPE,
+
+        'float' => GraphQL::FLOAT_TYPE,
+        'double' => GraphQL::FLOAT_TYPE,
+        'decimal' => GraphQL::FLOAT_TYPE
+      }.freeze
+
+      WRAPPER_TYPES = [
+        GraphQL::Schema::List,
+        GraphQL::Schema::NonNull,
+        GraphQL::NonNullType,
+        GraphQL::ListType
+      ].freeze
+
+      GRAPHQL_BASE_TYPES = [
+        GraphQL::BaseType,
+        GraphQL::ObjectType,
+        GraphQL::InputObjectType
+      ].freeze
+
+      RAW_GRAPHQL_TYPES = (WRAPPER_TYPES + GRAPHQL_BASE_TYPES).freeze
+
+      def unwrapped_scalar_type
+        TYPE_MAPPING[nullable_inner_name.downcase.downcase]
+      end
+
+      def raw_graphql_type?
+        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 graphql_model
+        type_class = \
+          if unparsed_type.is_a?(Class) && unparsed_type < GraphqlRails::Model
+            unparsed_type
+          else
+            nullable_inner_name.safe_constantize
+          end
+
+        return if type_class.nil?
+        return unless type_class < GraphqlRails::Model
+
+        type_class
+      end
+
+      protected
+
+      def unwrap_type(type)
+        unwrappable = type
+        unwrappable = unwrappable.of_type while wrapped_type?(unwrappable)
+        unwrappable
+      end
+
+      def wrapped_type?(type)
+        WRAPPER_TYPES.any? { |wrapper| type.is_a?(wrapper) }
+      end
+
+      def nullable_inner_name
+        type_name_info.nullable_inner_name
+      end
+
+      def list?
+        type_name_info.list?
+      end
+
+      def required_inner_type?
+        type_name_info.required_inner_type?
+      end
+
+      def required_list?
+        type_name_info.required_list?
+      end
+
+      def required?
+        type_name_info.required?
+      end
+
+      def type_name_info
+        @type_name_info ||= begin
+          type_name = \
+            if unparsed_type.respond_to?(:to_type_signature)
+              unparsed_type.to_type_signature
+            else
+              unparsed_type.to_s
+            end
+          TypeNameInfo.new(type_name)
+        end
+      end
+
+      def raise_not_supported_type_error
+        error_message = \
+          "Type #{unparsed_type.inspect} is not supported. " \
+          "Supported scalar types are: #{TypeParseable::TYPE_MAPPING.keys}. " \
+          'All the classes that includes `GraphqlRails::Model` are also supported as types.'
+
+        raise UnknownTypeError, error_message
+      end
+    end
+  end
+end

data/lib/graphql_rails/attributes/type_parser.rb

@@ -1,44 +1,29 @@
 # frozen_string_literal: true
 
 require 'graphql'
+require 'graphql_rails/model/build_connection_type'
+require 'graphql_rails/errors/error'
 
 module GraphqlRails
   module Attributes
     # converts string value in to GraphQL type
     class TypeParser
       require_relative './type_name_info'
+      require_relative './type_parseable'
 
-      class UnknownTypeError < ArgumentError; end
+      class NotSupportedFeature < GraphqlRails::Error; end
 
-      TYPE_MAPPING = {
-        'id' => GraphQL::ID_TYPE,
+      include TypeParseable
 
-        'int' => GraphQL::INT_TYPE,
-        'integer' => GraphQL::INT_TYPE,
+      delegate :list?, :required_inner_type?, :required_list?, :required?, to: :type_name_info
 
-        'string' => GraphQL::STRING_TYPE,
-        'str' => GraphQL::STRING_TYPE,
-        'text' => GraphQL::STRING_TYPE,
-        'time' => GraphQL::STRING_TYPE,
-        'date' => GraphQL::STRING_TYPE,
-
-        'bool' => GraphQL::BOOLEAN_TYPE,
-        'boolean' => GraphQL::BOOLEAN_TYPE,
-
-        'float' => GraphQL::FLOAT_TYPE,
-        'double' => GraphQL::FLOAT_TYPE,
-        'decimal' => GraphQL::FLOAT_TYPE
-      }.freeze
-
-      RAW_GRAPHQL_TYPES = [
-        GraphQL::Schema::List,
-        GraphQL::BaseType,
-        GraphQL::ObjectType,
-        GraphQL::InputObjectType
-      ].freeze
-
-      def initialize(unparsed_type)
+      def initialize(unparsed_type, paginated: false)
         @unparsed_type = unparsed_type
+        @paginated = paginated
+      end
+
+      def paginated?
+        @paginated
       end
 
       def graphql_type
@@ -51,25 +36,43 @@ module GraphqlRails
         end
       end
 
-      def graphql_model
-        type_class = nullable_inner_name.safe_constantize
-        return unless type_class.respond_to?(:graphql)
-
-        type_class
+      def type_arg
+        if paginated?
+          paginated_type_arg
+        elsif list?
+          list_type_arg
+        else
+          raw_unwrapped_type
+        end
       end
 
       protected
 
-      def dynamicly_defined_type
-        type_class = graphql_model
-        return unless type_class
+      def paginated_type_arg
+        return graphql_model.graphql.connection_type if graphql_model
 
-        type_class.graphql.graphql_type
+        raise NotSupportedFeature, 'pagination is only supported for models which include GraphqlRails::Model'
       end
 
-      private
+      def list_type_arg
+        if required_inner_type?
+          [raw_unwrapped_type]
+        else
+          [raw_unwrapped_type, null: true]
+        end
+      end
 
-      delegate :list?, :required_inner_type?, :required_list?, :nullable_inner_name, to: :type_name_info
+      def parsed_type
+        return unparsed_type if raw_graphql_type?
+
+        type_by_name
+      end
+
+      def raw_unwrapped_type
+        @raw_unwrapped_type ||= unwrap_type(parsed_type)
+      end
+
+      private
 
       attr_reader :unparsed_type
 
@@ -91,26 +94,27 @@ module GraphqlRails
         end
       end
 
-      def raw_graphql_type?
-        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 type_name_info
-        @type_name_info ||= TypeNameInfo.new(unparsed_type.to_s)
+        @type_name_info ||= begin
+          type_name = \
+            if unparsed_type.respond_to?(:to_type_signature)
+              unparsed_type.to_type_signature
+            else
+              unparsed_type.to_s
+            end
+          TypeNameInfo.new(type_name)
+        end
       end
 
       def type_by_name
-        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}." \
-            ' All the classes that includes `GraphqlRails::Model` are also supported as types.'
-          )
-        end
+        unwrapped_scalar_type || unwrapped_model_type || raise_not_supported_type_error
+      end
+
+      def unwrapped_model_type
+        type_class = graphql_model
+        return unless type_class
+
+        type_class.graphql.graphql_type
       end
     end
   end

data/lib/graphql_rails/concerns/service.rb

@@ -0,0 +1,15 @@
+# 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, &block)
+        new(*args).call(&block)
+      end
+    end
+  end
+end

data/lib/graphql_rails/controller.rb

@@ -4,17 +4,18 @@ 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)
+      def inherited(subclass)
         super
-        sublass.instance_variable_set(:@controller_configuration, controller_configuration.dup)
+        new_config = controller_configuration.dup_with(controller: subclass)
+        subclass.instance_variable_set(:@controller_configuration, new_config)
       end
 
       def before_action(*args, &block)
@@ -33,8 +34,16 @@ module GraphqlRails
         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
 
@@ -48,7 +57,7 @@ module GraphqlRails
       @action_name = method_name
       with_controller_action_logging do
         call_with_rendering
-        format_controller_results
+        graphql_request.object_to_return
       end
     ensure
       @action_name = nil
@@ -78,7 +87,11 @@ module GraphqlRails
 
       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)
@@ -86,7 +99,7 @@ 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)
@@ -98,14 +111,5 @@ module GraphqlRails
         &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