@open-mercato/core 0.4.5-develop-5191db4ef3 → 0.4.5-develop-033a719bf2

package/src/modules/messages/commands/attachments.ts

@@ -0,0 +1,227 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { z } from 'zod'
+import { registerCommand, type CommandHandler } from '@open-mercato/shared/lib/commands'
+import { extractUndoPayload } from '@open-mercato/shared/lib/commands/undo'
+import { Message } from '../data/entities'
+import { attachmentIdsPayloadSchema, unlinkAttachmentPayloadSchema } from '../data/validators'
+import { linkAttachmentsToMessage } from '../lib/attachments'
+import { MESSAGE_ATTACHMENT_ENTITY_ID } from '../lib/constants'
+import { assertOrganizationAccess, getAttachmentIdsForMessage, type MessageScopeInput } from './shared'
+
+const attachmentMutationScopeSchema = z.object({
+  messageId: z.string().uuid(),
+  tenantId: z.string().uuid(),
+  organizationId: z.string().uuid().nullable(),
+  userId: z.string().uuid(),
+})
+
+const linkDraftAttachmentsSchema = attachmentMutationScopeSchema.extend({
+  attachmentIds: attachmentIdsPayloadSchema.shape.attachmentIds,
+})
+
+const unlinkDraftAttachmentsSchema = attachmentMutationScopeSchema.extend({
+  attachmentIds: z.array(z.string().uuid()).min(1).max(100),
+})
+
+type AttachmentState = { attachmentIds: string[] }
+
+type LinkDraftAttachmentsInput = z.infer<typeof linkDraftAttachmentsSchema>
+type UnlinkDraftAttachmentsInput = z.infer<typeof unlinkDraftAttachmentsSchema>
+
+async function requireEditableDraftMessage(em: EntityManager, scope: MessageScopeInput, messageId: string) {
+  const message = await em.findOne(Message, {
+    id: messageId,
+    tenantId: scope.tenantId,
+    deletedAt: null,
+  })
+  if (!message) throw new Error('Message not found')
+  assertOrganizationAccess(scope, message)
+  if (message.senderUserId !== scope.userId) throw new Error('Access denied')
+  if (!message.isDraft) throw new Error('Attachments can only be modified on drafts')
+  return message
+}
+
+const linkDraftAttachmentsCommand: CommandHandler<unknown, { ok: true }> = {
+  id: 'messages.attachments.link_to_draft',
+  async prepare(rawInput, ctx) {
+    const input = linkDraftAttachmentsSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const message = await requireEditableDraftMessage(em, input, input.messageId)
+    return {
+      before: {
+        attachmentIds: await getAttachmentIdsForMessage(em, message.id, {
+          tenantId: input.tenantId,
+          organizationId: input.organizationId,
+        }),
+      } satisfies AttachmentState,
+    }
+  },
+  async execute(rawInput, ctx) {
+    const input = linkDraftAttachmentsSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    await requireEditableDraftMessage(em, input, input.messageId)
+    await linkAttachmentsToMessage(
+      em,
+      input.messageId,
+      input.attachmentIds,
+      input.organizationId,
+      input.tenantId,
+    )
+    return { ok: true }
+  },
+  async captureAfter(rawInput, _result, ctx) {
+    const input = linkDraftAttachmentsSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    return {
+      attachmentIds: await getAttachmentIdsForMessage(em, input.messageId, {
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+      }),
+    } satisfies AttachmentState
+  },
+  buildLog: async ({ input, snapshots }) => {
+    const parsed = linkDraftAttachmentsSchema.parse(input)
+    return {
+      actionLabel: 'Link message draft attachments',
+      resourceKind: 'messages.message',
+      resourceId: parsed.messageId,
+      tenantId: parsed.tenantId,
+      organizationId: parsed.organizationId,
+      payload: {
+        undo: {
+          before: (snapshots.before as AttachmentState | undefined) ?? null,
+          after: (snapshots.after as AttachmentState | undefined) ?? null,
+        },
+      },
+      snapshotBefore: snapshots.before ?? null,
+      snapshotAfter: snapshots.after ?? null,
+    }
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const undo = extractUndoPayload<{ before?: AttachmentState | null }>(logEntry)
+    const before = undo?.before
+    if (!before) return
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const messageId = logEntry?.resourceId as string | null
+    const tenantId = logEntry?.tenantId as string | null
+    const organizationId = (logEntry?.organizationId as string | null) ?? null
+    if (!messageId || !tenantId) return
+    const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+    await em.nativeDelete(Attachment, {
+      entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+      recordId: messageId,
+      tenantId,
+      organizationId,
+      id: { $nin: before.attachmentIds.length ? before.attachmentIds : ['00000000-0000-0000-0000-000000000000'] },
+    })
+    if (before.attachmentIds.length > 0) {
+      const attachments = await em.find(Attachment, {
+        id: { $in: before.attachmentIds },
+        tenantId,
+        organizationId,
+      })
+      for (const attachment of attachments) {
+        attachment.entityId = MESSAGE_ATTACHMENT_ENTITY_ID
+        attachment.recordId = messageId
+      }
+    }
+    await em.flush()
+  },
+}
+
+const unlinkDraftAttachmentsCommand: CommandHandler<unknown, { ok: true }> = {
+  id: 'messages.attachments.unlink_from_draft',
+  async prepare(rawInput, ctx) {
+    const input = unlinkDraftAttachmentsSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const message = await requireEditableDraftMessage(em, input, input.messageId)
+    return {
+      before: {
+        attachmentIds: await getAttachmentIdsForMessage(em, message.id, {
+          tenantId: input.tenantId,
+          organizationId: input.organizationId,
+        }),
+      } satisfies AttachmentState,
+    }
+  },
+  async execute(rawInput, ctx) {
+    const input = unlinkDraftAttachmentsSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    await requireEditableDraftMessage(em, input, input.messageId)
+    const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+    await em.nativeDelete(Attachment, {
+      id: { $in: input.attachmentIds },
+      entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+      recordId: input.messageId,
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+    })
+    return { ok: true }
+  },
+  async captureAfter(rawInput, _result, ctx) {
+    const input = unlinkDraftAttachmentsSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    return {
+      attachmentIds: await getAttachmentIdsForMessage(em, input.messageId, {
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+      }),
+    } satisfies AttachmentState
+  },
+  buildLog: async ({ input, snapshots }) => {
+    const parsed = unlinkDraftAttachmentsSchema.parse(input)
+    return {
+      actionLabel: 'Unlink message draft attachments',
+      resourceKind: 'messages.message',
+      resourceId: parsed.messageId,
+      tenantId: parsed.tenantId,
+      organizationId: parsed.organizationId,
+      payload: {
+        undo: {
+          before: (snapshots.before as AttachmentState | undefined) ?? null,
+          after: (snapshots.after as AttachmentState | undefined) ?? null,
+        },
+      },
+      snapshotBefore: snapshots.before ?? null,
+      snapshotAfter: snapshots.after ?? null,
+    }
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const undo = extractUndoPayload<{ before?: AttachmentState | null }>(logEntry)
+    const before = undo?.before
+    if (!before) return
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const messageId = logEntry?.resourceId as string | null
+    const tenantId = logEntry?.tenantId as string | null
+    const organizationId = (logEntry?.organizationId as string | null) ?? null
+    if (!messageId || !tenantId) return
+    const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+    await em.nativeDelete(Attachment, {
+      entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+      recordId: messageId,
+      tenantId,
+      organizationId,
+      id: { $nin: before.attachmentIds.length ? before.attachmentIds : ['00000000-0000-0000-0000-000000000000'] },
+    })
+    if (before.attachmentIds.length > 0) {
+      const attachments = await em.find(Attachment, {
+        id: { $in: before.attachmentIds },
+        tenantId,
+        organizationId,
+      })
+      for (const attachment of attachments) {
+        attachment.entityId = MESSAGE_ATTACHMENT_ENTITY_ID
+        attachment.recordId = messageId
+      }
+    }
+    await em.flush()
+  },
+}
+
+export function parseUnlinkAttachmentIds(rawInput: unknown): string[] {
+  const input = unlinkAttachmentPayloadSchema.parse(rawInput)
+  return input.attachmentIds ?? (input.attachmentId ? [input.attachmentId] : [])
+}
+
+registerCommand(linkDraftAttachmentsCommand)
+registerCommand(unlinkDraftAttachmentsCommand)

