collavre 0.24.0 → 0.25.0

data/app/models/collavre/comment/broadcastable.rb

@@ -18,6 +18,18 @@ module Collavre
       end
 
       module ClassMethods
+        # The one enqueue seam for badge recomputation. Every write path that
+        # invalidates a badge goes through here rather than calling
+        # #broadcast_badges directly, so "badges are recounted off the request"
+        # holds for all of them and can't drift back one caller at a time.
+        # #broadcast_badges itself stays synchronous: the job — and the tests
+        # that pin the arithmetic — need a place that just computes.
+        def broadcast_badges_later(creative)
+          return unless creative
+
+          CommentBadgesBroadcastJob.perform_later(creative.id)
+        end
+
         def broadcast_badges(creative)
           origin = creative.effective_origin
           users = [ origin.user ].compact + origin.all_shared_users(:feedback).map(&:user)
@@ -25,74 +37,32 @@ module Collavre
           users.uniq!
           return if users.empty?
 
-          user_ids = users.map(&:id)
-
-          pointers = CommentReadPointer.where(user_id: user_ids, creative: origin).index_by(&:user_id)
-          present_user_ids = CommentPresenceStore.list(origin.id)
-
-          public_count = origin.comments.public_only.count
-          private_counts = origin.comments
-            .where(private: true, user_id: user_ids)
-            .group(:user_id)
-            .count
-
-          last_read_ids = pointers.transform_values { |p| p.last_read_comment_id || 0 }
-
-          unread_public_by_threshold = {}
-          # Include 0 for users without a read pointer (never opened chat)
-          all_thresholds = (last_read_ids.values + [ 0 ]).uniq
-          all_thresholds.each do |threshold|
-            unread_public_by_threshold[threshold] = origin.comments
-              .where(private: false)
-              .where("comments.id > ?", threshold)
-              .count
-          end
-
-          unread_private_counts = {}
-          user_ids.each do |uid|
-            threshold = last_read_ids[uid] || 0
-            unread_private_counts[uid] = origin.comments
-              .where(private: true, user_id: uid)
-              .where("comments.id > ?", threshold)
-              .count
-          end
+          badges_by_user_id = Creatives::CommentBadgeIndex.for_users(origin: origin, users: users)
 
           users.each do |u|
-            user_private_count = private_counts[u.id] || 0
-            total_count = public_count + user_private_count
-
-            threshold = last_read_ids[u.id] || 0
-            unread_public = unread_public_by_threshold[threshold] || 0
-            unread_private = unread_private_counts[u.id] || 0
-            unread_count = unread_public + unread_private
-
-            unread_count = 0 if present_user_ids.include?(u.id)
+            badge = badges_by_user_id.fetch(u.id)
 
             Turbo::StreamsChannel.broadcast_replace_to(
               [ u, origin, :comment_badge ],
               target: "comment-badge-#{origin.id}",
               partial: "inbox/badge_component/count",
               locals: {
-                count: unread_count,
+                count: badge.unread_count,
                 badge_id: "comment-badge-#{origin.id}",
-                show_zero: total_count.positive?
+                show_zero: badge.visible_comments
               }
             )
 
             # Also update the global inbox badge when the creative is an inbox
-            broadcast_inbox_badge(origin, u, count: unread_count) if origin.inbox?
+            broadcast_inbox_badge(origin, u, count: badge.unread_count) if origin.inbox?
           end
         end
 
         def broadcast_badge(creative, user)
           origin = creative.effective_origin
-          visible_comments = origin.comments.visible_to(user)
-          comments_count = visible_comments.count
-          pointer = CommentReadPointer.find_by(user: user, creative: origin)
-          last_read_id = pointer&.last_read_comment_id
-          unread_scope = last_read_id ? visible_comments.where("comments.id > ?", last_read_id) : visible_comments
-          unread_count = unread_scope.count
-          unread_count = 0 if CommentPresenceStore.list(origin.id).include?(user.id)
+          badge_index = Creatives::CommentBadgeIndex.new(user: user)
+          badge_index.index([ origin ])
+          unread_count = badge_index.unread_count_for(origin)
           Turbo::StreamsChannel.broadcast_replace_to(
             [ user, origin, :comment_badge ],
             target: "comment-badge-#{origin.id}",
@@ -100,7 +70,7 @@ module Collavre
             locals: {
               count: unread_count,
               badge_id: "comment-badge-#{origin.id}",
-              show_zero: comments_count.positive?
+              show_zero: badge_index.visible_comments?(origin)
             }
           )
 
