@navette-js/panels 1.0.0-beta.4 → 1.0.0-beta.5

package/lib/import-export.d.ts

@@ -68,6 +68,8 @@ export type ExportActionInstance = Action & {
     columnMapping(condition: boolean): ExportActionInstance;
     /** Files offered for download: `['csv', 'xlsx']` (both by default). */
     formats(formats: ('csv' | 'xlsx')[]): ExportActionInstance;
+    /** Builds the files after the response, in the background; the download links arrive in the bell. */
+    queued(condition?: boolean): ExportActionInstance;
 };
 /** Exports the records of the table (with its filters, search and sort) to a CSV file. */
 export declare class ExportAction {
@@ -130,12 +132,53 @@ export declare abstract class Importer {
 }
 export type ImportActionInstance = Action & {
     importer(importer: typeof Importer): ImportActionInstance;
-    /** Refuses files with more rows (1,000 by default, 10,000 at most). */
+    /** Refuses files with more rows (1,000 by default, 10,000 at most; 100,000 for a queued import). */
     maxRows(count: number): ImportActionInstance;
     /** Largest accepted file, in kilobytes (5,120 by default). */
     maxFileSize(kilobytes: number): ImportActionInstance;
+    /** `false`: no column selection after the upload; file headers are matched to the columns automatically. */
+    columnMapping(condition: boolean): ImportActionInstance;
+    /** Runs after the response, in the background: the user is told it started, then notified in the bell when it ends. */
+    queued(condition?: boolean): ImportActionInstance;
 };
-/** Imports the rows of a CSV file: each row is validated, then creates or updates a record through the data adapter. */
+/** Rows of an uploaded CSV or XLSX file (detected from its content, never its name), up to `limit` rows. */
+export declare function readSpreadsheet(path: string, limit: number): string[][];
+export type BackgroundTask = () => Promise<void>;
+/**
+ * Runs queued imports and exports. By default, one at a time in this process, after the response. Plug your own queue (BullMQ,
+ * a worker…) with a function receiving each task.
+ */
+export declare const useBackgroundRunner: (runner: (task: BackgroundTask) => void) => void;
+export declare const runInBackground: (task: BackgroundTask) => void;
+/** Where runs of imports and exports are recorded (see `knexImportExportHistory()`). */
+export interface ImportExportHistory {
+    startImport(data: {
+        userId: string | number;
+        importer: string;
+        fileName: string;
+        totalRows: number;
+    }): Promise<string | number>;
+    finishImport(id: string | number, data: {
+        processedRows: number;
+        successfulRows: number;
+    }): Promise<void>;
+    recordFailedImportRow(importId: string | number, row: Record<string, unknown>, error: string): Promise<void>;
+    startExport(data: {
+        userId: string | number;
+        exporter: string;
+        fileName: string;
+        totalRows: number;
+    }): Promise<string | number>;
+    finishExport(id: string | number, data: {
+        successfulRows: number;
+    }): Promise<void>;
+}
+type Query = (table: string) => any;
+/** History in `imports`, `exports` and `failed_import_rows` tables (create them with `importExportSchema()`). */
+export declare function knexImportExportHistory(db: Query): ImportExportHistory;
+/** Creates the history tables when missing (call it from a migration). */
+export declare function importExportSchema(knex: any): Promise<void>;
+/** Imports the rows of a CSV or XLSX file: each row is validated, then creates or updates a record through the data adapter. */
 export declare class ImportAction {
     static make(name?: string): ImportActionInstance;
 }

package/lib/import-export.js

@@ -1,9 +1,11 @@
-// Import and export actions: CSV files read and written during the request (no queue), and a per-user download store.
-import { buildXlsx } from "./xlsx.js";
+// Import and export actions: CSV and XLSX files, read and written during the request or in the background (queued()),
+// an optional history of runs, and a per-user download store.
+import { buildXlsx, readXlsx } from "./xlsx.js";
 import { randomBytes } from 'node:crypto';
 import { readFileSync, statSync } from 'node:fs';
 import { Action } from '@navette-js/actions';
-import { CheckboxList, FileUpload } from '@navette-js/forms';
+import { CheckboxList, FileUpload, Select } from '@navette-js/forms';
+import { Fieldset } from '@navette-js/schemas';
 import { configured } from '@navette-js/support';
 import { t, tc } from '@navette-js/support/i18n';
 import { getTableQuery } from '@navette-js/tables';
@@ -128,7 +130,7 @@ export class Exporter {
 const DEFAULT_MAX_EXPORT_ROWS = 10000, HARD_MAX_EXPORT_ROWS = 100000, CHUNK = 1000;
 const fileNameOf = (name) => name.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 120) || 'export';
 function makeExportAction(name, bulk) {
-    let exporter = null, maxRows = DEFAULT_MAX_EXPORT_ROWS, mapping = true, formats = ['csv', 'xlsx'];
+    let exporter = null, maxRows = DEFAULT_MAX_EXPORT_ROWS, mapping = true, formats = ['csv', 'xlsx'], queued = false;
     const columnsOf = () => { if (!exporter)
         throw new Error('ExportAction: call exporter() with an Exporter class.'); return exporter.getColumns(); };
     const action = Action.make(name).color('gray').icon('m-arrow-down-tray')
@@ -160,25 +162,37 @@ function makeExportAction(name, bulk) {
             Notification.make().danger().title(t('filament-actions::export.notifications.max_rows.title')).body(tc('filament-actions::export.notifications.max_rows.body', limit, { count: limit.toLocaleString('en-US') })).send();
             return;
         }
-        const rows = [columns.map((column) => column.getLabel())];
-        for (let page = 1; page <= first.lastPage; page++) {
-            const { records } = page === 1 ? first : await adapter.paginate({ ...query, page, perPage: CHUNK });
-            for (const record of records)
-                rows.push(columns.map((column) => column.getValue(record)));
-        }
-        const count = rows.length - 1;
         const user = livewire._ctx?.user;
         const panel = livewire._ctx?.panel;
-        const fileName = fileNameOf(exporter.getFileName(count));
-        const links = [];
-        if (formats.includes('csv'))
-            links.push({ label: t('filament-actions::export.notifications.completed.actions.download_csv.label'), url: panel.getDownloadUrl(panel.getDownloads().put(user.id, `${fileName}.csv`, 'text/csv; charset=utf-8', `\uFEFF${rows.map(csvLine).join('\r\n')}\r\n`)) });
-        if (formats.includes('xlsx'))
-            links.push({ label: t('filament-actions::export.notifications.completed.actions.download_xlsx.label'), url: panel.getDownloadUrl(panel.getDownloads().put(user.id, `${fileName}.xlsx`, 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', buildXlsx(rows))) });
-        Notification.make().success().persistent().title(t('filament-actions::export.notifications.completed.title')).body(exporter.getCompletedNotificationBody(count))
-            .actions(links).send();
+        const background = queued && canQueue(panel);
+        const history = panel?.getImportExportHistory?.() ?? null;
+        const run = async () => {
+            const exportId = history ? await history.startExport({ userId: user.id, exporter: exporter.name, fileName: fileNameOf(exporter.getFileName(first.total)), totalRows: first.total }) : null;
+            const rows = [columns.map((column) => column.getLabel())];
+            for (let page = 1; page <= first.lastPage; page++) {
+                const { records } = page === 1 ? first : await adapter.paginate({ ...query, page, perPage: CHUNK });
+                for (const record of records)
+                    rows.push(columns.map((column) => column.getValue(record)));
+            }
+            const count = rows.length - 1;
+            const fileName = fileNameOf(exporter.getFileName(count));
+            const links = [];
+            if (formats.includes('csv'))
+                links.push({ label: t('filament-actions::export.notifications.completed.actions.download_csv.label'), url: panel.getDownloadUrl(panel.getDownloads().put(user.id, `${fileName}.csv`, 'text/csv; charset=utf-8', `${rows.map(csvLine).join('\r\n')}\r\n`)) });
+            if (formats.includes('xlsx'))
+                links.push({ label: t('filament-actions::export.notifications.completed.actions.download_xlsx.label'), url: panel.getDownloadUrl(panel.getDownloads().put(user.id, `${fileName}.xlsx`, 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', buildXlsx(rows))) });
+            if (history && exportId !== null)
+                await history.finishExport(exportId, { successfulRows: count });
+            await deliver(Notification.make().success().persistent().title(t('filament-actions::export.notifications.completed.title')).body(exporter.getCompletedNotificationBody(count)).actions(links), background, panel, user);
+        };
         if (bulk)
             livewire.deselectAllTableRecords();
+        if (!background) {
+            await run();
+            return;
+        }
+        Notification.make().success().title(t('filament-actions::export.notifications.started.title')).body(tc('filament-actions::export.notifications.started.body', first.total, { count: first.total.toLocaleString('en-US') })).send();
+        runInBackground(run);
     });
     action.exporter = (value) => { exporter = value; return action; };
     action.maxRows = (count) => { maxRows = Math.max(1, Math.floor(count)); return action; };
@@ -186,6 +200,7 @@ function makeExportAction(name, bulk) {
         throw new Error('ExportAction: formats() needs csv and/or xlsx.'); formats = [...new Set(allowed)]; return action; };
     action.columnMapping = (condition) => { mapping = condition; if (!condition)
         action.requiresConfirmation(); return action; };
+    action.queued = (condition = true) => { queued = condition; return action; };
     return action;
 }
 /** Exports the records of the table (with its filters, search and sort) to a CSV file. */
@@ -281,11 +296,121 @@ export class Importer {
         return `Your import has completed and ${imported.toLocaleString('en-US')} ${imported === 1 ? 'row' : 'rows'} imported.${failed ? ` ${failed.toLocaleString('en-US')} ${failed === 1 ? 'row' : 'rows'} failed to import.` : ''}`;
     }
 }
-const DEFAULT_MAX_IMPORT_ROWS = 1000, HARD_MAX_IMPORT_ROWS = 10000;
-/** Imports the rows of a CSV file: each row is validated, then creates or updates a record through the data adapter. */
+const DEFAULT_MAX_IMPORT_ROWS = 1000, HARD_MAX_IMPORT_ROWS = 10000, HARD_MAX_QUEUED_IMPORT_ROWS = 100000;
+/** Rows of an uploaded CSV or XLSX file (detected from its content, never its name), up to `limit` rows. */
+export function readSpreadsheet(path, limit) {
+    const buffer = readFileSync(path);
+    if (buffer.length >= 4 && buffer.readUInt32LE(0) === 0x04034b50)
+        return readXlsx(buffer, limit);
+    return parseCsv(buffer.toString('utf8').replace(/^/, ''), limit);
+}
+/** Path of the temporary file uploaded in a FileUpload state, if any. */
+function temporaryPathOf(livewire, state) {
+    // A saved entry (`{ file: TemporaryUpload }`), a list of them, or the raw state of the field (upload references).
+    if (state && typeof state === 'object' && typeof state.file?.path === 'string')
+        return state.file.path;
+    const values = Array.isArray(state) ? state : state && typeof state === 'object' ? Object.values(state) : [state];
+    for (const value of values) {
+        const file = (value && typeof value === 'object' && value.file?.path) ? value.file : livewire?._runtime?.uploads?.resolve?.(value);
+        if (typeof file?.path === 'string')
+            return file.path;
+    }
+    return null;
+}
+const headersOf = (livewire, state) => {
+    const path = temporaryPathOf(livewire, state);
+    if (!path)
+        return [];
+    try {
+        return (readSpreadsheet(path, 1)[0] ?? []).map((cell) => cell.trim()).filter((cell, index, all) => cell !== '' && all.indexOf(cell) === index);
+    }
+    catch {
+        return [];
+    }
+};
+const pendingTasks = [];
+let draining = false;
+async function drainTasks() {
+    if (draining)
+        return;
+    draining = true;
+    while (pendingTasks.length) {
+        const task = pendingTasks.shift();
+        try {
+            await task();
+        }
+        catch (error) {
+            console.error('[navette] background task failed:', error);
+        }
+    }
+    draining = false;
+}
+let backgroundRunner = (task) => { pendingTasks.push(task); setImmediate(() => { void drainTasks(); }); };
+/**
+ * Runs queued imports and exports. By default, one at a time in this process, after the response. Plug your own queue (BullMQ,
+ * a worker…) with a function receiving each task.
+ */
+export const useBackgroundRunner = (runner) => { backgroundRunner = runner; };
+export const runInBackground = (task) => backgroundRunner(task);
+const now = () => new Date().toISOString().slice(0, 19).replace('T', ' ');
+/** History in `imports`, `exports` and `failed_import_rows` tables (create them with `importExportSchema()`). */
+export function knexImportExportHistory(db) {
+    const insert = async (table, values) => { const [id] = await db(table).insert(values); return typeof id === 'object' && id !== null ? id.id : id; };
+    return {
+        startImport: (data) => insert('imports', { user_id: data.userId, importer: data.importer, file_name: data.fileName.slice(0, 255), total_rows: data.totalRows, processed_rows: 0, successful_rows: 0, created_at: now(), updated_at: now() }),
+        async finishImport(id, data) { await db('imports').where('id', id).update({ processed_rows: data.processedRows, successful_rows: data.successfulRows, completed_at: now(), updated_at: now() }); },
+        async recordFailedImportRow(importId, row, error) { await db('failed_import_rows').insert({ import_id: importId, data: JSON.stringify(row), validation_error: error.slice(0, 1000), created_at: now(), updated_at: now() }); },
+        startExport: (data) => insert('exports', { user_id: data.userId, exporter: data.exporter, file_name: data.fileName.slice(0, 255), total_rows: data.totalRows, successful_rows: 0, created_at: now(), updated_at: now() }),
+        async finishExport(id, data) { await db('exports').where('id', id).update({ successful_rows: data.successfulRows, completed_at: now(), updated_at: now() }); },
+    };
+}
+/** Creates the history tables when missing (call it from a migration). */
+export async function importExportSchema(knex) {
+    if (!(await knex.schema.hasTable('imports')))
+        await knex.schema.createTable('imports', (table) => {
+            table.increments('id');
+            table.integer('user_id').index();
+            table.string('importer');
+            table.string('file_name');
+            table.integer('total_rows');
+            table.integer('processed_rows').defaultTo(0);
+            table.integer('successful_rows').defaultTo(0);
+            table.timestamp('completed_at').nullable();
+            table.timestamps();
+        });
+    if (!(await knex.schema.hasTable('failed_import_rows')))
+        await knex.schema.createTable('failed_import_rows', (table) => {
+            table.increments('id');
+            table.integer('import_id').index();
+            table.text('data');
+            table.text('validation_error').nullable();
+            table.timestamps();
+        });
+    if (!(await knex.schema.hasTable('exports')))
+        await knex.schema.createTable('exports', (table) => {
+            table.increments('id');
+            table.integer('user_id').index();
+            table.string('exporter');
+            table.string('file_name');
+            table.integer('total_rows');
+            table.integer('successful_rows').defaultTo(0);
+            table.timestamp('completed_at').nullable();
+            table.timestamps();
+        });
+}
+/** Sends a notification now (in the request) or, for background work, to the user's database notifications. */
+async function deliver(notification, background, panel, user) {
+    if (background)
+        await notification.sendToDatabase(panel.getDatabaseNotifications?.() ?? null, user.id);
+    else
+        notification.send();
+}
+/** Background work needs database notifications to tell the user it ended; without them, it runs in the request. */
+const canQueue = (panel) => Boolean(panel?.getDatabaseNotifications?.());
+/** Imports the rows of a CSV or XLSX file: each row is validated, then creates or updates a record through the data adapter. */
 export class ImportAction {
     static make(name = 'import') {
-        let importer = null, maxRows = DEFAULT_MAX_IMPORT_ROWS, maxKilobytes = 5120;
+        let importer = null, maxRows = DEFAULT_MAX_IMPORT_ROWS, maxKilobytes = 5120, mapping = true, queued = false;
         const columnsOf = () => { if (!importer)
             throw new Error('ImportAction: call importer() with an Importer class.'); return importer.getColumns(); };
         const example = Action.make('downloadExample').label(t('filament-actions::import.modal.actions.download_example.label')).color('gray').link()
@@ -302,69 +427,117 @@ export class ImportAction {
             .modalHeading(({ livewire }) => t('filament-actions::import.modal.heading', { label: livewire?.resource?.getPluralModelLabel?.() ?? '' }).trim())
             .modalSubmitActionLabel(t('filament-actions::import.modal.actions.import.label'))
             .modalWidth('md')
-            .schema(() => [FileUpload.make('file').label(t('filament-actions::import.modal.form.file.label')).acceptedFileTypes(['text/csv', 'text/plain', 'application/vnd.ms-excel', '.csv']).maxSize(maxKilobytes).storeFiles(false).required()])
+            .schema((schema) => {
+            const livewire = schema.livewire;
+            const columns = columnsOf();
+            // The columns of the uploaded file, to map them to the importer's columns.
+            const mounted = livewire?.mountedActions?.find?.((candidate) => candidate.name === name);
+            const headers = mapping ? headersOf(livewire, mounted?.data?.file) : [];
+            const file = FileUpload.make('file').label(t('filament-actions::import.modal.form.file.label')).placeholder(t('filament-actions::import.modal.form.file.placeholder'))
+                .acceptedFileTypes(['text/csv', 'text/plain', 'application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', '.csv', '.xlsx']).maxSize(maxKilobytes).storeFiles(false).required();
+            if (mapping)
+                file.live().afterStateUpdated(({ state, set }) => {
+                    const found = headersOf(livewire, state);
+                    set('columnMap', Object.fromEntries(columns.map((column) => [column.name, found.find((header) => column.matches(header)) ?? null])));
+                });
+            return schema.components([
+                file,
+                ...(mapping && headers.length ? [Fieldset.make(t('filament-actions::import.modal.form.columns.label')).statePath('columnMap').columns(1).schema(columns.map((column) => Select.make(column.name).label(column.getLabel()).placeholder(t('filament-actions::import.modal.form.columns.placeholder')).options(headers.map((header) => [header, header])).required(column.isMappingRequired())))] : []),
+            ]);
+        })
             .extraModalFooterActions([example])
             .action(async ({ livewire, data }) => {
-            const entry = Array.isArray(data.file) ? data.file[0] : data.file;
-            const path = entry?.file?.path;
+            const path = temporaryPathOf(livewire, data.file);
             // Only a temporary upload of this request is read, never a path sent by the browser.
             if (typeof path !== 'string' || statSync(path).size > maxKilobytes * 1024)
                 return;
-            const limit = Math.min(maxRows, HARD_MAX_IMPORT_ROWS);
-            const rows = parseCsv(readFileSync(path, 'utf8'), limit + 1);
-            const header = rows.shift() ?? [];
+            const panel = livewire._ctx?.panel, user = livewire._ctx?.user;
+            const background = queued && canQueue(panel);
+            const limit = Math.min(maxRows, background ? HARD_MAX_QUEUED_IMPORT_ROWS : HARD_MAX_IMPORT_ROWS);
+            let rows;
+            try {
+                rows = readSpreadsheet(path, limit + 1);
+            }
+            catch {
+                Notification.make().danger().title(t('filament-actions::import.notifications.completed.title')).body('The file could not be read: upload a CSV or XLSX file.').send();
+                return;
+            }
+            const header = (rows.shift() ?? []).map((cell) => cell.trim());
             if (rows.length > limit) {
                 Notification.make().danger().title(t('filament-actions::import.notifications.max_rows.title')).body(tc('filament-actions::import.notifications.max_rows.body', limit, { count: limit.toLocaleString('en-US') })).send();
                 return;
             }
             const columns = columnsOf();
-            const mapping = new Map(columns.map((column) => [column, header.findIndex((cell) => column.matches(cell))]));
-            const missing = columns.filter((column) => column.isMappingRequired() && mapping.get(column) === -1);
+            // Chosen columns (only headers of the file are accepted), else automatic matching.
+            const chosen = (data.columnMap && typeof data.columnMap === 'object' ? data.columnMap : {});
+            const indexOf = (column) => {
+                if (mapping && Object.hasOwn(chosen, column.name))
+                    return typeof chosen[column.name] === 'string' ? header.indexOf(chosen[column.name]) : -1;
+                return header.findIndex((cell) => column.matches(cell));
+            };
+            const columnIndexes = new Map(columns.map((column) => [column, indexOf(column)]));
+            const missing = columns.filter((column) => column.isMappingRequired() && columnIndexes.get(column) === -1);
             if (missing.length) {
                 Notification.make().danger().title(t('filament-actions::import.notifications.completed.title'))
                     .body(missing.map((column) => t('filament-actions::import.failure_csv.column_mapping_required_for_new_record', { attribute: column.getLabel() })).join(' ')).send();
                 return;
             }
             const adapter = livewire.getDataAdapterForTable();
-            let imported = 0;
-            const failures = [];
-            for (const cells of rows) {
-                const raw = {};
-                for (const [column, index] of mapping)
-                    raw[column.name] = index === -1 ? null : (cells[index] ?? null);
-                const error = columns.map((column) => (mapping.get(column) === -1 ? null : column.validate(raw[column.name], raw))).find((message) => message !== null);
-                if (error) {
-                    failures.push(csvLine([...cells, error]));
-                    continue;
+            const history = panel?.getImportExportHistory?.() ?? null;
+            const fileName = String(Object.values(data.file ?? {})[0]?.file?.name ?? Object.values(data.file ?? {})[0]?.name ?? 'import');
+            const run = async () => {
+                const importId = history ? await history.startImport({ userId: user.id, importer: importer.name, fileName, totalRows: rows.length }) : null;
+                let imported = 0;
+                const failures = [];
+                for (const cells of rows) {
+                    const raw = {};
+                    for (const [column, index] of columnIndexes)
+                        raw[column.name] = index === -1 ? null : (cells[index] ?? null);
+                    const fail = async (message) => { failures.push(csvLine([...cells, message])); if (history && importId !== null)
+                        await history.recordFailedImportRow(importId, raw, message); };
+                    const error = columns.map((column) => (columnIndexes.get(column) === -1 ? null : column.validate(raw[column.name], raw))).find((message) => message !== null);
+                    if (error) {
+                        await fail(error);
+                        continue;
+                    }
+                    try {
+                        const record = await importer.resolveRecord(raw, { livewire });
+                        const values = {};
+                        for (const column of columns)
+                            if (columnIndexes.get(column) !== -1)
+                                column.fill(values, column.cast(raw[column.name]));
+                        await importer.beforeSave(values, record);
+                        const saved = record ? await adapter.update(adapter.getKey(record), values) : await adapter.create(values);
+                        await importer.afterSave(saved);
+                        imported++;
+                    }
+                    catch (failure) {
+                        console.error(failure);
+                        await fail(t('filament-actions::import.failure_csv.system_error'));
+                    }
                 }
-                try {
-                    const record = await importer.resolveRecord(raw, { livewire });
-                    const values = {};
-                    for (const column of columns)
-                        if (mapping.get(column) !== -1)
-                            column.fill(values, column.cast(raw[column.name]));
-                    await importer.beforeSave(values, record);
-                    const saved = record ? await adapter.update(adapter.getKey(record), values) : await adapter.create(values);
-                    await importer.afterSave(saved);
-                    imported++;
+                if (history && importId !== null)
+                    await history.finishImport(importId, { processedRows: rows.length, successfulRows: imported });
+                const notification = Notification.make().title(t('filament-actions::import.notifications.completed.title')).body(importer.getCompletedNotificationBody(imported, failures.length)).persistent();
+                if (failures.length) {
+                    const csv = `${[csvLine([...header, t('filament-actions::import.failure_csv.error_header')]), ...failures].join('\r\n')}\r\n`;
+                    const token = panel.getDownloads().put(user.id, 'import-failed-rows.csv', 'text/csv; charset=utf-8', csv);
+                    notification.actions([{ label: tc('filament-actions::import.notifications.completed.actions.download_failed_rows_csv.label', failures.length), url: panel.getDownloadUrl(token) }]);
                 }
-                catch (failure) {
-                    console.error(failure);
-                    failures.push(csvLine([...cells, t('filament-actions::import.failure_csv.system_error')]));
-                }
-            }
-            const notification = Notification.make().title(t('filament-actions::import.notifications.completed.title')).body(importer.getCompletedNotificationBody(imported, failures.length)).persistent();
-            if (failures.length) {
-                const panel = livewire._ctx?.panel;
-                const csv = `${[csvLine([...header, t('filament-actions::import.failure_csv.error_header')]), ...failures].join('\r\n')}\r\n`;
-                const token = panel.getDownloads().put(livewire._ctx.user.id, 'import-failed-rows.csv', 'text/csv; charset=utf-8', csv);
-                notification.actions([{ label: tc('filament-actions::import.notifications.completed.actions.download_failed_rows_csv.label', failures.length), url: panel.getDownloadUrl(token) }]);
+                await deliver(imported ? (failures.length ? notification.warning() : notification.success()) : notification.danger(), background, panel, user);
+            };
+            if (!background) {
+                await run();
+                return;
             }
-            (imported ? (failures.length ? notification.warning() : notification.success()) : notification.danger()).send();
+            Notification.make().success().title(t('filament-actions::import.notifications.started.title')).body(tc('filament-actions::import.notifications.started.body', rows.length, { count: rows.length.toLocaleString('en-US') })).send();
+            runInBackground(run);
         });
         action.importer = (value) => { importer = value; return action; };
         action.maxRows = (count) => { maxRows = Math.max(1, Math.floor(count)); return action; };
         action.maxFileSize = (kilobytes) => { maxKilobytes = Math.max(1, Math.floor(kilobytes)); return action; };
+        action.columnMapping = (condition) => { mapping = condition; return action; };
+        action.queued = (condition = true) => { queued = condition; return action; };
         return action;
     }
 }