rails-graphql 0.2.0 → 1.0.0.beta

data/lib/rails/graphql/helpers/leaf_from_ar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module allowing leaf values to be collected direct from
       # ActiveRecord. It also helps AR Adapters to define the necessary
       # methods and settings to operate with this extractor.
@@ -12,10 +12,10 @@ module Rails # :nodoc:
         def self.extended(other)
           # Defines which type exactly represents the scalar type on the
           # ActiveRecord adapter for casting purposes
-          other.class_attribute :ar_adapter_type, instance_writer: false, default: {}
+          other.class_attribute :ar_adapter_type, instance_accessor: false, default: {}
 
           # A list of ActiveRecord aliases per adapter to skip casting
-          other.class_attribute :ar_adapter_aliases, instance_writer: false,
+          other.class_attribute :ar_adapter_aliases, instance_accessor: false,
             default: (Hash.new { |h, k| h[k] = Set.new })
         end
 
@@ -87,7 +87,7 @@ module Rails # :nodoc:
         #   equivalent
         def define_for(adapter, **settings)
           adapter = ar_adapters[adapter] if ar_adapters.key?(adapter)
-          raise ArgumentError, <<~MSG.squish unless ar_adapters.values.include?(adapter)
+          raise ArgumentError, (+<<~MSG).squish unless ar_adapters.values.include?(adapter)
             The given #{adapter.inspect} adapter is not a valid option.
             The valid options are: #{ar_adapters.to_a.flatten.map(&:inspect).to_sentence}.
           MSG
@@ -99,7 +99,7 @@ module Rails # :nodoc:
             if settings.key?(:cast)
 
           ar_adapter_type[adapter] = settings[:type] if settings.key?(:type)
-          ar_adapter_aliases[adapter] += Array.wrap(settings[:aliases]) \
+          ar_adapter_aliases[adapter] += ::Array.wrap(settings[:aliases]) \
             if settings.key?(:aliases)
         end
 

data/lib/rails/graphql/helpers/registerable.rb

@@ -1,77 +1,52 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
-      # Helper module responsible for name stuff and also responsible for
-      # registering the objects to the type map, which also checks for the
-      # uniqueness of the name of things.
+module Rails
+  module GraphQL
+    module Helpers
+      # Helper module responsible for registering the objects to the type map,
+      # which also checks for the uniqueness of the name of things.
       module Registerable
-        NAME_EXP = /GraphQL::(?:Type::\w+::|Directive::)?([:\w]+?)([A-Z][a-z]+)?\z/.freeze
-
         # Here we define a couple of attributes used by registration
         def self.extended(other)
-          other.extend(Registerable::ClassMethods)
+          other.extend(Helpers::Unregisterable)
           other.extend(Helpers::WithNamespace)
-
-          # If a type is marked as abstract, it's then used as a base and it
-          # won't appear in the introspection
-          other.class_attribute :abstract, instance_writer: false, default: false
+          other.extend(Helpers::WithName)
+          other.extend(Helpers::WithDescription)
 
           # Marks if the object is one of those defined on the spec, which
           # marks the object as part of the introspection system
-          other.class_attribute :spec_object, instance_writer: false, default: false
-
-          # The given description of the type
-          other.class_attribute :description, instance_writer: false
+          other.class_attribute :spec_object, instance_accessor: false, default: false
         end
 
-        module ClassMethods # :nodoc: all
-          # Here we wait for the class to be fully loaded so that we can
-          # correctly trigger the registration
-          def inherited(subclass)
-            super if defined? super
-            return if subclass.try(:abstract)
-            GraphQL.type_map.postpone_registration(subclass)
-          end
-
-          # Check if the class is already registered in the typemap
-          def registered?
-            GraphQL.type_map.object_exist?(self, exclusive: true)
-          end
-
-          # The process to register a class and it's name on the index
-          def register!
-            return if abstract? || gql_name.blank?
-
-            raise DuplicatedError, <<~MSG.squish if registered?
-              The "#{gql_name}" is already defined, the only way to change its
-              definition is by using extensions.
-            MSG
-
-            invalid_internal = !spec_object && gql_name.start_with?('__')
-            raise NameError, <<~MSG.squish if invalid_internal
-              The name "#{gql_name}" is invalid. Only internal objects from the
-              spec can have a name starting with "__".
-            MSG
-
-            super if defined? super
-            GraphQL.type_map.register(self).method(:validate!)
-          end
+        # Here we wait for the class to be fully loaded so that we can
+        # correctly trigger the registration
+        def inherited(subclass)
+          super if defined? super
+          GraphQL.type_map.postpone_registration(subclass)
         end
 
