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

package/src/modules/data_sync/api/mappings/route.ts

@@ -0,0 +1,144 @@
+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 { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
+import { findAndCountWithDecryption, findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { SyncMapping } from '../../data/entities'
+
+const listMappingsQuerySchema = z.object({
+  integrationId: z.string().min(1).optional(),
+  entityType: z.string().min(1).optional(),
+  page: z.coerce.number().int().min(1).default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).default(20),
+})
+
+const createMappingSchema = z.object({
+  integrationId: z.string().min(1),
+  entityType: z.string().min(1),
+  mapping: z.record(z.string(), z.unknown()),
+})
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['data_sync.view'] },
+  POST: { requireAuth: true, requireFeatures: ['data_sync.configure'] },
+}
+
+export const openApi = {
+  tags: ['DataSync'],
+  summary: 'List or create field mappings',
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const url = new URL(req.url)
+  const parsed = listMappingsQuerySchema.safeParse({
+    integrationId: url.searchParams.get('integrationId') ?? undefined,
+    entityType: url.searchParams.get('entityType') ?? undefined,
+    page: url.searchParams.get('page') ?? undefined,
+    pageSize: url.searchParams.get('pageSize') ?? undefined,
+  })
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid query', details: parsed.error.flatten() }, { status: 400 })
+  }
+
+  const container = await createRequestContainer()
+  const em = container.resolve('em') as EntityManager
+  const scope = { organizationId: auth.orgId as string, tenantId: auth.tenantId }
+
+  const where: FilterQuery<SyncMapping> = {
+    organizationId: scope.organizationId,
+    tenantId: scope.tenantId,
+  }
+  if (parsed.data.integrationId) where.integrationId = parsed.data.integrationId
+  if (parsed.data.entityType) where.entityType = parsed.data.entityType
+
+  const [items, total] = await findAndCountWithDecryption(
+    em,
+    SyncMapping,
+    where,
+    {
+      orderBy: { createdAt: 'DESC' },
+      limit: parsed.data.pageSize,
+      offset: (parsed.data.page - 1) * parsed.data.pageSize,
+    },
+    scope,
+  )
+
+  return NextResponse.json({
+    items: items.map((item) => ({
+      id: item.id,
+      integrationId: item.integrationId,
+      entityType: item.entityType,
+      mapping: item.mapping,
+      createdAt: item.createdAt.toISOString(),
+      updatedAt: item.updatedAt.toISOString(),
+    })),
+    total,
+    page: parsed.data.page,
+    pageSize: parsed.data.pageSize,
+    totalPages: Math.max(1, Math.ceil(total / parsed.data.pageSize)),
+  })
+}
+
+export async function POST(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const payload = await req.json().catch(() => null)
+  const parsed = createMappingSchema.safeParse(payload)
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload', details: parsed.error.flatten() }, { status: 422 })
+  }
+
+  const container = await createRequestContainer()
+  const em = container.resolve('em') as EntityManager
+  const scope = { organizationId: auth.orgId as string, tenantId: auth.tenantId }
+
+  const existing = await findOneWithDecryption(
+    em,
+    SyncMapping,
+    {
+      integrationId: parsed.data.integrationId,
+      entityType: parsed.data.entityType,
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+    },
+    undefined,
+    scope,
+  )
+
+  if (existing) {
+    existing.mapping = parsed.data.mapping
+    await em.flush()
+    return NextResponse.json({
+      id: existing.id,
+      integrationId: existing.integrationId,
+      entityType: existing.entityType,
+      mapping: existing.mapping,
+    })
+  }
+
+  const created = em.create(SyncMapping, {
+    integrationId: parsed.data.integrationId,
+    entityType: parsed.data.entityType,
+    mapping: parsed.data.mapping,
+    organizationId: scope.organizationId,
+    tenantId: scope.tenantId,
+  })
+  await em.persistAndFlush(created)
+
+  return NextResponse.json({
+    id: created.id,
+    integrationId: created.integrationId,
+    entityType: created.entityType,
+    mapping: created.mapping,
+  }, { status: 201 })
+}

