@open-mercato/core 0.4.5-develop-754ef4d2f0 → 0.4.5-develop-9f9549ebc8

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

@@ -0,0 +1,204 @@
+import type { Message, MessageAction, MessageActionData, MessageObject } from '../data/entities'
+import { getMessageObjectType } from './message-objects-registry'
+import { getMessageType } from './message-types-registry'
+
+type MessageActionSource = 'message' | 'type_default' | 'object'
+
+export type MessageActionObjectRef = {
+  objectId: string
+  entityModule: string
+  entityType: string
+  entityId: string
+}
+
+export type ResolvedMessageAction = MessageAction & {
+  source: MessageActionSource
+  objectRef?: MessageActionObjectRef
+}
+
+export type MessageActionResolutionContext = {
+  tenantId: string
+  organizationId?: string | null
+  userId: string
+}
+
+function normalizeActionLabel(
+  action: Pick<MessageAction, 'label' | 'id'>,
+  fallback?: string | null,
+): string {
+  if (typeof action.label === 'string' && action.label.trim().length > 0) {
+    return action.label
+  }
+  if (typeof fallback === 'string' && fallback.trim().length > 0) {
+    return fallback.trim()
+  }
+  return action.id
+}
+
+export function isTerminalMessageAction(
+  action: Pick<MessageAction, 'isTerminal' | 'commandId' | 'href'>,
+): boolean {
+  if (typeof action.isTerminal === 'boolean') return action.isTerminal
+  if (typeof action.commandId === 'string' && action.commandId.trim().length > 0) return true
+  if (typeof action.href === 'string' && action.href.trim().length > 0) return false
+  return true
+}
+
+export function buildMessageObjectActionId(objectId: string, actionId: string): string {
+  return `object:${objectId}:${actionId}`
+}
+
+function readActionDataExpiry(message: Message): string | undefined {
+  if (message.actionData?.expiresAt) return message.actionData.expiresAt
+  const messageType = getMessageType(message.type)
+  if (!messageType?.actionsExpireAfterHours || !message.sentAt) return undefined
+  return new Date(
+    message.sentAt.getTime() + messageType.actionsExpireAfterHours * 60 * 60 * 1000,
+  ).toISOString()
+}
+
+export function buildResolvedMessageActions(
+  message: Message,
+  objects: MessageObject[],
+): MessageActionData | null {
+  const resolved: ResolvedMessageAction[] = []
+  const usedIds = new Set<string>()
+
+  const pushAction = (
+    action: MessageAction,
+    source: MessageActionSource,
+    objectRef?: MessageActionObjectRef,
+    labelFallback?: string | null,
+  ) => {
+    const id = typeof action.id === 'string' ? action.id.trim() : ''
+    if (!id || usedIds.has(id)) return
+    usedIds.add(id)
+
+    resolved.push({
+      ...action,
+      id,
+      label: normalizeActionLabel(action, labelFallback),
+      source,
+      objectRef,
+    })
+  }
+
+  for (const action of message.actionData?.actions ?? []) {
+    pushAction(action, 'message')
+  }
+
+  const messageType = getMessageType(message.type)
+  for (const action of messageType?.defaultActions ?? []) {
+    pushAction(action, 'type_default')
+  }
+
+  for (const object of objects) {
+    if (!object.actionRequired || !object.actionType) continue
+    const objectType = getMessageObjectType(object.entityModule, object.entityType)
+    if (!objectType) continue
+    const actionDef = objectType.actions.find((entry) => entry.id === object.actionType)
+    if (!actionDef) continue
+
+    pushAction(
+      {
+        id: buildMessageObjectActionId(object.id, actionDef.id),
+        label: object.actionLabel ?? actionDef.id,
+        labelKey: actionDef.labelKey,
+        variant: actionDef.variant,
+        icon: actionDef.icon,
+        commandId: actionDef.commandId,
+        href: actionDef.href,
+        isTerminal: actionDef.isTerminal,
+        confirmRequired: actionDef.confirmRequired,
+        confirmMessage: actionDef.confirmMessage,
+      },
+      'object',
+      {
+        objectId: object.id,
+        entityModule: object.entityModule,
+        entityType: object.entityType,
+        entityId: object.entityId,
+      },
+      object.actionLabel ?? actionDef.id,
+    )
+  }
+
+  const expiresAt = readActionDataExpiry(message)
+  if (resolved.length === 0 && !expiresAt) {
+    return null
+  }
+
+  const configuredPrimaryActionId = message.actionData?.primaryActionId
+  const primaryActionId = configuredPrimaryActionId && resolved.some((entry) => entry.id === configuredPrimaryActionId)
+    ? configuredPrimaryActionId
+    : resolved[0]?.id
+
+  return {
+    actions: resolved,
+    primaryActionId,
+    expiresAt,
+  }
+}
+
+export function findResolvedMessageActionById(
+  message: Message,
+  objects: MessageObject[],
+  actionId: string,
+): ResolvedMessageAction | null {
+  const actionData = buildResolvedMessageActions(message, objects)
+  const match = actionData?.actions.find((entry) => entry.id === actionId)
+  return (match as ResolvedMessageAction | undefined) ?? null
+}
+
+function buildTemplateContext(
+  message: Message,
+  resolutionContext: MessageActionResolutionContext,
+  objectRef?: MessageActionObjectRef,
+): Record<string, unknown> {
+  return {
+    messageId: message.id,
+    sourceEntityId: message.sourceEntityId ?? message.id,
+    sourceEntityType: message.sourceEntityType ?? null,
+    threadId: message.threadId ?? null,
+    parentMessageId: message.parentMessageId ?? null,
+    messageType: message.type,
+    tenantId: resolutionContext.tenantId,
+    organizationId: resolutionContext.organizationId ?? null,
+    userId: resolutionContext.userId,
+    objectId: objectRef?.objectId ?? null,
+    entityId: objectRef?.entityId ?? null,
+    entityType: objectRef?.entityType ?? null,
+    entityModule: objectRef?.entityModule ?? null,
+  }
+}
+
+function resolveTemplateString(template: string, context: Record<string, unknown>): string {
+  return template.replace(/\{([a-zA-Z0-9_]+)\}/g, (fullMatch, key: string) => {
+    const value = context[key]
+    if (value == null) return fullMatch
+    return String(value)
+  })
+}
+
+export function resolveActionHref(
+  action: ResolvedMessageAction,
+  message: Message,
+  resolutionContext: MessageActionResolutionContext,
+): string | null {
+  if (!action.href) return null
+  const context = buildTemplateContext(message, resolutionContext, action.objectRef)
+  return resolveTemplateString(action.href, context)
+}
+
+export function resolveActionCommandInput(
+  action: ResolvedMessageAction,
+  message: Message,
+  _resolutionContext: MessageActionResolutionContext,
+  requestInput: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    ...requestInput,
+    messageId: message.id,
+    actionId: action.id,
+  }
+}

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

