@open-mercato/core 0.7.1-develop.7178.1.ab93fbaf4e → 0.7.1-develop.7180.1.9717fbbb43

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

@@ -59,6 +59,7 @@
   "data_sync.dashboard.start.parametersHelp": "Opcjonalne wartości akceptowane przez tę integrację dla ręcznego uruchomienia.",
   "data_sync.dashboard.start.providerManaged": "Ta integracja uruchamia synchronizacje z własnego przepływu konfiguracji. Otwórz ustawienia integracji, aby kontynuować.",
   "data_sync.dashboard.start.runNowDescription": "Użyj tej opcji dla najbliższej natychmiastowej synchronizacji. Rozmiar partii i tryb pełnej synchronizacji dotyczą wyłącznie tego ręcznego przebiegu.",
+  "data_sync.dashboard.start.runNowDescriptionScoped": "Użyj tej opcji dla najbliższej natychmiastowej synchronizacji. Ustawienia wprowadzone tutaj dotyczą wyłącznie tego ręcznego przebiegu.",
   "data_sync.dashboard.start.runNowFootnote": "Ręczne przebiegi od razu pokazują postęp, a po uruchomieniu przenoszą na stronę szczegółów przebiegu.",
   "data_sync.dashboard.start.runNowTitle": "Uruchom teraz jednorazowo",
   "data_sync.dashboard.start.status.credentialsMissing": "Brak poświadczeń",

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

@@ -207,6 +207,14 @@ export interface RunParameter {
   entityType?: string | string[]
 }
 
