rails-graphql 0.2.0 → 1.0.0.beta

data/lib/rails/graphql/request/strategy/cached_strategy.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Request
+      # = GraphQl Cached Strategy
+      #
+      # This strategy will process hard cached operations. Soft cached
+      # operations are those that only the document is cached in the server and
+      # processed via its unique identifier (UUID). Whereas, hard cached
+      # operations pretty muchy skips the organize step since that is what is
+      # cached.
+      #
+      # Beware, if the version in the cache is different from the version in the
+      # type map, it won't be able to process it.
+      class Strategy::CachedStrategy < Strategy
+        self.priority = 100
+
+        class << self
+
+          # Resolve whenever it has a cache directive on any of the operations
+          def can_resolve?(request)
+            false
+            # request.operations.each_value.any? do |op|
+            #   op.data&.directives&.any? { |dir| directive_name(dir) == 'cached' }
+            # end
+          end
+
+          private
+
+            def directive_name(obj)
+              Native.node_name(Native.directive_name(obj))
+            end
+        end
+
+        # Executes the strategy in the normal mode
+        def resolve!
+          response.with_stack('data') do
+            for_each_operation { |op| collect_listeners { op.organize! } }
+            for_each_operation { |op| collect_data      { op.prepare!  } }
+            for_each_operation { |op| collect_response  { op.resolve!  } }
+
+            # collect_data(true) { op.prepare! }
+            # collect_response   { op.resolve! }
+
+            # operations.each_value do |op|
+            #   collect_listeners  { op.organize! }
+            #   collect_data(true) { op.prepare! }
+            #   collect_response   { op.resolve! }
+            # end
+          end
+        end
+
+        private
+
+          # Execute a given block for each defined operation
+          def for_each_operation(&block)
+            operations.each_value(&block)
+          end
+
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/strategy/dynamic_instance.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQl Strategy Dynamic Instance
       #
       # When an event is call on non-object types, this class allows both
@@ -16,18 +16,18 @@ module Rails # :nodoc:
 
         private
 
-          def respond_to_missing?(method_name, include_private = false) # :nodoc:
+          def respond_to_missing?(method_name, include_private = false)
             __current_object__&.respond_to?(method_name, include_private) || super
           end
 
-          def method_missing(method_name, *args, **xargs, &block) # :nodoc:
+          def method_missing(method_name, *args, **xargs, &block)
             object = __current_object__
 
             return super unless object&.respond_to?(method_name)
             object.public_send(method_name, *args, **xargs, &block)
           end
 
-          def __current_object__ # :nodoc:
+          def __current_object__
             return unless __getobj__.instance_variable_defined?(:@event)
 
             event = __getobj__.instance_variable_get(:@event)

data/lib/rails/graphql/request/strategy/multi_query_strategy.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQl Multi Query Strategy
       #
       # This is a resolution strategy to solve requests that only contain
@@ -11,25 +11,18 @@ module Rails # :nodoc:
       class Strategy::MultiQueryStrategy < Strategy
         self.priority = 10
 
-        def self.can_resolve?(request) # :nodoc:
-          request.operations.values.all?(&:query?)
+        def self.can_resolve?(request)
+          request.operations.each_value.all? { |op| op.of_type?(:query) }
         end
 
         # Executes the strategy in the normal mode
         def resolve!
-          response.with_stack(:data) do
+          response.with_stack('data') do
             for_each_operation { |op| collect_listeners { op.organize! } }
             for_each_operation { |op| collect_data      { op.prepare!  } }
             for_each_operation { |op| collect_response  { op.resolve!  } }
           end
         end
-
-        private
-
-          # Execute a given block for each defined operation
-          def for_each_operation
-            operations.each_value { |op| yield op }
-          end
       end
     end
   end

data/lib/rails/graphql/request/strategy/sequenced_strategy.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQl Sequenced Strategy
       #
       # This is the default resolution strategy, where each operation is
       # performed in sequece, and they don't relate to each other in any way.
       class Strategy::SequencedStrategy < Strategy
-        def self.can_resolve?(_) # :nodoc:
+        def self.can_resolve?(_)
           true
         end
 
         # Executes the strategy in the normal mode
         def resolve!
