rails-graphql 0.2.0 → 1.0.0.beta

data/lib/rails/graphql/source.rb

@@ -1,29 +1,45 @@
 # 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 :ActiveRecordSource
+      ATTACH_FIELDS_STEP = -> do
+        if fields?
+          attach_fields!(type, fields)
+          attach_scoped_arguments_to(fields.values)
+        end
       end
 
-      ScopedConfig = Struct.new(:receiver, :self_object) do # :nodoc: all
+      autoload :Base
+      autoload :Builder
+
+      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
+
+        # 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)
@@ -39,53 +55,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
 
       # 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 +93,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 +113,17 @@ 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
-
-        # Checks if a given method can act as resolver
-        def gql_resolver?(method_name)
-          (instance_methods - GraphQL::Source.instance_methods).include?(method_name)
-        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,54 +137,15 @@ 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
 
@@ -246,13 +153,13 @@ module Rails # :nodoc:
           # 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)
+          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?
-              send("run_#{hook_name}_hooks", block)
+            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
@@ -262,7 +169,7 @@ module Rails # :nodoc:
           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,7 +177,7 @@ 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
@@ -291,86 +198,55 @@ module Rails # :nodoc:
 
           # Return the module where the GraphQL types should be created at
           def gql_module
-            name.starts_with?('GraphQL::') ? module_parent : ::GraphQL
+            name.start_with?('GraphQL::') ? module_parent : ::GraphQL
           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
+          # 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
+
+            self.skip_fields.merge(list)
           end
 
-        private
+          # 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
 
-          # The list of pending sources to be built asscoaited to where they
-          # were defined
-          def pending
-            @@pending ||= {}
+            all_skip_fields&.include?(name) ||
+              all_segmented_skip_fields.try(:[], on)&.include?(name) ||
+              all_segmented_only_fields.try(:[], on)&.exclude?(name)
           end
 
-          # Check if there are pending sources to be built
-          def pending?
-            pending.any?
+          # 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 the pending sources
-          def build_pending!
-            while (klass, = pending.shift)
-              klass.send(:build!) unless klass.abstract?
-            end
+        private
+
+          # Make sure to reset the value of +abstract+
+          def inherited(subclass)
+            subclass.abstract = false
+            super if defined? super
           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
-            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
-
-            catch(:skip) { send(:run_finish_hooks) } if respond_to?(:run_finish_hooks, true)
+            @@base_sources ||= GraphQL.config.sources.map(&:constantize).to_set
           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
-          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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'action_cable'
+
+module Rails
+  module GraphQL
+    module Subscription
+      module Provider
+        # = GraphQL Action Cable Subscription Provider
+        #
+        # The subscription provider associated with Rails Action Cable, that
+        # delivers subscription notifications through an Action Cable Channel
+        class ActionCable < Base
+          INTERNAL_CHANNEL = 'rails-graphql:events'
+
+          attr_reader :cable, :prefix
+
+          def initialize(*args, **options)
+            @cable = options.fetch(:cable, ::ActionCable)
+            @prefix = options.fetch(:prefix, 'graphql')
+
+            @event_callback = ->(message) do
+              method_name, args, xargs = Marshal.load(message)
+              @mutex.synchronize { send(method_name, *args, **xargs) }
+            end
+
+            super
+          end
+
+          def shutdown
+            @pubsub = nil
+          end
+
+          def accepts?(operation)
+            operation.request.origin.is_a?(::ActionCable::Channel::Base)
+          end
+
+          def add(*subscriptions)
+            with_pubsub do
+              subscriptions.each do |item|
+                log(:added, item)
+                store.add(item)
+                stream_from(item)
+              end
+            end
+          end
+
+          def async_remove(item)
+            return unless instance?(item) || !(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?
+            removing = false
+
+            log(:updated, item) do
+              data = execute(item) if data.nil?
+              item.updated!
+
+              unless (removing = unsubscribing?(data))
+                data = { 'result' => data, 'more' => true }
+                cable.server.broadcast(stream_name(item), data)
+              end
+            end
+
+            async_remove(item) if removing
+          end
+
+          def stream_name(item)
+            "#{prefix}:#{instance?(item) ? item.sid : item}"
+          end
+
+          protected
+
+            def stream_from(item)
+              item.origin.stream_from(stream_name(item))
+            end
+
+            def execute(subscription, **xargs)
+              super(subscription, origin: subscription.origin, **xargs, as: :hash)
+            end
+
+            def async_exec(method_name, *args, **xargs)
+              payload = [method_name, args, store.serialize(**xargs)]
+              with_pubsub { @pubsub.broadcast(INTERNAL_CHANNEL, Marshal.dump(payload)) }
+              nil
+            end
+
+            def with_pubsub(&callback)
+              success = -> { cable.server.event_loop.post(&callback) }
+              return success.call if defined?(@pubsub) && !@pubsub.nil?
+
+              cable.server.pubsub.subscribe(INTERNAL_CHANNEL, @event_callback, success)
+              @pubsub = cable.server.pubsub
+            end
+
+            def validate!
+              super
+
+              raise ValidationError, (+<<~MSG).squish if @prefix.blank?
+                Unable to setup #{self.class.name} because a proper prefix was not provided.
+              MSG
+            end
+        end
+      end
+    end
+  end
+end