chats 0.1.1 → 0.3.1

data/lib/chats/engine.rb

@@ -30,7 +30,7 @@ module Chats
     CHATS_LIB = File.expand_path("chats", LIB_ROOT)
 
     ZEITWERK_IGNORED = %w[
-      version.rb errors.rb configuration.rb engine.rb macros.rb
+      version.rb errors.rb configuration.rb engine.rb macros.rb subscribers.rb
     ].freeze
 
     initializer "chats.autoload", before: :set_autoload_paths do
@@ -64,6 +64,13 @@ module Chats
       end
     end
 
+    # Hand the gem's deprecator to the app, so `config.active_support.
+    # deprecation` (and `deprecators.silence`) govern chats' own deprecation
+    # warnings like any other framework's.
+    initializer "chats.deprecator" do |app|
+      app.deprecators[:chats] = Chats.deprecator if app.respond_to?(:deprecators)
+    end
+
     # Expose `acts_as_messager` / `acts_as_chat_subject` on every AR model.
     initializer "chats.active_record" do
       ActiveSupport.on_load(:active_record) do
@@ -71,11 +78,20 @@ module Chats
       end
     end
 
-    # Ship the gem's locale files (en, es). Host locale files with the same
-    # keys override these automatically (I18n's load order puts the app last).
-    initializer "chats.locales" do |app|
-      app.config.i18n.load_path += Dir[root.join("config", "locales", "**", "*.{rb,yml}").to_s]
-    end
+    # The gem's locale files (en, es) ship through Rails::Engine's own
+    # :add_locales initializer, which picks up every engine's config/locales
+    # automatically — and deliberately NOT through a manual
+    # `app.config.i18n.load_path +=` on top of it.
+    #
+    # That append is not merely redundant, it inverts the contract: railtie
+    # paths are unshifted ahead of everything in load_path, so an appended
+    # copy lands AFTER the host's own locales and silently overrides them. A
+    # host rewording `chats.flashes.blocked` in its own es.yml would keep
+    # reading ours, with no error and nothing to see.
+    #
+    # Gem first, host last. `clickwrap` carries the same note; `support_desk`
+    # shipped the bug and measured it (its file sat in load_path 14 times and
+    # the host's override lost).
 
     # NOTE: the host-facing helpers (`chat_button_to`, `chats_unread_badge`, …)
     # are exposed to ActionView from the BOTTOM of engine_helper.rb itself
@@ -90,7 +106,8 @@ module Chats
 
     # -------------------------------------------------------------------------
     # JavaScript: the engine ships tiny Stimulus controllers (thread, composer,
-    # debounced-submit) with NO build step, pinned for importmap-rails hosts.
+    # debounced-submit, refresh-inbox) with NO build step, pinned for
+    # importmap-rails hosts.
     #
     # The pin keys live under "controllers/chats/..." ON PURPOSE: the stock
     # Rails `app/javascript/controllers/index.js` calls
@@ -125,6 +142,11 @@ module Chats
       if app.config.respond_to?(:assets)
         app.config.assets.paths << root.join("app/javascript")
         app.config.assets.paths << root.join("app/assets/stylesheets")
+
+        # Propshaft serves anything on the load path; Sprockets serves only
+        # what is on the precompile list, so a Sprockets host 404s the
+        # stylesheet without this line.
+        app.config.assets.precompile << "chats.css" if app.config.assets.respond_to?(:precompile)
       end
     end
 

data/lib/chats/errors.rb

@@ -17,4 +17,20 @@ module Chats
   # Raised when the host `can_message` policy (or a feature flag like
   # `config.groups = false`) forbids the attempted action.
   class NotAllowedError < Error; end
+
+  # Raised when a conversation's SUBJECT has locked it (see
+  # Chats::ChatSubject#chat_locked?) and something tries to write to it
+  # anyway — send, edit, delete, react. A subclass of NotAllowedError on
+  # purpose: a host that already rescues NotAllowedError keeps working, and
+  # one that wants to show the lock notice specifically can rescue this.
+  # System messages are never refused: the app must always be able to say
+  # "this was closed" in the thread it just closed.
+  class LockedError < NotAllowedError
+    attr_reader :conversation
+
+    def initialize(message = nil, conversation: nil)
+      @conversation = conversation
+      super(message || conversation&.locked_notice || "this conversation is closed")
+    end
+  end
 end

