rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/helpers/inherited_collection/hash.rb

@@ -0,0 +1,88 @@
+module Rails
+  module GraphQL
+    module Helpers
+      # A inherited collection of Hash that can contain simple values, arrays,
+      # or sets
+      class InheritedCollection::Hash < InheritedCollection::Base
+        delegate :transform_values, :transform_keys, to: :to_hash
+        delegate :filter_map, :map, to: :eager
+
+        # Simply go over each definition and check for the given key
+        def key?(value)
+          each_definition.any? { |definition| definition.key?(value) }
+        end
+
+        # Collect all the keys of all the definitions
+        def keys
+          each_definition.reverse_each.flat_map(&:keys).uniq
+        end
+
+        # Go over each key and value
+        def each
+          Enumerator::Lazy.new(keys) do |yielder, key|
+            val = self[key]
+            yield(key, val) if block_given?
+            yielder.yield(key, val)
+          end
+        end
+
+        # Go over each value exclusively
+        def each_value(&block)
+          Enumerator::Lazy.new(keys) do |yielder, key|
+            val = self[key]
+            yield(val) if block_given?
+            yielder.yield(val)
+          end
+        end
+
+        # Go over each key exclusively
+        def each_key(&block)
+          keys.each(&block)
+        end
+
+        # Get all the values by lazy iterating over all the keys
+        def values
+          keys.lazy.map(&method(:[]))
+        end
+
+        # Basically returns the plain result value
+        def to_hash
+          each.to_h
+        end
+
+        # A simple way to get the result of one single key
+        def [](key)
+          lazy[key]
+        end
+
+        # Build a lazy hash
+        def lazy
+          @table ||= Hash.new(&method(_combine? ? :_combined_hash : :_simple_hash))
+        end
+
+        private
+
+          # Check if it has to combine the values
+          def _combine?
+            @type != :hash
+          end
+
+          # Builds a values for a combined hash
+          def _combined_hash(hash, key)
+            hash[key] = each_definition.reverse_each.inject(nil) do |result, definition|
+              next result unless definition.key?(key)
+              next definition[key] if result.nil?
+              result + definition[key]
+            end
+          end
+
+          # Builds a values for a simple hash
+          def _simple_hash(hash, key)
+            hash[key] = each_definition.reverse_each do |definition|
+              break definition[key] if definition.key?(key)
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,22 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
-      module InheritedCollection # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
+      # Helper module that allow classes to have specific type of attributes
+      # that are corretly delt when it is inherited by another class. It keeps
+      # track of its own value and allow access to all values of the property
+      # in the tree,
+      #
+      # TODO: Rewrite this!
+      module InheritedCollection
+        # All possible types of inheritable values
         DEFAULT_TYPES = {
           array:      '[]',
           set:        'Set.new',
           hash:       '{}',
-          hash_array: 'Hash.new { |h, k| h[k] = [] }',
-          hash_set:   'Hash.new { |h, k| h[k] = Set.new }',
+          hash_array: '::Hash.new { |h, k| h[k] = [] }',
+          hash_set:   '::Hash.new { |h, k| h[k] = Set.new }',
         }.freeze
 
         # Declare a class-level attribute whose value is both isolated and also
@@ -60,20 +67,19 @@ module Rails # :nodoc:
           type: :set
         )
           attrs.each do |name|
