graphql_rails 1.2.4 → 2.2.0

data/docs/other_tools/schema_dump.md

@@ -6,24 +6,24 @@ GraphqlRails includes rake task to allow creating schema snapshots easier:
 rake graphql_rails:schema:dump
 ```
 
-## Dumping non default schema
+## Dumping only selected schema groups
 
-You can have multiple graphql schemas. Read more about this in [routes section](components/routes). In order to generate schema for one of groups, provide optional `name` argument:
+You can specify which schema groups you want to dump. In order to do so, provide groups list as rake task argument and separate group names by comma:
 
 ```bash
-rake graphql_rails:schema:dump['your_group_name']
+rake graphql_rails:schema:dump['your_group_name, your_group_name2']
 ```
 
-or using env variable `SCHEMA_GROUP_NAME`:
+You can do this also by using ENV variable `SCHEMA_GROUP_NAME`:
 
 ```bash
-SCHEMA_GROUP_NAME=your_group_name rake graphql_rails:schema:dump
+SCHEMA_GROUP_NAME="your_group_name, your_group_name2" rake graphql_rails:schema:dump
 ```
 
-## Dumping schema in to non default path
+## Dumping schema in to non default folder
 
-By default schema will be dumped to `spec/fixtures/graphql_schema.graphql` path. If you want different schema path, add `GRAPHQL_SCHEMA_DUMP_PATH` env variable, like this:
+By default schema will be dumped to `spec/fixtures` directory. If you want different schema path, add `GRAPHQL_SCHEMA_DUMP_DIR` env variable, like this:
 
 ```bash
