rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/source/active_record/builders.rb

@@ -4,21 +4,17 @@ module Rails
   module GraphQL
     # All the helper methods for building the source
     module Source::ActiveRecordSource::Builders
-      # Override the object class to identify interfaces due to STI
-      def object_class
-        sti_interface? ? interface_class : super
-      end
-
-      # Get all unique attribute names that exists in the current model
-      def reflection_attributes(holder)
-        items = []
-        each_reflection(holder) do |item|
-          next unless item.belongs_to?
-          next items << item.foreign_key.to_s unless item.polymorphic?
-          items += [item.foreign_type, item.foreign_key]
+      # List of all columns that should be threated as IDs
+      # TODO: Add a exclusive cache for the build process
+      def id_columns
+        @id_columns ||= begin
+          result = Set.new(GraphQL.enumerate(primary_key))
+          each_reflection.each_with_object(result) do |item, arr|
+            next unless item.belongs_to?
+            arr << item.foreign_key.to_s
+            arr << item.foreign_key if item.polymorphic?
+          end
         end
-
-        items.compact.flatten.unshift(primary_key)
       end
 
       # Iterate over all the attributes, except the primary key, from the model
@@ -27,26 +23,32 @@ module Rails
       def each_attribute(holder, skip_primary_key = true)
         adapter_key = GraphQL.ar_adapter_key(adapter_name)
 
-        skip_fields = skips_for(holder).map(&:to_s)
+        skip_fields = Set.new
         skip_fields << model.inheritance_column
         skip_fields << primary_key unless skip_primary_key
 
-        send("#{adapter_key}_attributes") do |attribute, *args|
-          yield attribute, *args unless skip_fields.include?(attribute)
+        send(:"#{adapter_key}_attributes") do |attribute, *args, **xargs|
+          yield(attribute, *args, **xargs) unless skip_fields.include?(attribute)
         end
       end
 
       # Iterate over all the model reflections
-      # TODO: Turn into an enumerator
-      def each_reflection(holder)
-        skip_fields = skips_for(holder).map(&:to_s)
-        model._reflections.each_value do |reflection|
-          next if skip_fields.include?(reflection.name.to_s)
-
+      def each_reflection(&block)
+        model._reflections.each_value.select do |reflection|
           reflection = model._reflections[reflection.to_s] \
             unless reflection.is_a?(abstract_reflection)
 
-          yield reflection unless reflection.nil?
+          !reflection.nil?
+        end.each(&block)
+      end
+
+      # Build arguments that correctly reflect the primary key, as a single
+      # column or as an array of columns
+      def build_primary_key_arguments(holder)
+        if primary_key.is_a?(::Array)
+          primary_key.each { |key| holder.argument(key, :id, null: false) }
+        else
+          holder.argument(primary_key, :id, null: false)
         end
       end
 
@@ -55,9 +57,7 @@ module Rails
         # Check if the given model is consider an interface due to single table
         # inheritance and the given model is the base class
         def sti_interface?
-          @sti_interface ||= begin
-            model.has_attribute?(model.inheritance_column) && model.base_class == model
-          end
+          model.has_attribute?(model.inheritance_column) && model.base_class == model
         end
 
         # Build all enums associated to the class, collecting them from the
@@ -65,22 +65,22 @@ module Rails
         def build_enum_types
           return remove_instance_variable(:@enums) if enums.blank?
 
-          @enums = enums.map do |attribute, setting|
-            [attribute.to_s, create_enum(attribute.to_s, setting, once: true)]
+          @enums = enums.each_with_object({}) do |(attribute, setting), hash|
+            class_name = base_name + attribute.to_s.classify
+            hash[attribute.to_s] = create_enum(class_name, setting)
           rescue DuplicatedError
             next
-          end.compact.to_h.freeze
+          end.freeze
         end
 
         # Build all necessary attribute fields into the given +holder+
         def build_attribute_fields(holder, **field_options)
-          attributes_as_ids = reflection_attributes(holder)
           each_attribute(holder) do |key, type, **options|
-            next if skip.include?(key) || holder.field?(key)
+            next if holder.has_field?(key) || skip_field?(key, on: holder.kind)
 
             str_key = key.to_s
             type = (defined?(@enums) && @enums.key?(str_key) && @enums[str_key]) ||
