@open-mercato/core 0.6.4-develop.4382.1.6b4f656b77 → 0.6.4

package/src/modules/communication_channels/api/post/channels/[id]/test-send/route.ts

@@ -0,0 +1,241 @@
+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 { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CommunicationChannel } from '../../../../../data/entities'
+import { getChannelAdapter } from '../../../../../lib/adapter-registry-singleton'
+import { ChannelAccessDeniedError, assertCanManageChannel } from '../../../../../lib/access-control'
+import { refreshCredentialsIfNeeded } from '../../../../../lib/credential-refresh'
+import { validateRouteMutationGuard } from '../../../../../lib/route-mutation-guard'
+
+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]/test-send',
+  POST: {
+    // Owner self-service: a user may send a test from their OWN mailbox (gated
+    // by `connect_user_channel`). Test-sending from a shared/tenant-wide channel
+    // still requires `manage` — enforced per channel type by `assertCanManageChannel`.
+    requireAuth: true,
+    requireFeatures: ['communication_channels.connect_user_channel'],
+  },
+}
+
+const bodySchema = z.object({
+  to: z.string().email(),
+  subject: z.string().min(1).max(500).optional(),
+  body: z.string().max(50_000).optional(),
+})
+
+type RouteContext = {
+  params: Promise<{ id: string }> | { id: string }
+}
+
+type CredentialsServiceLike = {
+  resolve: (
+    integrationId: string,
+    scope: { organizationId: string; tenantId: string; userId?: string | null },
+  ) => Promise<Record<string, unknown> | null>
+  save?: (
+    integrationId: string,
+    credentials: Record<string, unknown>,
+    scope: { organizationId: string; tenantId: string; userId?: string | null },
+  ) => Promise<void>
+}
+
+/**
+ * Admin diagnostic — send a test message via the adapter without creating a
+ * platform `Message`. Useful for verifying credentials + outbound connectivity
+ * after a channel is configured.
+ *
+ * The result is NOT persisted to `ExternalMessage` / `MessageChannelLink` — it
+ * is a one-shot probe.
+ */
+export async function POST(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?.sub || !auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  let body: z.infer<typeof bodySchema>
+  try {
+    body = bodySchema.parse(await readJsonSafe(req, null))
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Invalid request body' },
+      { status: 422 },
+    )
+  }
+
+  const container = await createRequestContainer()
+  const em = (container.resolve('em') as EntityManager).fork()
+  const organizationId = (auth as { orgId?: string | null }).orgId ?? null
+  const dscope = { tenantId: auth.tenantId as string, organizationId }
+  const channel = await findOneWithDecryption(
+    em,
+    CommunicationChannel,
+    {
+      id,
+      tenantId: auth.tenantId as string,
+      organizationId,
+      deletedAt: null,
+    },
+    undefined,
+    dscope,
+  )
+  if (!channel) {
+    return NextResponse.json({ error: 'Channel not found' }, { status: 404 })
+  }
+  // Load features via RBAC service so admin bypass (`communication_channels.admin`,
+  // wildcards, super-admin) is honoured. The `auth` object from
+  // `getAuthFromRequest` carries identity only — feature ACLs live in the RBAC
+  // service and must be loaded per request.
+  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,
+    })
+    userFeatures = acl?.isSuperAdmin ? ['*'] : Array.isArray(acl?.features) ? acl.features : []
+  } catch {
+    userFeatures = []
+  }
+  try {
+    assertCanManageChannel(
+      { userId: channel.userId },
+      auth.sub as string,
+      userFeatures,
+      'communication_channels.manage',
+    )
+  } catch (err) {
+    if (err instanceof ChannelAccessDeniedError) {
+      return NextResponse.json({ error: 'Channel not found' }, { status: 404 })
+    }
+    const status = (err as { statusCode?: number }).statusCode ?? 403
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Access denied' },
+      { status },
+    )
+  }
+  if (!channel.isActive || channel.status !== 'connected') {
+    return NextResponse.json(
+      { error: `Channel is in status '${channel.status}' (not connected)` },
+      { status: 409 },
+    )
+  }
+
+  const guard = await validateRouteMutationGuard({
+    container,
+    req,
+    auth,
+    input: {
+      resourceKind: 'communication_channels.channel',
+      resourceId: channel.id,
+      operation: 'custom',
+      mutationPayload: body as unknown as Record<string, unknown>,
+    },
+  })
+  if ('response' in guard) return guard.response
+
+  const adapter = getChannelAdapter(channel.providerKey)
+  if (!adapter) {
+    return NextResponse.json(
+      { error: `No adapter registered for provider '${channel.providerKey}'` },
+      { status: 404 },
+    )
+  }
+
+  // Resolve credentials + optionally refresh.
+  let credentials: Record<string, unknown> = {}
+  let credentialsService: CredentialsServiceLike | null = null
+  try {
+    credentialsService = container.resolve('integrationCredentialsService') as CredentialsServiceLike
+  } catch {
+    credentialsService = null
+  }
+  if (channel.credentialsRef && credentialsService) {
+    credentials =
+      (await credentialsService
+        .resolve(`channel_${channel.providerKey}`, {
+          tenantId: auth.tenantId as string,
+          organizationId: organizationId ?? (auth.tenantId as string),
+          userId: channel.userId ?? null,
+        })
+        .catch(() => null)) ?? {}
+  }
+  const credentialScope = {
+    tenantId: auth.tenantId as string,
+    organizationId: organizationId ?? (auth.tenantId as string),
+    userId: channel.userId ?? null,
+  }
+  const refreshed = await refreshCredentialsIfNeeded(
+    {
+      adapter,
+      channelId: channel.id,
+      credentials,
+      scope: credentialScope,
+    },
+    { credentialsService },
+  )
+  credentials = refreshed.credentials
+
+  try {
+    const converted = await adapter.convertOutbound({
+      body: body.body ?? 'Test message from Open Mercato',
+      bodyFormat: 'text',
+    })
+    const result = await adapter.sendMessage({
+      content: converted.content,
+      credentials,
+      scope: {
+        tenantId: auth.tenantId as string,
+        organizationId: organizationId ?? (auth.tenantId as string),
+      },
+      metadata: { to: body.to, subject: body.subject ?? 'Test send', testSend: true },
+    })
+    await guard.afterSuccess()
+    return NextResponse.json({
+      status: result.status,
+      externalMessageId: result.externalMessageId,
+      providerError: result.error ?? null,
+    })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'send failed'
+    return NextResponse.json({ status: 'failed', error: message }, { status: 502 })
+  }
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    POST: {
+      summary: 'Diagnostic — send a test message through the channel without persisting',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 200, description: 'Test send result' },
+        { status: 400, description: 'Invalid channel id' },
+        { status: 401, description: 'Unauthorized' },
+        { status: 403, description: 'Not allowed to manage this channel' },
+        { status: 404, description: 'Channel or adapter not found' },
+        { status: 409, description: 'Channel not connected' },
+        { status: 422, description: 'Invalid request body' },
+        { status: 502, description: 'Provider error' },
+      ],
+    },
+  },
+}
+export default POST

