@open-mercato/core 0.6.5-develop.4384.1.ce2ec6eaaa → 0.6.5-develop.4393.1.de282b5dfd

package/src/modules/communication_channels/api/put/threads/[threadId]/assign/route.ts

@@ -0,0 +1,132 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { CommandBus } from '@open-mercato/shared/lib/commands'
+import { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import {
+  COMMUNICATION_CHANNELS_REASSIGN_CONVERSATION_COMMAND_ID,
+  type ReassignConversationInput,
+  type ReassignConversationResult,
+} from '../../../../../commands/reassign-conversation'
+import { validateRouteMutationGuard } from '../../../../../lib/route-mutation-guard'
+
+export const metadata = {
+  path: '/communication_channels/threads/[threadId]/assign',
+  PUT: {
+    requireAuth: true,
+    requireFeatures: ['communication_channels.assign'],
+  },
+}
+
+const bodySchema = z.object({
+  assignedUserId: z.string().uuid().nullable(),
+})
+
+type RouteContext = {
+  params: Promise<{ threadId: string }> | { threadId: string }
+}
+
+export async function PUT(req: Request, context: RouteContext): Promise<Response> {
+  const { threadId } = await context.params
+  if (!z.string().uuid().safeParse(threadId).success) {
+    return NextResponse.json({ error: 'Invalid threadId' }, { status: 400 })
+  }
+
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  let body: z.infer<typeof bodySchema>
+  try {
+    const json = await readJsonSafe(req, null)
+    body = bodySchema.parse(json)
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Invalid request body' },
+      { status: 422 },
+    )
+  }
+
+  const container = await createRequestContainer()
+  const guard = await validateRouteMutationGuard({
+    container,
+    req,
+    auth,
+    input: {
+      resourceKind: 'communication_channels.thread',
+      resourceId: threadId,
+      operation: 'custom',
+      mutationPayload: body,
+    },
+  })
+  if ('response' in guard) return guard.response
+
+  const commandBus = container.resolve('commandBus') as CommandBus
+
+  const input: ReassignConversationInput = {
+    threadId,
+    assignedUserId: body.assignedUserId,
+    scope: {
+      tenantId: auth.tenantId,
+      organizationId: (auth as { orgId?: string | null }).orgId ?? null,
+    },
+  }
+  const { result } = await commandBus.execute<
+    ReassignConversationInput,
+    ReassignConversationResult
+  >(COMMUNICATION_CHANNELS_REASSIGN_CONVERSATION_COMMAND_ID, {
+    input,
+    ctx: {
+      container,
+      auth: auth as never,
+      organizationScope: null,
+      selectedOrganizationId: (auth as { orgId?: string | null }).orgId ?? null,
+      organizationIds: (auth as { orgId?: string | null }).orgId
+        ? [(auth as { orgId?: string | null }).orgId!]
+        : null,
+    },
+  })
+
+  if (result.status === 'no_channel_link') {
+    return NextResponse.json({ error: result.reason }, { status: 404 })
+  }
+  if (result.status === 'invalid_assignee') {
+    return NextResponse.json({ error: result.reason }, { status: 422 })
+  }
+  if (result.status === 'noop') {
+    return NextResponse.json(
+      { threadId, assignedUserId: body.assignedUserId, unchanged: true },
+      { status: 200 },
+    )
+  }
+  await guard.afterSuccess()
+  return NextResponse.json(
+    {
+      threadId: result.threadId,
+      conversationId: result.conversationId,
+      previousAssignedUserId: result.previousAssignedUserId,
+      assignedUserId: result.nextAssignedUserId,
+    },
+    { status: 200 },
+  )
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    PUT: {
+      summary: 'Reassign a channel-linked conversation to a different owner',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 200, description: 'Conversation reassigned (or unchanged)' },
+        { status: 400, description: 'Invalid threadId' },
+        { status: 401, description: 'Unauthorized' },
+        { status: 404, description: 'Conversation not channel-linked' },
+        { status: 422, description: 'Invalid request body' },
+      ],
+    },
+  },
+}
+export default PUT

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

