@wix/bex-core 2.332.0 → 2.333.0

package/dist/cjs/state/ImportState/__tests__/ImportState.engine.spec.js

@@ -19,13 +19,17 @@ const COMPLETED_JOB = {
     itemsSuccessful: 2,
     itemsRejected: 0,
     total: 2,
-    current: 2
+    current: 2,
+    itemsSuccessfulInfo: {
+      itemsCreated: 1,
+      itemsUpdated: 1
+    }
   }
 };
 
-// Config overrides merge into the default config; `config` fully replaces it
-// (for schema-backed configs). `detectColumnType` is an infra prop; `mergeFields`
-// is part of the config (merged via configOverrides).
+// Convenience flat overrides, assembled into the `dataSource` union below;
+// `config` fully replaces the assembled config (for schema-backed configs).
+// `detectColumnType` is an infra prop.
 
 function setup(clientOverrides = {}, extra = {}) {
   const client = {
@@ -49,15 +53,49 @@ function setup(clientOverrides = {}, extra = {}) {
   const {
     detectColumnType,
     config: configOverride,
-    ...configOverrides
+    collectionId,
+    destination,
+    updateSchema,
+    createFields,
+    fieldManagement,
+    mergeFields,
+    fields,
+    idFieldKey,
+    backup,
+    jobApplicationErrorMap
   } = extra;
+  const dataSource = destination ? {
+    destination,
+    ...(createFields && {
+      createFields
+    }),
+    ...(fieldManagement && {
+      fieldManagement
+    })
+  } : {
+    collectionId: collectionId ?? 'Movies',
+    ...(updateSchema && {
+      updateSchema
+    })
+  };
   const config = configOverride ?? {
-    fields: [{
+    fields: fields ?? [{
       id: 'name',
       header: 'Name'
     }],
-    collectionId: 'Movies',
-    ...configOverrides
+    dataSource,
+    ...(mergeFields && {
+      mergeFields
+    }),
+    ...(idFieldKey && {
+      idFieldKey
+    }),
+    ...(backup && {
+      backup
+    }),
+    ...(jobApplicationErrorMap && {
+      jobApplicationErrorMap
+    })
   };
   const props = {
     config,
@@ -99,8 +137,8 @@ function setup(clientOverrides = {}, extra = {}) {
 }
 describe('ImportState engine (data-hub job)', () => {
   beforeEach(() => {
-    // The success path awaits a real setTimeout (completion linger); make sure
-    // timers are real even if the preset defaults to fake ones.
+    // The poll loop awaits real setTimeouts between polls; make sure timers are
+    // real even if the preset defaults to fake ones.
     jest.useRealTimers();
   });
   it('uploads the aligned file, submits a job, and reports success', async () => {
@@ -122,17 +160,63 @@ describe('ImportState engine (data-hub job)', () => {
         }
       }
     });
+
+    // created/updated come from the job's itemsSuccessfulInfo.
     expect(state.result).toEqual({
       succeeded: 2,
-      failed: 0
+      failed: 0,
+      created: 1,
+      updated: 1
     });
     expect(state.importStatus.status).toBe('success');
-    expect(importModalState.close).toHaveBeenCalled();
+    // The modal stays open on the summary step; the collection is refreshed now
+    // so the table is current once the user closes it via `done`.
+    expect(state.currentStep).toBe('summary');
+    expect(importModalState.close).not.toHaveBeenCalled();
     expect(collection.clearResultAndMoveToStart).toHaveBeenCalledWith({
       force: true
     });
   });
-  it('shows a partial-success toast when some rows are rejected', async () => {
+  it('holds the completed (100%) progress bar on the progress step before the summary (CAIRO-4476)', async () => {
+    const {
+      state
+    } = setup();
+
+    // The job reports counts only when it finishes, so the bar can only reach
+    // 100% at the very end. Capture the step + counts at the moment the linger
+    // starts to prove the user sees the completed bar before the summary
+    // replaces it.
+    let atLinger = null;
+    const spy = jest
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .spyOn(state, '_lingerOnCompletion').mockImplementation(() => {
+      atLinger = {
+        step: state.currentStep,
+        processed: state.processedCount,
+        total: state.totalCount
+      };
+      return Promise.resolve();
+    });
+    await state.startImport();
+    expect(atLinger).toEqual({
+      step: 'progress',
+      processed: 2,
+      total: 2
+    });
+    expect(state.currentStep).toBe('summary');
+    spy.mockRestore();
+  });
+  it('closes the modal only when the user dismisses the summary via done', async () => {
+    const {
+      state,
+      importModalState
+    } = setup();
+    await state.startImport();
+    expect(importModalState.close).not.toHaveBeenCalled();
+    state.done();
+    expect(importModalState.close).toHaveBeenCalled();
+  });
+  it('shows the summary step (no toast) when some rows are rejected', async () => {
     const {
       state,
       showToast,
@@ -145,25 +229,30 @@ describe('ImportState engine (data-hub job)', () => {
           itemsSuccessful: 1,
           itemsRejected: 1,
           total: 2,
-          current: 2
+          current: 2,
+          itemsSuccessfulInfo: {
+            itemsCreated: 1,
+            itemsUpdated: 0
+          }
         }
       }))
     });
     await state.startImport();
     expect(state.result).toEqual({
       succeeded: 1,
-      failed: 1
+      failed: 1,
+      created: 1,
+      updated: 0
     });
-    expect(showToast).toHaveBeenCalledWith(expect.objectContaining({
-      type: 'WARNING'
-    }));
-    expect(importModalState.close).toHaveBeenCalled();
+    expect(state.currentStep).toBe('summary');
+    // The completion toast is gone — the summary step reports the outcome.
+    expect(showToast).not.toHaveBeenCalled();
+    expect(importModalState.close).not.toHaveBeenCalled();
   });
   it('maps the failed "row N" by record (unaffected by an embedded-newline cell)', async () => {
     const {
       state,
-      downloadCsv,
-      showToast
+      downloadCsv
     } = setup({
       getJob: jest.fn(async () => ({
         id: 'job-1',
@@ -206,19 +295,17 @@ describe('ImportState engine (data-hub job)', () => {
       };
     });
     await state.startImport();
-    const toast = showToast.mock.calls[0][0];
-    await toast.action.onClick();
+    await state.downloadFailedRows();
 
     // "row 4" → csvRows[2] (Mango), NOT shifted by the embedded newline in row 0.
     const [content] = downloadCsv.mock.calls[0];
     expect(content).toContain('Mango');
     expect(content).not.toContain('Apple');
   });
-  it('downloads a re-importable CSV of the failed rows from the partial toast action', async () => {
+  it('downloads a re-importable CSV of the failed rows, each prefixed with its failure reason', async () => {
     const {
       state,
       client,
-      showToast,
       downloadCsv
     } = setup({
       getJob: jest.fn(async () => ({
@@ -235,7 +322,7 @@ describe('ImportState engine (data-hub job)', () => {
           sourceItemId: 'row 3',
           failure: {
             code: 'bad',
-            description: 'x'
+            description: 'Invalid value'
           }
         }],
         pagingMetadata: {
@@ -244,13 +331,12 @@ describe('ImportState engine (data-hub job)', () => {
       }))
     });
     await state.startImport();
-
-    // Trigger the toast's download action.
-    const toast = showToast.mock.calls[0][0];
-    await toast.action.onClick();
+    await state.downloadFailedRows();
     expect(client.listMovementLogs).toHaveBeenCalledWith('job-1', undefined);
-    // Original headers + only the failed row, ready to fix and re-upload.
-    expect(downloadCsv).toHaveBeenCalledWith('Name\r\nPear', 'failed-data.csv');
+    // A leading reason column (the translated header) + original headers, then
+    // the failed row prefixed with the server's failure reason — ready to fix
+    // and re-upload. `translate` here echoes the key for the column header.
+    expect(downloadCsv).toHaveBeenCalledWith('cairo.import.failureReasonColumn,Name\r\nInvalid value,Pear', 'failed-data.csv');
   });
   it('surfaces an error state with an application-error-shaped error when the job fails', async () => {
     var _error$response;
@@ -278,17 +364,18 @@ describe('ImportState engine (data-hub job)', () => {
     expect(importModalState.close).not.toHaveBeenCalled();
     expect(collection.clearResultAndMoveToStart).not.toHaveBeenCalled();
   });
-  it('hands a failed job to onJobError, which surfaces the wrapped error', async () => {
+  it('resolves a failed job through the consumer jobApplicationErrorMap', async () => {
     var _error$response2;
-    // Wiring only: the consumer forwards `run` to their withErrorHandler exactly
-    // as documented, and the error it re-rejects is the one surfaced to the UI
-    // (with the application-error-shaped code intact). End-to-end resolution
-    // against the real error handler is covered in the cairo
-    // Table.importButton spec, which has a real errorHandler instance.
-    // Mirror `(run) => errorHandler.withErrorHandler(run, errorCodesMap)`;
-    // a passthrough stub, so this just runs `run` and re-rejects.
-    const withErrorHandler = fn => fn();
-    const onJobError = jest.fn(run => withErrorHandler(run));
+    // ImportState wraps the failure with `errorHandler.withErrorHandler(run,
+    // jobApplicationErrorMap)` itself; the consumer only supplies the per-code
+    // map. The surfaced error keeps the application-error-shaped code intact.
+    // End-to-end resolution against the real error handler (getResolvedError) is
+    // covered in the cairo Table.importButton spec.
+    const jobApplicationErrorMap = {
+      duplicate_key: () => ({
+        message: 'Bad rows'
+      })
+    };
     const {
       state
     } = setup({
@@ -301,11 +388,9 @@ describe('ImportState engine (data-hub job)', () => {
         }
       }))
     }, {
-      onJobError
+      jobApplicationErrorMap
     });
     await state.startImport();
-    expect(onJobError).toHaveBeenCalledTimes(1);
-    expect(typeof onJobError.mock.calls[0][0]).toBe('function');
     expect(state.importStatus.status).toBe('error');
     const error = state.importStatus.error;
     expect((_error$response2 = error.response) == null || (_error$response2 = _error$response2.data) == null || (_error$response2 = _error$response2.details) == null || (_error$response2 = _error$response2.applicationError) == null ? void 0 : _error$response2.code).toBe('duplicate_key');
@@ -365,7 +450,7 @@ describe('ImportState engine (data-hub job)', () => {
     // forever; it must stop after the first fetch.
     expect(client.getJob).toHaveBeenCalledTimes(1);
   });
-  it('does not restore when closed during the success completion linger', async () => {
+  it('does not restore a completed import when the summary is closed', async () => {
     const restoreFn = jest.fn().mockResolvedValue(undefined);
     const {
       state,
@@ -376,30 +461,19 @@ describe('ImportState engine (data-hub job)', () => {
         restore: restoreFn
       })
     });
+    await state.startImport();
 
-    // A 0ms macrotask drains the pending async chain without firing the 600ms
-    // linger timer.
-    const flush = () => new Promise(resolve => setTimeout(resolve, 0));
-    const promise = state.startImport();
-    // Run backup → upload → submit → poll (terminal) → success, parking on the
-    // 600ms completion linger (still on the 'progress' step) without firing it.
-    await flush();
-    await flush();
-    await flush();
+    // The import finished on the summary step and the collection was refreshed.
     expect(state.importStatus.isSuccess).toBe(true);
-    expect(state.currentStep).toBe('progress');
+    expect(state.currentStep).toBe('summary');
+    expect(collection.clearResultAndMoveToStart).toHaveBeenCalledWith({
+      force: true
+    });
 
-    // User closes the modal mid-linger.
+    // Closing the summary must not revert a successful import.
     await state.close();
-    await promise;
-
-    // A successful import must not be reverted; the modal closes and the
-    // collection refreshes.
     expect(restoreFn).not.toHaveBeenCalled();
     expect(importModalState.close).toHaveBeenCalled();
-    expect(collection.clearResultAndMoveToStart).toHaveBeenCalledWith({
-      force: true
-    });
   });
 });
 describe('ImportState writePolicy (id-collision handling)', () => {
@@ -685,6 +759,115 @@ describe('ImportState platformized destination (non–Wix-Data)', () => {
     const wixData = setup().state;
     expect(wixData.canConfigureWritePolicy).toBe(true);
   });
+  describe('DataExtension create fields (destination branch)', () => {
+    it('enables create-new-field when the destination branch supplies createFields', () => {
+      const withCreate = setup({}, {
+        destination: {
+          storesCatalogProducts: {}
+        },
+        createFields: jest.fn(async () => undefined)
+      }).state;
+      expect(withCreate.canCreateNewField).toBe(true);
+      const withoutCreate = setup({}, {
+        destination: {
+          storesCatalogProducts: {}
+        }
+      }).state;
+      expect(withoutCreate.canCreateNewField).toBe(false);
+    });
+    it('hands createFields the deduped pending columns (source builds its own def)', async () => {
+      const createFields = jest.fn(async () => undefined);
+      const {
+        state,
+        client
+      } = setup({}, {
+        destination: {
+          storesCatalogProducts: {}
+        },
+        createFields
+      });
+      (0, _mobx.runInAction)(() => {
+        state.csvHeaders = ['Name', 'Color'];
+        state.csvRows = [['Apple', 'Red'], ['Pear', 'Green']];
+        state.mappingByHeader = {
+          Name: {
+            kind: 'existing',
+            fieldId: 'name'
+          },
+          Color: {
+            kind: 'new',
+            fieldType: 'text'
+          }
+        };
+      });
+      await state.startImport();
+      expect(createFields).toHaveBeenCalledTimes(1);
+      // Core passes the neutral pending column (deduped key + name + the mapping);
+      // the DataExtension source turns it into its own field shape.
+      expect(createFields).toHaveBeenCalledWith([{
+        key: 'color',
+        displayName: 'Color',
+        mapping: {
+          kind: 'new',
+          fieldType: 'text'
+        }
+      }]);
+      // The consumer's destination is still sent verbatim.
+      expect(client.submitImportJob).toHaveBeenCalledWith(expect.objectContaining({
+        destination: {
+          storesCatalogProducts: {}
+        }
+      }));
+    });
+    it('carries the edited mapping config (precise type, permissions, PII) in the pending column', async () => {
+      const createFields = jest.fn(async () => undefined);
+      const {
+        state
+      } = setup({}, {
+        destination: {
+          storesCatalogProducts: {}
+        },
+        createFields
+      });
+      const config = {
+        deType: 'decimal',
+        isPii: true,
+        permissions: {
+          installedApps: {
+            defaultRead: true,
+            defaultWrite: false
+          }
+        }
+      };
+      (0, _mobx.runInAction)(() => {
+        state.csvHeaders = ['Name', 'Count'];
+        state.csvRows = [['Apple', '3']];
+        state.mappingByHeader = {
+          Name: {
+            kind: 'existing',
+            fieldId: 'name'
+          },
+          Count: {
+            kind: 'new',
+            fieldType: 'number',
+            displayName: 'Count',
+            config
+          }
+        };
+      });
+      await state.startImport();
+      expect(createFields).toHaveBeenCalledWith([{
+        key: 'count',
+        displayName: 'Count',
+        mapping: {
+          kind: 'new',
+          fieldType: 'number',
+          displayName: 'Count',
+          config
+        }
+      }]);
+    });
+  });
   describe('created fields (CAIRO-4400)', () => {
     const RETURNED_FIELDS = {
       name: {
@@ -807,7 +990,6 @@ describe('ImportState platformized destination (non–Wix-Data)', () => {
       const updateSchema = jest.fn(async () => RETURNED_FIELDS);
       const {
         state,
-        importModalState,
         collection
       } = setup({}, {
         updateSchema,
@@ -818,22 +1000,32 @@ describe('ImportState platformized destination (non–Wix-Data)', () => {
       expect(mergeFields).toHaveBeenCalledTimes(1);
       // A throwing merge is swallowed — the completed import is untouched.
       expect(state.importStatus.status).toBe('success');
-      expect(importModalState.close).toHaveBeenCalled();
+      expect(state.currentStep).toBe('summary');
       expect(collection.clearResultAndMoveToStart).toHaveBeenCalled();
       consoleError.mockRestore();
     });
   });
   describe('schema-backed config (live getters + create-field permission)', () => {
-    // A schema-backed config sets canAddFields explicitly and supplies
-    // updateSchema/idFieldKey — the shape a SchemaImportRef satisfies.
+    // A schema-backed config: the CMS `dataSource` branch a SchemaImportRef
+    // satisfies. It supplies `updateSchema` only when create is permitted — its
+    // presence is the create-new-field opt-in (no separate flag).
     const schemaConfig = (over = {}) => ({
-      fields: [{
+      fields: over.fields ?? [{
         id: 'name',
         header: 'Name'
       }],
-      collectionId: 'RefCollection',
-      canAddFields: false,
-      ...over
+      dataSource: {
+        collectionId: over.collectionId ?? 'RefCollection',
+        ...(over.updateSchema && {
+          updateSchema: over.updateSchema
+        })
+      },
+      ...(over.idFieldKey && {
+        idFieldKey: over.idFieldKey
+      }),
+      ...(over.mergeFields && {
+        mergeFields: over.mergeFields
+      })
     });
     it('reads fields live from the config rather than snapshotting them', () => {
       const config = schemaConfig();
@@ -856,17 +1048,17 @@ describe('ImportState platformized destination (non–Wix-Data)', () => {
       config.fields = updated;
       expect(state.fields).toBe(updated);
     });
-    it('gates create-new-field on canAddFields even when updateSchema is present', () => {
+    it('gates create-new-field on the presence of a create callback (updateSchema)', () => {
+      // No create callback ⇒ create-new-field off (the source didn't permit it).
       const off = setup({}, {
-        config: schemaConfig({
-          canAddFields: false,
-          updateSchema: jest.fn()
-        })
+        config: schemaConfig()
       });
       expect(off.state.canCreateNewField).toBe(false);
+
+      // A create callback present ⇒ on.
       const on = setup({}, {
         config: schemaConfig({
-          canAddFields: true
+          updateSchema: jest.fn()
         })
       });
       expect(on.state.canCreateNewField).toBe(true);
@@ -906,7 +1098,6 @@ describe('ImportState platformized destination (non–Wix-Data)', () => {
         state
       } = setup({}, {
         config: schemaConfig({
-          canAddFields: true,
           updateSchema
         })
       });
@@ -947,4 +1138,147 @@ describe('ImportState platformized destination (non–Wix-Data)', () => {
     });
   });
 });
+describe('ImportState required fields (CAIRO-4452)', () => {
+  beforeEach(() => {
+    jest.useRealTimers();
+  });
+  it('is satisfied when a required field has a column mapped to it', () => {
+    const {
+      state
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+
+    // The seeded mapping maps the "Name" column to the `name` field.
+    expect(state.hasMissingRequiredFields).toBe(false);
+    expect(state.missingRequiredFields).toEqual([]);
+  });
+  it('flags a required field the user set to "don\'t import"', () => {
+    const {
+      state
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+    state.setMapping('Name', null);
+    expect(state.hasMissingRequiredFields).toBe(true);
+    expect(state.missingRequiredFields.map(f => f.id)).toEqual(['name']);
+  });
+  it('ignores unmapped fields that are not required', () => {
+    const {
+      state
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name'
+        }, {
+          id: 'year',
+          header: 'Year',
+          required: false
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+    state.setMapping('Name', null);
+    expect(state.hasMissingRequiredFields).toBe(false);
+  });
+  it('is not satisfied by a create-new-field mapping', () => {
+    const {
+      state
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }],
+        dataSource: {
+          collectionId: 'Movies',
+          updateSchema: async () => undefined
+        }
+      }
+    });
+
+    // Mapping the column to a brand-new field can't fill the existing required
+    // field, so it stays missing.
+    state.setNewFieldMapping('Name');
+    expect(state.hasMissingRequiredFields).toBe(true);
+  });
+  it('blocks startImport and shows an error toast when a required field is missing', async () => {
+    const {
+      state,
+      client,
+      showToast
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }, {
+          id: 'year',
+          header: 'Year'
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+
+    // Keep a mapping (so the import isn't blocked by "no mappings") but leave the
+    // required `name` field unmapped.
+    (0, _mobx.runInAction)(() => {
+      state.csvHeaders = ['Name', 'Year'];
+      state.csvRows = [['Apple', '2020']];
+    });
+    state.setMapping('Name', null);
+    state.setMapping('Year', 'year');
+    await state.startImport();
+    expect(client.uploadFile).not.toHaveBeenCalled();
+    expect(client.submitImportJob).not.toHaveBeenCalled();
+    expect(state.currentStep).not.toBe('progress');
+    expect(showToast).toHaveBeenCalledWith(expect.objectContaining({
+      type: 'ERROR'
+    }));
+  });
+  it('proceeds with import when all required fields are mapped', async () => {
+    const {
+      state,
+      client
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+    await state.startImport();
+    expect(client.submitImportJob).toHaveBeenCalledTimes(1);
+  });
+});
 //# sourceMappingURL=ImportState.engine.spec.js.map