package/src/modules/data_sync/api/run.ts

@@ -0,0 +1,97 @@
+import { NextResponse } from 'next/server'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { ProgressService } from '../../progress/lib/progressService'
+import type { SyncRunService } from '../lib/sync-run-service'
+import { runSyncSchema } from '../data/validators'
+import { getSyncQueue } from '../lib/queue'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['data_sync.run'] },
+}
+
+export const openApi = {
+  tags: ['DataSync'],
+  summary: 'Start a data sync run',
+}
+
+export async function POST(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const payload = await req.json().catch(() => null)
+  const parsed = runSyncSchema.safeParse(payload)
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload', details: parsed.error.flatten() }, { status: 422 })
+  }
+
+  const container = await createRequestContainer()
+  const syncRunService = container.resolve('dataSyncRunService') as SyncRunService
+  const progressService = container.resolve('progressService') as ProgressService
+
+  const scope = {
+    organizationId: auth.orgId as string,
+    tenantId: auth.tenantId,
+  }
+
+  const overlap = await syncRunService.findRunningOverlap(
+    parsed.data.integrationId,
+    parsed.data.entityType,
+    parsed.data.direction,
+    scope,
+  )
+  if (overlap) {
+    return NextResponse.json({ error: 'A sync run is already in progress for this integration and entity direction' }, { status: 409 })
+  }
+
+  const cursor = parsed.data.fullSync
+    ? null
+    : await syncRunService.resolveCursor(parsed.data.integrationId, parsed.data.entityType, parsed.data.direction, scope)
+
+  const progressJob = await progressService.createJob(
+    {
+      jobType: `data_sync:${parsed.data.direction}`,
+      name: `Data sync ${parsed.data.integrationId}`,
+      description: `${parsed.data.entityType} ${parsed.data.direction}`,
+      cancellable: true,
+      meta: {
+        integrationId: parsed.data.integrationId,
+        entityType: parsed.data.entityType,
+        direction: parsed.data.direction,
+      },
+    },
+    {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+      userId: auth.sub,
+    },
+  )
+
+  const run = await syncRunService.createRun(
+    {
+      integrationId: parsed.data.integrationId,
+      entityType: parsed.data.entityType,
+      direction: parsed.data.direction,
+      cursor,
+      triggeredBy: parsed.data.triggeredBy ?? auth.sub,
+      progressJobId: progressJob.id,
+    },
+    scope,
+  )
+
+  const queueName = parsed.data.direction === 'import' ? 'data-sync-import' : 'data-sync-export'
+  const queue = getSyncQueue(queueName)
+  await queue.enqueue({
+    runId: run.id,
+    batchSize: parsed.data.batchSize,
+    scope: {
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      userId: auth.sub,
+    },
+  })
+
+  return NextResponse.json({ id: run.id, progressJobId: progressJob.id }, { status: 201 })
+}

package/src/modules/data_sync/api/runs/[id]/cancel.ts

@@ -0,0 +1,57 @@
+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 { ProgressService } from '../../../../progress/lib/progressService'
+import type { SyncRunService } from '../../../lib/sync-run-service'
+
+const paramsSchema = z.object({ id: z.string().uuid() })
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['data_sync.run'] },
+}
+
+export const openApi = {
+  tags: ['DataSync'],
+  summary: 'Cancel a running sync',
+}
+
+export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }> | { id?: string } }) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const rawParams = (ctx.params && typeof (ctx.params as Promise<unknown>).then === 'function')
+    ? await (ctx.params as Promise<{ id?: string }>)
+    : (ctx.params as { id?: string } | undefined)
+
+  const parsed = paramsSchema.safeParse(rawParams)
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid run id' }, { status: 400 })
+  }
+
+  const container = await createRequestContainer()
+  const syncRunService = container.resolve('dataSyncRunService') as SyncRunService
+  const progressService = container.resolve('progressService') as ProgressService
+  const scope = { organizationId: auth.orgId as string, tenantId: auth.tenantId }
+
+  const run = await syncRunService.getRun(parsed.data.id, scope)
+  if (!run) {
+    return NextResponse.json({ error: 'Run not found' }, { status: 404 })
+  }
+  if (run.status !== 'running' && run.status !== 'pending') {
+    return NextResponse.json({ error: 'Only pending or running runs can be cancelled' }, { status: 409 })
+  }
+
+  if (run.progressJobId) {
+    await progressService.cancelJob(run.progressJobId, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+      userId: auth.sub,
+    })
+  }
+
+  await syncRunService.markStatus(run.id, 'cancelled', scope)
+  return NextResponse.json({ ok: true })
+}

