@open-mercato/core 0.4.7-develop-0a657b411f → 0.4.7-develop-e249d3e7d0

package/src/modules/integrations/api/[id]/route.ts

@@ -5,6 +5,11 @@ import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getBundle, getBundleIntegrations, getIntegration } from '@open-mercato/shared/modules/integrations/types'
 import type { CredentialsService } from '../../lib/credentials-service'
 import type { IntegrationStateService } from '../../lib/state-service'
+import {
+  finalizeIntegrationsReadResponse,
+  integrationApiRoutePaths,
+  runIntegrationsReadBeforeInterceptors,
+} from '../umes-read'
 
 const idParamsSchema = z.object({ id: z.string().min(1) })
 
@@ -38,6 +43,15 @@ export async function GET(req: Request, ctx: { params?: Promise<{ id?: string }>
   }
 
   const container = await createRequestContainer()
+  const beforeInterceptors = await runIntegrationsReadBeforeInterceptors({
+    routePath: integrationApiRoutePaths.detail,
+    request: req,
+    auth,
+    container,
+  })
+  if (!beforeInterceptors.ok) {
+    return NextResponse.json(beforeInterceptors.body, { status: beforeInterceptors.statusCode })
+  }
   const credentialsService = container.resolve('integrationCredentialsService') as CredentialsService
   const stateService = container.resolve('integrationStateService') as IntegrationStateService
   const scope = { organizationId: auth.orgId as string, tenantId: auth.tenantId }
@@ -68,17 +82,30 @@ export async function GET(req: Request, ctx: { params?: Promise<{ id?: string }>
     )
     : []
 
-  return NextResponse.json({
-    integration,
-    bundle,
-    bundleIntegrations,
-    state: {
-      isEnabled: state?.isEnabled ?? true,
-      apiVersion: state?.apiVersion ?? null,
-      reauthRequired: state?.reauthRequired ?? false,
-      lastHealthStatus: state?.lastHealthStatus ?? null,
-      lastHealthCheckedAt: state?.lastHealthCheckedAt?.toISOString() ?? null,
+  return finalizeIntegrationsReadResponse({
+    routePath: integrationApiRoutePaths.detail,
+    request: req,
+    auth,
+    container,
+    interceptorRequest: beforeInterceptors.request,
+    beforeMetadata: beforeInterceptors.metadataByInterceptor,
+    enrich: {
+      targetEntity: 'integrations.integration',
+      recordKeys: ['integration'],
+      listKeys: ['bundleIntegrations'],
+    },
+    body: {
+      integration,
+      bundle,
+      bundleIntegrations,
+      state: {
+        isEnabled: state?.isEnabled ?? true,
+        apiVersion: state?.apiVersion ?? null,
+        reauthRequired: state?.reauthRequired ?? false,
+        lastHealthStatus: state?.lastHealthStatus ?? null,
+        lastHealthCheckedAt: state?.lastHealthCheckedAt?.toISOString() ?? null,
+      },
+      hasCredentials: Boolean(credentials),
     },
-    hasCredentials: Boolean(credentials),
   })
 }

package/src/modules/integrations/api/logs/route.ts

@@ -3,6 +3,11 @@ import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { listIntegrationLogsQuerySchema } from '@open-mercato/core/modules/integrations/data/validators'
 import type { IntegrationLogService } from '@open-mercato/core/modules/integrations/lib/log-service'
+import {
+  finalizeIntegrationsReadResponse,
+  integrationApiRoutePaths,
+  runIntegrationsReadBeforeInterceptors,
+} from '../umes-read'
 
 export const metadata = {
   GET: { requireAuth: true, requireFeatures: ['integrations.manage'] },
@@ -19,22 +24,31 @@ export async function GET(req: Request) {
     return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
   }
 
-  const url = new URL(req.url)
+  const container = await createRequestContainer()
+  const beforeInterceptors = await runIntegrationsReadBeforeInterceptors({
+    routePath: integrationApiRoutePaths.logs,
+    request: req,
+    auth,
+    container,
+  })
+  if (!beforeInterceptors.ok) {
+    return NextResponse.json(beforeInterceptors.body, { status: beforeInterceptors.statusCode })
+  }
+
+  const query = beforeInterceptors.request.query ?? {}
   const parsed = listIntegrationLogsQuerySchema.safeParse({
-    integrationId: url.searchParams.get('integrationId') ?? undefined,
-    level: url.searchParams.get('level') ?? undefined,
-    runId: url.searchParams.get('runId') ?? undefined,
-    entityType: url.searchParams.get('entityType') ?? undefined,
-    entityId: url.searchParams.get('entityId') ?? undefined,
-    page: url.searchParams.get('page') ?? undefined,
-    pageSize: url.searchParams.get('pageSize') ?? undefined,
+    integrationId: typeof query.integrationId === 'string' ? query.integrationId : undefined,
+    level: typeof query.level === 'string' ? query.level : undefined,
+    runId: typeof query.runId === 'string' ? query.runId : undefined,
+    entityType: typeof query.entityType === 'string' ? query.entityType : undefined,
+    entityId: typeof query.entityId === 'string' ? query.entityId : undefined,
+    page: typeof query.page === 'string' ? query.page : undefined,
+    pageSize: typeof query.pageSize === 'string' ? query.pageSize : undefined,
   })
 
   if (!parsed.success) {
     return NextResponse.json({ error: 'Invalid query', details: parsed.error.flatten() }, { status: 400 })
   }
-
-  const container = await createRequestContainer()
   const logService = container.resolve('integrationLogService') as IntegrationLogService
 
   const { items, total } = await logService.query(parsed.data, {
@@ -42,22 +56,34 @@ export async function GET(req: Request) {
     tenantId: auth.tenantId,
   })
 
-  return NextResponse.json({
-    items: items.map((item) => ({
-      id: item.id,
-      integrationId: item.integrationId,
-      runId: item.runId ?? null,
-      scopeEntityType: item.scopeEntityType ?? null,
-      scopeEntityId: item.scopeEntityId ?? null,
-      level: item.level,
-      message: item.message,
-      code: item.code ?? null,
-      payload: item.payload ?? null,
-      createdAt: item.createdAt.toISOString(),
-    })),
-    total,
-    page: parsed.data.page,
-    pageSize: parsed.data.pageSize,
-    totalPages: Math.max(1, Math.ceil(total / parsed.data.pageSize)),
+  return finalizeIntegrationsReadResponse({
+    routePath: integrationApiRoutePaths.logs,
+    request: req,
+    auth,
+    container,
+    interceptorRequest: beforeInterceptors.request,
+    beforeMetadata: beforeInterceptors.metadataByInterceptor,
+    enrich: {
+      targetEntity: 'integrations.log',
+      listKeys: ['items'],
+    },
+    body: {
+      items: items.map((item) => ({
+        id: item.id,
+        integrationId: item.integrationId,
+        runId: item.runId ?? null,
+        scopeEntityType: item.scopeEntityType ?? null,
+        scopeEntityId: item.scopeEntityId ?? null,
+        level: item.level,
+        message: item.message,
+        code: item.code ?? null,
+        payload: item.payload ?? null,
+        createdAt: item.createdAt.toISOString(),
+      })),
+      total,
+      page: parsed.data.page,
+      pageSize: parsed.data.pageSize,
+      totalPages: Math.max(1, Math.ceil(total / parsed.data.pageSize)),
+    },
   })
 }

package/src/modules/integrations/api/route.ts

@@ -5,6 +5,11 @@ import type { CredentialsService } from '../lib/credentials-service'
 import type { IntegrationStateService } from '../lib/state-service'
 import { getAllBundles, getAllIntegrations } from '@open-mercato/shared/modules/integrations/types'
 import { buildIntegrationsCrudOpenApi, createPagedListResponseSchema, integrationInfoSchema } from './openapi'
+import {
+  finalizeIntegrationsReadResponse,
+  integrationApiRoutePaths,
+  runIntegrationsReadBeforeInterceptors,
+} from './umes-read'
 
 export const metadata = {
   GET: { requireAuth: true, requireFeatures: ['integrations.view'] },
@@ -24,6 +29,15 @@ export async function GET(req: Request) {
   }
 
   const container = await createRequestContainer()
+  const beforeInterceptors = await runIntegrationsReadBeforeInterceptors({
+    routePath: integrationApiRoutePaths.list,
+    request: req,
+    auth,
+    container,
+  })
+  if (!beforeInterceptors.ok) {
+    return NextResponse.json(beforeInterceptors.body, { status: beforeInterceptors.statusCode })
+  }
   const credentialsService = container.resolve('integrationCredentialsService') as CredentialsService
   const stateService = container.resolve('integrationStateService') as IntegrationStateService
 
@@ -37,10 +51,14 @@ export async function GET(req: Request) {
       return {
         id: integration.id,
         title: integration.title,
+        description: integration.description ?? null,
         category: integration.category ?? null,
         hub: integration.hub ?? null,
         providerKey: integration.providerKey ?? null,
         bundleId: integration.bundleId ?? null,
+        author: integration.author ?? null,
+        company: integration.company ?? null,
+        version: integration.version ?? null,
         hasCredentials: Boolean(resolvedCredentials),
         isEnabled: state?.isEnabled ?? true,
         apiVersion: state?.apiVersion ?? null,
@@ -62,12 +80,24 @@ export async function GET(req: Request) {
     }
   })
 
-  return NextResponse.json({
+  return finalizeIntegrationsReadResponse({
+    routePath: integrationApiRoutePaths.list,
+    request: req,
+    auth,
+    container,
+    interceptorRequest: beforeInterceptors.request,
+    beforeMetadata: beforeInterceptors.metadataByInterceptor,
+    enrich: {
+      targetEntity: 'integrations.integration',
+      listKeys: ['items'],
+    },
+    body: {
     items: rows,
     bundles,
     total: rows.length,
     page: 1,
     pageSize: 100,
     totalPages: 1,
+    },
   })
 }

package/src/modules/integrations/api/umes-read.ts

@@ -0,0 +1,177 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { NextResponse } from 'next/server'
+import type { AwilixContainer } from 'awilix'
+import { runApiInterceptorsAfter, runApiInterceptorsBefore, type RunInterceptorsBeforeResult } from '@open-mercato/shared/lib/crud/interceptor-runner'
+import { applyResponseEnrichers, applyResponseEnricherToRecord } from '@open-mercato/shared/lib/crud/enricher-runner'
+import type { ApiInterceptorMethod, InterceptorRequest } from '@open-mercato/shared/lib/crud/api-interceptor'
+
+export const integrationApiRoutePaths = {
+  list: 'integrations',
+  detail: 'integrations/detail',
+  logs: 'integrations/logs',
+} as const
+
+type ReadRouteFieldConfig = {
+  targetEntity: string
+  recordKeys?: string[]
+  listKeys?: string[]
+}
+
+type ReadRouteContext = {
+  routePath: string
+  request: Request
+  auth: {
+    tenantId: string | null
+    orgId: string | null
+    sub?: string | null
+    features?: unknown
+  }
+  container: AwilixContainer
+}
+
+function headersToObject(headers: Headers): Record<string, string> {
+  return Object.fromEntries(headers.entries())
+}
+
+function searchParamsToObject(url: URL): Record<string, string> {
+  const entries: Record<string, string> = {}
+  url.searchParams.forEach((value, key) => {
+    entries[key] = value
+  })
+  return entries
+}
+
+function toUserFeatures(features: unknown): string[] {
+  if (!Array.isArray(features)) return []
+  return features.filter((value): value is string => typeof value === 'string')
+}
+
+function mergeAdditiveRecord<T extends Record<string, unknown>>(base: T, candidate: T): T {
+  const additions = Object.fromEntries(
+    Object.entries(candidate).filter(([key]) => !(key in base)),
+  ) as Partial<T>
+
+  return {
+    ...base,
+    ...additions,
+  }
+}
+
+function mergeAdditiveBody(
+  baseBody: Record<string, unknown>,
+  candidateBody: Record<string, unknown>,
+): Record<string, unknown> {
+  return mergeAdditiveRecord(baseBody, candidateBody)
+}
+
+function getEnricherContext(input: ReadRouteContext) {
+  return {
+    organizationId: input.auth.orgId as string,
+    tenantId: input.auth.tenantId as string,
+    userId: input.auth.sub ?? '',
+    em: input.container.resolve('em') as EntityManager,
+    container: input.container,
+    userFeatures: toUserFeatures(input.auth.features),
+  }
+}
+
+export async function runIntegrationsReadBeforeInterceptors(
+  input: ReadRouteContext,
+): Promise<RunInterceptorsBeforeResult> {
+  const url = new URL(input.request.url)
+
+  return runApiInterceptorsBefore({
+    routePath: input.routePath,
+    method: 'GET',
+    request: {
+      method: 'GET',
+      url: input.request.url,
+      headers: headersToObject(input.request.headers),
+      query: searchParamsToObject(url),
+    },
+    context: getEnricherContext(input),
+  })
+}
+
+async function applySafeRecordEnrichment(
+  record: Record<string, unknown>,
+  targetEntity: string,
+  context: ReturnType<typeof getEnricherContext>,
+): Promise<Record<string, unknown>> {
+  const enriched = await applyResponseEnricherToRecord(record, targetEntity, context)
+  return mergeAdditiveRecord(record, enriched.record)
+}
+
+async function applySafeListEnrichment(
+  items: Record<string, unknown>[],
+  targetEntity: string,
+  context: ReturnType<typeof getEnricherContext>,
+): Promise<Record<string, unknown>[]> {
+  const enriched = await applyResponseEnrichers(items, targetEntity, context)
+  return items.map((item, index) => {
+    const enrichedItem = enriched.items[index]
+    if (!enrichedItem) return item
+    return mergeAdditiveRecord(item, enrichedItem)
+  })
+}
+
+export async function finalizeIntegrationsReadResponse(
+  input: ReadRouteContext & {
+    interceptorRequest: InterceptorRequest
+    body: Record<string, unknown>
+    enrich?: ReadRouteFieldConfig
+    method?: ApiInterceptorMethod
+    beforeMetadata?: Record<string, Record<string, unknown> | undefined>
+  },
+): Promise<NextResponse> {
+  const method = input.method ?? 'GET'
+  const baseBody = input.body
+  const context = getEnricherContext(input)
+
+  const intercepted = await runApiInterceptorsAfter({
+    routePath: input.routePath,
+    method,
+    request: input.interceptorRequest,
+    response: {
+      statusCode: 200,
+      body: baseBody,
+      headers: {},
+    },
+    context,
+    metadataByInterceptor: input.beforeMetadata,
+  })
+
+  if (!intercepted.ok) {
+    return NextResponse.json(intercepted.body, { status: intercepted.statusCode, headers: intercepted.headers })
+  }
+
+  let responseBody = mergeAdditiveBody(baseBody, intercepted.body)
+
+  if (input.enrich) {
+    const { targetEntity, recordKeys = [], listKeys = [] } = input.enrich
+
+    for (const key of recordKeys) {
+      const current = responseBody[key]
+      if (!current || typeof current !== 'object' || Array.isArray(current)) continue
+      responseBody = {
+        ...responseBody,
+        [key]: await applySafeRecordEnrichment(current as Record<string, unknown>, targetEntity, context),
+      }
+    }
+
+    for (const key of listKeys) {
+      const current = responseBody[key]
+      if (!Array.isArray(current)) continue
+      const records = current.filter(
+        (item): item is Record<string, unknown> => typeof item === 'object' && item !== null && !Array.isArray(item),
+      )
+      if (records.length !== current.length) continue
+      responseBody = {
+        ...responseBody,
+        [key]: await applySafeListEnrichment(records, targetEntity, context),
+      }
+    }
+  }
+
+  return NextResponse.json(responseBody, { headers: intercepted.headers })
+}