package/src/modules/communication_channels/api/post/channels/connect/credentials/route.ts

@@ -0,0 +1,134 @@
+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_CONNECT_CREDENTIAL_CHANNEL_COMMAND_ID,
+  type ConnectCredentialChannelInput,
+  type ConnectCredentialChannelResult,
+} from '../../../../../commands/connect-credential-channel'
+import { validateRouteMutationGuard } from '../../../../../lib/route-mutation-guard'
+
+export const metadata = {
+  path: '/communication_channels/channels/connect/credentials',
+  POST: {
+    requireAuth: true,
+    requireFeatures: ['communication_channels.connect_user_channel'],
+  },
+}
+
+const bodySchema = z.object({
+  providerKey: z.string().min(1).max(64),
+  displayName: z.string().min(1).max(255),
+  credentials: z.record(z.string(), z.unknown()),
+  pollIntervalSeconds: z.number().int().positive().max(86_400).optional(),
+})
+
+export async function POST(req: Request): Promise<Response> {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub || !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.channel',
+      resourceId: `new:${body.providerKey}`,
+      operation: 'create',
+      mutationPayload: {
+        providerKey: body.providerKey,
+        displayName: body.displayName,
+        pollIntervalSeconds: body.pollIntervalSeconds,
+      },
+    },
+  })
+  if ('response' in guard) return guard.response
+
+  const commandBus = container.resolve('commandBus') as CommandBus
+
+  const input: ConnectCredentialChannelInput = {
+    providerKey: body.providerKey,
+    displayName: body.displayName,
+    credentials: body.credentials,
+    pollIntervalSeconds: body.pollIntervalSeconds,
+    userId: auth.sub as string,
+    scope: {
+      tenantId: auth.tenantId as string,
+      organizationId: (auth as { orgId?: string | null }).orgId ?? null,
+    },
+  }
+  const { result } = await commandBus.execute<
+    ConnectCredentialChannelInput,
+    ConnectCredentialChannelResult
+  >(COMMUNICATION_CHANNELS_CONNECT_CREDENTIAL_CHANNEL_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_adapter') {
+    return NextResponse.json({ error: result.reason }, { status: 404 })
+  }
+  if (result.status === 'validation_failed') {
+    return NextResponse.json({ error: 'Credential validation failed', fieldErrors: result.errors }, { status: 422 })
+  }
+  if (result.status === 'duplicate_mailbox') {
+    return NextResponse.json(
+      {
+        error: `This mailbox is already connected via "${result.existingProviderKey}". Disconnect it there before connecting it again with a different provider.`,
+        code: 'mailbox_already_connected',
+      },
+      { status: 409 },
+    )
+  }
+  await guard.afterSuccess()
+  return NextResponse.json(
+    {
+      channelId: result.channelId,
+      externalIdentifier: result.externalIdentifier,
+    },
+    { status: 201 },
+  )
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    POST: {
+      summary: 'Connect a credential-based per-user channel (IMAP/SMTP)',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 201, description: 'Channel connected' },
+        { status: 401, description: 'Unauthorized' },
+        { status: 404, description: 'Unknown provider' },
+        { status: 409, description: 'Mailbox already connected via another provider' },
+        { status: 422, description: 'Invalid body or credential validation failed' },
+      ],
+    },
+  },
+}
+export default POST

