rails-graphql 1.0.0.beta → 1.0.0.rc1

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

@@ -8,7 +8,7 @@ module Rails
     # 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::Base
       include Source::ScopedArguments
@@ -24,17 +24,25 @@ module Rails
       # 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_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).to_set
+      self.hook_names = hook_names.to_a.insert(1, :enums, :interface).to_set.freeze
 
       delegate :primary_key, :singular, :plural, :model, :id_columns, to: :class
 
@@ -48,44 +56,51 @@ module Rails
         build_reflection_fields(self)
       end
 
+      step(:interface) do
+        build_attribute_fields(self)
+        build_reflection_fields(self)
+      end
+
       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
 
       step(:query) do
-        build_object
+        interface? ? build_interface : build_object
+        type = interface? ? interface : object
 
-        safe_field(plural, object, full: true) do
+        safe_field(plural, type, full: true) do
           before_resolve(:load_records)
         end
 
-        safe_field(singular, object, null: false) do
+        safe_field(singular, type, null: false) do
           build_primary_key_arguments(self)
           before_resolve(:load_record)
         end
       end
 
       step(:mutation) do
-        build_object
+        interface? ? build_interface : build_object
+        type = interface? ? interface : object
         build_input
 
-        safe_field("create_#{singular}", object, null: false) do
+        safe_field("create_#{singular}", type, null: false) do
           argument(singular, input, null: false)
           perform(:create_record)
         end
 
-        safe_field("update_#{singular}", object, null: false) do
+        safe_field("update_#{singular}", type, null: false) do
           build_primary_key_arguments(self)
           argument(singular, input, null: false)
           before_resolve(:load_record)
@@ -124,6 +139,22 @@ module Rails
           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
@@ -151,23 +182,56 @@ module Rails
 
         private
 
+          # 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, find_by: nil)
+      # 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
 
-      # Get the chain result and preload the records with thre resulting scope
+      # 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 the resulting scope
       def preload_association(association, scope = nil)
         event.stop(preload(association, scope || event.last_result), layer: :object)
       end
@@ -177,10 +241,11 @@ module Rails
         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)
@@ -189,26 +254,21 @@ module Rails
       # 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
-
-      # The perform step for the +update+ based mutation
-      def update_record
-        current_value.tap { |record| record.update!(**input_argument.params) }
-      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 +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

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

@@ -32,8 +32,8 @@ module Rails
 
           # Unregister all objects that this source was providing
           def unregister!
-            GraphQL.type_map.unregister(*created_types) if defined?(@created_types)
             @object = @input = nil
+            super
           end
 
           # Return the GraphQL object type associated with the source. It will
@@ -59,52 +59,24 @@ module Rails
               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
+              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, **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
+            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
 
-          private
-
-            # Keep track of all the types created byt this source
-            def created_types
-              @created_types ||= []
+              GraphQL::Type.create!(self, name, superclass, **xargs, &block)
             end
 
         end
-
       end
     end
   end

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

@@ -34,10 +34,10 @@ module Rails
           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) unless built?(type)
+          build!(type, *args, **xargs, &block)
         end
 
         protected
@@ -47,13 +47,6 @@ module Rails
             @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
@@ -100,29 +93,23 @@ module Rails
           # 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)) }
+            catch(:skip) { run_hooks(type, hook_scope_for(type, schema_type)) }
 
-            built << type.to_sym
+            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)
+          def hook_scope_for(type, schema_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)
+            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

@@ -15,8 +15,8 @@ module Rails
         def initialize(*args, block:, on: nil, **xargs)
           super(*args, **xargs)
 
-          @block = block
-          @fields = GraphQL.enumerate(on)
+          @block = (block == true) ? name : block
+          @fields = on
         end
 
         # Apply the argument block to the given object, using or not the value
@@ -36,7 +36,7 @@ module Rails
         def attach_to?(field)
           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
@@ -48,11 +48,17 @@ module Rails
           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?
+            block ||= proc_method if proc_method.present?
             argument = Argument.new(param, type, **settings, owner: self, block: block)
             (@scoped_arguments ||= {})[argument.name] = argument
           end

data/lib/rails/graphql/source.rb

@@ -17,13 +17,6 @@ module Rails
 
       include Helpers::Instantiable
 
-      ATTACH_FIELDS_STEP = -> do
-        if fields?
-          attach_fields!(type, fields)
-          attach_scoped_arguments_to(fields.values)
-        end
-      end
-
       autoload :Base
       autoload :Builder
 
@@ -39,7 +32,6 @@ module Rails
           self_object.safe_field(name, *args, **xargs, &block)
         end
 
-        # skip_field?(item.name, on: holder.kind)
         def respond_to_missing?(method_name, include_private = false)
           self_object.respond_to?(method_name, include_private) ||
             receiver.respond_to?(method_name, include_private)
@@ -61,7 +53,7 @@ module Rails
       # set the order of the execution of the hooks while validating the hooks
       # callbacks using the +on+ method
       class_attribute :hook_names, instance_accessor: false,
-        default: %i[start object input query mutation subscription].to_set
+        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
@@ -113,6 +105,22 @@ module Rails
           base_sources.reverse_each.find { |source| object <= source.assigned_class }
         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
+
+          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!(type = :all, from = self)
@@ -149,22 +157,6 @@ module Rails
             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 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
-
-            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
-
           # Creates a hook that throws a done action, preventing any parent hooks
           def skip(*names)
             names.each do |hook_name|