@@ -0,0 +1,197 @@
+import type { EntityManager } from '@mikro-orm/core'
+import { MESSAGE_ATTACHMENT_ENTITY_ID } from './constants'
+const LIBRARY_ATTACHMENT_ENTITY_ID = 'attachments:library'
+
+function buildOrganizationScopeFilter(organizationId: string | null) {
+  if (!organizationId) {
+    return { organizationId: null }
+  }
+  return {
+    $or: [
+      { organizationId },
+      { organizationId: null },
+    ],
+  }
+}
+
+export async function linkAttachmentsToMessage(
+  em: EntityManager,
+  messageId: string,
+  attachmentIds: string[],
+  organizationId: string | null,
+  tenantId: string,
+): Promise<void> {
+  if (attachmentIds.length === 0) return
+
+  const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+
+  const attachments = await em.find(Attachment, {
+    id: { $in: attachmentIds },
+    tenantId,
+    ...buildOrganizationScopeFilter(organizationId),
+  })
+
+  for (const attachment of attachments) {
+    attachment.entityId = MESSAGE_ATTACHMENT_ENTITY_ID
+    attachment.recordId = messageId
+  }
+
+  await em.flush()
+}
+
+export async function getMessageAttachments(
+  em: EntityManager,
+  messageId: string,
+  organizationId: string | null,
+  tenantId: string,
+): Promise<Array<{
+  id: string
+  fileName: string
+  fileSize: number
+  mimeType: string
+  url: string
+}>> {
+  const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+
+  const attachments = await em.find(Attachment, {
+    entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+    recordId: messageId,
+    tenantId,
+    ...buildOrganizationScopeFilter(organizationId),
+  })
+
+  return attachments.map((attachment) => ({
+    id: attachment.id,
+    fileName: attachment.fileName,
+    fileSize: attachment.fileSize,
+    mimeType: attachment.mimeType,
+    url: attachment.url,
+  }))
+}
+
+export type MessageEmailAttachment = {
+  fileName: string
+  fileSize: number
+  mimeType: string
+  partitionCode: string
+  storagePath: string
+  storageDriver: string
+}
+
+export async function getMessageEmailAttachments(
+  em: EntityManager,
+  messageId: string,
+  organizationId: string | null,
+  tenantId: string,
+): Promise<MessageEmailAttachment[]> {
+  const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+
+  const attachments = await em.find(Attachment, {
+    entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+    recordId: messageId,
+    tenantId,
+    ...buildOrganizationScopeFilter(organizationId),
+  })
+
+  return attachments.map((attachment) => ({
+    fileName: attachment.fileName,
+    fileSize: attachment.fileSize,
+    mimeType: attachment.mimeType,
+    partitionCode: attachment.partitionCode,
+    storagePath: attachment.storagePath,
+    storageDriver: attachment.storageDriver,
+  }))
+}
+
+export async function linkLibraryAttachmentsToMessage(
+  em: EntityManager,
+  messageId: string,
+  sourceRecordId: string,
+  organizationId: string | null,
+  tenantId: string,
+): Promise<void> {
+  if (!sourceRecordId.trim()) return
+
+  const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+
+  const attachments = await em.find(Attachment, {
+    entityId: LIBRARY_ATTACHMENT_ENTITY_ID,
+    recordId: sourceRecordId,
+    tenantId,
+    ...buildOrganizationScopeFilter(organizationId),
+  })
+
+  if (!attachments.length) return
+
+  for (const attachment of attachments) {
+    attachment.entityId = MESSAGE_ATTACHMENT_ENTITY_ID
+    attachment.recordId = messageId
+  }
+
+  await em.flush()
+}
+
+export async function copyAttachmentsForForward(
+  em: EntityManager,
+  sourceMessageId: string,
+  targetMessageId: string,
+  organizationId: string | null,
+  tenantId: string,
+): Promise<number> {
+  return copyAttachmentsForForwardMessages(
+    em,
+    [sourceMessageId],
+    targetMessageId,
+    organizationId,
+    tenantId,
+  )
+}
+
+export async function copyAttachmentsForForwardMessages(
+  em: EntityManager,
+  sourceMessageIds: string[],
+  targetMessageId: string,
+  targetOrganizationId: string | null,
+  tenantId: string,
+): Promise<number> {
+  if (sourceMessageIds.length === 0) return 0
+
+  const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+  const sourceAttachments = await em.find(Attachment, {
+    entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+    recordId: { $in: sourceMessageIds },
+    tenantId,
+  })
+  if (sourceAttachments.length === 0) {
+    return 0
+  }
+
+  const dedupedById = new Map<string, typeof sourceAttachments[number]>()
+  for (const sourceAttachment of sourceAttachments) {
+    if (!dedupedById.has(sourceAttachment.id)) {
+      dedupedById.set(sourceAttachment.id, sourceAttachment)
+    }
+  }
+
+  for (const sourceAttachment of dedupedById.values()) {
+    const copy = em.create(Attachment, {
+      entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+      recordId: targetMessageId,
+      organizationId: targetOrganizationId,
+      tenantId,
+      fileName: sourceAttachment.fileName,
+      mimeType: sourceAttachment.mimeType,
+      fileSize: sourceAttachment.fileSize,
+      storageDriver: sourceAttachment.storageDriver,
+      storagePath: sourceAttachment.storagePath,
+      storageMetadata: sourceAttachment.storageMetadata,
+      url: sourceAttachment.url,
+      partitionCode: sourceAttachment.partitionCode,
+    })
+
+    em.persist(copy)
+  }
+
+  await em.flush()
+  return dedupedById.size
+}

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

