perf: load unarchive flag lazily for archived threads

Consult the phone's UnarchiveThread setting inside
MessageThreadService.UpdateThread only when an inbound message lands on
an archived thread, instead of loading the phone on every received
message. Removes the per-message phone read in ReceiveMessage and drops
the UnarchiveThread field from the received-message event payload.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf78429e-573c-406c-9f7c-1d6e1bddbbb5

Author: AchoArnold

api/pkg/di/container.go

@@ -1111,6 +1111,7 @@ func (container *Container) MessageThreadService() (service *services.MessageThr
 		container.Logger(),
 		container.Tracer(),
 		container.MessageThreadRepository(),
+		container.PhoneRepository(),
 		container.EventDispatcher(),
 	)
 }

api/pkg/events/message_phone_received_event.go

@@ -13,14 +13,13 @@ const EventTypeMessagePhoneReceived = "message.phone.received"
 
 // MessagePhoneReceivedPayload is the payload of the EventTypeMessagePhoneReceived event
 type MessagePhoneReceivedPayload struct {
-	MessageID       uuid.UUID       `json:"message_id"`
-	UserID          entities.UserID `json:"user_id"`
-	Owner           string          `json:"owner"`
-	Encrypted       bool            `json:"encrypted"`
-	Contact         string          `json:"contact"`
-	Timestamp       time.Time       `json:"timestamp"`
-	Content         string          `json:"content"`
-	SIM             entities.SIM    `json:"sim"`
-	Attachments     []string        `json:"attachments"`
-	UnarchiveThread bool            `json:"unarchive_thread"`
+	MessageID   uuid.UUID       `json:"message_id"`
+	UserID      entities.UserID `json:"user_id"`
+	Owner       string          `json:"owner"`
+	Encrypted   bool            `json:"encrypted"`
+	Contact     string          `json:"contact"`
+	Timestamp   time.Time       `json:"timestamp"`
+	Content     string          `json:"content"`
+	SIM         entities.SIM    `json:"sim"`
+	Attachments []string        `json:"attachments"`
 }

api/pkg/listeners/message_thread_listener.go

