upkeep-rails 0.2.5-aarch64-linux-gnu

data/lib/upkeep/invalidation/collection_prepend.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Upkeep
+  module Invalidation
+    class CollectionPrepend
+      def self.build(recipe:, change:)
+        new(recipe, change).build
+      end
+
+      def initialize(recipe, change)
+        @recipe = recipe
+        @change = change
+      end
+
+      def build
+        replay = recipe.replay
+        return unless replay.is_a?(Replay::Collection)
+        return if replay.derived_partial?
+        return unless create_change?
+
+        collection = replay.collection
+        return unless collection.is_a?(Replay::ActiveRecordRelationValue)
+        return unless collection.primary_key
+        return unless collection.appendable? || unfilled_limit_window?(collection)
+
+        model = constantize(collection.model)
+        return unless change.fetch(:table) == model.table_name
+
+        record = model.find_by(id: change.fetch(:id))
+        return unless record && relation_prepends_record?(model, collection, record)
+
+        Replay::Recipe.new(
+          kind: :render_site_prepend,
+          frame_id: recipe.frame_id,
+          target_kind: recipe.target_kind,
+          target_id: recipe.target_id,
+          template: recipe.template,
+          metadata: recipe.metadata,
+          runtime: "rails",
+          replay: Replay::CollectionMember.new(
+            controller_class: replay.controller_class,
+            partial: replay.partial,
+            record: Replay.active_record_value(record),
+            options: replay.options
+          )
+        )
+      end
+
+      private
+
+      attr_reader :recipe, :change
+
+      def create_change?
+        change[:id] && change.fetch(:type).to_s.include?("create")
+      end
+
+      def relation_prepends_record?(model, collection, record)
+        primary_key = collection.primary_key
+        snapshot_ids = collection.member_ids.map(&:to_s)
+        candidate_ids = (snapshot_ids + [record.public_send(primary_key).to_s]).uniq
+        ordered_ids = model.find_by_sql(collection.sql).filter_map do |candidate|
+          candidate_id = candidate.public_send(primary_key).to_s
+          candidate_id if candidate_ids.include?(candidate_id)
+        end
+
+        ordered_ids.first == record.public_send(primary_key).to_s &&
+          (snapshot_ids - ordered_ids).empty?
+      end
+
+      def unfilled_limit_window?(collection)
+        return false unless collection.limit_value
+
+        limit = Integer(collection.limit_value)
+        limit.positive? && collection.member_ids.size < limit
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      def constantize(name)
+        name.to_s.split("::").reduce(Object) { |namespace, constant_name| namespace.const_get(constant_name) }
+      end
+    end
+  end
+end

data/lib/upkeep/invalidation/collection_remove.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Upkeep
+  module Invalidation
+    class CollectionRemove
+      def self.build(recipe:, change:)
+        new(recipe, change).build
+      end
+
+      def initialize(recipe, change)
+        @recipe = recipe
+        @change = change
+      end
+
+      def build
+        replay = recipe.replay
+        return unless replay.is_a?(Replay::Collection)
+        return unless destroy_change?
+
+        collection = replay.collection
+        return unless collection.is_a?(Replay::ActiveRecordRelationValue)
+        return unless collection.member_ids.map(&:to_s).include?(change.fetch(:id).to_s)
+
+        model = constantize(collection.model)
+        return unless change.fetch(:table) == model.table_name
+
+        Replay::Recipe.new(
+          kind: :render_site_remove,
+          frame_id: recipe.frame_id,
+          target_kind: "dom_id",
+          target_id: dom_id(model, change.fetch(:id)),
+          template: recipe.template,
+          metadata: recipe.metadata,
+          runtime: "rails",
+          replay: Replay::Empty.new
+        )
+      end
+
+      private
+
+      attr_reader :recipe, :change
+
+      def destroy_change?
+        type = change.fetch(:type).to_s
+        change[:id] && (type.include?("destroy") || type.include?("delete"))
+      end
+
+      def dom_id(model, id)
+        "#{model.model_name.param_key}_#{id}"
+      end
+
+      def constantize(name)
+        name.to_s.split("::").reduce(Object) { |namespace, constant_name| namespace.const_get(constant_name) }
+      end
+    end
+  end
+end

