@wix/bex-core 2.328.0 → 2.330.0

package/dist/cjs/state/ImportState/ImportState.js

@@ -7,16 +7,60 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 var _mobx = require("mobx");
 var _model = require("../../model");
 var _ConditionalModalState = require("../ConditionalModalState");
+var _types = require("@wix/bex-utils/@wix/ambassador-hub-v1-job/types");
+exports.WritePolicy = _types.WritePolicy;
 var _parseCsv = require("./parseCsv");
+var _rewriteCsv = require("./rewriteCsv");
+var _hubJobClient = require("./hubJobClient");
+var _importJobPoller = require("./importJobPoller");
 var _detectFieldType = require("./detectFieldType");
-var _set = _interopRequireDefault(require("lodash/set"));
+var _fieldEdit = require("./fieldEdit");
+/** Outcome of a server-side import job, derived from the job's progress. */
+
+/**
+ * Optional snapshot taken before the import runs, returning a `restore` used to
+ * undo the import on cancel. See {@link BackupResult.restore} for the revert
+ * contract under upsert.
+ */
+
+/**
+ * Consumer hook for resolving a failed import job's message. An import runs
+ * server-side, so a failure arrives on a 200 (the poll succeeds; the job
+ * doesn't) with no HTTP error to carry the application error. Cairo hands the
+ * consumer `run` — an operation that rejects with a synthetic, HTTP-error-shaped
+ * error carrying the job's application error — and the consumer wraps it with
+ * their own `withErrorHandler` + error-code map (their codes, their
+ * translations), keeping the map coupled to the `withErrorHandler` call as
+ * everywhere else (e.g. `fetchData`). The map is keyed by application-error code
+ * (the v2 errorHandler shape, like `getExportAsyncJobErrors`):
+ *
+ *   onJobError: (run) =>
+ *     errorHandler.withErrorHandler(run, {
+ *       [jobErrorCode]: (error) => ({ message: translate(...) }),
+ *     })
+ *
+ * `withErrorHandler` attaches the map to the error object and re-rejects it, so
+ * the progress step resolves a consumer-specific message via `getResolvedError`.
+ * When omitted, the error still surfaces but resolves to the generic message.
+ */
+
 // `NewFieldType`, `detectColumnType`, etc. are re-exported from the package via
 // the `ImportState` barrel (`./index`), which also exports `./detectFieldType`.
 
+// Re-export the write-policy enum so consumers (and the cairo UI) reference it
+// from `@wix/bex-core` rather than the bundled ambassador path.
+
+// Per-type configuration for a new field, captured from the "Edit field" editor
+// (CAIRO-4398). All optional — an unedited field carries none and is created
+// from detected defaults only. `displayName` is intentionally not here: the
+// (possibly user-overridden) name is deduped and surfaced as
+// `NewFieldDefinition.displayName`.
+
 // A new field to add to the collection schema during import. `key` is decided by
-// Cairo (derived from the column header, deduped) and is also the key the
-// column's values are written under, so the consumer must add the field under
-// exactly this key.
+// Cairo (derived from the column header — or the user's name override — deduped)
+// and is also the key the column's values are written under, so the consumer
+// must add the field under exactly this key. `config` carries any per-type
+// configuration the field editor produced; create the field with it.
 
 /**
  * Consumer-supplied callback that adds the given new fields to the collection
@@ -30,17 +74,23 @@ var _set = _interopRequireDefault(require("lodash/set"));
 /**
  * How a CSV column is mapped:
  * - `existing` — into an existing collection field by id
- * - `new` — into a new field created during import (always text for now)
+ * - `new` — into a new field created during import. `fieldType` is the detected
+ *   type, or the type the user picked in the field editor. `displayName` and
+ *   `config` are present only once the user edited the pending field via the
+ *   "Edit field" editor — `displayName` overrides the header-derived name and
+ *   `config` carries the per-type configuration.
  * - `null` — don't import (skip)
  */
 