+/**
+ * A control the `data_sync` dashboard renders on its "Run once now" card.
+ *
+ * - `fullSync` asks the run API for a `null` start cursor instead of a resolved one.
+ * - `batchSize` sets `StreamImportInput.batchSize` / `StreamExportInput.batchSize`.
+ */
+export type DataSyncStartControl = 'fullSync' | 'batchSize'
+
 export interface DataSyncAdapter {
   readonly providerKey: string
   readonly direction: 'import' | 'export' | 'bidirectional'
@@ -266,6 +274,43 @@ export interface DataSyncAdapter {
    * kinds — an incremental feed and a whole-table backfill.
    */
   persistsSharedCursor?(entityType: string): boolean
+  /**
+   * Whether a control on the Data Sync dashboard's "Run once now" card is
+   * meaningful for this entity type. Only an explicit `false` removes a
+   * control, so an adapter that declares nothing — or returns nothing — keeps
+   * today's form exactly.
+   *
+   * Return `false` for an entity type where the operator's choice reaches the
+   * adapter and changes nothing observable: an entity type whose cursor carries
+   * identity, so an inherited cursor is discarded and the run starts from the
+   * top whichever way `fullSync` is set; or one whose paging the source fixes,
+   * so `batchSize` is read and ignored. That card then omits the control rather
+   * than offering a switch whose "no effect" an operator cannot tell apart from
+   * "it worked".
+   *
+   * Core cannot infer this — it does not know what an entity type does with the
+   * values it is handed. The adapter does, and this is the channel for saying
+   * so.
+   *
+   * SCOPE: the "Run once now" card only. It does NOT gate the recurring-schedule
+   * switch on the same page, nor the per-entity-type "Full" switch on the
+   * integration settings tab — whose row-level run posts that schedule's own
+   * `fullSync` to the same run API. An adapter that declares `fullSync`
+   * inapplicable still sees those, and `buildDefaultScheduleState` may pre-set
+   * them to `true`. Harmless by construction, since the adapter has said the
+   * value does not matter, but do not read this predicate as covering every
+   * place a run can be started.
+   *
+   * This governs what the dashboard OFFERS, not what the API accepts:
+   * `POST /api/data_sync/run` keeps honouring both fields, so a client that
+   * posts `fullSync: true` still gets a `null` cursor whatever this returns.
+   *
+   * The predicate is per entity type for the same reason
+   * {@link DataSyncAdapter.persistsSharedCursor} is — one adapter commonly
+   * serves both an incremental feed and a whole-table backfill, and only one of
+   * them has a beginning to restart from.
+   */
+  supportsStartControl?(control: DataSyncStartControl, entityType: string): boolean
   getInitialCursor?(input: { entityType: string; scope: TenantScope }): Promise<string | null>
   getMapping(input: { entityType: string; scope: TenantScope }): Promise<DataMapping>
   validateConnection?(input: {

package/src/modules/data_sync/lib/start-controls.ts

@@ -0,0 +1,89 @@
+import type { DataSyncAdapter, DataSyncStartControl } from './adapter'
+
+/**
+ * Keyed by the union rather than listed, so adding a control to
+ * {@link DataSyncStartControl} fails to compile here instead of silently
+ * dropping out of the resolution loop and the client-side read.
+ */
+const START_CONTROL_KEYS: Record<DataSyncStartControl, true> = { fullSync: true, batchSize: true }
+
+export const DATA_SYNC_START_CONTROLS = Object.keys(START_CONTROL_KEYS) as readonly DataSyncStartControl[]
+
+export type StartControlApplicability = Record<DataSyncStartControl, boolean>
+
+/**
+ * Which manual-start controls apply, per entity type, as resolved by
+ * `api/options.ts` and read by the dashboard.
+ *
+ * The map is sparse: an entity type whose controls all apply is omitted, so an
+ * adapter that declares nothing serializes to `{}` and adds nothing to the
+ * wire. "Not declared" and "nothing restricted" therefore share one default.
+ */
+export type StartControlMap = Record<string, StartControlApplicability>
+
+function allApplicable(): StartControlApplicability {
+  return { fullSync: true, batchSize: true }
+}
+
+/**
+ * A predicate that throws is treated as "applies". `api/options.ts` evaluates
+ * every registered adapter in one response, so an adapter with a broken
+ * predicate would otherwise take the options list — and with it the whole
+ * dashboard — down for every other integration.
+ */
+function isApplicable(
+  adapter: DataSyncAdapter,
+  control: DataSyncStartControl,
+  entityType: string,
+): boolean {
+  try {
+    return adapter.supportsStartControl?.(control, entityType) !== false
+  } catch {
+    return true
+  }
+}
+
+/**
+ * Evaluates an adapter's declaration across the entity types it supports.
+ *
+ * The accumulator has a null prototype: assigning `__proto__` on a plain object
+ * literal sets that object's prototype instead of creating an own property, so
+ * an entity type under that name would serialize away and silently lose the
+ * restriction the adapter declared.
+ */
+export function resolveStartControlMap(adapter: DataSyncAdapter | null | undefined): StartControlMap {
+  if (!adapter || typeof adapter.supportsStartControl !== 'function') return {}
+  const map: StartControlMap = Object.create(null)
+  for (const entityType of adapter.supportedEntities ?? []) {
+    const applicability = allApplicable()
+    let restricted = false
+    for (const control of DATA_SYNC_START_CONTROLS) {
+      if (isApplicable(adapter, control, entityType)) continue
+      applicability[control] = false
+      restricted = true
+    }
+    if (restricted) map[entityType] = applicability
+  }
+  return map
+}
+
+/**
+ * Reads the resolved map for the selected entity type, defaulting to "every
+ * control applies" for an entity type the map does not restrict.
+ *
+ * The lookup is own-property only: an entity type named after something on
+ * `Object.prototype` would otherwise read back an inherited value whose
+ * `fullSync` is `undefined`, hiding a control the adapter never restricted.
+ */
+export function applicableStartControls(
+  map: StartControlMap | null | undefined,
+  entityType: string,
+): StartControlApplicability {
+  if (!map || !Object.prototype.hasOwnProperty.call(map, entityType)) return allApplicable()
+  const declared = map[entityType]
+  const applicability = allApplicable()
+  for (const control of DATA_SYNC_START_CONTROLS) {
+    if (declared?.[control] === false) applicability[control] = false
+  }
+  return applicability
+}