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

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

@@ -0,0 +1,180 @@
+import { Entity, Index, OptionalProps, PrimaryKey, Property } from '@mikro-orm/core'
+
+@Entity({ tableName: 'sync_runs' })
+@Index({ properties: ['integrationId', 'entityType', 'status', 'organizationId', 'tenantId'] })
+export class SyncRun {
+  [OptionalProps]?: 'status' | 'cursor' | 'initialCursor' | 'createdCount' | 'updatedCount' | 'skippedCount' | 'failedCount' | 'batchesCompleted' | 'lastError' | 'progressJobId' | 'jobId' | 'triggeredBy' | 'createdAt' | 'updatedAt' | 'deletedAt'
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'integration_id', type: 'text' })
+  integrationId!: string
+
+  @Property({ name: 'entity_type', type: 'text' })
+  entityType!: string
+
+  @Property({ name: 'direction', type: 'text' })
+  direction!: 'import' | 'export'
+
+  @Property({ name: 'status', type: 'text' })
+  status!: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'paused'
+
+  @Property({ name: 'cursor', type: 'text', nullable: true })
+  cursor?: string | null
+
+  @Property({ name: 'initial_cursor', type: 'text', nullable: true })
+  initialCursor?: string | null
+
+  @Property({ name: 'created_count', type: 'int', default: 0 })
+  createdCount: number = 0
+
+  @Property({ name: 'updated_count', type: 'int', default: 0 })
+  updatedCount: number = 0
+
+  @Property({ name: 'skipped_count', type: 'int', default: 0 })
+  skippedCount: number = 0
+
+  @Property({ name: 'failed_count', type: 'int', default: 0 })
+  failedCount: number = 0
+
+  @Property({ name: 'batches_completed', type: 'int', default: 0 })
+  batchesCompleted: number = 0
+
+  @Property({ name: 'last_error', type: 'text', nullable: true })
+  lastError?: string | null
+
+  @Property({ name: 'progress_job_id', type: 'uuid', nullable: true })
+  progressJobId?: string | null
+
+  @Property({ name: 'job_id', type: 'text', nullable: true })
+  jobId?: string | null
+
+  @Property({ name: 'triggered_by', type: 'text', nullable: true })
+  triggeredBy?: string | 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: 'sync_cursors' })
+@Index({ properties: ['integrationId', 'entityType', 'direction', 'organizationId', 'tenantId'], options: { unique: true } })
+export class SyncCursor {
+  [OptionalProps]?: 'cursor' | 'updatedAt'
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'integration_id', type: 'text' })
+  integrationId!: string
+
+  @Property({ name: 'entity_type', type: 'text' })
+  entityType!: string
+
+  @Property({ name: 'direction', type: 'text' })
+  direction!: 'import' | 'export'
+
+  @Property({ name: 'cursor', type: 'text', nullable: true })
+  cursor?: string | null
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'updated_at', type: Date, onCreate: () => new Date(), onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+}
+
+@Entity({ tableName: 'sync_mappings' })
+@Index({ properties: ['integrationId', 'entityType', 'organizationId', 'tenantId'], options: { unique: true } })
+export class SyncMapping {
+  [OptionalProps]?: 'createdAt' | 'updatedAt'
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'integration_id', type: 'text' })
+  integrationId!: string
+
+  @Property({ name: 'entity_type', type: 'text' })
+  entityType!: string
+
+  @Property({ name: 'mapping', type: 'json' })
+  mapping!: 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()
+}
+
+@Entity({ tableName: 'sync_schedules' })
+@Index({ properties: ['integrationId', 'entityType', 'direction', 'organizationId', 'tenantId'] })
+export class SyncSchedule {
+  [OptionalProps]?: 'timezone' | 'fullSync' | 'isEnabled' | 'scheduledJobId' | 'lastRunAt' | 'createdAt' | 'updatedAt' | 'deletedAt'
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'integration_id', type: 'text' })
+  integrationId!: string
+
+  @Property({ name: 'entity_type', type: 'text' })
+  entityType!: string
+
+  @Property({ name: 'direction', type: 'text' })
+  direction!: 'import' | 'export'
+
+  @Property({ name: 'schedule_type', type: 'text' })
+  scheduleType!: 'cron' | 'interval'
+
+  @Property({ name: 'schedule_value', type: 'text' })
+  scheduleValue!: string
+
+  @Property({ name: 'timezone', type: 'text', default: 'UTC' })
+  timezone: string = 'UTC'
+
+  @Property({ name: 'full_sync', type: 'boolean', default: false })
+  fullSync: boolean = false
+
+  @Property({ name: 'is_enabled', type: 'boolean', default: true })
+  isEnabled: boolean = true
+
+  @Property({ name: 'scheduled_job_id', type: 'uuid', nullable: true })
+  scheduledJobId?: string | null
+
+  @Property({ name: 'last_run_at', type: Date, nullable: true })
+  lastRunAt?: 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
+}

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

