rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/source/builder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Source
+      module Builder
+
+        # Check if the object was already built
+        def built?(part = nil)
+          defined?(@built) && @built.present? &&
+            (part.nil? || @built.include?(part.to_sym))
+        end
+
+        # Build all from all descendant sources
+        def build_all_sources
+          descendants.each(&:build_all)
+        end
+
+        # Trigger a safe build of everything
+        def build_all
+          build_all! unless abstract?
+        end
+
+        # Allows building anything that is in hooks
+        def respond_to_missing?(method_name, *)
+          return super unless method_name.to_s.start_with?('build_') &&
+            hook_names.include?(method_name.to_s[6..-1].to_sym)
+        end
+
+        # Allow fast creation of values
+        def method_missing(method_name, *args, **xargs, &block)
+          return super unless method_name.to_s.start_with?('build_')
+
+          type = method_name.to_s[6..-1]
+          type = type.singularize unless hook_names.include?(type.to_sym)
+          type = type.to_sym
+          return if built?(type)
+
+          import_skips_for(type, xargs)
+          build!(type, *args, **xargs, &block)
+        end
+
+        protected
+
+          # Store the list of built steps
+          def built
+            @built ||= Set.new
+          end
+
+        private
+
+          # Import all options-based settings for skipping field
+          def import_skips_for(type, options)
+            return if type == :all
+
+            if !(values = options.delete(:except)).nil?
+              segmented_skip_fields[type] += GraphQL.enumerate(values).map do |value|
+                value.to_s.underscore
+              end
+            end
+
+            if !(values = options.delete(:only)).nil?
+              segmented_only_fields[type] += GraphQL.enumerate(values).map do |value|
+                value.to_s.underscore
+              end
+            end
+          end
+
+          # Build all the hooks if it's not built
+          def build_all!
+            catch(:done) do
+              hook_names.to_enum.drop(1).each do |hook|
+                send("build_#{hook}")
+              end
+            end
+          end
+
+          # Check if the build process can happen
+          def ensure_build!(type)
+            raise DefinitionError, (+<<~MSG).squish if hook_names.exclude?(type)
+              #{self.name} doesn't know how build #{type}, hook not proper defined.
+            MSG
+
+            raise DefinitionError, (+<<~MSG).squish if abstract
+              Abstract source #{name} cannot be built.
+            MSG
+
+            raise DefinitionError, (+<<~MSG).squish if built?(type)
+              The #{type} part is already built.
+            MSG
+          end
+
+          # Build all the objects associated with this source
+          def build!(type)
+            ensure_build!(type)
+            built << type
+
+            schema_type = Helpers::WithSchemaFields::TYPE_FIELD_CLASS.key?(type)
+            catch(:skip) { run_hooks(:start) } unless built?(:start)
+            catch(:skip) { run_hooks(type, hook_scope_for(type, schema_type)) }
+
+            attach_fields!(type, fields_for(type)) if schema_type && fields_for?(type)
+          end
+
+          # Get the correct +self_object+ for the hook instance
+          def hook_scope_for(type, schema_type)
+            type = type.to_sym
+            klass = schema_type ? 'WithSchemaFields::ScopedConfig' : 'AttributeDelegator'
+            Source::ScopedConfig.new(self, Helpers.const_get(klass).new(self, type), type)
+          end
+
+      end
+    end
+  end
+end

data/lib/rails/graphql/source/scoped_arguments.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # This is a helper class that allows sources to have scoped-based arguments,
     # meaning that when an argument is present, it triggers the underlying block
     # on the fields where the argument was attached to
-    #
-    # TODO: Easy the usage of scoped arguments with AR, to map model scopes as
-    # arguments using the abilities here provided
     module Source::ScopedArguments
       def self.included(other)
         other.extend(ClassMethods)
@@ -15,41 +12,58 @@ module Rails # :nodoc:
 
       # Extended argument class to be the instance of the scoped
       class Argument < GraphQL::Argument
