@open-mercato/core 0.6.8-develop.6993.1.3fc50f3409 → 0.6.8-develop.7000.1.0ae682bad1

package/src/modules/data_sync/backend/data-sync/runs/[id]/page.tsx

@@ -19,6 +19,17 @@ import { LoadingMessage, ErrorMessage, RecordNotFoundState } from '@open-mercato
 import { useAppEvent } from '@open-mercato/ui/backend/injection/useAppEvent'
 import { RotateCcw, XCircle } from 'lucide-react'
 import { getSyncRunStatusVariant } from '../../../../lib/syncRunStatus'
+import {
+  buildRetryFailureMessage,
+  resolveRunParameterText,
+  type RetryFailureBody,
+} from '../../../../components/RunParameterFields'
+
+type RunParameterDeclaration = {
+  key: string
+  label?: string
+  labelKey?: string
+}
 
 type SyncRunDetail = {
   id: string
@@ -33,6 +44,7 @@ type SyncRunDetail = {
   batchesCompleted: number
   lastError: string | null
   progressJobId: string | null
+  parameters: Record<string, unknown> | null
   progressJob: {
     id: string
     status: string
@@ -111,6 +123,11 @@ export default function SyncRunDetailPage({ params }: SyncRunDetailPageProps) {
   const [logsTotal, setLogsTotal] = React.useState(0)
   const [logsPage, setLogsPage] = React.useState(1)
   const logsPageRef = React.useRef(1)
+  const [parameterLabels, setParameterLabels] = React.useState<Record<string, string>>({})
+  // Declarations cannot change between two refreshes of the same run, so the
+  // options list is fetched once per integration rather than on every progress
+  // event that re-reads the run.
+  const parameterLabelsIntegrationRef = React.useRef<string | null>(null)
 
   const resolveCurrentRunId = React.useCallback(() => {
     return runId ?? (
@@ -120,6 +137,26 @@ export default function SyncRunDetailPage({ params }: SyncRunDetailPageProps) {
     )
   }, [runId])
 
+  // The run row stores machine keys. Resolve the adapter's declared labels so a
+  // past run reads as "Start id" rather than "startId"; keys the adapter no
+  // longer declares keep their raw form, which keeps historical runs readable.
+  const loadParameterLabels = React.useCallback(async (integrationId: string) => {
+    if (parameterLabelsIntegrationRef.current === integrationId) return
+    parameterLabelsIntegrationRef.current = integrationId
+    const call = await apiCall<{ items?: Array<{ integrationId: string; runParameters?: RunParameterDeclaration[] }> }>(
+      '/api/data_sync/options',
+      undefined,
+      { fallback: { items: [] } },
+    )
+    const declared = (call.result?.items ?? []).find((item) => item.integrationId === integrationId)?.runParameters ?? []
+    const labels: Record<string, string> = {}
+    for (const param of declared) {
+      const resolved = resolveRunParameterText(t, param.labelKey, param.label)
+      if (resolved) labels[param.key] = resolved
+    }
+    setParameterLabels(labels)
+  }, [t])
+
   const loadRun = React.useCallback(async () => {
     const currentRunId = resolveCurrentRunId()
     if (!currentRunId) {
@@ -144,7 +181,10 @@ export default function SyncRunDetailPage({ params }: SyncRunDetailPageProps) {
     }
     setRun(call.result)
     setIsLoading(false)
-  }, [resolveCurrentRunId, t])
+    if (call.result.parameters && Object.keys(call.result.parameters).length > 0) {
+      void loadParameterLabels(call.result.integrationId)
+    }
+  }, [loadParameterLabels, resolveCurrentRunId, t])
 
   const loadLogs = React.useCallback(async (page?: number) => {
     const currentRunId = resolveCurrentRunId()
@@ -268,7 +308,7 @@ export default function SyncRunDetailPage({ params }: SyncRunDetailPageProps) {
       flash(t('data_sync.runs.detail.retrySuccess'), 'success')
       router.push(`/backend/data-sync/runs/${encodeURIComponent(call.result.id)}`)
     } else {
-      flash(t('data_sync.runs.detail.retryError'), 'error')
+      flash(buildRetryFailureMessage(call.result as RetryFailureBody | null, t), 'error')
     }
   }, [resolveCurrentRunId, router, runMutation, t])
 
@@ -404,6 +444,26 @@ export default function SyncRunDetailPage({ params }: SyncRunDetailPageProps) {
           </Card>
         </div>
 
+        {run.parameters && Object.keys(run.parameters).length > 0 ? (
+          <Card>
+            <CardHeader>
+              <CardTitle>{t('data_sync.runs.detail.parameters', 'Run parameters')}</CardTitle>
+            </CardHeader>
+            <CardContent>
+              <dl className="grid grid-cols-1 gap-2 sm:grid-cols-2">
+                {Object.entries(run.parameters).map(([key, value]) => (
+                  <div key={key} className="flex items-center justify-between gap-3 rounded-md border bg-card px-3 py-2 text-sm">
+                    <dt className="font-medium text-muted-foreground">{parameterLabels[key] ?? key}</dt>
+                    <dd className="font-mono text-foreground">
+                      {typeof value === 'boolean' ? String(value) : String(value ?? '')}
+                    </dd>
+                  </div>
+                ))}
+              </dl>
+            </CardContent>
+          </Card>
+        ) : null}
+
         {run.lastError && (
           <Card className="border-status-error-border bg-status-error-bg">
             <CardHeader>

package/src/modules/data_sync/components/IntegrationScheduleTab.tsx

@@ -23,6 +23,12 @@ import { Switch } from '@open-mercato/ui/primitives/switch'
 import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { getSyncSummaryVariant } from '../lib/syncRunStatus'
+import type { RunParameter } from '../lib/adapter'
+import { getApplicableRunParameters } from '../lib/run-parameters'
+import {
+  buildDefaultRunParameterValues,
+  hasRequiredRunParameterWithoutDefault,
+} from './RunParameterFields'
 import {
   CalendarClock,
   Play,
@@ -40,6 +46,7 @@ type SyncOption = {
   runMode?: 'generic' | 'provider'
   canStartRun?: boolean
   supportedEntities: string[]
+  runParameters?: RunParameter[]
   hasCredentials: boolean
   isEnabled: boolean
 }
@@ -223,29 +230,35 @@ export function IntegrationScheduleTab(props: IntegrationScheduleTabProps) {
       return
     }
 
+    // This table has no room for a parameter form, so a row run submits the
+    // adapter's declared defaults. A parameter the operator must fill in has no
+    // default to send, so route them to the Data Sync dashboard instead of
+    // letting the run API reject the request.
+    const runParameters = getApplicableRunParameters(option?.runParameters, direction, entityType)
+    if (hasRequiredRunParameterWithoutDefault(runParameters)) {
+      flash(t('data_sync.integrationTab.parametersRequired', 'This run needs parameters. Start it from the Data Sync dashboard.'), 'error')
+      return
+    }
+
     setRunningKey(scheduleKey)
     try {
       const scheduleState = schedules[scheduleKey] ?? buildDefaultScheduleState(entityType)
+      const requestBody: Record<string, unknown> = {
+        integrationId: props.integrationId,
+        entityType,
+        direction,
+        fullSync: scheduleState.fullSync,
+        batchSize: 100,
+      }
+      if (runParameters.length > 0) requestBody.parameters = buildDefaultRunParameterValues(runParameters)
       const call = await runMutation({
         // optimistic-lock-exempt: starts a new sync run (create), not a concurrent record edit
         operation: () => apiCall<{ id: string }>('/api/data_sync/run', {
           method: 'POST',
           headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({
-            integrationId: props.integrationId,
-            entityType,
-            direction,
-            fullSync: scheduleState.fullSync,
-            batchSize: 100,
-          }),
+          body: JSON.stringify(requestBody),
         }, { fallback: null }),
-        mutationPayload: {
-          integrationId: props.integrationId,
-          entityType,
-          direction,
-          fullSync: scheduleState.fullSync,
-          batchSize: 100,
-        },
+        mutationPayload: requestBody,
         context: {
           operation: 'create',
           actionId: 'start-sync-run',
@@ -264,7 +277,7 @@ export function IntegrationScheduleTab(props: IntegrationScheduleTabProps) {
     } finally {
       setRunningKey(null)
     }
-  }, [option?.canStartRun, props.hasCredentials, props.integrationId, props.isEnabled, runMutation, schedules, t])
+  }, [option?.canStartRun, option?.runParameters, props.hasCredentials, props.integrationId, props.isEnabled, runMutation, schedules, t])
 
   const handleSaveSchedule = React.useCallback(async (entityType: string, direction: 'import' | 'export', scheduleKey: string) => {
     const scheduleState = schedules[scheduleKey] ?? buildDefaultScheduleState(entityType)

package/src/modules/data_sync/components/RunParameterFields.tsx

@@ -0,0 +1,229 @@
+"use client"
+
+import * as React from 'react'
+import { Input } from '@open-mercato/ui/primitives/input'
+import { Label } from '@open-mercato/ui/primitives/label'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@open-mercato/ui/primitives/select'
+import { Switch } from '@open-mercato/ui/primitives/switch'
+import { useT, type TranslateFn } from '@open-mercato/shared/lib/i18n/context'
+import type { RunParameter } from '../lib/adapter'
+
+/**
+ * Form-state representation of a run parameter value. Numbers are held as
+ * strings while the operator types; the run API coerces them to the declared
+ * type via `normalizeRunParameters`.
+ */
+export type RunParameterFormValue = string | boolean
+
+export function buildDefaultRunParameterValues(
+  params: RunParameter[],
+): Record<string, RunParameterFormValue> {
+  const values: Record<string, RunParameterFormValue> = {}
+  for (const param of params) {
+    if (param.type === 'boolean') {
+      values[param.key] = param.defaultValue === true
+    } else {
+      values[param.key] = param.defaultValue !== undefined && param.defaultValue !== null
+        ? String(param.defaultValue)
+        : ''
+    }
+  }
+  return values
+}
+
+export function buildRunParametersPayload(
+  params: RunParameter[],
+  values: Record<string, RunParameterFormValue>,
+): Record<string, RunParameterFormValue> {
+  const payload: Record<string, RunParameterFormValue> = {}
+  for (const param of params) {
+    if (param.key in values) payload[param.key] = values[param.key]
+  }
+  return payload
+}
+
+/**
+ * True when a run cannot be started without operator input — a required
+ * parameter with no default to fall back on. Surfaces that cannot render the
+ * full parameter form (the integration schedule table) use this to point the
+ * operator at the Data Sync dashboard instead of failing with a 422.
+ *
+ * Booleans are excluded: a switch always submits `true` or `false`, so their
+ * `required` can never fail (see `RunParameter.required`). Counting them would
+ * send the operator away from a button that would in fact have worked.
+ */
+export function hasRequiredRunParameterWithoutDefault(params: RunParameter[]): boolean {
+  return params.some((param) => param.type !== 'boolean' && param.required && param.defaultValue === undefined)
+}
+
+export type RunParameterErrorEntry = {
+  key?: string
+  code?: string
+  params?: { label?: string; type?: string; min?: number; max?: number; options?: string }
+  message?: string
+}
+
+export type RunFailureBody = {
+  error?: string
+  details?: { parameters?: RunParameterErrorEntry[] }
+}
+
+type Translate = TranslateFn
+
+/** Resolves an optional i18n key, falling back to the adapter's literal. */
+export function resolveRunParameterText(
+  t: Translate,
+  key: string | undefined,
+  literal: string | undefined,
+): string | undefined {
+  if (key) {
+    const translated = t(key, literal ?? key)
+    if (translated && translated !== key) return translated
+  }
+  return literal
+}
+
+const ERROR_FALLBACKS: Record<string, string> = {
+  required: '{label} is required.',
+  type: '{label} must be a {type}.',
+  min: '{label} must be at least {min}.',
+  max: '{label} must be at most {max}.',
+  select: '{label} must be one of: {options}.',
+}
+
+/**
+ * Picks the most specific message out of a failed run response and renders it
+ * in the operator's language. The run API reports invalid parameters per key
+ * under `details.parameters` with a machine-readable `code`; surfacing only the
+ * top-level `error` would say "Invalid run parameters" without saying which one
+ * or why, and using the server's pre-rendered `message` would put an English
+ * sentence next to a translated dashboard.
+ */
+export function buildRunFailureMessage(
+  failure: RunFailureBody | null | undefined,
+  fallback: string,
+  t?: Translate,
+): string {
+  const rendered = (failure?.details?.parameters ?? [])
+    .map((entry) => {
+      if (t && entry?.code && ERROR_FALLBACKS[entry.code]) {
+        return t(`data_sync.runParameters.errors.${entry.code}`, ERROR_FALLBACKS[entry.code], {
+          ...(entry.params ?? {}),
+        })
+      }
+      return entry?.message
+    })
+    .filter((message): message is string => typeof message === 'string' && message.trim().length > 0)
+  if (rendered.length > 0) return rendered.join(' ')
+  return failure?.error ?? fallback
+}
+
+export type RetryFailureBody = {
+  code?: string
+}
+
+/**
+ * Retry failures are otherwise indistinguishable to the operator, so both retry
+ * buttons flash one generic sentence. The stale-parameter refusal is the one
+ * whose remedy is not obvious from context — it is reported with a machine
+ * -readable `code` so the UI can name the way out instead of dead-ending.
+ */
+export function buildRetryFailureMessage(
+  failure: RetryFailureBody | null | undefined,
+  t: Translate,
+): string {
+  if (failure?.code === 'parametersStale') {
+    return t(
+      'data_sync.runs.detail.retryParametersStale',
+      'The stored run parameters are no longer valid for this integration. Start a new run from the Data Sync dashboard.',
+    )
+  }
+  return t('data_sync.runs.detail.retryError', 'Failed to retry sync run')
+}
+
+export type RunParameterFieldsProps = {
+  params: RunParameter[]
+  values: Record<string, RunParameterFormValue>
+  onChange: (key: string, value: RunParameterFormValue) => void
+}
+
+export function RunParameterFields({ params, values, onChange }: RunParameterFieldsProps) {
+  const t = useT()
+  return (
+    <div className="grid gap-3 sm:grid-cols-2">
+      {params.map((param) => {
+        const value = values[param.key]
+        const fieldId = `run-param-${param.key}`
+        const describedById = `${fieldId}-description`
+        const label = resolveRunParameterText(t, param.labelKey, param.label) ?? param.key
+        const description = resolveRunParameterText(t, param.descriptionKey, param.description)
+        const placeholder = resolveRunParameterText(t, param.placeholderKey, param.placeholder)
+        // No required marker on booleans: a switch always submits true/false,
+        // so `required` can never fail for them (see RunParameter.required).
+        if (param.type === 'boolean') {
+          return (
+            <div key={param.key} className="rounded-lg border bg-card p-3 sm:col-span-2">
+              <div className="flex items-center justify-between gap-3">
+                <div className="space-y-1">
+                  <Label htmlFor={fieldId} className="text-sm font-medium">{label}</Label>
+                  {description ? (
+                    <p id={describedById} className="text-xs text-muted-foreground">{description}</p>
+                  ) : null}
+                </div>
+                <Switch
+                  id={fieldId}
+                  aria-describedby={description ? describedById : undefined}
+                  checked={value === true}
+                  onCheckedChange={(checked) => onChange(param.key, checked)}
+                />
+              </div>
+            </div>
+          )
+        }
+        return (
+          <div key={param.key} className="space-y-2">
+            <Label htmlFor={fieldId} className="text-sm font-medium">
+              {label}
+              {param.required ? <span className="text-status-error-text"> *</span> : null}
+            </Label>
+            {param.type === 'select' ? (
+              <Select
+                value={typeof value === 'string' && value.length > 0 ? value : undefined}
+                onValueChange={(next) => onChange(param.key, next ?? '')}
+              >
+                <SelectTrigger id={fieldId} aria-describedby={description ? describedById : undefined}>
+                  <SelectValue placeholder={placeholder ?? undefined} />
+                </SelectTrigger>
+                <SelectContent>
+                  {(param.options ?? []).map((option) => (
+                    <SelectItem key={option.value} value={option.value}>
+                      {option.label ?? option.value}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            ) : (
+              <Input
+                id={fieldId}
+                aria-describedby={description ? describedById : undefined}
+                value={typeof value === 'string' ? value : ''}
+                onChange={(event) => onChange(param.key, event.target.value)}
+                placeholder={placeholder ?? undefined}
+                inputMode={param.type === 'number' ? 'numeric' : undefined}
+              />
+            )}
+            {description ? (
+              <p id={describedById} className="text-xs text-muted-foreground">{description}</p>
+            ) : null}
+          </div>
+        )
+      })}
+    </div>
+  )
+}

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

@@ -4,7 +4,7 @@ import { Entity, Index, PrimaryKey, Property } from '@mikro-orm/decorators/legac
 @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'
+  [OptionalProps]?: 'status' | 'cursor' | 'initialCursor' | 'createdCount' | 'updatedCount' | 'skippedCount' | 'failedCount' | 'batchesCompleted' | 'lastError' | 'progressJobId' | 'jobId' | 'triggeredBy' | 'parameters' | 'createdAt' | 'updatedAt' | 'deletedAt'
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string
 
@@ -53,6 +53,9 @@ export class SyncRun {
   @Property({ name: 'triggered_by', type: 'text', nullable: true })
   triggeredBy?: string | null
 
+  @Property({ name: 'parameters', type: 'json', nullable: true })
+  parameters?: Record<string, unknown> | null
+
   @Property({ name: 'organization_id', type: 'uuid' })
   organizationId!: string
 

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

@@ -7,6 +7,9 @@ export const runSyncSchema = z.object({
   fullSync: z.boolean().default(false),
   batchSize: z.number().int().min(1).max(1000).default(100),
   triggeredBy: z.string().optional(),
+  // Adapter-declared run parameters. Validated/coerced against the adapter's
+  // `runParameters` declaration in the run route; here we only accept a record.
+  parameters: z.record(z.string(), z.unknown()).optional(),
 })
 
 export type RunSyncInput = z.infer<typeof runSyncSchema>

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

@@ -55,6 +55,8 @@
   "data_sync.dashboard.start.fullSync": "Run as full sync",
   "data_sync.dashboard.start.fullSyncHelp": "Ignore the saved cursor and process the entire source again for this run.",
   "data_sync.dashboard.start.invalidBatchSize": "Batch size must be between 1 and 1000.",
+  "data_sync.dashboard.start.parameters": "Lauf-Parameter",
+  "data_sync.dashboard.start.parametersHelp": "Optionale Werte, die diese Integration für den manuellen Lauf akzeptiert.",
   "data_sync.dashboard.start.providerManaged": "Diese Integration startet Synchronisierungsläufe über ihren eigenen Einrichtungsablauf. Öffne die Integrationseinstellungen, um fortzufahren.",
   "data_sync.dashboard.start.runNowDescription": "Use this for the next immediate sync. Batch size and full-sync mode apply only to this manual run.",
   "data_sync.dashboard.start.runNowFootnote": "Manual runs show progress immediately and land on the run detail page after launch.",
@@ -85,6 +87,7 @@
   "data_sync.integrationTab.integrationDisabledNotice": "The integration is disabled. You can save schedules now, but runs will stay blocked until the integration is enabled.",
   "data_sync.integrationTab.loadError": "Failed to load sync schedules.",
   "data_sync.integrationTab.notAvailable": "This integration is not registered as a data sync provider.",
+  "data_sync.integrationTab.parametersRequired": "Dieser Lauf benötigt Parameter. Starte ihn über das Data-Sync-Dashboard.",
   "data_sync.integrationTab.providerManaged": "Starte diese Integration über ihren anbieterspezifischen Einrichtungsablauf.",
   "data_sync.integrationTab.providerManagedNotice": "Dieser Anbieter benötigt einen eigenen Einrichtungsablauf, bevor ein Lauf gestartet werden kann. Verwende den Anbieter-Tab auf dieser Seite statt der generischen Zeitpläne.",
   "data_sync.integrationTab.refresh": "Refresh",
@@ -96,6 +99,11 @@
   "data_sync.integrationTab.starting": "Starting...",
   "data_sync.integrationTab.title": "Sync schedules",
   "data_sync.nav.title": "Datensynchronisation",
+  "data_sync.runParameters.errors.max": "{label} darf höchstens {max} betragen.",
+  "data_sync.runParameters.errors.min": "{label} muss mindestens {min} betragen.",
+  "data_sync.runParameters.errors.required": "{label} ist erforderlich.",
+  "data_sync.runParameters.errors.select": "{label} muss einer dieser Werte sein: {options}.",
+  "data_sync.runParameters.errors.type": "{label} muss vom Typ {type} sein.",
   "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",
@@ -112,6 +120,7 @@
   "data_sync.runs.detail.logs.time": "Zeit",
   "data_sync.runs.detail.noLogs": "Keine Protokolleinträge",
   "data_sync.runs.detail.notFound": "Synchronisierungslauf nicht gefunden.",
+  "data_sync.runs.detail.parameters": "Lauf-Parameter",
   "data_sync.runs.detail.progress": "Fortschritt",
   "data_sync.runs.detail.progress.batches": "{count} Stapel",
   "data_sync.runs.detail.progress.eta": "{eta} verbleibend",
@@ -120,6 +129,7 @@
   "data_sync.runs.detail.progress.percent": "{percent}% abgeschlossen",
   "data_sync.runs.detail.retry": "Wiederholen",
   "data_sync.runs.detail.retryError": "Lauf konnte nicht wiederholt werden",
+  "data_sync.runs.detail.retryParametersStale": "Die gespeicherten Laufparameter sind für diese Integration nicht mehr gültig. Starten Sie einen neuen Lauf über das Data-Sync-Dashboard.",
   "data_sync.runs.detail.retrySuccess": "Lauf wiederholt",
   "data_sync.runs.detail.title": "Synchronisierungslauf"
 }

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

@@ -55,6 +55,8 @@
   "data_sync.dashboard.start.fullSync": "Run as full sync",
   "data_sync.dashboard.start.fullSyncHelp": "Ignore the saved cursor and process the entire source again for this run.",
   "data_sync.dashboard.start.invalidBatchSize": "Batch size must be between 1 and 1000.",
+  "data_sync.dashboard.start.parameters": "Run parameters",
+  "data_sync.dashboard.start.parametersHelp": "Optional values this integration accepts for the manual run.",
   "data_sync.dashboard.start.providerManaged": "This integration starts sync runs from its own setup flow. Open the integration settings page to continue.",
   "data_sync.dashboard.start.runNowDescription": "Use this for the next immediate sync. Batch size and full-sync mode apply only to this manual run.",
   "data_sync.dashboard.start.runNowFootnote": "Manual runs show progress immediately and land on the run detail page after launch.",
@@ -85,6 +87,7 @@
   "data_sync.integrationTab.integrationDisabledNotice": "The integration is disabled. You can save schedules now, but runs will stay blocked until the integration is enabled.",
   "data_sync.integrationTab.loadError": "Failed to load sync schedules.",
   "data_sync.integrationTab.notAvailable": "This integration is not registered as a data sync provider.",
+  "data_sync.integrationTab.parametersRequired": "This run needs parameters. Start it from the Data Sync dashboard.",
   "data_sync.integrationTab.providerManaged": "Start this integration from its provider-specific setup flow.",
   "data_sync.integrationTab.providerManagedNotice": "This provider needs its own setup flow before a run can start. Use the provider tab on this page instead of generic schedules.",
   "data_sync.integrationTab.refresh": "Refresh",
@@ -96,6 +99,11 @@
   "data_sync.integrationTab.starting": "Starting...",
   "data_sync.integrationTab.title": "Sync schedules",
   "data_sync.nav.title": "Data Sync",
+  "data_sync.runParameters.errors.max": "{label} must be at most {max}.",
+  "data_sync.runParameters.errors.min": "{label} must be at least {min}.",
+  "data_sync.runParameters.errors.required": "{label} is required.",
+  "data_sync.runParameters.errors.select": "{label} must be one of: {options}.",
+  "data_sync.runParameters.errors.type": "{label} must be a {type}.",
   "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",
@@ -112,6 +120,7 @@
   "data_sync.runs.detail.logs.time": "Time",
   "data_sync.runs.detail.noLogs": "No log entries",
   "data_sync.runs.detail.notFound": "Sync run not found.",
+  "data_sync.runs.detail.parameters": "Run parameters",
   "data_sync.runs.detail.progress": "Progress",
   "data_sync.runs.detail.progress.batches": "{count} batches",
   "data_sync.runs.detail.progress.eta": "{eta} remaining",
@@ -120,6 +129,7 @@
   "data_sync.runs.detail.progress.percent": "{percent}% complete",
   "data_sync.runs.detail.retry": "Retry",
   "data_sync.runs.detail.retryError": "Failed to retry sync run",
+  "data_sync.runs.detail.retryParametersStale": "The stored run parameters are no longer valid for this integration. Start a new run from the Data Sync dashboard.",
   "data_sync.runs.detail.retrySuccess": "Sync run retried",
   "data_sync.runs.detail.title": "Sync Run"
 }

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

@@ -55,6 +55,8 @@
   "data_sync.dashboard.start.fullSync": "Run as full sync",
   "data_sync.dashboard.start.fullSyncHelp": "Ignore the saved cursor and process the entire source again for this run.",
   "data_sync.dashboard.start.invalidBatchSize": "Batch size must be between 1 and 1000.",
+  "data_sync.dashboard.start.parameters": "Parámetros de ejecución",
+  "data_sync.dashboard.start.parametersHelp": "Valores opcionales que esta integración acepta para la ejecución manual.",
   "data_sync.dashboard.start.providerManaged": "Esta integración inicia las sincronizaciones desde su propio flujo de configuración. Abre la página de ajustes de la integración para continuar.",
   "data_sync.dashboard.start.runNowDescription": "Use this for the next immediate sync. Batch size and full-sync mode apply only to this manual run.",
   "data_sync.dashboard.start.runNowFootnote": "Manual runs show progress immediately and land on the run detail page after launch.",
@@ -85,6 +87,7 @@
   "data_sync.integrationTab.integrationDisabledNotice": "The integration is disabled. You can save schedules now, but runs will stay blocked until the integration is enabled.",
   "data_sync.integrationTab.loadError": "Failed to load sync schedules.",
   "data_sync.integrationTab.notAvailable": "This integration is not registered as a data sync provider.",
+  "data_sync.integrationTab.parametersRequired": "Esta ejecución necesita parámetros. Iníciala desde el panel de Data Sync.",
   "data_sync.integrationTab.providerManaged": "Inicia esta integración desde su flujo de configuración específico del proveedor.",
   "data_sync.integrationTab.providerManagedNotice": "Este proveedor necesita su propio flujo de configuración antes de poder iniciar una ejecución. Usa la pestaña del proveedor en esta página en lugar de los calendarios genéricos.",
   "data_sync.integrationTab.refresh": "Refresh",
@@ -96,6 +99,11 @@
   "data_sync.integrationTab.starting": "Starting...",
   "data_sync.integrationTab.title": "Sync schedules",
   "data_sync.nav.title": "Sincronización de datos",
+  "data_sync.runParameters.errors.max": "{label} debe ser como máximo {max}.",
+  "data_sync.runParameters.errors.min": "{label} debe ser como mínimo {min}.",
+  "data_sync.runParameters.errors.required": "{label} es obligatorio.",
+  "data_sync.runParameters.errors.select": "{label} debe ser uno de: {options}.",
+  "data_sync.runParameters.errors.type": "{label} debe ser de tipo {type}.",
   "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",
@@ -112,6 +120,7 @@
   "data_sync.runs.detail.logs.time": "Hora",
   "data_sync.runs.detail.noLogs": "Sin entradas de registro",
   "data_sync.runs.detail.notFound": "Ejecución de sincronización no encontrada.",
+  "data_sync.runs.detail.parameters": "Parámetros de ejecución",
   "data_sync.runs.detail.progress": "Progreso",
   "data_sync.runs.detail.progress.batches": "{count} lotes",
   "data_sync.runs.detail.progress.eta": "Quedan {eta}",
@@ -120,6 +129,7 @@
   "data_sync.runs.detail.progress.percent": "{percent}% completado",
   "data_sync.runs.detail.retry": "Reintentar",
   "data_sync.runs.detail.retryError": "No se pudo reintentar la ejecución",
+  "data_sync.runs.detail.retryParametersStale": "Los parámetros de ejecución guardados ya no son válidos para esta integración. Inicia una nueva ejecución desde el panel de Data Sync.",
   "data_sync.runs.detail.retrySuccess": "Ejecución reintentada",
   "data_sync.runs.detail.title": "Ejecución de sincronización"
 }

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

@@ -55,6 +55,8 @@
   "data_sync.dashboard.start.fullSync": "전체 동기화로 실행",
   "data_sync.dashboard.start.fullSyncHelp": "저장된 커서를 무시하고 이 실행에 대해 전체 소스를 다시 처리합니다.",
   "data_sync.dashboard.start.invalidBatchSize": "배치 크기는 1에서 1000 사이여야 합니다.",
+  "data_sync.dashboard.start.parameters": "실행 매개변수",
+  "data_sync.dashboard.start.parametersHelp": "이 통합이 수동 실행에 대해 허용하는 선택적 값입니다.",
   "data_sync.dashboard.start.providerManaged": "이 통합은 자체 설정 흐름에서 동기화 실행을 시작합니다. 계속하려면 통합 설정 페이지를 여세요.",
   "data_sync.dashboard.start.runNowDescription": "다음 즉시 동기화에 사용하세요. 배치 크기와 전체 동기화 모드는 이 수동 실행에만 적용됩니다.",
   "data_sync.dashboard.start.runNowFootnote": "수동 실행은 즉시 진행 상황을 표시하며 시작 후 실행 상세 페이지로 이동합니다.",
@@ -85,6 +87,7 @@
   "data_sync.integrationTab.integrationDisabledNotice": "통합이 비활성화되어 있습니다. 지금 일정을 저장할 수 있지만 통합이 활성화될 때까지 실행이 차단됩니다.",
   "data_sync.integrationTab.loadError": "동기화 일정을 불러오지 못했습니다.",
   "data_sync.integrationTab.notAvailable": "이 통합은 데이터 동기화 제공업체로 등록되어 있지 않습니다.",
+  "data_sync.integrationTab.parametersRequired": "이 실행에는 매개변수가 필요합니다. 데이터 동기화 대시보드에서 시작하세요.",
   "data_sync.integrationTab.providerManaged": "이 통합은 제공업체별 설정 흐름에서 시작하세요.",
   "data_sync.integrationTab.providerManagedNotice": "이 제공업체는 실행을 시작하기 전에 자체 설정 흐름이 필요합니다. 일반 일정 대신 이 페이지의 제공업체 탭을 사용하세요.",
   "data_sync.integrationTab.refresh": "새로고침",
@@ -96,6 +99,11 @@
   "data_sync.integrationTab.starting": "시작하는 중...",
   "data_sync.integrationTab.title": "동기화 일정",
   "data_sync.nav.title": "데이터 동기화",
+  "data_sync.runParameters.errors.max": "{label}은(는) 최대 {max} 이하여야 합니다.",
+  "data_sync.runParameters.errors.min": "{label}은(는) 최소 {min} 이상이어야 합니다.",
+  "data_sync.runParameters.errors.required": "{label}은(는) 필수입니다.",
+  "data_sync.runParameters.errors.select": "{label}은(는) 다음 중 하나여야 합니다: {options}.",
+  "data_sync.runParameters.errors.type": "{label}은(는) {type} 형식이어야 합니다.",
   "data_sync.runs.detail.back": "동기화 실행으로 돌아가기",
   "data_sync.runs.detail.cancel": "취소",
   "data_sync.runs.detail.cancelError": "동기화 실행 취소에 실패했습니다",
@@ -112,6 +120,7 @@
   "data_sync.runs.detail.logs.time": "시간",
   "data_sync.runs.detail.noLogs": "로그 항목 없음",
   "data_sync.runs.detail.notFound": "동기화 실행을 찾을 수 없습니다.",
+  "data_sync.runs.detail.parameters": "실행 매개변수",
   "data_sync.runs.detail.progress": "진행 상황",
   "data_sync.runs.detail.progress.batches": "{count}개 배치",
   "data_sync.runs.detail.progress.eta": "{eta} 남음",
@@ -120,6 +129,7 @@
   "data_sync.runs.detail.progress.percent": "{percent}% 완료",
   "data_sync.runs.detail.retry": "재시도",
   "data_sync.runs.detail.retryError": "동기화 실행 재시도에 실패했습니다",
+  "data_sync.runs.detail.retryParametersStale": "저장된 실행 매개변수가 이 연동에 더 이상 유효하지 않습니다. Data Sync 대시보드에서 새 실행을 시작하세요.",
   "data_sync.runs.detail.retrySuccess": "동기화 실행이 재시도되었습니다",
   "data_sync.runs.detail.title": "동기화 실행"
 }