@open-mercato/core 0.6.7 → 0.6.8-develop.6874.1.982d6097d8

package/src/modules/messages/i18n/ko.json

@@ -0,0 +1,263 @@
+{
+  "messages.actions.archive": "보관",
+  "messages.actions.archiveConversation": "대화 보관",
+  "messages.actions.backToList": "메시지로 돌아가기",
+  "messages.actions.confirmation": "확인",
+  "messages.actions.conversationActions": "대화 작업",
+  "messages.actions.delete": "삭제",
+  "messages.actions.deleteConversation": "대화 삭제",
+  "messages.actions.edit": "편집",
+  "messages.actions.executing": "실행 중...",
+  "messages.actions.forwardAll": "모두 전달",
+  "messages.actions.markAllRead": "모두 읽음으로 표시",
+  "messages.actions.markAllUnread": "모두 읽지 않음으로 표시",
+  "messages.actions.markRead": "읽음으로 표시",
+  "messages.actions.markUnread": "읽지 않음으로 표시",
+  "messages.actions.open": "열기",
+  "messages.actions.taken": "실행된 작업",
+  "messages.actions.title": "작업",
+  "messages.actions.unarchive": "보관 취소",
+  "messages.actions.unarchiveConversation": "대화 보관 취소",
+  "messages.attachFiles": "파일 첨부",
+  "messages.attachObject": "객체 첨부",
+  "messages.attachedFiles": "첨부 파일",
+  "messages.attachedObjects": "첨부된 객체",
+  "messages.attachmentIds": "첨부 파일 ID",
+  "messages.badge.unread": "읽지 않은 메시지 {count}개",
+  "messages.body": "메시지",
+  "messages.bodyFormat.toggle": "마크다운 전환",
+  "messages.bulk.delete.description": "선택한 메시지를 보기에서 제거합니다.",
+  "messages.bulk.delete.title": "{count}개 메시지를 삭제하시겠습니까?",
+  "messages.bulk.flash.archiveSuccess": "메시지 {count}개가 보관되었습니다.",
+  "messages.bulk.flash.deleteSuccess": "메시지 {count}개가 삭제되었습니다.",
+  "messages.bulk.flash.failed": "메시지 {count}개 처리에 실패했습니다.",
+  "messages.bulk.flash.markReadSuccess": "메시지 {count}개가 읽음으로 표시되었습니다.",
+  "messages.bulk.flash.markUnreadSuccess": "메시지 {count}개가 읽지 않음으로 표시되었습니다.",
+  "messages.bulk.flash.partial": "{total}개 메시지 중 {succeeded}개가 처리되었습니다. {failed}개는 실패했습니다.",
+  "messages.bulk.flash.unarchiveSuccess": "메시지 {count}건을 받은편지함으로 이동했습니다.",
+  "messages.compose": "메시지 작성",
+  "messages.composeHint": "메시지를 작성하고, 객체를 첨부한 다음, 선택한 수신자에게 보내세요.",
+  "messages.composer.attachmentPicker.confirm": "선택 항목 첨부",
+  "messages.composer.attachmentPicker.empty": "아직 업로드된 파일이 없습니다.",
+  "messages.composer.attachmentPicker.limit": "최대 {count}개 파일을 첨부할 수 있습니다.",
+  "messages.composer.attachmentPicker.loading": "첨부 파일을 불러오는 중...",
+  "messages.composer.attachmentPicker.maxWarning": "첨부 파일 한도에 도달했습니다.",
+  "messages.composer.attachmentPicker.title": "파일 첨부",
+  "messages.composer.attachmentPicker.upload": "파일 업로드",
+  "messages.composer.confirm.incompatibleObjects": "메시지 유형을 변경하면 호환되지 않는 첨부 객체 {count}개가 제거됩니다. 계속하시겠습니까?",
+  "messages.composer.dialogDescription": "메시지를 작성하고 전송합니다.",
+  "messages.composer.hints.actionExpiry": "이 유형의 작업은 {hours}시간 후 만료됩니다.",
+  "messages.composer.maxObjectsWarning": "권장 첨부 객체 한도인 25개에 도달했습니다.",
+  "messages.composer.noAttachments": "아직 첨부된 파일이 없습니다.",
+  "messages.composer.noObjectTypesForMessageType": "이 메시지 유형에 사용 가능한 객체 유형이 없습니다.",
+  "messages.composer.noObjects": "아직 첨부된 객체가 없습니다.",
+  "messages.composer.objectAction": "작업: {action}",
+  "messages.composer.objectActionRequired": "작업 필요",
+  "messages.composer.objectPicker.actionRequiredHint": "이 객체를 수신자 작업이 필요한 것으로 표시합니다.",
+  "messages.composer.objectPicker.actionRequiredLabel": "작업 필요",
+  "messages.composer.objectPicker.actionTypeLabel": "작업 유형",
+  "messages.composer.objectPicker.actionTypePlaceholder": "작업 선택",
+  "messages.composer.objectPicker.confirm": "첨부",
+  "messages.composer.objectPicker.entityIdLabel": "엔터티 ID",
+  "messages.composer.objectPicker.entityIdPlaceholder": "엔터티의 UUID",
+  "messages.composer.objectPicker.errors.actionRequired": "작업을 선택하세요.",
+  "messages.composer.objectPicker.errors.duplicate": "이 객체는 이미 첨부되어 있습니다.",
+  "messages.composer.objectPicker.errors.entityIdInvalid": "유효한 UUID를 입력하세요.",
+  "messages.composer.objectPicker.errors.maxObjects": "최대 {count}개 객체를 첨부할 수 있습니다.",
+  "messages.composer.objectPicker.errors.messageTypeRequired": "객체를 첨부하기 전에 메시지 유형을 선택하세요.",
+  "messages.composer.objectPicker.errors.recordRequired": "레코드를 선택하세요.",
+  "messages.composer.objectPicker.errors.typeRequired": "객체 유형을 선택하세요.",
+  "messages.composer.objectPicker.loadingRecords": "레코드를 불러오는 중...",
+  "messages.composer.objectPicker.maxWarning": "권장 객체 한도인 {count}개에 도달했습니다.",
+  "messages.composer.objectPicker.messageTypeHint": "선택한 메시지 유형과 호환되는 객체 유형만 사용할 수 있습니다.",
+  "messages.composer.objectPicker.noRecords": "이 객체 유형에 대한 레코드를 찾을 수 없습니다.",
+  "messages.composer.objectPicker.recordLabel": "레코드",
+  "messages.composer.objectPicker.recordPlaceholder": "레코드 선택",
+  "messages.composer.objectPicker.recordSearchLabel": "레코드 검색",
+  "messages.composer.objectPicker.recordSearchPlaceholder": "레코드를 찾으려면 입력하세요",
+  "messages.composer.objectPicker.searchLabel": "객체 유형 검색",
+  "messages.composer.objectPicker.searchPlaceholder": "모듈 또는 엔터티 이름 입력",
+  "messages.composer.objectPicker.title": "객체 첨부",
+  "messages.composer.objectPicker.typeLabel": "객체 유형",
+  "messages.composer.objectPicker.typePlaceholder": "객체 유형 선택",
+  "messages.composer.removeAttachment": "첨부 파일 제거",
+  "messages.composer.removeObject": "첨부된 객체 제거",
+  "messages.composer.shortcuts": "제출하려면 Cmd/Ctrl + Enter를, 취소하려면 Escape를 사용하세요.",
+  "messages.confirm.action": "계속하시겠습니까?",
+  "messages.confirm.actionConfirm": "확인",
+  "messages.confirm.actionTitle": "작업 확인",
+  "messages.confirm.delete": "이 메시지를 보기에서 삭제하시겠습니까?",
+  "messages.confirm.deleteConversation": "이 대화를 보기에서 삭제하시겠습니까?",
+  "messages.confirm.deleteConversationTitle": "대화 삭제",
+  "messages.confirm.deleteTitle": "메시지 삭제",
+  "messages.confirmation.confirmed": "확인됨",
+  "messages.confirmation.confirmedAt": "확인 시각",
+  "messages.confirmation.notConfirmed": "확인되지 않음",
+  "messages.detail.from": "보낸 사람",
+  "messages.detail.hideDetails": "상세 정보 숨기기",
+  "messages.detail.noAttachments": "연결된 첨부 파일이 없습니다.",
+  "messages.detail.noObjects": "첨부된 객체가 없습니다.",
+  "messages.detail.noThread": "아직 스레드 메시지가 없습니다.",
+  "messages.detail.priority": "우선순위",
+  "messages.detail.showDetails": "상세 정보 표시",
+  "messages.detail.source": "소스",
+  "messages.detail.thread": "스레드",
+  "messages.detail.type": "유형",
+  "messages.email.attachments": "첨부 파일",
+  "messages.email.footer": "Open Mercato 메시지",
+  "messages.email.from": "보낸 사람",
+  "messages.email.heading": "새 메시지",
+  "messages.email.objects": "관련 레코드",
+  "messages.email.preview": "Open Mercato에서 메시지를 받았습니다",
+  "messages.email.sentAt": "전송됨",
+  "messages.email.viewCta": "메시지 보기",
+  "messages.errors.actionFailed": "작업을 실행하지 못했습니다.",
+  "messages.errors.archiveSenderMessageUnsupported": "본인이 보낸 메시지는 보관할 수 없습니다.",
+  "messages.errors.conversationActionFailed": "대화 업데이트에 실패했습니다.",
+  "messages.errors.deleteFailed": "메시지 삭제에 실패했습니다.",
+  "messages.errors.forwardPreviewFailed": "전달 미리보기를 불러오지 못했습니다.",
+  "messages.errors.invalidContext": "메시지 컨텍스트가 없습니다.",
+  "messages.errors.loadAttachmentOptionsFailed": "첨부 파일을 불러오지 못했습니다.",
+  "messages.errors.loadAttachmentsFailed": "첨부 파일을 불러오지 못했습니다.",
+  "messages.errors.loadDetailFailed": "메시지 상세 정보를 불러오지 못했습니다.",
+  "messages.errors.loadListFailed": "메시지를 불러오지 못했습니다.",
+  "messages.errors.loadObjectOptionsFailed": "객체 옵션을 불러오지 못했습니다.",
+  "messages.errors.loadObjectTypesFailed": "객체 유형을 불러오지 못했습니다.",
+  "messages.errors.loadTypesFailed": "메시지 유형을 불러오지 못했습니다.",
+  "messages.errors.messageDeleted": "이 메시지는 더 이상 사용할 수 없습니다.",
+  "messages.errors.noBody": "메시지를 입력하세요.",
+  "messages.errors.noExternalEmail": "유효한 외부 이메일을 입력하세요.",
+  "messages.errors.noRecipients": "수신자를 하나 이상 추가하세요.",
+  "messages.errors.noSubject": "제목을 입력하세요.",
+  "messages.errors.sendFailed": "메시지 전송에 실패했습니다.",
+  "messages.errors.stateChangeFailed": "메시지 상태 업데이트에 실패했습니다.",
+  "messages.errors.uploadAttachmentFailed": "첨부 파일 업로드에 실패했습니다.",
+  "messages.externalEmail": "외부 이메일",
+  "messages.externalName": "외부 이름",
+  "messages.fields.type": "메시지 유형",
+  "messages.filters.all": "전체",
+  "messages.filters.hasActions": "작업 요청 있음",
+  "messages.filters.hasActionsTooltip": "하나 이상의 첨부 레코드에 응답(승인, 거부, 검토)이 필요한 메시지를 표시합니다.",
+  "messages.filters.hasAttachments": "첨부 파일 있음",
+  "messages.filters.hasObjects": "관련 레코드 있음",
+  "messages.filters.hasObjectsTooltip": "주문, 견적, 고객과 같은 Open Mercato 레코드가 첨부된 메시지를 표시합니다.",
+  "messages.filters.sender": "발신자",
+  "messages.filters.senderEmpty": "사용자를 검색하려면 입력하세요",
+  "messages.filters.since": "이후 전송됨",
+  "messages.filters.sincePlaceholder": "YYYY-MM-DD",
+  "messages.filters.status": "상태",
+  "messages.filters.type": "유형",
+  "messages.flash.actionSuccess": "작업이 완료되었습니다.",
+  "messages.flash.conversationArchived": "대화가 보관되었습니다.",
+  "messages.flash.conversationDeleted": "대화가 삭제되었습니다.",
+  "messages.flash.conversationMarkedRead": "대화를 읽음으로 표시했습니다.",
+  "messages.flash.conversationMarkedUnread": "대화가 읽지 않음으로 표시되었습니다.",
+  "messages.flash.conversationUnarchived": "대화를 보관함에서 복원했습니다.",
+  "messages.flash.deleted": "메시지가 삭제되었습니다.",
+  "messages.flash.draftSaved": "임시 저장되었습니다.",
+  "messages.flash.forwardSuccess": "메시지가 전달되었습니다.",
+  "messages.flash.replySuccess": "답장이 전송되었습니다.",
+  "messages.flash.sentSuccess": "메시지가 전송되었습니다.",
+  "messages.folder.all": "전체",
+  "messages.folder.archived": "보관됨",
+  "messages.folder.drafts": "임시보관함",
+  "messages.folder.inbox": "받은편지함",
+  "messages.folder.selector": "폴더",
+  "messages.folder.sent": "보낸편지함",
+  "messages.forward": "전달",
+  "messages.forwardContent": "전달된 콘텐츠",
+  "messages.forwardNote": "선택적 메모",
+  "messages.includeAttachments": "첨부 파일 포함",
+  "messages.includeAttachmentsHint": "원본 메시지의 첨부 파일을 그대로 가져옵니다.",
+  "messages.list.noRecipient": "(수신자 없음)",
+  "messages.list.noSubject": "(제목 없음)",
+  "messages.loading.attachments": "첨부 파일을 불러오는 중...",
+  "messages.loading.detail": "메시지를 불러오는 중...",
+  "messages.loading.objectTypes": "객체 유형을 불러오는 중...",
+  "messages.message.archived": "메시지가 보관되었습니다",
+  "messages.message.deleted": "메시지가 삭제되었습니다",
+  "messages.message.marked_unread": "메시지가 읽지 않음으로 표시되었습니다",
+  "messages.message.read": "메시지를 읽었습니다",
+  "messages.message.sent": "메시지가 전송되었습니다",
+  "messages.message.unarchived": "메시지 보관이 취소되었습니다",
+  "messages.nav.compose": "작성",
+  "messages.nav.detail": "메시지 상세 정보",
+  "messages.nav.group": "메시지",
+  "messages.nav.inbox": "메시지",
+  "messages.notifications.new.body": "{from}님으로부터 새 메시지를 받았습니다: {title}",
+  "messages.notifications.new.title": "새 메시지",
+  "messages.objectPreview.fallback.subtitle": "{type} • {id}",
+  "messages.objectPreview.fallback.title": "연결된 객체",
+  "messages.objects.actions.approve": "승인",
+  "messages.objects.actions.reject": "거부",
+  "messages.objects.actions.review": "검토",
+  "messages.objects.actions.view": "상세 정보 보기",
+  "messages.objects.record": "연결된 레코드",
+  "messages.openMessageA11y": "{sender}님의 메시지 열기",
+  "messages.openMessageDetailedA11y": "{sender}님이 {sentAt}에 보낸 {subject} 메시지 열기",
+  "messages.placeholders.attachmentIds": "첨부 파일 UUID를 붙여넣고 Enter를 누르세요",
+  "messages.placeholders.body": "메시지를 작성하세요...",
+  "messages.placeholders.externalEmail": "name@example.com",
+  "messages.placeholders.externalName": "외부 연락처 이름",
+  "messages.placeholders.forwardBody": "전달하기 전에 맥락을 추가하세요...",
+  "messages.placeholders.forwardContent": "전달된 콘텐츠를 검토하고 편집하세요...",
+  "messages.placeholders.recipients": "수신자 검색...",
+  "messages.placeholders.replyBody": "답장을 작성하세요...",
+  "messages.placeholders.sourceEntityId": "연결된 레코드의 UUID",
+  "messages.placeholders.sourceEntityType": "예: sales.order",
+  "messages.placeholders.subject": "제목 입력...",
+  "messages.priority": "우선순위",
+  "messages.reply": "답장",
+  "messages.replyAll": "전체 답장",
+  "messages.replyAllHint": "원본의 모든 수신자를 포함합니다.",
+  "messages.replyBody": "답장",
+  "messages.saveDraft": "임시 저장",
+  "messages.savingDraft": "임시 저장 중...",
+  "messages.search.badge.message": "메시지",
+  "messages.search.fallback.title": "메시지",
+  "messages.searchPlaceholder": "메시지 검색",
+  "messages.send": "보내기",
+  "messages.sendViaEmail": "이메일로도 전송",
+  "messages.sendViaEmailForcedPublic": "공개 표시를 위해 이메일 전달이 항상 활성화되어 있습니다.",
+  "messages.sendViaEmailHint": "수신자는 보안 링크가 포함된 이메일 사본을 받게 됩니다.",
+  "messages.sending": "전송 중...",
+  "messages.sourceEntityId": "소스 엔터티 ID",
+  "messages.sourceEntityType": "소스 엔터티 유형",
+  "messages.status.archived": "보관됨",
+  "messages.status.draft": "임시보관",
+  "messages.status.read": "읽음",
+  "messages.status.unread": "읽지 않음",
+  "messages.subject": "제목",
+  "messages.table.attachmentsCount": "첨부 파일 {count}개",
+  "messages.table.from": "보낸 사람",
+  "messages.table.meta": "메타",
+  "messages.table.noAttachments": "첨부 파일 없음",
+  "messages.table.noObjects": "객체 없음",
+  "messages.table.objectsCount": "객체 {count}개",
+  "messages.table.sentAt": "전송됨",
+  "messages.table.status": "상태",
+  "messages.table.subject": "제목",
+  "messages.table.type": "유형",
+  "messages.title": "메시지",
+  "messages.to": "받는 사람",
+  "messages.token.authRequired.description": "이 메시지에는 보호된 객체가 포함되어 있습니다. 계속하려면 로그인하세요.",
+  "messages.token.authRequired.title": "로그인이 필요합니다",
+  "messages.token.errors.expired": "이 메시지 링크가 만료되었습니다.",
+  "messages.token.errors.generic": "이 메시지를 불러올 수 없습니다.",
+  "messages.token.errors.limitExceeded": "이 메시지 링크가 사용 한도에 도달했습니다.",
+  "messages.token.errors.notFound": "이 메시지 링크가 유효하지 않거나 이미 사용되었습니다.",
+  "messages.token.loading": "메시지를 불러오는 중...",
+  "messages.token.noObjects": "첨부된 객체가 없습니다.",
+  "messages.token.pageTitle": "메시지",
+  "messages.token.sentAt": "전송됨",
+  "messages.types.approvalRequest": "승인 요청",
+  "messages.types.confirmation": "확인",
+  "messages.types.default": "메시지",
+  "messages.types.defaultWithObjects": "객체 메시지",
+  "messages.types.system": "시스템 알림",
+  "messages.visibility": "공개 범위",
+  "messages.visibilityInternal": "내부",
+  "messages.visibilityInternalHint": "내부 메시지는 선택한 시스템 사용자에게 전송됩니다.",
+  "messages.visibilityPublic": "공개",
+  "messages.visibilityPublicHint": "공개 메시지는 외부 이메일로만 전송됩니다."
+}