package/src/modules/data_sync/api/runs/[id]/retry.ts

@@ -0,0 +1,108 @@
+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 { ProgressService } from '../../../../progress/lib/progressService'
+import type { SyncRunService } from '../../../lib/sync-run-service'
+import { retrySyncSchema } from '../../../data/validators'
+import { getSyncQueue } from '../../../lib/queue'
+
+const paramsSchema = z.object({ id: z.string().uuid() })
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['data_sync.run'] },
+}
+
+export const openApi = {
+  tags: ['DataSync'],
+  summary: 'Retry a failed sync run',
+}
+
+export async function POST(req: Request, ctx: { params?: Promise<{ id?: string }> | { id?: string } }) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const rawParams = (ctx.params && typeof (ctx.params as Promise<unknown>).then === 'function')
+    ? await (ctx.params as Promise<{ id?: string }>)
+    : (ctx.params as { id?: string } | undefined)
+
+  const parsedParams = paramsSchema.safeParse(rawParams)
+  if (!parsedParams.success) {
+    return NextResponse.json({ error: 'Invalid run id' }, { status: 400 })
+  }
+
+  const payload = await req.json().catch(() => null)
+  const parsedBody = retrySyncSchema.safeParse(payload ?? {})
+  if (!parsedBody.success) {
+    return NextResponse.json({ error: 'Invalid payload', details: parsedBody.error.flatten() }, { status: 422 })
+  }
+
+  const container = await createRequestContainer()
+  const syncRunService = container.resolve('dataSyncRunService') as SyncRunService
+  const progressService = container.resolve('progressService') as ProgressService
+  const scope = { organizationId: auth.orgId as string, tenantId: auth.tenantId }
+
+  const previous = await syncRunService.getRun(parsedParams.data.id, scope)
+  if (!previous) {
+    return NextResponse.json({ error: 'Run not found' }, { status: 404 })
+  }
+  if (previous.status !== 'failed' && previous.status !== 'cancelled') {
+    return NextResponse.json({ error: 'Only failed or cancelled runs can be retried' }, { status: 409 })
+  }
+
+  const overlap = await syncRunService.findRunningOverlap(
+    previous.integrationId,
+    previous.entityType,
+    previous.direction,
+    scope,
+  )
+  if (overlap) {
+    return NextResponse.json({ error: 'A sync run is already in progress for this integration and entity direction' }, { status: 409 })
+  }
+
+  const cursor = parsedBody.data.fromBeginning
+    ? null
+    : previous.cursor ?? await syncRunService.resolveCursor(previous.integrationId, previous.entityType, previous.direction, scope)
+
+  const progressJob = await progressService.createJob(
+    {
+      jobType: `data_sync:${previous.direction}`,
+      name: `Retry data sync ${previous.integrationId}`,
+      description: `${previous.entityType} ${previous.direction}`,
+      cancellable: true,
+    },
+    {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+      userId: auth.sub,
+    },
+  )
+
+  const run = await syncRunService.createRun(
+    {
+      integrationId: previous.integrationId,
+      entityType: previous.entityType,
+      direction: previous.direction,
+      cursor,
+      triggeredBy: auth.sub,
+      progressJobId: progressJob.id,
+    },
+    scope,
+  )
+
+  const queueName = run.direction === 'import' ? 'data-sync-import' : 'data-sync-export'
+  const queue = getSyncQueue(queueName)
+  await queue.enqueue({
+    runId: run.id,
+    batchSize: 100,
+    scope: {
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      userId: auth.sub,
+    },
+  })
+
+  return NextResponse.json({ id: run.id, progressJobId: progressJob.id }, { status: 201 })
+}