package/src/modules/communication_channels/api/post/messages/[messageId]/reactions/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 { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import {
+  COMMUNICATION_CHANNELS_TOGGLE_OUTBOUND_REACTION_COMMAND_ID,
+  type ToggleOutboundReactionInput,
+  type ToggleOutboundReactionResult,
+} from '../../../../../commands/toggle-outbound-reaction'
+import { validateRouteMutationGuard } from '../../../../../lib/route-mutation-guard'
+
+const bodySchema = z.object({
+  emoji: z.string().min(1).max(64),
+})
+
+export const metadata = {
+  path: '/communication_channels/messages/[messageId]/reactions',
+  POST: {
+    requireAuth: true,
+    requireFeatures: ['communication_channels.react'],
+  },
+}
+
+type RouteContext = {
+  params: Promise<{ messageId: string }> | { messageId: 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 POST(req: Request, context: RouteContext): Promise<Response> {
+  const { messageId } = await context.params
+  if (!messageId || !z.string().uuid().safeParse(messageId).success) {
+    return NextResponse.json({ error: 'Invalid messageId' }, { status: 400 })
+  }
+
+  const auth = context.auth
+  if (!auth?.sub || !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.message',
+      resourceId: messageId,
+      operation: 'custom',
+      mutationPayload: body,
+    },
+  })
+  if ('response' in guard) return guard.response
+
+  const commandBus = container.resolve('commandBus') as CommandBus
+
+  const input: ToggleOutboundReactionInput = {
+    messageId,
+    emoji: body.emoji,
+    action: 'add',
+    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 === 'no_channel_link') {
+    return NextResponse.json({ error: result.reason }, { status: 409 })
+  }
+  if (result.status === 'not_owner') {
+    // Reacting would send from another user's connected account — refuse.
+    return NextResponse.json({ error: result.reason }, { status: 403 })
+  }
+  if (result.status === 'noop') {
+    return NextResponse.json({ error: result.reason }, { status: 409 })
+  }
+  if (result.status === 'added') {
+    await guard.afterSuccess()
+    return NextResponse.json(
+      {
+        id: result.reactionId,
+        messageId: result.messageId,
+        emoji: result.emoji,
+        replaced: result.replaced,
+        enqueued: result.enqueued,
+      },
+      { status: 201 },
+    )
+  }
+  return NextResponse.json({ error: 'Unexpected result' }, { status: 500 })
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    POST: {
+      summary: 'Add a reaction to a channel-linked message',
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 201, description: 'Reaction added' },
+        { status: 400, description: 'Invalid messageId' },
+        { status: 401, description: 'Unauthorized' },
+        { status: 403, description: 'Channel is owned by another user' },
+        { status: 409, description: 'Message not channel-linked or duplicate reaction' },
+        { status: 422, description: 'Invalid request body' },
+      ],
+    },
+  },
+}
+export default POST