graphql_rails 0.8.0 → 1.2.2

data/lib/graphql_rails/attributes/attribute_name_parser.rb

@@ -27,11 +27,11 @@ module GraphqlRails
         @graphql_type ||= \
           case name
           when 'id', /_id\Z/
-            GraphQL::ID_TYPE
+            GraphQL::Types::ID
           when /\?\Z/
-            GraphQL::BOOLEAN_TYPE
+            GraphQL::Types::Boolean
           else
-            GraphQL::STRING_TYPE
+            GraphQL::Types::String
           end
       end
 
@@ -44,7 +44,7 @@ module GraphqlRails
       attr_reader :options
 
       def original_format?
-        options[:input_format] == :original
+        options[:input_format] == :original || options[:attribute_name_format] == :original
       end
 
       def preprocesed_name

data/lib/graphql_rails/attributes/input_attribute.rb

@@ -5,12 +5,13 @@ module GraphqlRails
     # contains info about single graphql input attribute
     class InputAttribute
       require_relative './input_type_parser'
+      require_relative './attribute_name_parser'
       include Attributable
 
       attr_reader :description
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(name, type = nil, description: nil, subtype: nil, required: nil, options: {})
+      def initialize(name, type: nil, description: nil, subtype: nil, required: nil, options: {})
         @initial_name = name
         @initial_type = type
         @description = description
@@ -20,26 +21,39 @@ module GraphqlRails
       end
       # rubocop:enable Metrics/ParameterLists
 
-      def function_argument_args
-        [field_name, graphql_input_type, { description: description }]
-      end
-
       def input_argument_args
-        type = raw_input_type || input_type_parser.nullable_type || nullable_type
+        type = raw_input_type || input_type_parser.input_type_arg
+
+        [field_name, type]
+      end
 
-        [field_name, type, { required: required?, description: description }]
+      def input_argument_options
+        { required: required?, description: description, camelize: false }
       end
 
-      def graphql_input_type
-        raw_input_type || input_type_parser.graphql_type || graphql_field_type
+      def paginated?
+        false
       end
 
       private
 
       attr_reader :initial_name, :initial_type, :options, :subtype
 
+      def attribute_name_parser
+        @attribute_name_parser ||= AttributeNameParser.new(
+          initial_name, options: attribute_naming_options
+        )
+      end
+
+      def attribute_naming_options
+        options.slice(:input_format)
+      end
+
       def input_type_parser
-        @input_type_parser ||= InputTypeParser.new(initial_type, subtype: subtype)
+        @input_type_parser ||= begin
+          initial_parseable_type = initial_type || attribute_name_parser.graphql_type
+          InputTypeParser.new(initial_parseable_type, subtype: subtype)
+        end
       end
 
       def raw_input_type

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,132 @@
+# 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::Types::ID,
+
+        'int' => GraphQL::Types::Int,
+        'integer' => GraphQL::Types::Int,
+
+        'string' => GraphQL::Types::String,
+        'str' => GraphQL::Types::String,
+        'text' => GraphQL::Types::String,
+        'time' => GraphQL::Types::String,
+        'date' => GraphQL::Types::String,
+
+        'bool' => GraphQL::Types::Boolean,
+        'boolean' => GraphQL::Types::Boolean,
+
+        'float' => GraphQL::Types::Float,
+        'double' => GraphQL::Types::Float,
+        'decimal' => GraphQL::Types::Float
+      }.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 core_scalar_type?
+        unwrapped_scalar_type.in?(TYPE_MAPPING.values)
+      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