@open-mercato/core 0.4.5-develop-5191db4ef3 → 0.4.5-develop-9f9549ebc8

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

@@ -0,0 +1,240 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { User } from '../../auth/data/entities'
+import { Message, MessageRecipient } from '../data/entities'
+
+const FORWARD_MARKER = '---------- Forwarded message ----------'
+const MAX_FORWARD_BODY_LENGTH = 50_000
+
+type MessageScope = {
+  tenantId: string
+  organizationId: string | null
+  userId?: string | null
+}
+
+type ForwardMessageBlock = {
+  id: string
+  senderUserId: string
+  subject: string
+  body: string
+  sentAt: Date | null | undefined
+  createdAt: Date
+}
+
+function formatForwardSubject(subject: string): string {
+  if (/^fwd:\s*/i.test(subject)) return subject
+  return `Fwd: ${subject}`
+}
+
+function formatDateLabel(date: Date | null | undefined): string {
+  if (!date) return '-'
+  return date.toISOString()
+}
+
+function normalizeSubject(subject: string | null | undefined): string {
+  if (typeof subject !== 'string') return '(no subject)'
+  const trimmed = subject.trim()
+  return trimmed.length > 0 ? trimmed : '(no subject)'
+}
+
+function formatUserLabel(user: { name?: string | null; email?: string | null } | undefined, fallbackUserId: string): string {
+  const name = user?.name?.trim()
+  const email = user?.email?.trim()
+  if (name && email) return `${name} <${email}>`
+  if (name) return name
+  if (email) return email
+  return fallbackUserId
+}
+
+function ensureMaxForwardBodyLength(body: string): void {
+  if (body.length > MAX_FORWARD_BODY_LENGTH) {
+    throw new Error('Forward body exceeds maximum length')
+  }
+}
+
+export async function buildForwardThreadSlice(
+  em: EntityManager,
+  scope: MessageScope,
+  selectedMessage: Message,
+): Promise<ForwardMessageBlock[]> {
+  const threadMessages = await em.find(
+    Message,
+    {
+      threadId: selectedMessage.threadId ?? selectedMessage.id,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      deletedAt: null,
+      isDraft: false,
+    },
+    {
+      orderBy: {
+        sentAt: 'ASC',
+        createdAt: 'ASC',
+        id: 'ASC',
+      },
+    },
+  )
+
+  const messagesById = new Map(threadMessages.map((item) => [item.id, item]))
+  messagesById.set(selectedMessage.id, selectedMessage)
+
+  const threadRootId = selectedMessage.threadId ?? null
+  if (threadRootId && !messagesById.has(threadRootId)) {
+    const threadRoot = await em.findOne(Message, {
+      id: threadRootId,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      deletedAt: null,
+      isDraft: false,
+    })
+    if (threadRoot) {
+      messagesById.set(threadRoot.id, threadRoot)
+    }
+  }
+
+  let parentMessageId = selectedMessage.parentMessageId ?? null
+  while (parentMessageId) {
+    const parentMessage = await em.findOne(Message, {
+      id: parentMessageId,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      deletedAt: null,
+      isDraft: false,
+    })
+    if (!parentMessage) break
+    messagesById.set(parentMessage.id, parentMessage)
+    parentMessageId = parentMessage.parentMessageId ?? null
+  }
+
+  const orderedThreadMessages = Array.from(messagesById.values()).sort((a, b) => {
+    const aTime = a.sentAt?.getTime() ?? 0
+    const bTime = b.sentAt?.getTime() ?? 0
+    if (aTime !== bTime) return aTime - bTime
+
+    const aCreatedAt = a.createdAt.getTime()
+    const bCreatedAt = b.createdAt.getTime()
+    if (aCreatedAt !== bCreatedAt) return aCreatedAt - bCreatedAt
+
+    return a.id.localeCompare(b.id)
+  })
+
+  const selectedIndex = orderedThreadMessages.findIndex((item) => item.id === selectedMessage.id)
+  const threadSlice = selectedIndex >= 0 ? orderedThreadMessages.slice(0, selectedIndex + 1) : [selectedMessage]
+
+  if (scope.userId) {
+    const sliceIds = threadSlice.map((item) => item.id)
+    const recipientRows = sliceIds.length > 0
+      ? await em.find(MessageRecipient, {
+        messageId: { $in: sliceIds },
+        recipientUserId: scope.userId,
+        deletedAt: null,
+      })
+      : []
+    const recipientMessageIds = new Set(recipientRows.map((row) => row.messageId))
+    const visibleSlice = threadSlice.filter(
+      (item) => item.senderUserId === scope.userId || recipientMessageIds.has(item.id),
+    )
+    return visibleSlice.map((item) => ({
+      id: item.id,
+      senderUserId: item.senderUserId,
+      subject: item.subject,
+      body: item.body,
+      sentAt: item.sentAt,
+      createdAt: item.createdAt,
+    }))
+  }
+
+  return threadSlice.map((item) => ({
+    id: item.id,
+    senderUserId: item.senderUserId,
+    subject: item.subject,
+    body: item.body,
+    sentAt: item.sentAt,
+    createdAt: item.createdAt,
+  }))
+}
+
+export async function buildForwardPreviewFromThreadSlice(
+  em: EntityManager,
+  scope: MessageScope,
+  selectedMessage: Message,
+  threadSlice: ForwardMessageBlock[],
+): Promise<{ subject: string; body: string }> {
+  const allMessageIds = threadSlice.map((item) => item.id)
+  const allSenderIds = Array.from(new Set(threadSlice.map((item) => item.senderUserId)))
+
+  const recipients = allMessageIds.length > 0
+    ? await em.find(MessageRecipient, {
+      messageId: { $in: allMessageIds },
+      deletedAt: null,
+    })
+    : []
+
+  const allRecipientUserIds = Array.from(new Set(recipients.map((item) => item.recipientUserId)))
+  const allUserIds = Array.from(new Set([...allSenderIds, ...allRecipientUserIds]))
+  const users = allUserIds.length > 0
+    ? await findWithDecryption(
+      em,
+      User,
+      { id: { $in: allUserIds } },
+      undefined,
+      { tenantId: scope.tenantId, organizationId: scope.organizationId },
+    )
+    : []
+
+  const userById = new Map(users.map((user) => [user.id, user]))
+  const recipientsByMessageId = new Map<string, MessageRecipient[]>()
+  for (const recipient of recipients) {
+    const currentRecipients = recipientsByMessageId.get(recipient.messageId) ?? []
+    currentRecipients.push(recipient)
+    recipientsByMessageId.set(recipient.messageId, currentRecipients)
+  }
+
+  const body = threadSlice.map((item) => {
+    const sender = userById.get(item.senderUserId)
+    const toRecipients = recipientsByMessageId.get(item.id) ?? []
+    const toLabel = toRecipients.length > 0
+      ? toRecipients
+        .map((recipient) => formatUserLabel(userById.get(recipient.recipientUserId), recipient.recipientUserId))
+        .join(', ')
+      : '-'
+
+    return [
+      FORWARD_MARKER,
+      `From: ${formatUserLabel(sender, item.senderUserId)}`,
+      `Date: ${formatDateLabel(item.sentAt ?? item.createdAt)}`,
+      `Subject: ${normalizeSubject(item.subject)}`,
+      `To: ${toLabel}`,
+      '',
+      item.body ?? '',
+    ].join('\n')
+  }).join('\n\n')
+
+  ensureMaxForwardBodyLength(body)
+
+  return {
+    subject: formatForwardSubject(selectedMessage.subject),
+    body,
+  }
+}
+
+export async function buildForwardPreview(
+  em: EntityManager,
+  scope: MessageScope,
+  selectedMessage: Message,
+): Promise<{ subject: string; body: string }> {
+  const threadSlice = await buildForwardThreadSlice(em, scope, selectedMessage)
+  return buildForwardPreviewFromThreadSlice(em, scope, selectedMessage, threadSlice)
+}
+
+export function buildForwardBodyFromLegacyInput(
+  generatedBody: string,
+  additionalBody?: string,
+): string {
+  const legacyPrefix = additionalBody?.trim()
+  const finalBody = legacyPrefix
+    ? `${legacyPrefix}\n\n${generatedBody}`
+    : generatedBody
+  ensureMaxForwardBodyLength(finalBody)
+  return finalBody
+}