package/src/modules/messages/commands/confirmations.ts

@@ -0,0 +1,183 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { registerCommand } from '@open-mercato/shared/lib/commands'
+import type { CommandHandler } from '@open-mercato/shared/lib/commands'
+import { extractUndoPayload, type UndoPayload } from '@open-mercato/shared/lib/commands/undo'
+import { Message, MessageConfirmation, MessageRecipient } from '../data/entities'
+import { confirmMessageSchema } from '../data/validators'
+
+type ConfirmMessageResult = {
+  messageId: string
+  confirmed: boolean
+  confirmedAt: string | null
+  confirmedByUserId: string | null
+}
+
+type ConfirmationSnapshot = {
+  id: string | null
+  messageId: string
+  confirmed: boolean
+  confirmedAt: string | null
+  confirmedByUserId: string | null
+  tenantId: string
+  organizationId: string | null
+}
+
+function toIso(value: Date | null | undefined): string | null {
+  return value ? value.toISOString() : null
+}
+
+function toDate(value: string | null | undefined): Date | null {
+  if (!value) return null
+  return new Date(value)
+}
+
+const confirmMessageCommand: CommandHandler<unknown, ConfirmMessageResult> = {
+  id: 'messages.confirmations.confirm',
+  async prepare(rawInput, ctx) {
+    const input = confirmMessageSchema.parse(rawInput)
+    const tenantId = input.tenantId ?? ctx.auth?.tenantId ?? null
+    if (!tenantId) throw new Error('Tenant scope is required')
+    const organizationId = input.organizationId ?? ctx.selectedOrganizationId ?? null
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const existing = await em.findOne(MessageConfirmation, { messageId: input.messageId })
+    return {
+      before: {
+        id: existing?.id ?? null,
+        messageId: input.messageId,
+        confirmed: existing?.confirmed ?? false,
+        confirmedAt: toIso(existing?.confirmedAt),
+        confirmedByUserId: existing?.confirmedByUserId ?? null,
+        tenantId,
+        organizationId,
+      } satisfies ConfirmationSnapshot,
+    }
+  },
+  async execute(rawInput, ctx) {
+    const input = confirmMessageSchema.parse(rawInput)
+    const tenantId = input.tenantId ?? ctx.auth?.tenantId ?? null
+
+    if (!tenantId) {
+      throw new Error('Tenant scope is required')
+    }
+
+    const organizationId = input.organizationId ?? ctx.selectedOrganizationId ?? null
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+
+    const message = await em.findOne(Message, {
+      id: input.messageId,
+      tenantId,
+      organizationId,
+      deletedAt: null,
+    })
+
+    if (!message) {
+      throw new Error('Message not found')
+    }
+
+    const actorUserId = ctx.auth?.sub ?? null
+    if (!actorUserId) {
+      throw new Error('Authentication required')
+    }
+
+    const recipient = await em.findOne(MessageRecipient, {
+      messageId: message.id,
+      recipientUserId: actorUserId,
+      deletedAt: null,
+    })
+    const isSender = message.senderUserId === actorUserId
+    if (!isSender && !recipient) {
+      throw new Error('Access denied')
+    }
+
+    let confirmation = await em.findOne(MessageConfirmation, { messageId: message.id })
+    if (!confirmation) {
+      confirmation = em.create(MessageConfirmation, {
+        messageId: message.id,
+        tenantId,
+        organizationId,
+      })
+    }
+
+    confirmation.confirmed = input.confirmed
+    confirmation.confirmedByUserId = actorUserId
+    confirmation.confirmedAt = input.confirmed ? new Date() : null
+
+    await em.persistAndFlush(confirmation)
+
+    return {
+      messageId: confirmation.messageId,
+      confirmed: confirmation.confirmed,
+      confirmedAt: confirmation.confirmedAt ? confirmation.confirmedAt.toISOString() : null,
+      confirmedByUserId: confirmation.confirmedByUserId ?? null,
+    }
+  },
+  async captureAfter(rawInput, _result, ctx) {
+    const input = confirmMessageSchema.parse(rawInput)
+    const tenantId = input.tenantId ?? ctx.auth?.tenantId ?? null
+    if (!tenantId) return null
+    const organizationId = input.organizationId ?? ctx.selectedOrganizationId ?? null
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const confirmation = await em.findOne(MessageConfirmation, { messageId: input.messageId })
+    return {
+      id: confirmation?.id ?? null,
+      messageId: input.messageId,
+      confirmed: confirmation?.confirmed ?? false,
+      confirmedAt: toIso(confirmation?.confirmedAt),
+      confirmedByUserId: confirmation?.confirmedByUserId ?? null,
+      tenantId,
+      organizationId,
+    } satisfies ConfirmationSnapshot
+  },
+  async buildLog({ input, snapshots }) {
+    const parsed = confirmMessageSchema.parse(input)
+    return {
+      actionLabel: parsed.confirmed ? 'Confirm message' : 'Unconfirm message',
+      resourceKind: 'messages.message',
+      resourceId: parsed.messageId,
+      tenantId: parsed.tenantId ?? null,
+      organizationId: parsed.organizationId ?? null,
+      payload: {
+        undo: {
+          before: (snapshots.before as ConfirmationSnapshot | undefined) ?? null,
+          after: (snapshots.after as ConfirmationSnapshot | undefined) ?? null,
+        } satisfies UndoPayload<ConfirmationSnapshot>,
+      },
+      snapshotBefore: snapshots.before ?? null,
+      snapshotAfter: snapshots.after ?? null,
+    }
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const undo = extractUndoPayload<UndoPayload<ConfirmationSnapshot>>(logEntry)
+    const before = undo?.before
+    if (!before) return
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const existing = await em.findOne(MessageConfirmation, { messageId: before.messageId })
+    if (!before.id) {
+      if (existing) {
+        em.remove(existing)
+        await em.flush()
+      }
+      return
+    }
+    if (!existing) {
+      em.persist(em.create(MessageConfirmation, {
+        id: before.id,
+        messageId: before.messageId,
+        confirmed: before.confirmed,
+        confirmedAt: toDate(before.confirmedAt),
+        confirmedByUserId: before.confirmedByUserId,
+        tenantId: before.tenantId,
+        organizationId: before.organizationId,
+      }))
+    } else {
+      existing.confirmed = before.confirmed
+      existing.confirmedAt = toDate(before.confirmedAt)
+      existing.confirmedByUserId = before.confirmedByUserId
+      existing.tenantId = before.tenantId
+      existing.organizationId = before.organizationId
+    }
+    await em.flush()
+  },
+}
+
+registerCommand(confirmMessageCommand)

