graphql_rails 0.7.0 → 1.2.1

data/lib/graphql_rails/attributes/attribute.rb

@@ -2,29 +2,93 @@
 
 require 'graphql'
 require 'graphql_rails/attributes/attributable'
+require 'graphql_rails/input_configurable'
 
 module GraphqlRails
   module Attributes
     # contains info about single graphql attribute
     class Attribute
       include Attributable
+      include InputConfigurable
 
-      attr_reader :property, :description
+      attr_reader :attributes
 
-      def initialize(name, type = nil, description: nil, property: name)
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(name, type = nil, description: nil, property: name, required: nil, options: {})
         @initial_type = type
         @initial_name = name
+        @options = options
         @description = description
         @property = property.to_s
+        @required = required
+        @attributes ||= {}
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def type(new_type = nil)
+        return @initial_type if new_type.nil?
+
+        @initial_type = new_type
+        self
+      end
+
+      def description(new_description = nil)
+        return @description if new_description.nil?
+
+        @description = new_description
+        self
+      end
+
+      def property(new_property = nil)
+        return @property if new_property.nil?
+
+        @property = new_property.to_s
+        self
+      end
+
+      def options(new_options = {})
+        return @options if new_options.blank?
+
+        @options = new_options
+        self
       end
 
       def field_args
-        [field_name, graphql_field_type, { property: property.to_sym, description: description }]
+        [
+          field_name,
+          type_parser.type_arg,
+          *description
+        ]
+      end
+
+      def field_options
+        {
+          method: property.to_sym,
+          null: optional?,
+          camelize: camelize?
+        }
+      end
+
+      def argument_args
+        [
+          field_name,
+          type_parser.type_arg,
+          {
+            description: description,
+            required: required?
+          }
+        ]
       end
 
       protected
 
       attr_reader :initial_type, :initial_name
+
+      private
+
+      def camelize?
+        options[:input_format] != :original && options[:attribute_name_format] != :original
+      end
     end
   end
 end

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

@@ -4,43 +4,61 @@ module GraphqlRails
   module Attributes
     # contains info about single graphql input attribute
     class InputAttribute
+      require_relative './input_type_parser'
+      require_relative './attribute_name_parser'
       include Attributable
 
       attr_reader :description
 
-      def initialize(name, type = nil, description: nil, options: {})
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(name, type: nil, description: nil, subtype: nil, required: nil, options: {})
         @initial_name = name
         @initial_type = type
         @description = description
         @options = options
+        @subtype = subtype
+        @required = required
       end
+      # rubocop:enable Metrics/ParameterLists
 
-      def function_argument_args
-        [field_name, graphql_input_type, { description: description }]
+      def input_argument_args
+        type = raw_input_type || input_type_parser.input_type_arg
+
+        [field_name, type]
       end
 