@@ -0,0 +1,35 @@
+import { z } from 'zod'
+
+export const runSyncSchema = z.object({
+  integrationId: z.string().min(1),
+  entityType: z.string().min(1),
+  direction: z.enum(['import', 'export']),
+  fullSync: z.boolean().default(false),
+  batchSize: z.number().int().min(1).max(1000).default(100),
+  triggeredBy: z.string().optional(),
+})
+
+export type RunSyncInput = z.infer<typeof runSyncSchema>
+
+export const retrySyncSchema = z.object({
+  fromBeginning: z.boolean().default(false),
+})
+
+export type RetrySyncInput = z.infer<typeof retrySyncSchema>
+
+export const validateConnectionSchema = z.object({
+  integrationId: z.string().min(1),
+  entityType: z.string().min(1),
+  direction: z.enum(['import', 'export']),
+})
+
+export const listSyncRunsQuerySchema = z.object({
+  integrationId: z.string().optional(),
+  entityType: z.string().optional(),
+  direction: z.enum(['import', 'export']).optional(),
+  status: z.enum(['pending', 'running', 'completed', 'failed', 'cancelled', 'paused']).optional(),
+  page: z.coerce.number().int().min(1).default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).default(20),
+})
+
+export type ListSyncRunsQuery = z.infer<typeof listSyncRunsQuerySchema>

package/src/modules/data_sync/di.ts

@@ -0,0 +1,38 @@
+import { asFunction, asValue } from 'awilix'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import type { CredentialsService } from '../integrations/lib/credentials-service'
+import type { IntegrationLogService } from '../integrations/lib/log-service'
+import type { ProgressService } from '../progress/lib/progressService'
+import { SyncCursor, SyncMapping, SyncRun, SyncSchedule } from './data/entities'
+import { createExternalIdMappingService } from './lib/id-mapping'
+import { createSyncRunService } from './lib/sync-run-service'
+import { createSyncEngine } from './lib/sync-engine'
+
+type Cradle = {
+  em: EntityManager
+  integrationCredentialsService: CredentialsService
+  integrationLogService: IntegrationLogService
+  progressService: ProgressService
+}
+
+export function register(container: AppContainer) {
+  container.register({
+    externalIdMappingService: asFunction(({ em }: Cradle) => createExternalIdMappingService(em)).scoped().proxy(),
+    dataSyncRunService: asFunction(({ em }: Cradle) => createSyncRunService(em)).scoped().proxy(),
+    dataSyncEngine: asFunction(({ em, dataSyncRunService, integrationCredentialsService, integrationLogService, progressService }: Cradle & {
+      dataSyncRunService: ReturnType<typeof createSyncRunService>
+    }) => createSyncEngine({
+      em,
+      syncRunService: dataSyncRunService,
+      integrationCredentialsService,
+      integrationLogService,
+      progressService,
+    })).scoped().proxy(),
+
+    SyncRun: asValue(SyncRun),
+    SyncCursor: asValue(SyncCursor),
+    SyncMapping: asValue(SyncMapping),
+    SyncSchedule: asValue(SyncSchedule),
+  })
+}