package/src/modules/messages/commands/conversation.ts

@@ -0,0 +1,292 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { z } from 'zod'
+import { registerCommand, type CommandHandler } from '@open-mercato/shared/lib/commands'
+import { Message, MessageRecipient } from '../data/entities'
+import { emitMessagesEvent } from '../events'
+import { assertOrganizationAccess, type MessageScopeInput } from './shared'
+
+const conversationCommandSchema = z.object({
+  anchorMessageId: z.string().uuid(),
+  tenantId: z.string().uuid(),
+  organizationId: z.string().uuid().nullable(),
+  userId: z.string().uuid(),
+})
+
+type ConversationCommandInput = z.infer<typeof conversationCommandSchema>
+
+type ConversationScope = {
+  anchorMessageId: string
+  messageIds: string[]
+  recipientMessageIds: Set<string>
+  senderMessageIds: Set<string>
+}
+
+async function resolveConversationScope(
+  em: EntityManager,
+  input: ConversationCommandInput,
+): Promise<ConversationScope> {
+  const anchorMessage = await em.findOne(Message, {
+    id: input.anchorMessageId,
+    tenantId: input.tenantId,
+    deletedAt: null,
+  })
+
+  if (!anchorMessage) throw new Error('Message not found')
+  assertOrganizationAccess(input as MessageScopeInput, anchorMessage)
+
+  const anchorRecipient = await em.findOne(MessageRecipient, {
+    messageId: input.anchorMessageId,
+    recipientUserId: input.userId,
+    deletedAt: null,
+  })
+
+  const canAccessAnchor = anchorMessage.senderUserId === input.userId || Boolean(anchorRecipient)
+  if (!canAccessAnchor) throw new Error('Access denied')
+
+  const threadId = anchorMessage.threadId ?? anchorMessage.id
+  const conversationMessages = await em.find(
+    Message,
+    {
+      threadId,
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+      deletedAt: null,
+      isDraft: false,
+    },
+    {
+      orderBy: {
+        sentAt: 'ASC',
+        createdAt: 'ASC',
+        id: 'ASC',
+      },
+    },
+  )
+
+  const messagesById = new Map<string, Message>(conversationMessages.map((message) => [message.id, message]))
+  messagesById.set(anchorMessage.id, anchorMessage)
+
+  if (anchorMessage.threadId && !messagesById.has(anchorMessage.threadId)) {
+    const threadRoot = await em.findOne(Message, {
+      id: anchorMessage.threadId,
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+      deletedAt: null,
+      isDraft: false,
+    })
+    if (threadRoot) {
+      messagesById.set(threadRoot.id, threadRoot)
+    }
+  }
+
+  let parentMessageId = anchorMessage.parentMessageId ?? null
+  while (parentMessageId) {
+    if (messagesById.has(parentMessageId)) break
+    const parentMessage = await em.findOne(Message, {
+      id: parentMessageId,
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+      deletedAt: null,
+      isDraft: false,
+    })
+    if (!parentMessage) break
+    messagesById.set(parentMessage.id, parentMessage)
+    parentMessageId = parentMessage.parentMessageId ?? null
+  }
+
+  let frontier = Array.from(messagesById.keys())
+  while (frontier.length > 0) {
+    const children = await em.find(Message, {
+      parentMessageId: { $in: frontier },
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+      deletedAt: null,
+      isDraft: false,
+    })
+
+    const nextFrontier: string[] = []
+    for (const child of children) {
+      if (messagesById.has(child.id)) continue
+      messagesById.set(child.id, child)
+      nextFrontier.push(child.id)
+    }
+    frontier = nextFrontier
+  }
+
+  const scopedMessages = Array.from(messagesById.values())
+  const messageIds = scopedMessages.map((message) => message.id)
+  const recipientRows = messageIds.length > 0
+    ? await em.find(MessageRecipient, {
+      messageId: { $in: messageIds },
+      recipientUserId: input.userId,
+      deletedAt: null,
+    })
+    : []
+
+  const recipientMessageIds = new Set(recipientRows.map((item) => item.messageId))
+  const senderMessageIds = new Set(
+    scopedMessages
+      .filter((item) => item.senderUserId === input.userId)
+      .map((item) => item.id),
+  )
+
+  const visibleMessageIds = scopedMessages
+    .map((item) => item.id)
+    .filter((messageId) => recipientMessageIds.has(messageId) || senderMessageIds.has(messageId))
+
+  if (visibleMessageIds.length === 0) throw new Error('Access denied')
+
+  return {
+    anchorMessageId: anchorMessage.id,
+    messageIds: visibleMessageIds,
+    recipientMessageIds,
+    senderMessageIds,
+  }
+}
+
+const archiveConversationForActorCommand: CommandHandler<unknown, { ok: true; affectedCount: number }> = {
+  id: 'messages.conversation.archive_for_actor',
+  async execute(rawInput, ctx) {
+    const input = conversationCommandSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const scope = await resolveConversationScope(em, input)
+    const messageIdsToArchive = scope.messageIds.filter((messageId) => scope.recipientMessageIds.has(messageId))
+
+    if (messageIdsToArchive.length === 0) {
+      return { ok: true, affectedCount: 0 }
+    }
+
+    const archivedAt = new Date()
+    const archivedIds: string[] = []
+    await em.transactional(async (trx) => {
+      const recipients = await trx.find(MessageRecipient, {
+        messageId: { $in: messageIdsToArchive },
+        recipientUserId: input.userId,
+        deletedAt: null,
+      })
+      for (const recipient of recipients) {
+        if (recipient.status !== 'archived' || recipient.archivedAt === null) {
+          recipient.archivedAt = archivedAt
+          recipient.status = 'archived'
+          archivedIds.push(recipient.messageId)
+        }
+      }
+    })
+
+    for (const messageId of archivedIds) {
+      await emitMessagesEvent('messages.message.archived', {
+        messageId,
+        recipientUserId: input.userId,
+        userId: input.userId,
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+      }, { persistent: true })
+    }
+
+    return { ok: true, affectedCount: archivedIds.length }
+  },
+}
+
+const markConversationUnreadForActorCommand: CommandHandler<unknown, { ok: true; affectedCount: number }> = {
+  id: 'messages.conversation.mark_unread_for_actor',
+  async execute(rawInput, ctx) {
+    const input = conversationCommandSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const scope = await resolveConversationScope(em, input)
+    const messageIdsToMarkUnread = scope.messageIds.filter((messageId) => scope.recipientMessageIds.has(messageId))
+
+    if (messageIdsToMarkUnread.length === 0) {
+      return { ok: true, affectedCount: 0 }
+    }
+
+    const markedIds: string[] = []
+    await em.transactional(async (trx) => {
+      const recipients = await trx.find(MessageRecipient, {
+        messageId: { $in: messageIdsToMarkUnread },
+        recipientUserId: input.userId,
+        deletedAt: null,
+      })
+      for (const recipient of recipients) {
+        if (recipient.status !== 'unread' || recipient.readAt !== null) {
+          recipient.status = 'unread'
+          recipient.readAt = null
+          markedIds.push(recipient.messageId)
+        }
+      }
+    })
+
+    for (const messageId of markedIds) {
+      await emitMessagesEvent('messages.message.marked_unread', {
+        messageId,
+        recipientUserId: input.userId,
+        userId: input.userId,
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+      }, { persistent: true })
+    }
+
+    return { ok: true, affectedCount: markedIds.length }
+  },
+}
+
+type DeletedTarget = { messageId: string; target: 'sender' | 'recipient' }
+
+const deleteConversationForActorCommand: CommandHandler<unknown, { ok: true; affectedCount: number }> = {
+  id: 'messages.conversation.delete_for_actor',
+  async execute(rawInput, ctx) {
+    const input = conversationCommandSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const scope = await resolveConversationScope(em, input)
+    const messageIdsToDelete = scope.messageIds.filter(
+      (messageId) => scope.recipientMessageIds.has(messageId) || scope.senderMessageIds.has(messageId),
+    )
+
+    if (messageIdsToDelete.length === 0) {
+      return { ok: true, affectedCount: 0 }
+    }
+
+    const deletedNow = new Date()
+    const deletedTargets: DeletedTarget[] = []
+    await em.transactional(async (trx) => {
+      for (const messageId of messageIdsToDelete) {
+        const recipient = await trx.findOne(MessageRecipient, {
+          messageId,
+          recipientUserId: input.userId,
+          deletedAt: null,
+        })
+        if (recipient) {
+          recipient.status = 'deleted'
+          recipient.deletedAt = deletedNow
+          deletedTargets.push({ messageId, target: 'recipient' })
+          continue
+        }
+        if (scope.senderMessageIds.has(messageId)) {
+          const message = await trx.findOne(Message, {
+            id: messageId,
+            tenantId: input.tenantId,
+            deletedAt: null,
+          })
+          if (message && message.senderUserId === input.userId) {
+            message.deletedAt = deletedNow
+            deletedTargets.push({ messageId, target: 'sender' })
+          }
+        }
+      }
+    })
+
+    for (const { messageId, target } of deletedTargets) {
+      await emitMessagesEvent('messages.message.deleted', {
+        messageId,
+        actorUserId: input.userId,
+        target,
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+      }, { persistent: true })
+    }
+
+    return { ok: true, affectedCount: deletedTargets.length }
+  },
+}
+
+registerCommand(archiveConversationForActorCommand)
+registerCommand(markConversationUnreadForActorCommand)
+registerCommand(deleteConversationForActorCommand)