@open-mercato/core 0.4.6-develop-6d72ec5960 → 0.4.6-develop-cd1e2a9a0e

package/src/modules/integrations/backend/integrations/page.meta.ts

@@ -0,0 +1,18 @@
+import React from 'react'
+
+const puzzleIcon = React.createElement('svg', { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2 },
+  React.createElement('path', { d: 'M19.439 7.85c-.049.322.059.648.289.878l1.568 1.568c.47.47.706 1.087.706 1.704s-.235 1.233-.706 1.704l-1.611 1.611a.98.98 0 0 1-.837.276c-.47-.07-.802-.48-.968-.925a2.501 2.501 0 1 0-3.214 3.214c.446.166.855.497.925.968a.979.979 0 0 1-.276.837l-1.61 1.61a2.404 2.404 0 0 1-1.705.707 2.402 2.402 0 0 1-1.704-.706l-1.568-1.568a1.026 1.026 0 0 0-.877-.29c-.493.074-.84.504-1.02.968a2.5 2.5 0 1 1-3.237-3.237c.464-.18.894-.527.967-1.02a1.026 1.026 0 0 0-.289-.877l-1.568-1.568A2.402 2.402 0 0 1 1.998 12c0-.617.236-1.234.706-1.704L4.23 8.77c.24-.24.581-.353.917-.303.515.077.877.528 1.073 1.01a2.5 2.5 0 1 0 3.259-3.259c-.482-.196-.933-.558-1.01-1.073-.05-.336.062-.676.303-.917l1.525-1.525A2.402 2.402 0 0 1 12 2c.617 0 1.234.236 1.704.706l1.568 1.568c.23.23.556.338.877.29.493-.074.84-.504 1.02-.968a2.5 2.5 0 1 1 3.237 3.237c-.464.18-.894.527-.967 1.02Z' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['integrations.view'],
+  pageTitle: 'Integrations',
+  pageTitleKey: 'integrations.nav.title',
+  pageGroup: 'Settings',
+  pageGroupKey: 'settings.sections.general',
+  pageOrder: 50,
+  icon: puzzleIcon,
+  pageContext: 'settings' as const,
+  breadcrumb: [{ label: 'Integrations', labelKey: 'integrations.nav.title' }],
+}

package/src/modules/integrations/backend/integrations/page.tsx

@@ -0,0 +1,296 @@
+"use client"
+import * as React from 'react'
+import Link from 'next/link'
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { Card, CardHeader, CardTitle, CardContent } from '@open-mercato/ui/primitives/card'
+import { Badge } from '@open-mercato/ui/primitives/badge'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Switch } from '@open-mercato/ui/primitives/switch'
+import { Input } from '@open-mercato/ui/primitives/input'
+import { Spinner } from '@open-mercato/ui/primitives/spinner'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import {
+  LayoutGrid,
+  CreditCard,
+  Truck,
+  RefreshCw,
+  MessageSquare,
+  Bell,
+  HardDrive,
+  Webhook,
+} from 'lucide-react'
+
+type IntegrationItem = {
+  id: string
+  title: string
+  description?: string
+  category?: string
+  icon?: string
+  bundleId?: string
+  isEnabled: boolean
+  hasCredentials: boolean
+}
+
+type BundleItem = {
+  id: string
+  title: string
+  description?: string
+  icon?: string
+  integrationCount: number
+  enabledCount: number
+}
+
+type ListResponse = {
+  items: IntegrationItem[]
+  bundles: BundleItem[]
+}
+
+const CATEGORY_ICONS: Record<string, React.ElementType> = {
+  all: LayoutGrid,
+  payment: CreditCard,
+  shipping: Truck,
+  data_sync: RefreshCw,
+  communication: MessageSquare,
+  notification: Bell,
+  storage: HardDrive,
+  webhook: Webhook,
+}
+
+const CATEGORIES = ['all', 'payment', 'shipping', 'data_sync', 'communication', 'notification', 'storage', 'webhook'] as const
+
+function categoryBadgeVariant(category: string | undefined): 'default' | 'secondary' | 'outline' {
+  if (!category) return 'outline'
+  return 'secondary'
+}
+
+export default function IntegrationsMarketplacePage() {
+  const [data, setData] = React.useState<ListResponse | null>(null)
+  const [isLoading, setIsLoading] = React.useState(true)
+  const [search, setSearch] = React.useState('')
+  const [category, setCategory] = React.useState<string>('all')
+  const [togglingIds, setTogglingIds] = React.useState<Set<string>>(new Set())
+  const scopeVersion = useOrganizationScopeVersion()
+  const t = useT()
+
+  const load = React.useCallback(async () => {
+    setIsLoading(true)
+    const fallback: ListResponse = { items: [], bundles: [] }
+    const call = await apiCall<ListResponse>('/api/integrations', undefined, { fallback })
+    if (!call.ok) {
+      flash(t('integrations.marketplace.loadError'), 'error')
+      setIsLoading(false)
+      return
+    }
+    setData(call.result ?? fallback)
+    setIsLoading(false)
+  }, [t])
+
+  React.useEffect(() => { void load() }, [load, scopeVersion])
+
+  const handleToggle = React.useCallback(async (integrationId: string, enabled: boolean) => {
+    setTogglingIds((prev) => new Set(prev).add(integrationId))
+    const call = await apiCall(`/api/integrations/${encodeURIComponent(integrationId)}/state`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ isEnabled: enabled }),
+    }, { fallback: null })
+
+    if (!call.ok) {
+      flash(t('integrations.detail.stateError'), 'error')
+    } else {
+      setData((prev) => {
+        if (!prev) return prev
+        return {
+          ...prev,
+          items: prev.items.map((item) =>
+            item.id === integrationId ? { ...item, isEnabled: enabled } : item,
+          ),
+        }
+      })
+    }
+    setTogglingIds((prev) => { const next = new Set(prev); next.delete(integrationId); return next })
+  }, [t])
+
+  const filteredItems = React.useMemo(() => {
+    if (!data) return { bundles: [], standalone: [] }
+
+    let items = data.items
+    if (search) {
+      const q = search.toLowerCase()
+      items = items.filter((item) => item.title.toLowerCase().includes(q) || item.description?.toLowerCase().includes(q))
+    }
+    if (category !== 'all') {
+      items = items.filter((item) => item.category === category)
+    }
+
+    const bundled = new Map<string, IntegrationItem[]>()
+    const standalone: IntegrationItem[] = []
+    for (const item of items) {
+      if (item.bundleId) {
+        const list = bundled.get(item.bundleId) ?? []
+        list.push(item)
+        bundled.set(item.bundleId, list)
+      } else {
+        standalone.push(item)
+      }
+    }
+
+    const bundles = (data.bundles ?? [])
+      .filter((b) => bundled.has(b.id))
+      .map((b) => ({ ...b, integrations: bundled.get(b.id) ?? [] }))
+
+    return { bundles, standalone }
+  }, [data, search, category])
+
+  if (isLoading) {
+    return (
+      <Page>
+        <PageBody>
+          <div className="flex items-center justify-center py-16">
+            <Spinner />
+          </div>
+        </PageBody>
+      </Page>
+    )
+  }
+
+  return (
+    <Page>
+      <PageBody className="space-y-6">
+        <section className="space-y-6 rounded-lg border bg-background p-6">
+          <header className="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
+            <div className="space-y-1">
+              <h2 className="text-lg font-semibold">{t('integrations.marketplace.title')}</h2>
+              <p className="text-sm text-muted-foreground">
+                {t('integrations.marketplace.description')}
+              </p>
+            </div>
+          </header>
+
+          <div className="flex flex-col gap-4 sm:flex-row sm:items-center">
+            <Input
+              placeholder={t('integrations.marketplace.search')}
+              value={search}
+              onChange={(e) => setSearch(e.target.value)}
+              className="max-w-sm"
+            />
+            <div className="flex flex-wrap gap-1.5">
+              {CATEGORIES.map((cat) => {
+                const Icon = CATEGORY_ICONS[cat]
+                return (
+                  <Button
+                    key={cat}
+                    type="button"
+                    variant={category === cat ? 'default' : 'outline'}
+                    size="sm"
+                    onClick={() => setCategory(cat)}
+                  >
+                    {Icon ? <Icon className="mr-1.5 h-3.5 w-3.5" /> : null}
+                    {t(`integrations.marketplace.categories.${cat}`)}
+                  </Button>
+                )
+              })}
+            </div>
+          </div>
+
+          {filteredItems.bundles.map((bundle) => (
+            <Card key={bundle.id}>
+              <CardHeader>
+                <div className="flex items-center justify-between">
+                  <div>
+                    <CardTitle>{bundle.title}</CardTitle>
+                    {bundle.description && (
+                      <p className="text-muted-foreground text-sm mt-1">{bundle.description}</p>
+                    )}
+                    <p className="text-muted-foreground text-xs mt-1">
+                      {t('integrations.marketplace.integrations', { count: bundle.integrations.length })}
+                    </p>
+                  </div>
+                  <Button asChild variant="outline" size="sm">
+                    <Link href={`/backend/integrations/bundle/${encodeURIComponent(bundle.id)}`}>
+                      {t('integrations.marketplace.configure')}
+                    </Link>
+                  </Button>
+                </div>
+              </CardHeader>
+              <CardContent>
+                <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3">
+                  {bundle.integrations.map((item) => (
+                    <div
+                      key={item.id}
+                      className="flex items-center justify-between rounded-lg border p-3"
+                    >
+                      <div className="min-w-0">
+                        <Link
+                          href={`/backend/integrations/${encodeURIComponent(item.id)}`}
+                          className="text-sm font-medium hover:underline"
+                        >
+                          {item.title}
+                        </Link>
+                        {item.category && (
+                          <Badge variant={categoryBadgeVariant(item.category)} className="ml-2 text-xs">
+                            {item.category}
+                          </Badge>
+                        )}
+                      </div>
+                      <Switch
+                        checked={item.isEnabled}
+                        disabled={togglingIds.has(item.id)}
+                        onCheckedChange={(checked) => void handleToggle(item.id, checked)}
+                      />
+                    </div>
+                  ))}
+                </div>
+              </CardContent>
+            </Card>
+          ))}
+
+          {filteredItems.standalone.length > 0 && (
+            <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
+              {filteredItems.standalone.map((item) => (
+                <Card key={item.id} className="flex flex-col">
+                  <CardHeader>
+                    <div className="flex items-center justify-between">
+                      <CardTitle className="text-base">{item.title}</CardTitle>
+                      <Switch
+                        checked={item.isEnabled}
+                        disabled={togglingIds.has(item.id)}
+                        onCheckedChange={(checked) => void handleToggle(item.id, checked)}
+                      />
+                    </div>
+                    {item.category && (
+                      <Badge variant={categoryBadgeVariant(item.category)} className="w-fit text-xs">
+                        {item.category}
+                      </Badge>
+                    )}
+                  </CardHeader>
+                  <CardContent className="flex-1">
+                    {item.description && (
+                      <p className="text-muted-foreground text-sm">{item.description}</p>
+                    )}
+                  </CardContent>
+                  <div className="px-6 pb-4">
+                    <Button asChild variant="outline" size="sm" className="w-full">
+                      <Link href={`/backend/integrations/${encodeURIComponent(item.id)}`}>
+                        {t('integrations.marketplace.configure')}
+                      </Link>
+                    </Button>
+                  </div>
+                </Card>
+              ))}
+            </div>
+          )}
+
+          {filteredItems.bundles.length === 0 && filteredItems.standalone.length === 0 && (
+            <div className="text-center py-12 text-muted-foreground">
+              {t('integrations.marketplace.noResults')}
+            </div>
+          )}
+        </section>
+      </PageBody>
+    </Page>
+  )
+}

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