-        attr_reader :block, :fields
-
-        def initialize(*args, on: nil, **xargs, &block)
+        def initialize(*args, block:, on: nil, **xargs)
           super(*args, **xargs)
 
-          @block = block
-          @fields = Array.wrap(on).presence
+          @block = (block == true) ? name : block
+          @fields = on
+        end
+
+        # Apply the argument block to the given object, using or not the value
+        def apply_to(object, value)
+          callable = @block.is_a?(Symbol) ? object.method(@block) : @block
+          raise ::ArgumentError, (+<<~MSG) unless callable.respond_to?(:call)
+            Unable to call "#{@block.inspect}" on #{object.class}.
+          MSG
+
+          args = (callable.arity == 1 || callable.arity == -1) ? [value] : nil
+
+          return callable.call(*args) if callable.is_a?(Method)
+          object.instance_exec(*args, &callable)
         end
 
         # Check if the argument should be attached to the given +field+
         def attach_to?(field)
-          return true if fields.nil?
+          return true if @fields.nil?
 
-          fields.any? do |item|
+          GraphQL.enumerate(@fields).any? do |item|
             (item.is_a?(Symbol) && field.name.eql?(item)) || field.gql_name.eql?(item)
           end
         end
       end
 
-      module ClassMethods # :nodoc:
+      module ClassMethods
         # Return the list of scoped params defined
         def scoped_arguments
           defined?(@scoped_arguments) ? @scoped_arguments : {}
         end
 
+        # Hook into the attach fields process to attach the scoped arguments
+        def attach_fields!(type, fields)
+          attach_scoped_arguments_to(fields.values)
+          super
+        end
+
         protected
 
           # Add a new scoped param to the list
           def scoped_argument(param, type = :string, proc_method = nil, **settings, &block)
-            block = proc_method if proc_method.present? && block.nil?
-            argument = Argument.new(param, type, **settings, owner: self, &block)
+            block ||= proc_method if proc_method.present?
+            argument = Argument.new(param, type, **settings, owner: self, block: block)
             (@scoped_arguments ||= {})[argument.name] = argument
           end
 
-          alias scoped_arg scoped_arguments
+          alias scoped_arg scoped_argument
 
           # Helper method to attach the scoped arguments to a given +field+
           def attach_scoped_arguments_to(*fields, safe: true)
@@ -69,14 +83,18 @@ module Rails # :nodoc:
       # Find all the executable arguments attached to the running field and
       # call them with the given object
       def inject_scopes(object, assigned_to = nil)
-        return object if event.field.nil? || (args_source = event.send(:args_source)).nil?
+        return object if event.field.nil? || (field_args = event.field.all_arguments).blank?
 
+        args_source = event.send(:args_source)
         event.data[assigned_to] ||= object unless assigned_to.nil?
-        event.field.all_arguments.each_value.inject(object) do |result, argument|
-          next result unless argument.respond_to?(:block) && args_source.key?(argument.name)
-          send_args = argument.block.arity.eql?(1) ? [args_source[argument.name]] : []
+        field_args.each_value.inject(object) do |result, argument|
+          arg_value = args_source.key?(argument.name) \
+            ? args_source[argument.name] \
+            : argument.default
+
+          next result if arg_value.nil? || !argument.is_a?(Argument)
 
-          value = result.instance_exec(*send_args, &argument.block)
+          value = argument.apply_to(result, arg_value)
           value = value.nil? ? result : value
 
           assigned_to.nil? ? value : event.data[assigned_to] = value

data/lib/rails/graphql/source.rb

@@ -1,29 +1,37 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Source
     #
     # Source is an abstract object that can contains fields, objects, and
