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

package/src/modules/communication_channels/api/delete/messages/[messageId]/reactions/[reactionId]/route.ts

@@ -0,0 +1,143 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { CommandBus } from '@open-mercato/shared/lib/commands'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import {
+  COMMUNICATION_CHANNELS_TOGGLE_OUTBOUND_REACTION_COMMAND_ID,
+  type ToggleOutboundReactionInput,
+  type ToggleOutboundReactionResult,
+} from '../../../../../../commands/toggle-outbound-reaction'
+import { MessageReaction } from '../../../../../../data/entities'
+import { validateRouteMutationGuard } from '../../../../../../lib/route-mutation-guard'
+
+export const metadata = {
+  path: '/communication_channels/messages/[messageId]/reactions/[reactionId]',
+  DELETE: {
+    requireAuth: true,
+    requireFeatures: ['communication_channels.react'],
+  },
+}
+
+type RouteContext = {
+  params: Promise<{ messageId: string; reactionId: string }> | { messageId: string; reactionId: string }
+  auth?: {
+    sub?: string
+    tenantId?: string
+    /**
+     * AuthContext (`packages/shared/src/lib/auth/server.ts`) exposes the
+     * selected organization as `orgId`, not `organizationId`. Round-2 F3 fix.
+     */
+    orgId?: string | null
+  } | null
+}
+
+export async function DELETE(_req: Request, context: RouteContext): Promise<Response> {
+  const { messageId, reactionId } = await context.params
+  if (
+    !messageId ||
+    !reactionId ||
+    !z.string().uuid().safeParse(messageId).success ||
+    !z.string().uuid().safeParse(reactionId).success
+  ) {
+    return NextResponse.json({ error: 'Invalid params' }, { status: 400 })
+  }
+
+  const auth = context.auth
+  if (!auth?.sub || !auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const em = (container.resolve('em') as EntityManager).fork()
+  const reaction = await findOneWithDecryption(
+    em,
+    MessageReaction,
+    {
+      id: reactionId,
+      messageId,
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId ?? null,
+    },
+    undefined,
+    { tenantId: auth.tenantId, organizationId: auth.orgId ?? null },
+  )
+  if (!reaction) {
+    return NextResponse.json({ error: 'Reaction not found' }, { status: 404 })
+  }
+
+  const guard = await validateRouteMutationGuard({
+    container,
+    req: _req,
+    auth,
+    input: {
+      resourceKind: 'communication_channels.message',
+      resourceId: messageId,
+      operation: 'custom',
+      mutationPayload: { reactionId, emoji: reaction.emoji, action: 'remove' },
+    },
+  })
+  if ('response' in guard) return guard.response
+
+  const commandBus = container.resolve('commandBus') as CommandBus
+  const input: ToggleOutboundReactionInput = {
+    messageId,
+    emoji: reaction.emoji,
+    action: 'remove',
+    reactionId,
+    reactedByUserId: auth.sub,
+    scope: {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId ?? null,
+    },
+  }
+
+  const { result } = await commandBus.execute<
+    ToggleOutboundReactionInput,
+    ToggleOutboundReactionResult
+  >(COMMUNICATION_CHANNELS_TOGGLE_OUTBOUND_REACTION_COMMAND_ID, {
+    input,
+    ctx: {
+      container,
+      auth: auth as never,
+      organizationScope: null,
+      selectedOrganizationId: auth.orgId ?? null,
+      organizationIds: auth.orgId ? [auth.orgId] : null,
+    },
+  })
+
+  if (result.status === 'noop') {
+    return NextResponse.json({ error: result.reason }, { status: 404 })
+  }
+  if (result.status === 'not_owner') {
+    // The command's ownership gate runs before the remove branch too — surface it
+    // as 403 (matching the POST reactions route) rather than a false 204 success.
+    return NextResponse.json({ error: result.reason }, { status: 403 })
+  }
+  if (result.status === 'no_channel_link') {
+    return NextResponse.json({ error: result.reason }, { status: 409 })
+  }
+  // 'removed'
+  await guard.afterSuccess()
+  return new NextResponse(null, { status: 204 })
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    DELETE: {
+      summary: 'Remove a reaction from a channel-linked message',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 204, description: 'Reaction removed' },
+        { status: 400, description: 'Invalid params' },
+        { status: 401, description: 'Unauthorized' },
+        { status: 403, description: 'Channel is owned by another user' },
+        { status: 404, description: 'Reaction not found or not owned by current user' },
+        { status: 409, description: 'Message not channel-linked' },
+      ],
+    },
+  },
+}
+export default DELETE