-const DEFAULT_BATCH_SIZE = 100;
-
 // How long to keep the completed progress bar (100%) on screen before closing
 // the modal on a clean import. Without it, an import of very few rows finishes
 // near-instantly and the modal appears to vanish without ever showing the bar
 // reaching completion.
 const COMPLETION_LINGER_MS = 600;
+
+// The Wix Data collection's id field key. A CSV column mapped to this field lets
+// the user choose how rows that collide on `_id` are written (writePolicy).
+const ID_FIELD_KEY = '_id';
 function normalize(value) {
   return value.trim().toLowerCase();
 }
@@ -76,23 +126,10 @@ function uniqueFieldNameAndKey(header, usedNames, usedKeys) {
     displayName = `${header}-${suffix}`;
   }
 }
-function toMappedRows(rows, headers, mappingByHeader) {
-  return rows.map(row => {
-    const mapped = {};
-    headers.forEach((header, index) => {
-      const mappedField = mappingByHeader[header];
-      if (mappedField == null) {
-        return;
-      }
-      (0, _set.default)(mapped, mappedField, row[index] ?? '');
-    });
-    return mapped;
-  });
-}
 class ImportState {
   constructor(props) {
     (0, _defineProperty2.default)(this, "fields", void 0);
-    (0, _defineProperty2.default)(this, "bulkUploadItems", void 0);
+    (0, _defineProperty2.default)(this, "collectionId", void 0);
     (0, _defineProperty2.default)(this, "backup", void 0);
     (0, _defineProperty2.default)(this, "updateSchema", void 0);
     (0, _defineProperty2.default)(this, "collection", void 0);
@@ -101,7 +138,8 @@ class ImportState {
     (0, _defineProperty2.default)(this, "errorHandler", void 0);
     (0, _defineProperty2.default)(this, "showToast", void 0);
     (0, _defineProperty2.default)(this, "downloadCsv", void 0);
-    (0, _defineProperty2.default)(this, "batchSize", void 0);
+    (0, _defineProperty2.default)(this, "onJobError", void 0);
+    (0, _defineProperty2.default)(this, "hubJobClient", void 0);
     (0, _defineProperty2.default)(this, "_detectColumnType", void 0);
     (0, _defineProperty2.default)(this, "discardChangesModal", new _ConditionalModalState.ConditionalModalState());
     (0, _defineProperty2.default)(this, "currentStep", 'upload');
@@ -111,26 +149,43 @@ class ImportState {
     (0, _defineProperty2.default)(this, "fileName", '');
     (0, _defineProperty2.default)(this, "csvHeaders", []);
     (0, _defineProperty2.default)(this, "csvRows", []);
+    // Header display order for the configuration step, snapshotted when the file
+    // is parsed. The column auto-mapped to `_id` floats to the top (CAIRO-4418);
+    // the order then stays fixed while the user edits mappings, so clearing or
+    // remapping the `_id` column can't reorder the row under the user's cursor.
+    // Recomputed only on a new file (`applyParsedCsv`) or a full `reset()`.
+    (0, _defineProperty2.default)(this, "orderedHeaders", []);
     (0, _defineProperty2.default)(this, "mappingByHeader", {});
+    // How rows that collide on `_id` are written. Only meaningful (and only sent
+    // to the server) when a CSV column is mapped to the `_id` field — see
+    // `idMappedHeader` and `_destination`. Defaults to the server default
+    // (`OVERWRITE` = upsert by `_id`).
+    //
+    // Retention: the choice is deliberately kept while editing mappings within a
+    // file — remapping `_id` away and back keeps the user's selection rather than
+    // silently reverting it. It resets to the default only on a *new file* upload
+    // (`applyParsedCsv`) or a full `reset()`.
+    (0, _defineProperty2.default)(this, "writePolicy", _types.WritePolicy.OVERWRITE);
     (0, _defineProperty2.default)(this, "processedCount", 0);
     (0, _defineProperty2.default)(this, "totalCount", 0);
     (0, _defineProperty2.default)(this, "result", {
       succeeded: 0,
-      failed: 0,
-      errors: []
+      failed: 0
     });
     (0, _defineProperty2.default)(this, "isBackingUp", false);
     (0, _defineProperty2.default)(this, "isRestoring", false);
     (0, _defineProperty2.default)(this, "restoreFn", null);
     (0, _defineProperty2.default)(this, "_cancelled", false);
     (0, _defineProperty2.default)(this, "_abortController", null);
-    // Global indices (into `csvRows`) of every row that was not imported: rows
-    // the server rejected via a batch's returned `errors`, plus — when a batch
-    // throws after some rows succeeded — the throwing batch and all un-attempted
-    // rows. Offered to the user as a downloadable CSV via the partial toast.
-    (0, _defineProperty2.default)(this, "_failedRowIndices", []);
+    // Id of the running data-movement job, set once submitted — used to cancel it
+    // (`terminateJob`) if the user closes mid-import.
+    (0, _defineProperty2.default)(this, "_jobId", null);
+    // The column whose pending new field the field editor is currently editing.
+    // Not observable — transient wiring between `beginFieldEdit` and the editor's
+    // `applyFieldEdit` callback, never rendered.
+    (0, _defineProperty2.default)(this, "_editingHeader", null);
     this.fields = props.fields ?? [];
-    this.bulkUploadItems = props.bulkUploadItems;
+    this.collectionId = props.collectionId;
     this.backup = props.backup;
     this.updateSchema = props.updateSchema;
     this.collection = props.collection;
@@ -139,15 +194,21 @@ class ImportState {
     this.errorHandler = props.errorHandler;
     this.showToast = props.showToast;
     this.downloadCsv = props.downloadCsv;
-    this.batchSize = props.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.onJobError = props.onJobError;
     this._detectColumnType = props.detectColumnType ?? _detectFieldType.detectColumnType;
+    this.hubJobClient = (0, _hubJobClient.createHubJobClient)({
+      httpClient: props.httpClient,
+      errorHandler: props.errorHandler
+    });
     (0, _mobx.makeObservable)(this, {
       currentStep: _mobx.observable.ref,
       importStatus: _mobx.observable.ref,
       fileName: _mobx.observable.ref,
       csvHeaders: _mobx.observable.ref,
       csvRows: _mobx.observable.ref,
+      orderedHeaders: _mobx.observable.ref,
       mappingByHeader: _mobx.observable.ref,
+      writePolicy: _mobx.observable.ref,
       processedCount: _mobx.observable.ref,
       totalCount: _mobx.observable.ref,
       result: _mobx.observable.ref,
@@ -157,10 +218,15 @@ class ImportState {
       hasMappings: _mobx.computed,
       hasNoMappedData: _mobx.computed,
       selectedFieldIds: _mobx.computed,
+      idMappedHeader: _mobx.computed,
+      setWritePolicy: _mobx.action.bound,
       onUploadContinue: _mobx.action.bound,
       goToUpload: _mobx.action.bound,
       setMapping: _mobx.action.bound,
       setNewFieldMapping: _mobx.action.bound,
+      setNewFieldConfig: _mobx.action.bound,
+      beginFieldEdit: _mobx.action.bound,
+      applyFieldEdit: _mobx.action.bound,
       close: _mobx.action.bound,
       onFileSelected: _mobx.action.bound,
       startImport: _mobx.action.bound,
@@ -168,7 +234,15 @@ class ImportState {
     });
   }
   init() {
-    return () => undefined;
+    return () => {
+      // Unmounting mid-import stops the poll loop (it checks `_cancelled`) so it
+      // doesn't run to terminal holding references. We deliberately do NOT abort
+      // the AbortController: during a cancel-triggered restore it holds the
+      // restore controller, and aborting it would cancel an in-progress restore.
+      // The server-side job is also left running — an unmount isn't an explicit
+      // user cancel.
+      this._cancelled = true;
+    };
   }
   get hasParsedRows() {
     return this.csvHeaders.length > 0 && this.csvRows.length > 0;
@@ -200,6 +274,20 @@ class ImportState {
     return new Set(Object.values(this.mappingByHeader).filter(m => (m == null ? void 0 : m.kind) === 'existing').map(m => m.fieldId));
   }
 
+  /**
+   * The CSV header currently mapped to the collection's `_id` field, or `null`
+   * when no column targets it. Drives both the "When items share the same ID"
+   * control (only shown on this row) and whether `writePolicy` is sent at all —
+   * with no `_id` mapped, every row is a fresh insert and collisions can't occur.
+   */
+  get idMappedHeader() {
+    const entry = Object.entries(this.mappingByHeader).find(([, mapping]) => (mapping == null ? void 0 : mapping.kind) === 'existing' && mapping.fieldId === ID_FIELD_KEY);
+    return entry ? entry[0] : null;
+  }
+  setWritePolicy(policy) {
+    this.writePolicy = policy;
+  }
+
   /**
    * Whether columns may be mapped to a brand-new field created during import.
    * Driven purely by the presence of the `updateSchema` callback — providing the
@@ -220,25 +308,42 @@ class ImportState {
     this.fileName = '';
     this.csvHeaders = [];
     this.csvRows = [];
+    this.orderedHeaders = [];
     this.mappingByHeader = {};
+    this.writePolicy = _types.WritePolicy.OVERWRITE;
     this.processedCount = 0;
     this.totalCount = 0;
     this.result = {
       succeeded: 0,
-      failed: 0,
-      errors: []
+      failed: 0
     };
     this.isBackingUp = false;
     this.isRestoring = false;
     this.restoreFn = null;
     this._cancelled = false;
-    this._failedRowIndices = [];
+    this._jobId = null;
   }
   async close() {
-    if (this.currentStep === 'progress') {
+    // While on the progress step we treat close as a cancel — terminate the job
+    // and restore the backup — UNLESS the import already succeeded. On the
+    // success path `startImport` lingers ~600ms on the completed bar with the
+    // step still 'progress'; closing during that window must NOT restore (it
+    // would undo a clean import). A successful close just closes the modal and
+    // lets the success path do its collection refresh.
+    if (this.currentStep === 'progress' && !this.importStatus.isSuccess) {
       var _this$_abortControlle2;
       this._cancelled = true;
       (_this$_abortControlle2 = this._abortController) == null || _this$_abortControlle2.abort();
+
+      // Stop the server-side job. It does not roll back rows already written —
+      // that's what the backup restore below is for.
+      if (this._jobId) {
+        try {
+          await this.hubJobClient.terminateJob(this._jobId);
+        } catch (error) {
+          console.error('Terminate import job failed', error);
+        }
+      }
       if (!this.isBackingUp) {
         await this._restoreBackup();
       }
@@ -325,11 +430,26 @@ class ImportState {
   _columnValues(columnIndex) {
     return this.csvRows.slice(0, _detectFieldType.TYPE_SAMPLE_SIZE).map(row => row[columnIndex] ?? '');
   }
+
+  // Puts the `_id`-mapped column first (CAIRO-4418), preserving CSV order for the
+  // rest. Returns a fresh array so the snapshot doesn't alias `csvHeaders`.
+  _orderHeadersWithIdFirst(headers) {
+    const idHeader = this.idMappedHeader;
+    return idHeader != null ? [idHeader, ...headers.filter(header => header !== idHeader)] : [...headers];
+  }
   applyParsedCsv(fileName, parsedCsv) {
     this.fileName = fileName;
     this.csvHeaders = parsedCsv.headers;
     this.csvRows = parsedCsv.rows;
     this.mappingByHeader = this.getDefaultMapping(parsedCsv.headers);
+    // Snapshot the row order for this file with the auto-mapped `_id` column
+    // first. Reads `idMappedHeader`, so it must run after `mappingByHeader` is
+    // set. Kept stable until the next file so mapping edits don't reorder rows.
+    this.orderedHeaders = this._orderHeadersWithIdFirst(parsedCsv.headers);
+    // A new file is a fresh import: start from the default policy so a prior
+    // file's Skip choice doesn't silently carry over (only the new-file path
+    // resets — remapping `_id` within the same file keeps the user's choice).
+    this.writePolicy = _types.WritePolicy.OVERWRITE;
     this.currentStep = 'configuration';
   }
   async onFileSelected(file) {
@@ -382,6 +502,7 @@ class ImportState {
       this.fileName = file.name;
       this.csvHeaders = [];
       this.csvRows = [];
+      this.orderedHeaders = [];
       this.mappingByHeader = {};
       this.currentStep = 'upload';
     });
@@ -404,12 +525,11 @@ class ImportState {
   }
   _showPartialSuccessToast() {
     var _this$showToast3;
-    const failed = this._failedRowIndices.length;
     (_this$showToast3 = this.showToast) == null || _this$showToast3.call(this, {
       type: 'WARNING',
       message: this.translate('cairo.import.partialSuccessToast', {
-        failed: String(failed),
-        imported: String(this.totalCount - failed)
+        failed: String(this.result.failed),
+        imported: String(this.result.succeeded)
       }),
       action: {
         text: this.translate('cairo.import.downloadFailedRows'),
@@ -418,12 +538,70 @@ class ImportState {
       }
     });
   }
-  _downloadFailedRows() {
+
+  /**
+   * Builds a plain, re-importable CSV of the rows the server rejected — the
+   * original headers plus just the failed rows — and hands it to `downloadCsv`.
+   * The failed rows come from the job's movement logs (which row failed), mapped
+   * back to the parsed `csvRows` we still hold in memory.
+   */
+  async _downloadFailedRows() {
     var _this$downloadCsv;
-    const failedRows = this._failedRowIndices.map(index => this.csvRows[index]);
+    const jobId = this._jobId;
+    if (!jobId) {
+      return;
+    }
+    let indices;
+    try {
+      indices = await this._fetchFailedRowIndices(jobId);
+    } catch (error) {
+      console.error('Fetching failed rows report failed', error);
+      return;
+    }
+    const failedRows = indices.map(index => this.csvRows[index]).filter(row => row != null);
+    if (failedRows.length === 0) {
+      return;
+    }
     const content = (0, _parseCsv.unparseCsv)(this.csvHeaders, failedRows);
     (_this$downloadCsv = this.downloadCsv) == null || _this$downloadCsv.call(this, content, `failed-${this.fileName || 'import.csv'}`);
   }
+
+  // Pages through the job's movement logs and returns the `csvRows` indices of
+  // the rows that failed. data-hub's CSV decoder
+  // (wix-data-hub: packages/wix-data-hub-executor-c/src/plugins/formats/csv/
+  // csv-binary-decoder.ts) parses with the `csv-parse` library (`columns: true`)
+  // and sets `sourceItemId = "row ${++index + 1}"`, incrementing once **per
+  // record** — not per physical line. So N is the 1-based record number with
+  // the header consumed as columns: the first data record is `"row 2"` →
+  // `csvRows[0]`, i.e. `csvRows[N - 2]`. Because `csv-parse` is RFC-4180,
+  // quoted cells containing embedded newlines are a single record, so they do
+  // NOT shift the numbering. Out-of-range indices are guarded below.
+  async _fetchFailedRowIndices(jobId) {
+    const indices = [];
+    let cursor;
+    do {
+      var _pagingMetadata$curso;
+      const {
+        logs,
+        pagingMetadata
+      } = await this.hubJobClient.listMovementLogs(jobId, cursor ? {
+        cursor
+      } : undefined);
+      for (const log of logs ?? []) {
+        var _exec;
+        if (!log.failure || log.sourceItemId == null) {
+          continue;
+        }
+        const fileLine = Number((_exec = /\d+/.exec(log.sourceItemId)) == null ? void 0 : _exec[0]);
+        const index = fileLine - 2;
+        if (Number.isInteger(index) && index >= 0 && index < this.csvRows.length) {
+          indices.push(index);
+        }
+      }
+      cursor = (pagingMetadata == null ? void 0 : pagingMetadata.hasNext) && ((_pagingMetadata$curso = pagingMetadata.cursors) == null ? void 0 : _pagingMetadata$curso.next) || undefined;
+    } while (cursor);
+    return indices;
+  }
   setMapping(header, fieldId) {
     this.mappingByHeader = {
       ...this.mappingByHeader,
@@ -444,56 +622,158 @@ class ImportState {
       }
     };
   }
-  async _uploadBatches(batches) {
-    let processedRows = 0;
-    let receivedOkResponse = false;
-    const failedRowIndices = [];
-    for (const batch of batches) {
-      if (this._cancelled) {
-        break;
+
+  /**
+   * Persists the result of the "Edit field" editor for a column's pending new
+   * field: the (possibly overridden) type, an optional display-name override,
+   * and the per-type configuration. No-op if the column isn't currently mapped
+   * to a new field.
+   */
+  setNewFieldConfig(header, edit) {
+    const mapping = this.mappingByHeader[header];
+    if ((mapping == null ? void 0 : mapping.kind) !== 'new') {
+      return;
+    }
+    this.mappingByHeader = {
+      ...this.mappingByHeader,
+      [header]: {
+        kind: 'new',
+        fieldType: edit.fieldType,
+        ...(edit.displayName != null && {
+          displayName: edit.displayName
+        }),
+        ...(edit.config && {
+          config: edit.config
+        })
       }
-      const batchStart = processedRows;
-      try {
-        const batchResult = await this.bulkUploadItems(batch);
-        receivedOkResponse = true;
-        this.result = {
-          succeeded: this.result.succeeded + batchResult.succeeded,
-          failed: this.result.failed + batchResult.failed,
-          errors: [...this.result.errors, ...batchResult.errors]
-        };
+    };
+  }
 
-        // Rows the server rejected within an otherwise-OK response. `rowIndex`
-        // is relative to the batch, so offset it to a global `csvRows` index.
-        for (const {
-          rowIndex
-        } of batchResult.errors) {
-          failedRowIndices.push(batchStart + rowIndex);
-        }
-      } catch (error) {
-        // Full batch failure: a batch threw before any OK response came back.
-        // Surface it as an error state with a "Try again" action by rejecting
-        // up to `startImport`, instead of reporting a partial success.
-        if (!receivedOkResponse) {
-          throw error;
-        }
+  /**
+   * Marks which column's pending new field the field editor is currently
+   * editing, so a later `applyFieldEdit` (the editor's `onSubmit`) knows where to
+   * write the result.
+   */
+  beginFieldEdit(header) {
+    this._editingHeader = header;
+  }
 
-        // A batch threw after some rows were already imported. Every row from
-        // the throwing batch onward (including the batches we won't attempt)
-        // counts as failed, on top of any rows already rejected via returned
-        // errors in earlier batches.
-        for (let index = batchStart; index < this.totalCount; index++) {
-          failedRowIndices.push(index);
+  /**
+   * `onSubmit` handler for the field editor: maps the edited field spec into the
+   * column being edited (set via `beginFieldEdit`). No-op if nothing is being
+   * edited.
+   */
+  applyFieldEdit(field) {
+    if (this._editingHeader == null) {
+      return;
+    }
+    this.setNewFieldConfig(this._editingHeader, (0, _fieldEdit.toFieldEdit)(field));
+  }
+
+  /**
+   * Runs the server-side import: align the CSV to the resolved field keys,
+   * upload it, submit a data-movement job, then poll until terminal. Throws on
+   * a failed job so `startImport` surfaces the error state; partial success is
+   * reported via `result.failed` and the partial toast.
+   */
+  async _runImportJob(resolvedMapping) {
+    const csv = (0, _rewriteCsv.rewriteParsedCsvForImport)(this.csvHeaders, this.csvRows, resolvedMapping);
+    const file = new File([csv], this.fileName || 'import.csv', {
+      type: 'text/csv'
+    });
+    const fileId = await this.hubJobClient.uploadFile(file);
+    if (this._cancelled) {
+      return this.result;
+    }
+    const jobId = await this.hubJobClient.submitImportJob({
+      fileId,
+      name: this.fileName,
+      destination: this._destination()
+    });
+    (0, _mobx.runInAction)(() => {
+      this._jobId = jobId;
+    });
+    if (this._cancelled) {
+      // The user cancelled while `submitImportJob` was in flight, so `close()`
+      // saw no `_jobId` and couldn't terminate it. Terminate it here, otherwise
+      // the job keeps importing server-side after cancel (and would overwrite a
+      // restored backup).
+      await this.hubJobClient.terminateJob(jobId).catch(() => undefined);
+      return this.result;
+    }
+    const job = await (0, _importJobPoller.pollImportJob)(id => this.hubJobClient.getJob(id), jobId, {
+      isCancelled: () => this._cancelled,
+      onProgress: polled => this._applyJobProgress(polled)
+    });
+
+    // `null` means cancelled mid-poll — leave whatever progress we have.
+    if (!job) {
+      return this.result;
+    }
+    if (job.status === _types.JobStatus.FAILED) {
+      var _job$error;
+      // The job ran server-side, so a failure arrives on a 200 (the poll
+      // succeeded; the job didn't) with no HTTP error to carry the application
+      // error. Build a synthetic, HTTP-error-shaped error (the error handler
+      // reads the code from `response.data.details.applicationError`) and hand
+      // the throwing operation to the consumer's `onJobError` so THEY wrap it
+      // with their own `withErrorHandler` + error-code map — `job.error` is the
+      // consumer's application error (their import business logic), so only they
+      // can map its codes, and the map stays coupled to the `withErrorHandler`
+      // call as everywhere else (e.g. `fetchData`). The map is attached to the
+      // error object, which the progress step resolves via `getResolvedError`.
+      // Without a handler the same error still throws, falling back to the
+      // generic message.
+      const error = Object.assign(new Error(`ImportJob.${((_job$error = job.error) == null ? void 0 : _job$error.code) ?? 'failed'}`), {
+        response: {
+          data: {
+            details: {
+              applicationError: job.error
+            }
+          }
         }
-        break;
-      }
-      processedRows += batch.length;
-      (0, _mobx.runInAction)(() => {
-        this.processedCount = Math.min(processedRows, this.totalCount);
       });
+      const run = () => Promise.reject(error);
+      if (this.onJobError) {
+        // The consumer wraps `run` with `withErrorHandler`; it re-rejects with
+        // `error` (now carrying their map), which propagates from here.
+        await this.onJobError(run);
+      }
+      throw error;
     }
-    this._failedRowIndices = failedRowIndices;
+    this._applyJobProgress(job);
     return this.result;
   }
+
+  // Destination: the consumer's Wix Data collection. `writePolicy` is sent only
+  // when a CSV column is mapped to `_id` (the only case collisions can occur);
+  // otherwise it's omitted and the server applies its default (upsert by `_id`).
+  _destination() {
+    return {
+      wixDataCollection: {
+        collectionId: this.collectionId,
+        ...(this.idMappedHeader != null && {
+          writePolicy: this.writePolicy
+        })
+      }
+    };
+  }
+  _applyJobProgress(job) {
+    const progress = job.progress;
+    const succeeded = (progress == null ? void 0 : progress.itemsSuccessful) ?? 0;
+    const failed = (progress == null ? void 0 : progress.itemsRejected) ?? 0;
+    const current = (progress == null ? void 0 : progress.current) ?? succeeded + failed;
+
+    // `totalCount` is fixed up front in `startImport` from the CSV row count
+    // (one uploaded row per CSV row); polling only advances `processedCount`.
+    (0, _mobx.runInAction)(() => {
+      this.processedCount = Math.min(current, this.totalCount);
+      this.result = {
+        succeeded,
+        failed
+      };
+    });
+  }
   async _runBackup() {
     const backup = this.backup;
     if (!backup) {
@@ -550,16 +830,23 @@ class ImportState {
       } else if (mapping.kind === 'existing') {
         resolved[header] = mapping.fieldId;
       } else if (this.updateSchema) {
+        var _mapping$displayName;
+        // The user's name override (from the field editor) seeds the unique
+        // name/key derivation; otherwise fall back to the column header.
+        const baseName = ((_mapping$displayName = mapping.displayName) == null ? void 0 : _mapping$displayName.trim()) || header;
         const {
           displayName,
           key
-        } = uniqueFieldNameAndKey(header, usedNames, usedKeys);
+        } = uniqueFieldNameAndKey(baseName, usedNames, usedKeys);
         usedKeys.add(key);
         usedNames.add(displayName);
         newFields.push({
           key,
           type: mapping.fieldType,
-          displayName
+          displayName,
+          ...(mapping.config && {
+            config: mapping.config
+          })
         });
         resolved[header] = key;
       } else {
@@ -572,15 +859,6 @@ class ImportState {
     }
     return resolved;
   }
-  _createRowsBatches(rows) {
-    return rows.reduce((acc, row, index) => {
-      if (index % this.batchSize === 0) {
-        acc.push([]);
-      }
-      acc[acc.length - 1].push(row);
-      return acc;
-    }, []);
-  }
   async startImport() {
     if (!this.hasMappings) {
       return;
@@ -588,8 +866,8 @@ class ImportState {
     this._cancelled = false;
     this._abortController = new AbortController();
 
-    // One mapped row is produced per CSV row, so the total is known up front and
-    // doesn't depend on field creation below.
+    // One uploaded row per CSV row (the rewrite drops columns, not rows), so the
+    // total is known up front from the parsed CSV and stays fixed through polling.
     const totalCount = this.csvRows.length;
     (0, _mobx.runInAction)(() => {
       this.currentStep = 'progress';
@@ -603,10 +881,9 @@ class ImportState {
       };
       this.result = {
         succeeded: 0,
-        failed: 0,
-        errors: []
+        failed: 0
       };
-      this._failedRowIndices = [];
+      this._jobId = null;
     });
     const backupFailed = await this._runBackup();
     if (backupFailed) {
@@ -617,8 +894,8 @@ class ImportState {
     }
 
     // Create any new fields and resolve every column to its destination key
-    // before building the payload. A creation failure surfaces as the error
-    // state with a "Try again" CTA, like a first-batch upload failure.
+    // before uploading. A creation failure surfaces as the error state with a
+    // "Try again" CTA, like an upload/job failure.
     let resolvedMapping;
     try {
       resolvedMapping = await this._resolveFieldMapping();
@@ -634,9 +911,7 @@ class ImportState {
     if (this._cancelled) {
       return;
     }
-    const rows = toMappedRows(this.csvRows, this.csvHeaders, resolvedMapping);
-    const batches = this._createRowsBatches(rows);
-    const promise = this._uploadBatches(batches);
+    const promise = this._runImportJob(resolvedMapping);
     this.importStatus = {
       ..._model.queryStatus.loading,
       promise
@@ -657,17 +932,16 @@ class ImportState {
       // briefly so the completion is perceptible even for very few rows. Skip
       // the wait when there are failed rows — that path closes and surfaces a
       // toast instead.
-      if (this._failedRowIndices.length === 0) {
+      if (this.result.failed === 0) {
         await this._lingerOnCompletion();
         if (this._cancelled) {
           return;
         }
       }
       (0, _mobx.runInAction)(() => {
-        // Any rows that didn't make it in — whether rejected via a batch's
-        // returned `errors` or left unimported when a batch threw — are
-        // reported via a toast that offers them as a downloadable CSV.
-        if (this._failedRowIndices.length > 0) {
+        // Rows the server rejected are reported via a toast (the downloadable
+        // failed-rows report is added by the failed-rows-report task).
+        if (this.result.failed > 0) {
           this._showPartialSuccessToast();
         }
         this.importModalState.close();