data/lib/chats/inbox.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+module Chats
+  # THE inbox query, in one object: load a viewer's recent conversations,
+  # optionally filter them, and fold the ones that belong to a stacked
+  # counterpart into Chats::InboxGroup rows.
+  #
+  #   Chats::Inbox.for(alice)                       # rows, newest activity first
+  #   Chats::Inbox.for(alice, query: "madrid")      # the search box
+  #   Chats::Inbox.for(alice, with: support_desk)   # one stack's contents
+  #
+  # Rows are `Chats::Conversation | Chats::InboxGroup`, sorted by last
+  # activity descending. Grouping happens HERE and nowhere else.
+  #
+  # == Why `inbox_limit` bounds ROWS, not conversations
+  #
+  # A stacked counterpart can hold hundreds of threads. Limiting the raw
+  # conversation query first would let a busy support desk EVICT everything
+  # else from the inbox — 200 desk threads and not one message from a friend.
+  # So the two populations are queried separately: ordinary conversations get
+  # the limit, stacked ones get their own bounded window, and the limit is
+  # applied again to the ROWS that come out. A stack's numbers
+  # (`open_count`, `unread_count`) are then GLOBAL, read with two indexed
+  # aggregates per stack — never per conversation, and never by loading the
+  # stack to count it.
+  class Inbox
+    include Enumerable
+
+    attr_reader :viewer, :query, :with
+
+    class << self
+      # The inbox for +viewer+. Returns a Chats::Inbox, which enumerates its
+      # rows (`to_a` for a plain Array).
+      def for(viewer, query: nil, with: nil)
+        new(viewer, query: query, with: with)
+      end
+    end
+
+    def initialize(viewer, query: nil, with: nil)
+      @viewer = viewer
+      @query = query.to_s.strip.presence
+      @with = with
+    end
+
+    # Conversation | InboxGroup rows, newest activity first, at most
+    # `config.inbox_limit` of them.
+    def rows
+      @rows ||= build_rows
+    end
+
+    # Yield each row (Enumerable gives `map`, `select`, `find`, … from here).
+    def each(&)
+      rows.each(&)
+    end
+
+    # The rows as a plain Array.
+    def to_a
+      rows
+    end
+
+    # How many rows the inbox has.
+    def size
+      rows.size
+    end
+
+    # Whether the inbox has any rows at all.
+    def any?
+      rows.any?
+    end
+
+    # Whether the inbox has no rows.
+    def empty?
+      rows.empty?
+    end
+
+    # The conversations behind the rows, stacked threads included. Stays an
+    # ActiveRecord::Relation (already loaded) in the simple case — no search,
+    # nothing stacked — so an inbox ejected under 0.1.x can still chain
+    # `.where` or hand it to a paginator. Becomes an Array once rows had to
+    # be assembled in Ruby.
+    def conversations
+      rows
+      @flat
+    end
+
+    # { conversation_id => unread message count } — one grouped query for
+    # every loaded conversation, which is what the row badges read.
+    def unread_counts
+      @unread_counts ||= Chats::Conversation.unread_counts_for(viewer, conversations)
+    end
+
+    # Unread messages in one conversation, from the grouped query above.
+    def unread_count_for(conversation)
+      unread_counts.fetch(conversation.id, 0)
+    end
+
+    # The stack-aware badge number: how many inbox ROWS carry unread content
+    # (a stack of five unread threads is still one thing to deal with).
+    # `Messager#unread_chats_count` is the unstacked count and is unchanged.
+    def unread_count
+      rows.count do |row|
+        row.is_a?(Chats::InboxGroup) ? row.unread? : unread_count_for(row).positive?
+      end
+    end
+
+    # True when scoped to one counterpart (`?with=`): a stack's contents,
+    # which are listed individually rather than re-stacked.
+    def filtered?
+      with.present?
+    end
+
+    private
+
+    def limit
+      Chats.config.inbox_limit
+    end
+
+    # Memoized so `config.inbox_scope` is consulted ONCE per inbox for the
+    # row query, however many legs it is split into (the stack aggregates
+    # apply it separately, to their own relation).
+    def base_relation
+      @base_relation ||= begin
+        relation = Chats::Conversation.inbox_for(viewer)
+                                      .includes(:last_message, :subject, participants: :messager)
+        Chats.config.inbox_scope.call(relation, viewer) || relation
+      end
+    end
+
+    # The polymorphic types worth splitting out. Empty when nothing stacks
+    # (an ordinary app pays nothing) and when the inbox is already filtered
+    # to one counterpart.
+    def grouped_types
+      @grouped_types ||= filtered? ? [] : Chats.grouped_messager_types
+    end
+
+    # Seats held by a stacked messager — never the viewer's own seat, so a
+    # stacked messager's OWN inbox stays flat.
+    def stacked_seats
+      Chats::Participant.select(:conversation_id)
+                        .where(messager_type: grouped_types)
+                        .where.not(messager_type: viewer.class.polymorphic_name, messager_id: viewer.id)
+    end
+
+    def load_conversations
+      if filtered?
+        @ungrouped_relation = filter_to_counterpart(base_relation).limit(limit)
+        @stacked = []
+      elsif grouped_types.empty?
+        @ungrouped_relation = base_relation.limit(limit)
+        @stacked = []
+      else
+        stacked = Chats::Conversation.direct.where(id: stacked_seats)
+        @ungrouped_relation = base_relation.where.not(id: stacked).limit(limit)
+        # Ordered by recency and limited like the other leg, which also makes
+        # the FIRST conversation of each counterpart that counterpart's
+        # freshest — that's the one the stacked row previews.
+        @stacked = apply_search(base_relation.direct.where(id: stacked_seats).limit(limit))
+      end
+
+      @ungrouped = apply_search(@ungrouped_relation)
+      # The relation itself when nothing had to be assembled in Ruby (it is
+      # loaded, so iterating it costs nothing extra); the flat Array otherwise.
+      @flat = @stacked.empty? && query.nil? ? @ungrouped_relation : @ungrouped + @stacked
+    end
+
+    # Only the direct threads shared with one counterpart. Direct only, by
+    # design: a group that happens to include the desk is not part of the
+    # desk's stack.
+    def filter_to_counterpart(relation)
+      seats = Chats::Participant.select(:conversation_id).where(
+        messager_type: with.class.polymorphic_name, messager_id: with.id
+      )
+      relation.direct.where(id: seats)
+    end
+
+    def build_rows
+      load_conversations
+      rows = @ungrouped.dup
+      stacks = {}
+
+      @stacked.each do |conversation|
+        counterpart = stacked_counterpart(conversation)
+        # The SQL prefilter matches by polymorphic type; an STI sibling that
+        # isn't actually grouped lands here and goes back to being a row.
+        next rows << conversation if counterpart.nil?
+
+        (stacks[Chats.messager_key(counterpart)] ||= [counterpart, []]).last << conversation
+      end
+
+      rows.concat(stacks.each_value.map { |messager, members| build_group(messager, members) })
+      sort_rows(rows).first(limit)
+    end
+
+    # Newest activity first, exactly like the SQL the relation would have
+    # used (COALESCE(last_message_at, created_at) DESC), at full timestamp
+    # precision — `to_r`, not `to_f`, because two messages a microsecond
+    # apart must not collapse into a tie. Ties break on id, so the order is
+    # total and a row never shuffles between renders.
+    def sort_rows(rows)
+      rows.sort do |a, b|
+        by_activity = sort_key(b).to_r <=> sort_key(a).to_r
+        by_activity.zero? ? compare_ids(b, a) : by_activity
+      end
+    end
+
+    def build_group(messager, members)
+      totals = stack_totals(messager)
+
+      Chats::InboxGroup.new(
+        messager: messager,
+        conversations: sort_rows(members),
+        unread_count: totals[:unread],
+        open_count: totals[:open]
+      )
+    end
+
+    # What a stacked row says about the WHOLE stack, in two indexed
+    # aggregates — independent of how deep the stack is, and of how much of
+    # it we loaded.
+    def stack_totals(messager)
+      scope = Chats::Conversation.inbox_for(viewer).reorder(nil).direct.where(
+        id: Chats::Participant.select(:conversation_id).where(
+          messager_type: messager.class.polymorphic_name, messager_id: messager.id
+        )
+      )
+      scope = Chats.config.inbox_scope.call(scope, viewer) || scope
+
+      {
+        open: scope.distinct.count,
+        unread: scope.unread_by(viewer).reorder(nil).count("chats_messages.id")
+      }
+    end
+
+    # The other party of a DIRECT conversation, when their class asked to be
+    # stacked (`acts_as_messager inbox: :grouped`). Read from the preloaded
+    # participants — no extra query per row.
+    def stacked_counterpart(conversation)
+      return nil unless conversation.direct?
+
+      other = conversation.participants.find do |participant|
+        participant.messager.present? && participant.messager != viewer
+      end&.messager
+
+      other if Chats.grouped_inbox?(other)
+    end
+
+    def sort_key(row)
+      row.last_message_at || (row.respond_to?(:created_at) ? row.created_at : nil) || Chats::Conversation::EPOCH
+    end
+
+    # The total-order tiebreak: a conversation's own id, a stack's freshest
+    # conversation's id. Works for bigint and uuid keys alike, and never
+    # raises on a pair it can't compare — it just calls them equal.
+    def compare_ids(a, b)
+      left = tiebreak(a)
+      right = tiebreak(b)
+      return 0 if left.nil? || right.nil? || left.class != right.class
+
+      left <=> right
+    end
+
+    def tiebreak(row)
+      row.is_a?(Chats::InboxGroup) ? row.conversation&.id : row.id
+    end
+
+    # Partial, case-insensitive matching across the inbox metadata users can
+    # actually see: participant names, conversation titles, subject labels,
+    # and message bodies. Each leg is capped (config.inbox_limit), so
+    # metadata is filtered portably in Ruby from the already-preloaded
+    # objects while the potentially larger message-body set stays in SQL. No
+    # PostgreSQL-only full-text dependency is needed at this scale.
+    def apply_search(relation)
+      return relation.to_a unless Chats.config.search && query
+
+      loaded = relation.to_a
+      normalized_query = query.downcase
+      message_match_ids = conversations_matching_body(loaded)
+
+      loaded.select do |conversation|
+        message_match_ids.include?(conversation.id) ||
+          searchable_metadata(conversation).downcase.include?(normalized_query)
+      end
+    end
+
+    def conversations_matching_body(conversations)
+      return [] if Chats.config.encrypt_messages || conversations.empty?
+
+      pattern = "%#{Chats::Conversation.sanitize_sql_like(query.downcase)}%"
+      Chats::Message.where(conversation_id: conversations.map(&:id), deleted_at: nil)
+                    .where("LOWER(chats_messages.body) LIKE ?", pattern)
+                    .distinct
+                    .pluck(:conversation_id)
+    end
+
+    def searchable_metadata(conversation)
+      participant_names = conversation.participants.filter_map do |participant|
+        Chats.display_name_for(participant.messager) if participant.active?
+      end
+
+      [conversation.title, conversation.subject_label, *participant_names].compact.join(" ")
+    end
+  end
+end

