@open-mercato/core 0.6.6-develop.6126.1.0b9392fdae → 0.6.6-develop.6133.1.f01540250e

package/src/modules/communication_channels/data/enrichers.ts

@@ -8,75 +8,27 @@ import {
   MessageReaction,
 } from './entities'
 
-/**
- * Resolve channels by `id` (not `providerKey`) — multi-user channels share the
- * same `providerKey` (e.g. two users with Gmail), so a providerKey-keyed Map
- * collapses them and returns the wrong owner's capabilities snapshot. The hop
- * goes `MessageChannelLink → ExternalConversation → CommunicationChannel`.
- *
- * Returns a Map keyed by the platform Message id so enrichers can read
- * `channelByMessageId.get(record.id)` without further joins.
- */
-async function resolveChannelsByMessageId(
-  em: EntityManager,
-  links: MessageChannelLink[],
-  tenantId: string,
-  organizationId: string | null,
-): Promise<Map<string, CommunicationChannel>> {
-  if (links.length === 0) return new Map()
-  const conversationIds = Array.from(
-    new Set(
-      links.map((l) => (l as { externalConversationId?: string }).externalConversationId).filter(
-        (id): id is string => typeof id === 'string' && id.length > 0,
-      ),
-    ),
-  )
-  if (conversationIds.length === 0) return new Map()
-  const dscope = { tenantId, organizationId }
-  const conversations = await findWithDecryption(
-    em,
-    ExternalConversation,
-    { id: { $in: conversationIds }, tenantId, organizationId },
-    undefined,
-    dscope,
-  )
-  const channelIdByConversation = new Map<string, string>()
-  for (const conv of conversations) {
-    channelIdByConversation.set(conv.id, conv.channelId)
-  }
-  const channelIds = Array.from(new Set(Array.from(channelIdByConversation.values())))
-  if (channelIds.length === 0) return new Map()
-  const channels = await findWithDecryption(
-    em,
-    CommunicationChannel,
-    { id: { $in: channelIds }, tenantId, organizationId, deletedAt: null },
-    undefined,
-    dscope,
-  )
-  const channelsById = new Map<string, CommunicationChannel>(
-    channels.map((c) => [c.id, c]),
-  )
-  const result = new Map<string, CommunicationChannel>()
-  for (const link of links) {
-    const channelId = link.externalConversationId
-      ? channelIdByConversation.get(link.externalConversationId)
-      : undefined
-    const channel = channelId ? channelsById.get(channelId) : undefined
-    if (channel) result.set(link.messageId, channel)
-  }
-  return result
-}
-
 /**
  * Response enrichers for the messages.message entity.
  *
- * The hub declares 4 enrichers; downstream hosts (Messages module's `/api/messages`
+ * The hub declares 2 enrichers; downstream hosts (Messages module's `/api/messages`
  * CRUD route + future provider routes) opt in via `makeCrudRoute({ enrichers: { entityId: 'messages.message' } })`.
  *
+ *   - `messageChannelEnricher` → `_channel`, `_channelPayload`, `_channelContact`
+ *   - `messageReactionsEnricher` → `_reactions`
+ *
+ * The channel/payload/contact enrichments were three separate enrichers, each
+ * independently issuing its own `MessageChannelLink` `$in` query (and two of them
+ * an `ExternalConversation` query) for the same message page. Because the shared
+ * enricher runner executes active enrichers sequentially with no per-pass shared
+ * context, those lookups were repeated for every page (#3183). They are merged
+ * into one batched enricher so the link batch (and the conversation batch) is
+ * loaded once per pass, while preserving the public enriched field names:
+ *
  *   - `_channel`           → channel metadata + capabilities snapshot
  *   - `_channelPayload`    → channel-native payload (Block Kit / interactive / email MIME / …)
- *   - `_reactions`         → grouped emoji counts + users + reactedByMe
  *   - `_channelContact`    → CRM person preview (email + display name)
+ *   - `_reactions`         → grouped emoji counts + users + reactedByMe
  *
  * Per `packages/shared/lib/crud/response-enricher` rules:
  *   - `enrichMany` is implemented for every enricher (N+1 prevention).
@@ -98,15 +50,43 @@ function ctxEm(ctx: EnricherContext): EntityManager {
   return ctx.em as EntityManager
 }
 
-// ── _channel ────────────────────────────────────────────────────────────────
+export type ChannelEnrichment = {
+  providerKey: string
+  channelType: string
+  direction: 'inbound' | 'outbound' | string
+  deliveryStatus: string | null
+  capabilities: Record<string, unknown> | null
+}
 
-const messageChannelEnricher: ResponseEnricher<MessageRecord, { _channel?: ChannelEnrichment | null }> = {
+export type ChannelPayloadEnrichment = {
+  channelContentType: string | null
+  channelPayload: Record<string, unknown> | null
+  interactiveState: Record<string, unknown> | null
+  channelMetadata: Record<string, unknown> | null
+}
+
+export type ChannelContactEnrichment = {
+  contactPersonId: string | null
+  assignedUserId: string | null
+  subject: string | null
+}
+
+// ── _channel + _channelPayload + _channelContact ──────────────────────────────
+
+const messageChannelEnricher: ResponseEnricher<
+  MessageRecord,
+  {
+    _channel?: ChannelEnrichment | null
+    _channelPayload?: ChannelPayloadEnrichment | null
+    _channelContact?: ChannelContactEnrichment | null
+  }
+> = {
   id: 'communication_channels.message-channel',
   targetEntity: 'messages.message',
   features: ['communication_channels.view'],
   priority: 30,
-  timeout: 1500,
-  fallback: { _channel: null },
+  timeout: 2000,
+  fallback: { _channel: null, _channelPayload: null, _channelContact: null },
   critical: false,
 
   async enrichOne(record, ctx) {
@@ -118,117 +98,127 @@ const messageChannelEnricher: ResponseEnricher<MessageRecord, { _channel?: Chann
     if (records.length === 0) return records
     const messageIds = records.map((r) => r.id)
     const em = ctxEm(ctx)
-    const dscope = { tenantId: ctx.tenantId, organizationId: ctx.organizationId ?? null }
+    const tenantId = ctx.tenantId as string
+    const organizationId = ctx.organizationId ?? null
+    const dscope = { tenantId, organizationId }
+
+    // 1) MessageChannelLink — one bounded `$in` query for the whole page, shared by
+    // all three enrichments (channel metadata, channel payload, conversation
+    // contact). The result set is already bounded by the `messageId $in messageIds`
+    // filter (the host list endpoint caps the page at 100), so no separate row
+    // limit is needed.
     const links = await findWithDecryption(
       em,
       MessageChannelLink,
       {
         messageId: { $in: messageIds },
-        tenantId: ctx.tenantId,
-        organizationId: ctx.organizationId ?? null,
+        tenantId,
+        organizationId,
       },
-      // Result set is already bounded by the `messageId $in messageIds` filter
-      // (the host list endpoint caps the page at 100), matching the other
-      // enrichers — no separate row limit needed.
       undefined,
       dscope,
     )
+    const linksByMessage = new Map<string, MessageChannelLink>()
+    for (const link of links) linksByMessage.set(link.messageId, link)
 
-    // Resolve channels via the `link → ExternalConversation → CommunicationChannel`
-    // path. Keys are platform Message ids — direct mapping per row.
-    const channelByMessageId = await resolveChannelsByMessageId(
-      em,
-      links,
-      ctx.tenantId as string,
-      ctx.organizationId ?? null,
+    // 2) ExternalConversation — one query, shared by the channel-capabilities hop and
+    // the conversation-contact enrichment.
+    const conversationIds = Array.from(
+      new Set(
+        links
+          .map((l) => l.externalConversationId)
+          .filter((id): id is string => typeof id === 'string' && id.length > 0),
+      ),
     )
+    const conversationsById = new Map<string, ExternalConversation>()
+    if (conversationIds.length > 0) {
+      const conversations = await findWithDecryption(
+        em,
+        ExternalConversation,
+        { id: { $in: conversationIds }, tenantId, organizationId },
+        undefined,
+        dscope,
+      )
+      for (const conversation of conversations) {
+        conversationsById.set(conversation.id, conversation)
+      }
+    }
 
-    const linksByMessage = new Map<string, MessageChannelLink>()
-    for (const link of links) linksByMessage.set(link.messageId, link)
+    // 3) CommunicationChannel — capabilities snapshot. Resolve by `id` (not
+    // `providerKey`): multi-user channels share the same `providerKey` (e.g. two
+    // users with Gmail), so a providerKey-keyed map collapses them and returns the
+    // wrong owner's capabilities. The hop is `link → ExternalConversation → CommunicationChannel`.
+    const channelIds = Array.from(
+      new Set(
+        Array.from(conversationsById.values())
+          .map((conversation) => conversation.channelId)
+          .filter((id): id is string => typeof id === 'string' && id.length > 0),
+      ),
+    )
+    const channelsById = new Map<string, CommunicationChannel>()
+    if (channelIds.length > 0) {
+      const channels = await findWithDecryption(
+        em,
+        CommunicationChannel,
+        { id: { $in: channelIds }, tenantId, organizationId, deletedAt: null },
+        undefined,
+        dscope,
+      )
+      for (const channel of channels) channelsById.set(channel.id, channel)
+    }
+
+    const channelByMessageId = new Map<string, CommunicationChannel>()
+    for (const link of links) {
+      if (!link.externalConversationId) continue
+      const conversation = conversationsById.get(link.externalConversationId)
+      if (!conversation) continue
+      const channel = conversation.channelId ? channelsById.get(conversation.channelId) : undefined
+      if (channel) channelByMessageId.set(link.messageId, channel)
+    }
 
     return records.map((r) => {
       const link = linksByMessage.get(r.id)
-      if (!link) return { ...r, _channel: null }
+      if (!link) {
+        return { ...r, _channel: null, _channelPayload: null, _channelContact: null }
+      }
+
       const channel = channelByMessageId.get(r.id)
-      const enrichment: ChannelEnrichment = {
+      const channelEnrichment: ChannelEnrichment = {
         providerKey: link.providerKey,
         channelType: link.channelType,
         direction: link.direction,
         deliveryStatus: link.deliveryStatus ?? null,
         capabilities: (channel?.capabilities as Record<string, unknown> | null) ?? null,
       }
-      return { ...r, _channel: enrichment }
-    })
-  },
-}
-
-export type ChannelEnrichment = {
-  providerKey: string
-  channelType: string
-  direction: 'inbound' | 'outbound' | string
-  deliveryStatus: string | null
-  capabilities: Record<string, unknown> | null
-}
-
-// ── _channelPayload ─────────────────────────────────────────────────────────
 
-const messageChannelPayloadEnricher: ResponseEnricher<
-  MessageRecord,
-  { _channelPayload?: ChannelPayloadEnrichment | null }
-> = {
-  id: 'communication_channels.message-channel-payload',
-  targetEntity: 'messages.message',
-  features: ['communication_channels.view'],
-  priority: 20,
-  timeout: 1500,
-  fallback: { _channelPayload: null },
-  critical: false,
-
-  async enrichOne(record, ctx) {
-    const [out] = await this.enrichMany!([record], ctx)
-    return out
-  },
-
-  async enrichMany(records, ctx) {
-    if (records.length === 0) return records
-    const messageIds = records.map((r) => r.id)
-    const em = ctxEm(ctx)
-    const dscope = { tenantId: ctx.tenantId, organizationId: ctx.organizationId ?? null }
-    const links = await findWithDecryption(
-      em,
-      MessageChannelLink,
-      {
-        messageId: { $in: messageIds },
-        tenantId: ctx.tenantId,
-        organizationId: ctx.organizationId ?? null,
-      },
-      undefined,
-      dscope,
-    )
-    const byMessage = new Map<string, MessageChannelLink>()
-    for (const link of links) byMessage.set(link.messageId, link)
-
-    return records.map((r) => {
-      const link = byMessage.get(r.id)
-      if (!link) return { ...r, _channelPayload: null }
-      const enrichment: ChannelPayloadEnrichment = {
+      const payloadEnrichment: ChannelPayloadEnrichment = {
         channelContentType: link.channelContentType ?? null,
         channelPayload: link.channelPayload ?? null,
         interactiveState: link.interactiveState ?? null,
         channelMetadata: link.channelMetadata ?? null,
       }
-      return { ...r, _channelPayload: enrichment }
+
+      const conversation = link.externalConversationId
+        ? conversationsById.get(link.externalConversationId)
+        : undefined
+      const contactEnrichment: ChannelContactEnrichment | null = conversation
+        ? {
+            contactPersonId: conversation.contactPersonId ?? null,
+            assignedUserId: conversation.assignedUserId ?? null,
+            subject: conversation.subject ?? null,
+          }
+        : null
+
+      return {
+        ...r,
+        _channel: channelEnrichment,
+        _channelPayload: payloadEnrichment,
+        _channelContact: contactEnrichment,
+      }
     })
   },
 }
 
-export type ChannelPayloadEnrichment = {
-  channelContentType: string | null
-  channelPayload: Record<string, unknown> | null
-  interactiveState: Record<string, unknown> | null
-  channelMetadata: Record<string, unknown> | null
-}
-
 // ── _reactions ──────────────────────────────────────────────────────────────
 
 const messageReactionsEnricher: ResponseEnricher<
@@ -323,91 +313,11 @@ function groupReactions(rows: MessageReaction[], currentUserId: string): Reactio
   return Array.from(map.values()).sort((a, b) => b.count - a.count)
 }
 
-// ── _channelContact ─────────────────────────────────────────────────────────
-
-const conversationContactEnricher: ResponseEnricher<
-  MessageRecord,
-  { _channelContact?: ChannelContactEnrichment | null }
-> = {
-  id: 'communication_channels.conversation-contact',
-  targetEntity: 'messages.message',
-  features: ['communication_channels.view'],
-  priority: 15,
-  timeout: 2000,
-  fallback: { _channelContact: null },
-  critical: false,
-
-  async enrichOne(record, ctx) {
-    const [out] = await this.enrichMany!([record], ctx)
-    return out
-  },
-
-  async enrichMany(records, ctx) {
-    if (records.length === 0) return records
-    const messageIds = records.map((r) => r.id)
-    const em = ctxEm(ctx)
-    const dscope = { tenantId: ctx.tenantId, organizationId: ctx.organizationId ?? null }
-    const links = await findWithDecryption(
-      em,
-      MessageChannelLink,
-      {
-        messageId: { $in: messageIds },
-        tenantId: ctx.tenantId,
-        organizationId: ctx.organizationId ?? null,
-      },
-      undefined,
-      dscope,
-    )
-    const conversationIds = Array.from(
-      new Set(links.map((l) => l.externalConversationId).filter(Boolean)),
-    )
-    let conversationsById = new Map<string, ExternalConversation>()
-    if (conversationIds.length > 0) {
-      const conversations = await findWithDecryption(
-        em,
-        ExternalConversation,
-        {
-          id: { $in: conversationIds },
-          tenantId: ctx.tenantId,
-          organizationId: ctx.organizationId ?? null,
-        },
-        undefined,
-        dscope,
-      )
-      conversationsById = new Map(conversations.map((c) => [c.id, c]))
-    }
-
-    const linksByMessage = new Map<string, MessageChannelLink>()
-    for (const link of links) linksByMessage.set(link.messageId, link)
-
-    return records.map((r) => {
-      const link = linksByMessage.get(r.id)
-      if (!link) return { ...r, _channelContact: null }
-      const conversation = conversationsById.get(link.externalConversationId)
-      if (!conversation) return { ...r, _channelContact: null }
-      const enrichment: ChannelContactEnrichment = {
-        contactPersonId: conversation.contactPersonId ?? null,
-        assignedUserId: conversation.assignedUserId ?? null,
-        subject: conversation.subject ?? null,
-      }
-      return { ...r, _channelContact: enrichment }
-    })
-  },
-}
-
-export type ChannelContactEnrichment = {
-  contactPersonId: string | null
-  assignedUserId: string | null
-  subject: string | null
-}
-
 // ── Export ──────────────────────────────────────────────────────────────────
 
 export const enrichers: ResponseEnricher[] = [
   messageChannelEnricher as unknown as ResponseEnricher,
-  messageChannelPayloadEnricher as unknown as ResponseEnricher,
   messageReactionsEnricher as unknown as ResponseEnricher,
-  conversationContactEnricher as unknown as ResponseEnricher,
 ]
 
 export default enrichers

package/src/modules/configs/components/CachePanel.tsx

@@ -8,6 +8,9 @@ import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuarde
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
+import { hasFeature } from '@open-mercato/shared/security/features'
+
+const MANAGE_FEATURE = 'configs.cache.manage'
 
 const API_PATH = '/api/configs/cache'
 const CACHE_MUTATION_CONTEXT_ID = 'configs-cache-panel'
@@ -87,7 +90,7 @@ export function CachePanel() {
           {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ features: ['configs.cache.manage'] }),
+            body: JSON.stringify({ features: [MANAGE_FEATURE] }),
           },
           {
             errorMessage: t('configs.cache.loadError', 'Failed to load cache statistics.'),
@@ -98,8 +101,8 @@ export function CachePanel() {
         const granted = Array.isArray(payload?.granted)
           ? (payload.granted as unknown[]).filter((feature) => typeof feature === 'string') as string[]
           : []
-        const hasFeature = payload?.ok === true || granted.includes('configs.cache.manage')
-        setCanManage(hasFeature)
+        const canManageFeature = payload?.ok === true || hasFeature(granted, MANAGE_FEATURE)
+        setCanManage(canManageFeature)
       } catch {
         if (!cancelled) setCanManage(false)
       } finally {

package/src/modules/feature_toggles/api/openapi.ts

@@ -7,6 +7,7 @@ import {
     overrideListQuerySchema,
     getToggleOverrideQuerySchema,
     featureToggleOverrideResponseSchema,
+    overrideRowIdSchema,
 } from '../data/validators'
 
 export const featureTogglesTag = 'Feature Toggles'
@@ -42,16 +43,20 @@ export const featureToggleListResponseSchema = z.object({
 
 export { toggleCreateSchema, toggleUpdateSchema }
 
+// Documents the actual override-list row shape returned by GET /api/feature_toggles/overrides
+// (see lib/queries.ts → getOverrides). Each row reports whether the tenant has a
+// per-tenant override via `isOverride`; inherited rows (no override) carry an
+// empty-string `id` sentinel instead of a UUID, hence `overrideRowIdSchema`.
 export const featureToggleOverrideSchema = z
     .object({
-        id: z.string().uuid(),
+        id: overrideRowIdSchema,
         toggleId: z.string().uuid(),
-        overrideState: z.enum(['enabled', 'disabled', 'inherit']),
+        tenantName: z.string(),
+        tenantId: z.string().uuid(),
         identifier: z.string(),
         name: z.string(),
-        category: z.string().nullable().optional(),
-        defaultState: z.boolean(),
-        tenantName: z.string().nullable().optional(),
+        category: z.string(),
+        isOverride: z.boolean(),
     })
     .passthrough()
 

package/src/modules/feature_toggles/data/validators.ts

@@ -90,8 +90,13 @@ export const featureToggleSchema = z.object({
   updatedAt: z.string().optional(),
 })
 
+// Inherited rows (no per-tenant override) intentionally carry an empty-string
+// `id` sentinel instead of a UUID, so the row id must accept both a UUID (real
+// override rows) and the empty inherited sentinel. See lib/queries.ts.
+export const overrideRowIdSchema = z.union([z.string().uuid(), z.literal('')])
+
 export const overrideListResponseSchema = z.object({
-  id: z.string().uuid(),
+  id: overrideRowIdSchema,
   toggleId: z.string().uuid(),
   tenantName: z.string(),
   tenantId: z.string().uuid(),

package/src/modules/integrations/widgets/injection/external-ids/widget.client.tsx

@@ -10,10 +10,10 @@ import { cn } from '@open-mercato/shared/lib/utils'
 type IntegrationsData = Record<string, ExternalIdMapping>
 
 const SYNC_STATUS_STYLES: Record<ExternalIdMapping['syncStatus'], { dot: string; label: string }> = {
-  synced: { dot: 'bg-green-500', label: 'integrations.syncStatus.synced' },
-  pending: { dot: 'bg-yellow-500', label: 'integrations.syncStatus.pending' },
-  error: { dot: 'bg-red-500', label: 'integrations.syncStatus.error' },
-  not_synced: { dot: 'bg-gray-400', label: 'integrations.syncStatus.notSynced' },
+  synced: { dot: 'bg-status-success-icon', label: 'integrations.syncStatus.synced' },
+  pending: { dot: 'bg-status-warning-icon', label: 'integrations.syncStatus.pending' },
+  error: { dot: 'bg-status-error-icon', label: 'integrations.syncStatus.error' },
+  not_synced: { dot: 'bg-status-neutral-icon', label: 'integrations.syncStatus.notSynced' },
 }
 
 function SyncStatusBadge({ status, lastSynced }: { status: ExternalIdMapping['syncStatus']; lastSynced?: string }) {