graphql_rails 1.2.2 → 2.0.0

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/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
 
@@ -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_connection_type/count_items.rb

@@ -27,7 +27,7 @@ module GraphqlRails
         attr_reader :graphql_object
 
         def list
-          graphql_object.nodes
+          graphql_object.items
         end
 
         def active_record?

data/lib/graphql_rails/model/build_connection_type.rb

@@ -33,7 +33,7 @@ module GraphqlRails
           field :total, Integer, null: false
 
           def total
-            CountItems.call(self)
+            CountItems.call(object)
           end
         end
       end

data/lib/graphql_rails/model/configurable.rb

@@ -2,25 +2,47 @@
 
 module GraphqlRails
   module Model
-    # contains methods which are shared between various configurations
-    # expects `default_name` to be defined
+    # Contains methods which are shared between various configurations.
+    #
+    # Expects `default_name` to be defined.
+    # Expects `build_attribute(attr_name)` method to be defined.
     module Configurable
+      require 'active_support/concern'
+      require 'graphql_rails/concerns/chainable_options'
+
+      extend ActiveSupport::Concern
+
+      included do
+        include GraphqlRails::ChainableOptions
+
+        chainable_option :description
+      end
+
+      def initialize_copy(other)
+        super
+        @type_name = nil
+        @attributes = other.attributes.transform_values(&:dup)
+      end
+
       def attributes
         @attributes ||= {}
       end
 
-      def name(graphql_name = nil)
-        @name = graphql_name if graphql_name
-        @name || default_name
+      def name(*args)
+        get_or_set_chainable_option(:name, *args) || default_name
       end
 
       def type_name
         @type_name ||= "#{name.camelize}Type#{SecureRandom.hex}"
       end
 
-      def description(new_description = nil)
-        @description = new_description if new_description
-        @description
+      def attribute(attribute_name, **attribute_options)
+        key = attribute_name.to_s
+
+        attributes[key] ||= build_attribute(attribute_name).tap do |new_attribute|
+          new_attribute.with(**attribute_options) unless attribute_options.empty?
+          yield(new_attribute) if block_given?
+        end
       end
     end
   end

data/lib/graphql_rails/model/configuration.rb

@@ -2,7 +2,6 @@
 
 require 'graphql_rails/attributes'
 require 'graphql_rails/model/find_or_build_graphql_type'
-require 'graphql_rails/model/build_enum_type'
 require 'graphql_rails/model/input'
 require 'graphql_rails/model/configurable'
 require 'graphql_rails/model/build_connection_type'
@@ -11,6 +10,7 @@ module GraphqlRails
   module Model
     # stores information about model specific config, like attributes and types
     class Configuration
+      include ChainableOptions
       include Configurable
 
       def initialize(model_class)
@@ -22,22 +22,14 @@ module GraphqlRails
         @connection_type = nil
         @graphql_type = nil
         @input = other.instance_variable_get(:@input)&.transform_values(&:dup)
-        @attributes = other.instance_variable_get(:@attributes)&.transform_values(&:dup)
       end
 
       def attribute(attribute_name, **attribute_options)
         key = attribute_name.to_s
 
-        attributes[key] ||= Attributes::Attribute.new(attribute_name)
-
-        attributes[key].tap do |attribute|
-          attribute_options.each do |method_name, args|
-            send_args = [method_name]
-            send_args << args if attribute.method(method_name).parameters.present?
-            attribute.public_send(*send_args)
-          end
-
-          yield(attribute) if block_given?
+        attributes[key] ||= build_attribute(attribute_name).tap do |new_attribute|
+          new_attribute.with(**attribute_options)
+          yield(new_attribute) if block_given?
         end
       end
 
@@ -68,13 +60,35 @@ module GraphqlRails
         @connection_type ||= BuildConnectionType.call(graphql_type)
       end
 
+      def with_ensured_fields!
+        return self if @graphql_type.blank?
+
+        reset_graphql_type if attributes.any? && graphql_type.fields.length != attributes.length
+
+        self
+      end
+
       private
 
       attr_reader :model_class
 
+      def build_attribute(attribute_name)
+        Attributes::Attribute.new(attribute_name)
+      end
+
       def default_name
         @default_name ||= model_class.name.split('::').last
       end
