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

package/src/modules/messages/api/token/[token]/route.ts

@@ -0,0 +1,103 @@
+import type { CommandBus } from '@open-mercato/shared/lib/commands/command-bus'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi/types'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { Message, MessageObject } from '../../../data/entities'
+import { messageTokenResponseSchema } from '../../openapi'
+
+export const metadata = {
+  GET: { requireAuth: false },
+}
+
+export async function GET(_req: Request, { params }: { params: { token: string } }) {
+  const container = await createRequestContainer()
+  const commandBus = container.resolve('commandBus') as CommandBus
+  const em = container.resolve('em') as EntityManager
+
+  let commandResult: { messageId: string; recipientUserId: string }
+  try {
+    const executed = await commandBus.execute<unknown, { messageId: string; recipientUserId: string }>('messages.tokens.consume', {
+      input: { token: params.token },
+      ctx: {
+        container,
+        auth: null,
+        organizationScope: null,
+        selectedOrganizationId: null,
+        organizationIds: null,
+      },
+    })
+    commandResult = executed.result
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message === 'Invalid or expired link') {
+        return Response.json({ error: 'Invalid or expired link' }, { status: 404 })
+      }
+      if (error.message === 'This link has expired') {
+        return Response.json({ error: 'This link has expired' }, { status: 410 })
+      }
+      if (error.message === 'This link can no longer be used') {
+        return Response.json({ error: 'This link can no longer be used' }, { status: 409 })
+      }
+      if (error.message === 'Message not found') {
+        return Response.json({ error: 'Message not found' }, { status: 404 })
+      }
+    }
+    throw error
+  }
+
+  const message = await em.findOne(Message, {
+    id: commandResult.messageId,
+    deletedAt: null,
+  })
+  if (!message) {
+    return Response.json({ error: 'Message not found' }, { status: 404 })
+  }
+
+  const objects = await em.find(MessageObject, { messageId: message.id })
+
+  return Response.json({
+    id: message.id,
+    type: message.type,
+    subject: message.subject,
+    body: message.body,
+    bodyFormat: message.bodyFormat,
+    priority: message.priority,
+    senderUserId: message.senderUserId,
+    sentAt: message.sentAt,
+    actionData: message.actionData,
+    actionTaken: message.actionTaken,
+    actionTakenAt: message.actionTakenAt,
+    actionTakenByUserId: message.actionTakenByUserId,
+    objects: objects.map((item) => ({
+      id: item.id,
+      entityModule: item.entityModule,
+      entityType: item.entityType,
+      entityId: item.entityId,
+      actionRequired: item.actionRequired,
+      actionType: item.actionType,
+      actionLabel: item.actionLabel,
+      snapshot: item.entitySnapshot,
+    })),
+    requiresAuth: objects.some((item) => item.actionRequired),
+    recipientUserId: commandResult.recipientUserId,
+  })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Messages',
+  methods: {
+    GET: {
+      summary: 'Access message via token',
+      responses: [
+        {
+          status: 200,
+          description: 'Message detail via token',
+          schema: messageTokenResponseSchema,
+        },
+        { status: 404, description: 'Invalid or expired link' },
+        { status: 409, description: 'Token usage exceeded' },
+        { status: 410, description: 'Token expired' },
+      ],
+    },
+  },
+}

package/src/modules/messages/api/types/route.ts