-              (attributes_as_ids.include?(str_key) && :id) || type
+              (id_columns.include?(str_key) && :id) || type
 
             options[:null] = !attr_required?(key) unless options.key?(:null)
             holder.field(key, type, **options.merge(field_options[key] || {}))
@@ -89,55 +89,68 @@ module Rails
 
         # Build all necessary reflection fields into the given +holder+
         def build_reflection_fields(holder)
-          each_reflection(holder) do |item|
-            next if holder.field?(item.name)
+          return unless with_associations?
+
+          each_reflection do |item|
+            next if holder.has_field?(item.name) || item.polymorphic? ||
+              skip_field?(item.name, on: holder.kind)
+
             type_map_after_register(item.klass) do |type|
-              next unless (type.object? && type.try(:assigned_to) != item.klass) ||
-                type.interface?
+              next unless type.try(:assigned_to) != item.klass ||
+                type.input_type? || type.leaf_type?
 
               options = reflection_to_options(item)
 
-              if type <= Source::ActiveRecordSource
-                source_name = item.collection? ? type.plural : type.singular
-                proxy_options = options.merge(alias: reflection.name, of_type: :proxy)
+              if item.collection?
+                owner = type.try(:owner)
+                source = owner.is_a?(Helpers::WithSchemaFields) &&
+                  (owner.try(:collection_field) || owner.query_fields.try(:[], item.name))
 
-                if (source = type.query_fields[source_name]).present?
+                if source.present?
+                  proxy_options = options.merge(alias: item.name, of_type: :proxy)
                   field = holder.safe_field(source, **proxy_options)
                 end
               end
 
-              field ||= holder.field(item.name, type, **options)
-              field.before_resolve(:preload_association, item.name)
-              field.before_resolve(:build_association_scope, item.name)
-              field.resolve(:parent_owned_records, item.collection?)
+              if (field ||= holder.safe_field(item.name, type, **options))
+                field.before_resolve(:preload_association, item.name)
+                field.before_resolve(:build_association_scope, item.name)
+                field.resolve(:parent_owned_records, item.collection?)
+              end
             end
           end
         end
 
         # Build all +accepts_nested_attributes_for+ inside the input object
         def build_reflection_inputs(holder)
+          return unless with_associations?
+
+          suffix = GraphQL.config.auto_suffix_input_objects
           model.nested_attributes_options.each_key do |reflection_name|
-            next if (reflection = model._reflect_on_association(reflection_name)).nil?
+            reflection = model._reflect_on_association(reflection_name)
+            next if reflection.nil? || reflection.polymorphic?
 
             expected_name = reflection.klass.name.tr(':', '')
-            expected_name += 'Input' unless expected_name.ends_with?('Input')
+            expected_name += suffix unless expected_name.end_with?(suffix)
+
+            type_map_after_register(expected_name) do |type|
+              next unless type.input?
 
-            type_map_after_register(expected_name) do |input|
               options = reflection_to_options(reflection).merge(null: true)
               field_name = "#{reflection.name}_attributes"
-              holder.safe_field(field_name, input, **options)
+              holder.safe_field(field_name, type, **options)
             end
           end
         end
 
-        # Transform a replection into a field options
+        # Transform a reflection into a field options
         def reflection_to_options(reflection)
           options = { array: reflection.collection? }
 
           required = options[:array]
           required ||= attr_required?(reflection.name)
           required ||= attr_required?(reflection.association_foreign_key) \
-            if reflection.belongs_to?
+            if reflection.belongs_to? && !reflection.options[:optional]
 
           options[:nullable] = !options[:array]
           options[:null] = !required

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

@@ -1,107 +1,116 @@
 # 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
     # source object, creating:
     # 1. 1 Object
     # 2. 1 Input
-    # 3. 2 Query fields (ingular and plural)
+    # 3. 2 Query fields (singular 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
+
+      # Set what type of errors should be exported to the extensions of the
+      # request when trying to save records. False will disable it
+      class_attribute :errors_to_extensions, instance_accessor: false, default: false
+
+      # Marks if the source should be threated as an interface, meaning that
+      # no object will be created, instead an interface will
+      class_attribute :act_as_interface, instance_accessor: false, default: false
+
       # 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 }