package/src/modules/data_sync/events.ts

@@ -0,0 +1,12 @@
+import { createModuleEvents } from '@open-mercato/shared/modules/events'
+
+const events = [
+  { id: 'data_sync.run.started', label: 'Sync Run Started', category: 'lifecycle', entity: 'run' },
+  { id: 'data_sync.run.completed', label: 'Sync Run Completed', category: 'lifecycle', entity: 'run' },
+  { id: 'data_sync.run.failed', label: 'Sync Run Failed', category: 'lifecycle', entity: 'run' },
+  { id: 'data_sync.run.cancelled', label: 'Sync Run Cancelled', category: 'lifecycle', entity: 'run' },
+] as const
+
+export const eventsConfig = createModuleEvents({ moduleId: 'data_sync', events })
+export const emitDataSyncEvent = eventsConfig.emit
+export default eventsConfig

package/src/modules/data_sync/i18n/de.json

@@ -0,0 +1,48 @@
+{
+  "data_sync.dashboard.actions.view": "Anzeigen",
+  "data_sync.dashboard.columns.created": "Erstellt",
+  "data_sync.dashboard.columns.createdAt": "Gestartet",
+  "data_sync.dashboard.columns.direction": "Richtung",
+  "data_sync.dashboard.columns.entityType": "Entitätstyp",
+  "data_sync.dashboard.columns.failed": "Fehlgeschlagen",
+  "data_sync.dashboard.columns.integration": "Integration",
+  "data_sync.dashboard.columns.status": "Status",
+  "data_sync.dashboard.columns.updated": "Aktualisiert",
+  "data_sync.dashboard.direction.export": "Export",
+  "data_sync.dashboard.direction.import": "Import",
+  "data_sync.dashboard.filters.allDirections": "Alle Richtungen",
+  "data_sync.dashboard.filters.allStatuses": "Alle Status",
+  "data_sync.dashboard.filters.status": "Status",
+  "data_sync.dashboard.loadError": "Synchronisierungsläufe konnten nicht geladen werden",
+  "data_sync.dashboard.noRuns": "Noch keine Synchronisierungsläufe",
+  "data_sync.dashboard.status.cancelled": "Abgebrochen",
+  "data_sync.dashboard.status.completed": "Abgeschlossen",
+  "data_sync.dashboard.status.failed": "Fehlgeschlagen",
+  "data_sync.dashboard.status.paused": "Pausiert",
+  "data_sync.dashboard.status.pending": "Ausstehend",
+  "data_sync.dashboard.status.running": "Läuft",
+  "data_sync.dashboard.title": "Synchronisierungsläufe",
+  "data_sync.nav.title": "Datensynchronisation",
+  "data_sync.runs.detail.back": "Zurück zu Läufen",
+  "data_sync.runs.detail.cancel": "Abbrechen",
+  "data_sync.runs.detail.cancelError": "Lauf konnte nicht abgebrochen werden",
+  "data_sync.runs.detail.cancelSuccess": "Lauf abgebrochen",
+  "data_sync.runs.detail.counters.created": "Erstellt",
+  "data_sync.runs.detail.counters.failed": "Fehlgeschlagen",
+  "data_sync.runs.detail.counters.skipped": "Übersprungen",
+  "data_sync.runs.detail.counters.updated": "Aktualisiert",
+  "data_sync.runs.detail.error": "Fehler",
+  "data_sync.runs.detail.loadError": "Lauf konnte nicht geladen werden",
+  "data_sync.runs.detail.logs": "Betriebsprotokolle",
+  "data_sync.runs.detail.logs.level": "Stufe",
+  "data_sync.runs.detail.logs.message": "Nachricht",
+  "data_sync.runs.detail.logs.time": "Zeit",
+  "data_sync.runs.detail.noLogs": "Keine Protokolleinträge",
+  "data_sync.runs.detail.progress": "Fortschritt",
+  "data_sync.runs.detail.progress.batches": "{count} Stapel",
+  "data_sync.runs.detail.progress.itemsProcessed": "{count} Elemente verarbeitet",
+  "data_sync.runs.detail.retry": "Wiederholen",
+  "data_sync.runs.detail.retryError": "Lauf konnte nicht wiederholt werden",
+  "data_sync.runs.detail.retrySuccess": "Lauf wiederholt",
+  "data_sync.runs.detail.title": "Synchronisierungslauf"
+}