+
+      def reset_graphql_type
+        @graphql_type = FindOrBuildGraphqlType.call(
+          name: name,
+          description: description,
+          attributes: attributes,
+          type_name: type_name,
+          force_define_attributes: true
+        )
+      end
     end
   end
 end

data/lib/graphql_rails/model/find_or_build_graphql_type.rb

@@ -10,20 +10,21 @@ module GraphqlRails
 
       include ::GraphqlRails::Service
 
-      def initialize(name:, description:, attributes:, type_name:)
+      def initialize(name:, description:, attributes:, type_name:, force_define_attributes: false)
         @name = name
         @description = description
         @attributes = attributes
         @type_name = type_name
+        @force_define_attributes = force_define_attributes
       end
 
       def call
-        klass.tap { add_fields_to_graphql_type if new_class? }
+        klass.tap { add_fields_to_graphql_type if new_class? || force_define_attributes }
       end
 
       private
 
-      attr_reader :name, :description, :attributes, :type_name
+      attr_reader :name, :description, :attributes, :type_name, :force_define_attributes
 
       delegate :klass, :new_class?, to: :type_class_finder
 
@@ -36,29 +37,30 @@ module GraphqlRails
       end
 
       def add_fields_to_graphql_type
-        AddFieldsToGraphqlType.call(klass: klass, attributes: attributes.values.select(&:scalar_type?))
+        scalar_attributes, dynamic_attributes = attributes.values.partition(&:scalar_type?)
 
-        attributes.values.reject(&:scalar_type?).tap do |dynamic_attributes|
-          find_or_build_dynamic_graphql_types(dynamic_attributes) do |name, description, attributes, type_name|
-            self.class.call(
-              name: name, description: description,
-              attributes: attributes, type_name: type_name
-            )
-          end
-          AddFieldsToGraphqlType.call(klass: klass, attributes: dynamic_attributes)
-        end
+        AddFieldsToGraphqlType.call(klass: klass, attributes: scalar_attributes)
+        dynamic_attributes.each { |attribute| find_or_build_dynamic_type(attribute) }
+        AddFieldsToGraphqlType.call(klass: klass, attributes: dynamic_attributes)
       end
 
-      def find_or_build_dynamic_graphql_types(dynamic_attributes)
-        dynamic_attributes.each do |attribute|
-          yield(
-            attribute.graphql_model.graphql.name,
-            attribute.graphql_model.graphql.description,
-            attribute.graphql_model.graphql.attributes,
-            attribute.graphql_model.graphql.type_name
-          )
+      def find_or_build_dynamic_type(attribute)
+        graphql_model = attribute.graphql_model
+        if graphql_model
+          find_or_build_graphql_model_type(graphql_model)
+        else
+          AddFieldsToGraphqlType.call(klass: klass, attributes: [attribute])
         end
       end
+
+      def find_or_build_graphql_model_type(graphql_model)
+        self.class.call(
+          name: graphql_model.graphql.name,
+          description: graphql_model.graphql.description,
+          attributes: graphql_model.graphql.attributes,
+          type_name: graphql_model.graphql.type_name
+        )
+      end
     end
   end
 end

data/lib/graphql_rails/model/input.rb

@@ -1,58 +1,42 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/model/build_graphql_input_type'
-require 'graphql_rails/model/configurable'
-
 module GraphqlRails
   module Model
     # stores information about model input specific config, like attributes and types
     class Input
+      require 'graphql_rails/concerns/chainable_options'
+      require 'graphql_rails/model/configurable'
+      require 'graphql_rails/model/build_graphql_input_type'
+
       include Configurable
 
+      chainable_option :enum
+
       def initialize(model_class, input_name_suffix)
         @model_class = model_class
         @input_name_suffix = input_name_suffix
       end
 
-      def initialize_copy(other)
-        super
-        @attributes = other.instance_variable_get(:@attributes)&.transform_values(&:dup)
-      end
-
       def graphql_input_type
         @graphql_input_type ||= BuildGraphqlInputType.call(
           name: name, description: description, attributes: attributes
         )
       end
 