@@ -0,0 +1,34 @@
+import React from 'react'
+
+const channelIcon = React.createElement(
+  'svg',
+  {
+    width: 16,
+    height: 16,
+    viewBox: '0 0 24 24',
+    fill: 'none',
+    stroke: 'currentColor',
+    strokeWidth: 2,
+    strokeLinecap: 'round',
+    strokeLinejoin: 'round',
+  },
+  React.createElement('path', {
+    d: 'M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z',
+  }),
+  React.createElement('circle', { cx: 12, cy: 11, r: 1 }),
+  React.createElement('circle', { cx: 7, cy: 11, r: 1 }),
+  React.createElement('circle', { cx: 17, cy: 11, r: 1 }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['communication_channels.view'],
+  pageTitle: 'Channel Detail',
+  pageTitleKey: 'communication_channels.detail.title',
+  icon: channelIcon,
+  navHidden: true,
+  breadcrumb: [
+    { label: 'Communication Channels', labelKey: 'communication_channels.nav.title', href: '/backend/communication_channels/channels' },
+    { label: 'Channel detail', labelKey: 'communication_channels.detail.title' },
+  ],
+} as const

package/src/modules/communication_channels/backend/communication_channels/channels/[id]/page.tsx

@@ -0,0 +1,250 @@
+'use client'
+
+import * as React from 'react'
+import { useParams } from 'next/navigation'
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { LoadingMessage, ErrorMessage, RecordNotFoundState } from '@open-mercato/ui/backend/detail'
+import { Tag } from '@open-mercato/ui/primitives/tag'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+
+type ChannelDetail = {
+  id: string
+  providerKey: string
+  channelType: string
+  displayName: string
+  externalIdentifier: string | null
+  capabilities: Record<string, unknown> | null
+  isActive: boolean
+}
+
+type ChannelHealth = {
+  channelId: string
+  providerKey: string
+  channelType: string
+  windowHours: number
+  totalsLast24h: number
+  counts: Record<string, number>
+  recentFailures: Array<{
+    id: string
+    messageId: string
+    direction: string
+    createdAt: string | null
+    lastError: string | null
+    transient: boolean | null
+  }>
+}
+
+export default function ChannelDetailPage() {
+  const t = useT()
+  const params = useParams<{ id: string }>()
+  const id = (params?.id as string) ?? ''
+
+  const [detail, setDetail] = React.useState<ChannelDetail | null>(null)
+  const [health, setHealth] = React.useState<ChannelHealth | null>(null)
+  const [isLoading, setIsLoading] = React.useState(true)
+  const [errorMessage, setErrorMessage] = React.useState<string | null>(null)
+  const [notFound, setNotFound] = React.useState(false)
+
+  React.useEffect(() => {
+    if (!id) return
+    let cancelled = false
+    async function load() {
+      setIsLoading(true)
+      setErrorMessage(null)
+      setNotFound(false)
+      const [detailRes, healthRes] = await Promise.all([
+        apiCall<ChannelDetail>(`/api/communication_channels/channels/${encodeURIComponent(id)}`),
+        apiCall<ChannelHealth>(`/api/communication_channels/channels/${encodeURIComponent(id)}/health`),
+      ]).catch((err: unknown) => {
+        return [
+          { ok: false, result: { error: err instanceof Error ? err.message : 'load failed' } },
+          { ok: false, result: { error: err instanceof Error ? err.message : 'load failed' } },
+        ] as const
+      })
+      if (cancelled) return
+      if (!detailRes.ok) {
+        const status = (detailRes as { status?: number }).status
+        if (status === 404) {
+          setNotFound(true)
+        } else {
+          const body = detailRes.result as { error?: string } | undefined
+          setErrorMessage(
+            body?.error ?? t('communication_channels.errors.loadDetail', 'Failed to load channel'),
+          )
+        }
+        setDetail(null)
+        setHealth(null)
+      } else {
+        setDetail(detailRes.result ?? null)
+        setHealth(healthRes.ok ? (healthRes.result ?? null) : null)
+      }
+      setIsLoading(false)
+    }
+    void load()
+    return () => {
+      cancelled = true
+    }
+  }, [id, t])
+
+  if (isLoading) {
+    return (
+      <Page>
+        <PageBody>
+          <LoadingMessage label={t('communication_channels.detail.loading', 'Loading channel...')} />
+        </PageBody>
+      </Page>
+    )
+  }
+  if (notFound) {
+    return (
+      <Page>
+        <PageBody>
+          <RecordNotFoundState
+            label={t('communication_channels.detail.notFound', 'Channel not found')}
+            backHref="/backend/communication_channels/channels"
+          />
+        </PageBody>
+      </Page>
+    )
+  }
+  if (errorMessage || !detail) {
+    return (
+      <Page>
+        <PageBody>
+          <ErrorMessage
+            label={errorMessage ?? t('communication_channels.errors.loadDetail', 'Failed to load channel')}
+          />
+        </PageBody>
+      </Page>
+    )
+  }
+
+  const capabilities = (detail.capabilities ?? {}) as Record<string, unknown>
+  const capabilityKeys = Object.keys(capabilities)
+
+  return (
+    <Page>
+      <PageBody>
+        <header className="mb-4 flex flex-wrap items-baseline justify-between gap-4">
+          <div>
+            <h2 className="text-2xl font-semibold">{detail.displayName}</h2>
+            <p className="text-sm text-muted-foreground">
+              {detail.providerKey} · {detail.channelType}
+              {detail.externalIdentifier ? ` · ${detail.externalIdentifier}` : ''}
+            </p>
+          </div>
+          {detail.isActive ? (
+            <Tag variant="success" dot>
+              {t('communication_channels.status.active', 'Active')}
+            </Tag>
+          ) : (
+            <Tag variant="neutral">{t('communication_channels.status.inactive', 'Inactive')}</Tag>
+          )}
+        </header>
+
+        <section
+          className="mb-4 rounded-md border bg-card p-4"
+          aria-label={t('communication_channels.detail.capabilities', 'Capabilities')}
+        >
+          <header className="mb-2 text-overline text-muted-foreground">
+            {t('communication_channels.detail.capabilities', 'Capabilities')}
+          </header>
+          {capabilityKeys.length === 0 ? (
+            <p className="text-sm text-muted-foreground">
+              {t(
+                'communication_channels.detail.noCapabilities',
+                'No capabilities snapshot recorded for this channel yet.',
+              )}
+            </p>
+          ) : (
+            <dl className="grid grid-cols-2 gap-x-6 gap-y-1 text-sm md:grid-cols-3">
+              {capabilityKeys.sort().map((key) => (
+                <React.Fragment key={key}>
+                  <dt className="text-muted-foreground">{key}</dt>
+                  <dd className="md:col-span-2">{renderCapabilityValue(capabilities[key])}</dd>
+                </React.Fragment>
+              ))}
+            </dl>
+          )}
+        </section>
+
+        <section
+          className="rounded-md border bg-card p-4"
+          aria-label={t('communication_channels.detail.health', 'Delivery health (last 24h)')}
+        >
+          <header className="mb-2 flex items-baseline justify-between text-overline text-muted-foreground">
+            <span>{t('communication_channels.detail.health', 'Delivery health (last 24h)')}</span>
+            {health ? (
+              <span className="text-xs">
+                {health.totalsLast24h}{' '}
+                {t('communication_channels.detail.messages', 'messages')}
+              </span>
+            ) : null}
+          </header>
+          {health ? (
+            <>
+              <ul className="mb-3 flex flex-wrap gap-2 text-xs">
+                {Object.entries(health.counts).map(([status, count]) => (
+                  <li key={status}>
+                    <Tag variant={tagVariantForStatus(status)}>
+                      {status}: {count}
+                    </Tag>
+                  </li>
+                ))}
+              </ul>
+              {health.recentFailures.length > 0 ? (
+                <details>
+                  <summary className="cursor-pointer text-sm text-muted-foreground">
+                    {t('communication_channels.detail.recentFailures', 'Recent failures')} (
+                    {health.recentFailures.length})
+                  </summary>
+                  <ul className="mt-2 space-y-1 text-xs">
+                    {health.recentFailures.map((failure) => (
+                      <li key={failure.id} className="rounded border bg-muted p-2">
+                        <div className="font-mono text-xs text-muted-foreground">
+                          {failure.messageId} · {failure.direction} ·{' '}
+                          {failure.createdAt ?? '—'}
+                        </div>
+                        {failure.lastError ? (
+                          <div className="mt-1">{failure.lastError}</div>
+                        ) : null}
+                      </li>
+                    ))}
+                  </ul>
+                </details>
+              ) : null}
+            </>
+          ) : (
+            <p className="text-sm text-muted-foreground">
+              {t('communication_channels.detail.noHealth', 'No health data available.')}
+            </p>
+          )}
+        </section>
+      </PageBody>
+    </Page>
+  )
+}
+
+function renderCapabilityValue(value: unknown): string {
+  if (value === null || value === undefined) return '—'
+  if (Array.isArray(value)) return value.join(', ')
+  if (typeof value === 'object') return JSON.stringify(value)
+  return String(value)
+}
+
+function tagVariantForStatus(status: string): 'success' | 'warning' | 'error' | 'info' | 'neutral' {
+  switch (status) {
+    case 'sent':
+    case 'delivered':
+    case 'read':
+      return 'success'
+    case 'failed':
+      return 'error'
+    case 'pending':
+    case 'queued':
+      return 'warning'
+    default:
+      return 'neutral'
+  }
+}

package/src/modules/communication_channels/backend/communication_channels/channels/page.meta.ts

@@ -0,0 +1,36 @@
+import React from 'react'
+
+const channelsIcon = React.createElement(
+  'svg',
+  {
+    width: 16,
+    height: 16,
+    viewBox: '0 0 24 24',
+    fill: 'none',
+    stroke: 'currentColor',
+    strokeWidth: 2,
+    strokeLinecap: 'round',
+    strokeLinejoin: 'round',
+  },
+  React.createElement('path', {
+    d: 'M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z',
+  }),
+  React.createElement('circle', { cx: 12, cy: 11, r: 1 }),
+  React.createElement('circle', { cx: 7, cy: 11, r: 1 }),
+  React.createElement('circle', { cx: 17, cy: 11, r: 1 }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['communication_channels.view'],
+  pageTitle: 'Communication Channels',
+  pageTitleKey: 'communication_channels.nav.title',
+  pageGroup: 'Integrations',
+  pageGroupKey: 'communication_channels.nav.group',
+  pageOrder: 90,
+  icon: channelsIcon,
+  pageContext: 'main' as const,
+  breadcrumb: [
+    { label: 'Communication Channels', labelKey: 'communication_channels.nav.title' },
+  ],
+} as const

package/src/modules/communication_channels/backend/communication_channels/channels/page.tsx

@@ -0,0 +1,137 @@
+'use client'
+
+import * as React from 'react'
+import type { ColumnDef } from '@tanstack/react-table'
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { DataTable } from '@open-mercato/ui/backend/DataTable'
+import { Tag } from '@open-mercato/ui/primitives/tag'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+
+type ChannelRow = {
+  id: string
+  providerKey: string
+  channelType: string
+  displayName: string
+  externalIdentifier: string | null
+  isActive: boolean
+  capabilities: Record<string, unknown> | null
+  createdAt: string | null
+}
+
+type ChannelListResponse = {
+  items?: ChannelRow[]
+  total?: number
+  totalPages?: number
+}
+
+export default function ChannelsListPage() {
+  const t = useT()
+  const [rows, setRows] = React.useState<ChannelRow[]>([])
+  const [total, setTotal] = React.useState(0)
+  const [totalPages, setTotalPages] = React.useState(1)
+  const [page, setPage] = React.useState(1)
+  const [isLoading, setIsLoading] = React.useState(true)
+  const [errorMessage, setErrorMessage] = React.useState<string | null>(null)
+  const pageSize = 50
+
+  React.useEffect(() => {
+    let cancelled = false
+    async function load() {
+      setIsLoading(true)
+      setErrorMessage(null)
+      const response = await apiCall<ChannelListResponse>(
+        `/api/communication_channels/channels?page=${page}&pageSize=${pageSize}`,
+      ).catch((err: unknown) => {
+        return {
+          ok: false,
+          result: { error: err instanceof Error ? err.message : 'Failed to load channels' },
+        }
+      })
+      if (cancelled) return
+      if (!response.ok) {
+        const errBody = response.result as { error?: string } | undefined
+        setErrorMessage(
+          errBody?.error ?? t('communication_channels.errors.loadList', 'Failed to load channels'),
+        )
+        setRows([])
+        setTotal(0)
+        setTotalPages(1)
+      } else {
+        const data = (response.result ?? {}) as ChannelListResponse
+        setRows(Array.isArray(data.items) ? data.items : [])
+        setTotal(typeof data.total === 'number' ? data.total : 0)
+        setTotalPages(typeof data.totalPages === 'number' ? data.totalPages : 1)
+      }
+      setIsLoading(false)
+    }
+    void load()
+    return () => {
+      cancelled = true
+    }
+  }, [page, t])
+
+  const columns = React.useMemo<ColumnDef<ChannelRow>[]>(
+    () => [
+      {
+        header: t('communication_channels.columns.displayName', 'Channel'),
+        accessorKey: 'displayName',
+      },
+      {
+        header: t('communication_channels.columns.provider', 'Provider'),
+        accessorKey: 'providerKey',
+      },
+      {
+        header: t('communication_channels.columns.type', 'Type'),
+        accessorKey: 'channelType',
+      },
+      {
+        header: t('communication_channels.columns.identifier', 'External ID'),
+        accessorKey: 'externalIdentifier',
+        cell: ({ row }) => row.original.externalIdentifier ?? '—',
+        meta: { truncate: true, maxWidth: 240 },
+      },
+      {
+        header: t('communication_channels.columns.status', 'Status'),
+        accessorKey: 'isActive',
+        cell: ({ row }) =>
+          row.original.isActive ? (
+            <Tag variant="success" dot>
+              {t('communication_channels.status.active', 'Active')}
+            </Tag>
+          ) : (
+            <Tag variant="neutral">
+              {t('communication_channels.status.inactive', 'Inactive')}
+            </Tag>
+          ),
+      },
+    ],
+    [t],
+  )
+
+  return (
+    <Page>
+      <PageBody>
+        <DataTable<ChannelRow>
+          title={t('communication_channels.nav.title', 'Communication Channels')}
+          extensionTableId="communication_channels.channels"
+          columns={columns}
+          data={rows}
+          isLoading={isLoading}
+          error={errorMessage}
+          emptyState={t(
+            'communication_channels.emptyState',
+            'No shared channels yet. This page lists shared, tenant-wide channels. Your personal email mailbox is private — connect and manage it under Profile → Communication Channels.',
+          )}
+          pagination={{
+            page,
+            pageSize,
+            total,
+            totalPages,
+            onPageChange: setPage,
+          }}
+        />
+      </PageBody>
+    </Page>
+  )
+}

package/src/modules/communication_channels/backend/profile/communication-channels/page.meta.ts

@@ -0,0 +1,36 @@
+import React from 'react'
+
+const channelsIcon = React.createElement(
+  'svg',
+  {
+    width: 16,
+    height: 16,
+    viewBox: '0 0 24 24',
+    fill: 'none',
+    stroke: 'currentColor',
+    strokeWidth: 2,
+    strokeLinecap: 'round',
+    strokeLinejoin: 'round',
+  },
+  React.createElement('path', { d: 'M3 5h18l-2 3v6l2 3H3l2-3V8L3 5z' }),
+  React.createElement('path', { d: 'M3 5l9 7 9-7' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['communication_channels.connect_user_channel'],
+  pageTitle: 'My communication channels',
+  pageTitleKey: 'communication_channels.profile.title',
+  pageGroup: 'Profile',
+  pageGroupKey: 'communication_channels.profile.group',
+  pageOrder: 20,
+  icon: channelsIcon,
+  pageContext: 'profile' as const,
+  breadcrumb: [
+    { label: 'Profile', labelKey: 'communication_channels.profile.group' },
+    {
+      label: 'My communication channels',
+      labelKey: 'communication_channels.profile.title',
+    },
+  ],
+} as const