@@ -0,0 +1,39 @@
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi/types'
+import { getAllMessageTypes } from '../../lib/message-types-registry'
+import { messageTypeListResponseSchema } from '../openapi'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['messages.view'] },
+}
+
+export async function GET() {
+  const items = getAllMessageTypes().map((type) => ({
+    type: type.type,
+    module: type.module,
+    labelKey: type.labelKey,
+    icon: type.icon,
+    color: type.color ?? null,
+    allowReply: type.allowReply ?? true,
+    allowForward: type.allowForward ?? true,
+    actionsExpireAfterHours: type.actionsExpireAfterHours ?? null,
+    ui: {
+      listItemComponent: type.ui?.listItemComponent ?? null,
+      contentComponent: type.ui?.contentComponent ?? null,
+      actionsComponent: type.ui?.actionsComponent ?? null,
+    },
+  }))
+
+  return Response.json({ items })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Messages',
+  methods: {
+    GET: {
+      summary: 'List registered message types',
+      responses: [
+        { status: 200, description: 'Message types', schema: messageTypeListResponseSchema },
+      ],
+    },
+  },
+}

package/src/modules/messages/api/unread-count/route.ts

@@ -0,0 +1,55 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { Knex } from 'knex'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi/types'
+import { resolveMessageContext } from '../../lib/routeHelpers'
+import { unreadCountResponseSchema } from '../openapi'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['messages.view'] },
+}
+
+function getKnex(em: EntityManager): Knex {
+  return (em.getConnection() as unknown as { getKnex: () => Knex }).getKnex()
+}
+
+export async function GET(req: Request) {
+  const { ctx, scope } = await resolveMessageContext(req)
+  const em = ctx.container.resolve('em') as EntityManager
+  const knex = getKnex(em)
+
+  let query = knex('message_recipients as r')
+    .join('messages as m', 'm.id', 'r.message_id')
+    .where('r.recipient_user_id', scope.userId)
+    .where('r.status', 'unread')
+    .whereNull('r.deleted_at')
+    .whereNull('r.archived_at')
+    .where('m.tenant_id', scope.tenantId)
+    .whereNull('m.deleted_at')
+
+  if (scope.organizationId) {
+    query = query.where('m.organization_id', scope.organizationId)
+  } else {
+    query = query.whereNull('m.organization_id')
+  }
+
+  const row = await query.count('* as count').first<{ count: string | number }>()
+  const count = Number(row?.count ?? 0)
+
+  return Response.json({ unreadCount: count })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Messages',
+  methods: {
+    GET: {
+      summary: 'Get unread message count',
+      responses: [
+        {
+          status: 200,
+          description: 'Unread count',
+          schema: unreadCountResponseSchema,
+        },
+      ],
+    },
+  },
+}

package/src/modules/messages/backend/messages/[id]/page.meta.ts

@@ -0,0 +1,12 @@
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['messages.view'],
+  pageTitle: 'Message details',
+  pageTitleKey: 'messages.nav.detail',
+  pageGroup: 'Messages',
+  pageGroupKey: 'messages.nav.group',
+  navHidden: true,
+  breadcrumb: [
+    { label: 'Messages', labelKey: 'messages.nav.inbox', href: '/backend/messages' },
+  ],
+} as const

package/src/modules/messages/backend/messages/[id]/page.tsx

@@ -0,0 +1,12 @@
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { MessageDetailPageClient } from '../../../components/MessageDetailPageClient'
+
+export default function MessageDetailPage({ params }: { params: { id: string } }) {
+  return (
+    <Page>
+      <PageBody>
+        <MessageDetailPageClient id={params.id} />
+      </PageBody>
+    </Page>
+  )
+}

package/src/modules/messages/backend/messages/compose/page.meta.ts

@@ -0,0 +1,13 @@
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['messages.compose'],
+  pageTitle: 'Compose message',
+  pageTitleKey: 'messages.nav.compose',
+  pageGroup: 'Messages',
+  pageGroupKey: 'messages.nav.group',
+  navHidden: true,
+  breadcrumb: [
+    { label: 'Messages', labelKey: 'messages.nav.inbox', href: '/backend/messages' },
+    { label: 'Compose', labelKey: 'messages.nav.compose' },
+  ],
+} as const

package/src/modules/messages/backend/messages/compose/page.tsx