@@ -8,11 +8,14 @@
  */
 
 import type { ResponseEnricher, EnricherContext } from '@open-mercato/shared/lib/crud/response-enricher'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import type { ExternalIdEnrichment } from '@open-mercato/shared/modules/integrations/types'
 import { getIntegration } from '@open-mercato/shared/modules/integrations/types'
 import { SyncExternalIdMapping } from './entities'
 
 type EntityRecord = Record<string, unknown> & { id: string }
+type EnricherScope = EnricherContext & { targetEntity?: string; em: EntityManager }
 
 function buildIntegrationData(
   mappings: SyncExternalIdMapping[],
@@ -41,17 +44,24 @@ const externalIdMappingEnricher: ResponseEnricher<EntityRecord, ExternalIdEnrich
   critical: false,
   fallback: {},
 
-  async enrichOne(record, context: EnricherContext & { targetEntity?: string }) {
-    const em = (context.em as any).fork()
-    const targetEntity = (context as any).targetEntity as string | undefined
+  async enrichOne(record, context: EnricherScope) {
+    const em = context.em.fork()
+    const targetEntity = context.targetEntity
     if (!targetEntity) return { ...record, _integrations: {} }
 
-    const mappings: SyncExternalIdMapping[] = await em.find(SyncExternalIdMapping, {
-      internalEntityType: targetEntity,
-      internalEntityId: record.id,
-      organizationId: context.organizationId,
-      deletedAt: null,
-    })
+    const mappings = await findWithDecryption(
+      em,
+      SyncExternalIdMapping,
+      {
+        internalEntityType: targetEntity,
+        internalEntityId: record.id,
+        organizationId: context.organizationId,
+        tenantId: context.tenantId,
+        deletedAt: null,
+      },
+      undefined,
+      { organizationId: context.organizationId, tenantId: context.tenantId },
+    )
 
     if (mappings.length === 0) return { ...record, _integrations: {} }
 
@@ -61,18 +71,25 @@ const externalIdMappingEnricher: ResponseEnricher<EntityRecord, ExternalIdEnrich
     }
   },
 
-  async enrichMany(records, context: EnricherContext & { targetEntity?: string }) {
-    const em = (context.em as any).fork()
-    const targetEntity = (context as any).targetEntity as string | undefined
+  async enrichMany(records, context: EnricherScope) {
+    const em = context.em.fork()
+    const targetEntity = context.targetEntity
     if (!targetEntity || records.length === 0) return records.map((r) => ({ ...r, _integrations: {} }))
 
     const recordIds = records.map((r) => r.id)
-    const allMappings: SyncExternalIdMapping[] = await em.find(SyncExternalIdMapping, {
-      internalEntityType: targetEntity,
-      internalEntityId: { $in: recordIds },
-      organizationId: context.organizationId,
-      deletedAt: null,
-    })
+    const allMappings = await findWithDecryption(
+      em,
+      SyncExternalIdMapping,
+      {
+        internalEntityType: targetEntity,
+        internalEntityId: { $in: recordIds },
+        organizationId: context.organizationId,
+        tenantId: context.tenantId,
+        deletedAt: null,
+      },
+      undefined,
+      { organizationId: context.organizationId, tenantId: context.tenantId },
+    )
 
     if (allMappings.length === 0) return records.map((r) => ({ ...r, _integrations: {} }))
 

package/src/modules/integrations/data/entities.ts

@@ -1,13 +1,10 @@
-import { Entity, PrimaryKey, Property, Index } from '@mikro-orm/core'
+import { Entity, PrimaryKey, Property, Index, OptionalProps } from '@mikro-orm/core'
 
-/**
- * Stores mappings between internal entity IDs and external system IDs.
- * Used by integration modules to track synced records across platforms.
- */
 @Entity({ tableName: 'sync_external_id_mappings' })
 @Index({ properties: ['internalEntityType', 'internalEntityId', 'organizationId'] })
 @Index({ properties: ['integrationId', 'externalId', 'organizationId'] })
 export class SyncExternalIdMapping {
+  [OptionalProps]?: 'syncStatus' | 'lastSyncedAt' | 'createdAt' | 'updatedAt' | 'deletedAt'
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string
 
@@ -44,3 +41,115 @@ export class SyncExternalIdMapping {
   @Property({ name: 'deleted_at', type: Date, nullable: true })
   deletedAt?: Date | null
 }
+
+@Entity({ tableName: 'integration_credentials' })
+@Index({ properties: ['integrationId', 'organizationId', 'tenantId'] })
+export class IntegrationCredentials {
+  [OptionalProps]?: 'createdAt' | 'updatedAt' | 'deletedAt'
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'integration_id', type: 'text' })
+  integrationId!: string
+
+  @Property({ name: 'credentials', type: 'json' })
+  credentials!: Record<string, unknown>
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+}
+
+@Entity({ tableName: 'integration_states' })
+@Index({ properties: ['integrationId', 'organizationId', 'tenantId'] })
+export class IntegrationState {
+  [OptionalProps]?: 'isEnabled' | 'apiVersion' | 'reauthRequired' | 'lastHealthStatus' | 'lastHealthCheckedAt' | 'createdAt' | 'updatedAt' | 'deletedAt'
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'integration_id', type: 'text' })
+  integrationId!: string
+
+  @Property({ name: 'is_enabled', type: 'boolean', default: true })
+  isEnabled: boolean = true
+
+  @Property({ name: 'api_version', type: 'text', nullable: true })
+  apiVersion?: string | null
+
+  @Property({ name: 'reauth_required', type: 'boolean', default: false })
+  reauthRequired: boolean = false
+
+  @Property({ name: 'last_health_status', type: 'text', nullable: true })
+  lastHealthStatus?: 'healthy' | 'degraded' | 'unhealthy' | null
+
+  @Property({ name: 'last_health_checked_at', type: Date, nullable: true })
+  lastHealthCheckedAt?: Date | null
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+}
+
+@Entity({ tableName: 'integration_logs' })
+@Index({ properties: ['integrationId', 'organizationId', 'tenantId', 'createdAt'] })
+@Index({ properties: ['level', 'organizationId', 'tenantId', 'createdAt'] })
+export class IntegrationLog {
+  [OptionalProps]?: 'runId' | 'scopeEntityType' | 'scopeEntityId' | 'code' | 'payload' | 'createdAt'
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'integration_id', type: 'text' })
+  integrationId!: string
+
+  @Property({ name: 'run_id', type: 'uuid', nullable: true })
+  runId?: string | null
+
+  @Property({ name: 'scope_entity_type', type: 'text', nullable: true })
+  scopeEntityType?: string | null
+
+  @Property({ name: 'scope_entity_id', type: 'uuid', nullable: true })
+  scopeEntityId?: string | null
+
+  @Property({ name: 'level', type: 'text' })
+  level!: 'info' | 'warn' | 'error'
+
+  @Property({ name: 'message', type: 'text' })
+  message!: string
+
+  @Property({ name: 'code', type: 'text', nullable: true })
+  code?: string | null
+
+  @Property({ name: 'payload', type: 'json', nullable: true })
+  payload?: Record<string, unknown> | null
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+}

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

