From 626a1f7a291bc3e86fcfd565b55a2e37f9b13142 Mon Sep 17 00:00:00 2001 From: Rogee Date: Sun, 7 Jun 2026 09:13:03 +0800 Subject: [PATCH] feat(search): align message result payloads --- cmd/reindex_search/main.go | 5 +- docs/CHATWOOT_PARITY_DEVELOPMENT_PLAN.md | 18 +- internal/app/bootstrap.go | 2 +- internal/handler/api/v1/search_handler.go | 203 +++++++++++++----- .../handler/api/v1/search_handler_test.go | 69 +++++- internal/model/message.go | 3 + internal/search/engine.go | 92 +++++++- internal/search/engine_test.go | 33 +++ internal/service/search_indexer_worker.go | 31 ++- 9 files changed, 388 insertions(+), 68 deletions(-) diff --git a/cmd/reindex_search/main.go b/cmd/reindex_search/main.go index a8f8f439..a4f146e8 100644 --- a/cmd/reindex_search/main.go +++ b/cmd/reindex_search/main.go @@ -173,7 +173,10 @@ func reindexMessages(ctx context.Context, engine search.SearchEngine, db *gorm.D var lastID uint for { var rows []model.Message - q := db.WithContext(ctx).Where("id > ?", lastID).Order("id ASC").Limit(batchSize) + q := db.WithContext(ctx). + Preload("Conversation"). + Preload("Attachments", func(db *gorm.DB) *gorm.DB { return db.Order("id ASC") }). + Where("id > ?", lastID).Order("id ASC").Limit(batchSize) if accountID != 0 { q = q.Where("account_id = ?", accountID) } diff --git a/docs/CHATWOOT_PARITY_DEVELOPMENT_PLAN.md b/docs/CHATWOOT_PARITY_DEVELOPMENT_PLAN.md index af6c0088..331f8a08 100644 --- a/docs/CHATWOOT_PARITY_DEVELOPMENT_PLAN.md +++ b/docs/CHATWOOT_PARITY_DEVELOPMENT_PLAN.md @@ -49,11 +49,11 @@ Hermes task landing checklist: ## Current Baseline -- Current tracking checkpoint: 2026-06-07 tracker reconciliation, prepared as `docs: reconcile parity tracker`. -- Latest implementation checkpoint: `0b47066 feat(search): align conversation result payloads` closes P3.85 search conversation payload parity. -- Latest documentation/tooling checkpoint: this tracker update reconciles stale next-slice wording, adds the P3.84/P3.85 commit ledger rows, and keeps the executable queue pointed at Phase 2/3 drift audit, Phase 6 placeholder audit, or B12 live smoke. No route artifacts change. +- Current tracking checkpoint: 2026-06-07 P3.86 search message payload parity, prepared as `feat(search): align message result payloads`. +- Latest implementation checkpoint: this checkpoint, prepared as `feat(search): align message result payloads`. +- Latest documentation/tooling checkpoint: this tracker update records Chatwoot search message Jbuilder payload parity for sender, attachments, and display-ID routing. No route artifacts change. - Plan landing status: complete for the current known Hermes plans and user-confirmed scope. Future work should update this file directly instead of opening a parallel tracker. -- Worktree status at this implementation checkpoint: SearchAPI conversation results now include Chatwoot-compatible nested `message`, `contact`, `inbox`, `agent`, and `additional_attributes` payloads from DB fallback and Meilisearch documents, while retaining P3.84 agent-sender filter parity, P3.83 conversation ordering, P3.82 contact-conversation reindex fanout, P3.81 conversation identity search, P3.80 search time-bound parity, P3.79 advanced-search feature gates, P3.78 message recency, P3.77 current-user inbox access, and prior checkpoints. Live API/browser/enterprise smoke still needs the full PostgreSQL/Redis/Meilisearch/GoChat/Vite/Chrome stack. +- Worktree status at this implementation checkpoint: SearchAPI message results now hydrate Chatwoot `_message` fields with conversation display IDs, sender push data, and attachment push data from DB-backed handlers plus Meilisearch document payloads, while retaining P3.85 conversation payloads, P3.84 agent-sender filter parity, P3.83 conversation ordering, P3.82 contact-conversation reindex fanout, P3.81 conversation identity search, P3.80 search time-bound parity, P3.79 advanced-search feature gates, P3.78 message recency, P3.77 current-user inbox access, and prior checkpoints. Live API/browser/enterprise smoke still needs the full PostgreSQL/Redis/Meilisearch/GoChat/Vite/Chrome stack. - Next executable implementation checkpoint: continue Phase 2/3 drift audit for the next reused-frontend mismatch, or run B12 live smoke when the full PostgreSQL/Redis/Meilisearch/GoChat/Vite/Chrome stack is available. Re-run Phase 6 placeholder audit after future route/smoke changes. - `go test ./...` passes when run outside the restricted socket sandbox for the latest implementation baseline; the latest docs/tooling checkpoint verified `scripts/parity_frontend_smoke.sh --check` with workspace-local temp/cache dirs after `/tmp` was full. - Route dump succeeds with `967` registered routes after profile MFA route tracking. @@ -156,6 +156,7 @@ This table is the shortest authoritative handoff view. If an older lower section | Priority | Workstream | Current state | Next checkpoint | Commit close rule | | --- | --- | --- | --- | --- | +| 0 | P3.86 search message payload parity | Implemented for reused SearchAPI message cards: DB-backed handlers now serialize message search hits through the Chatwoot `_message` contract with conversation display IDs, sender push data, and attachment push data; Meilisearch message documents and reindex/durable indexing paths now carry display-ID and attachment payload data when relations are loaded. | Keep in Review; reopen from B12 search smoke or fresh reference evidence for exact AgentBot sender push data, voice-call `call` payloads, or provider-specific attachment metadata beyond the inspected frontend card usage. | Focused SearchHandler, SearchRepo, DurableSearchIndexer, reindex, and document-builder tests passed; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | | 0 | P3.85 search conversation payload parity | Implemented for reused SearchAPI conversation cards: DB fallback results and Meilisearch documents now carry Chatwoot search Jbuilder fields `message`, `contact`, `inbox`, `agent`, and `additional_attributes`, with conversation indexing/reindexing preloading those display relations. | Keep in Review; reopen from B12 search smoke or fresh reference evidence for exact `api/v1/models/message` field drift, message attachment/sender serialization gaps, or Meilisearch document payload bloat/per-page tuning. | Focused SearchHandler, SearchRepo, and document-builder tests passed; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | | 0 | P3.84 search agent-sender filter parity | Implemented for reused SearchAPI message filters: frontend `from=agent:id` now matches GoChat's stored agent sender variants (`agent`, `user`, `User`) in both DB fallback and Meilisearch filters, while contact and bot sender filters also tolerate local/Rails-style casing. | Keep in Review; reopen from B12 search smoke or fresh reference evidence for additional polymorphic sender values, exact Searchkick sender-type indexing, or global `ChatwootApp.advanced_search_allowed?` differences. | Focused SearchFilter, Meilisearch engine, and SearchRepo sender-filter tests passed; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | | 0 | P3.83 search conversation ordering parity | Implemented for DB fallback conversation search: default ordering now matches Chatwoot `SearchService#filter_conversations` with newest `conversations.created_at` first instead of `last_activity_at`. | Keep in Review; reopen from B12 search smoke or fresh reference evidence for Meilisearch Searchkick ordering drift, tie-break behavior, or explicit sort param differences. | Focused SearchRepo ordering test passed; full `go test ./...` passed outside the restricted socket sandbox after retrying an unrelated `internal/worker` SQLite in-memory flake; `git diff --check` passed. No route artifacts change. | @@ -249,6 +250,7 @@ These rows are the executable development plan from this point forward. A checkp | ID | Owner files | Reference files | Work to land | Exit gate | | --- | --- | --- | --- | --- | +| P3.86 search message payload parity | `internal/handler/api/v1/search_handler.go`, `internal/search/engine.go`, `internal/service/search_indexer_worker.go`, `cmd/reindex_search/main.go`, search handler/document/indexer tests | `reference/chatwoot/app/views/api/v1/models/_message.json.jbuilder`, `reference/chatwoot/app/models/message.rb#push_event_data`, `reference/chatwoot/app/models/attachment.rb#push_event_data`, `reference/chatwoot/app/javascript/dashboard/modules/search/components/SearchResultMessagesList.vue`, `SearchResultMessageItem.vue` | Message SearchAPI results now match the reused frontend card needs from Chatwoot's `_message` serializer: `conversation_id` is the conversation display ID for navigation, `sender` is hydrated from persisted contact/user rows for DB-backed handlers, attachments use Chatwoot-style push data, and Meilisearch message documents carry display-ID/attachment payload data when relations are preloaded by durable indexing and full reindex. | Review by `feat(search): align message result payloads`; focused SearchHandler, SearchRepo, DurableSearchIndexer, reindex, and document-builder tests prove DB-backed payload hydration plus Meilisearch nested payload shape; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | | P3.83 search conversation ordering parity | `internal/repository/search_repo.go`, `internal/repository/search_repo_test.go` | `reference/chatwoot/app/services/search_service.rb#filter_conversations` | Conversation DB fallback search default ordering now uses `conversations.created_at DESC, conversations.id DESC`, matching Chatwoot `@conversations = conversations_query.order('conversations.created_at DESC')`, instead of the older local `last_activity_at DESC` conversation-list default. | Review by `feat(search): align conversation search order`; focused test proves created-at ordering wins even when `last_activity_at` points the other way; full `go test ./...` passed outside the restricted socket sandbox after retrying an unrelated `internal/worker` SQLite in-memory flake; `git diff --check` passed. No route artifacts change. | | P3.82 search contact-conversation reindex parity | `internal/service/contact_service.go`, `internal/service/search_indexer_hooks_test.go` | `reference/chatwoot/app/services/search_service.rb#filter_conversations`, P3.81 Meilisearch conversation document contract | Contact search indexing now fans out to related account-scoped conversations after the contact document is indexed. Each related conversation is loaded with `Contact` preloaded and passed to `IndexConversation`, keeping Meilisearch conversation identity text aligned with contact direct updates and import merge updates. | Review by `feat(search): reindex contact conversations`; focused test proves contact update indexes both the contact and its conversation with the updated contact name; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | | P3.81 search conversation identity parity | `internal/repository/search_repo.go`, `internal/search/engine.go`, `internal/model/conversation.go`, `internal/service/search_indexer_worker.go`, `cmd/reindex_search/main.go`, repository/search/service tests | `reference/chatwoot/app/services/search_service.rb#filter_conversations`, `reference/chatwoot/app/javascript/dashboard/api/search.js`, `reference/chatwoot/app/javascript/dashboard/api/specs/search.spec.js` | Conversation global/entity search now matches Chatwoot's identity search contract: DB fallback matches `CAST(conversations.display_id AS TEXT)` plus joined contact `name`, `email`, `phone_number`, and `identifier`, while label and message-content text are not conversation-search matches. Meilisearch conversation documents use display/contact identity text in `title`/`content`; the conversation model exposes a `Contact` relation for preload; durable search indexing and full reindex preload contacts before indexing conversation documents. | Review by `feat(search): align conversation identity search`; focused tests cover DB display/contact matching, DB label/message exclusion, Meilisearch document content, and durable contact preload; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | @@ -358,6 +360,7 @@ This ledger records the committed parity checkpoints that future slices should b | Commit | Scope | Verification summary | Follow-up state | | --- | --- | --- | --- | +| `feat(search): align message result payloads` | Advances P3.86 with Chatwoot SearchAPI message result payload parity. Message search hits now route to conversation display IDs instead of DB IDs, expose `sender` push data for DB-backed results, expose attachment push data for DB-backed and Meilisearch document results, and index/reindex message documents with preloaded conversation/attachment display data where available. | `go test ./internal/handler/api/v1 ./internal/search ./internal/repository ./internal/service ./cmd/reindex_search -run 'TestSearchHandler_SearchMessages\|TestDocumentBuildersSetStableUIDAndType\|TestMessageDocumentCarriesChatwootPayloadData\|TestSearchRepo_SearchMessages\|TestDurableSearchIndexer' -count=1` passed with workspace-local temp/cache dirs; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | Move P3.86 to Review; continue Phase 2/3 drift audit, Phase 6 placeholder audit, or B12 live smoke. | | `feat(search): align conversation result payloads` | Advances P3.85 with Chatwoot search conversation-result payload parity. SearchAPI conversation hits now expose nested `message`, `contact`, `inbox`, `agent`, and `additional_attributes` data from both DB fallback rows and Meilisearch documents, and the indexing/reindexing paths preload the display relations needed by the reused frontend cards. | Focused SearchHandler, SearchRepo, and document-builder tests passed; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | Move P3.85 to Review; continue Phase 2/3 drift audit, Phase 6 placeholder audit, or B12 live smoke. | | `feat(search): align agent sender filters` | Advances P3.84 with Chatwoot SearchAPI sender filter parity. The reused frontend `from=agent:id` filter now matches locally persisted agent/user sender variants in DB fallback and Meilisearch filters, while contact and bot sender filters tolerate Rails/local casing drift. | Focused SearchFilter, Meilisearch engine, and SearchRepo sender-filter tests passed; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. | Move P3.84 to Review; continue search payload smoke or the next Phase 2/3 drift slice. | | `feat(search): align conversation search order` | Advances P3.83 with Chatwoot `SearchService#filter_conversations` ordering parity. DB fallback conversation search now defaults to `conversations.created_at DESC` with deterministic `id DESC`, instead of reusing the normal conversation list `last_activity_at` ordering. | `go test ./internal/repository -run 'TestSearchRepo_SearchConversations_DefaultOrderUsesCreatedAt\|TestSearchRepo_SearchConversations_(DisplayAndContactMatch\|DoesNotMatchLabelsOrMessages)' -count=1`; full `go test ./...` passed outside the restricted socket sandbox after retrying an unrelated `internal/worker` SQLite in-memory flake; `git diff --check` passed. No route artifacts change. | Move P3.83 to Review; continue Phase 2/3 drift audit, Phase 6 placeholder audit, or B12 live smoke. | @@ -608,9 +611,9 @@ This ledger records the committed parity checkpoints that future slices should b ## Next Slice Contract -Committed implementation baseline: `0b47066 feat(search): align conversation result payloads` closes P3.85 SearchAPI conversation payload parity for the inspected `reference/chatwoot` search controller, Jbuilder views, and reused dashboard search result cards. +Committed implementation baseline: the current checkpoint is prepared as `feat(search): align message result payloads`, closing P3.86 SearchAPI message payload parity for the inspected `reference/chatwoot` message serializer, push-event data, and reused dashboard message search result cards. -Completed documentation slice: this checkpoint keeps the plan self-contained for follow-up work. The user-confirmed scope, Hermes source-plan landing map, active route/search/enterprise contracts, current route-parity numbers, next executable queue, P3.84/P3.85 commit ledger rows, and progress log are all represented in this document. +Completed documentation slice: this checkpoint keeps the plan self-contained for follow-up work. The user-confirmed scope, Hermes source-plan landing map, active route/search/enterprise contracts, current route-parity numbers, next executable queue, P3.86 commit ledger row, and progress log are all represented in this document. Next implementation slice: do not start from older Hermes TODOs directly. Continue with one of these evidence-backed paths: Phase 2/3 route/controller/serializer drift audit, Phase 6 placeholder audit, or B12 live smoke when the full PostgreSQL/Redis/Meilisearch/GoChat/Vite/Chrome stack is available. Every discovered failure becomes a named row in the Active Remaining Work Board before implementation. @@ -823,7 +826,7 @@ B6 request and payload matrix after `a16c23c`: | --- | --- | --- | --- | | `GET /api/v1/accounts/:account_id/search` | `q`, `page`, default 15 items, existing local filters, plus `since`, `until`, `from`, `inbox_id`. | `{ payload: { conversations, contacts, messages, articles } }`. | `TestSearchHandler_GlobalSearch_Success`, `TestParseSearchFilter_ChatwootSearchParams`. | | `GET /api/v1/accounts/:account_id/search/conversations` | `q`, `page`, status/priority/assignee/team/inbox/labels/date filters. | `{ payload: { conversations: [...] } }`. | `TestSearchHandler_SearchConversations_Success`. | -| `GET /api/v1/accounts/:account_id/search/messages` | `q`, `page`, `message_type`, `sender_type`, `from`, `sender_id`, `content_type`, `private`, `inbox_id`, `since`, `until`. | `{ payload: { messages: [...] } }` with numeric Chatwoot `message_type` for model and Meilisearch hit data. | `TestSearchHandler_SearchMessages_Success`, `TestSearchHandler_SearchMessages_MeiliHitPayloadShape`, `TestMeiliSearchEngine_SearchSendsMessageSenderIDFilter`. | +| `GET /api/v1/accounts/:account_id/search/messages` | `q`, `page`, `message_type`, `sender_type`, `from`, `sender_id`, `content_type`, `private`, `inbox_id`, `since`, `until`. | `{ payload: { messages: [...] } }` with numeric Chatwoot `message_type`, conversation display IDs, sender push data, and attachment push data for DB-backed and Meilisearch hit data. | `TestSearchHandler_SearchMessages_Success`, `TestSearchHandler_SearchMessages_MeiliHitPayloadShape`, `TestSearchHandler_SearchMessages_HydratesChatwootMessagePayload`, `TestMeiliSearchEngine_SearchSendsMessageSenderIDFilter`. | | `GET /api/v1/accounts/:account_id/search/contacts` | `q`, `page`, `contact_source`. | `{ payload: { contacts: [...] } }`. | `TestSearchHandler_SearchContacts_Success`. | | `GET /api/v1/accounts/:account_id/search/articles` | `q`, `page`, `portal_id`, `article_status`, `locale`. | `{ payload: { articles: [...] } }`. | `TestSearchHandler_SearchArticles_Success`. | @@ -2720,3 +2723,4 @@ Verification milestone gates: - 2026-06-07: P3.84 search agent-sender filter checkpoint prepared as `feat(search): align agent sender filters`; audited Chatwoot `SearchService#parse_from_param`, `#apply_sender_filter`, and reused `SearchContactAgentSelector.vue`/SearchAPI message filter callers. GoChat DB fallback and Meilisearch message filters now treat `from=agent:id` as agent/user sender aliases (`agent`, `user`, `User`) and tolerate contact/bot casing aliases, so reused frontend agent filters find locally stored outgoing agent messages. Focused SearchFilter, Meilisearch engine, and SearchRepo sender-filter tests passed; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. - 2026-06-07: P3.85 search conversation payload checkpoint prepared as `feat(search): align conversation result payloads`; audited Chatwoot search `conversations.json.jbuilder`, `_conversation_search_result`, `_message`, `_contact`, `_inbox`, `_agent`, and reused `SearchResultConversationsList.vue`. GoChat SearchAPI conversation results now include nested `message`, `contact`, `inbox`, `agent`, and `additional_attributes` payloads for DB fallback and Meilisearch hits; DB search, durable indexing, contact fanout reindexing, and `cmd/reindex_search` now preload the display relations needed to build those documents. Focused SearchHandler, SearchRepo, and document-builder tests passed; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. - 2026-06-07: Documentation checkpoint prepared as `docs: reconcile parity tracker`; current baseline now points at `0b47066 feat(search): align conversation result payloads`, the stale P3.39 next-slice wording is replaced, and the Commit Ledger now includes P3.84/P3.85 so the plan can be followed from this document without reading older Hermes notes. Verification for this docs-only checkpoint: `git diff --check`; no Go code or route artifacts changed. +- 2026-06-07: P3.86 search message payload checkpoint prepared as `feat(search): align message result payloads`; audited Chatwoot `_message.json.jbuilder`, `Message#push_event_data`, `Attachment#push_event_data`, and reused `SearchResultMessagesList.vue`/`SearchResultMessageItem.vue`. GoChat SearchAPI message results now hydrate DB-backed hits with conversation display IDs, sender push data, and attachment push data; Meilisearch hit serialization preserves nested sender/attachment payloads; message documents, durable index replay, and full `cmd/reindex_search` now preload or carry display/attachment data where available. Focused SearchHandler, SearchRepo, DurableSearchIndexer, reindex, and document-builder tests passed; full `go test ./...` passed outside the restricted socket sandbox; `git diff --check` passed. No route artifacts change. diff --git a/internal/app/bootstrap.go b/internal/app/bootstrap.go index ab564445..9d1c0c06 100644 --- a/internal/app/bootstrap.go +++ b/internal/app/bootstrap.go @@ -804,7 +804,7 @@ func Bootstrap(env string) (*App, error) { CustomRole: v1.NewCustomRoleHandler(customRoleService).WithAuditService(auditService), AgentCapacity: v1.NewAgentCapacityHandler(agentCapacityPolicyService).WithAuditService(auditService), CsatMetrics: v1.NewCsatMetricsHandler(csatMetricsService), - Search: v1.NewSearchHandler(searchService), + Search: v1.NewSearchHandler(searchService, db), Widget: widgetHandler, // M13: SSO/SAML enterprise authentication handlers AccountSamlSettings: v1.NewAccountSamlSettingsHandler(accountSamlSettingsRepo), diff --git a/internal/handler/api/v1/search_handler.go b/internal/handler/api/v1/search_handler.go index c3e7d1a4..19333884 100644 --- a/internal/handler/api/v1/search_handler.go +++ b/internal/handler/api/v1/search_handler.go @@ -1,10 +1,12 @@ package v1 import ( + "context" "net/http" "strings" "github.com/gin-gonic/gin" + "gorm.io/gorm" "github.com/gochat/gochat/internal/model" "github.com/gochat/gochat/internal/search" @@ -17,11 +19,16 @@ const chatwootSearchPerPage = 15 // Reference: Chatwoot GlobalSearchService — cross-entity search with advanced filtering. type SearchHandler struct { svc *search.SearchService + db *gorm.DB } // NewSearchHandler creates a new SearchHandler. -func NewSearchHandler(svc *search.SearchService) *SearchHandler { - return &SearchHandler{svc: svc} +func NewSearchHandler(svc *search.SearchService, dbs ...*gorm.DB) *SearchHandler { + h := &SearchHandler{svc: svc} + if len(dbs) > 0 { + h.db = dbs[0] + } + return h } // GlobalSearch performs a unified search across conversations, messages, and contacts. @@ -79,7 +86,7 @@ func (h *SearchHandler) GlobalSearch(c *gin.Context) { return } - c.JSON(http.StatusOK, gin.H{"payload": serializeSearchPayload(result.Results)}) + c.JSON(http.StatusOK, gin.H{"payload": serializeSearchPayload(c.Request.Context(), h.db, result.Results)}) } // SearchConversations performs a conversation-only search with advanced filters. @@ -131,7 +138,7 @@ func (h *SearchHandler) SearchConversations(c *gin.Context) { } _ = total - c.JSON(http.StatusOK, gin.H{"payload": gin.H{"conversations": serializeSearchConversations(results)}}) + c.JSON(http.StatusOK, gin.H{"payload": gin.H{"conversations": serializeSearchConversations(c.Request.Context(), h.db, results)}}) } // SearchMessages performs a message-only search with advanced filters. @@ -182,7 +189,7 @@ func (h *SearchHandler) SearchMessages(c *gin.Context) { } _ = total - c.JSON(http.StatusOK, gin.H{"payload": gin.H{"messages": serializeSearchMessages(results)}}) + c.JSON(http.StatusOK, gin.H{"payload": gin.H{"messages": serializeSearchMessages(c.Request.Context(), h.db, results)}}) } // SearchContacts performs a contact-only search with advanced filters. @@ -278,11 +285,11 @@ func (h *SearchHandler) SearchArticles(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"payload": gin.H{"articles": serializeSearchArticles(results)}}) } -func serializeSearchPayload(results []search.SearchResult) gin.H { +func serializeSearchPayload(ctx context.Context, db *gorm.DB, results []search.SearchResult) gin.H { return gin.H{ - "conversations": serializeSearchConversations(filterSearchResults(results, search.ResultTypeConversation)), + "conversations": serializeSearchConversations(ctx, db, filterSearchResults(results, search.ResultTypeConversation)), "contacts": serializeSearchContacts(filterSearchResults(results, search.ResultTypeContact)), - "messages": serializeSearchMessages(filterSearchResults(results, search.ResultTypeMessage)), + "messages": serializeSearchMessages(ctx, db, filterSearchResults(results, search.ResultTypeMessage)), "articles": serializeSearchArticles(filterSearchResults(results, search.ResultTypeArticle)), } } @@ -308,20 +315,20 @@ func filterSearchResults(results []search.SearchResult, resultType search.Search return filtered } -func serializeSearchConversations(results []search.SearchResult) []map[string]any { +func serializeSearchConversations(ctx context.Context, db *gorm.DB, results []search.SearchResult) []map[string]any { payload := make([]map[string]any, 0, len(results)) for _, result := range results { - payload = append(payload, serializeSearchConversation(result)) + payload = append(payload, serializeSearchConversation(ctx, db, result)) } return payload } -func serializeSearchConversation(result search.SearchResult) map[string]any { +func serializeSearchConversation(ctx context.Context, db *gorm.DB, result search.SearchResult) map[string]any { if conv, ok := result.Data.(model.Conversation); ok { - return serializeSearchConversationModel(&conv) + return serializeSearchConversationModel(ctx, db, &conv) } if conv, ok := result.Data.(*model.Conversation); ok && conv != nil { - return serializeSearchConversationModel(conv) + return serializeSearchConversationModel(ctx, db, conv) } root := searchDataRoot(result) data := nestedSearchDataFromRoot(root, "conversation") @@ -330,31 +337,31 @@ func serializeSearchConversation(result search.SearchResult) map[string]any { "account_id": firstMapValue(data, "account_id"), "created_at": unixFromMapValue(firstMapValue(data, "created_at", "created_at_ts")), "additional_attributes": firstMapValue(data, "additional_attributes"), - "message": serializeSearchConversationMessageMap(firstNestedSearchData(root, data, "message")), + "message": serializeSearchConversationMessageMap(ctx, db, firstNestedSearchData(root, data, "message")), "contact": serializeSearchConversationContactMap(firstNestedSearchData(root, data, "contact")), "inbox": serializeSearchConversationInboxMap(firstNestedSearchData(root, data, "inbox")), "agent": serializeSearchConversationAgentMap(firstNestedSearchData(root, data, "agent", "assignee")), } } -func serializeSearchConversationModel(conv *model.Conversation) map[string]any { +func serializeSearchConversationModel(ctx context.Context, db *gorm.DB, conv *model.Conversation) map[string]any { return map[string]any{ "id": conversationDisplayID(conv), "account_id": conv.AccountID, "created_at": conv.CreatedAt.Unix(), "additional_attributes": jsonObject(conv.AdditionalAttributes), - "message": serializeSearchConversationMessageModel(conv), + "message": serializeSearchConversationMessageModel(ctx, db, conv), "contact": serializeSearchConversationContactModel(conv), "inbox": serializeSearchConversationInboxModel(conv), "agent": serializeSearchConversationAgentModel(conv), } } -func serializeSearchConversationMessageModel(conv *model.Conversation) map[string]any { +func serializeSearchConversationMessageModel(ctx context.Context, db *gorm.DB, conv *model.Conversation) map[string]any { if len(conv.Messages) == 0 { return map[string]any{} } - return serializeSearchMessageModel(&conv.Messages[0]) + return serializeSearchMessageModel(ctx, db, &conv.Messages[0]) } func serializeSearchConversationContactModel(conv *model.Conversation) map[string]any { @@ -395,11 +402,11 @@ func serializeSearchConversationAgentModel(conv *model.Conversation) map[string] return map[string]any{} } -func serializeSearchConversationMessageMap(data map[string]any) map[string]any { +func serializeSearchConversationMessageMap(ctx context.Context, db *gorm.DB, data map[string]any) map[string]any { if len(data) == 0 { return map[string]any{} } - return serializeSearchMessage(search.SearchResult{Data: map[string]any{"message": data}}) + return serializeSearchMessage(ctx, db, search.SearchResult{Data: map[string]any{"message": data}}) } func serializeSearchConversationContactMap(data map[string]any) map[string]any { @@ -481,37 +488,44 @@ func serializeSearchContactModel(contact *model.Contact) map[string]any { } } -func serializeSearchMessages(results []search.SearchResult) []map[string]any { +func serializeSearchMessages(ctx context.Context, db *gorm.DB, results []search.SearchResult) []map[string]any { payload := make([]map[string]any, 0, len(results)) for _, result := range results { - payload = append(payload, serializeSearchMessage(result)) + payload = append(payload, serializeSearchMessage(ctx, db, result)) } return payload } -func serializeSearchMessage(result search.SearchResult) map[string]any { +func serializeSearchMessage(ctx context.Context, db *gorm.DB, result search.SearchResult) map[string]any { if message, ok := result.Data.(model.Message); ok { - return serializeSearchMessageModel(&message) + return serializeSearchMessageModel(ctx, db, &message) } if message, ok := result.Data.(*model.Message); ok && message != nil { - return serializeSearchMessageModel(message) + return serializeSearchMessageModel(ctx, db, message) } data := nestedSearchData(result, "message") - return map[string]any{ - "id": firstMapValue(data, "id"), - "content": firstMapValue(data, "content"), - "account_id": firstMapValue(data, "account_id"), - "inbox_id": firstMapValue(data, "inbox_id"), - "conversation_id": firstMapValue(data, "conversation_id"), - "message_type": normalizeSearchMessageType(firstMapValue(data, "message_type")), - "content_type": firstMapValue(data, "content_type"), - "status": firstMapValue(data, "status"), - "content_attributes": firstMapValue(data, "content_attributes"), - "additional_attributes": firstMapValue(data, "additional_attributes"), - "created_at": unixFromMapValue(firstMapValue(data, "created_at", "created_at_ts")), - "private": firstMapValue(data, "private"), - "source_id": firstMapValue(data, "source_id"), + if db != nil { + if payload, ok := loadSearchMessagePayload(ctx, db, uintFromAny(firstMapValue(data, "id")), result.AccountID); ok { + return payload + } } + return omitNilSearchMessageFields(map[string]any{ + "id": firstMapValue(data, "id"), + "content": firstMapValue(data, "content"), + "account_id": firstMapValue(data, "account_id"), + "inbox_id": firstMapValue(data, "inbox_id"), + "conversation_id": firstMapValue(data, "conversation_id"), + "message_type": normalizeSearchMessageType(firstMapValue(data, "message_type")), + "content_type": firstMapValue(data, "content_type"), + "status": firstMapValue(data, "status"), + "content_attributes": firstMapValue(data, "content_attributes"), + "created_at": unixFromMapValue(firstMapValue(data, "created_at", "created_at_ts")), + "private": firstMapValue(data, "private"), + "source_id": firstMapValue(data, "source_id"), + "echo_id": firstMapValue(data, "echo_id"), + "sender": firstMapValue(data, "sender"), + "attachments": firstMapValue(data, "attachments"), + }) } func normalizeSearchMessageType(value any) any { @@ -525,22 +539,83 @@ func normalizeSearchMessageType(value any) any { return messageTypeValue(s) } -func serializeSearchMessageModel(message *model.Message) map[string]any { - return map[string]any{ - "id": message.ID, - "content": message.Content, - "account_id": message.AccountID, - "inbox_id": message.InboxID, - "conversation_id": message.ConversationID, - "message_type": messageTypeValue(message.MessageType), - "content_type": nonEmpty(message.ContentType, "text"), - "status": nonEmpty(message.Status, "sent"), - "content_attributes": jsonObject(message.ContentAttributes), - "additional_attributes": jsonObject(message.AdditionalAttributes), - "created_at": message.CreatedAt.Unix(), - "private": message.Private, - "source_id": message.SourceID, +func serializeSearchMessageModel(ctx context.Context, db *gorm.DB, message *model.Message) map[string]any { + if db != nil { + if payload, ok := loadSearchMessagePayload(ctx, db, message.ID, message.AccountID); ok { + return payload + } } + return omitNilSearchMessageFields(map[string]any{ + "id": message.ID, + "content": message.Content, + "account_id": message.AccountID, + "inbox_id": message.InboxID, + "conversation_id": message.ConversationID, + "message_type": messageTypeValue(message.MessageType), + "content_type": nonEmpty(message.ContentType, "text"), + "status": nonEmpty(message.Status, "sent"), + "content_attributes": jsonObject(message.ContentAttributes), + "created_at": message.CreatedAt.Unix(), + "private": message.Private, + "source_id": message.SourceID, + "echo_id": message.EchoID, + }) +} + +func loadSearchMessagePayload(ctx context.Context, db *gorm.DB, messageID uint, accountID uint) (map[string]any, bool) { + if db == nil || messageID == 0 { + return nil, false + } + var message model.Message + q := db.WithContext(ctx).Where("id = ?", messageID) + if accountID != 0 { + q = q.Where("account_id = ?", accountID) + } + if err := q.First(&message).Error; err != nil { + return nil, false + } + var conversation model.Conversation + if err := db.WithContext(ctx). + Where("id = ? AND account_id = ?", message.ConversationID, message.AccountID). + First(&conversation).Error; err != nil { + return chatwootMessagePayloadMap(serializeMessage(ctx, db, &message, nil)), true + } + return chatwootMessagePayloadMap(serializeMessage(ctx, db, &message, &conversation)), true +} + +func chatwootMessagePayloadMap(payload chatwootMessagePayload) map[string]any { + data := map[string]any{ + "id": payload.ID, + "content": payload.Content, + "inbox_id": payload.InboxID, + "conversation_id": payload.ConversationID, + "message_type": payload.MessageType, + "content_type": payload.ContentType, + "status": payload.Status, + "content_attributes": payload.ContentAttributes, + "created_at": payload.CreatedAt, + "private": payload.Private, + "source_id": payload.SourceID, + } + if payload.EchoID != "" { + data["echo_id"] = payload.EchoID + } + if len(payload.Sender) > 0 { + data["sender"] = payload.Sender + } + if len(payload.Attachments) > 0 { + data["attachments"] = payload.Attachments + } + return data +} + +func omitNilSearchMessageFields(data map[string]any) map[string]any { + for _, key := range []string{"echo_id", "sender", "attachments"} { + if data[key] == nil || data[key] == "" { + delete(data, key) + } + } + return data } func serializeSearchArticles(results []search.SearchResult) []map[string]any { @@ -670,3 +745,23 @@ func unixFromMapValue(value any) any { return typed } } + +func uintFromAny(value any) uint { + switch typed := value.(type) { + case uint: + return typed + case int: + if typed > 0 { + return uint(typed) + } + case int64: + if typed > 0 { + return uint(typed) + } + case float64: + if typed > 0 { + return uint(typed) + } + } + return 0 +} diff --git a/internal/handler/api/v1/search_handler_test.go b/internal/handler/api/v1/search_handler_test.go index 58555754..1e9dd6d2 100644 --- a/internal/handler/api/v1/search_handler_test.go +++ b/internal/handler/api/v1/search_handler_test.go @@ -12,6 +12,9 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "gorm.io/datatypes" + "gorm.io/driver/sqlite" + "gorm.io/gorm" + "gorm.io/gorm/logger" "github.com/gochat/gochat/internal/model" "github.com/gochat/gochat/internal/search" @@ -342,9 +345,11 @@ func TestSearchHandler_SearchMessages_MeiliHitPayloadShape(t *testing.T) { "id": float64(9), "content": "hello from meili", "account_id": float64(1), - "conversation_id": float64(3), + "conversation_id": float64(42), "message_type": "incoming", "created_at_ts": float64(1700000000), + "sender": map[string]any{"id": float64(7), "name": "Ada Contact"}, + "attachments": []any{map[string]any{"id": float64(11), "file_type": "file", "data_url": "https://files.example/doc.pdf"}}, }, }, }, @@ -368,6 +373,68 @@ func TestSearchHandler_SearchMessages_MeiliHitPayloadShape(t *testing.T) { message := messages[0].(map[string]any) assert.Equal(t, float64(0), message["message_type"]) assert.Equal(t, float64(1700000000), message["created_at"]) + assert.Equal(t, float64(42), message["conversation_id"]) + assert.Equal(t, "Ada Contact", message["sender"].(map[string]any)["name"]) + attachments := message["attachments"].([]any) + require.Len(t, attachments, 1) + assert.Equal(t, "https://files.example/doc.pdf", attachments[0].(map[string]any)["data_url"]) +} + +func TestSearchHandler_SearchMessages_HydratesChatwootMessagePayload(t *testing.T) { + db, err := gorm.Open(sqlite.Open("file:search-message-payload?mode=memory&cache=private"), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)}) + require.NoError(t, err) + require.NoError(t, db.AutoMigrate(&model.Account{}, &model.User{}, &model.Inbox{}, &model.Contact{}, &model.Conversation{}, &model.Message{}, &model.Attachment{})) + + account := model.Account{Name: "Acme"} + require.NoError(t, db.Create(&account).Error) + inbox := model.Inbox{AccountID: account.ID, Name: "Website", ChannelType: "web_widget"} + require.NoError(t, db.Create(&inbox).Error) + contact := model.Contact{AccountID: account.ID, Name: "Ada Contact", Email: "ada@example.com"} + require.NoError(t, db.Create(&contact).Error) + agent := model.User{Name: "Agent One", Email: "agent@example.com"} + require.NoError(t, db.Create(&agent).Error) + displayID := uint(42) + conversation := model.Conversation{AccountID: account.ID, InboxID: inbox.ID, ContactID: contact.ID, DisplayID: &displayID, Status: "open"} + require.NoError(t, db.Create(&conversation).Error) + message := model.Message{ + AccountID: account.ID, + InboxID: inbox.ID, + ConversationID: conversation.ID, + SenderID: &agent.ID, + SenderType: "user", + MessageType: "outgoing", + ContentType: "text", + Status: "sent", + Content: "hello with attachment", + ContentAttributes: datatypes.JSON([]byte(`{"source":"search"}`)), + } + require.NoError(t, db.Create(&message).Error) + require.NoError(t, db.Create(&model.Attachment{AccountID: account.ID, MessageID: message.ID, FileType: "file", FileName: "quote.pdf", FileURL: "https://files.example/quote.pdf", FileSize: 128}).Error) + + repo := &mockSearchRepo{messages: []model.Message{{Base: model.Base{ID: message.ID}, AccountID: account.ID}}, msgTotal: 1} + svc := search.NewSearchService(repo) + handler := NewSearchHandler(svc, db) + router := setupSearchHandlerRouter(handler) + + w := httptest.NewRecorder() + req := httptest.NewRequest("GET", "/api/v1/accounts/1/search/messages?q=hello", nil) + router.ServeHTTP(w, req) + + require.Equal(t, http.StatusOK, w.Code) + var body map[string]any + require.NoError(t, json.Unmarshal(w.Body.Bytes(), &body)) + payload := body["payload"].(map[string]any) + messages := payload["messages"].([]any) + require.Len(t, messages, 1) + got := messages[0].(map[string]any) + assert.Equal(t, float64(displayID), got["conversation_id"]) + sender := got["sender"].(map[string]any) + assert.Equal(t, "Agent One", sender["name"]) + attachments := got["attachments"].([]any) + require.Len(t, attachments, 1) + attachment := attachments[0].(map[string]any) + assert.Equal(t, "file", attachment["file_type"]) + assert.Equal(t, "https://files.example/quote.pdf", attachment["data_url"]) } func TestSearchHandler_SearchMessages_InvalidAccountID(t *testing.T) { diff --git a/internal/model/message.go b/internal/model/message.go index a415060c..c3382dc6 100644 --- a/internal/model/message.go +++ b/internal/model/message.go @@ -23,6 +23,9 @@ type Message struct { ContentAttributes datatypes.JSON `gorm:"type:jsonb" json:"content_attributes,omitempty"` // attachments, mentions, etc AdditionalAttributes datatypes.JSON `gorm:"type:jsonb" json:"additional_attributes,omitempty"` ExternalSourceIDs datatypes.JSON `gorm:"type:jsonb" json:"external_source_ids,omitempty"` // external platform IDs + + Conversation *Conversation `gorm:"foreignKey:ConversationID" json:"conversation,omitempty"` + Attachments []Attachment `gorm:"foreignKey:MessageID" json:"attachments,omitempty"` } func (Message) TableName() string { return "messages" } diff --git a/internal/search/engine.go b/internal/search/engine.go index 3d333524..473c3060 100644 --- a/internal/search/engine.go +++ b/internal/search/engine.go @@ -2,7 +2,9 @@ package search import ( "context" + "encoding/json" "fmt" + "path/filepath" "strings" "time" @@ -247,6 +249,7 @@ func conversationSearchContent(conv model.Conversation) string { func MessageDocument(msg model.Message) SearchDocument { inboxID := msg.InboxID conversationID := msg.ConversationID + messageData := messageDocumentData(msg) doc := SearchDocument{ ID: msg.ID, Type: ResultTypeMessage, @@ -264,12 +267,99 @@ func MessageDocument(msg model.Message) SearchDocument { ConversationID: &conversationID, CreatedAtTS: timestamp(msg.CreatedAt), UpdatedAtTS: timestamp(msg.UpdatedAt), - Data: map[string]interface{}{"message": msg}, + Data: map[string]interface{}{"message": messageData}, } doc.ensureUID() return doc } +func messageDocumentData(msg model.Message) map[string]interface{} { + conversationID := msg.ConversationID + if msg.Conversation != nil { + conversationID = messageConversationDisplayID(msg.Conversation) + } + data := map[string]interface{}{ + "id": msg.ID, + "content": msg.Content, + "account_id": msg.AccountID, + "inbox_id": msg.InboxID, + "conversation_id": conversationID, + "message_type": msg.MessageType, + "content_type": firstNonEmpty(msg.ContentType, "text"), + "status": firstNonEmpty(msg.Status, "sent"), + "content_attributes": jsonObject(msg.ContentAttributes), + "created_at": timestamp(msg.CreatedAt), + "private": msg.Private, + "source_id": msg.SourceID, + } + if msg.EchoID != "" { + data["echo_id"] = msg.EchoID + } + if len(msg.Attachments) > 0 { + attachments := make([]map[string]interface{}, 0, len(msg.Attachments)) + for i := range msg.Attachments { + attachments = append(attachments, attachmentDocumentData(msg.Attachments[i])) + } + data["attachments"] = attachments + } + return data +} + +func messageConversationDisplayID(conversation *model.Conversation) uint { + if conversation != nil && conversation.DisplayID != nil && *conversation.DisplayID != 0 { + return *conversation.DisplayID + } + if conversation != nil { + return conversation.ID + } + return 0 +} + +func attachmentDocumentData(attachment model.Attachment) map[string]interface{} { + dataURL := firstNonEmpty(attachment.FileURL, attachment.ExternalURL) + data := map[string]interface{}{ + "id": attachment.ID, + "message_id": attachment.MessageID, + "file_type": attachment.FileType, + "account_id": attachment.AccountID, + "data_url": dataURL, + "thumb_url": attachment.ThumbURL, + "file_size": attachment.FileSize, + "extension": strings.TrimPrefix(filepath.Ext(attachment.FileName), "."), + "width": attachment.Width, + "height": attachment.Height, + } + if attachment.FileType == "audio" { + data["transcribed_text"] = metadataValue(attachment.Metadata, "transcribed_text") + } + return data +} + +func jsonObject(raw []byte) map[string]interface{} { + if len(raw) == 0 || string(raw) == "null" { + return map[string]interface{}{} + } + var out map[string]interface{} + if err := json.Unmarshal(raw, &out); err != nil || out == nil { + return map[string]interface{}{} + } + return out +} + +func metadataValue(raw string, key string) string { + if strings.TrimSpace(raw) == "" { + return "" + } + var data map[string]interface{} + if err := json.Unmarshal([]byte(raw), &data); err != nil { + return "" + } + if value, ok := data[key].(string); ok { + return value + } + return "" +} + func ContactDocument(contact model.Contact) SearchDocument { content := strings.TrimSpace(strings.Join([]string{contact.Email, contact.PhoneNumber, contact.Identifier}, " ")) doc := SearchDocument{ diff --git a/internal/search/engine_test.go b/internal/search/engine_test.go index f56d6a29..f4a4e5a8 100644 --- a/internal/search/engine_test.go +++ b/internal/search/engine_test.go @@ -69,6 +69,39 @@ func TestDocumentBuildersSetStableUIDAndType(t *testing.T) { assert.Equal(t, uint(15), doc.Data["message"].(map[string]interface{})["id"]) } +func TestMessageDocumentCarriesChatwootPayloadData(t *testing.T) { + displayID := uint(42) + msg := model.Message{ + Base: model.Base{ID: 15, CreatedAt: time.Unix(1772884700, 0)}, + AccountID: 3, + InboxID: 7, + ConversationID: 12, + Content: "hello with file", + MessageType: "incoming", + ContentType: "text", + Status: "sent", + Conversation: &model.Conversation{Base: model.Base{ID: 12}, DisplayID: &displayID}, + Attachments: []model.Attachment{{ + Base: model.Base{ID: 99}, + AccountID: 3, + MessageID: 15, + FileType: "audio", + FileName: "note.mp3", + FileURL: "https://files.example/note.mp3", + Metadata: `{"transcribed_text":"hello transcript"}`, + }}, + } + + doc := MessageDocument(msg) + + message := doc.Data["message"].(map[string]interface{}) + assert.Equal(t, displayID, message["conversation_id"]) + attachments := message["attachments"].([]map[string]interface{}) + require.Len(t, attachments, 1) + assert.Equal(t, "audio", attachments[0]["file_type"]) + assert.Equal(t, "hello transcript", attachments[0]["transcribed_text"]) +} + func TestContactDocumentSetsResolvedScopeFields(t *testing.T) { doc := ContactDocument(model.Contact{ Base: model.Base{ID: 5}, diff --git a/internal/service/search_indexer_worker.go b/internal/service/search_indexer_worker.go index 0228d50c..e8222089 100644 --- a/internal/service/search_indexer_worker.go +++ b/internal/service/search_indexer_worker.go @@ -61,6 +61,9 @@ func (i *DurableSearchIndexer) IndexMessage(ctx context.Context, message *model. return nil } return i.enqueueOrIndex(ctx, "message", message.AccountID, message.ID, func() error { + if enriched, err := i.loadMessage(ctx, message.AccountID, message.ID); err == nil && enriched != nil { + return i.delegate.IndexMessage(ctx, enriched) + } return i.delegate.IndexMessage(ctx, message) }) } @@ -160,11 +163,14 @@ func (i *DurableSearchIndexer) performIndex(ctx context.Context, payload searchI } return i.delegate.IndexConversation(ctx, item) case "message": - var item model.Message - if err := i.load(ctx, payload, &item); err != nil { + item, err := i.loadMessage(ctx, payload.AccountID, payload.ID) + if err != nil { return err } - return i.delegate.IndexMessage(ctx, &item) + if item == nil { + return nil + } + return i.delegate.IndexMessage(ctx, item) case "contact": var item model.Contact if err := i.load(ctx, payload, &item); err != nil { @@ -188,6 +194,25 @@ func (i *DurableSearchIndexer) performIndex(ctx context.Context, payload searchI } } +func (i *DurableSearchIndexer) loadMessage(ctx context.Context, accountID, id uint) (*model.Message, error) { + if i.db == nil { + return nil, nil + } + var item model.Message + err := i.db.WithContext(ctx). + Preload("Conversation"). + Preload("Attachments", func(db *gorm.DB) *gorm.DB { return db.Order("id ASC") }). + Where("id = ? AND account_id = ?", id, accountID). + First(&item).Error + if errors.Is(err, gorm.ErrRecordNotFound) { + return nil, i.performDelete(ctx, searchIndexJob{Operation: "delete", Entity: "message", AccountID: accountID, ID: id}) + } + if err != nil { + return nil, err + } + return &item, nil +} + func (i *DurableSearchIndexer) loadConversation(ctx context.Context, accountID, id uint) (*model.Conversation, error) { var item model.Conversation err := i.db.WithContext(ctx).