package/src/modules/messages/lib/message-objects-registry.ts

@@ -0,0 +1,60 @@
+import type { MessageObjectTypeDefinition } from '@open-mercato/shared/modules/messages/types'
+import defaultTypes from '../message-objects'
+
+const registry = new Map<string, MessageObjectTypeDefinition>()
+
+export type RegisterMessageObjectTypesOptions = {
+  replace?: boolean
+}
+
+function getKey(module: string, entityType: string): string {
+  return `${module}:${entityType}`
+}
+
+function ensureDefaults(): void {
+  if (registry.size > 0) return
+  registerMessageObjectTypes(defaultTypes)
+}
+
+export function registerMessageObjectTypes(
+  types: MessageObjectTypeDefinition[],
+  options: RegisterMessageObjectTypesOptions = {},
+): void {
+  if (options.replace) {
+    registry.clear()
+  }
+  for (const type of types) {
+    const key = getKey(type.module, type.entityType)
+    if (registry.has(key)) {
+      console.warn(`[messages] Message object type "${key}" is already registered, overwriting`)
+    }
+    registry.set(key, type)
+  }
+}
+
+export function getMessageObjectType(module: string, entityType: string): MessageObjectTypeDefinition | undefined {
+  ensureDefaults()
+  return registry.get(getKey(module, entityType))
+}
+
+export function isMessageObjectTypeAllowedForMessageType(
+  objectType: MessageObjectTypeDefinition,
+  messageType: string,
+): boolean {
+  if (!messageType || !messageType.trim()) return true
+  const allowed = objectType.messageTypes
+  if (!Array.isArray(allowed) || allowed.length === 0) return true
+  return allowed.includes(messageType)
+}
+
+export function getMessageObjectTypesForMessageType(messageType: string): MessageObjectTypeDefinition[] {
+  ensureDefaults()
+  return Array.from(registry.values()).filter((objectType) =>
+    isMessageObjectTypeAllowedForMessageType(objectType, messageType),
+  )
+}
+
+export function getAllMessageObjectTypes(): MessageObjectTypeDefinition[] {
+  ensureDefaults()
+  return Array.from(registry.values())
+}