package/src/modules/communication_channels/api/get/channels/[id]/health/route.ts

@@ -0,0 +1,173 @@
+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 { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CommunicationChannel, ExternalConversation, MessageChannelLink } from '../../../../../data/entities'
+import { ChannelAccessDeniedError, assertCanAccessChannel } from '../../../../../lib/access-control'
+
+type RbacServiceLike = {
+  loadAcl: (
+    userId: string,
+    scope: { tenantId: string | null; organizationId: string | null },
+  ) => Promise<{ isSuperAdmin: boolean; features: string[]; organizations: string[] | null }>
+}
+
+export const metadata = {
+  path: '/communication_channels/channels/[id]/health',
+  GET: { requireAuth: true, requireFeatures: ['communication_channels.view'] },
+}
+
+type RouteContext = {
+  params: Promise<{ id: string }> | { id: string }
+}
+
+const WINDOW_HOURS = 24
+const RECENT_FAILURES_LIMIT = 10
+
+/**
+ * Channel health snapshot — live aggregates from `message_channel_links` rather
+ * than a dedicated `HealthLog` table.
+ *
+ * Returns counts of `sent` / `failed` / `pending` deliveries in the trailing
+ * 24-hour window, plus the most recent failed links with last-error context.
+ *
+ * Per-user isolation: aggregates are scoped to **this channel only** via the
+ * `external_conversations.channelId` join (a MessageChannelLink does not have a
+ * direct channelId column — the link goes through ExternalConversation). Before
+ * any DB read for aggregates, the channel must pass `assertCanAccessChannel`
+ * so a non-admin caller cannot inspect another user's channel telemetry.
+ */
+export async function GET(req: Request, context: RouteContext): Promise<Response> {
+  const { id } = await context.params
+  if (!z.string().uuid().safeParse(id).success) {
+    return NextResponse.json({ error: 'Invalid channel id' }, { status: 400 })
+  }
+
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const em = (container.resolve('em') as EntityManager).fork()
+
+  const dscope = {
+    tenantId: auth.tenantId as string,
+    organizationId: (auth as { orgId?: string | null }).orgId ?? null,
+  }
+  const channel = await findOneWithDecryption(
+    em,
+    CommunicationChannel,
+    { id, tenantId: auth.tenantId, organizationId: dscope.organizationId, deletedAt: null },
+    undefined,
+    dscope,
+  )
+  if (!channel) {
+    return NextResponse.json({ error: 'Channel not found' }, { status: 404 })
+  }
+
+  let userFeatures: string[] = []
+  try {
+    const rbac = container.resolve('rbacService') as RbacServiceLike
+    const acl = await rbac.loadAcl(auth.sub as string, {
+      tenantId: auth.tenantId as string,
+      organizationId: dscope.organizationId,
+    })
+    userFeatures = acl?.isSuperAdmin ? ['*'] : Array.isArray(acl?.features) ? acl.features : []
+  } catch {
+    userFeatures = []
+  }
+  try {
+    assertCanAccessChannel(channel, auth.sub as string, userFeatures)
+  } catch (err) {
+    if (err instanceof ChannelAccessDeniedError) {
+      return NextResponse.json({ error: 'Channel not found' }, { status: 404 })
+    }
+    throw err
+  }
+
+  // ExternalConversation is append-only on the hub side — no soft-delete column.
+  // Scope by channel + tenant so aggregates stay isolated even when the same
+  // provider is connected by multiple users in the same tenant.
+  const conversations = await findWithDecryption(
+    em,
+    ExternalConversation,
+    { channelId: channel.id, tenantId: auth.tenantId },
+    undefined,
+    dscope,
+  )
+  const conversationIds = conversations.map((c) => c.id).filter(Boolean) as string[]
+
+  let links: MessageChannelLink[] = []
+  let recentFailures: MessageChannelLink[] = []
+  if (conversationIds.length > 0) {
+    const since = new Date(Date.now() - WINDOW_HOURS * 60 * 60 * 1000)
+    links = await findWithDecryption(
+      em,
+      MessageChannelLink,
+      {
+        externalConversationId: { $in: conversationIds },
+        tenantId: auth.tenantId,
+        createdAt: { $gte: since },
+      },
+      undefined,
+      dscope,
+    )
+    recentFailures = await findWithDecryption(
+      em,
+      MessageChannelLink,
+      {
+        externalConversationId: { $in: conversationIds },
+        tenantId: auth.tenantId,
+        deliveryStatus: 'failed',
+      },
+      { limit: RECENT_FAILURES_LIMIT, orderBy: { createdAt: 'desc' } },
+      dscope,
+    )
+  }
+
+  const counts = { sent: 0, delivered: 0, read: 0, failed: 0, pending: 0, queued: 0, other: 0 }
+  for (const link of links) {
+    const key = link.deliveryStatus as keyof typeof counts
+    if (key in counts) counts[key] += 1
+    else counts.other += 1
+  }
+
+  return NextResponse.json({
+    channelId: channel.id,
+    providerKey: channel.providerKey,
+    channelType: channel.channelType,
+    windowHours: WINDOW_HOURS,
+    counts,
+    totalsLast24h: links.length,
+    recentFailures: recentFailures.map((link) => ({
+      id: link.id,
+      messageId: link.messageId,
+      direction: link.direction,
+      createdAt: link.createdAt?.toISOString?.() ?? null,
+      lastError:
+        (link.channelMetadata as Record<string, unknown> | null)?.lastError ?? null,
+      transient:
+        (link.channelMetadata as Record<string, unknown> | null)?.transient ?? null,
+    })),
+  })
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    GET: {
+      summary: 'Snapshot of channel delivery health (last 24h)',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 200, description: 'Health snapshot' },
+        { status: 400, description: 'Invalid channel id' },
+        { status: 401, description: 'Unauthorized' },
+        { status: 404, description: 'Channel not found' },
+      ],
+    },
+  },
+}
+export default GET

