rails-graphql 0.2.1 → 1.0.0.rc1

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
@@ -90,28 +92,28 @@ module Rails # :nodoc:
         # Execute the prepare step for the given +field+ and execute the given
         # block using context stack
         def prepare(field, &block)
+          check_fragment_multiple_prepare!(field)
           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 +126,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_data: 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 +162,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,71 +200,118 @@ 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)
+            # TODO: We don't need to traverse over the fields, we can
+            # get the ones with such event and use parent to figure out
+            # the stack
+            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
           # of the returned list
+          # TODO: Maybe implement root value to be returned by entry points
           def data_for(result, field)
             return result << @data_pool[field] if @data_pool.key?(field)
             return if field.entry_point?
 
-            current, key = context.current_value, field.method_name
-            return result << current.public_send(key) if current.respond_to?(key)
-
-            result << current[key] if current.respond_to?(:key?) && current.key?(key)
+            key = field.method_name
+            if (current = context.current_value).is_a?(::Hash)
+              result << (current.key?(key) ? current[key] : current[field.gql_name])
+            elsif current.respond_to?(key)
+              result << current.public_send(key)
+            end
           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
+          # If the data pool already have data for the given +field+ and there
+          # is a fragment in the stack, we throw back to the fragment
+          def check_fragment_multiple_prepare!(field)
+            return unless @data_pool.key?(field)
+            throw(:fragment_prepared) if request.stack.any?(Component::Fragment)
           end
       end
     end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Request
+      # = GraphQL Request Subscription
+      #
+      # A simple object to store information about a generated subscription
+      # TODO: Maybe 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, :created_at, :updated_at, :operation_id
+
+        alias broadcastable? broadcastable
+        alias id sid
+
+        def initialize(request, operation)
+          entrypoint = operation.selection.each_value.first            # Memory Fingerprint
+
+          @schema = request.schema.namespace                           # 1 Symbol
+          @origin = request.origin                                     # * HEAVY!
+          @operation_id = operation.hash                               # 1 Integer
+          @args = entrypoint.arguments.to_h                            # 1 Hash of GQL values
+          @field = entrypoint.field                                    # 1 Pointer
+          @context = request.context.to_h                              # 1 Hash +/- heavy
+          @broadcastable = operation.broadcastable?                    # 1 Boolean
+          @created_at = Time.current                                   # 1 Integer
+          updated!                                                     # 1 Integer
+
+          @scope = parse_scope(field.full_scope, request, operation)   # 1 Integer after save
+          @sid = request.schema.subscription_id_for(self)              # 1 String
+        end
+
+        def updated!
+          @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.inspect}, #{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