package/src/modules/data_sync/i18n/en.json

@@ -0,0 +1,48 @@
+{
+  "data_sync.dashboard.actions.view": "View",
+  "data_sync.dashboard.columns.created": "Created",
+  "data_sync.dashboard.columns.createdAt": "Started",
+  "data_sync.dashboard.columns.direction": "Direction",
+  "data_sync.dashboard.columns.entityType": "Entity Type",
+  "data_sync.dashboard.columns.failed": "Failed",
+  "data_sync.dashboard.columns.integration": "Integration",
+  "data_sync.dashboard.columns.status": "Status",
+  "data_sync.dashboard.columns.updated": "Updated",
+  "data_sync.dashboard.direction.export": "Export",
+  "data_sync.dashboard.direction.import": "Import",
+  "data_sync.dashboard.filters.allDirections": "All Directions",
+  "data_sync.dashboard.filters.allStatuses": "All Statuses",
+  "data_sync.dashboard.filters.status": "Status",
+  "data_sync.dashboard.loadError": "Failed to load sync runs",
+  "data_sync.dashboard.noRuns": "No sync runs yet",
+  "data_sync.dashboard.status.cancelled": "Cancelled",
+  "data_sync.dashboard.status.completed": "Completed",
+  "data_sync.dashboard.status.failed": "Failed",
+  "data_sync.dashboard.status.paused": "Paused",
+  "data_sync.dashboard.status.pending": "Pending",
+  "data_sync.dashboard.status.running": "Running",
+  "data_sync.dashboard.title": "Sync Runs",
+  "data_sync.nav.title": "Data Sync",
+  "data_sync.runs.detail.back": "Back to Sync Runs",
+  "data_sync.runs.detail.cancel": "Cancel",
+  "data_sync.runs.detail.cancelError": "Failed to cancel sync run",
+  "data_sync.runs.detail.cancelSuccess": "Sync run cancelled",
+  "data_sync.runs.detail.counters.created": "Created",
+  "data_sync.runs.detail.counters.failed": "Failed",
+  "data_sync.runs.detail.counters.skipped": "Skipped",
+  "data_sync.runs.detail.counters.updated": "Updated",
+  "data_sync.runs.detail.error": "Error",
+  "data_sync.runs.detail.loadError": "Failed to load sync run",
+  "data_sync.runs.detail.logs": "Operation Logs",
+  "data_sync.runs.detail.logs.level": "Level",
+  "data_sync.runs.detail.logs.message": "Message",
+  "data_sync.runs.detail.logs.time": "Time",
+  "data_sync.runs.detail.noLogs": "No log entries",
+  "data_sync.runs.detail.progress": "Progress",
+  "data_sync.runs.detail.progress.batches": "{count} batches",
+  "data_sync.runs.detail.progress.itemsProcessed": "{count} items processed",
+  "data_sync.runs.detail.retry": "Retry",
+  "data_sync.runs.detail.retryError": "Failed to retry sync run",
+  "data_sync.runs.detail.retrySuccess": "Sync run retried",
+  "data_sync.runs.detail.title": "Sync Run"
+}

package/src/modules/data_sync/i18n/es.json