package/src/modules/communication_channels/api/get/channels/[id]/route.ts

@@ -0,0 +1,111 @@
+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 { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CommunicationChannel } from '../../../../data/entities'
+import { ChannelAccessDeniedError, assertCanAccessChannel } from '../../../../lib/access-control'
+
+type RbacServiceLike = {
+  loadAcl: (
+    userId: string,
+    scope: { tenantId: string | null; organizationId: string | null },
+  ) => Promise<{ isSuperAdmin: boolean; features: string[]; organizations: string[] | null }>
+}
+
+export const metadata = {
+  path: '/communication_channels/channels/[id]',
+  GET: { requireAuth: true, requireFeatures: ['communication_channels.view'] },
+}
+
+type RouteContext = {
+  params: Promise<{ id: string }> | { id: string }
+}
+
+export async function GET(req: Request, context: RouteContext): Promise<Response> {
+  const { id } = await context.params
+  if (!z.string().uuid().safeParse(id).success) {
+    return NextResponse.json({ error: 'Invalid channel id' }, { status: 400 })
+  }
+
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const em = (container.resolve('em') as EntityManager).fork()
+
+  const channel = await findOneWithDecryption(
+    em,
+    CommunicationChannel,
+    {
+      id,
+      tenantId: auth.tenantId,
+      organizationId: (auth as { orgId?: string | null }).orgId ?? null,
+      deletedAt: null,
+    },
+    undefined,
+    { tenantId: auth.tenantId as string, organizationId: (auth as { orgId?: string | null }).orgId ?? null },
+  )
+  if (!channel) {
+    return NextResponse.json({ error: 'Channel not found' }, { status: 404 })
+  }
+
+  // Per-user access guard: callers without `communication_channels.admin` can
+  // only see tenant-wide channels (userId IS NULL) or channels they own.
+  let userFeatures: string[] = []
+  try {
+    const rbac = container.resolve('rbacService') as RbacServiceLike
+    const acl = await rbac.loadAcl(auth.sub as string, {
+      tenantId: auth.tenantId as string,
+      organizationId: (auth as { orgId?: string | null }).orgId ?? null,
+    })
+    userFeatures = acl?.isSuperAdmin
+      ? ['*']
+      : (Array.isArray(acl?.features) ? acl.features : [])
+  } catch {
+    userFeatures = []
+  }
+  try {
+    assertCanAccessChannel(channel, auth.sub as string, userFeatures)
+  } catch (err) {
+    if (err instanceof ChannelAccessDeniedError) {
+      // 404 (not 403) — don't leak existence of other users' channels.
+      return NextResponse.json({ error: 'Channel not found' }, { status: 404 })
+    }
+    throw err
+  }
+
+  return NextResponse.json({
+    id: channel.id,
+    providerKey: channel.providerKey,
+    channelType: channel.channelType,
+    displayName: channel.displayName,
+    externalIdentifier: channel.externalIdentifier ?? null,
+    credentialsRef: channel.credentialsRef ?? null,
+    capabilities: channel.capabilities ?? null,
+    isActive: channel.isActive,
+    organizationId: channel.organizationId ?? null,
+    createdAt: channel.createdAt?.toISOString?.() ?? null,
+    updatedAt: channel.updatedAt?.toISOString?.() ?? null,
+  })
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    GET: {
+      summary: 'Get a single communication channel by id',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 200, description: 'Channel detail' },
+        { status: 400, description: 'Invalid channel id' },
+        { status: 401, description: 'Unauthorized' },
+        { status: 404, description: 'Channel not found' },
+      ],
+    },
+  },
+}
+export default GET