-      def attribute(attribute_name, type: nil, enum: nil, **attribute_options)
-        input_type = attribute_type(attribute_name, type: type, enum: enum, **attribute_options)
-
-        attributes[attribute_name.to_s] = Attributes::InputAttribute.new(
-          attribute_name, type: input_type, **attribute_options
-        )
-      end
-
       private
 
       attr_reader :input_name_suffix, :model_class
 
+      def build_attribute(attribute_name)
+        Attributes::InputAttribute.new(attribute_name, config: self)
+      end
+
       def default_name
         @default_name ||= begin
           suffix = input_name_suffix ? input_name_suffix.to_s.camelize : ''
           "#{model_class.name.split('::').last}#{suffix}Input"
         end
       end
-
-      def attribute_type(attribute_name, type:, enum:, description: nil, **_other)
-        return type unless enum
-
-        BuildEnumType.call(
-          "#{name}_#{attribute_name}_enum",
-          allowed_values: enum,
-          description: description
-        )
-      end
     end
   end
 end

data/lib/graphql_rails/model.rb

@@ -28,7 +28,7 @@ module GraphqlRails
 
       def graphql
         @graphql ||= Model::Configuration.new(self)
-        yield(@graphql) if block_given?
+        @graphql.tap { |it| yield(it) }.with_ensured_fields! if block_given?
         @graphql
       end
     end

data/lib/graphql_rails/router/route.rb

@@ -6,7 +6,7 @@ module GraphqlRails
   class Router
     # Generic class for any type graphql action. Should not be used directly
     class Route
-      attr_reader :name, :module_name, :on, :relative_path
+      attr_reader :name, :module_name, :on, :relative_path, :groups
 
       def initialize(name, to: '', on:, groups: nil, **options)
         @name = name.to_s.camelize(:lower)
@@ -43,7 +43,7 @@ module GraphqlRails
 
       private
 
-      attr_reader :function, :groups
+      attr_reader :function
 
       def resolver
         @resolver ||= Controller::BuildControllerActionResolver.call(route: self)

data/lib/graphql_rails/tasks/dump_graphql_schema.rb

@@ -7,51 +7,37 @@ module GraphqlRails
 
     class MissingGraphqlRouterError < GraphqlRails::Error; end
 
-    attr_reader :name
-
-    def self.call(*args)
-      new(*args).call
+    def self.call(**args)
+      new(**args).call
     end
 
-    def initialize(name:)
-      @name = name
+    def initialize(group:, router:, dump_dir: nil)
+      @group = group
+      @router = router
+      @dump_dir = dump_dir
     end
 
     def call
-      validate
       File.write(schema_path, schema.to_definition)
     end
 
     private
 
-    def validate
-      return if router
-
-      error_message = \
-        'GraphqlRouter is missing. ' \
-        'Run `rails g graphql_rails:install` to build it'
-      raise MissingGraphqlRouterError, error_message
-    end
-
-    def router
-      @router ||= '::GraphqlRouter'.safe_constantize
-    end
+    attr_reader :router, :group
 
     def schema
-      @schema ||= ::GraphqlRouter.graphql_schema(name.presence)
+      @schema ||= router.graphql_schema(group.presence)
     end
 
     def schema_path
-      ENV['GRAPHQL_SCHEMA_DUMP_PATH'] || default_schema_path
-    end
+      FileUtils.mkdir_p(dump_dir)
+      file_name = group.present? ? "graphql_#{group}_schema.graphql" : 'graphql_schema.graphql'
 
-    def default_schema_path
-      schema_folder_path = Rails.root.join('spec', 'fixtures')
-
-      FileUtils.mkdir_p(schema_folder_path)
-      file_name = name.present? ? "graphql_#{name}_schema.graphql" : 'graphql_schema.graphql'
+      "#{dump_dir}/#{file_name}"
+    end
 
-      schema_folder_path.join(file_name)
+    def dump_dir
+      @dump_dir ||= Rails.root.join('spec/fixtures').to_s
     end
   end
 end