@@ -222,14 +222,13 @@ func (listener *MessageThreadListener) OnMessagePhoneReceived(ctx context.Contex
 	}
 
 	updateParams := services.MessageThreadUpdateParams{
-		Owner:           payload.Owner,
-		Contact:         payload.Contact,
-		Timestamp:       payload.Timestamp,
-		UserID:          payload.UserID,
-		Status:          entities.MessageStatusReceived,
-		Content:         payload.Content,
-		MessageID:       payload.MessageID,
-		UnarchiveThread: payload.UnarchiveThread,
+		Owner:     payload.Owner,
+		Contact:   payload.Contact,
+		Timestamp: payload.Timestamp,
+		UserID:    payload.UserID,
+		Status:    entities.MessageStatusReceived,
+		Content:   payload.Content,
+		MessageID: payload.MessageID,
 	}
 
 	if err := listener.service.UpdateThread(ctx, updateParams); err != nil {

api/pkg/services/message_service.go

@@ -348,25 +348,16 @@ func (service *MessageService) ReceiveMessage(ctx context.Context, params *Messa
 
 	owner := phonenumbers.Format(&params.Owner, phonenumbers.E164)
 
-	unarchiveThread := false
-	phone, err := service.phoneService.Load(ctx, params.UserID, owner)
-	if err != nil {
-		ctxLogger.Warn(stacktrace.Propagate(err, "cannot load phone [%s] for user [%s] to resolve UnarchiveThread; defaulting to false", owner, params.UserID))
-	} else {
-		unarchiveThread = phone.UnarchiveThread
-	}
-
 	eventPayload := events.MessagePhoneReceivedPayload{
-		MessageID:       messageID,
-		UserID:          params.UserID,
-		Encrypted:       params.Encrypted,
-		Owner:           owner,
-		Contact:         params.Contact,
-		Timestamp:       params.Timestamp,
-		Content:         params.Content,
-		SIM:             params.SIM,
-		Attachments:     attachmentURLs,
-		UnarchiveThread: unarchiveThread,
+		MessageID:   messageID,
+		UserID:      params.UserID,
+		Encrypted:   params.Encrypted,
+		Owner:       owner,
+		Contact:     params.Contact,
+		Timestamp:   params.Timestamp,
+		Content:     params.Content,
+		SIM:         params.SIM,
+		Attachments: attachmentURLs,
 	}
 
 	ctxLogger.Info(fmt.Sprintf("creating cloud event for received with ID [%s]", eventPayload.MessageID))

api/pkg/services/message_thread_service.go

@@ -21,6 +21,7 @@ type MessageThreadService struct {
 	logger          telemetry.Logger
 	tracer          telemetry.Tracer
 	repository      repositories.MessageThreadRepository
+	phoneRepository repositories.PhoneRepository
 	eventDispatcher *EventDispatcher
 }
 
@@ -29,33 +30,35 @@ func NewMessageThreadService(
 	logger telemetry.Logger,
 	tracer telemetry.Tracer,
 	repository repositories.MessageThreadRepository,
+	phoneRepository repositories.PhoneRepository,
 	eventDispatcher *EventDispatcher,
 ) (s *MessageThreadService) {
 	return &MessageThreadService{
 		logger:          logger.WithService(fmt.Sprintf("%T", s)),
 		tracer:          tracer,
 		eventDispatcher: eventDispatcher,
 		repository:      repository,
+		phoneRepository: phoneRepository,
 	}
 }
 
 // MessageThreadUpdateParams are parameters for updating a thread
 type MessageThreadUpdateParams struct {
-	Owner           string
-	Status          entities.MessageStatus
-	Contact         string
-	Content         string
-	UserID          entities.UserID
-	MessageID       uuid.UUID
-	Timestamp       time.Time
-	UnarchiveThread bool
+	Owner     string
+	Status    entities.MessageStatus
+	Contact   string
+	Content   string
+	UserID    entities.UserID
+	MessageID uuid.UUID
+	Timestamp time.Time
 }
 
-// shouldUnarchive reports whether an archived thread should be moved back to
-// the inbox because a new inbound message was received and the phone has the
-// UnarchiveThread setting enabled.
-func (service *MessageThreadService) shouldUnarchive(thread *entities.MessageThread, params MessageThreadUpdateParams) bool {
-	return thread.IsArchived && params.UnarchiveThread && params.Status == entities.MessageStatusReceived
+// shouldCheckUnarchive reports whether a thread update is a new inbound message
+// landing on an archived thread. Only in that case is the phone's
+// UnarchiveThread setting consulted, so the phone is not loaded on the common
+// path where the thread is not archived.
+func (service *MessageThreadService) shouldCheckUnarchive(thread *entities.MessageThread, params MessageThreadUpdateParams) bool {
+	return thread.IsArchived && params.Status == entities.MessageStatusReceived
 }
 
 // DeleteAllForUser deletes all entities.MessageThread for an entities.UserID.
@@ -100,9 +103,14 @@ func (service *MessageThreadService) UpdateThread(ctx context.Context, params Me
 		return nil
 	}
 
-	if service.shouldUnarchive(thread, params) {
-		thread.UpdateArchive(false)
-		ctxLogger.Info(fmt.Sprintf("unarchiving thread [%s] after inbound message [%s]", thread.ID, params.MessageID))
+	if service.shouldCheckUnarchive(thread, params) {
+		phone, phoneErr := service.phoneRepository.Load(ctx, params.UserID, params.Owner)
+		if phoneErr != nil {
+			ctxLogger.Warn(stacktrace.Propagate(phoneErr, "cannot load phone [%s] for user [%s] to resolve UnarchiveThread; leaving thread [%s] archived", params.Owner, params.UserID, thread.ID))
+		} else if phone.UnarchiveThread {
+			thread.UpdateArchive(false)
+			ctxLogger.Info(fmt.Sprintf("unarchiving thread [%s] after inbound message [%s]", thread.ID, params.MessageID))
+		}
 	}
 
 	if err = service.repository.Update(ctx, thread.Update(params.Timestamp, params.MessageID, params.Content, params.Status)); err != nil {

api/pkg/services/message_thread_service_test.go

@@ -7,18 +7,16 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestShouldUnarchive(t *testing.T) {
+func TestShouldCheckUnarchive(t *testing.T) {
 	service := &MessageThreadService{}
 
 	archived := &entities.MessageThread{IsArchived: true}
 	notArchived := &entities.MessageThread{IsArchived: false}
 
-	received := MessageThreadUpdateParams{Status: entities.MessageStatusReceived, UnarchiveThread: true}
-	receivedFlagOff := MessageThreadUpdateParams{Status: entities.MessageStatusReceived, UnarchiveThread: false}
-	sentFlagOn := MessageThreadUpdateParams{Status: entities.MessageStatusSent, UnarchiveThread: true}
+	received := MessageThreadUpdateParams{Status: entities.MessageStatusReceived}
+	sent := MessageThreadUpdateParams{Status: entities.MessageStatusSent}
 
-	assert.True(t, service.shouldUnarchive(archived, received), "archived + inbound + flag on -> unarchive")
-	assert.False(t, service.shouldUnarchive(archived, receivedFlagOff), "flag off -> no unarchive")
-	assert.False(t, service.shouldUnarchive(archived, sentFlagOn), "outbound status -> no unarchive")
-	assert.False(t, service.shouldUnarchive(notArchived, received), "already unarchived -> no change")
+	assert.True(t, service.shouldCheckUnarchive(archived, received), "archived + inbound -> consult phone setting")
+	assert.False(t, service.shouldCheckUnarchive(archived, sent), "outbound status -> no check")
+	assert.False(t, service.shouldCheckUnarchive(notArchived, received), "already unarchived -> no check")
 }