@@ -0,0 +1,2 @@
+export const MESSAGE_ATTACHMENT_ENTITY_ID = 'messages:message'
+export const MESSAGE_ATTACHMENT_PARTITION = 'messages'

package/src/modules/messages/lib/email-sender.ts

@@ -0,0 +1,255 @@
+import * as React from 'react'
+import crypto from 'node:crypto'
+import { promises as fs } from 'fs'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { sendEmail } from '@open-mercato/shared/lib/email/send'
+import { loadDictionary } from '@open-mercato/shared/lib/i18n/server'
+import { defaultLocale } from '@open-mercato/shared/lib/i18n/config'
+import { createFallbackTranslator } from '@open-mercato/shared/lib/i18n/translate'
+import type { Message, MessageObject } from '../data/entities'
+import { MessageAccessToken } from '../data/entities'
+import MessageEmail from '../emails/MessageEmail'
+import { resolveAttachmentAbsolutePath } from '../../attachments/lib/storage'
+import type { MessageEmailAttachment } from './attachments'
+
+const ACCESS_TOKEN_EXPIRY_HOURS = 24 * 7
+const DEBUG = process.env.MESSAGES_EMAIL_DEBUG === 'true'
+const MAX_EMAIL_ATTACHMENTS = 10
+const MAX_TOTAL_ATTACHMENT_BYTES = 20 * 1024 * 1024
+
+export type SenderIdentity = {
+  name: string | null
+  email: string | null
+}
+
+function logDebug(message: string, details?: Record<string, unknown>) {
+  if (!DEBUG) return
+  if (details) {
+    console.log(`[messages:email-sender] ${message}`, details)
+    return
+  }
+  console.log(`[messages:email-sender] ${message}`)
+}
+
+function resolveAppUrl(): string | null {
+  const raw = process.env.APP_URL?.trim()
+  if (!raw) return null
+  return raw.replace(/\/$/, '')
+}
+
+function buildSenderLabel(sender: SenderIdentity): string {
+  const name = sender.name?.trim()
+  if (name) return name
+  const email = sender.email?.trim()
+  if (email) return email
+  return 'System'
+}
+
+function generateAccessToken(): string {
+  return crypto.randomBytes(32).toString('hex')
+}
+
+function resolveObjectLabels(objects: MessageObject[]): string[] {
+  return objects.map((item) => `${item.entityModule}.${item.entityType} (${item.entityId})`)
+}
+
+type ResendAttachment = {
+  filename: string
+  content: string
+  contentType?: string
+}
+
+async function mapAttachmentsForEmail(
+  messageId: string,
+  attachments: MessageEmailAttachment[],
+): Promise<ResendAttachment[]> {
+  const resendAttachments: ResendAttachment[] = []
+  let totalBytes = 0
+
+  for (const attachment of attachments.slice(0, MAX_EMAIL_ATTACHMENTS)) {
+    const absolutePath = resolveAttachmentAbsolutePath(
+      attachment.partitionCode,
+      attachment.storagePath,
+      attachment.storageDriver,
+    )
+
+    let buffer: Buffer
+    try {
+      buffer = await fs.readFile(absolutePath)
+    } catch (error) {
+      logDebug('Attachment skipped: file read failed', {
+        messageId,
+        fileName: attachment.fileName,
+        error: error instanceof Error ? error.message : String(error),
+      })
+      continue
+    }
+
+    if ((totalBytes + buffer.length) > MAX_TOTAL_ATTACHMENT_BYTES) {
+      logDebug('Attachment skipped: total size limit exceeded', {
+        messageId,
+        fileName: attachment.fileName,
+        nextTotalBytes: totalBytes + buffer.length,
+      })
+      continue
+    }
+
+    totalBytes += buffer.length
+    resendAttachments.push({
+      filename: attachment.fileName,
+      content: buffer.toString('base64'),
+      contentType: attachment.mimeType || undefined,
+    })
+  }
+
+  return resendAttachments
+}
+
+async function renderMarkdownEmailBody(body: string) {
+  const ReactMarkdownModule = await import('react-markdown')
+  const remarkGfmModule = await import('remark-gfm')
+  const ReactMarkdown =
+    (ReactMarkdownModule.default ?? ReactMarkdownModule) as React.ComponentType<{
+      remarkPlugins?: unknown
+      children?: React.ReactNode
+    }>
+  const remarkGfmPlugin = remarkGfmModule.default ?? remarkGfmModule
+  const { renderToStaticMarkup } = await import('react-dom/server')
+
+  return renderToStaticMarkup(
+    React.createElement(ReactMarkdown, { remarkPlugins: [remarkGfmPlugin] }, body),
+  )
+}
+
+async function buildEmailBodyHtml(message: Message): Promise<string | undefined> {
+  if (message.bodyFormat !== 'markdown') return undefined
+  if (!message.body) return undefined
+  return renderMarkdownEmailBody(message.body)
+}
+
+async function buildEmailCopy(sentAt: Date) {
+  const dict = await loadDictionary(defaultLocale)
+  const t = createFallbackTranslator(dict)
+  return {
+    preview: t('messages.email.preview', 'You received a message in Open Mercato'),
+    heading: t('messages.email.heading', 'New message'),
+    from: t('messages.email.from', 'From'),
+    sentAt: t('messages.email.sentAt', 'Sent'),
+    sentAtLabel: sentAt.toISOString(),
+    viewCta: t('messages.email.viewCta', 'View message'),
+    attachmentsLabel: t('messages.email.attachments', 'Attachments'),
+    objectsLabel: t('messages.email.objects', 'Related records'),
+    footer: t('messages.email.footer', 'Open Mercato messages'),
+  }
+}
+
+export async function createMessageAccessToken(
+  em: EntityManager,
+  messageId: string,
+  recipientUserId: string,
+): Promise<string> {
+  const token = generateAccessToken()
+  const expiresAt = new Date(Date.now() + ACCESS_TOKEN_EXPIRY_HOURS * 60 * 60 * 1000)
+  const record = em.create(MessageAccessToken, {
+    messageId,
+    recipientUserId,
+    token,
+    expiresAt,
+    useCount: 0,
+  })
+  await em.persistAndFlush(record)
+  logDebug('Created access token', {
+    messageId,
+    recipientUserId,
+    expiresAt: expiresAt.toISOString(),
+  })
+  return token
+}
+
+export async function sendMessageEmailToRecipient(params: {
+  em: EntityManager
+  message: Message
+  recipientUserId: string
+  recipientEmail: string
+  sender: SenderIdentity
+  objects: MessageObject[]
+  attachments: MessageEmailAttachment[]
+}): Promise<void> {
+  const { em, message, recipientUserId, recipientEmail, sender, objects, attachments } = params
+  const token = await createMessageAccessToken(em, message.id, recipientUserId)
+  const appUrl = resolveAppUrl()
+  const viewUrl = appUrl ? `${appUrl}/messages/view/${token}` : null
+  if (!appUrl) {
+    logDebug('APP_URL missing - email link omitted', { messageId: message.id })
+  }
+  const copy = await buildEmailCopy(message.sentAt ?? new Date())
+  const bodyHtml = await buildEmailBodyHtml(message)
+  const resendAttachments = await mapAttachmentsForEmail(message.id, attachments)
+  logDebug('Sending recipient email via Resend', {
+    messageId: message.id,
+    recipientUserId,
+    recipientEmail,
+    hasViewUrl: Boolean(viewUrl),
+    attachmentsCount: resendAttachments.length,
+    hasApiKey: Boolean(process.env.RESEND_API_KEY),
+    from: process.env.EMAIL_FROM ?? null,
+  })
+
+  await sendEmail({
+    to: recipientEmail,
+    subject: message.subject,
+    react: MessageEmail({
+      subject: message.subject,
+      body: message.body,
+      bodyHtml,
+      senderName: buildSenderLabel(sender),
+      sentAtLabel: copy.sentAtLabel,
+      viewUrl,
+      copy,
+      attachmentNames: attachments.map((item) => item.fileName),
+      objectLabels: resolveObjectLabels(objects),
+    }),
+    attachments: resendAttachments,
+  })
+}
+
+export async function sendMessageEmailToExternal(params: {
+  message: Message
+  email: string
+  sender: SenderIdentity
+  objects: MessageObject[]
+  attachments: MessageEmailAttachment[]
+}): Promise<void> {
+  const { message, email, sender, objects, attachments } = params
+  const copy = await buildEmailCopy(message.sentAt ?? new Date())
+  const bodyHtml = await buildEmailBodyHtml(message)
+  const resendAttachments = await mapAttachmentsForEmail(message.id, attachments)
+  logDebug('Sending external email via Resend', {
+    messageId: message.id,
+    email,
+    attachmentsCount: resendAttachments.length,
+    hasApiKey: Boolean(process.env.RESEND_API_KEY),
+    from: process.env.EMAIL_FROM ?? null,
+  })
+
+  await sendEmail({
+    to: email,
+    subject: message.subject,
+    react: MessageEmail({
+      subject: message.subject,
+      body: message.body,
+      bodyHtml,
+      senderName: buildSenderLabel(sender),
+      sentAtLabel: copy.sentAtLabel,
+      viewUrl: null,
+      copy,
+      attachmentNames: attachments.map((item) => item.fileName),
+      objectLabels: resolveObjectLabels(objects),
+    }),
+    attachments: resendAttachments,
+  })
+  logDebug('External email sent via Resend', {
+    messageId: message.id,
+    email,
+  })
+}