-    # informations that them are delivered to the relative schemas throughout
-    # proxies, ensuring that it still kepps the main ownership of the objects
+    # information that them are delivered to the relative schemas throughout
+    # proxies, ensuring that it still keeps the main ownership of the objects
     class Source
       extend ActiveSupport::Autoload
 
       extend Helpers::InheritedCollection
-      extend Helpers::WithSchemaFields
-      extend Helpers::WithAssignment
       extend Helpers::WithNamespace
+      extend Helpers::WithEvents
+      extend Helpers::WithCallbacks
 
-      DEFAULT_NAMESPACES = %i[base].freeze
+      include Helpers::Instantiable
 
-      eager_autoload do
-        autoload :ScopedArguments
+      autoload :Base
+      autoload :Builder
 
-        autoload :ActiveRecordSource
-      end
+      autoload :ScopedArguments
+      autoload :ActiveRecordSource
+
+      extend Source::Builder
+
+      # Helper class to be used as the +self+ in configuration blocks
+      ScopedConfig = Struct.new(:receiver, :self_object, :type) do
+        def safe_field(name, *args, **xargs, &block)
+          return if receiver.send(:skip_field?, name, on: type)
+          self_object.safe_field(name, *args, **xargs, &block)
+        end
 
-      ScopedConfig = Struct.new(:receiver, :self_object) do # :nodoc: all
         def respond_to_missing?(method_name, include_private = false)
           self_object.respond_to?(method_name, include_private) ||
             receiver.respond_to?(method_name, include_private)
@@ -39,53 +47,34 @@ module Rails # :nodoc:
       # If a source is marked as abstract, it means that it generates a new
       # source describer and any non-abstract class inherited from it will be
       # described by this new abstraction
-      class_attribute :abstract, instance_writer: false, default: false
+      class_attribute :abstract, instance_accessor: false, default: false
 
       # List of hook names used while describing a new source. This basically
       # set the order of the execution of the hooks while validating the hooks
-      # callbacks using the +on+ method. Make sure to kepp the +finish+ hook
-      # always at the end of the list
-      class_attribute :hook_names, instance_writer: false,
-        default: %i[start object input query mutation finish].to_set
+      # callbacks using the +on+ method
+      class_attribute :hook_names, instance_accessor: false,
+        default: %i[start object input query mutation subscription].to_set.freeze
 
       # The list of hooks defined in order to describe a source
       inherited_collection :hooks, instance_reader: false, type: :hash_array
 
-      # The name of the class (or the class itself) to be used as superclass for
-      # the generate GraphQL object type of this source
-      class_attribute :object_class, instance_writer: false,
-        default: '::Rails::GraphQL::Type::Object'
-
-      # The name of the class (or the class itself) to be used as superclass for
-      # the generate GraphQL input type of this source
-      class_attribute :input_class, instance_writer: false,
-        default: '::Rails::GraphQL::Type::Input'
-
-      # Mark if the objects created from this source will build fields for
-      # associations associated to the object
-      class_attribute :with_associations, instance_writer: false, default: true
-
       # A list of fields to skip when performing shared methods
-      inherited_collection :skip_fields, instance_reader: false
+      inherited_collection :skip_fields, instance_reader: false, type: :set
 
       # A list of fields to skip but segmented by holder source
       inherited_collection :segmented_skip_fields, instance_reader: false, type: :hash_set
 
-      # The purpose of instantiating a source is to have access to its public
-      # methods. It then runs from the strategy perspective, pointing out any
-      # other methods to the manually set event
-      delegate_missing_to :event
-      attr_reader :event
+      # A list of fields that should only be included. Available only when using
+      # individual builders
+      inherited_collection :segmented_only_fields, instance_reader: false, type: :hash_set
 
       self.abstract = true
 
       class << self
-        attr_reader :schemas
+        delegate :field, :proxy_field, :overwrite_field, :field?, :field_names,
+          :gql_name, to: :object
 
-        delegate :field, :proxy_field, :overwrite_field, :[], :field?,
-          :field_names, :gql_name, to: :object
-
-        def kind # :nodoc:
+        def kind
           :source
         end
 