-        # Return the name of the object as a GraphQL name
-        def gql_name
-          @gql_name ||= begin
-            name.match(NAME_EXP).try(:[], 1)&.tr(':', '')
-          end unless anonymous?
+        # Check if the class is already registered in the typemap
+        def registered?
+          GraphQL.type_map.object_exist?(self, exclusive: true)
         end
 
-        alias graphql_name gql_name
+        # The process to register a class and it's name on the index
+        def register!
+          return if abstract? || gql_name.blank?
+
+          raise DuplicatedError, (+<<~MSG).squish if registered?
+            The "#{gql_name}" is already defined, the only way to change its
+            definition is by using extensions.
+          MSG
 
-        # Return the name of the object as a symbol
-        def to_sym
-          @gql_key ||= gql_name&.underscore&.to_sym
+          invalid_internal = !spec_object && gql_name.start_with?('__')
+          raise NameError, (+<<~MSG).squish if invalid_internal
+            The name "#{gql_name}" is invalid. Only internal objects from the
+            spec can have a name starting with "__".
+          MSG
+
+          super if defined? super
+          GraphQL.type_map.register(self)
         end
 
         # Get or set a list of aliases for this object
@@ -85,17 +60,24 @@ module Rails # :nodoc:
           end
         end
 
+        # TODO: When an object is frozen, it was successfully validated
+        # alias valid? frozen?
+
         protected
 
           # An alias for +description = value.strip_heredoc.chomp+ that can be
           # used as method
           def desc(value)
-            self.description = value.strip_heredoc.chomp
+            self.description = value
           end
 