package/src/modules/data_sync/api/runs/[id]/route.ts

@@ -0,0 +1,81 @@
+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 { ProgressService } from '../../../../progress/lib/progressService'
+import type { SyncRunService } from '../../../lib/sync-run-service'
+
+const paramsSchema = z.object({ id: z.string().uuid() })
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['data_sync.view'] },
+}
+
+export const openApi = {
+  tags: ['DataSync'],
+  summary: 'Get sync run detail',
+}
+
+export async function GET(req: Request, ctx: { params?: Promise<{ id?: string }> | { id?: string } }) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const rawParams = (ctx.params && typeof (ctx.params as Promise<unknown>).then === 'function')
+    ? await (ctx.params as Promise<{ id?: string }>)
+    : (ctx.params as { id?: string } | undefined)
+
+  const parsed = paramsSchema.safeParse(rawParams)
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid run id' }, { status: 400 })
+  }
+
+  const container = await createRequestContainer()
+  const syncRunService = container.resolve('dataSyncRunService') as SyncRunService
+  const progressService = container.resolve('progressService') as ProgressService
+  const scope = { organizationId: auth.orgId as string, tenantId: auth.tenantId }
+
+  const run = await syncRunService.getRun(parsed.data.id, scope)
+  if (!run) {
+    return NextResponse.json({ error: 'Run not found' }, { status: 404 })
+  }
+
+  const progressJob = run.progressJobId
+    ? await progressService.getJob(run.progressJobId, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+      userId: auth.sub,
+    })
+    : null
+
+  return NextResponse.json({
+    id: run.id,
+    integrationId: run.integrationId,
+    entityType: run.entityType,
+    direction: run.direction,
+    status: run.status,
+    cursor: run.cursor ?? null,
+    initialCursor: run.initialCursor ?? null,
+    createdCount: run.createdCount,
+    updatedCount: run.updatedCount,
+    skippedCount: run.skippedCount,
+    failedCount: run.failedCount,
+    batchesCompleted: run.batchesCompleted,
+    lastError: run.lastError ?? null,
+    progressJobId: run.progressJobId ?? null,
+    progressJob: progressJob
+      ? {
+        id: progressJob.id,
+        status: progressJob.status,
+        progressPercent: progressJob.progressPercent,
+        processedCount: progressJob.processedCount,
+        totalCount: progressJob.totalCount ?? null,
+        etaSeconds: progressJob.etaSeconds ?? null,
+      }
+      : null,
+    triggeredBy: run.triggeredBy ?? null,
+    createdAt: run.createdAt.toISOString(),
+    updatedAt: run.updatedAt.toISOString(),
+  })
+}

package/src/modules/data_sync/api/runs.ts

@@ -0,0 +1,69 @@
+import { NextResponse } from 'next/server'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { listSyncRunsQuerySchema } from '../data/validators'
+import type { SyncRunService } from '../lib/sync-run-service'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['data_sync.view'] },
+}
+
+export const openApi = {
+  tags: ['DataSync'],
+  summary: 'List sync runs',
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const url = new URL(req.url)
+  const parsed = listSyncRunsQuerySchema.safeParse({
+    integrationId: url.searchParams.get('integrationId') ?? undefined,
+    entityType: url.searchParams.get('entityType') ?? undefined,
+    direction: url.searchParams.get('direction') ?? undefined,
+    status: url.searchParams.get('status') ?? undefined,
+    page: url.searchParams.get('page') ?? undefined,
+    pageSize: url.searchParams.get('pageSize') ?? undefined,
+  })
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid query', details: parsed.error.flatten() }, { status: 400 })
+  }
+
+  const container = await createRequestContainer()
+  const syncRunService = container.resolve('dataSyncRunService') as SyncRunService
+
+  const { items, total } = await syncRunService.listRuns(parsed.data, {
+    organizationId: auth.orgId as string,
+    tenantId: auth.tenantId,
+  })
+
+  return NextResponse.json({
+    items: items.map((item) => ({
+      id: item.id,
+      integrationId: item.integrationId,
+      entityType: item.entityType,
+      direction: item.direction,
+      status: item.status,
+      cursor: item.cursor ?? null,
+      initialCursor: item.initialCursor ?? null,
+      createdCount: item.createdCount,
+      updatedCount: item.updatedCount,
+      skippedCount: item.skippedCount,
+      failedCount: item.failedCount,
+      batchesCompleted: item.batchesCompleted,
+      lastError: item.lastError ?? null,
+      progressJobId: item.progressJobId ?? null,
+      triggeredBy: item.triggeredBy ?? null,
+      createdAt: item.createdAt.toISOString(),
+      updatedAt: item.updatedAt.toISOString(),
+    })),
+    total,
+    page: parsed.data.page,
+    pageSize: parsed.data.pageSize,
+    totalPages: Math.max(1, Math.ceil(total / parsed.data.pageSize)),
+  })
+}