@@ -0,0 +1,48 @@
+{
+  "data_sync.dashboard.actions.view": "Ver",
+  "data_sync.dashboard.columns.created": "Creados",
+  "data_sync.dashboard.columns.createdAt": "Iniciado",
+  "data_sync.dashboard.columns.direction": "Dirección",
+  "data_sync.dashboard.columns.entityType": "Tipo de entidad",
+  "data_sync.dashboard.columns.failed": "Fallidos",
+  "data_sync.dashboard.columns.integration": "Integración",
+  "data_sync.dashboard.columns.status": "Estado",
+  "data_sync.dashboard.columns.updated": "Actualizados",
+  "data_sync.dashboard.direction.export": "Exportación",
+  "data_sync.dashboard.direction.import": "Importación",
+  "data_sync.dashboard.filters.allDirections": "Todas las direcciones",
+  "data_sync.dashboard.filters.allStatuses": "Todos los estados",
+  "data_sync.dashboard.filters.status": "Estado",
+  "data_sync.dashboard.loadError": "No se pudieron cargar las ejecuciones de sincronización",
+  "data_sync.dashboard.noRuns": "Sin ejecuciones de sincronización",
+  "data_sync.dashboard.status.cancelled": "Cancelado",
+  "data_sync.dashboard.status.completed": "Completado",
+  "data_sync.dashboard.status.failed": "Fallido",
+  "data_sync.dashboard.status.paused": "Pausado",
+  "data_sync.dashboard.status.pending": "Pendiente",
+  "data_sync.dashboard.status.running": "En ejecución",
+  "data_sync.dashboard.title": "Ejecuciones de sincronización",
+  "data_sync.nav.title": "Sincronización de datos",
+  "data_sync.runs.detail.back": "Volver a ejecuciones",
+  "data_sync.runs.detail.cancel": "Cancelar",
+  "data_sync.runs.detail.cancelError": "No se pudo cancelar la ejecución",
+  "data_sync.runs.detail.cancelSuccess": "Ejecución cancelada",
+  "data_sync.runs.detail.counters.created": "Creados",
+  "data_sync.runs.detail.counters.failed": "Fallidos",
+  "data_sync.runs.detail.counters.skipped": "Omitidos",
+  "data_sync.runs.detail.counters.updated": "Actualizados",
+  "data_sync.runs.detail.error": "Error",
+  "data_sync.runs.detail.loadError": "No se pudo cargar la ejecución",
+  "data_sync.runs.detail.logs": "Registros de operación",
+  "data_sync.runs.detail.logs.level": "Nivel",
+  "data_sync.runs.detail.logs.message": "Mensaje",
+  "data_sync.runs.detail.logs.time": "Hora",
+  "data_sync.runs.detail.noLogs": "Sin entradas de registro",
+  "data_sync.runs.detail.progress": "Progreso",
+  "data_sync.runs.detail.progress.batches": "{count} lotes",
+  "data_sync.runs.detail.progress.itemsProcessed": "{count} elementos procesados",
+  "data_sync.runs.detail.retry": "Reintentar",
+  "data_sync.runs.detail.retryError": "No se pudo reintentar la ejecución",
+  "data_sync.runs.detail.retrySuccess": "Ejecución reintentada",
+  "data_sync.runs.detail.title": "Ejecución de sincronización"
+}

package/src/modules/data_sync/i18n/pl.json