package/src/modules/messages/lib/message-types-registry.ts

@@ -0,0 +1,48 @@
+import type { MessageTypeDefinition } from '@open-mercato/shared/modules/messages/types'
+import defaultTypes from '../message-types'
+
+const registry = new Map<string, MessageTypeDefinition>()
+
+export type RegisterMessageTypesOptions = {
+  replace?: boolean
+}
+
+function ensureDefaults(): void {
+  if (registry.size > 0) return
+  registerMessageTypes(defaultTypes)
+}
+
+export function registerMessageTypes(
+  types: MessageTypeDefinition[],
+  options: RegisterMessageTypesOptions = {},
+): void {
+  if (options.replace) {
+    registry.clear()
+  }
+  for (const type of types) {
+    if (registry.has(type.type)) {
+      console.warn(`[messages] Message type "${type.type}" is already registered, overwriting`)
+    }
+    registry.set(type.type, type)
+  }
+}
+
+export function getMessageType(type: string): MessageTypeDefinition | undefined {
+  ensureDefaults()
+  return registry.get(type)
+}
+
+export function getMessageTypeOrDefault(type: string): MessageTypeDefinition {
+  ensureDefaults()
+  return registry.get(type) ?? registry.get('default') ?? defaultTypes[0]!
+}
+
+export function getAllMessageTypes(): MessageTypeDefinition[] {
+  ensureDefaults()
+  return Array.from(registry.values())
+}
+
+export function getMessageTypesByModule(module: string): MessageTypeDefinition[] {
+  ensureDefaults()
+  return Array.from(registry.values()).filter((entry) => entry.module === module)
+}

package/src/modules/messages/lib/object-validation.ts

@@ -0,0 +1,26 @@
+import {
+  getMessageObjectType,
+  isMessageObjectTypeAllowedForMessageType,
+} from './message-objects-registry'
+
+type MessageObjectLike = {
+  entityModule: string
+  entityType: string
+  entityId: string
+}
+
+export function validateMessageObjectsForType(
+  messageType: string,
+  objects: MessageObjectLike[],
+): string | null {
+  for (const object of objects) {
+    const objectType = getMessageObjectType(object.entityModule, object.entityType)
+    if (!objectType) {
+      return `Unsupported message object type: ${object.entityModule}:${object.entityType}`
+    }
+    if (!isMessageObjectTypeAllowedForMessageType(objectType, messageType)) {
+      return `Object type ${object.entityModule}:${object.entityType} is not allowed for message type ${messageType}`
+    }
+  }
+  return null
+}

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

