rails-graphql 0.2.1 → 1.0.0.beta

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

@@ -0,0 +1,191 @@
+# 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)
+            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)
+            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) \
+                unless subscriptions.one? || first.broadcastable?
+
+              subscriptions.each { |item| update(item, data) }
+            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)
+            update_all(*find_each(**options))
+          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,145 @@
+# 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
+
+          # 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 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
+  end
+end

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

@@ -0,0 +1,127 @@
+# 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
+
+            list[subscription.sid] = subscription
+            index_set = subscription_to_index(subscription).reduce(index, &:[])
+            index_set << subscription.sid
+            subscription.sid
+          end
+
+          def fetch(*sids)
+            if sids.none?
+              nil
+            elsif sids.one?
+              list[sids.first]
+            else
+              sids.map(&list.method(:[]))
+            end
+          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 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)
+              [
+                hash_for(subscription.field),
+                possible_scopes(subscription.scope)&.first,
+                hash_for(subscription.args),
+              ]
+            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

data/lib/rails/graphql/to_gql.rb

@@ -3,8 +3,8 @@
 require 'arel/visitors/visitor'
 
 # rubocop:disable Naming/MethodParameterName, Naming/MethodName
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL ToGQL
     #
     # This class can turn any class related to GraphQL into its GraphQL string
@@ -35,14 +35,13 @@ module Rails # :nodoc:
         collector ||= Collectors::IdentedCollector.new
         @with_descriptions = with_descriptions
         @with_spec = with_spec.nil? ? schema.introspection? : with_spec
+        @namespace = schema.namespace
 
-        accept(schema, collector).eol
-
-        GraphQL.type_map.each_from(schema.namespace, base_class: :Type)
+        GraphQL.type_map.each_from(@namespace, base_class: :Type)
           .group_by(&:kind).values_at(*DESCRIBE_TYPES)
-          .each do |items|
+          .prepend([schema]).each do |items|
             items&.sort_by(&:gql_name)&.each do |item|
-              next if !@with_spec && item.internal?
+              next if !@with_spec && item.try(:internal?)
 
               next visit_Rails_GraphQL_Type_Object(item, collector).eol \
                 if item.is_a?(::OpenStruct) && item.object?
@@ -109,8 +108,9 @@ module Rails # :nodoc:
           visit_directives(o.directives, collector)
 
           collector.indented(' {', '}') do
-            Helpers::WithSchemaFields::SCHEMA_FIELD_TYPES.each do |key, name|
+            Helpers::WithSchemaFields::TYPE_FIELD_CLASS.each_key do |key|
               next unless key.eql?(:query) || o.fields_for(key).present?
+              name = o.type_name_for(key)
 
               collector << key.to_s
               collector << ': '
@@ -152,14 +152,6 @@ module Rails # :nodoc:
           visit_Rails_GraphQL_Field(o, collector)
         end
 
-        def visit_Rails_GraphQL_Field_OutputField(o, collector)
-          visit_Rails_GraphQL_Field(o, collector)
-        end
-
-        def visit_Rails_GraphQL_Field_InputField(o, collector)
-          visit_Rails_GraphQL_Field(o, collector)
-        end
-
         def visit_Rails_GraphQL_Type_Enum(o, collector)
           visit_description(o, collector)
           collector << 'enum '
@@ -178,9 +170,7 @@ module Rails # :nodoc:
           collector << o.gql_name
           visit_directives(o.directives, collector)
 
-          collector.indented(' {', '}') do
-            o.fields.each_value { |x| visit(x, collector) }
-          end
+          collector.indented(' {', '}') { visit_fields(o.fields, collector) }
         end
 
         def visit_Rails_GraphQL_Type_Interface(o, collector)
@@ -190,9 +180,7 @@ module Rails # :nodoc:
           collector << o.gql_name
           visit_directives(o.directives, collector)
 
-          collector.indented(' {', '}') do
-            o.fields.each_value { |x| visit(x, collector) }
-          end
+          collector.indented(' {', '}') { visit_fields(o.fields, collector) }
         end
 
         def visit_Rails_GraphQL_Type_Object(o, collector)
@@ -211,9 +199,7 @@ module Rails # :nodoc:
 
           visit_directives(o.directives, collector)
 
-          collector.indented(' {', '}') do
-            o.fields.each_value { |x| visit(x, collector) }
-          end
+          collector.indented(' {', '}') { visit_fields(o.fields, collector) }
         end
 
         def visit_Rails_GraphQL_Type_Scalar(o, collector)
@@ -260,8 +246,16 @@ module Rails # :nodoc:
           visit_typed_object(o, collector)
         end
 
+        def visit_fields(list, collector)
+          return if list.blank?
+
+          list.values.sort_by do |field|
+            field.name == :id ? '' : field.gql_name
+          end.each { |x| visit(x, collector) }
+        end
+
         def visit_arguments(list, collector)
-          return if list.empty?
+          return if list.blank?
 
           indented = @with_descriptions && list.values.any?(&:description?)
 
@@ -292,15 +286,18 @@ module Rails # :nodoc:
         end
 
         def visit_description(o, collector)
-          return unless @with_descriptions && o.description?
+          return unless @with_descriptions
+
+          args = o.method(:description).arity == 0 ? [] : [@namespace]
+          return if (desc = o.description(*args)).nil?
 
-          if o.description.lines.size === 1
-            collector << o.description.inspect
+          if desc.lines.size === 1
+            collector << desc.inspect
           else
             collector << '"""'
             collector.eol
 
-            collector << o.description
+            collector << desc
             collector.eol
 
             collector << '"""'
@@ -344,7 +341,7 @@ module Rails # :nodoc:
           collector << ' = ' << o.to_json(o.default) if o.try(:default_value?)
         end
 
-        def visit(object, collector = nil) # :nodoc:
+        def visit(object, collector = nil)
           object_class = object.is_a?(Module) ? object : object.class
           dispatch_method = dispatch[object_class]
           if collector
@@ -358,7 +355,7 @@ module Rails # :nodoc:
             respond_to?(dispatch[klass], true)
           end
 
-          raise(::TypeError, "Cannot visit #{object_class}") unless superklass
+          raise(::TypeError, +"Cannot visit #{object_class}") unless superklass
           dispatch[object_class] = dispatch[superklass]
           retry
         end