@@ -0,0 +1,41 @@
+import { z } from 'zod'
+
+export const saveCredentialsSchema = z.object({
+  credentials: z.record(
+    z.string().min(1).max(128),
+    z.union([z.string().max(20_000), z.number(), z.boolean(), z.null()]),
+  ),
+}).refine((value) => Object.keys(value.credentials).length <= 200, {
+  message: 'At most 200 credential fields are allowed',
+})
+
+export type SaveCredentialsInput = z.infer<typeof saveCredentialsSchema>
+
+export const updateVersionSchema = z.object({
+  apiVersion: z.string().min(1),
+})
+
+export type UpdateVersionInput = z.infer<typeof updateVersionSchema>
+
+export const updateStateSchema = z.object({
+  isEnabled: z.boolean().optional(),
+  reauthRequired: z.boolean().optional(),
+}).refine((value) => value.isEnabled !== undefined || value.reauthRequired !== undefined, {
+  message: 'At least one state field must be provided',
+})
+
+export type UpdateStateInput = z.infer<typeof updateStateSchema>
+
+export const integrationLogLevelSchema = z.enum(['info', 'warn', 'error'])
+
+export const listIntegrationLogsQuerySchema = z.object({
+  integrationId: z.string().min(1).optional(),
+  level: integrationLogLevelSchema.optional(),
+  runId: z.string().uuid().optional(),
+  entityType: z.string().optional(),
+  entityId: z.string().uuid().optional(),
+  page: z.coerce.number().int().min(1).default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).default(20),
+})
+
+export type ListIntegrationLogsQuery = z.infer<typeof listIntegrationLogsQuerySchema>

