graphql_rails 0.6.0 → 1.2.0

data/lib/graphql_rails/attributes/attribute.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+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 :attributes
+
+      # 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,
+          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/{attribute → attributes}/attribute_name_parser.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module GraphqlRails
-  class Attribute
+  module Attributes
     # Parses attribute name and can generates graphql scalar type,
     # grapqhl name and etc. based on that
     class AttributeNameParser
@@ -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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+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
+
+      # 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 input_argument_args
+        type = raw_input_type || input_type_parser.input_type_arg
+
+        [field_name, type]
+      end
+
+      def input_argument_options
+        { required: required?, description: description, camelize: false }
+      end
+
+      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 ||= begin
+          initial_parseable_type = initial_type || attribute_name_parser.graphql_type
+          InputTypeParser.new(initial_parseable_type, subtype: subtype)
+        end
+      end
+
+      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
+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,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

@@ -0,0 +1,121 @@
+# 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 NotSupportedFeature < GraphqlRails::Error; end
+
+      include TypeParseable
+
+      delegate :list?, :required_inner_type?, :required_list?, :required?, to: :type_name_info
+
+      def initialize(unparsed_type, paginated: false)
+        @unparsed_type = unparsed_type
+        @paginated = paginated
+      end
+
+      def paginated?
+        @paginated
+      end
+
+      def graphql_type
+        return unparsed_type if raw_graphql_type?
+
+        if list?
+          parsed_list_type
+        else
+          parsed_inner_type
+        end
+      end
+
+      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
+
+      def raw_unwrapped_type
+        @raw_unwrapped_type ||= unwrap_type(parsed_type)
+      end
+
+      private
+
+      attr_reader :unparsed_type
+
+      def parsed_list_type
+        list_type = parsed_inner_type.to_list_type
+
+        if required_list?
+          list_type.to_non_null_type
+        else
+          list_type
+        end
+      end
+
+      def parsed_inner_type
+        if required_inner_type?
+          type_by_name.to_non_null_type
+        else
+          type_by_name
+        end
+      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 type_by_name
+        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
+end