@@ -183,22 +175,21 @@ module Rails
           # 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.start_with?('GraphQL::') ? module_parent : ::GraphQL
+            self.hook_names = (hook_names + list).freeze
           end
 
           # Add one or more fields to the list of fields that needs to be
@@ -236,17 +227,12 @@ module Rails
             super if defined? super
           end
 
-          # Find all classes that inherits from source that are abstract,
-          # meaning that they are a base sources
+          # 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
-
-      step(:query, &ATTACH_FIELDS_STEP)
-      step(:mutation, &ATTACH_FIELDS_STEP)
-      step(:subscription, &ATTACH_FIELDS_STEP)
     end
   end
 end

data/lib/rails/graphql/subscription/provider/action_cable.rb

@@ -10,6 +10,7 @@ module Rails
         #
         # The subscription provider associated with Rails Action Cable, that
         # delivers subscription notifications through an Action Cable Channel
+        # TODO: Try to serialize and deserialize the origin
         class ActionCable < Base
           INTERNAL_CHANNEL = 'rails-graphql:events'
 
@@ -17,7 +18,7 @@ module Rails
 
           def initialize(*args, **options)
             @cable = options.fetch(:cable, ::ActionCable)
-            @prefix = options.fetch(:prefix, 'graphql')
+            @prefix = options.fetch(:prefix, 'rails-graphql')
 
             @event_callback = ->(message) do
               method_name, args, xargs = Marshal.load(message)
@@ -46,20 +47,20 @@ module Rails
           end
 
           def async_remove(item)
-            return unless instance?(item) || !(item = store.fetch(item)).nil?
+            return if (item = store.fetch(item)).nil?
             cable.server.broadcast(stream_name(item), unsubscribed_payload)
             store.remove(item)
 
             log(:removed, item)
           end
 
-          def async_update(item, data = nil)
-            return unless instance?(item) || !(item = store.fetch(item)).nil?
+          def async_update(item, data = nil, **xargs)
+            return if (item = store.fetch(item)).nil?
             removing = false
 
             log(:updated, item) do
-              data = execute(item) if data.nil?
-              item.updated!
+              data = execute(item, **xargs) if data.nil?
+              store.update!(item)
 
               unless (removing = unsubscribing?(data))
                 data = { 'result' => data, 'more' => true }
@@ -71,7 +72,7 @@ module Rails
           end
 
           def stream_name(item)
-            "#{prefix}:#{instance?(item) ? item.sid : item}"
+            "#{prefix}:#{item.sid}"
           end
 
           protected
@@ -80,8 +81,8 @@ module Rails
               item.origin.stream_from(stream_name(item))
             end
 
-            def execute(subscription, **xargs)
-              super(subscription, origin: subscription.origin, **xargs, as: :hash)
+            def execute(item, **xargs)
+              super(item, origin: item.origin, **xargs, as: :hash)
             end
 
             def async_exec(method_name, *args, **xargs)

data/lib/rails/graphql/subscription/provider/base.rb

@@ -94,7 +94,7 @@ module Rails
           # Update one single subscription, for broadcasting, use +update_all+
           # or +search_and_update+. You can provide the +data+ that will be sent
           # to upstream, skipping it from being collected from a request
-          async_exec def update(item, data = nil)
+          async_exec def update(item, data = nil, **xargs)
             raise NotImplementedError, +"#{self.class.name} does not implement update"
           end
 
@@ -104,15 +104,15 @@ module Rails
           end
 
           # A simple shortcut for calling update on each individual sid
-          async_exec def update_all(*sids)
+          async_exec def update_all(*sids, **xargs)
             return if sids.blank?
 
             enum = GraphQL.enumerate(store.fetch(*sids))
             enum.group_by(&:operation_id).each_value do |subscriptions|
-              data = execute(subscriptions.first, broadcasting: true) \
+              data = execute(subscriptions.first, **xargs, broadcasting: true) \
                 unless subscriptions.one? || first.broadcastable?
 
-              subscriptions.each { |item| update(item, data) }
+              subscriptions.each { |item| update(item, data, **xargs) }
             end
           end
 
@@ -123,7 +123,8 @@ module Rails
 
           # A shortcut for finding the subscriptions and then updating them
           async_exec def search_and_update(**options)
-            update_all(*find_each(**options))
+            xargs = options.slice(:data_for)
+            update_all(*find_each(**options), **xargs)
           end
 
           # Get the payload that should be used when unsubscribing

data/lib/rails/graphql/subscription/store/base.rb

@@ -65,6 +65,11 @@ module Rails
             raise NotImplementedError, +"#{self.class.name} does not implement remove"
           end
 
+          # Marks that a subscription has received an update
+          def update!(item)
+            raise NotImplementedError, +"#{self.class.name} does not implement update!"
+          end
+
           # Check if a given sid or instance is stored
           def has?(item)
             raise NotImplementedError, +"#{self.class.name} does not implement has?"
@@ -123,21 +128,12 @@ module Rails
             def hash_for(value, klass = nil)
               if !klass.nil?
                 klass.hash ^ value.hash
-              elsif extract_class_from?(value)
-                value.class.hash ^ value.id.hash
               elsif value.is_a?(Numeric)
                 value
               else
                 value.hash
               end
             end
-
-            # Check if ActiveRecord::Base is available and then if the object
-            # provided is an instance of it, so that the serialize can work
-            # correctly
-            def extract_class_from?(value)
-              defined?(ActiveRecord) && value.is_a?(ActiveRecord::Base)
-            end
         end
       end
     end