package/src/modules/integrations/di.ts

@@ -0,0 +1,31 @@
+import { asFunction, asValue } from 'awilix'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { IntegrationCredentials, IntegrationLog, IntegrationState, SyncExternalIdMapping } from './data/entities'
+import { createCredentialsService } from './lib/credentials-service'
+import { createIntegrationStateService } from './lib/state-service'
+import { createIntegrationLogService } from './lib/log-service'
+import { createHealthService } from './lib/health-service'
+import type { IntegrationStateService } from './lib/state-service'
+import type { IntegrationLogService } from './lib/log-service'
+
+type Cradle = {
+  em: EntityManager
+  integrationStateService: IntegrationStateService
+  integrationLogService: IntegrationLogService
+}
+
+export function register(container: AppContainer) {
+  container.register({
+    integrationCredentialsService: asFunction(({ em }: Cradle) => createCredentialsService(em)).scoped().proxy(),
+    integrationStateService: asFunction(({ em }: Cradle) => createIntegrationStateService(em)).scoped().proxy(),
+    integrationLogService: asFunction(({ em }: Cradle) => createIntegrationLogService(em)).scoped().proxy(),
+    integrationHealthService: asFunction(({ integrationStateService, integrationLogService }: Cradle) =>
+      createHealthService(container, integrationStateService, integrationLogService),
+    ).scoped().proxy(),
+    SyncExternalIdMapping: asValue(SyncExternalIdMapping),
+    IntegrationCredentials: asValue(IntegrationCredentials),
+    IntegrationState: asValue(IntegrationState),
+    IntegrationLog: asValue(IntegrationLog),
+  })
+}

package/src/modules/integrations/events.ts

@@ -0,0 +1,17 @@
+import { createModuleEvents } from '@open-mercato/shared/modules/events'
+
+const events = [
+  { id: 'integrations.credentials.updated', label: 'Integration Credentials Updated', category: 'custom', entity: 'credentials' },
+  { id: 'integrations.state.updated', label: 'Integration State Updated', category: 'custom', entity: 'state' },
+  { id: 'integrations.version.changed', label: 'Integration Version Changed', category: 'custom', entity: 'state' },
+  { id: 'integrations.log.created', label: 'Integration Log Created', category: 'system', entity: 'log', excludeFromTriggers: true },
+] as const
+
+export const eventsConfig = createModuleEvents({
+  moduleId: 'integrations',
+  events,
+})
+
+export const emitIntegrationsEvent = eventsConfig.emit
+
+export default eventsConfig