-          response.with_stack(:data) do
-            operations.each_value do |op|
-              collect_listeners { op.organize! }
-              collect_data      { op.prepare! }
-              collect_response  { op.resolve! }
+          response.with_stack('data') do
+            for_each_operation do |op|
+              collect_listeners  { op.organize! }
+              collect_data(true) { op.prepare! }
+              collect_response   { op.resolve! }
             end
           end
         end

data/lib/rails/graphql/request/strategy.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQL Request Strategy
       #
       # This is the base class for the strategies of resolving a request.
@@ -11,10 +11,9 @@ module Rails # :nodoc:
 
         autoload :DynamicInstance
 
-        eager_autoload do
-          autoload :SequencedStrategy
-          autoload :MultiQueryStrategy
-        end
+        autoload :SequencedStrategy
+        autoload :MultiQueryStrategy
+        autoload :CachedStrategy
 
         # Configurations for the prepare step
         PREPARE_XARGS = { object?: true, reverse?: true }.freeze
@@ -24,7 +23,7 @@ module Rails # :nodoc:
 
         delegate :operations, :errors, :response, :schema, to: :request
 
-        attr_reader :listeners, :request, :context
+        attr_reader :listeners, :request, :context, :stage
 
         class << self
           # Check if the strategy can resolve the given +request+. By default,
@@ -38,7 +37,15 @@ module Rails # :nodoc:
         def initialize(request)
           @request = request
           @objects_pool = {}
-          collect_request_listeners
+          @listeners = Hash.new { |h, k| h[k] = Set.new }
+          add_listeners_from(request)
+        end
+
+        # Clear all strategy information
+        def clear
+          @listeners.clear
+          @objects_pool.clear
+          @stage = @context = @objects_pool = @data_pool = @listeners = nil
         end
 
         # Executes the strategy in the normal mode
@@ -48,17 +55,12 @@ module Rails # :nodoc:
 
         # Find a given +type+ and store it on request cache
         def find_type!(type)
-          request.cache(:types)[type] ||= schema.find_type!(type)
+          request.nested_cache(:types, type) { schema.find_type!(type) }
         end
 
         # Find a given +directive+ and store it on request cache
         def find_directive!(directive)
-          request.cache(:directives)[directive] ||= schema.find_directive!(directive)
-        end
-
-        # Check if it's enabled to collect listeners
-        def add_listeners?
-          !listeners.frozen?
+          request.nested_cache(:directives, directive) { schema.find_directive!(directive) }
         end
 
         # Check if any listener were actually added
@@ -79,8 +81,8 @@ module Rails # :nodoc:
 
         # When a +field+ has a perform step, run it under the context of the
         # prepared value from the data pool
-        def perform(field)
-          context.stacked(@data_pool[field]) do
+        def perform(field, data = nil)
+          context.stacked(data || @data_pool[field]) do
             safe_store_data(field) do
               Event.trigger(:perform, field, self, &field.performer)
             end
@@ -91,27 +93,26 @@ module Rails # :nodoc:
         # block using context stack
         def prepare(field, &block)
           value = safe_store_data(field) do
-            Event.trigger(:prepare, field, self, **PREPARE_XARGS)
+            prepared = request.prepared_data_for(field)
+            if prepared.is_a?(PreparedData)
+              field.prepared_data!
+              prepared.all
+            else
+              Event.trigger(:prepare, field, self, **PREPARE_XARGS)
+            end
           end
 
-          return context.stacked(value, &block) unless value.nil?
+          perform(field, value) if field.mutation?
 
-          stack = field.all_events[:prepare].map { |cb| cb.source_location.join(':') }
-          request.report_node_error(<<~MSG.squish, field, stack: stack.reverse)
-            It is expected to get a result from prepare events
-          MSG
+          value = @data_pool[field]
+          context.stacked(value, &block) unless value.nil?
         end
 
         # Resolve a value for a given object, It uses the +args+ to prevent
         # problems with nil values.
         def resolve(field, *args, array: false, decorate: false, &block)
-          rescue_with_handler(field: field) do
-            prepared = data_for(args, field)&.last
-            args << Event.trigger(:resolve, field, self, prepared: prepared,
-              &field.resolver) if field.try(:dynamic_resolver?)
-          end if args.size.zero?
+          resolve_data_for(field, args)
 