@@ -96,27 +85,19 @@ module Rails # :nodoc:
 
         # Get the main name of the source
         def base_name
-          name.demodulize[0..-7] unless abstract?
-        end
-
-        # Wait the end of the class in order to create the objects
-        def inherited(subclass)
-          subclass.abstract = false
-          super if defined? super
-
-          pending[subclass] ||= caller(1).find do |item|
-            !item.end_with?("`inherited'")
-          end
+          name.demodulize[0..-7]
         end
 
+        # :singleton-method:
         # Find a source for a given object. If none is found, then raise an
         # exception
         def find_for!(object)
-          find_for(object) || raise(::ArgumentError, <<~MSG.squish)
+          find_for(object) || raise(::ArgumentError, (+<<~MSG).squish)
             Unable to find a source for "#{object.name}".
           MSG
         end
 
+        # :singleton-method:
         # Using the list of +base_sources+, find the first one that can handle
         # the given +object+
         def find_for(object)
@@ -124,60 +105,33 @@ module Rails # :nodoc:
           base_sources.reverse_each.find { |source| object <= source.assigned_class }
         end
 
-        # Return the GraphQL object type associated with the source. It will
-        # create one if it's not defined yet. The created class will be added
-        # to the +::GraphQL+ namespace with the addition of any namespace of the
-        # currect class
-        def object
-          @object ||= create_type(superclass: object_class)
-        end
-
-        # Return the GraphQL input type associated with the source. It will
-        # create one if it's not defined yet. The created class will be added
-        # to the +::GraphQL+ namespace with the addition of any namespace of the
-        # currect class
-        def input
-          @input ||= create_type(superclass: input_class)
-        end
-
-        # Check if the object was already built
-        def built?
-          defined?(@built) && !!@built
-        end
+        # Add a new description hook. You can use +throw :skip+ and skip
+        # parent hooks. If the class is already built, then execute the hook.
+        # Use the +unshift: true+ to add the hook at the beginning of the
+        # list, which will then be the last to run
+        def step(hook_name, unshift: false, &block)
+          raise ArgumentError, (+<<~MSG).squish unless hook_names.include?(hook_name.to_sym)
+            The #{hook_name.inspect} is not a valid hook method.
+          MSG
 
-        # Checks if a given method can act as resolver
-        def gql_resolver?(method_name)
-          (instance_methods - GraphQL::Source.instance_methods).include?(method_name)
+          if built?(hook_name)
+            hook_scope_for(hook_name).instance_exec(&block)
+          else
+            hooks[hook_name.to_sym].public_send(unshift ? :unshift : :push, block)
+          end
         end
 
         # Attach all defined schema fields into the schemas using the namespaces
         # configured for the source
-        def attach_fields!
-          refresh_schemas!
-          schemas.each_value do |schema|
-            Helpers::WithSchemaFields::SCHEMA_FIELD_TYPES.keys.each do |type|
-              list = public_send("#{type}_fields")
-              next if list.empty?
-
-              list.each_value do |field|
-                next if schema.has_field?(type, field)
-                schema.add_proxy_field(type, field)
-              end
-            end
-          end
+        def attach_fields!(type = :all, from = self)
+          schemas.each { |schema| schema.import_into(type, from) }
         end
 
         # Find all the schemas associated with the configured namespaces
-        def refresh_schemas!
-          @schemas = (namespaces.presence || DEFAULT_NAMESPACES).map do |ns|
-            (schema = Schema.find(ns)).present? ? [ns, schema] : nil
-          end.compact.to_h
-        end
-
-        def eager_load! # :nodoc:
-          super
-
-          build_pending!
+        def schemas
+          GraphQL.enumerate(namespaces.presence || :base).lazy.filter_map do |ns|
+            Schema.find(ns)
+          end
         end
 
         protected