+        settings = { abstract: true, owner: true }
         send("#{type}_class=", create_type(type, **settings))
       end
 
       self.abstract = true
+      self.hook_names = hook_names.to_a.insert(1, :enums, :interface).to_set.freeze
+
+      delegate :primary_key, :singular, :plural, :model, :id_columns, to: :class
 
-      delegate :primary_key, :singular, :plural, :model, to: :class
+      skip_from(:input, :created_at, :updated_at)
 
-      skip_on :input, :created_at, :updated_at
+      step(:start) { GraphQL.enable_ar_adapter(adapter_name) }
+      step(:enums) { build_enum_types }
 
-      on :start do
-        GraphQL.enable_ar_adapter(adapter_name)
-        build_enum_types
+      step(:object) do
+        build_attribute_fields(self)
+        build_reflection_fields(self)
       end
 
-      on :object do
+      step(:interface) 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)
 
-        safe_field(model.inheritance_column, :string, null: false) if object.interface?
+        safe_field(model.inheritance_column, :string, null: false) if interface?
         safe_field(:_delete, :boolean, default: false)
 
         reference = model.new
         model.columns_hash.each_value do |column|
           change_field(column.name, default: reference[column.name]) \
-            if column.default.present? && field?(column.name)
+            if column.default.present? && has_field?(column.name)
         end
       end
 
-      on :query do
-        safe_field(plural, object, full: true) do
-          before_resolve :load_records
+      step(:query) do
+        interface? ? build_interface : build_object
+        type = interface? ? interface : object
+
+        safe_field(plural, type, full: true) do
+          before_resolve(:load_records)
         end
 
-        safe_field(singular, object, null: false) do
-          argument primary_key, :id, null: false
-          before_resolve :load_record
+        safe_field(singular, type, null: false) do
+          build_primary_key_arguments(self)
+          before_resolve(:load_record)
         end
       end
 
-      on :mutation do
-        safe_field("create_#{singular}", object, null: false) do
-          argument singular, input, null: false
-          perform :create_record
-        end
+      step(:mutation) do
+        interface? ? build_interface : build_object
+        type = interface? ? interface : object
+        build_input
 
-        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
+        safe_field("create_#{singular}", type, null: false) do
+          argument(singular, input, null: false)
+          perform(:create_record)
         end
 
-        safe_field("delete_#{singular}", :boolean, null: false) do
-          argument primary_key, :id, null: false
-          before_resolve :load_record
-          perform :destroy_record
+        safe_field("update_#{singular}", type, null: false) do
+          build_primary_key_arguments(self)
+          argument(singular, input, null: false)
+          before_resolve(:load_record)
+          perform(:update_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) do |type|
-          object.implements(type) if type.interface?
+        safe_field("delete_#{singular}", :boolean, null: false) do
+          build_primary_key_arguments(self)
+          before_resolve(:load_record)
+          perform(:destroy_record)
         end
       end
 
@@ -110,10 +119,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,41 +135,103 @@ 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
 
+        # Allows setting up an interface instead of an object. Mostly because
+        # some models are better dealt as interfaces than actual objects
+        def interface
+          @interface ||= create_type(superclass: interface_class, gql_name: object_name)
+        end
+
+        # Checks if the source is building an interface instead of an object
+        def interface?
+          defined?(@interface) || act_as_interface? || sti_interface?
+        end
+
+        # Provides access to the default plural query field, for associations interconnection
+        def collection_field
+          find_field(:query, plural)
+        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:
+          # Hook into the build process to selective avoid :interface or :object
+          def build!(type)
+            return if type == :object && interface?
+            return if type == :interface && !interface?
+            super
+          end
+
+          def presence_validator
             ::ActiveRecord::Validations::PresenceValidator
           end
       end
 
-      # Prepare to load multiple records from the underlying table
-      def load_records(scope = model.default_scoped)
+      # Prepare to load multiple records from the underlying model
+      def load_records(scope = nil)
+        scope ||= event.last_result || model.default_scoped
         inject_scopes(scope, :relation)
       end
 