@@ -187,7 +157,7 @@ module Collavre
 
       def broadcast_badges
         return unless creative
-        self.class.broadcast_badges(creative)
+        self.class.broadcast_badges_later(creative)
       end
     end
   end

data/app/models/collavre/comment/notifiable.rb

@@ -3,17 +3,21 @@ module Collavre
     module Notifiable
       extend ActiveSupport::Concern
 
+      NOTIFICATION_RELEVANT_ATTRIBUTES = %w[
+        action approver_id content creative_id private topic_id user_id
+      ].freeze
+
       included do
-        after_create_commit :notify_write_users, :notify_mentions, :notify_approver
+        before_update :advance_notification_revision, if: :notification_relevant_change?
+        after_create_commit :enqueue_create_notifications, if: :notification_eligible_on_create?
       end
 
-      def mentioned_users
+      def mentioned_users(notification_content = content)
         return Collavre.user_class.none unless user
-        emails = mentioned_emails - [ user.email.downcase ]
-        names = mentioned_names - [ user.name.downcase ]
 
-        origin = creative.effective_origin
-        mentionable_users = Collavre.user_class.mentionable_for(origin)
+        emails = mentioned_emails(notification_content) - [ user.email.downcase ]
+        names = mentioned_names(notification_content) - [ user.name.downcase ]
+        mentionable_users = Collavre.user_class.mentionable_for(creative.effective_origin)
 
         scope = Collavre.user_class.none
         scope = scope.or(mentionable_users.where(email: emails)) if emails.any?
@@ -21,54 +25,128 @@ module Collavre
         scope
       end
 
-      # Notify users about a completed AI streaming message.
-      # Called from ResponseFinalizer after placeholder is updated with final content.
-      # Sends both write-user and mention notifications that were skipped at placeholder creation.
-      # Errors are rescued to avoid breaking the finalization flow.
+      def notification_event
+        {
+          "creative_id" => creative_id,
+          "content" => content,
+          "regular_notification" => regular_notification_eligible?,
+          "approval_notification" => approval_notification_eligible?,
+          "revision" => notification_revision
+        }
+      end
+
+      # Notify users about a completed AI streaming message without holding up
+      # response finalization. Placeholder notifications are skipped on create.
       def notify_ai_completion
         return unless user&.ai_user?
-        return if private?
+        return if private? || suppress_inbox_notification?
 
-        notify_ai_write_users
-        notify_ai_mentions
+        CommentNotificationJob.perform_later(id, "ai_completion", notification_event)
       rescue StandardError => e
         Rails.logger.error("[notify_ai_completion] Failed for comment #{id}: #{e.message}")
       end
 
+      def deliver_notifications(kind, event)
+        event = event.stringify_keys
+        return unless event["creative_id"] == creative_id
+        return unless event["revision"] == notification_revision
+
+        notification_content = event.fetch("content", content)
+
+        case kind.to_s
+        when "created"
+          if event["regular_notification"]
+            notify_write_users("created", notification_content)
+            notify_mentions("created", notification_content)
+          end
+          notify_approver("created") if event["approval_notification"]
+        when "ai_completion"
+          return unless user&.ai_user?
+          return if private? || suppress_inbox_notification?
+
+          notify_write_users("ai_completion", notification_content)
+          notify_mentions("ai_completion", notification_content)
+        else
+          raise ArgumentError, "Unknown comment notification kind: #{kind}"
+        end
+      end
+
       private
 