@@ -191,78 +145,23 @@ module Rails # :nodoc:
           end
 
           # A little bypass to the actual type map after register method which
-          # just add the namesapace by default
+          # just add the namespace by default
           # See {TypeMap#after_register}[rdoc-ref:Rails::GraphQL::TypeMap#after_register]
           def type_map_after_register(*args, **xargs, &block)
             xargs[:namespaces] ||= namespaces
             GraphQL.type_map.after_register(*args, **xargs, &block)
           end
 
-          # A helper method to create an enum type
-          def create_enum(enum_name, values, **xargs, &block)
-            enumerator = values.each_pair if values.respond_to?(:each_pair)
-            enumerator ||= values.each.with_index
-
-            xargs = xargs.reverse_merge(once: true)
-            create_type(:enum, as: enum_name.classify, **xargs) do
-              indexed! if enumerator.first.last.is_a?(Numeric)
-              enumerator.sort_by(&:last).map(&:first).each(&method(:add))
-              instance_exec(&block) if block.present?
-            end
-          end
-
-          # Helper method to create a class based on the given type and allows
-          # several other settings to be executed on it
-          def create_type(type = nil, **xargs, &block)
-            name = "#{gql_module.name}::#{xargs.delete(:as) || base_name}"
-            superclass = xargs.delete(:superclass)
-            with_owner = xargs.delete(:with_owner)
-
-            if superclass.nil?
-              superclass = type.to_s.classify
-            elsif superclass.is_a?(String)
-              superclass = superclass.constantize
-            end
-
-            source = self
-            Schema.send(:create_type, name, superclass, **xargs) do
-              include Helpers::WithOwner if with_owner
-              set_namespaces(*source.namespaces)
-
-              self.owner = source if respond_to?(:owner=)
-              self.assigned_to = source.safe_assigned_class \
-                if source.assigned? && is_a?(Helpers::WithAssignment)
-
-              instance_exec(&block) if block.present?
-            end
-          end
-
           # Add fields to be skipped on the given +source+ as the segment
-          def skip_on(source, *fields)
+          def skip_from(source, *fields)
             segmented_skip_fields[source] += fields.flatten.compact.map(&:to_sym).to_set
           end
 
-          # Add a new description hook. You can use +throw :skip+ and skip
-          # parent hooks. If the class is already built, then execute the hook.
-          # Use the +unshift: true+ to add the hook at the beginning of the
-          # list, which will then be the last to run
-          def on(hook_name, unshift: false, &block)
-            raise ArgumentError, <<~MSG.squish unless hook_names.include?(hook_name.to_sym)
-              The #{hook_name.inspect} is not a valid hook method.
-            MSG
-
-            if built?
-              send("run_#{hook_name}_hooks", block)
-            else
-              hooks[hook_name.to_sym].public_send(unshift ? :unshift : :push, block)
-            end
-          end
-
           # Creates a hook that throws a done action, preventing any parent hooks
           def skip(*names)
             names.each do |hook_name|
               hook_name = hook_name.to_s.singularize.to_sym
-              on(hook_name) { throw :skip }
+              step(hook_name) { throw :skip }
             end
           end
 
@@ -270,106 +169,69 @@ module Rails # :nodoc:
           # +on hook_name do; end+
           def override(hook_name, &block)
             skip(hook_name)
-            on(hook_name, &block)
+            step(hook_name, &block)
           end
 
           # It's an alternative to +self.hook_names -= %i[*names]+ which
           # disables a specific hook
           def disable(*names)
-            self.hook_names -= names.flatten.map do |hook_name|
+            list = names.flatten.map do |hook_name|
               hook_name.to_s.singularize.to_sym
             end
+
+            self.hook_names = (hook_names - list).freeze
           end
 
           # It's an alternative to +self.hook_names += %i[*names]+ which
           # enables additional hooks
           def enable(*names)