data/lib/chats/inbox_group.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Chats
+  # A stack of direct conversations that share one counterpart, shown as a
+  # SINGLE inbox row. Built by Chats::Inbox for messagers declared with
+  # `acts_as_messager inbox: :grouped` — a support desk, a marketplace
+  # storefront, any seat a person ends up with many separate threads with.
+  #
+  # It quacks like the parts of Chats::Conversation the inbox row needs
+  # (+last_message+, +last_message_at+, +unread_count+) so the two row
+  # partials stay symmetrical.
+  #
+  # +unread_count+ and +open_count+ are GLOBAL: they describe the whole
+  # stack, however deep it runs, not the bounded window in +conversations+.
+  # Chats::Inbox reads them with two indexed aggregates per stack.
+  class InboxGroup
+    # +conversations+ is the loaded WINDOW of the stack (freshest first,
+    # bounded by config.inbox_limit); +open_count+ and +unread_count+ describe
+    # the whole stack, however deep it runs.
+    attr_reader :messager, :conversations, :unread_count, :open_count
+
+    def initialize(messager:, conversations:, unread_count: 0, open_count: nil)
+      @messager = messager
+      @conversations = conversations
+      @unread_count = unread_count
+      @open_count = open_count || conversations.size
+    end
+
+    # A stack of one is really just a conversation: the row links straight to
+    # it, and the thread carries a "see all" link back to the stack.
+    def single?
+      open_count == 1
+    end
+
+    # The freshest conversation in the stack — what the row previews, and
+    # what it links to when the stack holds exactly one.
+    def conversation
+      conversations.first
+    end
+
+    # The stack's most recent message (the row's preview line).
+    def last_message
+      conversation&.last_message
+    end
+
+    # The sort key the inbox orders rows by: the freshest activity in the
+    # stack (mirrors Conversation.recent_first's COALESCE).
+    def last_message_at
+      conversations.filter_map { |c| c.last_message_at || c.created_at }.max
+    end
+
+    # Whether the stack has anything unread in it, anywhere.
+    def unread?
+      unread_count.positive?
+    end
+
+    # What the row is called. A stack is named after its counterpart from
+    # every seat, so the viewer is accepted and ignored — the signature
+    # matches Chats::Conversation#title_for so both row partials can call it.
+    def title_for(_viewer)
+      Chats.display_name_for(messager)
+    end
+
+    # Stable DOM id for the row (no AR record to derive one from).
+    def dom_id
+      "chats_inbox_group_#{messager.class.polymorphic_name.underscore.tr("/", "_")}_#{messager.id}"
+    end
+
+    # The signed, purpose-scoped GlobalID that filters the inbox to this
+    # stack (`GET /conversations?with=…`).
+    def with_sgid
+      Chats.inbox_with_sgid(messager)
+    end
+  end
+end