package/src/modules/communication_channels/api/get/channels/route.ts

@@ -0,0 +1,109 @@
+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 { EntityManager } from '@mikro-orm/postgresql'
+import { findAndCountWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CommunicationChannel } from '../../../data/entities'
+
+export const metadata = {
+  path: '/communication_channels/channels',
+  GET: { requireAuth: true, requireFeatures: ['communication_channels.view'] },
+}
+
+const listQuerySchema = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).default(50),
+  providerKey: z.string().optional(),
+  channelType: z.string().optional(),
+  isActive: z
+    .union([z.literal('true'), z.literal('false')])
+    .optional()
+    .transform((value) => (value === undefined ? undefined : value === 'true')),
+})
+
+export async function GET(req: Request): Promise<Response> {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const url = new URL(req.url)
+  const parsed = listQuerySchema.safeParse(Object.fromEntries(url.searchParams.entries()))
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: 'Invalid query', details: parsed.error.flatten() },
+      { status: 400 },
+    )
+  }
+  const { page, pageSize, providerKey, channelType, isActive } = parsed.data
+
+  const container = await createRequestContainer()
+  const em = (container.resolve('em') as EntityManager).fork()
+
+  // Personal mailbox privacy (v1: strict owner-only). The admin Channels page
+  // lists ONLY shared / tenant-wide channels (WhatsApp Business, shared inboxes,
+  // Slack workspaces) — rows where `user_id IS NULL`. Per-user email mailboxes
+  // (`user_id` set) are private to their owner and surface exclusively on the
+  // profile page (`/api/communication_channels/me/channels`), never here, so no
+  // one — admins included — can see another user's connected personal account.
+  const where: Record<string, unknown> = {
+    tenantId: auth.tenantId,
+    organizationId: (auth as { orgId?: string | null }).orgId ?? null,
+    deletedAt: null,
+    userId: null,
+  }
+  if (providerKey) where.providerKey = providerKey
+  if (channelType) where.channelType = channelType
+  if (isActive !== undefined) where.isActive = isActive
+
+  const [items, total] = await findAndCountWithDecryption(
+    em,
+    CommunicationChannel,
+    where,
+    {
+      limit: pageSize,
+      offset: (page - 1) * pageSize,
+      orderBy: { createdAt: 'desc' },
+    },
+    { tenantId: auth.tenantId as string, organizationId: (auth as { orgId?: string | null }).orgId ?? null },
+  )
+
+  return NextResponse.json({
+    items: items.map(serializeChannel),
+    total,
+    page,
+    pageSize,
+    totalPages: Math.max(1, Math.ceil(total / pageSize)),
+  })
+}
+
+function serializeChannel(channel: CommunicationChannel) {
+  return {
+    id: channel.id,
+    providerKey: channel.providerKey,
+    channelType: channel.channelType,
+    displayName: channel.displayName,
+    externalIdentifier: channel.externalIdentifier ?? null,
+    isActive: channel.isActive,
+    capabilities: channel.capabilities ?? null,
+    createdAt: channel.createdAt?.toISOString?.() ?? null,
+    updatedAt: channel.updatedAt?.toISOString?.() ?? null,
+  }
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    GET: {
+      summary: 'List communication channels for the current tenant',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 200, description: 'Channel list (paginated)' },
+        { status: 400, description: 'Invalid query parameters' },
+        { status: 401, description: 'Unauthorized' },
+      ],
+    },
+  },
+}
+export default GET