-            self.hook_names += names.flatten.map do |hook_name|
+            list = names.flatten.map do |hook_name|
               hook_name.to_s.singularize.to_sym
             end
-          end
 
-          # Return the module where the GraphQL types should be created at
-          def gql_module
-            name.starts_with?('GraphQL::') ? module_parent : ::GraphQL
+            self.hook_names = (hook_names + list).freeze
           end
 
-          # Get the list of fields to be skipped from the given +holder+ as the
-          # segment source
-          def skips_for(holder)
-            segment = holder.kind
-            segment = :input if segment.eql?(:input_object)
-            segmented = all_segmented_skip_fields[segment]
-            segmented.present? ? all_skip_fields + segmented : all_skip_fields
-          end
-
-        private
+          # Add one or more fields to the list of fields that needs to be
+          # ignored in all places. It converts strings to underscore
+          def skip_fields!(*list)
+            list = list.flatten.map do |value|
+              value.is_a?(Symbol) ? value.to_s : value.to_s.underscore
+            end
 
-          # The list of pending sources to be built asscoaited to where they
-          # were defined
-          def pending
-            @@pending ||= {}
+            self.skip_fields.merge(list)
           end
 
-          # Check if there are pending sources to be built
-          def pending?
-            pending.any?
-          end
+          # Check if a given field +name+ should be skipped on the give type
+          def skip_field?(name, on:)
+            on = :input if on == :input_object
+            name = name.to_s.underscore
 
-          # Build the pending sources
-          def build_pending!
-            while (klass, = pending.shift)
-              klass.send(:build!) unless klass.abstract?
-            end
+            all_skip_fields&.include?(name) ||
+              all_segmented_skip_fields.try(:[], on)&.include?(name) ||
+              all_segmented_only_fields.try(:[], on)&.exclude?(name)
           end
 
-          # Find all classes that inherits from source that are abstract,
-          # meaning that they are a base sources
-          def base_sources
-            @@base_sources ||= begin
-              eager_load!
-              descendants.select(&:abstract?).to_set
+          # Run a list of hooks using the +source+ as the instance of the block
+          def run_hooks(hook_name, source = self)
+            all_hooks.try(:[], hook_name.to_sym)&.reverse_each do |block|
+              source.instance_exec(&block)
             end
           end
 
-          # Build all the objects associated with this source
-          def build!
-            return if built?
-
-            raise DefinitionError, <<~MSG.squish if abstract
-              Abstract source #{name} cannot be built.
-            MSG
-
-            @built = true
-
-            catch(:done) do
-              hook_names.each do |hook_name|
-                break if hook_name === :finish
-                catch(:skip) { send("run_#{hook_name}_hooks") }
-              end
-            end
+        private
 
-            catch(:skip) { send(:run_finish_hooks) } if respond_to?(:run_finish_hooks, true)
+          # Make sure to reset the value of +abstract+
+          def inherited(subclass)
+            subclass.abstract = false
+            super if defined? super
           end
 
-          {
-            start:        'self',
-            finish:       'self',
-            object:       'Helpers::AttributeDelegator.new(self, :object)',
-            input:        'Helpers::AttributeDelegator.new(self, :input)',
-            query:        format('schema_scoped_config(self, %s)', ':query'),
-            mutation:     format('schema_scoped_config(self, %s)', ':mutation'),
-            subscription: format('schema_scoped_config(self, %s)', ':subscription'),
-          }.each do |key, object|
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def run_#{key}_hooks(list = nil)
-                source_config = Source::ScopedConfig.new(self, #{object})
-                Array.wrap(list.presence || all_hooks[:#{key}]).reverse_each do |block|
-                  source_config.instance_exec(&block)
-                end
-              end
-            RUBY
+          # Constantize all the base sources that were defined in the settings
+          def base_sources
+            @@base_sources ||= GraphQL.config.sources.map(&:constantize).to_set
           end
+
       end
     end
   end