-          # Now we have a value to set on the context
           value = args.last
           value = field.decorate(value) if decorate
           context.stacked(value) do |current|
@@ -124,12 +125,18 @@ module Rails # :nodoc:
           end
         end
 
-        # Safe trigger an event and ensure to send any exception to the request
-        # handler
-        def rescue_with_handler(**extra)
-          yield
-        rescue => error
-          request.rescue_with_handler(error, **extra)
+        # Get the resolved data for a given field
+        def resolve_data_for(field, args)
+          return unless args.size.zero?
+
+          if field.try(:dynamic_resolver?)
+            prepared = prepared_data_for(field)
+            args << Event.trigger(:resolve, field, self, prepared: prepared, &field.resolver)
+          elsif field.prepared_data?
+            args << prepared_data_for(field)
+          else
+            data_for(args, field)
+          end
         end
 
         # Check if the given class is in the pool, or add a new instance to the
@@ -154,20 +161,35 @@ module Rails # :nodoc:
         def trigger_event(event_name, **xargs)
           return unless listening_to?(event_name)
 
-          objects = listeners[event_name.to_sym] & request.stack
-          return if objects.empty?
+          # A simpler attempt to remove select less objects (or even none) by
+          # assuming that the first item will work as exclusive and
+          # non-exclusive, and the others, only non-exclusive or anything
+          # different than a +Callback+
+          event_name = event_name.to_sym
+          list = listeners[event_name]
+          objects = request.stack.select.with_index do |obj, idx|
+            next unless list.include?(obj)
+            next true if idx == 0
+
+            obj.all_events.try(:[], event_name)&.any? do |ev|
+              !(ev.is_a?(Callback) && ev.exclusive?)
+            end
+          end
 
-          Event.trigger(event_name, objects, self, **xargs)
+          # Now trigger with more for all the selected objects
+          Event.trigger(event_name, objects, self, **xargs) if objects.present?
         end
 
         # Check what kind of event listeners the object have, in order to speed
-        # up processing by avoiding unnecesary event instances
-        def add_listener(object)
-          return unless add_listeners?
-
-          object.all_listeners.each do |event_name|
+        # up processing by avoiding unnecessary event instances
+        def add_listeners_from(object)
+          object.all_listeners&.each do |event_name|
             listeners[event_name] << object
           end
+
+          if request.prepared_data_for?(object)
+            listeners[:prepare] << object
+          end
         end
 
         # Store a given resolve +value+ for a given +field+
@@ -177,48 +199,93 @@ module Rails # :nodoc:
 
         # Only store a given +value+ for a given +field+ if it is not set yet
         def safe_store_data(field, value = nil)
-          rescue_with_handler(field: field) do
-            value ||= yield if block_given?
-            @data_pool[field] ||= value unless value.nil?
+          value ||= yield if block_given?
+          @data_pool[field] ||= value unless value.nil?
+        end
+
+        # Get the prepared data for the given +field+, getting ready for
+        # resolve, while ensuring to check prepared data on request
+        def prepared_data_for(field)
+          return @data_pool[field] unless field.prepared_data?
+
+          prepared = request.prepared_data_for(field).next
+          prepared unless prepared === PreparedData::NULL
+        end
+
+        # Simply run the organize step for compilation
+        def compile
+          for_each_operation { |op| collect_listeners { op.organize! } }
+        end
+
+        # Build the cache object
+        def cache_dump
+          { class: self.class }
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          data, operations, fragments = data.values_at(:strategy, :operations, :fragments)
+
+          collect_listeners do
+            # Load all operations
+            operations = operations.transform_values do |operation|
+              request.build_from_cache(operation.delete(:type)).tap do |instance|
+                instance.instance_variable_set(:@request, request)
+                instance.cache_load(operation)
+              end
+            end
+
+            # Load all fragments
+            fragments = fragments&.transform_values do |fragment|
+              request.build_from_cache(Component::Fragment).tap do |instance|
+                instance.instance_variable_set(:@request, request)
+                instance.cache_load(fragment)
+              end
+            end
           end