-GRAPHQL_SCHEMA_DUMP_PATH='path/to/my/schema.graphql' rake graphql_rails:schema:dump
+GRAPHQL_SCHEMA_DUMP_DIR='path/to/graphql/dumps' rake graphql_rails:schema:dump
 ```

data/lib/graphql_rails/attributes/attributable.rb

@@ -6,14 +6,14 @@ require 'graphql_rails/attributes/attribute_name_parser'
 module GraphqlRails
   module Attributes
     # contains methods which are shared between various attribute-like classes
-    # expects `initial_name` and `initial_type` to be defined
+    # expects `initial_name` and `type` to be defined
     module Attributable
       def field_name
         attribute_name_parser.field_name
       end
 
       def type_name
-        @type_name ||= initial_type.to_s
+        type.to_s
       end
 
       def name
@@ -23,17 +23,9 @@ module GraphqlRails
       def required?
         return @required unless @required.nil?
 
-        attribute_name_parser.required? || !initial_type.to_s[/!$/].nil? || initial_type.is_a?(GraphQL::Schema::NonNull)
-      end
-
-      def required
-        @required = true
-        self
-      end
-
-      def optional
-        @required = false
-        self
+        (type.nil? && attribute_name_parser.required?) ||
+          type.to_s[/!$/].present? ||
+          type.is_a?(GraphQL::Schema::NonNull)
       end
 
       def graphql_model
@@ -52,7 +44,7 @@ module GraphqlRails
 
       def type_parser
         @type_parser ||= begin
-          type_for_parser = initial_type || attribute_name_parser.graphql_type
+          type_for_parser = type || attribute_name_parser.graphql_type
           TypeParser.new(type_for_parser, paginated: paginated?)
         end
       end

data/lib/graphql_rails/attributes/attribute.rb

@@ -2,6 +2,7 @@
 
 require 'graphql'
 require 'graphql_rails/attributes/attributable'
+require 'graphql_rails/attributes/attribute_configurable'
 require 'graphql_rails/input_configurable'
 
 module GraphqlRails
@@ -9,47 +10,21 @@ module GraphqlRails
     # contains info about single graphql attribute
     class Attribute
       include Attributable
+      include AttributeConfigurable
       include InputConfigurable
 
       attr_reader :attributes
 
-      # rubocop:disable Metrics/ParameterLists
-      def initialize(name, type = nil, description: nil, property: name, required: nil, options: {})
-        @initial_type = type
+      def initialize(name)
         @initial_name = name
-        @options = options
-        @description = description
-        @property = property.to_s
-        @required = required
+        @property = name.to_s
         @attributes ||= {}
       end
-      # rubocop:enable Metrics/ParameterLists
 
-      def type(new_type = nil)
-        return @initial_type if new_type.nil?
+      def property(new_value = NOT_SET)
+        return @property if new_value == NOT_SET
 
-        @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
+        @property = new_value.to_s
         self
       end
 
@@ -65,7 +40,8 @@ module GraphqlRails
         {
           method: property.to_sym,
           null: optional?,
-          camelize: camelize?
+          camelize: camelize?,
+          groups: groups
         }
       end
 
@@ -82,7 +58,7 @@ module GraphqlRails
 
       protected
 
-      attr_reader :initial_type, :initial_name
+      attr_reader :initial_name
 
       private
 

data/lib/graphql_rails/attributes/attribute_configurable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/attributes/type_parser'
+require 'graphql_rails/attributes/attribute_name_parser'
+require 'graphql_rails/model/build_enum_type'
+require 'graphql_rails/concerns/chainable_options'
+require 'active_support/concern'
+
+module GraphqlRails
+  module Attributes
+    # Allows to set or get various attribute parameters
+    module AttributeConfigurable
+      extend ActiveSupport::Concern
+
+      included do
+        include GraphqlRails::ChainableOptions
+
+        chainable_option :description
+        chainable_option :options, default: {}
+        chainable_option :type
+      end
+
+      def groups(new_groups = ChainableOptions::NOT_SET)
+        @groups ||= []
+        return @groups if new_groups == ChainableOptions::NOT_SET
+
+        @groups = Array(new_groups).map(&:to_s)
+        self
+      end
+
+      def group(*args)
+        groups(*args)
+      end
+
+      def required(new_value = true) # rubocop:disable Style/OptionalBooleanParameter
+        @required = new_value
+        self
+      end
+
+      def optional(new_value = true) # rubocop:disable Style/OptionalBooleanParameter
+        required(!new_value)
+      end
+    end
+  end
+end

data/lib/graphql_rails/attributes/attribute_name_parser.rb

@@ -5,12 +5,8 @@ module GraphqlRails
     # Parses attribute name and can generates graphql scalar type,
     # grapqhl name and etc. based on that
     class AttributeNameParser
-      attr_reader :name
-
       def initialize(original_name, options: {})
-        name = original_name.to_s
-        @required = !name['!'].nil?
-        @name = name.tr('!', '')
+        @original_name = original_name.to_s
         @options = options
       end
 
@@ -36,12 +32,16 @@ module GraphqlRails
       end
 
       def required?
-        @required
+        original_name['!'].present? || original_name.end_with?('?')
+      end
+
+      def name
+        @name ||= original_name.tr('!', '')
       end
 
       private
 
-      attr_reader :options
+      attr_reader :options, :original_name
 
       def original_format?
         options[:input_format] == :original || options[:attribute_name_format] == :original

data/lib/graphql_rails/attributes/input_attribute.rb

@@ -4,22 +4,19 @@ module GraphqlRails
   module Attributes
     # contains info about single graphql input attribute
     class InputAttribute
+      require 'graphql_rails/model/build_enum_type'
       require_relative './input_type_parser'
       require_relative './attribute_name_parser'
       include Attributable
+      include AttributeConfigurable
 
-      attr_reader :description
+      chainable_option :subtype
+      chainable_option :enum
 
-      # rubocop:disable Metrics/ParameterLists
-      def initialize(name, type: nil, description: nil, subtype: nil, required: nil, options: {})
+      def initialize(name, config:)
+        @config = config
         @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
@@ -28,7 +25,7 @@ module GraphqlRails
       end
 
       def input_argument_options
-        { required: required?, description: description, camelize: false }
+        { required: required?, description: description, camelize: false, groups: groups }
       end
 
       def paginated?
@@ -37,7 +34,7 @@ module GraphqlRails
 
       private
 
-      attr_reader :initial_name, :initial_type, :options, :subtype
+      attr_reader :initial_name, :config
 
       def attribute_name_parser
         @attribute_name_parser ||= AttributeNameParser.new(
@@ -51,14 +48,23 @@ module GraphqlRails
 
       def input_type_parser
         @input_type_parser ||= begin
-          initial_parseable_type = initial_type || attribute_name_parser.graphql_type
+          initial_parseable_type = type || enum_type || attribute_name_parser.graphql_type
           InputTypeParser.new(initial_parseable_type, subtype: subtype)
         end
       end
 
+      def enum_type
+        return if enum.blank?
+
+        ::GraphqlRails::Model::BuildEnumType.call(
+          "#{config.name}_#{initial_name}_enum",
+          allowed_values: enum
+        )
+      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)
+        return type if type.is_a?(GraphQL::InputObjectType)
+        return type.graphql_input_type if type.is_a?(Model::Input)
       end
     end
   end

data/lib/graphql_rails/attributes/input_type_parser.rb

@@ -15,12 +15,6 @@ module GraphqlRails
         @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
@@ -34,7 +28,11 @@ module GraphqlRails
       attr_reader :unparsed_type, :subtype
 
       def unwrapped_type
-        raw_unwrapped_type || unwrapped_scalar_type || unwrapped_model_input_type || raise_not_supported_type_error
+        raw_unwrapped_type ||
+          unwrapped_scalar_type ||
+          unwrapped_model_input_type ||
+          graphql_type_object ||
+          raise_not_supported_type_error
       end
 
       def raw_unwrapped_type

data/lib/graphql_rails/attributes/type_parseable.rb

@@ -16,18 +16,27 @@ module GraphqlRails
         'int' => GraphQL::Types::Int,
         'integer' => GraphQL::Types::Int,
 
+        'big_int' => GraphQL::Types::BigInt,
+        'bigint' => GraphQL::Types::BigInt,
+
+        'float' => GraphQL::Types::Float,
+        'double' => GraphQL::Types::Float,
+        'decimal' => GraphQL::Types::Float,
+
+        'bool' => GraphQL::Types::Boolean,
+        'boolean' => GraphQL::Types::Boolean,
+
         '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,
+        'date' => GraphQL::Types::ISO8601Date,
 
-        'float' => GraphQL::Types::Float,
-        'double' => GraphQL::Types::Float,
-        'decimal' => GraphQL::Types::Float
+        'time' => GraphQL::Types::ISO8601DateTime,
+        'datetime' => GraphQL::Types::ISO8601DateTime,
+        'date_time' => GraphQL::Types::ISO8601DateTime,
+
+        'json' => GraphQL::Types::JSON
       }.freeze
 
       WRAPPER_TYPES = [
@@ -46,7 +55,7 @@ module GraphqlRails
       RAW_GRAPHQL_TYPES = (WRAPPER_TYPES + GRAPHQL_BASE_TYPES).freeze
 
       def unwrapped_scalar_type
-        TYPE_MAPPING[nullable_inner_name.downcase.downcase]
+        TYPE_MAPPING[nullable_inner_name.downcase]
       end
 
       def raw_graphql_type?
@@ -58,25 +67,46 @@ module GraphqlRails
       end
 
       def core_scalar_type?
-        unwrapped_scalar_type.in?(TYPE_MAPPING.values)
+        unwrapped_scalar_type.present?
       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
+        extract_type_class_if { |type| graphql_model?(type) }
+      end
 
-        type_class
+      def graphql_type_object
+        type_object = extract_type_class_if { |type| graphql_type_object?(type) }
+        type_object || graphql_model&.graphql&.graphql_type
       end
 
       protected
 
+      def extract_type_class_if
+        return unparsed_type if yield(unparsed_type)
+
+        type_class = nullable_inner_name.safe_constantize
+        return type_class if yield(type_class)
+
+        nil
+      end
+
+      def graphql_model?(type_class)
+        type_class.is_a?(Class) && type_class < GraphqlRails::Model
+      end
+
+      def graphql_type_object?(type_class)
+        return false unless type_class.is_a?(Class)
+
+        type_class < GraphQL::Schema::Member
+      end
+
+      def applicable_graphql_type?(type)
+        return false unless type.is_a?(Class)
+        return true if type < GraphqlRails::Model
+
+        false
+      end
+
       def unwrap_type(type)
         unwrappable = type
         unwrappable = unwrappable.of_type while wrapped_type?(unwrappable)

data/lib/graphql_rails/attributes/type_parser.rb

@@ -51,7 +51,9 @@ module GraphqlRails
       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'
+        error_message = "Unable to paginate #{unparsed_type.inspect}. " \
+                        'Pagination is only supported for models which include GraphqlRails::Model'
+        raise NotSupportedFeature, error_message
       end
 
       def list_type_arg
@@ -107,14 +109,7 @@ module GraphqlRails
       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
+        unwrapped_scalar_type || graphql_type_object || raise_not_supported_type_error
       end
     end
   end

data/lib/graphql_rails/concerns/chainable_options.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # Allows defining methods chained way
+  module ChainableOptions
+    NOT_SET = Object.new
+
+    # nodoc
+    module ClassMethods
+      def chainable_option(option_name, default: nil)
+        define_method(option_name) do |value = NOT_SET|
+          get_or_set_chainable_option(option_name, value, default: default)
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize_copy(other)
+      super
+      @chainable_option = other.instance_variable_get(:@chainable_option).dup
+    end
+
+    def with(**options)
+      options.each do |method_name, args|
+        send_args = [method_name]
+        send_args << args if method(method_name).parameters.present?
+        public_send(*send_args)
+      end
+      self
+    end
+
+    private
+
+    def fetch_chainable_option(option_name, *default, &block)
+      @chainable_option.fetch(option_name.to_sym, *default, &block)
+    end
+
+    def get_or_set_chainable_option(option_name, value = NOT_SET, default: nil)
+      @chainable_option ||= {}
+      return fetch_chainable_option(option_name, default) if value == NOT_SET
+
+      @chainable_option[option_name.to_sym] = value
+      self
+    end
+  end
+end

data/lib/graphql_rails/controller/build_controller_action_resolver/controller_action_resolver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'graphql_rails/controller/request'
+require 'graphql_rails/types/argument_type'
 
 module GraphqlRails
   class Controller
@@ -8,6 +9,8 @@ module GraphqlRails
       # Resolver which includes controller specific methods.
       # Used to simplify resolver build for each controller action
       class ControllerActionResolver < GraphQL::Schema::Resolver
+        argument_class(GraphqlRails::Types::ArgumentType)
+
         def self.controller(controller_class = nil)
           @controller = controller_class if controller_class
           @controller

data/lib/graphql_rails/controller/log_controller_action.rb

@@ -62,9 +62,14 @@ module GraphqlRails
       end
 
       def parameter_filter_class
-        return ActiveSupport::ParameterFilter if Object.const_defined?('ActiveSupport::ParameterFilter')
+        if ActiveSupport.gem_version.segments.first < 6
+          return ActiveSupport::ParameterFilter if Object.const_defined?('ActiveSupport::ParameterFilter')
 
-        ActionDispatch::Http::ParameterFilter
+          ActionDispatch::Http::ParameterFilter
+        else
+          require 'active_support/parameter_filter'
+          ActiveSupport::ParameterFilter
+        end
       end
     end
   end

data/lib/graphql_rails/decorator/relation_decorator.rb

@@ -5,7 +5,7 @@ module GraphqlRails
     # wrapps active record relation and returns decorated object instead
     class RelationDecorator
       delegate :map, :each, to: :to_a
-      delegate :limit_value, :offset_value, :count, :size, to: :relation
+      delegate :limit_value, :offset_value, :count, :size, :empty?, to: :relation
 
       def self.decorates?(object)
         (defined?(ActiveRecord) && object.is_a?(ActiveRecord::Relation)) ||
@@ -24,7 +24,7 @@ module GraphqlRails
         end
       end
 
-      %i[first second last].each do |method_name|
+      %i[first second last find find_by].each do |method_name|
         define_method method_name do |*args, &block|
           decoratable_object_method(method_name, *args, &block)
         end

data/lib/graphql_rails/input_configurable.rb

@@ -3,9 +3,14 @@
 module GraphqlRails
   # contains configuration options related with inputs
   module InputConfigurable
-    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) }
+    def permit(*args)
+      args.each do |arg|
+        if arg.is_a? Hash
+          arg.each { |attribute, type| permit_input(attribute, type: type) }
+        else
+          permit_input(arg)
+        end
+      end
       self
     end
 
@@ -21,7 +26,7 @@ module GraphqlRails
       pagination_options = nil if pagination_options == false
 
       @pagination_options = pagination_options
-      permit(:before, :after, first: :int, last: :int)
+      self
     end
 
     def paginated?
@@ -37,11 +42,8 @@ module GraphqlRails
     end
 
     def build_input_attribute(name, options: {}, **other_options)
-      Attributes::InputAttribute.new(
-        name.to_s,
-        options: input_attribute_options.merge(options),
-        **other_options
-      )
+      input_options = input_attribute_options.merge(options)
+      Attributes::InputAttribute.new(name.to_s, config: self).with(options: input_options, **other_options)
     end
   end
 end

data/lib/graphql_rails/model/build_graphql_input_type.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
+require 'graphql_rails/types/argument_type'
+require 'graphql_rails/concerns/service'
+
 module GraphqlRails
   module Model
     # stores information about model specific config, like attributes and types
     class BuildGraphqlInputType
-      require 'graphql_rails/concerns/service'
-
       include ::GraphqlRails::Service
 
       def initialize(name:, description: nil, attributes:)
@@ -20,6 +21,7 @@ module GraphqlRails
         type_attributes = attributes
 
         Class.new(GraphQL::Schema::InputObject) do
+          argument_class(GraphqlRails::Types::ArgumentType)
           graphql_name(type_name)
           description(type_description)