rails-graphql 0.2.0 → 1.0.0.beta

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Source Active Record
     #
     # This source allows the translation of active record objects into a new
@@ -10,20 +10,23 @@ module Rails # :nodoc:
     # 2. 1 Input
     # 3. 2 Query fields (ingular and plural)
     # 4. 3 Mutation fields (create, update, destroy)
-    class Source::ActiveRecordSource < Source
+    class Source::ActiveRecordSource < Source::Base
       include Source::ScopedArguments
 
       require_relative 'active_record/builders'
       extend Builders
 
       validate_assignment('ActiveRecord::Base') do |value|
-        "The \"#{value.name}\" is not a valid Active Record model"
+        +"The \"#{value.name}\" is not a valid Active Record model"
       end
 
+      # Mark if the objects created from this source will build fields for
+      # associations associated to the object
+      class_attribute :with_associations, instance_accessor: false, default: true
+
       # The name of the class (or the class itself) to be used as superclass for
       # the generate GraphQL interface type of this source
-      class_attribute :interface_class, instance_writer: false
-      alias interface interface_class
+      class_attribute :interface_class, instance_accessor: false
 
       %i[object interface input].each do |type|
         settings = { abstract: true, with_owner: true }
@@ -31,23 +34,22 @@ module Rails # :nodoc:
       end
 
       self.abstract = true
+      self.hook_names = hook_names.to_a.insert(1, :enums).to_set
 
-      delegate :primary_key, :singular, :plural, :model, to: :class
+      delegate :primary_key, :singular, :plural, :model, :id_columns, to: :class
 
-      skip_on :input, :created_at, :updated_at
+      skip_from(:input, :created_at, :updated_at)
 
-      on :start do
-        GraphQL.enable_ar_adapter(adapter_name)
-        build_enum_types
-      end
+      step(:start) { GraphQL.enable_ar_adapter(adapter_name) }
+      step(:enums) { build_enum_types }
 
-      on :object do
+      step(:object) do
         build_attribute_fields(self)
         build_reflection_fields(self)
       end
 
-      on :input do
-        extra = { primary_key => { null: true } }
+      step(:input) do
+        extra = GraphQL.enumerate(primary_key).entries.product([{ null: true }]).to_h
         build_attribute_fields(self, **extra)
         build_reflection_inputs(self)
 
@@ -61,47 +63,39 @@ module Rails # :nodoc:
         end
       end
 
-      on :query do
+      step(:query) do
+        build_object
+
         safe_field(plural, object, full: true) do
-          before_resolve :load_records
+          before_resolve(:load_records)
         end
 
         safe_field(singular, object, null: false) do
-          argument primary_key, :id, null: false
-          before_resolve :load_record
+          build_primary_key_arguments(self)
+          before_resolve(:load_record)
         end
       end
 
-      on :mutation do
+      step(:mutation) do
+        build_object
+        build_input
+
         safe_field("create_#{singular}", object, null: false) do
-          argument singular, input, null: false
-          perform :create_record
+          argument(singular, input, null: false)
+          perform(:create_record)
         end
 
         safe_field("update_#{singular}", object, null: false) do
-          argument primary_key, :id, null: false
-          argument singular, input, null: false
-          before_resolve :load_record
-          perform :update_record
+          build_primary_key_arguments(self)
+          argument(singular, input, null: false)
+          before_resolve(:load_record)
+          perform(:update_record)
         end
 
         safe_field("delete_#{singular}", :boolean, null: false) do
-          argument primary_key, :id, null: false
-          before_resolve :load_record
-          perform :destroy_record
-        end
-      end
-
-      on :finish do
-        attach_fields!
-        attach_scoped_arguments_to(query_fields.values)
-        attach_scoped_arguments_to(mutation_fields.values)
-
-        next if model.base_class == model
-
-        # TODO: Allow nested inheritance for setting up implementation
-        type_map_after_register(model.base_class.name) do |type|
-          object.implements(type) if type.interface?
+          build_primary_key_arguments(self)
+          before_resolve(:load_record)
+          perform(:destroy_record)
         end
       end
 
@@ -110,10 +104,11 @@ module Rails # :nodoc:
         delegate :singular, :plural, :param_key, to: :model_name
         delegate :adapter_name, to: 'model.connection'
 
+        alias interface interface_class
         alias model assigned_class
         alias model= assigned_to=
 
-        # Set the assignemnt to a model with a similar name as the source
+        # Set the assignment to a model with a similar name as the source
         def assigned_to
           @assigned_to ||= name.delete_prefix('GraphQL::')[0..-7]
         end
@@ -125,26 +120,38 @@ module Rails # :nodoc:
         end
 
         # Just a little override to ensure that both model and table are ready
-        def build!
+        def build!(*)
           super if model&.table_exists?
         end
 
+        # Hook into the unregister to clean enums
+        def unregister!
+          super
+          @enums = nil
+        end
+
         protected
 
           # Check if a given +attr_name+ is associated with a presence validator
-          # but ignores when there is a default value
+          # (that does not include +if+ nor +unless+), but ignores when there is
+          # a default value
           def attr_required?(attr_name)
             return true if attr_name.eql?(primary_key)
             return false if model.columns_hash[attr_name]&.default.present?
             return false unless model._validators.key?(attr_name.to_sym)