-      def create_inbox_comment(owner, key, params = {})
+      def notification_relevant_change?
+        return false if skip_notification_revision
+
+        NOTIFICATION_RELEVANT_ATTRIBUTES.any? { |attribute| will_save_change_to_attribute?(attribute) }
+      end
+
+      def advance_notification_revision
+        self.notification_revision += 1
+      end
+
+      def notification_eligible_on_create?
+        regular_notification_eligible? || approval_notification_eligible?
+      end
+
+      def regular_notification_eligible?
+        !private? && !streaming_placeholder? && !suppress_inbox_notification?
+      end
+
+      def approval_notification_eligible?
+        approver.present? && approval_action? && !creative&.inbox?
+      end
+
+      def enqueue_create_notifications
+        CommentNotificationJob.perform_later(id, "created", notification_event)
+      end
+
+      def create_inbox_comment(owner, key, params = {}, delivery_key: nil)
         inbox_creative = Creative.inbox_for(owner)
         return unless inbox_creative
 
         system_topic = inbox_creative.system_topic(fallback_user: owner)
         msg = I18n.t(key, **params.symbolize_keys, locale: owner.locale || "en")
-
-        comment = Comment.create!(
+        attributes = {
           creative: inbox_creative,
           topic: system_topic,
           content: msg,
           user: nil,
           skip_default_user: true,
           quoted_comment: self
-        )
+        }
+
+        if delivery_key
+          comment = nil
+          delivery = nil
+
+          Comment.transaction do
+            comment = Comment.create_or_find_by!(notification_key: delivery_key) do |candidate|
+              candidate.assign_attributes(attributes)
+            end
+            delivery = CommentNotificationDelivery.create_or_find_by!(delivery_key: delivery_key) do |candidate|
+              candidate.assign_attributes(
+                inbox_comment_id: comment.id,
+                recipient_id: owner.id,
+                message: msg,
+                link: inbox_comment_link
+              )
+            end
+          end
 
-        Comment.broadcast_inbox_badge(inbox_creative, owner)
-        PushNotificationJob.perform_later(owner.id, message: msg, link: inbox_comment_link)
-        comment
+          delivery.enqueue_push!
+          comment
+        else
+          comment = Comment.create!(attributes)
+          PushNotificationJob.perform_later(owner.id, message: msg, link: inbox_comment_link)
+          comment
+        end
       rescue StandardError => e
         Rails.logger.error("[Notifiable] Failed to create inbox comment for user #{owner.id}: #{e.message}")
-        nil
-      end
-
-      # Keep legacy method for backward compatibility during transition
-      def create_inbox_item(owner, key, params = {})
-        create_inbox_comment(owner, key, params)
+        raise
       end
 
       def creative_markdown_link(target_creative = creative)
-        path = Collavre::Engine.routes.url_helpers.creative_path(target_creative, open_comments: true)
-        "[#{target_creative.creative_snippet}](#{path})"
+        path = Collavre::Engine.routes.url_helpers.creative_path(target_creative, comment_id: id)
+        "[#{target_creative.creative_snippet_markdown}](#{path})"
       end
 
       def inbox_comment_link
@@ -83,25 +161,29 @@ module Collavre
         user&.ai_user? && content == STREAMING_PLACEHOLDER_CONTENT
       end
 
-      def mentioned_emails
-        return [] unless content
-        content.scan(/@([\w.\-+]+@[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,})/)
-               .flatten
-               .map(&:downcase)
-               .uniq
+      def mentioned_emails(notification_content = content)
+        return [] unless notification_content
+
+        notification_content
+          .scan(/@([\w.\-+]+@[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,})/)
+          .flatten
+          .map(&:downcase)
+          .uniq
       end
 
-      def mentioned_names
-        return [] unless content
-        content.scan(/@([^:]+):/)
-               .flatten
-               .map(&:downcase)
-               .uniq
+      def mentioned_names(notification_content = content)
+        return [] unless notification_content
+
+        notification_content
+          .scan(/@([^:]+):/)
+          .flatten
+          .map(&:downcase)
+          .uniq
       end
 
       # Build the list of write-access recipients minus the comment author,
       # mentioned users, and users currently present on the creative.
-      def notification_recipients
+      def notification_recipients(notification_content = content)
         base_creative = creative.effective_origin
         present_ids = CommentPresenceStore.list(base_creative.id)
 
@@ -110,57 +192,43 @@ module Collavre
         recipients.compact!
         recipients.uniq!
         recipients.delete(user)
-        recipients -= mentioned_users.to_a
-        recipients.reject! { |u| present_ids.include?(u.id) }
+        recipients -= mentioned_users(notification_content).to_a
+        recipients.reject! { |recipient| present_ids.include?(recipient.id) }
         recipients
       end
 
