rails-graphql 0.1.0

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module that allows other objects to hold arguments
+      module WithArguments
+        def self.extended(other)
+          other.extend(Helpers::InheritedCollection)
+          other.extend(WithArguments::ClassMethods)
+          other.inherited_collection(:arguments, type: :hash)
+        end
+
+        def self.included(other)
+          other.define_method(:arguments) do
+            defined?(@arguments) ? @arguments : {}
+          end
+        end
+
+        module ClassMethods # :nodoc: all
+          def inherited(subclass)
+            super if defined? super
+            return if arguments.empty?
+
+            new_arguments = Helpers.dup_all_with_owner(arguments.transform_values, subclass)
+            subclass.instance_variable_set(:@arguments, new_arguments)
+          end
+        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.
+            MSG
+
+            [object.name, Helpers.dup_with_owner(object, self)]
+          end.to_h unless arguments.nil?
+
+          super(*args, **xargs, &block)
+        end
+
+        def initialize_copy(orig)
+          super
+
+          @arguments = Helpers.dup_all_with_owner(orig.arguments.transform_values, self)
+        end
+
+        # Check if all the arguments are compatible
+        def =~(other)
+          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)
+
+          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
+        rescue DefinitionError => e
+          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)
+            The given object #{object.inspect} is not a valid argument.
+          MSG
+
+          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]}"
+        end
+
+        # A short cute for arguments named and typed as id
+        def id_argument(*args, **xargs, &block)
+          name = args.size >= 1 ? args.shift : :id
+          xargs[:null] = false unless xargs.key?(:null)
+          argument(name, :id, *args, **xargs, &block)
+        end
+
+        # Check if a given +name+ is already defined on the list of arguments
+        def has_argument?(name)
+          defined?(@arguments) && @arguments.key?(name)
+        end
+
+        # Validate all the arguments to make sure the definition is valid
+        def validate!(*)
+          super if defined? super
+
+          return unless defined? @arguments
+          @arguments.each_value(&:validate!)
+          @arguments.freeze
+        end
+
+        protected
+
+          # Show all the arguments as their inspect version
+          def inspect_arguments
+            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] }
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module that allows other objects to hold an +assigned_to+ object
+      module WithAssignment
+        # Add extra instance based methods
+        def self.extended(other)
+          other.delegate :assigned?, :assigned_to, :safe_assigned_class,
+            :assigned_class, to: :class
+        end
+
+        # Check if the class is assgined
+        def assigned?
+          assigned_to.present?
+        end
+
+        # Check if the given +value+ is a valid input for the assigned class
+        def valid_assignment?(value)
+          assigned? && (klass = safe_assigned_class).present? &&
+            ((value.is_a?(Module) && value <= klass) || value.is_a?(klass))
+        end
+
+        # Check its own class or pass it to the superclass
+        def assigned_to
+          (defined?(@assigned_to) && @assigned_to.presence) || superclass.try(:assigned_to)
+        end
+
+        # Make sure to always save the assignment as string, so that
+        # +assigned_class+ can return the actual object
+        def assigned_to=(value)
+          if value.is_a?(Module)
+            @assigned_class = value
+            @assigned_to = value.name
+          else
+            @assigned_to = value
+          end
+        end
+
+        # Return the actual class object of the assignment
+        def assigned_class
+          @assigned_class ||= begin
+            klass = assigned_to.constantize
+            validate_assignment!(klass)
+            klass
+          end
+        end
+
+        # Get the assigned class, but if an known exception happens, just ignore
+        def safe_assigned_class
+          assigned_class
+        rescue ::ArgumentError, ::NameError
+          # 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
+        def register!
+          return if abstract?
+          return super unless assigned?
+
+          result = super
+          return result unless (klass = safe_assigned_class)
+
+          GraphQL.type_map.register_alias(klass, namespaces: namespaces, &method(:itself))
+          result
+        end
+
+        protected
+
+          # Allows validating the +assigned_class+ before resolving it, making
+          # sure that it is a subclass of +base_class+. Use the +block+ to
+          # customize the error message
+          def validate_assignment(base_class, &block)
+            @base_class = base_class
+            @error_block = block unless block.nil?
+            self.assigned_to = base_class
+          end
+
+          # Check if the given +klass+ is valid, but just when +@base_class+
+          # is defined
+          def validate_assignment!(klass)
+            return if (base_class = base_assignment_class).nil? || klass <= base_class
+
+            klass = self
+            block = until klass === Class
+              break klass.instance_variable_get(:@error_block) \
+                if klass.instance_variable_defined?(:@error_block)
+
+              klass = klass.superclass
+            end
+
+            message = !block.nil? ? block.call(klass) : <<~MSG.squish
+              The "#{klass.name}" is not a subclass of #{base_class.name}.
+            MSG
+
+            raise ::ArgumentError, message
+          end
+
+          # Find a base class using the inheritance
+          def base_assignment_class
+            if defined?(@base_class)
+              @base_class = @base_class.constantize if @base_class.is_a?(String)
+              @base_class
+            elsif superclass.respond_to?(:base_assignment_class, true)
+              superclass.send(:base_assignment_class)
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # 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
+      module WithCallbacks
+        DEFAULT_EVENT_TYPES = %i[query mutation subscription request attach
+          organized prepared finalize].freeze
+
+        def self.extended(other)
+          other.extend(WithCallbacks::Setup)
+        end
+
+        def self.included(other)
+          other.extend(WithCallbacks::Setup)
+          other.delegate(:event_filters, to: :class)
+        end
+
+        # Add the ability to set up filters before the actual execution of the
+        # callback
+        module Setup
+          # Use the default list of event types when it's not set
+          def event_types(*, **)
+            (super if defined? super).presence || DEFAULT_EVENT_TYPES
+          end
+
+          # Return the list of event filters hooks
+          def event_filters
+            return @event_filters if defined? @event_filters
+            superclass.try(:event_filters) || {}
+          end
+
+          protected
+
+            # Attach a new key based event filter
+            def event_filter(key, sanitizer = nil, &block)
+              @event_filters ||= superclass.try(:event_filters)&.dup || {}
+              @event_filters[key.to_sym] = { block: block, sanitizer: sanitizer }
+            end
+        end
+
+        # Enhance the event by evolving the block to a
+        # {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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module that allows other objects to hold directives during the
+      # definition process
+      module WithDirectives
+        def self.extended(other)
+          other.extend(Helpers::InheritedCollection)
+          other.extend(WithDirectives::DirectiveLocation)
+          other.inherited_collection(:directives)
+        end
+
+        def self.included(other)
+          other.extend(WithDirectives::DirectiveLocation)
+          other.define_method(:directives) { @directives ||= Set.new }
+          other.class_attribute(:directive_location, instance_writer: false)
+        end
+
+        def initialize_copy(orig)
+          super
+
+          @directives = orig.directives.dup
+        end
+
+        module DirectiveLocation
+          # Return the symbol that represents the location that the directives
+          # must have in order to be added to the list
+          def directive_location
+            defined?(@directive_location) \
+              ? @directive_location \
+              : superclass.try(:directive_location)
+          end
+
+          # Use this once to define the directive location
+          def directive_location=(value)
+            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
+              Unable to find the #{item_or_symbol.inspect} directive.
+            MSG
+
+            list = [directive.new(**xargs)]
+          else
+            list << item_or_symbol
+          end
+
+          current = try(:all_directives) || @directives
+          items = GraphQL.directives_to_set(list, current, source: self)
+          directives.merge(items)
+        rescue DefinitionError => e
+          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.
+          MSG
+
+          all_directives.any? { |item| item.is_a?(directive) }
+        end
+
+        alias has_directive? using?
+
+        # 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
+        end
+
+        # 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
+          end
+        end
+
+        # Validate all the directives to make sure the definition is valid
+        def validate!(*)
+          super if defined? super
+
+          return unless defined? @directives
+          @directives.each(&:validate!)
+          @directives.freeze
+        end
+
+        private
+
+          # Find a directive for its symbolized name
+          def fetch!(name)
+            GraphQL.type_map.fetch!(name,
+              base_class: :Directive,
+              namespaces: namespaces,
+              prevent_register: try(:owner) || self,
+            )
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module that allows other objects to hold events, either from a
+      # singleton point-of-view, or for instances
+      module WithEvents
+        def self.extended(other)
+          other.extend(Helpers::InheritedCollection)
+          other.extend(WithEvents::FixedTypes)
+
+          other.inherited_collection(:events, type: :hash_array)
+          other.inherited_collection(:listeners)
+        end
+
+        def self.included(other)
+          other.extend(WithEvents::FixedTypes)
+          other.delegate(:event_types, to: :class)
+
+          other.define_method(:events) { @events ||= Hash.new { |h, k| h[k] = [] } }
+          other.define_method(:listeners) { @listeners ||= Set.new }
+        end
+
+        # Helper module to define static list of valid event types
+        module FixedTypes
+          # Set or get the list of possible event types when attaching events
+          def event_types(*list, append: false, expose: false)
+            return (defined?(@event_types) && @event_types.presence) ||
+              superclass.try(:event_types) if list.blank? 
+
+            list = event_types if append
+            list += list.flatten.compact.map(&:to_sym)
+            @event_types = list.uniq.freeze
+            expose_events! if expose
+            @event_types
+          end
+
+          protected
+
+            # Auxiliar method that creates easy-accessible callback assignment
+            def expose_events!
+              event_types.each do |event_name|
+                next if method_defined?(event_name)
+                define_method(event_name) do |*args, **xargs, &block|
+                  on(event_name, *args, **xargs, &block)
+                end
+              end
+            end
+        end
+
+        # Mostly for correct inheritance on instances
+        def all_events
+          current = (@events || {})
+          return current unless defined? super
+          Helpers.merge_hash_array(current, super)
+        end
+
+        # Mostly for correct inheritance on instances
+        def all_listeners
+          current = (defined?(@listeners) && @listeners) || Set.new
+          defined?(super) ? (current + super) : current
+        end
+
+        # Add a new event listener for the given +event_name+. It is possible
+        # to prepend the event by setting +unshift: true+. This checks if the
+        # event name is a valid one due to +event_types+.
+        def on(event_name, unshift: false, &block)
+          event_name = event_name.to_sym
+          valid = !event_types || event_types.include?(event_name)
+          raise ArgumentError, <<~MSG.squish unless valid
+            The #{event_name} is not a valid event type.
+          MSG
+
+          listeners << event_name
+          events[event_name].send(unshift ? :unshift : :push, block)
+        end
+      end
+    end
+  end
+end