+
+          # Mark itself as already organized
+          @organized = true
+
+          # Save operations and fragments into the request
+          request.instance_variable_set(:@operations, operations)
+          request.instance_variable_set(:@fragments, fragments)
         end
 
         protected
 
-          # Clean and enable the collecting of listeners
-          def release_listeners!
-            @listeners = @base_listeners.dup
-          end
+          # Execute a given block for each defined operation
+          def for_each_operation
+            operations.each do |key, value|
+              operations[key] = Component::Operation.build(request, value) \
+                if value.is_a?(::GQLParser::Token)
 
-          # Disable the collecting of listeners
-          def lock_listeners!
-            listeners.freeze
+              yield(operations[key])
+            end
           end
 
-          # A shortcut for +release_listeners!+ and +lock_listeners!+
+          # A start of the organize step
           def collect_listeners
-            release_listeners!
+            return if defined?(@organized)
+            @stage = :organize
             yield
-            lock_listeners!
           end
 
           # This is where the strategy is most effective. By preparing the tree,
           # it can load data in a pretty smart way
-          def collect_data
+          def collect_data(force = false)
+            @stage = :prepare
             @data_pool = {}
             @context = request.build(Request::Context)
 
             # TODO: Create an orchestrator to allow cross query loading
-            yield if listening_to?(:prepare)
+            yield if force || listening_to?(:prepare)
           end
 
-          # Initiate the response context, named
-          # ({Request::Context}[rdoc-ref:Rails::GraphQL::Request::Context])
-          # and start collecting results
+          # Start collecting results
           def collect_response
+            @stage = :resolve
             yield
-          ensure
-            @context = @objects_pool = @data_pool = @listeners = nil
           end
 
           # Fetch the data for a given field and set as the first element
@@ -232,17 +299,6 @@ module Rails # :nodoc:
 
             result << current[key] if current.respond_to?(:key?) && current.key?(key)
           end
-
-        private
-
-          # Collect the base listeners from the request
-          def collect_request_listeners
-            @listeners = Hash.new { |h, k| h[k] = [] }
-            add_listener(request)
-
-            lock_listeners!
-            @base_listeners = @listeners
-          end
       end
     end
   end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Request
+      # = GraphQL Request Subscription
+      #
+      # A simple object to store information about a generated subscription
+      # TODO: Add a callback for the schema allowing it to prepare the context
+      # before saving it into a subscription
+      class Subscription
+        NULL_SCOPE = Object.new.freeze
+
+        attr_reader :sid, :schema, :args, :field, :scope, :context, :broadcastable,
+          :origin, :last_updated_at, :operation_id
+
+        alias broadcastable? broadcastable
+
+        def initialize(request, operation)
+          entrypoint = operation.selection.each_value.first
+
+          @schema = request.schema.namespace
+          @origin = request.origin
+          @operation_id = operation.hash
+          @args = entrypoint.arguments.to_h
+          @field = entrypoint.field
+          @context = request.context.to_h
+          @broadcastable = operation.broadcastable?
+          updated!
+
+          @scope = parse_scope(field.full_scope, request, operation)
+          @sid = request.schema.subscription_id_for(self)
+        end
+
+        def updated!
+          @last_updated_at = Time.current
+        end
+
+        def marshal_dump
+          raise ::TypeError, +"Request subscriptions must not be used as payload."
+        end
+
+        def inspect
+          (+<<~INFO).squish << '>'
+            #<#{self.class.name}
+            #{schema}@#{sid}
+            [#{scope.nil? ? scope.inspect : scope.hash}, #{args.hash}]
+            #{field.inspect}
+          INFO
+        end
+
+        protected
+
+          def parse_scope(list, request, operation)
+            enum = GraphQL.enumerate(list)
+            return NULL_SCOPE if enum.empty?
+
+            ext_self = nil
+            enum.map do |item|
+              case item
+              when Symbol
+                context[item]
+              when Proc
+                next item.call if item.arity == 0
+
+                ext_self ||= SimpleDelegator.new(self).tap do |object|
+                  object.define_singleton_method(:request) { request }
+                  object.define_singleton_method(:operation) { operation }
+                end
+
+                item.call(ext_self)
+              else
+                item
+              end
+            end.compact
+          end
+      end
+    end
+  end
+end