package/src/modules/data_sync/api/validate.ts

@@ -0,0 +1,73 @@
+import { NextResponse } from 'next/server'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getIntegration } from '@open-mercato/shared/modules/integrations/types'
+import type { CredentialsService } from '../../integrations/lib/credentials-service'
+import { validateConnectionSchema } from '../data/validators'
+import { getDataSyncAdapter } from '../lib/adapter-registry'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['data_sync.configure'] },
+}
+
+export const openApi = {
+  tags: ['DataSync'],
+  summary: 'Validate sync connection',
+}
+
+export async function POST(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const parsed = validateConnectionSchema.safeParse(await req.json())
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload', details: parsed.error.flatten() }, { status: 422 })
+  }
+
+  const integration = getIntegration(parsed.data.integrationId)
+  if (!integration?.providerKey) {
+    return NextResponse.json({ ok: false, message: 'Integration or providerKey not found' }, { status: 404 })
+  }
+
+  const adapter = getDataSyncAdapter(integration.providerKey)
+  if (!adapter) {
+    return NextResponse.json({ ok: false, message: 'No registered sync adapter for provider' }, { status: 404 })
+  }
+
+  const container = await createRequestContainer()
+  const credentialsService = container.resolve('integrationCredentialsService') as CredentialsService
+  const credentials = await credentialsService.resolve(integration.id, {
+    organizationId: auth.orgId as string,
+    tenantId: auth.tenantId,
+  })
+
+  if (!credentials) {
+    return NextResponse.json({ ok: false, message: 'Missing credentials' }, { status: 422 })
+  }
+
+  const mapping = await adapter.getMapping({
+    entityType: parsed.data.entityType,
+    scope: {
+      organizationId: auth.orgId as string,
+      tenantId: auth.tenantId,
+    },
+  })
+
+  if (!adapter.validateConnection) {
+    return NextResponse.json({ ok: true, message: 'Adapter does not implement active connection validation' })
+  }
+
+  const result = await adapter.validateConnection({
+    entityType: parsed.data.entityType,
+    credentials,
+    mapping,
+    scope: {
+      organizationId: auth.orgId as string,
+      tenantId: auth.tenantId,
+    },
+  })
+
+  return NextResponse.json(result, { status: result.ok ? 200 : 422 })
+}

package/src/modules/data_sync/backend/data-sync/page.meta.ts

@@ -0,0 +1,21 @@
+import React from 'react'
+
+const syncIcon = React.createElement('svg', { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2 },
+  React.createElement('path', { d: 'M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8' }),
+  React.createElement('path', { d: 'M3 3v5h5' }),
+  React.createElement('path', { d: 'M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16' }),
+  React.createElement('path', { d: 'M16 16h5v5' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['data_sync.view'],
+  pageTitle: 'Data Sync',
+  pageTitleKey: 'data_sync.nav.title',
+  pageGroup: 'Settings',
+  pageGroupKey: 'settings.sections.general',
+  pageOrder: 51,
+  icon: syncIcon,
+  pageContext: 'settings' as const,
+  breadcrumb: [{ label: 'Data Sync', labelKey: 'data_sync.nav.title' }],
+}