data/lib/chats/macros.rb

@@ -17,8 +17,40 @@ module Chats
   # lives in Chats::Messager / Chats::ChatSubject so it's discoverable,
   # testable, and `include`-able directly when a host prefers that style.
   module Macros
-    def acts_as_messager
+    # Options (all optional; the defaults are 0.1.x behaviour):
+    #
+    #   notifications: false   this messager is never notifiable — a support
+    #                          desk, a bot, an org mailbox. `Participant#
+    #                          notifiable_for?` says no, so hosts stop
+    #                          branching on class in every notifier.
+    #   blockable: false       block/report affordances don't apply to it, so
+    #                          the bundled views hide them.
+    #   inbox: :grouped        every direct conversation with this messager
+    #                          stacks into ONE inbox row (see Chats::Inbox).
+    #   group_path: ->(viewer) { }  where that stacked row links to; defaults
+    #                          to the filtered inbox (`?with=<sgid>`).
+    #   verified: true         this messager is an OFFICIAL account — a support
+    #                          desk, an organization, a brand. The bundled views
+    #                          mark its name with the rosette everyone already
+    #                          reads as "verified". Strictly true/false: a badge
+    #                          is a trust claim, so a stray "false" string must
+    #                          raise rather than quietly verify.
+    #
+    #   class Desk < ApplicationRecord
+    #     acts_as_messager notifications: false, blockable: false, inbox: :grouped,
+    #                      verified: true
+    #   end
+    def acts_as_messager(notifications: true, blockable: true, inbox: :default, group_path: nil,
+                         verified: false)
       include Chats::Messager