@@ -0,0 +1,12 @@
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { ComposeMessagePageClient } from '../../../components/ComposeMessagePageClient'
+
+export default function ComposeMessagePage() {
+  return (
+    <Page>
+      <PageBody>
+        <ComposeMessagePageClient />
+      </PageBody>
+    </Page>
+  )
+}

package/src/modules/messages/backend/page.meta.ts

@@ -0,0 +1,31 @@
+import React from 'react'
+
+const mailIcon = React.createElement(
+  'svg',
+  {
+    width: 16,
+    height: 16,
+    viewBox: '0 0 24 24',
+    fill: 'none',
+    stroke: 'currentColor',
+    strokeWidth: 2,
+    strokeLinecap: 'round',
+    strokeLinejoin: 'round',
+  },
+  React.createElement('rect', { x: 2, y: 4, width: 20, height: 16, rx: 2 }),
+  React.createElement('path', { d: 'm22 7-8.97 5.7a2 2 0 0 1-2.06 0L2 7' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['messages.view'],
+  pageTitle: 'Messages',
+  pageTitleKey: 'messages.nav.inbox',
+  pageGroup: 'Messages',
+  pageGroupKey: 'messages.nav.group',
+  pageOrder: 460,
+  icon: mailIcon,
+  breadcrumb: [
+    { label: 'Messages', labelKey: 'messages.nav.inbox' },
+  ],
+} as const

package/src/modules/messages/backend/page.tsx

@@ -0,0 +1,12 @@
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { MessagesInboxPageClient } from '../components/MessagesInboxPageClient'
+
+export default function MessagesInboxPage() {
+  return (
+    <Page>
+      <PageBody>
+        <MessagesInboxPageClient />
+      </PageBody>
+    </Page>
+  )
+}

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

@@ -0,0 +1,307 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { z } from 'zod'
+import { registerCommand, type CommandHandler } from '@open-mercato/shared/lib/commands'
+import { extractUndoPayload, type UndoPayload } from '@open-mercato/shared/lib/commands/undo'
+import { Message, MessageObject, MessageRecipient } from '../data/entities'
+import { emitMessagesEvent } from '../events'
+import {
+  findResolvedMessageActionById,
+  isTerminalMessageAction,
+  resolveActionCommandInput,
+  resolveActionHref,
+} from '../lib/actions'
+import { getMessageType } from '../lib/message-types-registry'
+import { assertOrganizationAccess, type MessageScopeInput } from './shared'
+
+const recordTerminalActionSchema = z.object({
+  messageId: z.string().uuid(),
+  actionId: z.string().min(1),
+  result: z.record(z.string(), z.unknown()),
+  tenantId: z.string().uuid(),
+  organizationId: z.string().uuid().nullable(),
+  userId: z.string().uuid(),
+})
+
+type RecordTerminalActionInput = z.infer<typeof recordTerminalActionSchema>
+
+const executeActionSchema = z.object({
+  messageId: z.string().uuid(),
+  actionId: z.string().min(1),
+  payload: z.record(z.string(), z.unknown()).optional(),
+  tenantId: z.string().uuid(),
+  organizationId: z.string().uuid().nullable(),
+  userId: z.string().uuid(),
+})
+
+type ExecuteActionInput = z.infer<typeof executeActionSchema>
+
+type ActionStateSnapshot = {
+  actionTaken: string | null
+  actionTakenByUserId: string | null
+  actionTakenAt: string | null
+  actionResult: Record<string, unknown> | 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)
+}
+
+async function requireActionTarget(em: EntityManager, input: RecordTerminalActionInput) {
+  const message = await em.findOne(Message, {
+    id: input.messageId,
+    tenantId: input.tenantId,
+    deletedAt: null,
+  })
+  if (!message) throw new Error('Message not found')
+  assertOrganizationAccess(input as MessageScopeInput, message)
+
+  const recipient = await em.findOne(MessageRecipient, {
+    messageId: input.messageId,
+    recipientUserId: input.userId,
+    deletedAt: null,
+  })
+  if (!recipient) throw new Error('Access denied')
+  return message
+}
+
+async function requireActionMessage(em: EntityManager, input: ExecuteActionInput) {
+  const message = await em.findOne(Message, {
+    id: input.messageId,
+    tenantId: input.tenantId,
+    deletedAt: null,
+  })
+  if (!message) throw new Error('Message not found')
+  assertOrganizationAccess(input as MessageScopeInput, message)
+  const recipient = await em.findOne(MessageRecipient, {
+    messageId: input.messageId,
+    recipientUserId: input.userId,
+    deletedAt: null,
+  })
+  if (!recipient) throw new Error('Access denied')
+  return message
+}
+
+function snapshotActionState(message: Message): ActionStateSnapshot {
+  return {
+    actionTaken: message.actionTaken ?? null,
+    actionTakenByUserId: message.actionTakenByUserId ?? null,
+    actionTakenAt: toIso(message.actionTakenAt),
+    actionResult: message.actionResult ?? null,
+  }
+}
+
+const recordTerminalActionCommand: CommandHandler<unknown, { ok: true }> = {
+  id: 'messages.actions.record_terminal',
+  async prepare(rawInput, ctx) {
+    const input = recordTerminalActionSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const message = await requireActionTarget(em, input)
+    return { before: snapshotActionState(message) }
+  },
+  async execute(rawInput, ctx) {
+    const input = recordTerminalActionSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const message = await requireActionTarget(em, input)
+    if (message.actionTaken) {
+      throw new Error('Action already taken')
+    }
+    message.actionTaken = input.actionId
+    message.actionTakenByUserId = input.userId
+    message.actionTakenAt = new Date()
+    message.actionResult = input.result
+    await em.flush()
+    return { ok: true }
+  },
+  async captureAfter(rawInput, _result, ctx) {
+    const input = recordTerminalActionSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const message = await requireActionTarget(em, input)
+    return snapshotActionState(message)
+  },
+  buildLog: async ({ input, snapshots }) => {
+    const parsed = recordTerminalActionSchema.parse(input)
+    return {
+      actionLabel: 'Execute message terminal action',
+      resourceKind: 'messages.message',
+      resourceId: parsed.messageId,
+      tenantId: parsed.tenantId,
+      organizationId: parsed.organizationId,
+      payload: {
+        undo: {
+          before: (snapshots.before as ActionStateSnapshot | undefined) ?? null,
+          after: (snapshots.after as ActionStateSnapshot | undefined) ?? null,
+        } satisfies UndoPayload<ActionStateSnapshot>,
+      },
+      snapshotBefore: snapshots.before ?? null,
+      snapshotAfter: snapshots.after ?? null,
+    }
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const undo = extractUndoPayload<UndoPayload<ActionStateSnapshot>>(logEntry)
+    const before = undo?.before
+    if (!before) return
+    const messageId = logEntry?.resourceId as string | null
+    if (!messageId) return
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const message = await em.findOne(Message, { id: messageId })
+    if (!message) return
+    message.actionTaken = before.actionTaken
+    message.actionTakenByUserId = before.actionTakenByUserId
+    message.actionTakenAt = toDate(before.actionTakenAt)
+    message.actionResult = before.actionResult
+    await em.flush()
+  },
+}
+
+const executeActionCommand: CommandHandler<
+  unknown,
+  { ok: true; actionId: string; result: Record<string, unknown>; operationLogEntry: unknown | null }
+> = {
+  id: 'messages.actions.execute',
+  async execute(rawInput, ctx) {
+    const input = executeActionSchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const message = await requireActionMessage(em, input)
+    const objects = await em.find(MessageObject, { messageId: message.id })
+    const action = findResolvedMessageActionById(message, objects, input.actionId)
+
+    if (!action) {
+      throw new Error('Action not found')
+    }
+
+    if (message.actionTaken) {
+      throw Object.assign(new Error('Action already taken'), { actionTaken: message.actionTaken })
+    }
+
+    const shouldRecordActionTaken = isTerminalMessageAction(action)
+
+    if (message.actionData?.expiresAt) {
+      if (new Date(message.actionData.expiresAt) < new Date()) {
+        throw new Error('Actions have expired')
+      }
+    } else {
+      const messageType = getMessageType(message.type)
+      if (messageType?.actionsExpireAfterHours && message.sentAt) {
+        const expiry = new Date(message.sentAt.getTime() + messageType.actionsExpireAfterHours * 60 * 60 * 1000)
+        if (expiry < new Date()) {
+          throw new Error('Actions have expired')
+        }
+      }
+    }
+
+    const commandBus = ctx.container.resolve('commandBus') as {
+      execute: (
+        commandId: string,
+        options: { input: unknown; ctx: unknown; metadata?: unknown }
+      ) => Promise<{ result: unknown; logEntry?: unknown }>
+    }
+
+    let result: Record<string, unknown> = {}
+    let operationLogEntry: unknown | null = null
+
+    if (action.commandId) {
+      try {
+        const actionInput = resolveActionCommandInput(
+          action,
+          message,
+          {
+            tenantId: input.tenantId,
+            organizationId: input.organizationId,
+            userId: input.userId,
+          },
+          input.payload ?? {},
+        )
+
+        if (actionInput.id == null) {
+          const fallbackId = action.objectRef?.entityId ?? message.sourceEntityId ?? null
+          if (typeof fallbackId === 'string' && fallbackId.trim().length > 0) {
+            actionInput.id = fallbackId
+          }
+        }
+
+        const commandResult = await commandBus.execute(action.commandId, {
+          input: actionInput,
+          ctx: {
+            container: ctx.container,
+            auth: {
+              sub: input.userId,
+              tenantId: input.tenantId,
+              orgId: input.organizationId,
+            },
+            organizationScope: null,
+            selectedOrganizationId: input.organizationId,
+            organizationIds: input.organizationId ? [input.organizationId] : null,
+          },
+          metadata: {
+            tenantId: input.tenantId,
+            organizationId: input.organizationId,
+            resourceKind: 'messages',
+          },
+        })
+
+        result = (commandResult.result as Record<string, unknown>) ?? {}
+        operationLogEntry = commandResult.logEntry ?? null
+      } catch (err) {
+        console.error('[messages] executeActionCommand sub-command failed', err)
+        throw new Error('Action failed')
+      }
+    } else if (action.href) {
+      result = {
+        redirect: resolveActionHref(action, message, {
+          tenantId: input.tenantId,
+          organizationId: input.organizationId,
+          userId: input.userId,
+        }) ?? action.href,
+      }
+    } else {
+      throw new Error('Action has no executable target')
+    }
+
+    if (shouldRecordActionTaken) {
+      await commandBus.execute('messages.actions.record_terminal', {
+        input: {
+          messageId: message.id,
+          actionId: action.id,
+          result,
+          tenantId: input.tenantId,
+          organizationId: input.organizationId,
+          userId: input.userId,
+        },
+        ctx: {
+          container: ctx.container,
+          auth: ctx.auth ?? null,
+          organizationScope: null,
+          selectedOrganizationId: input.organizationId,
+          organizationIds: input.organizationId ? [input.organizationId] : null,
+        },
+      })
+      await emitMessagesEvent(
+        'messages.message.action_taken',
+        {
+          messageId: message.id,
+          actionId: action.id,
+          userId: input.userId,
+          result,
+          tenantId: input.tenantId,
+          organizationId: input.organizationId,
+        },
+        { persistent: true }
+      )
+    }
+
+    return {
+      ok: true,
+      actionId: action.id,
+      result,
+      operationLogEntry,
+    }
+  },
+}
+
+registerCommand(recordTerminalActionCommand)
+registerCommand(executeActionCommand)