@@ -0,0 +1,43 @@
+import { serializeOperationMetadata } from '@open-mercato/shared/lib/commands/operationMetadata'
+
+export type OperationLogEntryLike = {
+  id?: string | null
+  undoToken?: string | null
+  commandId?: string | null
+  actionLabel?: string | null
+  resourceKind?: string | null
+  resourceId?: string | null
+  createdAt?: Date | string | null
+}
+
+type OperationFallback = {
+  resourceKind?: string | null
+  resourceId?: string | null
+}
+
+export function attachOperationMetadataHeader(
+  response: Response,
+  logEntry: OperationLogEntryLike | null | undefined,
+  fallback: OperationFallback = {},
+) {
+  if (!logEntry?.undoToken || !logEntry.id || !logEntry.commandId) return
+
+  const executedAt = logEntry.createdAt instanceof Date
+    ? logEntry.createdAt.toISOString()
+    : typeof logEntry.createdAt === 'string' && logEntry.createdAt.trim().length > 0
+      ? logEntry.createdAt
+      : new Date().toISOString()
+
+  response.headers.set(
+    'x-om-operation',
+    serializeOperationMetadata({
+      id: logEntry.id,
+      undoToken: logEntry.undoToken,
+      commandId: logEntry.commandId,
+      actionLabel: logEntry.actionLabel ?? null,
+      resourceKind: logEntry.resourceKind ?? fallback.resourceKind ?? null,
+      resourceId: logEntry.resourceId ?? fallback.resourceId ?? null,
+      executedAt,
+    }),
+  )
+}

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

@@ -0,0 +1,76 @@
+import type { BadgeProps } from '@open-mercato/ui/primitives/badge'
+
+export type MessagePriority = 'low' | 'normal' | 'high' | 'urgent'
+
+/**
+ * Get the Badge variant for a given priority level
+ */
+export function getPriorityBadgeVariant(priority: MessagePriority): BadgeProps['variant'] {
+  switch (priority) {
+    case 'low':
+      return 'muted'
+    case 'normal':
+      return 'secondary'
+    case 'high':
+      return 'default'
+    case 'urgent':
+      return 'destructive'
+    default:
+      return 'secondary'
+  }
+}
+
+/**
+ * Get custom CSS classes for priority badge colors
+ */
+export function getPriorityBadgeClassName(priority: MessagePriority): string {
+  switch (priority) {
+    case 'low':
+      return 'text-slate-600 bg-slate-100 border-slate-200'
+    case 'normal':
+      return 'text-blue-600 bg-blue-100 border-blue-200'
+    case 'high':
+      return 'text-orange-600 bg-orange-100 border-orange-200'
+    case 'urgent':
+      return 'text-red-600 bg-red-100 border-red-200'
+    default:
+      return 'text-blue-600 bg-blue-100 border-blue-200'
+  }
+}
+
+/**
+ * Get the localized priority label key
+ */
+export function getPriorityLabelKey(priority: MessagePriority): string {
+  return `messages.priority.${priority}`
+}
+
+/**
+ * Get the default fallback label for a priority
+ */
+export function getPriorityFallbackLabel(priority: MessagePriority): string {
+  switch (priority) {
+    case 'low':
+      return 'Low'
+    case 'normal':
+      return 'Normal'
+    case 'high':
+      return 'High'
+    case 'urgent':
+      return 'Urgent'
+    default:
+      return 'Normal'
+  }
+}
+
+/**
+ * Get all available priority options for dropdowns/selects
+ */
+export function getPriorityOptions(): Array<{ value: MessagePriority; labelKey: string; fallbackLabel: string }> {
+  return [
+    { value: 'low', labelKey: getPriorityLabelKey('low'), fallbackLabel: getPriorityFallbackLabel('low') },
+    { value: 'normal', labelKey: getPriorityLabelKey('normal'), fallbackLabel: getPriorityFallbackLabel('normal') },
+    { value: 'high', labelKey: getPriorityLabelKey('high'), fallbackLabel: getPriorityFallbackLabel('high') },
+    { value: 'urgent', labelKey: getPriorityLabelKey('urgent'), fallbackLabel: getPriorityFallbackLabel('urgent') },
+  ]
+}

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