-          # Change the gql name of the object
-          def rename!(name)
-            @gql_name = name
+          def rename!(*)
+            GraphQL.logger.warn((+<<~MSG).squish) if registered?
+              \e[95m[GraphQL] Renaming #{name} after it has being registered
+              may cause unexpected behaviors.\e[0m
+            MSG
+
+            super
           end
       end
     end

data/lib/rails/graphql/helpers/unregisterable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Helpers
+      # Helper that allows unregisterable objects to be both identified and
+      # removed from type map
+      module Unregisterable
+        # Simply remove itself from the type map
+        def unregister!
+          GraphQL.type_map.unregister(self)
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/helpers/with_arguments.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module that allows other objects to hold arguments
       module WithArguments
         def self.extended(other)
@@ -13,14 +13,22 @@ module Rails # :nodoc:
 
         def self.included(other)
           other.define_method(:arguments) do
-            defined?(@arguments) ? @arguments : {}
+            @arguments ||= {}
+          end
+
+          other.define_method(:all_arguments) do
+            @arguments if defined?(@arguments)
+          end
+
+          other.define_method(:arguments?) do
+            defined?(@arguments) && @arguments.present?
           end
         end
 
-        module ClassMethods # :nodoc: all
+        module ClassMethods
           def inherited(subclass)
             super if defined? super
-            return if arguments.empty?
+            return if arguments.blank?
 
             new_arguments = Helpers.dup_all_with_owner(arguments.transform_values, subclass)
             subclass.instance_variable_set(:@arguments, new_arguments)
@@ -28,13 +36,13 @@ module Rails # :nodoc:
         end
 
         def initialize(*args, arguments: nil, **xargs, &block)
-          @arguments = Array.wrap(arguments).map do |object|
-            raise ArgumentError, <<~MSG.squish unless object.is_a?(Argument)
-              The given "#{object.inspect}" is not a valid Argument object.
+          @arguments = GraphQL.enumerate(arguments).each_with_object({}) do |item, hash|
+            raise ArgumentError, (+<<~MSG).squish unless item.is_a?(Argument)
+              The given "#{item.inspect}" is not a valid Argument object.
             MSG
 
-            [object.name, Helpers.dup_with_owner(object, self)]
-          end.to_h unless arguments.nil?
+            hash[item.name] = Helpers.dup_with_owner(item, self)
+          end unless arguments.nil?
 
           super(*args, **xargs, &block)
         end
@@ -50,39 +58,33 @@ module Rails # :nodoc:
           super && other.respond_to?(:all_arguments) && match_arguments?(other)
         end
 
-        # Mostly for correct inheritance on instances
-        def all_arguments
-          defined?(@arguments) ? @arguments : {}
-        end
-
         # See {Argument}[rdoc-ref:Rails::GraphQL::Argument] class.
         def argument(name, base_type, **xargs)
-          xargs[:owner] = self
-          object = GraphQL::Argument.new(name, base_type, **xargs)
+          object = GraphQL::Argument.new(name, base_type, **xargs, owner: self)
 
-          raise DuplicatedError, <<~MSG.squish if has_argument?(object.name)
+          raise DuplicatedError, (+<<~MSG).squish if has_argument?(object.name)
             The #{name.inspect} argument is already defined and can't be redefined.
           MSG
 
-          (@arguments ||= {})[object.name] = object
+          arguments[object.name] = object
         rescue DefinitionError => e
-          raise e.class, e.message + "\n  Defined at: #{caller(2)[0]}"
+          raise e.class, +"#{e.message}\n  Defined at: #{caller(2)[0]}"
         end
 
         # Since arguments' owner are more flexible, their instances can be
         # directly associated to objects that have argument
         def ref_argument(object)
-          raise ArgumentError, <<~MSG.squish unless object.is_a?(GraphQL::Argument)
+          raise ArgumentError, (+<<~MSG).squish unless object.is_a?(GraphQL::Argument)
             The given object #{object.inspect} is not a valid argument.
           MSG
 
-          raise DuplicatedError, <<~MSG.squish if has_argument?(object.name)
+          raise DuplicatedError, (+<<~MSG).squish if has_argument?(object.name)
             The #{object.name.inspect} argument is already defined and can't be redefined.
           MSG
 
           (@arguments ||= {})[object.name] = object
         rescue DefinitionError => e
-          raise e.class, e.message + "\n  Defined at: #{caller(2)[0]}"
+          raise e.class, +"#{e.message}\n  Defined at: #{caller(2)[0]}"
         end
 
         # A short cute for arguments named and typed as id
@@ -110,14 +112,16 @@ module Rails # :nodoc:
 
           # Show all the arguments as their inspect version
           def inspect_arguments
-            args = all_arguments.each_value.map(&:inspect)
-            args.presence && "(#{args.join(', ')})"
+            args = all_arguments&.each_value&.map(&:inspect)
+            args.presence && +"(#{args.join(', ')})"
           end
 
           # Check the equivalency of arguments
           def match_arguments?(other)
             l_args, r_args = all_arguments, other.all_arguments
-            l_args.size <= r_args.size && l_args.all? { |key, arg| arg =~ r_args[key] }
+            l_args.class == r_args.class &&
+              l_args.size <= r_args.size &&
+              l_args.all? { |key, arg| arg =~ r_args[key] }
           end
       end
     end

data/lib/rails/graphql/helpers/with_assignment.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module that allows other objects to hold an +assigned_to+ object
       module WithAssignment
         # Add extra instance based methods
@@ -11,7 +11,7 @@ module Rails # :nodoc:
             :assigned_class, to: :class
         end
 
-        # Check if the class is assgined
+        # Check if the class is assigned
         def assigned?
           assigned_to.present?
         end
@@ -54,16 +54,18 @@ module Rails # :nodoc:
           # Ignores the possible errors here related
         end
 
-        # After a successfully registration, add the assigned class to the
-        # type map as a great alias to find the object
+        # After a successfully registration, add the assigned class to the type
+        # map as a great alias to find the object, but only if the class does
+        # not have an alias already
         def register!
           return if abstract?
           return super unless assigned?
 
           result = super
           return result unless (klass = safe_assigned_class)
+          return result if GraphQL.type_map.exist?(klass, namespaces: namespaces)
 
-          GraphQL.type_map.register_alias(klass, namespaces: namespaces, &method(:itself))
+          GraphQL.type_map.register_alias(klass, to_sym, namespaces: namespaces)
           result
         end
 
@@ -91,7 +93,7 @@ module Rails # :nodoc:
               klass = klass.superclass
             end
 
-            message = !block.nil? ? block.call(klass) : <<~MSG.squish
+            message = !block.nil? ? block.call(klass) : (+<<~MSG).squish
               The "#{klass.name}" is not a subclass of #{base_class.name}.
             MSG
 

data/lib/rails/graphql/helpers/with_callbacks.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Callbacks is an extension of the events which works with the
       # {Callback}[rdoc-ref:Rails::GraphQL::Callback] class, then having extra
       # powers when actually executing the event against procs or owner-based
@@ -17,7 +17,7 @@ module Rails # :nodoc:
 
         def self.included(other)
           other.extend(WithCallbacks::Setup)
-          other.delegate(:event_filters, to: :class)
+          other.delegate(:event_filters, :default_exclusive?, to: :class)
         end
 
         # Add the ability to set up filters before the actual execution of the
@@ -31,15 +31,32 @@ module Rails # :nodoc:
           # Return the list of event filters hooks
           def event_filters
             return @event_filters if defined? @event_filters
-            superclass.try(:event_filters) || {}
+            superclass.try(:event_filters) || EMPTY_HASH
+          end
+
+          # Set the default +exclusive+ value for the given +for+ event names
+          def default_exclusive(value, **xargs)
+            new_values = Array.wrap(xargs.fetch(:for)).map(&:to_sym).product([value]).to_h
+            @callback_exclusive ||= superclass.try(:callback_exclusive)&.dup || {}
+            @callback_exclusive.merge!(new_values)
+          end
+
+          # Check if the given +event_name+ should be thread as exclusive or
+          # non-exclusive by default
+          def default_exclusive?(event_name)
+            if defined?(@callback_exclusive)
+              @callback_exclusive[event_name]
+            else
+              superclass.try(:default_exclusive?, event_name)
+            end
           end
 
           protected
 
             # Attach a new key based event filter
-            def event_filter(key, sanitizer = nil, &block)
+            def event_filter(key, &block)
               @event_filters ||= superclass.try(:event_filters)&.dup || {}
-              @event_filters[key.to_sym] = { block: block, sanitizer: sanitizer }
+              @event_filters[key.to_sym] = block
             end
         end
 
@@ -47,7 +64,7 @@ module Rails # :nodoc:
         # {Callback}[rdoc-ref:Rails::GraphQL::Callback] object.
         def on(event_name, *args, unshift: false, **xargs, &block)
           block = Callback.new(self, event_name, *args, **xargs, &block)
-          super(event_name, unshift: unshift, &block)
+          super(event_name, block, unshift: unshift)
         end
       end
     end

data/lib/rails/graphql/helpers/with_description.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Helpers
+      module WithDescription
+
+        # A getter or setter in the same function
+        def desc(value = nil)
+          value.nil? ? description : (self.description = value)
+        end
+
+        # Define and format description
+        def description=(value)
+          @description = value.to_s.presence&.strip_heredoc&.chomp
+        end
+
+        # Return the description of the argument
+        def description(namespace = nil, kind = nil)
+          return @description if description?
+          return unless GraphQL.config.enable_i18n_descriptions
+
+          # If it has been defined, but as nil, then it will always be nil
+          return if defined?(@description)
+          @description = i18n_description(namespace, kind)
+        end
+
+        # Checks if a description was provided
+        def description?
+          defined?(@description) && !!@description
+        end
+
+        protected
+
+          # Return a description from I18n
+          def i18n_description(namespace = nil, kind = nil)
+            return if (parent = try(:owner)).try(:spec_object?)
+
+            values = {
+              kind: kind || try(:kind),
+              parent: i18n_parent_value(parent),
+              namespace: GraphQL.enumerate(namespace || try(:namespaces)).first,
+              name: is_a?(Module) ? to_sym : name,
+            }
+
+            options = GraphQL.config.i18n_scopes.dup
+            while option = options.shift
+              key = format(option, values)
+              next if key.include?('..')
+
+              result = catch(:exception) { ::I18n.translate(key, throw: true) }
+              return result unless result.is_a?(Hash) ||
+                result.is_a?(I18n::MissingTranslation)
+            end
+          end
+
+          # Properly figure out the parent value for the interpolation
+          def i18n_parent_value(parent)
+            if parent.respond_to?(:i18n_scope)
+              parent.i18n_scope(self)
+            elsif parent.is_a?(Helpers::WithSchemaFields) && respond_to?(:schema_type)
+              schema_type
+            else
+              parent.try(:to_sym)
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/rails/graphql/helpers/with_directives.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module that allows other objects to hold directives during the
       # definition process
       module WithDirectives
@@ -15,12 +15,14 @@ module Rails # :nodoc:
         def self.included(other)
           other.extend(WithDirectives::DirectiveLocation)
           other.define_method(:directives) { @directives ||= Set.new }
-          other.class_attribute(:directive_location, instance_writer: false)
+          other.define_method(:all_directives) { @directives if defined?(@directives) }
+          other.define_method(:directives?) { defined?(@directives) && @directives.present? }
         end
 
         def initialize_copy(orig)
           super
 
+          return if orig.directives.nil?
           @directives = orig.directives.dup
         end
 
@@ -35,25 +37,20 @@ module Rails # :nodoc:
 
           # Use this once to define the directive location
           def directive_location=(value)
-            raise ArgumentError, 'Directive location is already defined' \
+            raise ArgumentError, +'Directive location is already defined' \
               unless directive_location.nil?
 
             @directive_location = value
           end
         end
 
-        # Mostly for correct inheritance on instances
-        def all_directives
-          defined?(@directives) ? @directives : Set.new
-        end
-
         # Use this method to assign directives to the given definition. You can
         # also provide a symbol as a first argument and extra named-arguments
         # to auto initialize a new instance of that directive.
         def use(item_or_symbol, *list, **xargs)
           if item_or_symbol.is_a?(Symbol)
             directive = fetch!(item_or_symbol)
-            raise ArgumentError, <<~MSG.squish unless directive < GraphQL::Directive
+            raise ArgumentError, (+<<~MSG).squish unless directive < GraphQL::Directive
               Unable to find the #{item_or_symbol.inspect} directive.
             MSG
 
@@ -62,21 +59,19 @@ module Rails # :nodoc:
             list << item_or_symbol
           end
 
-          current = try(:all_directives) || @directives
-          items = GraphQL.directives_to_set(list, current, source: self)
-          directives.merge(items)
+          directives += GraphQL.directives_to_set(list, all_directives, source: self)
         rescue DefinitionError => e
-          raise e.class, e.message + "\n  Defined at: #{caller(2)[0]}"
+          raise e.class, +"#{e.message}\n  Defined at: #{caller(2)[0]}"
         end
 
-        # Check wheter a given directive is being used
-        def using?(item_or_symbol)
-          directive = item_or_symbol.is_a?(Symbol) ? fetch!(item_or_symbol) : item_or_symbol
-          raise ArgumentError, <<~MSG.squish unless directive < GraphQL::Directive
-            The provided #{item_or_symbol.inspect} is not a valid directive.
+        # Check whether a given directive is being used
+        def using?(item)
+          directive = (item.is_a?(Symbol) || item.is_a?(String)) ? fetch!(item) : item
+          raise ArgumentError, (+<<~MSG).squish unless directive < GraphQL::Directive
+            The provided #{item.inspect} is not a valid directive.
           MSG
 
-          all_directives.any? { |item| item.is_a?(directive) }
+          !!all_directives&.any?(directive)
         end
 
         alias has_directive? using?
@@ -84,23 +79,45 @@ module Rails # :nodoc:
         # Override the +all_listeners+ method since callbacks can eventually be
         # attached to objects that have directives, which then they need to
         # be combined
-        def all_listeners
-          current = all_directives.map(&:all_listeners).reduce(:+) || Set.new
-          (defined?(super) ? super : Set.new) + current
+        def all_directive_listeners
+          inherited = super if defined?(super)
+          return inherited unless directives?
+
+          current = all_directives.map(&:all_listeners).compact.reduce(:+)
+          inherited.nil? ? current : inherited + current
+        end
+
+        alias all_listeners all_directive_listeners
+
+        # Make sure to consider directive listeners while checking for listeners
+        def directive_listeners?
+          (defined?(super) && super) || all_directives&.any?(&:listeners?)
         end
 
+        alias listeners? directive_listeners?
+
         # Override the +all_events+ method since callbacks can eventually be
         # attached to objects that have directives, which then they need to
         # be combined
-        def all_events
-          Helpers::AttributeDelegator.new do
-            base = defined?(super) ? super : {}
-            all_directives.map(&:all_events).inject(base) do |lhash, rhash|
-              Helpers.merge_hash_array(lhash, rhash)
-            end
+        def all_directive_events
+          inherited = super if defined?(super)
+          return inherited unless directives?
+
+          all_directives.inject(inherited || {}) do |result, directive|
+            next result if (val = directive.all_events).blank?
+            Helpers.merge_hash_array(result, val)
           end
         end
 
+        alias all_events all_directive_events
+
+        # Make sure to consider directive events while checking for events
+        def directive_events?
+          (defined?(super) && super) || all_directives&.any?(&:events?)
+        end
+
+        alias events? directive_events?
+
         # Validate all the directives to make sure the definition is valid
         def validate!(*)
           super if defined? super
@@ -110,6 +127,13 @@ module Rails # :nodoc:
           @directives.freeze
         end
 
+        protected
+
+          # Helper method to inspect the directives
+          def inspect_directives
+            all_directives&.map(&:inspect)&.join(' ')
+          end
+
         private
 
           # Find a directive for its symbolized name