data/lib/graphql_rails/tasks/dump_graphql_schemas.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/tasks/dump_graphql_schema'
+
+module GraphqlRails
+  # Generates graphql schema dump files
+  class DumpGraphqlSchemas
+    require 'graphql_rails/errors/error'
+
+    class MissingGraphqlRouterError < GraphqlRails::Error; end
+
+    def self.call(**args)
+      new(**args).call
+    end
+
+    def initialize(dump_dir:, groups: nil)
+      @groups = groups.presence
+      @dump_dir = dump_dir
+    end
+
+    def call
+      validate
+      return dump_default_schema if groups.empty?
+
+      groups.each { |group| dump_graphql_schema(group) }
+    end
+
+    private
+
+    attr_reader :dump_dir
+
+    def dump_default_schema
+      dump_graphql_schema('')
+    end
+
+    def dump_graphql_schema(group)
+      DumpGraphqlSchema.call(group: group, router: router, dump_dir: dump_dir)
+    end
+
+    def validate
+      return if router
+
+      error_message = \
+        'GraphqlRouter is missing. ' \
+        'Run `rails g graphql_rails:install` to build it'
+      raise MissingGraphqlRouterError, error_message
+    end
+
+    def router
+      @router ||= '::GraphqlRouter'.safe_constantize
+    end
+
+    def groups
+      @groups ||= router.routes.flat_map(&:groups).uniq
+    end
+  end
+end

data/lib/graphql_rails/tasks/schema.rake

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/tasks/dump_graphql_schema'
+require 'graphql_rails/tasks/dump_graphql_schemas'
 
 namespace :graphql_rails do
   namespace :schema do
     desc 'Dump GraphQL schema'
-    task(:dump, %i[name] => :environment) do |_, args|
-      default_name = ENV.fetch('SCHEMA_GROUP_NAME', '')
-      args.with_defaults(name: default_name)
-      GraphqlRails::DumpGraphqlSchema.call(name: args.name)
+    task(dump: :environment) do |_, args|
+      groups_from_args = args.extras
+      groups_from_env = ENV['SCHEMA_GROUP_NAME'].to_s.split(',').map(&:strip)
+      groups = groups_from_args + groups_from_env
+      dump_dir = ENV.fetch('GRAPHQL_SCHEMA_DUMP_DIR') { Rails.root.join('spec/fixtures').to_s }
+
+      GraphqlRails::DumpGraphqlSchemas.call(groups: groups, dump_dir: dump_dir)
     end
   end
 end

data/lib/graphql_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GraphqlRails
-  VERSION = '1.2.2'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql_rails
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Povilas Jurčys
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-19 00:00:00.000000000 Z
+date: 2021-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -128,19 +128,19 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6'
-description:
+description: 
 email:
 - po.jurcys@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -174,12 +174,14 @@ files:
 - lib/graphql_rails/attributes.rb
 - lib/graphql_rails/attributes/attributable.rb
 - lib/graphql_rails/attributes/attribute.rb
+- lib/graphql_rails/attributes/attribute_configurable.rb
 - lib/graphql_rails/attributes/attribute_name_parser.rb
 - lib/graphql_rails/attributes/input_attribute.rb
 - lib/graphql_rails/attributes/input_type_parser.rb
 - lib/graphql_rails/attributes/type_name_info.rb
 - lib/graphql_rails/attributes/type_parseable.rb
 - lib/graphql_rails/attributes/type_parser.rb
+- lib/graphql_rails/concerns/chainable_options.rb
 - lib/graphql_rails/concerns/service.rb
 - lib/graphql_rails/controller.rb
 - lib/graphql_rails/controller/action.rb
@@ -226,13 +228,14 @@ files:
 - lib/graphql_rails/router/schema_builder.rb
 - lib/graphql_rails/rspec_controller_helpers.rb
 - lib/graphql_rails/tasks/dump_graphql_schema.rb
+- lib/graphql_rails/tasks/dump_graphql_schemas.rb
 - lib/graphql_rails/tasks/schema.rake
 - lib/graphql_rails/version.rb
 homepage: https://github.com/samesystem/graphql_rails
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -247,8 +250,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key:
+rubygems_version: 3.2.15
+signing_key: 
 specification_version: 4
 summary: Rails style structure for GraphQL API.
 test_files: []

data/.travis.yml

@@ -1,5 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.7.1
-before_install: gem install bundler -v 2.1.4