-      def notify_write_users
-        return if private? || !user
-        return if streaming_placeholder?
-        return if suppress_inbox_notification? # only the System topic is the alarm stream
-        notification_recipients.each do |recipient|
+      def notify_write_users(kind, notification_content)
+        return unless user
+
+        notification_recipients(notification_content).each do |recipient|
           create_inbox_comment(
             recipient,
             "inbox.comment_added",
-            { user: user.display_name, comment: content, creative: creative_markdown_link }
+            {
+              user: user.display_name,
+              comment: notification_content,
+              creative: creative_markdown_link
+            },
+            delivery_key: notification_delivery_key(kind, "write", recipient)
           )
         end
       end
 
-      def notify_mentions
-        return if private?
-        return if streaming_placeholder?
-        return if suppress_inbox_notification? # only the System topic is the alarm stream
-        notify_mentioned_users
-      end
-
-      def notify_mentioned_users
-        mentioned_users.each do |mentioned|
+      def notify_mentions(kind, notification_content)
+        mentioned_users(notification_content).each do |mentioned|
           create_inbox_comment(
             mentioned,
             "inbox.user_mentioned",
-            { user: user.display_name, comment: content, creative: creative_markdown_link }
+            {
+              user: user.display_name,
+              comment: notification_content,
+              creative: creative_markdown_link
+            },
+            delivery_key: notification_delivery_key(kind, "mention", mentioned)
           )
         end
       end
 
-      def notify_ai_write_users
-        return if suppress_inbox_notification? # only the System topic is the alarm stream
-        notification_recipients.each do |recipient|
-          create_inbox_comment(
-            recipient,
-            "inbox.comment_added",
-            { user: user.display_name, comment: content, creative: creative_markdown_link }
-          )
-        end
-      end
-
-      def notify_ai_mentions
-        return if suppress_inbox_notification? # only the System topic is the alarm stream
-        notify_mentioned_users
-      end
-
       # #1301 made every inbox topic EXCEPT System dispatch like a normal topic;
       # the alarm stream follows suit. Suppress notifications ONLY for the System
       # topic itself (its system-authored notices must not cascade into more
@@ -171,7 +239,11 @@ module Collavre
         creative&.inbox? && inbox_system_topic?
       end
 
-      def notify_approver
+      def notification_delivery_key(kind, recipient_type, recipient)
+        "comment:#{id}:#{notification_revision}:#{kind}:#{recipient_type}:recipient:#{recipient.id}"
+      end
+
+      def notify_approver(kind)
         return unless approver.present? && approval_action?
         return if approver == user
         return if creative&.inbox? # Don't notify about inbox comments
@@ -179,7 +251,12 @@ module Collavre
         create_inbox_comment(
           approver,
           "inbox.approval_requested",
-          { user: user&.display_name, tool_name: parsed_action_tool_name, creative: creative_markdown_link }
+          {
+            user: user&.display_name,
+            tool_name: parsed_action_tool_name,
+            creative: creative_markdown_link
+          },
+          delivery_key: notification_delivery_key(kind, "approver", approver)
         )
       end
     end

data/app/models/collavre/comment/topic_membership.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Collavre
+  class Comment
+    module TopicMembership
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :assign_main_topic, on: :create
+        before_validation :stamp_topic_assignment
+        before_create :lock_matching_topic
+      end
+
+      private
+
+      def assign_main_topic
+        return if topic_id.present?
+        return unless creative
+
+        fallback = user || Collavre.current_user || creative.user
+        self.topic = creative.main_topic(fallback_user: fallback)
+      end
+
+      # Paging snapshots topic membership separately from comment ids. Content
+      # edits leave this timestamp alone; topic changes advance it.
+      def stamp_topic_assignment
+        return unless will_save_change_to_topic_id? || topic_assigned_at.nil?
+
+        self.topic_assigned_at = Time.current
+      end
+
+      def lock_matching_topic
+        locked_topic = Topic.where(id: topic_id).lock.first
+        return if locked_topic&.creative_id == creative_id
+
+        errors.add(:topic, I18n.t("collavre.comments.invalid_topic"))
+        throw :abort
+      end
+    end
+  end
+end