package/src/modules/communication_channels/api/get/me/channels/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from 'next/server'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CommunicationChannel } from '../../../../data/entities'
+
+export const metadata = {
+  path: '/communication_channels/me/channels',
+  GET: {
+    requireAuth: true,
+    requireFeatures: ['communication_channels.connect_user_channel'],
+  },
+}
+
+/**
+ * List the current user's owned channels. Used by the profile page.
+ *
+ * Returns the user-scoped subset only (NOT tenant-wide channels). Admin views
+ * of all channels live under `/api/communication_channels/channels` (slice 2e).
+ */
+export async function GET(req: Request): Promise<Response> {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub || !auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const em = (container.resolve('em') as EntityManager).fork()
+
+  const channels = await findWithDecryption(
+    em,
+    CommunicationChannel,
+    {
+      tenantId: auth.tenantId as string,
+      organizationId: (auth as { orgId?: string | null }).orgId ?? null,
+      userId: auth.sub as string,
+      deletedAt: null,
+    },
+    { orderBy: { createdAt: 'desc' } },
+    { tenantId: auth.tenantId as string, organizationId: (auth as { orgId?: string | null }).orgId ?? null },
+  )
+
+  return NextResponse.json({
+    items: (channels as CommunicationChannel[]).map(serialize),
+    total: channels.length,
+  })
+}
+
+function serialize(channel: CommunicationChannel) {
+  // Spec C — expose push status + last push error to the operator UI so
+  // the `PushStatusSection` can render the "Re-register push" affordance.
+  const channelState =
+    (channel.channelState as
+      | { pushStatus?: string; lastPushError?: { code?: string; message?: string; at?: string } | null }
+      | null) ?? null
+  const pushStatus =
+    typeof channelState?.pushStatus === 'string'
+      ? (channelState.pushStatus as 'active' | 'inactive' | 'failed')
+      : null
+  const lastPushError =
+    channelState?.lastPushError && typeof channelState.lastPushError === 'object'
+      ? {
+          code: channelState.lastPushError.code ?? null,
+          message: channelState.lastPushError.message ?? null,
+          at: channelState.lastPushError.at ?? null,
+        }
+      : null
+  return {
+    id: channel.id,
+    providerKey: channel.providerKey,
+    channelType: channel.channelType,
+    displayName: channel.displayName,
+    externalIdentifier: channel.externalIdentifier ?? null,
+    isPrimary: channel.isPrimary,
+    isActive: channel.isActive,
+    status: channel.status,
+    lastError: channel.lastError ?? null,
+    pollIntervalSeconds: channel.pollIntervalSeconds ?? null,
+    lastPolledAt: channel.lastPolledAt?.toISOString?.() ?? null,
+    pushStatus,
+    lastPushError,
+    createdAt: channel.createdAt?.toISOString?.() ?? null,
+  }
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    GET: {
+      summary: 'List the current user\'s connected channels',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 200, description: 'List of user-owned channels' },
+        { status: 401, description: 'Unauthorized' },
+      ],
+    },
+  },
+}
+export default GET