+
+      self.chat_options = Chats::Messager.normalize_options(
+        notifications: notifications,
+        blockable: blockable,
+        inbox: inbox,
+        group_path: group_path,
+        verified: verified
+      )
     end
 
     def acts_as_chat_subject

data/lib/chats/models/concerns/chat_subject.rb

@@ -31,5 +31,28 @@ module Chats
     def chat_subject_label
       "#{self.class.model_name.human} #{id}"
     end
+
+    # Whether conversations ABOUT this record still accept messages. The
+    # subject already owns the conversation's meaning, so it owns its
+    # openness too — a closed ticket, a delivered order, an archived listing:
+    #
+    #   class Ticket < ApplicationRecord
+    #     acts_as_chat_subject
+    #     def chat_locked?       = closed?
+    #     def chat_locked_notice = "This ticket is closed. Reply to reopen it."
+    #   end
+    #
+    # System messages are exempt (the host can always post "Ticket closed"),
+    # and locking is a WRITE rule only: the thread stays readable. See
+    # Chats::Conversation#locked?.
+    def chat_locked?
+      false
+    end
+
+    # The sentence shown where the composer would be. Nil falls back to the
+    # gem's localized "This conversation is closed."
+    def chat_locked_notice
+      nil
+    end
   end
 end

data/lib/chats/models/concerns/messager.rb

@@ -16,7 +16,93 @@ module Chats
   module Messager
     extend ActiveSupport::Concern
 