@@ -0,0 +1,65 @@
+import { resolveRequestContext } from '@open-mercato/shared/lib/api/context'
+import { hasFeature } from '@open-mercato/shared/security/features'
+
+export function hasOrganizationAccess(
+  scopeOrganizationId: string | null,
+  messageOrganizationId: string | null | undefined,
+): boolean {
+  if (scopeOrganizationId) {
+    return messageOrganizationId === scopeOrganizationId
+  }
+  return messageOrganizationId == null
+}
+
+export type MessageScope = {
+  tenantId: string
+  organizationId: string | null
+  userId: string
+}
+
+export async function resolveMessageContext(req: Request): Promise<{
+  ctx: Awaited<ReturnType<typeof resolveRequestContext>>['ctx']
+  scope: MessageScope
+}> {
+  const { ctx } = await resolveRequestContext(req)
+  return {
+    ctx,
+    scope: {
+      tenantId: ctx.auth?.tenantId ?? '',
+      organizationId: ctx.auth?.orgId ?? null,
+      userId: ctx.auth?.sub ?? '',
+    },
+  }
+}
+
+type RbacService = {
+  loadAcl: (
+    userId: string,
+    scope: { tenantId: string | null; organizationId: string | null }
+  ) => Promise<{ features?: string[]; isSuperAdmin?: boolean }>
+}
+
+export async function parseRequestBodySafe(req: Request): Promise<unknown> {
+  try {
+    const text = await req.text()
+    if (!text) return {}
+    return JSON.parse(text)
+  } catch {
+    return {}
+  }
+}
+
+export async function canUseMessageEmailFeature(
+  ctx: Awaited<ReturnType<typeof resolveRequestContext>>['ctx'],
+  scope: MessageScope,
+): Promise<boolean> {
+  if (!scope.userId || !scope.tenantId) return false
+
+  const rbac = ctx.container.resolve('rbacService') as RbacService
+  const acl = await rbac.loadAcl(scope.userId, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+  })
+
+  return Boolean(acl.isSuperAdmin) || hasFeature(acl.features, 'messages.email')
+}

package/src/modules/messages/message-objects.ts

@@ -0,0 +1,5 @@
+import type { MessageObjectTypeDefinition } from '@open-mercato/shared/modules/messages/types'
+
+export const messageObjectTypes: MessageObjectTypeDefinition[] = []
+
+export default messageObjectTypes

package/src/modules/messages/message-types.ts

@@ -0,0 +1,65 @@
+import type { MessageTypeDefinition } from '@open-mercato/shared/modules/messages/types'
+import { DefaultMessageActions } from './components/defaults/DefaultMessageActions'
+import { MessageConfirmationActions } from './components/confirmation/MessageConfirmationActions'
+import { MessageConfirmationContent } from './components/confirmation/MessageConfirmationContent'
+import { DefaultMessageContent } from './components/defaults/DefaultMessageContent'
+import { DefaultMessageListItem } from './components/defaults/DefaultMessageListItem'
+
+export const messageTypes: MessageTypeDefinition[] = [
+  {
+    type: 'default',
+    module: 'messages',
+    labelKey: 'messages.types.default',
+    icon: 'mail',
+    ui: {
+      listItemComponent: 'messages.default.listItem',
+      contentComponent: 'messages.default.content',
+      actionsComponent: 'messages.default.actions',
+    },
+    ListItemComponent: DefaultMessageListItem,
+    ContentComponent: DefaultMessageContent,
+    ActionsComponent: DefaultMessageActions,
+    allowReply: true,
+    allowForward: true,
+  },
+  {
+    type: 'messages.confirmation',
+    module: 'messages',
+    labelKey: 'messages.types.confirmation',
+    icon: 'badge-check',
+    color: 'green',
+    ui: {
+      listItemComponent: 'messages.default.listItem',
+      contentComponent: 'messages.confirmation.content',
+      actionsComponent: 'messages.confirmation.actions',
+    },
+    ListItemComponent: DefaultMessageListItem,
+    ContentComponent: MessageConfirmationContent,
+    ActionsComponent: MessageConfirmationActions,
+    defaultActions: [
+      {
+        id: 'confirmation',
+        label: 'Confirm',
+        labelKey: 'messages.actions.confirmation',
+        variant: 'default',
+        icon: 'check',
+        commandId: 'messages.confirmations.confirm',
+        isTerminal: true,
+        confirmRequired: true,
+      },
+    ],
+    allowReply: true,
+    allowForward: true,
+  },
+  {
+    type: 'messages.defaultWithObjects',
+    module: 'messages',
+    labelKey: 'messages.types.defaultWithObjects',
+    icon: 'attachment',
+    color: 'blue',
+    allowReply: true,
+    allowForward: true,
+  },
+]
+
+export default messageTypes