-      # Prepare to load a single record from the underlying table
-      def load_record(scope = model.default_scoped)
-        scope.find(event.argument(primary_key))
+      # Prepare to load a single record from the underlying model
+      def load_record(scope = nil, find_by: nil)
+        scope ||= event.last_result || model.default_scoped
+        find_by ||= { primary_key => event.argument(primary_key) }
+        inject_scopes(scope, :relation).find_by(find_by)
+      end
+
+      # The perform step for the +create+ based mutation
+      def create_record
+        input_argument.resource.tap(&:save!)
+      rescue ::ActiveRecord::RecordInvalid => error
+        errors_to_extensions(error.record.errors)
+        raise
+      end
+
+      # The perform step for the +update+ based mutation
+      def update_record
+        current_value.tap { |record| record.update!(**input_argument.params) }
+      rescue ::ActiveRecord::RecordInvalid => error
+        errors_to_extensions(error.record.errors)
+        raise
+      end
+
+      # The perform step for the +delete+ based mutation
+      def destroy_record
+        !!current_value.destroy!
+      rescue ::ActiveRecord::RecordInvalid => error
+        errors_to_extensions(error.record.errors)
+        raise
       end
 
-      # Get the chain result and preload the records with thre resulting scope
+      # Get the chain result and preload the records with the resulting scope
       def preload_association(association, scope = nil)
         event.stop(preload(association, scope || event.last_result), layer: :object)
       end
@@ -169,10 +241,11 @@ module Rails # :nodoc:
         scope = model._reflect_on_association(association).klass.default_scoped
 
         # Apply proxied injected scopes
-        proxied = event.field.try(:proxied_owner)
-        scope = event.on_instance(proxied) do |instance|
-          instance.inject_scopes(scope, :relation)
-        end if proxied.present? && proxied <= Source::ActiveRecordSource
+        # TODO: Arguments comes with their proxy, so we might not need this
+        # proxied = event.field.try(:proxied_owner)
+        # scope = event.on_instance(proxied) do |instance|
+        #   instance.inject_scopes(scope, :relation)
+        # end if proxied.present? && proxied <= Source::ActiveRecordSource
 
         # Apply self defined injected scopes
         inject_scopes(scope, :relation)
@@ -181,26 +254,21 @@ module Rails # :nodoc:
       # Once the records are pre-loaded due to +preload_association+, use the
       # parent value and the preloader result to get the records
       def parent_owned_records(collection_result = false)
-        data = event.data[:prepared]
+        data = event.data[:prepared_data]
         return collection_result ? [] : nil unless data
 
         result = data.records_by_owner[current_value] || []
         collection_result ? result : result.first
       end
 
-      # The perform step for the +create+ based mutation
-      def create_record
-        input_argument.resource.tap(&:save!)
-      end
+      # Expose the errors to the extensions of the response
+      def errors_to_extensions(errors, path = nil, format = nil)
+        format ||= self.class.errors_to_extensions
+        return unless format
 
-      # The perform step for the +update+ based mutation
-      def update_record
-        current_value.tap { |record| record.update!(**input_argument.params) }
-      end
-
-      # The perform step for the +delete+ based mutation
-      def destroy_record
-        !!current_value.destroy!
+        path ||= [operation.name, field.gql_name].compact
+        hash = GraphQL.enumerate(path).reduce(request.extensions) { |h, k| h[k] ||= {} }
+        hash.replace(format == :messages ? errors.as_json : errors.details)
       end
 
       protected
@@ -212,23 +280,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,83 @@
+# 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!
+            @object = @input = nil
+            super
+          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[:values] = enumerator.sort_by(&:last).map(&:first)
+              xargs[:indexed] = enumerator.first.last.is_a?(Numeric)
+
+              create_type(:enum, enum_name.classify, **xargs, &block)
+            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, name = base_name, **xargs, &block)
+              xargs[:owner] ||= self
+              xargs[:namespaces] = namespaces
+              xargs[:assigned_to] = safe_assigned_class
+              superclass = xargs.delete(:superclass) || type
+
+              GraphQL::Type.create!(self, name, superclass, **xargs, &block)
+            end
+
+        end
+      end
+    end
+  end
+end