+    # What `acts_as_messager` declares about a messager class. The defaults
+    # are exactly 0.1.x behaviour, so a bare `acts_as_messager` is unchanged.
+    DEFAULT_CHAT_OPTIONS = {
+      notifications: true,
+      blockable: true,
+      inbox: :default,
+      group_path: nil,
+      verified: false
+    }.freeze
+
+    INBOX_MODES = %i[default grouped].freeze
+
+    # Validate + freeze the macro's options, failing at BOOT with a plain
+    # English message rather than at 3am with a NoMethodError.
+    def self.normalize_options(notifications:, blockable:, inbox:, group_path:, verified: false)
+      inbox = inbox.to_sym
+      unless INBOX_MODES.include?(inbox)
+        raise Chats::ConfigurationError,
+              "acts_as_messager inbox: must be one of #{INBOX_MODES.inspect}, got #{inbox.inspect}"
+      end
+
+      if group_path && !group_path.respond_to?(:call)
+        raise Chats::ConfigurationError,
+              "acts_as_messager group_path: must respond to #call (a proc/lambda), got #{group_path.inspect}"
+      end
+
+      # Deliberately STRICTER than its boolean neighbours, which coerce with
+      # `!!`. "Official account" is a trust claim shown to everyone who talks
+      # to this messager, so `verified: "false"` (an ENV var, a YAML
+      # round-trip) has to fail at boot rather than quietly verify it.
+      unless [true, false].include?(verified)
+        raise Chats::ConfigurationError,
+              "acts_as_messager verified: must be true or false, got #{verified.inspect}"
+      end
+
+      {
+        notifications: !!notifications,
+        blockable: !!blockable,
+        inbox: inbox,
+        group_path: group_path,
+        verified: verified
+      }.freeze
+    end
+
+    class_methods do
+      # True unless declared with `acts_as_messager notifications: false`.
+      def chat_notifications?
+        chat_options[:notifications]
+      end
+
+      # True unless declared with `acts_as_messager blockable: false`.
+      def chat_blockable?
+        chat_options[:blockable]
+      end
+
+      # :default | :grouped (see Chats::Inbox).
+      def chat_inbox_mode
+        chat_options[:inbox]
+      end
+
+      # Whether every direct conversation with this messager folds into ONE
+      # inbox row (see Chats::InboxGroup).
+      def chat_grouped_inbox?
+        chat_inbox_mode == :grouped
+      end
+
+      # The `group_path:` callable, or nil (then the stacked row links to the
+      # filtered inbox).
+      def chat_group_path
+        chat_options[:group_path]
+      end
+
+      # True when declared with `acts_as_messager verified: true` — an
+      # OFFICIAL account (a support desk, an organization, a brand). The
+      # bundled views badge its name wherever they show it.
+      def chat_verified?
+        chat_options[:verified]
+      end
+    end
+
     included do
+      # Declared by `acts_as_messager`; a plain `include Chats::Messager`
+      # gets the defaults. class_attribute so STI subclasses inherit it.
+      class_attribute :chat_options,
+                      instance_accessor: false,
+                      default: Chats::Messager::DEFAULT_CHAT_OPTIONS
+
       has_many :chat_participations,
                class_name: "Chats::Participant",
                as: :messager,
@@ -63,14 +149,25 @@ module Chats
     #   alice.message!(bob, "are you coming?")
     #   alice.message!(bob, "about the ride", about: ride)
     #   alice.message!(conversation, "hi all!", files: [photo])
-    def message!(target, body = nil, about: nil, files: [], reply_to: nil)
+    #
+    # `author:` is the human (or bot) writing on the SENDER's behalf — an
+    # agent answering from a support desk seat. It signs the bubble; the
+    # sender stays the conversation identity. See Chats::Message#signed?.
+    #
+    #   desk.message!(alice, "On it!", author: lucia)
+    def message!(target, body = nil, about: nil, files: [], reply_to: nil, author: nil)
+      if author && !Chats.messager_class?(author.class)
+        raise Chats::NotAllowedError,
+              "author must be a messager (acts_as_messager), got #{author.class.name}"
+      end
+
       conversation =
         case target
         when Chats::Conversation then target
         else chat_with(target, about: about)
         end
 
-      attributes = { sender: self, body: body, reply_to: reply_to }
+      attributes = { sender: self, body: body, reply_to: reply_to, author: author }
       attributes[:files] = files if files.present?
       conversation.messages.create!(**attributes)
     end