@@ -0,0 +1,48 @@
+{
+  "data_sync.dashboard.actions.view": "Zobacz",
+  "data_sync.dashboard.columns.created": "Utworzone",
+  "data_sync.dashboard.columns.createdAt": "Rozpoczęto",
+  "data_sync.dashboard.columns.direction": "Kierunek",
+  "data_sync.dashboard.columns.entityType": "Typ encji",
+  "data_sync.dashboard.columns.failed": "Nieudane",
+  "data_sync.dashboard.columns.integration": "Integracja",
+  "data_sync.dashboard.columns.status": "Status",
+  "data_sync.dashboard.columns.updated": "Zaktualizowane",
+  "data_sync.dashboard.direction.export": "Eksport",
+  "data_sync.dashboard.direction.import": "Import",
+  "data_sync.dashboard.filters.allDirections": "Wszystkie kierunki",
+  "data_sync.dashboard.filters.allStatuses": "Wszystkie statusy",
+  "data_sync.dashboard.filters.status": "Status",
+  "data_sync.dashboard.loadError": "Nie udało się załadować przebiegów",
+  "data_sync.dashboard.noRuns": "Brak przebiegów synchronizacji",
+  "data_sync.dashboard.status.cancelled": "Anulowany",
+  "data_sync.dashboard.status.completed": "Zakończony",
+  "data_sync.dashboard.status.failed": "Nieudany",
+  "data_sync.dashboard.status.paused": "Wstrzymany",
+  "data_sync.dashboard.status.pending": "Oczekujący",
+  "data_sync.dashboard.status.running": "W toku",
+  "data_sync.dashboard.title": "Przebiegi synchronizacji",
+  "data_sync.nav.title": "Synchronizacja danych",
+  "data_sync.runs.detail.back": "Powrót do przebiegów",
+  "data_sync.runs.detail.cancel": "Anuluj",
+  "data_sync.runs.detail.cancelError": "Nie udało się anulować przebiegu",
+  "data_sync.runs.detail.cancelSuccess": "Przebieg anulowany",
+  "data_sync.runs.detail.counters.created": "Utworzone",
+  "data_sync.runs.detail.counters.failed": "Nieudane",
+  "data_sync.runs.detail.counters.skipped": "Pominięte",
+  "data_sync.runs.detail.counters.updated": "Zaktualizowane",
+  "data_sync.runs.detail.error": "Błąd",
+  "data_sync.runs.detail.loadError": "Nie udało się załadować przebiegu",
+  "data_sync.runs.detail.logs": "Logi operacji",
+  "data_sync.runs.detail.logs.level": "Poziom",
+  "data_sync.runs.detail.logs.message": "Wiadomość",
+  "data_sync.runs.detail.logs.time": "Czas",
+  "data_sync.runs.detail.noLogs": "Brak wpisów w logach",
+  "data_sync.runs.detail.progress": "Postęp",
+  "data_sync.runs.detail.progress.batches": "{count} partii",
+  "data_sync.runs.detail.progress.itemsProcessed": "{count} elementów przetworzonych",
+  "data_sync.runs.detail.retry": "Ponów",
+  "data_sync.runs.detail.retryError": "Nie udało się ponowić przebiegu",
+  "data_sync.runs.detail.retrySuccess": "Przebieg ponowiony",
+  "data_sync.runs.detail.title": "Przebieg synchronizacji"
+}

package/src/modules/data_sync/index.ts

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: 'data_sync',
+  title: 'Data Sync',
+  description: 'Streaming data sync hub for import/export integrations.',
+}

package/src/modules/data_sync/lib/adapter-registry.ts

@@ -0,0 +1,15 @@
+import type { DataSyncAdapter } from './adapter'
+
+const adapters = new Map<string, DataSyncAdapter>()
+
+export function registerDataSyncAdapter(adapter: DataSyncAdapter): void {
+  adapters.set(adapter.providerKey, adapter)
+}
+
+export function getDataSyncAdapter(providerKey: string): DataSyncAdapter | undefined {
+  return adapters.get(providerKey)
+}
+
+export function getAllDataSyncAdapters(): DataSyncAdapter[] {
+  return Array.from(adapters.values())
+}

package/src/modules/data_sync/lib/adapter.ts

