feat: add thread archiving and unread filters

Add per-phone outgoing archiving and server-side unread filtering.

Include integration coverage, frontend type fixes, and login badge fixes.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: aad7909a-5c34-42df-a4d2-ae6c83c22e7b

Author: AchoArnold

api/docs/docs.go

@@ -1166,6 +1166,13 @@ const docTemplate = `{
                         "description": "include matching contact details",
                         "name": "contacts",
                         "in": "query"
+                    },
+                    {
+                        "type": "boolean",
+                        "default": false,
+                        "description": "only include threads with unread messages",
+                        "name": "unread_only",
+                        "in": "query"
                     }
                 ],
                 "responses": {
@@ -4204,6 +4211,7 @@ const docTemplate = `{
         "entities.Phone": {
             "type": "object",
             "required": [
+                "archive_new_outgoing_message_threads",
                 "created_at",
                 "id",
                 "max_send_attempts",
@@ -4216,6 +4224,11 @@ const docTemplate = `{
                 "user_id"
             ],
             "properties": {
+                "archive_new_outgoing_message_threads": {
+                    "description": "ArchiveNewOutgoingMessageThreads archives new conversations started by an outgoing message on this phone.",
+                    "type": "boolean",
+                    "example": false
+                },
                 "created_at": {
                     "type": "string",
                     "example": "2022-06-05T14:26:02.302718+03:00"
@@ -4975,6 +4988,11 @@ const docTemplate = `{
                 "unarchive_thread"
             ],
             "properties": {
+                "archive_new_outgoing_message_threads": {
+                    "description": "ArchiveNewOutgoingMessageThreads archives new conversations started by an outgoing message on this phone.",
+                    "type": "boolean",
+                    "example": false
+                },
                 "fcm_token": {
                     "description": "FcmToken is either a Firebase registration token or a public HTTPS adapter callback URL.",
                     "type": "string",

api/docs/swagger.json

@@ -1163,6 +1163,13 @@
                         "description": "include matching contact details",
                         "name": "contacts",
                         "in": "query"
+                    },
+                    {
+                        "type": "boolean",
+                        "default": false,
+                        "description": "only include threads with unread messages",
+                        "name": "unread_only",
+                        "in": "query"
                     }
                 ],
                 "responses": {
@@ -4201,6 +4208,7 @@
         "entities.Phone": {
             "type": "object",
             "required": [
+                "archive_new_outgoing_message_threads",
                 "created_at",
                 "id",
                 "max_send_attempts",
@@ -4213,6 +4221,11 @@
                 "user_id"
             ],
             "properties": {
+                "archive_new_outgoing_message_threads": {
+                    "description": "ArchiveNewOutgoingMessageThreads archives new conversations started by an outgoing message on this phone.",
+                    "type": "boolean",
+                    "example": false
+                },
                 "created_at": {
                     "type": "string",
                     "example": "2022-06-05T14:26:02.302718+03:00"
@@ -4972,6 +4985,11 @@
                 "unarchive_thread"
             ],
             "properties": {
+                "archive_new_outgoing_message_threads": {
+                    "description": "ArchiveNewOutgoingMessageThreads archives new conversations started by an outgoing message on this phone.",
+                    "type": "boolean",
+                    "example": false
+                },
                 "fcm_token": {
                     "description": "FcmToken is either a Firebase registration token or a public HTTPS adapter callback URL.",
                     "type": "string",

api/docs/swagger.yaml

@@ -408,6 +408,11 @@ definitions:
     type: object
   entities.Phone:
     properties:
+      archive_new_outgoing_message_threads:
+        description: ArchiveNewOutgoingMessageThreads archives new conversations started
+          by an outgoing message on this phone.
+        example: false
+        type: boolean
       created_at:
         example: "2022-06-05T14:26:02.302718+03:00"
         type: string
@@ -452,6 +457,7 @@ definitions:
         example: WB7DRDWrJZRGbYrv2CKGkqbzvqdC
         type: string
     required:
+    - archive_new_outgoing_message_threads
     - created_at
     - id
     - max_send_attempts
@@ -990,6 +996,11 @@ definitions:
     type: object
   requests.PhoneUpsert:
     properties:
+      archive_new_outgoing_message_threads:
+        description: ArchiveNewOutgoingMessageThreads archives new conversations started
+          by an outgoing message on this phone.
+        example: false
+        type: boolean
       fcm_token:
         description: FcmToken is either a Firebase registration token or a public
           HTTPS adapter callback URL.
@@ -2510,6 +2521,11 @@ paths:
         in: query
         name: contacts
         type: boolean
+      - default: false
+        description: only include threads with unread messages
+        in: query
+        name: unread_only
+        type: boolean
       produces:
       - application/json
       responses:

api/pkg/entities/phone.go

@@ -30,6 +30,9 @@ type Phone struct {
 	// UnarchiveThread moves an archived message thread back to the inbox when a new message is received on this phone.
 	UnarchiveThread bool `json:"unarchive_thread" gorm:"default:false" example:"false"`
 
+	// ArchiveNewOutgoingMessageThreads archives new conversations started by an outgoing message on this phone.
+	ArchiveNewOutgoingMessageThreads bool `json:"archive_new_outgoing_message_threads" gorm:"default:false" example:"false"`
+
 	CreatedAt time.Time `json:"created_at" example:"2022-06-05T14:26:02.302718+03:00"`
 	UpdatedAt time.Time `json:"updated_at" example:"2022-06-05T14:26:10.303278+03:00"`
 }

api/pkg/handlers/message_thread_handler.go

@@ -58,6 +58,7 @@ func (h *MessageThreadHandler) RegisterRoutes(router fiber.Router, middlewares .
 // @Param        query	query  string  	false 	"filter message threads containing query"
 // @Param        limit	query  int  	false	"number of messages to return"				minimum(1)	maximum(20)
 // @Param        contacts	query  bool  	false	"include matching contact details"
+// @Param        unread_only	query  bool  	false	"only include threads with unread messages"	default(false)
 // @Success      200 	{object}	responses.MessageThreadsResponse
 // @Failure      400	{object}	responses.BadRequest
 // @Failure 	 401    {object}	responses.Unauthorized

api/pkg/handlers/message_thread_handler_contacts_test.go

@@ -22,10 +22,12 @@ import (
 
 type messageThreadHandlerIndexRepositoryStub struct {
 	repositories.MessageThreadRepository
-	threads []entities.MessageThread
+	threads    []entities.MessageThread
+	unreadOnly bool
 }
 
-func (stub *messageThreadHandlerIndexRepositoryStub) Index(context.Context, entities.UserID, string, bool, repositories.IndexParams) (*[]entities.MessageThread, error) {
+func (stub *messageThreadHandlerIndexRepositoryStub) Index(_ context.Context, _ entities.UserID, _ string, _ bool, unreadOnly bool, _ repositories.IndexParams) (*[]entities.MessageThread, error) {
+	stub.unreadOnly = unreadOnly
 	threads := make([]entities.MessageThread, len(stub.threads))
 	copy(threads, stub.threads)
 	return &threads, nil
@@ -41,7 +43,7 @@ func (stub *messageThreadHandlerContactProviderStub) GetContactMap(context.Conte
 	return stub.contacts, nil
 }
 
-func TestMessageThreadHandlerIndex_ParsesContactsQuery(t *testing.T) {
+func TestMessageThreadHandlerIndex_ParsesContactsAndUnreadQuery(t *testing.T) {
 	contact := &entities.Contact{ID: uuid.New(), Name: "Alice", PhoneNumbers: []string{"+18005550100"}}
 	repository := &messageThreadHandlerIndexRepositoryStub{threads: []entities.MessageThread{{Contact: "+18005550100"}}}
 	provider := &messageThreadHandlerContactProviderStub{contacts: map[string]*entities.Contact{"+18005550100": contact}}
@@ -57,19 +59,41 @@ func TestMessageThreadHandlerIndex_ParsesContactsQuery(t *testing.T) {
 	})
 	handler.RegisterRoutes(app)
 
-	req := httptest.NewRequest(http.MethodGet, "/v1/message-threads?owner=%2B18005550199&contacts=true", nil)
+	req := httptest.NewRequest(http.MethodGet, "/v1/message-threads?owner=%2B18005550199&contacts=true&unread_only=true", nil)
 	resp, err := app.Test(req, fiber.TestConfig{Timeout: time.Second})
 
 	require.NoError(t, err)
 	require.Equal(t, http.StatusOK, resp.StatusCode)
 	assert.Equal(t, 1, provider.calls)
+	assert.True(t, repository.unreadOnly)
 
 	var payload struct {
 		Data []entities.MessageThread `json:"data"`
 	}
+
 	require.NoError(t, json.NewDecoder(resp.Body).Decode(&payload))
 	require.Len(t, payload.Data, 1)
 	require.NotNil(t, payload.Data[0].ContactDetails)
 	assert.Equal(t, contact.ID, payload.Data[0].ContactDetails.ID)
 	assert.Equal(t, "Alice", payload.Data[0].ContactDetails.Name)
 }
+
+func TestMessageThreadHandlerIndexRejectsInvalidUnreadFilter(t *testing.T) {
+	repository := &messageThreadHandlerIndexRepositoryStub{}
+	logger := &messageThreadHandlerNoopLogger{}
+	tracer := telemetry.NewOtelLogger("test", logger)
+	service := services.NewMessageThreadService(logger, tracer, repository, nil, nil, nil)
+	handler := NewMessageThreadHandler(logger, tracer, validators.NewMessageThreadHandlerValidator(logger, tracer), service)
+	app := fiber.New()
+	app.Use(func(c fiber.Ctx) error {
+		c.Locals(middlewares.ContextKeyAuthUserID, entities.AuthContext{ID: entities.UserID("user-id"), Email: "user@example.com"})
+		return c.Next()
+	})
+	handler.RegisterRoutes(app)
+
+	response, err := app.Test(httptest.NewRequest(http.MethodGet, "/v1/message-threads?owner=%2B18005550199&unread_only=invalid", nil))
+
+	require.NoError(t, err)
+	defer response.Body.Close()
+	assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
+}

api/pkg/handlers/message_thread_handler_test.go

@@ -45,7 +45,7 @@ func (stub *messageThreadHandlerRepositoryStub) Load(context.Context, entities.U
 	return nil, nil
 }
 
-func (stub *messageThreadHandlerRepositoryStub) Index(context.Context, entities.UserID, string, bool, repositories.IndexParams) (*[]entities.MessageThread, error) {
+func (stub *messageThreadHandlerRepositoryStub) Index(context.Context, entities.UserID, string, bool, bool, repositories.IndexParams) (*[]entities.MessageThread, error) {
 	return nil, nil
 }
 

api/pkg/listeners/read_receipts_test_helpers_test.go

@@ -52,7 +52,7 @@ func (repository *listenerMessageThreadRepository) Load(context.Context, entitie
 	return &entities.MessageThread{}, nil
 }
 
-func (repository *listenerMessageThreadRepository) Index(context.Context, entities.UserID, string, bool, repositories.IndexParams) (*[]entities.MessageThread, error) {
+func (repository *listenerMessageThreadRepository) Index(context.Context, entities.UserID, string, bool, bool, repositories.IndexParams) (*[]entities.MessageThread, error) {
 	threads := []entities.MessageThread{}
 	return &threads, nil
 }

api/pkg/repositories/gorm_message_thread_repository.go

@@ -234,7 +234,7 @@ func (repository *gormMessageThreadRepository) Load(ctx context.Context, userID
 }
 
 // Index message threads for an owner
-func (repository *gormMessageThreadRepository) Index(ctx context.Context, userID entities.UserID, owner string, isArchived bool, params IndexParams) (*[]entities.MessageThread, error) {
+func (repository *gormMessageThreadRepository) Index(ctx context.Context, userID entities.UserID, owner string, isArchived bool, unreadOnly bool, params IndexParams) (*[]entities.MessageThread, error) {
 	ctx, span := repository.tracer.Start(ctx)
 	defer span.End()
 
@@ -249,6 +249,10 @@ func (repository *gormMessageThreadRepository) Index(ctx context.Context, userID
 		query.Where(repository.db.Where("is_archived = ?", isArchived).Or("is_archived IS NULL"))
 	}
 
+	if unreadOnly {
+		query.Where("unread_count > ?", 0)
+	}
+
 	if len(params.Query) > 0 {
 		queryPattern := "%" + params.Query + "%"
 		query.Where(

api/pkg/repositories/gorm_message_thread_repository_test.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"database/sql/driver"
 	"errors"
+	"fmt"
 	"strings"
 	"testing"
 	"time"
@@ -24,6 +25,42 @@ type messageThreadTestStatement struct {
 	args  []any
 }
 
+func TestMessageThreadIndexFiltersUnreadBeforePagination(t *testing.T) {
+	for _, unreadOnly := range []bool{false, true} {
+		t.Run(fmt.Sprintf("unread_only=%t", unreadOnly), func(t *testing.T) {
+			db, err := gorm.Open(postgres.New(postgres.Config{Conn: &messageThreadTestConnPool{}}), &gorm.Config{
+				DisableAutomaticPing: true,
+				DryRun:               true,
+			})
+			require.NoError(t, err)
+			var query string
+			var args []any
+			require.NoError(t, db.Callback().Query().After("gorm:query").Register("capture", func(db *gorm.DB) {
+				query = db.Statement.SQL.String()
+				args = db.Statement.Vars
+			}))
+			logger := &messageThreadTestLogger{}
+			repository := NewGormMessageThreadRepository(logger, telemetry.NewOtelLogger("test", logger), db)
+
+			_, err = repository.Index(context.Background(), entities.UserID("user-id"), "+18005550199", true, unreadOnly, IndexParams{Limit: 20, Skip: 5})
+
+			require.NoError(t, err)
+			assert.Contains(t, query, "user_id = $1")
+			assert.Contains(t, query, "owner = $2")
+			assert.Contains(t, query, "is_archived = $3")
+			assert.Equal(t, []any{entities.UserID("user-id"), "+18005550199", true}, args[:3])
+			if unreadOnly {
+				assert.Contains(t, query, "unread_count >")
+				assert.Less(t, strings.Index(query, "unread_count >"), strings.Index(query, "LIMIT"))
+			} else {
+				assert.NotContains(t, query, "unread_count >")
+			}
+			assert.Contains(t, query, "ORDER BY order_timestamp DESC LIMIT")
+			assert.Contains(t, query, "OFFSET")
+		})
+	}
+}
+
 type messageThreadTestConnPool struct {
 	statements []messageThreadTestStatement
 }