-      def input_argument_args
-        type = raw_input_type || model_input_type || nullable_type
-        [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 || model_input_type || graphql_field_type
+      def paginated?
+        false
       end
 
       private
 
-      attr_reader :initial_name, :initial_type, :options
+      attr_reader :initial_name, :initial_type, :options, :subtype
 
-      def raw_input_type
-        return initial_type if initial_type.is_a?(GraphQL::InputObjectType)
-        return initial_type.graphql_input_type if initial_type.is_a?(Model::Input)
+      def attribute_name_parser
+        @attribute_name_parser ||= AttributeNameParser.new(
+          initial_name, options: attribute_naming_options
+        )
       end
 
-      def model_input_type
-        return unless graphql_model
+      def attribute_naming_options
+        options.slice(:input_format)
+      end
+
+      def input_type_parser
+        @input_type_parser ||= begin
+          initial_parseable_type = initial_type || attribute_name_parser.graphql_type
+          InputTypeParser.new(initial_parseable_type, subtype: subtype)
+        end
+      end
 
-        graphql_model.graphql.input.graphql_input_type
+      def raw_input_type
+        return initial_type if initial_type.is_a?(GraphQL::InputObjectType)
+        return initial_type.graphql_input_type if initial_type.is_a?(Model::Input)
       end
     end
   end

data/lib/graphql_rails/attributes/input_type_parser.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+module GraphqlRails
+  module Attributes
+    # converts string value in to GraphQL type
+    class InputTypeParser
+      require_relative './type_parseable'
+
+      include TypeParseable
+
+      def initialize(unparsed_type, subtype:)
+        @unparsed_type = unparsed_type
+        @subtype = subtype
+      end
+
+      def graphql_type
+        return nil if unparsed_type.nil?
+
+        partly_parsed_type || parsed_type
+      end
+
+      def input_type_arg
+        if list?
+          list_type_arg
+        else
+          unwrapped_type
+        end
+      end
+
+      private
+
+      attr_reader :unparsed_type, :subtype
+
+      def unwrapped_type
+        raw_unwrapped_type || unwrapped_scalar_type || unwrapped_model_input_type || raise_not_supported_type_error
+      end
+
+      def raw_unwrapped_type
+        return nil unless raw_graphql_type?
+
+        unwrap_type(unparsed_type)
+      end
+
+      def list_type_arg
+        if required_inner_type?
+          [unwrapped_type]
+        else
+          [unwrapped_type, null: true]
+        end
+      end
+
+      def unwrapped_model_input_type
+        type_class = graphql_model
+        return unless type_class
+
+        type_class.graphql.input(subtype).graphql_input_type
+      end
+    end
+  end
+end

data/lib/graphql_rails/attributes/type_name_info.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Attributes
+    # checks various attributes based on graphql type name
+    class TypeNameInfo
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def nullable_inner_name
+        inner_name[/[^!]+/]
+      end
+
+      def inner_name
+        name[/[^!\[\]]+!?/]
+      end
+
+      def required_inner_type?
+        inner_name.include?('!')
+      end
+
+      def list?
+        name.include?(']')
+      end
+
+      def required?
+        name.end_with?('!')
+      end
+
+      def required_list?
+        required? && list?
+      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,35 +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
-      class UnknownTypeError < ArgumentError; end
+      require_relative './type_name_info'
+      require_relative './type_parseable'
 
-      TYPE_MAPPING = {
-        'id' => GraphQL::ID_TYPE,
+      class NotSupportedFeature < GraphqlRails::Error; end
 
-        'int' => GraphQL::INT_TYPE,
-        'integer' => GraphQL::INT_TYPE,
+      include TypeParseable
 
-        'string' => GraphQL::STRING_TYPE,
-        'str' => GraphQL::STRING_TYPE,
-        'text' => GraphQL::STRING_TYPE,
-        'time' => GraphQL::STRING_TYPE,
-        'date' => GraphQL::STRING_TYPE,
+      delegate :list?, :required_inner_type?, :required_list?, :required?, to: :type_name_info
 
-        'bool' => GraphQL::BOOLEAN_TYPE,
-        'boolean' => GraphQL::BOOLEAN_TYPE,
-
-        'float' => GraphQL::FLOAT_TYPE,
-        'double' => GraphQL::FLOAT_TYPE,
-        'decimal' => GraphQL::FLOAT_TYPE
-      }.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
@@ -42,11 +36,40 @@ module GraphqlRails
         end
       end
 
-      def graphql_model
-        type_class = inner_type_name.safe_constantize
-        return unless type_class.respond_to?(:graphql)
+      def type_arg
+        if paginated?
+          paginated_type_arg
+        elsif list?
+          list_type_arg
+        else
+          raw_unwrapped_type
+        end
+      end
+
+      protected
+
+      def paginated_type_arg
+        return graphql_model.graphql.connection_type if graphql_model
+
+        raise NotSupportedFeature, 'pagination is only supported for models which include GraphqlRails::Model'
+      end
+
+      def list_type_arg
+        if required_inner_type?
+          [raw_unwrapped_type]
+        else
+          [raw_unwrapped_type, null: true]
+        end
+      end
+
+      def parsed_type
+        return unparsed_type if raw_graphql_type?
+
+        type_by_name
+      end
 
-        type_class
+      def raw_unwrapped_type
+        @raw_unwrapped_type ||= unwrap_type(parsed_type)
       end
 
       private
@@ -56,7 +79,7 @@ module GraphqlRails
       def parsed_list_type
         list_type = parsed_inner_type.to_list_type
 
-        if required_list_type?
+        if required_list?
           list_type.to_non_null_type
         else
           list_type
@@ -71,40 +94,23 @@ module GraphqlRails
         end
       end
 
-      def required_inner_type?
-        !!unparsed_type[/\w!/] # rubocop:disable Style/DoubleNegation
-      end
-
-      def list?
-        unparsed_type.to_s.include?(']')
-      end
-
-      def required_list_type?
-        unparsed_type.to_s.include?(']!')
-      end
-
-      def raw_graphql_type?
-        unparsed_type.is_a?(GraphQL::BaseType) ||
-          unparsed_type.is_a?(GraphQL::ObjectType) ||
-          unparsed_type.is_a?(GraphQL::InputObjectType) ||
-          (defined?(GraphQL::Schema::Member) && unparsed_type.is_a?(Class) && unparsed_type < GraphQL::Schema::Member)
-      end
-
-      def inner_type_name
-        unparsed_type.to_s.tr('[]!', '')
+      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 type_by_name
-        TYPE_MAPPING.fetch(inner_type_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 dynamicly_defined_type
+      def unwrapped_model_type
         type_class = graphql_model
         return unless type_class