data/lib/upkeep/invalidation/planner.rb

@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module Upkeep
+  module Invalidation
+    class Planner
+      PlannedTarget = Data.define(
+        :subscription_id,
+        :subscriber_id,
+        :subscriber_ids,
+        :recipients,
+        :target,
+        :shared_stream_target,
+        :frame_id,
+        :identity_signature,
+        :sharing_signature,
+        :deployment_signature,
+        :recipe,
+        :matched_dependency_keys,
+        :action,
+        :deoptimization_reason
+      ) do
+        def represented_subscriber_count
+          subscriber_ids.size
+        end
+
+        def render
+          recipe.render_target(target)
+        end
+
+        def manifest_replay?
+          recipe.manifest_target_render?(target)
+        end
+      end
+
+      Plan = Data.define(:targets, :candidate_entries, :matched_entries, :request_id) do
+        def summary
+          {
+            targets: targets.size,
+            represented_subscribers: targets.sum(&:represented_subscriber_count),
+            candidate_entries: candidate_entries.size,
+            matched_entries: matched_entries.size,
+            target_kinds: targets.map { |target| target.target.kind }.uniq.sort,
+            manifest_replay_targets: targets.count(&:manifest_replay?),
+            deoptimizations: targets.filter_map(&:deoptimization_reason).tally
+          }
+        end
+      end
+
+      def initialize(store:)
+        @store = store
+      end
+
+      def plan(changes)
+        changes = Array(changes)
+        payload = { change_count: changes.size }
+        ActiveSupport::Notifications.instrument("plan.upkeep", payload) do
+          @delivery_strategy_cache = {}
+          candidate_entries = store.reverse_index.entries_for(changes)
+          matched_entries = candidate_entries.select { |entry| changes.any? { |change| entry.dependency.matches_change?(change) } }
+          entries_by_subscription_id = matched_entries.group_by(&:subscription_id)
+          subscriptions_by_id = entries_by_subscription_id.keys.to_h do |subscription_id|
+            [subscription_id, store.fetch(subscription_id)]
+          end
+          represented_subscriber_ids = matched_entries.flat_map(&:represented_subscriber_ids).uniq
+          represented_subscriber_ids = subscriptions_by_id.values.map(&:subscriber_id).uniq if represented_subscriber_ids.empty?
+          shared_delivery = represented_subscriber_ids.size > 1
+
+          targets = entries_by_subscription_id.flat_map do |subscription_id, entries|
+            targets_for_subscription(
+              subscriptions_by_id.fetch(subscription_id),
+              entries,
+              changes,
+              shared_delivery: shared_delivery
+            )
+          end
+
+          plan = Plan.new(deduplicate_targets(targets), candidate_entries, matched_entries, request_id_for(changes))
+          payload.merge!(payload_for(plan))
+          plan
+        end
+      ensure
+        @delivery_strategy_cache = nil
+      end
+
+      private
+
+      attr_reader :store
+
+      # All changes in a set were captured during one request, so the first stamped
+      # request id speaks for the whole plan. Writes from jobs/console carry none.
+      def request_id_for(changes)
+        changes.filter_map { |change| change[:request_id] if change.respond_to?(:[]) }.first
+      end
+
+      def payload_for(plan)
+        {
+          candidate_entries: plan.candidate_entries.size,
+          matched_entries: plan.matched_entries.size,
+          targets: plan.targets.size,
+          represented_subscribers: plan.targets.sum(&:represented_subscriber_count),
+          target_kinds: plan.targets.map { |target| target.target.kind }.uniq.sort,
+          manifest_replay_targets: plan.targets.count(&:manifest_replay?),
+          actions: plan.targets.map(&:action).tally,
+          deoptimizations: plan.targets.filter_map(&:deoptimization_reason).tally
+        }
+      end
+
+      def targets_for_subscription(subscription, entries, changes, shared_delivery:)
+        frames_by_id = Hash.new { |hash, key| hash[key] = { node: nil, dependency_keys: [], entries: [] } }
+
+        entries.each do |entry|
+          subscription.graph.nearest_frame_nodes_from(entry.owner_id).each do |frame|
+            bucket = frames_by_id[frame.id]
+            bucket[:node] ||= frame
+            bucket[:dependency_keys] << entry.dependency_cache_key
+            bucket[:entries] << entry
+          end
+        end
+
+        remove_contained_frames(subscription.graph, frames_by_id.values.map { |bucket| bucket.fetch(:node) }, changes: changes).filter_map do |frame|
+          bucket = frames_by_id.fetch(frame.id)
+          build_target(subscription, frame, bucket.fetch(:dependency_keys).uniq, bucket.fetch(:entries), changes, shared_delivery: shared_delivery)
+        end
+      end
+
+      def remove_contained_frames(graph, frames, changes:)
+        frames = prefer_render_sites_for_destroy(graph, frames.uniq(&:id), changes)
+
+        frames.reject do |frame|
+          frames.any? { |candidate| candidate.id != frame.id && graph.contained_by?(frame.id, candidate.id) }
+        end
+      end
+
+      def prefer_render_sites_for_destroy(graph, frames, changes)
+        return frames unless changes.any? { |change| destroy_change?(change) }
+
+        render_sites = frames.select { |frame| frame.payload.fetch(:kind) == "render_site" }
+        return frames if render_sites.empty?
+
+        frames.reject do |frame|
+          frame.payload.fetch(:kind) == "page" &&
+            render_sites.any? { |render_site| graph.contained_by?(render_site.id, frame.id) }
+        end
+      end
+
+      def build_target(subscription, frame, dependency_keys, entries, changes, shared_delivery:)
+        target = target_for_frame(frame)
+        return unless target
+
+        frame_id = Targeting::Extraction.frame_id_for(target)
+        recipe = subscription.replay_recipe(frame_id)
+        return unless recipe
+
+        # The enclosing frame's target is the stream the subscription registered as shared
+        # (see SharedStreams.names_for_graph). Member-level deopts (remove/replace) retarget the
+        # operation at an individual member, so capture the enclosing target now to keep shared
+        # delivery on the same stream the subscribers listen on.
+        shared_stream_target = target
+        identity_signature = subscription.identity_signature(frame_id)
+        sharing_signature = SharedStreams.signature_for(recipe) if shared_delivery && identity_signature == "public" && frame.payload.fetch(:kind) == "render_site"
+        deployment_signature = SharedStreams.deployment_signature_for(subscription.graph, frame.id) if sharing_signature
+        action, recipe, delivery_target, deoptimization_reason = cached_delivery_strategy(subscription.graph, frame, recipe, entries, changes, sharing_signature: sharing_signature)
+        target = delivery_target || target
+        subscriber_ids = represented_subscriber_ids(subscription, entries)
+        recipients = represented_recipients(subscription, entries)
+
+        PlannedTarget.new(
+          subscription.id,
+          subscription.subscriber_id,
+          subscriber_ids,
+          recipients,
+          target,
+          shared_stream_target,
+          frame_id,
+          identity_signature,
+          sharing_signature,
+          deployment_signature,
+          recipe,
+          dependency_keys,
+          action,
+          deoptimization_reason
+        )
+      end
+
+      def represented_subscriber_ids(subscription, entries)
+        subscriber_ids = entries.flat_map(&:represented_subscriber_ids).uniq.sort_by(&:to_s)
+        return [subscription.subscriber_id] if subscriber_ids.empty?
+
+        subscriber_ids
+      end
+
+      def represented_recipients(subscription, entries)
+        recipients = entries.flat_map(&:represented_recipients).uniq
+        return [[subscription.id, subscription.subscriber_id]] if recipients.empty?
+
+        recipients.sort_by { |subscription_id, subscriber_id| [subscription_id.to_s, subscriber_id.to_s] }
+      end
+
+      def cached_delivery_strategy(graph, frame, recipe, entries, changes, sharing_signature:)
+        key = delivery_strategy_cache_key(frame, recipe, entries, changes, sharing_signature)
+        return delivery_strategy(graph, frame, recipe, entries, changes) unless key
+
+        @delivery_strategy_cache.fetch(key) do
+          @delivery_strategy_cache[key] = delivery_strategy(graph, frame, recipe, entries, changes)
+        end
+      end
+
+      def delivery_strategy_cache_key(frame, recipe, entries, changes, sharing_signature)
+        return unless sharing_signature
+
+        [
+          frame.payload.fetch(:kind),
+          frame.payload.fetch(:site_id),
+          sharing_signature,
+          entries.map { |entry| entry.dependency_cache_key.inspect }.uniq.sort,
+          changes.map { |change| change.slice(:type, :table, :id, :changed_attributes).inspect }.sort
+        ]
+      end
+
+      def target_for_frame(frame)
+        case frame.payload.fetch(:kind)
+        when "page"
+          Targeting::Target.new("page", frame.id, "page frame dependency matched committed change")
+        when "render_site"
+          Targeting::Target.new("render_site", frame.payload.fetch(:site_id), "render-site dependency matched committed change")
+        when "fragment"
+          Targeting::Target.new("fragment", frame.id, "record attribute read matched committed attributes")
+        when "turbo_frame"
+          Targeting::Target.new("turbo_frame", frame.payload.fetch(:target_id), "Turbo Frame dependency matched committed change")
+        end
+      end
+
+      def delivery_strategy(graph, frame, recipe, entries, changes)
+        remove_recipe = remove_recipe_for(frame, recipe, entries, changes)
+        if remove_recipe
+          return [
+            "remove",
+            remove_recipe,
+            target_for_recipe(remove_recipe, "render-site member was destroyed"),
+            nil
+          ]
+        end
+
+        append_recipe = append_recipe_for(frame, recipe, entries, changes)
+        return ["append", append_recipe, nil, nil] if append_recipe
+
+        prepend_recipe = prepend_recipe_for(frame, recipe, entries, changes)
+        return ["prepend", prepend_recipe, nil, nil] if prepend_recipe
+
+        member_replace_recipe = member_replace_recipe_for(frame, recipe, entries, changes)
+        if member_replace_recipe
+          delivery_target = target_for_recipe(member_replace_recipe, "render-site member update kept collection order")
+          return ["replace", member_replace_recipe, delivery_target, nil]
+        end
+
+        [fallback_action_for(frame), recipe, nil, deoptimization_reason(graph, frame, entries, changes)]
+      end
+
+      def fallback_action_for(frame)
+        case frame.payload.fetch(:kind)
+        when "page"
+          "refresh"
+        when "render_site"
+          "update"
+        else
+          "replace"
+        end
+      end
+
+      def append_recipe_for(frame, recipe, entries, changes)
+        return unless frame.payload.fetch(:kind) == "render_site"
+        return unless entries.any? { |entry| entry.dependency.source == :active_record_collection }
+
+        create_changes = changes.select { |change| change[:id] && change.fetch(:type).to_s.include?("create") }
+        return unless create_changes.one?
+
+        CollectionAppend.build(recipe: recipe, change: create_changes.first)
+      end
+
+      def prepend_recipe_for(frame, recipe, entries, changes)
+        return unless frame.payload.fetch(:kind) == "render_site"
+        return unless entries.any? { |entry| entry.dependency.source == :active_record_collection }
+
+        create_changes = changes.select { |change| change[:id] && change.fetch(:type).to_s.include?("create") }
+        return unless create_changes.one?
+
+        CollectionPrepend.build(recipe: recipe, change: create_changes.first)
+      end
+
+      def member_replace_recipe_for(frame, recipe, entries, changes)
+        return unless frame.payload.fetch(:kind) == "render_site"
+        return unless entries.any? { |entry| entry.dependency.source == :active_record_collection }
+
+        update_changes = changes.select do |change|
+          change[:id] && !change.fetch(:type).to_s.include?("create") && !destroy_change?(change)
+        end
+        return unless update_changes.one?
+
+        CollectionMemberReplace.build(recipe: recipe, change: update_changes.first)
+      end
+
+      def remove_recipe_for(frame, recipe, entries, changes)
+        return unless frame.payload.fetch(:kind) == "render_site"
+        return unless entries.any? { |entry| entry.dependency.source == :active_record_collection }
+
+        destroy_changes = changes.select do |change|
+          change[:id] && destroy_change?(change)
+        end
+        return unless destroy_changes.one?
+
+        CollectionRemove.build(recipe: recipe, change: destroy_changes.first)
+      end
+
+      def deoptimization_reason(graph, frame, entries, changes)
+        case frame.payload.fetch(:kind)
+        when "page"
+          page_frame_deoptimization_reason(graph, frame, entries)
+        when "render_site"
+          render_site_deoptimization_reason(entries, changes)
+        end
+      end
+
+      def render_site_deoptimization_reason(entries, changes)
+        return unless entries.any? { |entry| entry.dependency.source == :active_record_collection }
+
+        if changes.one? { |change| change[:id] && change.fetch(:type).to_s.include?("create") }
+          "collection_create_position_unproven"
+        elsif changes.one? { |change| change[:id] && destroy_change?(change) }
+          "collection_remove_unproven"
+        elsif changes.one? { |change| change[:id] && !change.fetch(:type).to_s.include?("create") && !destroy_change?(change) }
+          "collection_member_replace_unproven"
+        else
+          "collection_multi_change_fallback"
+        end
+      end
+
+      def page_frame_deoptimization_reason(graph, frame, entries)
+        return "no_render_site" unless contains_render_site?(graph, frame)
+
+        "page_frame_dependency:#{entries.map { |entry| dependency_source_label(entry.dependency) }.min}"
+      end
+
+      def contains_render_site?(graph, frame)
+        graph.contained_node_ids(frame.id).any? do |node_id|
+          node = graph.node(node_id)
+          node.kind == :frame && node.payload[:kind] == "render_site" && node.payload[:recipe]
+        end
+      end
+
+      def dependency_source_label(dependency)
+        return dependency.source.to_s unless dependency.identity?
+
+        "#{dependency.source}:#{dependency.key.fetch(:key)}"
+      end
+
+      def destroy_change?(change)
+        type = change.fetch(:type).to_s
+        type.include?("destroy") || type.include?("delete")
+      end
+
+      def target_for_recipe(recipe, reason)
+        Targeting::Target.new(recipe.target_kind, recipe.target_id, reason)
+      end
+
+      def deduplicate_targets(targets)
+        targets.each_with_object({}) do |target, indexed_targets|
+          key = deduplication_key(target)
+          indexed_targets[key] = merge_target(indexed_targets[key], target)
+        end.values
+      end
+
+      def deduplication_key(target)
+        subscriber_key = target.sharing_signature ? "shared" : target.subscriber_id
+
+        [
+          subscriber_key,
+          target.target.kind,
+          target.target.id,
+          target.identity_signature,
+          target.sharing_signature,
+          target.deployment_signature,
+          target.action,
+          target.deoptimization_reason
+        ]
+      end
+
+      def merge_target(existing, target)
+        return target unless existing
+
+        PlannedTarget.new(
+          existing.subscription_id,
+          existing.subscriber_id,
+          (existing.subscriber_ids + target.subscriber_ids).uniq.sort_by(&:to_s),
+          (existing.recipients + target.recipients).uniq.sort_by { |subscription_id, subscriber_id| [subscription_id.to_s, subscriber_id.to_s] },
+          existing.target,
+          existing.shared_stream_target,
+          existing.frame_id,
+          existing.identity_signature,
+          existing.sharing_signature,
+          existing.deployment_signature,
+          existing.recipe,
+          (existing.matched_dependency_keys + target.matched_dependency_keys).uniq,
+          existing.action,
+          existing.deoptimization_reason
+        )
+      end
+    end
+  end
+end

data/lib/upkeep/invalidation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "invalidation/collection_append"
+require_relative "invalidation/collection_member_replace"
+require_relative "invalidation/collection_prepend"
+require_relative "invalidation/collection_remove"
+require_relative "invalidation/planner"