-            model._validators[attr_name.to_sym].any?(presence_validator)
+
+            model._validators[attr_name.to_sym].any? do |validator|
+              validator.is_a?(presence_validator) &&
+                !(validator.options[:if] ||
+                  validator.options[:unless])
+            end
           rescue ::ActiveRecord::StatementInvalid
             false
           end
 
         private
 
-          def presence_validator # :nodoc:
+          def presence_validator
             ::ActiveRecord::Validations::PresenceValidator
           end
       end
@@ -155,8 +162,9 @@ module Rails # :nodoc:
       end
 
       # Prepare to load a single record from the underlying table
-      def load_record(scope = model.default_scoped)
-        scope.find(event.argument(primary_key))
+      def load_record(scope = model.default_scoped, find_by: nil)
+        find_by ||= { primary_key => event.argument(primary_key) }
+        inject_scopes(scope, :relation).find_by(find_by)
       end
 
       # Get the chain result and preload the records with thre resulting scope
@@ -212,23 +220,31 @@ module Rails # :nodoc:
 
         # Preload the records for a given +association+ using the current value.
         # It can be further specified with a given +scope+
+        # TODO: On Rails 7 we can use the Preloader::Branch class
         def preload(association, scope = nil)
           reflection = model._reflect_on_association(association)
           records = current_value.is_a?(preloader_association) \
             ? current_value.preloaded_records \
             : Array.wrap(current_value.itself).compact
 
-          ar_preloader.send(:preloaders_for_reflection, reflection, records, scope).first
+          klass = preload_class(reflection)
+          args = [reflection.klass, records, reflection, scope]
+          args << nil if klass.instance_method(:initialize).arity == 6 # Rails 7
+          klass.new(*args, true).run
         end
 
-        # Get the cached instance of active record prelaoder
-        def ar_preloader
-          event.request.cache(:ar_preloader) { ::ActiveRecord::Associations::Preloader.new }
+        # Get the cached instance of active record preloader
+        def preload_class(reflection)
+          if reflection.options[:through]
+            ::ActiveRecord::Associations::Preloader::ThroughAssociation
+          else
+            ::ActiveRecord::Associations::Preloader::Association
+          end
         end
 
       private
 
-        def preloader_association # :nodoc:
+        def preloader_association
           ActiveRecord::Associations::Preloader::Association
         end
     end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Source
+      class Base < GraphQL::Source
+        extend Helpers::WithSchemaFields
+        extend Helpers::WithAssignment
+        extend Helpers::Unregisterable
+
+        self.abstract = true
+
+        # 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_accessor: 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_accessor: false,
+          default: '::Rails::GraphQL::Type::Input'
+
+        # Allow defining a name for the object without going to many troubles
+        # like overriding methods
+        class_attribute :object_name, instance_accessor: false
+
+        # Allow defining a name for the input without going to many troubles
+        # like overriding methods
+        class_attribute :input_name, instance_accessor: false
+
+        class << self
+
+          # Unregister all objects that this source was providing
+          def unregister!
+            GraphQL.type_map.unregister(*created_types) if defined?(@created_types)
+            @object = @input = nil
+          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 current class
+          def object
+            @object ||= create_type(superclass: object_class, gql_name: object_name)
+          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 current class
+          def input
+            @input ||= create_type(superclass: input_class, gql_name: input_name)
+          end
+
+          protected
+
+            # 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
+              gql_name = xargs.delete(:gql_name)
+              Schema.send(:create_type, name, superclass, **xargs) do
+                include Helpers::WithOwner if with_owner
+                set_namespaces(*source.namespaces)
+
+                instance_variable_set(:@gql_name, gql_name) unless gql_name.nil?
+
+                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.tap { |klass| created_types << klass }
+            end
+
+          private
+
+            # Keep track of all the types created byt this source
+            def created_types
+              @created_types ||= []
+            end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# 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
+
+          import_skips_for(type, xargs)
+
+          build!(type, *args, **xargs, &block) unless built?(type)
+        end
+
+        protected
+
+          # Store the list of built steps
+          def built
+            @built ||= Set.new
+          end
+
+          # Make sure to mark the hook name as built
+          def run_hooks(hook_name, *)
+            super
+          ensure
+            built << hook_name
+          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)
+
+            catch(:skip) { run_hooks(:start) } unless built?(:start)
+            catch(:skip) { run_hooks(type, hook_scope_for(type)) }
+
+            built << type.to_sym
+          end
+
+          # Get the correct +self_object+ for the hook instance
+          def hook_scope_for(type)
+            type = type.to_sym
+            object =
+              if Helpers::WithSchemaFields::TYPE_FIELD_CLASS.key?(type)
+                Helpers::WithSchemaFields::ScopedConfig.new(self, type)
+              else
+                Helpers::AttributeDelegator.new(self, type)
+              end
+
+            Source::ScopedConfig.new(self, object, 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,26 +12,37 @@ 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
+          @fields = GraphQL.enumerate(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|
+          @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 : {}
@@ -45,11 +53,11 @@ module Rails # :nodoc:
           # 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)
+            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 +77,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