-            module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-              def self.all_#{name}
-                ::Rails::GraphQL::Helpers::AttributeDelegator.new do
-                  fetch_inherited_#{type}('@#{name}')
-                end
+            instance_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+              def all_#{name}
+                return superclass.try(:all_#{name}) unless defined?(@#{name})
+                InheritedCollection::Base.handle(self, :@#{name}, :#{type})
               end
 
-              def self.#{name}
+              def #{name}
                 @#{name} ||= #{DEFAULT_TYPES[type]}
               end
             RUBY
 
-            module_eval(<<~RUBY, __FILE__, __LINE__ + 1) if instance_predicate
-              def self.#{name}?
+            instance_eval(<<~RUBY, __FILE__, __LINE__ + 1) if instance_predicate
+              def #{name}?
                 (defined?(@#{name}) && @#{name}.present?) || superclass.try(:#{name}?)
               end
             RUBY
@@ -84,69 +90,12 @@ module Rails # :nodoc:
             end
           end
         end
-
-        protected
-
-          # Combine an inherited list of arrays
-          def fetch_inherited_array(ivar)
-            inherited_ancestors.each_with_object([]) do |klass, result|
-              next result unless klass.instance_variable_defined?(ivar)
-              val = klass.instance_variable_get(ivar)
-              result.merge(val) unless val.blank?
-            end
-          end
-
-          # Combine an inherited list of set objects
-          def fetch_inherited_set(ivar)
-            inherited_ancestors.each_with_object(Set.new) do |klass, result|
-              next result unless klass.instance_variable_defined?(ivar)
-              val = klass.instance_variable_get(ivar)
-              result.merge(val) unless val.blank?
-            end
-          end
-
-          # Combine an inherited list of hashes but keeping only the most recent
-          # value, which means that keys might be replaced
-          def fetch_inherited_hash(ivar)
-            inherited_ancestors.each_with_object({}) do |klass, result|
-              next result unless klass.instance_variable_defined?(ivar)
-              val = klass.instance_variable_get(ivar)
-              result.merge!(val) unless val.blank?
-            end
-          end
-
-          # Right now we can't use Hash with default proc for equivalency due to
-          # a bug on Ruby https://bugs.ruby-lang.org/issues/17181
-
-          # Combine an inherited list of hashes, which also will combine arrays,
-          # ensuring that same key items will be combined
-          def fetch_inherited_hash_array(ivar)
-            inherited_ancestors.inject({}) do |result, klass|
-              next result unless klass.instance_variable_defined?(ivar)
-              val = klass.instance_variable_get(ivar)
-              Helpers.merge_hash_array(result, val)
-            end
-          end
-
-          # Combine an inherited list of hashes, which also will combine arrays,
-          # ensuring that same key items will be combined
-          def fetch_inherited_hash_set(ivar)
-            inherited_ancestors.inject({}) do |result, klass|
-              next result unless klass.instance_variable_defined?(ivar)
-              val = klass.instance_variable_get(ivar)
-              Helpers.merge_hash_array(result, val)
-            end
-          end
-
-        private
-
-          # Return a list of all the ancestor classes up until object
-          def inherited_ancestors
-            [self].tap do |list|
-              list.unshift(list.first.superclass) until list.first.superclass === Object
-            end
-          end
       end
     end
   end
 end
+
+require_relative 'inherited_collection/base'
+
+require_relative 'inherited_collection/array'
+require_relative 'inherited_collection/hash'

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Helpers
+      # This marks an object as instantiable during a requesting, which means it
+      # will be associated with an event and most of it's information comes from
+      # the running event.
+      module Instantiable
+        delegate_missing_to :event
+        attr_reader :event
+      end
+    end
+  end
+end

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 type map
+        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,34 @@ 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)
+        def argument(name, type = nil, **xargs)
+          object = GraphQL::Argument.new(name, 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
+          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
 
         # 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 +113,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
@@ -65,7 +65,7 @@ module Rails # :nodoc:
           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
 
@@ -93,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,15 +1,15 @@
 # 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
-      # symbolic methods
+      # powers when actually executing the event against Procs or owner-based
+      # methods, when provided a symbol
       module WithCallbacks
         DEFAULT_EVENT_TYPES = %i[query mutation subscription request attach
-          authorize organized prepared finalize].freeze
+          authorize organized prepared finalize prepare subscribed].freeze
 
         def self.extended(other)
           other.extend(WithCallbacks::Setup)
@@ -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