@@ -0,0 +1,90 @@
+export interface TenantScope {
+  organizationId: string
+  tenantId: string
+}
+
+export interface FieldMapping {
+  externalField: string
+  localField: string
+  transform?: string
+  required?: boolean
+  defaultValue?: unknown
+}
+
+export interface DataMapping {
+  entityType: string
+  fields: FieldMapping[]
+  matchStrategy: 'externalId' | 'sku' | 'email' | 'custom'
+  matchField?: string
+}
+
+export interface StreamImportInput {
+  entityType: string
+  cursor?: string
+  batchSize: number
+  credentials: Record<string, unknown>
+  mapping: DataMapping
+  scope: TenantScope
+}
+
+export interface ImportItem {
+  externalId: string
+  data: Record<string, unknown>
+  action: 'create' | 'update' | 'skip'
+  hash?: string
+}
+
+export interface ImportBatch {
+  items: ImportItem[]
+  cursor: string
+  hasMore: boolean
+  totalEstimate?: number
+  batchIndex: number
+}
+
+export interface StreamExportInput {
+  entityType: string
+  cursor?: string
+  batchSize: number
+  credentials: Record<string, unknown>
+  mapping: DataMapping
+  scope: TenantScope
+  filter?: Record<string, unknown>
+}
+
+export interface ExportItemResult {
+  localId: string
+  externalId?: string
+  status: 'success' | 'error' | 'skipped'
+  error?: string
+}
+
+export interface ExportBatch {
+  results: ExportItemResult[]
+  cursor: string
+  hasMore: boolean
+  batchIndex: number
+}
+
+export interface ValidationResult {
+  ok: boolean
+  message?: string
+  details?: Record<string, unknown>
+}
+
+export interface DataSyncAdapter {
+  readonly providerKey: string
+  readonly direction: 'import' | 'export' | 'bidirectional'
+  readonly supportedEntities: string[]
+
+  streamImport?(input: StreamImportInput): AsyncIterable<ImportBatch>
+  streamExport?(input: StreamExportInput): AsyncIterable<ExportBatch>
+  getInitialCursor?(input: { entityType: string; scope: TenantScope }): Promise<string | null>
+  getMapping(input: { entityType: string; scope: TenantScope }): Promise<DataMapping>
+  validateConnection?(input: {
+    entityType: string
+    credentials: Record<string, unknown>
+    mapping: DataMapping
+    scope: TenantScope
+  }): Promise<ValidationResult>
+}

package/src/modules/data_sync/lib/id-mapping.ts

@@ -0,0 +1,95 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { SyncExternalIdMapping } from '../../integrations/data/entities'
+
+type MappingScope = {
+  organizationId: string
+  tenantId: string
+}
+
+export function createExternalIdMappingService(em: EntityManager) {
+  return {
+    async lookupLocalId(integrationId: string, entityType: string, externalId: string, scope: MappingScope): Promise<string | null> {
+      const row = await findOneWithDecryption(
+        em,
+        SyncExternalIdMapping,
+        {
+        integrationId,
+        internalEntityType: entityType,
+        externalId,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+        deletedAt: null,
+        },
+        undefined,
+        scope,
+      )
+      return row?.internalEntityId ?? null
+    },
+
+    async lookupExternalId(integrationId: string, entityType: string, localId: string, scope: MappingScope): Promise<string | null> {
+      const row = await findOneWithDecryption(
+        em,
+        SyncExternalIdMapping,
+        {
+        integrationId,
+        internalEntityType: entityType,
+        internalEntityId: localId,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+        deletedAt: null,
+        },
+        undefined,
+        scope,
+      )
+      return row?.externalId ?? null
+    },
+
+    async storeExternalIdMapping(
+      integrationId: string,
+      entityType: string,
+      localId: string,
+      externalId: string,
+      scope: MappingScope,
+    ): Promise<SyncExternalIdMapping> {
+      const existing = await findOneWithDecryption(
+        em,
+        SyncExternalIdMapping,
+        {
+        integrationId,
+        internalEntityType: entityType,
+        internalEntityId: localId,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+        deletedAt: null,
+        },
+        undefined,
+        scope,
+      )
+
+      if (existing) {
+        existing.externalId = externalId
+        existing.syncStatus = 'synced'
+        existing.lastSyncedAt = new Date()
+        await em.flush()
+        return existing
+      }
+
+      const created = em.create(SyncExternalIdMapping, {
+        integrationId,
+        internalEntityType: entityType,
+        internalEntityId: localId,
+        externalId,
+        syncStatus: 'synced',
+        lastSyncedAt: new Date(),
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+      })
+
+      await em.persistAndFlush(created)
+      return created
+    },
+  }
+}
+
+export type ExternalIdMappingService = ReturnType<typeof createExternalIdMappingService>