rails-graphql 0.2.1 → 1.0.0.rc1

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

@@ -0,0 +1,113 @@
+# 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
+        # TODO: Try to serialize and deserialize the origin
+        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, 'rails-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 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, **xargs)
+            return if (item = store.fetch(item)).nil?
+            removing = false
+
+            log(:updated, item) do
+              data = execute(item, **xargs) if data.nil?
+              store.update!(item)
+
+              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}:#{item.sid}"
+          end
+
+          protected
+
+            def stream_from(item)
+              item.origin.stream_from(stream_name(item))
+            end
+
+            def execute(item, **xargs)
+              super(item, origin: item.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

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Subscription
+      module Provider
+        # = GraphQL Base Subscription Provider
+        #
+        # The base class for all the other subscription providers, which defines
+        # the necessary interfaces to install and stream the subscription to
+        # their right places
+        #
+        # As a way to properly support ActiveRecord objects as part of the scope
+        # in a way that does not require queries and instance, a hash scope,
+        # where we have the class as the key and one or more ids as values,
+        # must be supported. In general, a implementation using +.hash+ is
+        # recommended because +User.find(1).hash == User.class.hash ^ 1.hash+
+        class Base
+          # An abstract type won't appear in the introspection and will not be
+          # instantiated by requests
+          class_attribute :abstract, instance_accessor: false, default: false
+
+          delegate :fetch, :search, :find_each, to: :store
+
+          class << self
+
+            # Make sure that abstract classes cannot be instantiated
+            def new(*, **)
+              return super unless self.abstract
+
+              raise StandardError, (+<<~MSG).squish
+                #{name} is abstract and cannot be used as a subscription provider.
+              MSG
+            end
+
+            # Make sure to run the provided +methods+ in async mode. Use the
+            # lock to identify if it's already running in async or not
+            def async_exec(*method_names)
+              method_names.each do |method_name|
+                async_method_name = :"async_#{method_name}"
+
+                class_eval do
+                  return warn((+<<~MSG).squish) if method_defined?(async_method_name)
+                    Already async #{method_name}
+                  MSG
+
+                  alias_method async_method_name, method_name
+
+                  define_method(method_name) do |*args, **xargs|
+                    if @mutex.owned?
+                      send(async_method_name, *args, **xargs)
+                    else
+                      async_exec(async_method_name, *args, **xargs)
+                    end
+                  end
+                end
+              end
+            end
+
+          end
+
+          def initialize(**options)
+            @store = options.fetch(:store, Store::Memory.new)
+            @logger = options.fetch(:logger, GraphQL.logger)
+            @mutex = Mutex.new
+
+            validate!
+          end
+
+          # Use this method to remove variables that needs to be restarted when
+          # the provider is doing a refresh. Remember to keep the data in the
+          # store so that it can still recover and keep posting updates
+          def shutdown
+          end
+
+          # Before even generating the item, check if the operation can be
+          # subscribed
+          def accepts?(operation)
+            raise NotImplementedError, +"#{self.class.name} does not implement accepts?"
+          end
+
+          # Add one or more subscriptions to the provider
+          def add(*subscriptions)
+            raise NotImplementedError, +"#{self.class.name} does not implement add"
+          end
+
+          # Remove one subscription from the provider, assuming that they will
+          # be properly notified about the removal. For a group operation, use
+          # +search_and_remove+
+          async_exec def remove(item)
+            raise NotImplementedError, +"#{self.class.name} does not implement remove"
+          end
+
+          # 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, **xargs)
+            raise NotImplementedError, +"#{self.class.name} does not implement update"
+          end
+
+          # A simple shortcut for calling remove on each individual sid
+          async_exec def remove_all(*items)
+            items.each(&method(:remove))
+          end
+
+          # A simple shortcut for calling update on each individual sid
+          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, **xargs, broadcasting: true) \
+                unless subscriptions.one? || first.broadcastable?
+
+              subscriptions.each { |item| update(item, data, **xargs) }
+            end
+          end
+
+          # A shortcut for finding the subscriptions and then remove them
+          async_exec def search_and_remove(**options)
+            find_each(**options, &method(:remove))
+          end
+
+          # A shortcut for finding the subscriptions and then updating them
+          async_exec def search_and_update(**options)
+            xargs = options.slice(:data_for)
+            update_all(*find_each(**options), **xargs)
+          end
+
+          # Get the payload that should be used when unsubscribing
+          def unsubscribed_payload
+            Request::Component::Operation::Subscription::UNSUBSCRIBED_PAYLOAD
+          end
+
+          # Check if the given +value+ indicates that it is unsubscribing
+          def unsubscribing?(value)
+            value == Request::Component::Operation::Subscription::UNSUBSCRIBED_RESULT
+          end
+
+          protected
+            attr_reader :store, :logger
+
+            # Make sure to set sub provider as not abstract
+            def inherited(other)
+              other.abstract = false
+              super
+            end
+
+            # Check if the given +object+ is a subscription instance
+            def instance?(object)
+              object.is_a?(Request::Subscription)
+            end
+
+            # Logo a given +event+ for the given +item+
+            def log(event, item = nil, &block)
+              data = { item: item, type: event, provider: self }
+              ActiveSupport::Notifications.instrument('subscription.graphql', **data, &block)
+            end
+
+            # Create a new request and execute, but using all the information
+            # stored in the provided +subscription+
+            def execute(subscription, broadcasting: false, **xargs)
+              catch(:skip_subscription_update) do
+                context = subscription.context.dup
+                context[:broadcasting] = true if broadcasting
+                xargs.reverse_merge(context: context, as: :string)
+
+                namespace = subscription.schema
+                Request.execute(nil, **xargs, namespace: namespace, hash: subscription.sid)
+              end
+            end
+
+            # Make sure to rewrite this method so that you can properly execute
+            # methods asynchronously. Remember to
+            def async_exec(method_name, *args, **xargs)
+              @mutex.synchronize { send(method_name, *args, **xargs) }
+            end
+
+            # Make sure that the settings provided are enough to operate
+            def validate!
+              valid = defined?(@store) && @store.is_a?(Subscription::Store::Base)
+              raise ValidationError, (+<<~MSG).squish unless valid
+                Unable to setup #{self.class.name} because a proper store was not
+                defined, "#{@store.inspect}" was provided.
+              MSG
+            end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Subscription
+      # = GraphQL Subscription Provider
+      #
+      # Subscription provider holds all the possible options for handlers of
+      # subscriptions, which all should inherit from Provider::Base
+      module Provider
+        extend ActiveSupport::Autoload
+
+        autoload :Base
+        autoload :ActionCable
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Subscription
+      module Store
+        # = GraphQL Base Subscription Store
+        #
+        # The base class for all the other subscription stores, which defines
+        # the necessary interfaces to keep track of all the subscriptions
+        #
+        # Be careful with each subscription context. Although there are ways to
+        # clean it up (by implementing a +subscription_context+ callback into
+        # the field), it is still the most dangerous and heavy object that can
+        # be placed into the store. The problem with in memory store is that it
+        # does not work with a Rails application running cross-processes. On the
+        # other hand, file, Redis, or Database-based stores can find it
+        # difficult to save the context and bring it back to Rails again
+        #
+        # The closest best way to be safe about the context is relying on
+        # +ActiveJob::Arguments+ to serialize and deserialize it (which aligns
+        # with all possible arguments that jobs and receive and how they are
+        # usually properly stored in several different providers for ActiveJob)
+        class Base
+          # An abstract type won't appear in the introspection and will not be
+          # instantiated by requests
+          class_attribute :abstract, instance_accessor: false, default: false
+
+          class << self
+
+            # Make sure that abstract classes cannot be instantiated
+            def new(*)
+              return super unless self.abstract
+
+              raise StandardError, (+<<~MSG).squish
+                #{name} is abstract and cannot be used as a subscription store.
+              MSG
+            end
+
+          end
+
+          # Get the list of provided +xargs+ for search and serialize them
+          def serialize(**xargs)
+            xargs
+          end
+
+          # Return all the sids stored
+          def all
+            raise NotImplementedError, +"#{self.class.name} does not implement all"
+          end
+
+          # Add a new subscription to the store, saving in a way it can be easily
+          # searched at any point
+          def add(subscription)
+            raise NotImplementedError, +"#{self.class.name} does not implement add"
+          end
+
+          # Fetch one or more subscriptions by their ids
+          def fetch(*sids)
+            raise NotImplementedError, +"#{self.class.name} does not implement fetch"
+          end
+
+          # Remove a given subscription from the store by its id or instance
+          def remove(item)
+            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?"
+          end
+
+          # Search one or more subscriptions by the list of provided options and
+          # return the list of sids that matched. A block can be provided to go
+          # through each of the found results, yield the object itself instead
+          # of the sid
+          def search(**options, &block)
+            raise NotImplementedError, +"#{self.class.name} does not implement search"
+          end
+
+          alias find_each search
+
+          protected
+
+            # Check if the given +object+ is a subscription instance
+            def instance?(object)
+              object.is_a?(Request::Subscription)
+            end
+
+            # Transform a scope in several possible scopes, as in:
+            #   nil => nil
+            #   :user => [[:user]]
+            #   User.find(1) => [[NNN1]] # .hash
+            #   [User.find(1), :sample] => [[NNN1, :sample]]
+            #   { User => 1, other: :profile } => [[NNN1, :profile]]
+            #   { User => [1, 2], other: :profile } => [[NNN1, :profile], [NNN2, :profile]]
+            def possible_scopes(scope)
+              return if scope.nil? || scope === EMPTY_ARRAY
+
+              list = Array.wrap(scope).each_with_object([]) do |value, result|
+                result << options = []
+
+                next GraphQL.enumerate(value).each do |val|
+                  options << hash_for(val)
+                end unless value.is_a?(Hash)
+
+                value.each.with_index do |(key, sub_value), idx|
+                  result << options = [] if idx > 0
+
+                  klass_arg = key if key.is_a?(Class)
+                  GraphQL.enumerate(sub_value).each do |val|
+                    options << hash_for(val, klass_arg)
+                  end
+                end
+              end
+
+              list.reduce(:product).flatten.each_slice(list.size).map { |a| a.reduce(:^) }
+            end
+
+            # By default, get the hash of the value. If class is provided, add
+            # it as part of the hash (similar to how ActiveRecord calculates
+            # the hash for a model's record)
+            def hash_for(value, klass = nil)
+              if !klass.nil?
+                klass.hash ^ value.hash
+              elsif value.is_a?(Numeric)
+                value
+              else
+                value.hash
+              end
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Subscription
+      module Store
+        # = GraphQL Memory Subscription Store
+        #
+        # This store will save all the subscriptions in a very similar way that
+        # the TypeMap works, using nested concurrent maps that points out to
+        # them. Everything is based on the sid of the subscription
+        class Memory < Base
+          attr_reader :list, :index
+
+          def initialize
+            # The list store a simple association between sid and
+            @list = Concurrent::Map.new
+
+            # This store the index in a way that is possible to search
+            # subscriptions in a fast manner
+            @index = Concurrent::Map.new do |h1, key1|               # Fields
+              scopes = Concurrent::Map.new do |h2, key2|             # Scopes
+                arguments = Concurrent::Map.new do |h3, key3|        # Arguments
+                  h3.fetch_or_store(key3, Concurrent::Array.new)     # SIDs
+                end
+
+                h2.fetch_or_store(key2, arguments)
+              end
+
+              h1.fetch_or_store(key1, scopes)
+            end
+          end
+
+          def serialize(**xargs)
+            return xargs if !xargs.key?(:field) || xargs[:field].is_a?(Numeric)
+
+            xargs[:field] = hash_for(xargs[:field])
+            xargs[:scope] = possible_scopes(xargs[:scope])
+            xargs[:args] = Array.wrap(xargs[:args]).map(&method(:hash_for))
+            xargs
+          end
+
+          def all
+            list.keys
+          end
+
+          def add(subscription)
+            if has?(subscription.sid)
+              raise ::ArgumentError, +"SID #{subscription.sid} is already taken."
+            end
+
+            # Rewrite the scope, to save memory
+            scope = possible_scopes(subscription.scope)&.first
+            subscription.instance_variable_set(:@scope, scope)
+
+            # Save to the list and to the index
+            list[subscription.sid] = subscription
+            index_set = subscription_to_index(subscription).reduce(index, &:[])
+            index_set << subscription.sid
+            subscription.sid
+          end
+
+          def fetch(*sids)
+            return if sids.none?
+
+            items = sids.map do |item|
+              instance?(item) ? item : list[item]
+            end
+
+            items.one? ? items.first : items
+          end
+
+          def remove(item)
+            return unless has?(item)
+
+            instance = instance?(item) ? item : fetch(item)
+            path = subscription_to_index(instance)
+            index.delete(instance.sid)
+
+            f_level = index[path[0]]
+            s_level = f_level[path[1]]
+            a_level = s_level[path[2]]
+
+            a_level.delete(instance.sid)
+            s_level.delete(path[2]) if a_level.empty?
+            f_level.delete(path[1]) if s_level.empty?
+            index.delete(path[0]) if f_level.empty?
+          end
+
+          def update!(item)
+            (instance?(item) ? item : fetch(item)).update!
+          end
+
+          def has?(item)
+            list.key?(instance?(item) ? item.sid : item)
+          end
+
+          def search(**xargs, &block)
+            xargs = serialize(**xargs)
+            field, scope, args = xargs.values_at(:field, :scope, :args)
+
+            if field.nil? && args.nil? && scope.nil?
+              list.each(&block) unless block.nil?
+              return all
+            end
+
+            [].tap do |result|
+              GraphQL.enumerate(field || index.keys).each do |key1|
+                GraphQL.enumerate(scope || index[key1].keys).each do |key2|
+                  GraphQL.enumerate(args || index[key2].keys).each do |key3|
+                    items = index.fetch(key1, nil)&.fetch(key2, nil)&.fetch(key3, nil)
+                    items.each(&list.method(:[])).each(&block) unless block.nil?
+                    result.concat(items || EMPTY_ARRAY)
+                  end
+                end
+              end
+            end
+          end
+
+          alias find_each search
+
+          protected
+
+            # Turn the request subscription into into the path of the index
+            def subscription_to_index(subscription)
+              [
+                subscription.field.hash,
+                subscription.scope,
+                subscription.args.hash,
+              ]
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Subscription
+      # = GraphQL Subscription Store
+      #
+      # Subscription store holds all the possible options for storing the
+      # subscriptions, allowing to segmentation by field, variables, and several
+      # other things according to the necessity
+      module Store
+        extend ActiveSupport::Autoload
+
+        autoload :Base
+        autoload :Memory
+      end
+    end
+  end
+end

data/lib/rails/graphql/subscription.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    # = GraphQL Subscription
+    #
+    # A namespace for storing subscription-related objects like the provider
+    # for a stream/websocket provider, and the store, for where the
+    # subscriptions are stored
+    module Subscription
+      extend ActiveSupport::Autoload
+
+      autoload :Store
+      autoload :Provider
+    end
+  end
+end