@wix/bex-core 2.331.0 → 2.333.0

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

@@ -13,9 +13,15 @@ jest.mock('../hubJobClient');
 const COMPLETED_JOB = {
     id: 'job-1',
     status: JobStatus.COMPLETED,
-    progress: { itemsSuccessful: 2, itemsRejected: 0, total: 2, current: 2 },
+    progress: {
+        itemsSuccessful: 2,
+        itemsRejected: 0,
+        total: 2,
+        current: 2,
+        itemsSuccessfulInfo: { itemsCreated: 1, itemsUpdated: 1 },
+    },
 };
-function setup(clientOverrides = {}, extraProps = {}) {
+function setup(clientOverrides = {}, extra = {}) {
     const client = {
         uploadFile: jest.fn(async (_file) => 'file-1'),
         submitImportJob: jest.fn(async () => 'job-1'),
@@ -32,9 +38,27 @@ function setup(clientOverrides = {}, extraProps = {}) {
     const showToast = jest.fn();
     const downloadCsv = jest.fn();
     const translate = (key, params) => params ? `${key}:${JSON.stringify(params)}` : key;
+    const { detectColumnType, config: configOverride, 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 ?? [{ id: 'name', header: 'Name' }],
+        dataSource,
+        ...(mergeFields && { mergeFields }),
+        ...(idFieldKey && { idFieldKey }),
+        ...(backup && { backup }),
+        ...(jobApplicationErrorMap && { jobApplicationErrorMap }),
+    };
     const props = {
-        fields: [{ id: 'name', header: 'Name' }],
-        collectionId: 'Movies',
+        config,
         httpClient: {
             request: jest.fn(),
         },
@@ -46,7 +70,7 @@ function setup(clientOverrides = {}, extraProps = {}) {
         },
         showToast: showToast,
         downloadCsv,
-        ...extraProps,
+        detectColumnType,
     };
     const state = new ImportState(props);
     // Seed a parsed CSV mapped to an existing field.
@@ -67,8 +91,8 @@ function setup(clientOverrides = {}, extraProps = {}) {
 }
 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 () => {
@@ -81,14 +105,53 @@ describe('ImportState engine (data-hub job)', () => {
             name: 'data.csv',
             destination: { wixDataCollection: { collectionId: 'Movies' } },
         });
-        expect(state.result).toEqual({ succeeded: 2, failed: 0 });
+        // created/updated come from the job's itemsSuccessfulInfo.
+        expect(state.result).toEqual({
+            succeeded: 2,
+            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, importModalState } = setup({
             getJob: jest.fn(async () => ({
                 id: 'job-1',
@@ -98,16 +161,24 @@ describe('ImportState engine (data-hub job)', () => {
                     itemsRejected: 1,
                     total: 2,
                     current: 2,
+                    itemsSuccessfulInfo: { itemsCreated: 1, itemsUpdated: 0 },
                 },
             })),
         });
         await state.startImport();
-        expect(state.result).toEqual({ succeeded: 1, failed: 1 });
-        expect(showToast).toHaveBeenCalledWith(expect.objectContaining({ type: 'WARNING' }));
-        expect(importModalState.close).toHaveBeenCalled();
+        expect(state.result).toEqual({
+            succeeded: 1,
+            failed: 1,
+            created: 1,
+            updated: 0,
+        });
+        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 } = setup({
+        const { state, downloadCsv } = setup({
             getJob: jest.fn(async () => ({
                 id: 'job-1',
                 status: JobStatus.PARTIALLY_SUCCESSFUL,
@@ -137,15 +208,14 @@ 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 () => {
-        const { state, client, showToast, downloadCsv } = setup({
+    it('downloads a re-importable CSV of the failed rows, each prefixed with its failure reason', async () => {
+        const { state, client, downloadCsv } = setup({
             getJob: jest.fn(async () => ({
                 id: 'job-1',
                 status: JobStatus.PARTIALLY_SUCCESSFUL,
@@ -154,18 +224,21 @@ describe('ImportState engine (data-hub job)', () => {
             // csvRows[1] (the "Pear" row) failed → file line 3 → "row 3".
             listMovementLogs: jest.fn(async () => ({
                 logs: [
-                    { sourceItemId: 'row 3', failure: { code: 'bad', description: 'x' } },
+                    {
+                        sourceItemId: 'row 3',
+                        failure: { code: 'bad', description: 'Invalid value' },
+                    },
                 ],
                 pagingMetadata: { hasNext: false },
             })),
         });
         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 () => {
         const { state, importModalState, collection } = setup({
@@ -185,26 +258,21 @@ 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 () => {
-        // 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));
+    it('resolves a failed job through the consumer jobApplicationErrorMap', async () => {
+        // 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({
             getJob: jest.fn(async () => ({
                 id: 'job-1',
                 status: JobStatus.FAILED,
                 error: { code: 'duplicate_key', description: 'Bad rows' },
             })),
-        }, { 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.response?.data?.details?.applicationError?.code).toBe('duplicate_key');
@@ -246,30 +314,20 @@ 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, importModalState, collection } = setup({}, { backup: async () => ({ restore: restoreFn }) });
-        // 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();
+        await state.startImport();
+        // The import finished on the summary step and the collection was refreshed.
         expect(state.importStatus.isSuccess).toBe(true);
-        expect(state.currentStep).toBe('progress');
-        // User closes the modal mid-linger.
-        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(state.currentStep).toBe('summary');
         expect(collection.clearResultAndMoveToStart).toHaveBeenCalledWith({
             force: true,
         });
+        // Closing the summary must not revert a successful import.
+        await state.close();
+        expect(restoreFn).not.toHaveBeenCalled();
+        expect(importModalState.close).toHaveBeenCalled();
     });
 });
 describe('ImportState writePolicy (id-collision handling)', () => {
@@ -470,5 +528,334 @@ 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 });
+            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 },
+                },
+            };
+            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: { id: 'name', displayName: 'Name', type: 'SHORT_TEXT' },
+            color: { id: 'color', displayName: 'Color', type: 'SHORT_TEXT' },
+        };
+        // Maps an extra column to a NEW field so `_resolveFieldMapping` calls
+        // `updateSchema`. `updateSchema`'s presence is also what enables new mappings.
+        function withNewFieldMapping(state) {
+            runInAction(() => {
+                state.csvHeaders = ['Name', 'Color'];
+                state.csvRows = [
+                    ['Apple', 'Red'],
+                    ['Pear', 'Green'],
+                ];
+                state.mappingByHeader = {
+                    Name: { kind: 'existing', fieldId: 'name' },
+                    Color: { kind: 'new', fieldType: 'text' },
+                };
+            });
+        }
+        it('calls mergeFields with updateSchema’s returned map after a successful import', async () => {
+            const mergeFields = jest.fn();
+            const updateSchema = jest.fn(async () => RETURNED_FIELDS);
+            const { state, collection } = setup({}, { updateSchema, mergeFields });
+            withNewFieldMapping(state);
+            await state.startImport();
+            expect(updateSchema).toHaveBeenCalledTimes(1);
+            expect(mergeFields).toHaveBeenCalledTimes(1);
+            expect(mergeFields).toHaveBeenCalledWith(RETURNED_FIELDS);
+            // The merge runs alongside the data refetch on the success path.
+            expect(collection.clearResultAndMoveToStart).toHaveBeenCalled();
+        });
+        it('does not call mergeFields for a plain import (no new fields)', async () => {
+            const mergeFields = jest.fn();
+            const updateSchema = jest.fn(async () => RETURNED_FIELDS);
+            const { state } = setup({}, { updateSchema, mergeFields });
+            await state.startImport();
+            expect(updateSchema).not.toHaveBeenCalled();
+            expect(mergeFields).not.toHaveBeenCalled();
+        });
+        it('does not call mergeFields when updateSchema returns nothing', async () => {
+            const mergeFields = jest.fn();
+            const updateSchema = jest.fn(async () => undefined);
+            const { state } = setup({}, { updateSchema, mergeFields });
+            withNewFieldMapping(state);
+            await state.startImport();
+            expect(updateSchema).toHaveBeenCalledTimes(1);
+            expect(mergeFields).not.toHaveBeenCalled();
+        });
+        it('does not call mergeFields when updateSchema returns an empty map', async () => {
+            // A `{}` return is truthy; without a size guard it would reach a full-replace
+            // mergeFields({}) and wipe every column. Treat it as "nothing to merge".
+            const mergeFields = jest.fn();
+            const updateSchema = jest.fn(async () => ({}));
+            const { state } = setup({}, { updateSchema, mergeFields });
+            withNewFieldMapping(state);
+            await state.startImport();
+            expect(updateSchema).toHaveBeenCalledTimes(1);
+            expect(mergeFields).not.toHaveBeenCalled();
+        });
+        it('does not call mergeFields when the import fails after creating fields', async () => {
+            const mergeFields = jest.fn();
+            const updateSchema = jest.fn(async () => RETURNED_FIELDS);
+            const { state } = setup({
+                uploadFile: jest.fn(async () => {
+                    throw new Error('upload failed');
+                }),
+            }, { updateSchema, mergeFields });
+            withNewFieldMapping(state);
+            await state.startImport();
+            // Fields were created pre-upload, but a failed import must not merge them.
+            expect(updateSchema).toHaveBeenCalledTimes(1);
+            expect(state.importStatus.status).toBe('error');
+            expect(mergeFields).not.toHaveBeenCalled();
+        });
+        it('keeps the import successful when mergeFields throws (no void → duplicate-rows)', async () => {
+            const consoleError = jest
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            const mergeFields = jest.fn(() => {
+                throw new Error('merge boom');
+            });
+            const updateSchema = jest.fn(async () => RETURNED_FIELDS);
+            const { state, collection } = setup({}, { updateSchema, mergeFields });
+            withNewFieldMapping(state);
+            await state.startImport();
+            expect(mergeFields).toHaveBeenCalledTimes(1);
+            // A throwing merge is swallowed — the completed import is untouched.
+            expect(state.importStatus.status).toBe('success');
+            expect(state.currentStep).toBe('summary');
+            expect(collection.clearResultAndMoveToStart).toHaveBeenCalled();
+            consoleError.mockRestore();
+        });
+    });
+    describe('schema-backed config (live getters + create-field permission)', () => {
+        // 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: over.fields ?? [{ id: 'name', header: 'Name' }],
+            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();
+            const { state } = setup({}, { config });
+            expect(state.fields).toBe(config.fields);
+            // A later change to the config is reflected — values are read on demand,
+            // so a live (getter-backed) config needn't be resolved before the ctor.
+            const updated = [
+                { id: 'name', header: 'Name' },
+                { id: 'year', header: 'Year' },
+            ];
+            config.fields = updated;
+            expect(state.fields).toBe(updated);
+        });
+        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() });
+            expect(off.state.canCreateNewField).toBe(false);
+            // A create callback present ⇒ on.
+            const on = setup({}, { config: schemaConfig({ updateSchema: jest.fn() }) });
+            expect(on.state.canCreateNewField).toBe(true);
+        });
+        it('builds the destination from the config collectionId', async () => {
+            const { state, client } = setup({}, { config: schemaConfig({ collectionId: 'RefCollection' }) });
+            await state.startImport();
+            expect(client.submitImportJob).toHaveBeenCalledWith(expect.objectContaining({
+                destination: { wixDataCollection: { collectionId: 'RefCollection' } },
+            }));
+        });
+        it('creates new fields through the config updateSchema', async () => {
+            const updateSchema = jest.fn(async () => ({
+                name: { id: 'name', displayName: 'Name', type: 'SHORT_TEXT' },
+                year: { id: 'year', displayName: 'Year', type: 'NUMBER' },
+            }));
+            const { state } = setup({}, { config: schemaConfig({ updateSchema }) });
+            runInAction(() => {
+                state.csvHeaders = ['Name', 'Year'];
+                state.csvRows = [['Apple', '1999']];
+                state.mappingByHeader = {
+                    Name: { kind: 'existing', fieldId: 'name' },
+                    Year: { kind: 'new', fieldType: 'number' },
+                };
+            });
+            await state.startImport();
+            expect(updateSchema).toHaveBeenCalledTimes(1);
+        });
+        it('detects the id-mapped column using the config idFieldKey', () => {
+            const { state } = setup({}, { config: schemaConfig({ idFieldKey: 'movieId' }) });
+            runInAction(() => {
+                state.mappingByHeader = {
+                    Ref: { kind: 'existing', fieldId: 'movieId' },
+                };
+            });
+            expect(state.idMappedHeader).toBe('Ref');
+        });
+    });
+});
+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.
+        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