package/src/modules/messages/i18n/pl.json

@@ -213,6 +213,8 @@
   "messages.replyBody": "Odpowiedź",
   "messages.saveDraft": "Zapisz szkic",
   "messages.savingDraft": "Zapisywanie szkicu...",
+  "messages.search.badge.message": "Wiadomość",
+  "messages.search.fallback.title": "Wiadomość",
   "messages.searchPlaceholder": "Szukaj wiadomości",
   "messages.send": "Wyślij",
   "messages.sendViaEmail": "Wyślij także e-mailem",

package/src/modules/messages/lib/participantScope.ts

@@ -0,0 +1,64 @@
+import type { SelectQueryBuilder } from 'kysely'
+
+/**
+ * Minimal Kysely schema contract the message participant-scope predicate depends
+ * on. Both the messages list route (`api/route.ts`, `all` folder) and the
+ * `communication_channels.message-channel` response enricher build their
+ * sender-OR-recipient access filter from {@link applyMessageParticipantScope},
+ * so a column rename (`sender_user_id`, `recipient_user_id`, `deleted_at`) or a
+ * change to the recipient-visibility rules updates both call sites at once
+ * instead of silently desyncing the enricher's security boundary from the list
+ * route (#4133, follow-up to #4099).
+ */
+export type MessagesParticipantScopeDatabase = {
+  messages: {
+    id: string
+    tenant_id: string
+    organization_id: string | null
+    sender_user_id: string
+    deleted_at: Date | null
+  }
+  message_recipients: {
+    message_id: string
+    recipient_user_id: string
+    deleted_at: Date | null
+  }
+}
+
+type MessagesTable = MessagesParticipantScopeDatabase['messages']
+type MessageRecipientsTable = MessagesParticipantScopeDatabase['message_recipients']
+
+type MessagesFrom = MessagesParticipantScopeDatabase & { m: MessagesTable }
+type MessagesJoinedFrom = MessagesFrom & { r: MessageRecipientsTable }
+
+/**
+ * Apply the shared message participant-scope predicate to a query already built
+ * from `messages as m`. A message is visible to `userId` when they are the
+ * sender OR a non-deleted recipient. The recipient soft-delete rule
+ * (`r.deleted_at is null`) lives inside the recipient join, so it is part of the
+ * single source of truth — the recipient-visibility boundary cannot drift
+ * between the list route and the enricher.
+ *
+ * Message-level tenant / organization / soft-delete scoping stays with the
+ * caller (both call sites already apply it uniformly to every query), but the
+ * shared {@link MessagesParticipantScopeDatabase} type keeps those column names
+ * coupled at compile time as well.
+ */
+export function applyMessageParticipantScope<O>(
+  query: SelectQueryBuilder<MessagesFrom, 'm', O>,
+  userId: string,
+): SelectQueryBuilder<MessagesJoinedFrom, 'm' | 'r', O> {
+  return query
+    .leftJoin('message_recipients as r', (join) =>
+      join
+        .onRef('m.id', '=', 'r.message_id')
+        .on('r.recipient_user_id', '=', userId)
+        .on('r.deleted_at', 'is', null),
+    )
+    .where((eb) =>
+      eb.or([
+        eb('m.sender_user_id', '=', userId),
+        eb('r.message_id', 'is not', null),
+      ]),
+    ) as unknown as SelectQueryBuilder<MessagesJoinedFrom, 'm' | 'r', O>
+}

package/src/modules/messages/lib/routeHelpers.ts

@@ -1,5 +1,4 @@
 import { resolveRequestContext } from '@open-mercato/shared/lib/api/context'
-import { hasFeature } from '@open-mercato/shared/security/features'
 
 export function hasOrganizationAccess(
   scopeOrganizationId: string | null,
@@ -33,10 +32,11 @@ export async function resolveMessageContext(req: Request): Promise<{
 }
 
 type RbacService = {
-  loadAcl: (
+  userHasAllFeatures: (
     userId: string,
+    required: string[],
     scope: { tenantId: string | null; organizationId: string | null }
-  ) => Promise<{ features?: string[]; isSuperAdmin?: boolean }>
+  ) => Promise<boolean>
 }
 
 export async function parseRequestBodySafe(req: Request): Promise<unknown> {
@@ -56,10 +56,8 @@ export async function canUseMessageEmailFeature(
   if (!scope.userId || !scope.tenantId) return false
 
   const rbac = ctx.container.resolve('rbacService') as RbacService
-  const acl = await rbac.loadAcl(scope.userId, {
+  return rbac.userHasAllFeatures(scope.userId, ['messages.email'], {
     tenantId: scope.tenantId,
     organizationId: scope.organizationId,
   })
-
-  return Boolean(acl.isSuperAdmin) || hasFeature(acl.features, 'messages.email')
 }

package/src/modules/messages/lib/searchLookup.ts

@@ -1,10 +1,9 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
-import { type Kysely, sql } from 'kysely'
-import { resolveSearchConfig } from '@open-mercato/shared/lib/search/config'
-import { tokenizeText } from '@open-mercato/shared/lib/search/tokenize'
+import type { Kysely } from 'kysely'
+import { findEntityIdsBySearchTokensCompat, type SearchTokenDatabase } from '@open-mercato/shared/lib/search/tokenLookup'
 
-function getDb(em: EntityManager): Kysely<any> {
-  return em.getKysely<any>()
+function getDb(em: EntityManager): Kysely<SearchTokenDatabase> {
+  return em.getKysely<SearchTokenDatabase>()
 }
 
 export async function findMessageIdsBySearchTokens({
@@ -20,33 +19,11 @@ export async function findMessageIdsBySearchTokens({
   organizationId: string | null
   fields?: string[]
 }): Promise<string[] | null> {
-  const trimmed = query.trim()
-  if (!trimmed) return null
-
-  const tokens = tokenizeText(trimmed, resolveSearchConfig())
-  if (!tokens.hashes.length) return []
-
-  const db = getDb(em) as any
-  let searchQuery = db
-    .selectFrom('search_tokens')
-    .select('entity_id')
-    .where('entity_type', '=', 'messages:message')
-    .where('field', 'in', fields)
-    .where('token_hash', 'in', tokens.hashes)
-    .where(sql<boolean>`tenant_id is not distinct from ${tenantId}`)
-
-  if (organizationId) {
-    searchQuery = searchQuery.where('organization_id', '=', organizationId)
-  } else {
-    searchQuery = searchQuery.where(sql<boolean>`organization_id is not distinct from ${null}`)
-  }
-
-  const rows = await searchQuery
-    .groupBy('entity_id')
-    .having(sql<boolean>`count(distinct token_hash) >= ${tokens.hashes.length}`)
-    .execute()
-
-  return rows
-    .map((row: { entity_id?: unknown }) => (typeof row.entity_id === 'string' ? row.entity_id : null))
-    .filter((id: string | null): id is string => typeof id === 'string' && id.length > 0)
+  return findEntityIdsBySearchTokensCompat({
+    db: getDb(em),
+    entityType: 'messages:message',
+    query,
+    fields,
+    scope: { tenantId, organizationId },
+  })
 }

package/src/modules/messages/search.ts

@@ -4,6 +4,8 @@ import type {
   SearchIndexSource,
   SearchResultPresenter,
 } from '@open-mercato/shared/modules/search'
+import type { TranslateFn } from '@open-mercato/shared/lib/i18n/context'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 
 function appendLine(lines: string[], label: string, value: unknown) {
   if (value === null || value === undefined) return
@@ -31,8 +33,8 @@ function snippet(value: unknown, max = 140): string | undefined {
   return `${trimmed.slice(0, max - 3)}...`
 }
 
-function buildMessagePresenter(record: Record<string, unknown>): SearchResultPresenter {
-  const title = pickString(record.subject) ?? 'Message'
+function buildMessagePresenter(translate: TranslateFn, record: Record<string, unknown>): SearchResultPresenter {
+  const title = pickString(record.subject) ?? translate('messages.search.fallback.title', 'Message')
   const body = snippet(record.body)
   const externalName = pickString(record.external_name, record.externalName)
   const subtitle = [externalName, body].filter(Boolean).join(' · ') || undefined
@@ -40,7 +42,7 @@ function buildMessagePresenter(record: Record<string, unknown>): SearchResultPre
     title: String(title),
     subtitle,
     icon: 'mail',
-    badge: 'Message',
+    badge: translate('messages.search.badge.message', 'Message'),
   }
 }
 
@@ -51,6 +53,7 @@ export const searchConfig: SearchModuleConfig = {
       enabled: true,
       priority: 5,
       buildSource: async (ctx: SearchBuildContext): Promise<SearchIndexSource | null> => {
+        const { t } = await resolveTranslations()
         const record = ctx.record
         const lines: string[] = []
         appendLine(lines, 'Subject', record.subject)
@@ -59,7 +62,7 @@ export const searchConfig: SearchModuleConfig = {
         if (!lines.length) return null
         return {
           text: lines,
-          presenter: buildMessagePresenter(record),
+          presenter: buildMessagePresenter(t, record),
           checksumSource: {
             record: {
               subject: record.subject,
@@ -70,7 +73,10 @@ export const searchConfig: SearchModuleConfig = {
           },
         }
       },
-      formatResult: async (ctx) => buildMessagePresenter(ctx.record),
+      formatResult: async (ctx) => {
+        const { t } = await resolveTranslations()
+        return buildMessagePresenter(t, ctx.record)
+      },
       resolveUrl: async (ctx) => {
         const id = pickString(ctx.record.id)
         return id ? `/backend/messages/${encodeURIComponent(id)}` : null

package/src/modules/notifications/api/route.ts

@@ -1,8 +1,20 @@
+import { createHash } from 'node:crypto'
 import { z } from 'zod'
 import type { EntityManager } from '@mikro-orm/core'
+import { runWithCacheTenant } from '@open-mercato/cache'
+import {
+  buildCollectionTags,
+  debugCrudCache,
+  isCrudCacheEnabled,
+  resolveCrudCache,
+} from '@open-mercato/shared/lib/crud/cache'
 import { Notification } from '../data/entities'
 import { listNotificationsSchema, createNotificationSchema } from '../data/validators'
 import { toNotificationDto } from '../lib/notificationMapper'
+import {
+  buildNotificationReadScopeWhere,
+  getNotificationReadScopeTagOrganizationIds,
+} from '../lib/notificationScope'
 import {
   NOTIFICATION_RESOURCE_KIND,
   notificationCrudErrorResponse,
@@ -21,6 +33,61 @@ export const metadata = {
   POST: { requireAuth: true, requireFeatures: ['notifications.create'] },
 }
 
+const NOTIFICATIONS_LIST_TTL_MS = 10_000
+// v2: the key gained the selected-organization scope (#4840). Bumping the version
+// retires v1 entries, which were shared across organizations for the same user.
+const NOTIFICATIONS_LIST_CACHE_VERSION = 2
+const NOTIFICATIONS_LIST_RESOURCE = 'notifications.notification'
+
+type NotificationsListPayload = {
+  items: ReturnType<typeof toNotificationDto>[]
+  total: number
+  page: number
+  pageSize: number
+  totalPages: number
+}
+
+export function buildNotificationsListCacheKey(
+  userId: string,
+  organizationScope: { organizationId: string | null; organizationIds: string[] },
+  input: z.infer<typeof listNotificationsSchema>,
+): string {
+  const normalizedIds = Array.from(new Set(
+    organizationScope.organizationIds.filter((value) => value.trim().length > 0),
+  )).sort((left, right) => left.localeCompare(right))
+  const scopeKey = normalizedIds.length === 0
+    ? 'no-access'
+    : `${organizationScope.organizationId ?? 'none'}:scope=${createHash('sha256')
+        .update(normalizedIds.join('\0'))
+        .digest('hex')
+        .slice(0, 16)}`
+  const filterSignature = JSON.stringify({
+    status: Array.isArray(input.status)
+      ? [...input.status].sort((left, right) => left.localeCompare(right))
+      : input.status ?? null,
+    type: input.type ?? null,
+    severity: input.severity ?? null,
+    sourceEntityType: input.sourceEntityType ?? null,
+    sourceEntityId: input.sourceEntityId ?? null,
+    since: input.since ?? null,
+    page: input.page,
+    pageSize: input.pageSize,
+  })
+  return `notifications:list:v${NOTIFICATIONS_LIST_CACHE_VERSION}:u=${userId}:org=${scopeKey}:filters=${filterSignature}`
+}
+
+function isNotificationsListPayload(value: unknown): value is NotificationsListPayload {
+  if (!value || typeof value !== 'object') return false
+  const payload = value as Partial<NotificationsListPayload>
+  return (
+    Array.isArray(payload.items)
+    && typeof payload.total === 'number'
+    && typeof payload.page === 'number'
+    && typeof payload.pageSize === 'number'
+    && typeof payload.totalPages === 'number'
+  )
+}
+
 export async function GET(req: Request) {
   const { ctx, scope } = await resolveNotificationContext(req)
   const em = ctx.container.resolve('em') as EntityManager
@@ -28,10 +95,42 @@ export async function GET(req: Request) {
   const url = new URL(req.url)
   const queryParams = Object.fromEntries(url.searchParams.entries())
   const input = listNotificationsSchema.parse(queryParams)
+  const userId = scope.userId
+  // Mirrors api/unread-count/route.ts: unrestricted and omitted legacy organization
+  // scopes cannot be safely tagged for invalidation, because organization-specific
+  // writes only invalidate their own collection tag. Leave those scopes uncached
+  // rather than serving a stale tenant-wide list until the TTL expires.
+  const cacheableOrganizationIds = Array.isArray(scope.organizationIds)
+    ? scope.organizationIds
+    : null
+  const cache = userId && cacheableOrganizationIds && isCrudCacheEnabled()
+    ? resolveCrudCache(ctx.container)
+    : null
+  const cacheKey = cache && userId && cacheableOrganizationIds
+    ? buildNotificationsListCacheKey(
+        userId,
+        { organizationId: scope.organizationId, organizationIds: cacheableOrganizationIds },
+        input,
+      )
+    : null
+
+  if (cache && cacheKey) {
+    try {
+      const cached = await runWithCacheTenant(scope.tenantId, () => cache.get(cacheKey))
+      if (isNotificationsListPayload(cached)) {
+        return Response.json(cached)
+      }
+    } catch (error) {
+      debugCrudCache('notifications-list-cache-read-failed', {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
 
   const filters: Record<string, unknown> = {
-    recipientUserId: scope.userId,
+    recipientUserId: userId,
     tenantId: scope.tenantId,
+    ...buildNotificationReadScopeWhere(scope),
   }
 
   if (input.status) {
@@ -66,13 +165,34 @@ export async function GET(req: Request) {
 
   const items = notifications.map(toNotificationDto)
 
-  return Response.json({
+  const payload: NotificationsListPayload = {
     items,
     total,
     page: input.page,
     pageSize: input.pageSize,
     totalPages: Math.ceil(total / input.pageSize),
-  })
+  }
+
+  if (cache && cacheKey) {
+    try {
+      await runWithCacheTenant(scope.tenantId, () =>
+        cache.set(cacheKey, payload, {
+          ttl: NOTIFICATIONS_LIST_TTL_MS,
+          tags: buildCollectionTags(
+            NOTIFICATIONS_LIST_RESOURCE,
+            scope.tenantId,
+            getNotificationReadScopeTagOrganizationIds(scope),
+          ),
+        }),
+      )
+    } catch (error) {
+      debugCrudCache('notifications-list-cache-write-failed', {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  return Response.json(payload)
 }
 
 export async function POST(req: Request) {