sfmc-dataloader 2.6.1 → 2.7.0

package/lib/async-status.mjs

@@ -1,4 +1,5 @@
 import { asyncRequestResultsPath, asyncRequestStatusPath } from './import-routes.mjs';
+import { log } from './log.mjs';
 
 const POLL_INTERVAL_MS = 5000;
 const PENDING_STATUSES = new Set(['Pending', 'Executing']);
@@ -25,11 +26,11 @@ export async function pollAsyncImportCompletion(sdk, requestIds) {
 
     for (const requestId of requestIds) {
         if (!requestId) {
-            console.error('Async import: no requestId returned for chunk — skipping status check.');
+            log.error('Async import: no requestId returned for chunk — skipping status check.');
             continue;
         }
 
-        console.error(`Waiting for async import to complete (requestId: ${requestId})…`);
+        log.info(`Waiting for async import to complete (requestId: ${requestId})…`);
         await sleep(POLL_INTERVAL_MS);
 
         let requestStatus;
@@ -38,7 +39,7 @@ export async function pollAsyncImportCompletion(sdk, requestIds) {
             try {
                 statusResult = await sdk.rest.get(asyncRequestStatusPath(requestId));
             } catch (ex) {
-                console.error(
+                log.error(
                     `Async import: status check failed for requestId ${requestId}: ${ex.message}`,
                 );
                 break;
@@ -47,7 +48,7 @@ export async function pollAsyncImportCompletion(sdk, requestIds) {
             requestStatus = statusResult?.status?.requestStatus;
 
             if (PENDING_STATUSES.has(requestStatus)) {
-                console.error(
+                log.info(
                     `Async import still in progress (requestId: ${requestId}) — retrying in 5 s…`,
                 );
                 await sleep(POLL_INTERVAL_MS);
@@ -55,16 +56,16 @@ export async function pollAsyncImportCompletion(sdk, requestIds) {
         } while (PENDING_STATUSES.has(requestStatus));
 
         if (requestStatus === 'Complete') {
-            console.error(`Async import completed successfully (requestId: ${requestId}).`);
+            log.info(`Async import completed successfully (requestId: ${requestId}).`);
         } else if (requestStatus === 'Error') {
-            console.error(`Async import job failed (requestId: ${requestId}).`);
+            log.error(`Async import job failed (requestId: ${requestId}).`);
             hasError = true;
 
             let resultsResult;
             try {
                 resultsResult = await sdk.rest.get(asyncRequestResultsPath(requestId));
             } catch (ex) {
-                console.error(
+                log.error(
                     `Async import: could not retrieve error details for requestId ${requestId}: ${ex.message}`,
                 );
                 continue;
@@ -72,14 +73,14 @@ export async function pollAsyncImportCompletion(sdk, requestIds) {
 
             const items = resultsResult?.items ?? [];
             if (items.length === 0) {
-                console.error('Async import: no item-level error details returned by API.');
+                log.warn('Async import: no item-level error details returned by API.');
             } else {
                 for (const item of items) {
-                    console.error(`Import error: ${item.message}`);
+                    log.error(`Import error: ${item.message}`);
                 }
             }
         } else if (requestStatus !== undefined) {
-            console.error(
+            log.error(
                 `Async import: unexpected status "${requestStatus}" for requestId ${requestId}.`,
             );
         }

package/lib/batch.mjs

@@ -1,8 +1,8 @@
 /** Default max UTF-8 bytes per request body (Data API family; margin below 5.9 MB). */
 export const DEFAULT_MAX_BODY_BYTES = 5_500_000;
 
-/** Salesforce hard cap on objects per batch. */
-export const MAX_OBJECTS_PER_BATCH = 5_000;
+/** Max rows per HTTP payload chunk (byte cap in `DEFAULT_MAX_BODY_BYTES` may split further). */
+export const MAX_OBJECTS_PER_BATCH = 2_500;
 
 /**
  * Split rows into chunks that respect both max row count and serialized JSON body size.

package/lib/cli.mjs

@@ -13,9 +13,14 @@ import {
 } from './config.mjs';
 import { dataDirectoryForBu } from './paths.mjs';
 import { exportDataExtensionToFile } from './export-de.mjs';
-import { findImportCandidates, pickLatestByMtime } from './file-resolve.mjs';
+import { findImportCandidates, formatFromExtension, resolveImportSet } from './file-resolve.mjs';
 import { parseExportBasename } from './filename.mjs';
-import { importFromFile } from './import-de.mjs';
+import { MAX_OBJECTS_PER_BATCH } from './batch.mjs';
+import {
+    assertNonEmptyImportRowCount,
+    importRowsStreamingForDe,
+    warnIfImportCountUnexpected,
+} from './import-de.mjs';
 import { pollAsyncImportCompletion } from './async-status.mjs';
 import { clearDataExtensionRows } from './clear-de.mjs';
 import { confirmClearBeforeImport } from './confirm-clear.mjs';
@@ -24,6 +29,24 @@ import { multiBuExport } from './multi-bu-export.mjs';
 import { crossBuImport } from './cross-bu-import.mjs';
 import { initDebugLogger } from './debug-logger.mjs';
 import { runMcdataInit } from './init-project.mjs';
+import { countDataRowsFromImportPaths, streamRowsFromImportPaths } from './read-rows.mjs';
+import { log, setDebugLogger, formatTime } from './log.mjs';
+
+/**
+ * @param {string|undefined} raw
+ * @param {string} flagName
+ * @returns {number|undefined}
+ */
+function parseOptionalPositiveInt(raw, flagName) {
+    if (raw === undefined || raw === '') {
+        return;
+    }
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 1) {
+        throw new Error(`Invalid ${flagName}: ${raw} (expect positive integer)`);
+    }
+    return Math.floor(n);
+}
 
 /** @returns {string} semver from this package's package.json */
 function readCliPackageVersion() {
@@ -53,6 +76,7 @@ Options:
   --format <csv|tsv|json> Export file format (default: csv); ignored for imports
   --json-pretty           Pretty-print JSON on export
   --git                   Stable filenames: <key>.mcdata.<ext> (no timestamp)
+  --max-rows-per-file <n> Split exports into multiple files after N data rows (optional)
   --debug                 Write API requests/responses to ./logs/data/*.log
 
 Init options:
@@ -82,7 +106,7 @@ Config files:
 
 Notes:
   Exports are written under ./data/<credential>/<bu>/ using ".mcdata." in the filename.
-  Import with --de resolves the latest matching file (csv/tsv/json) in that folder (by mtime).
+  Import with --de resolves the latest matching export (csv/tsv/json), including multi-part partN files.
   Import with --file parses the DE key from the basename (.mcdata. format).
   Import format is auto-detected from file extension (.csv, .tsv, .json).
   Cross-BU import stores a download file in each target BU's data directory.
@@ -128,12 +152,13 @@ export async function main(argv) {
                 'auth-url': { type: 'string' },
                 'enterprise-id': { type: 'string' },
                 yes: { type: 'boolean', short: 'y', default: false },
+                'max-rows-per-file': { type: 'string' },
             },
         });
         values = parsed.values;
         positionals = parsed.positionals;
     } catch (ex) {
-        console.error(ex.message);
+        log.error(ex.message);
         printHelp();
         return 1;
     }
@@ -172,7 +197,7 @@ export async function main(argv) {
 
     const fmt = values.format ?? 'csv';
     if (!['csv', 'tsv', 'json'].includes(fmt)) {
-        console.error(`Invalid --format: ${fmt}`);
+        log.error(`Invalid --format: ${fmt}`);
         return 1;
     }
 
@@ -195,31 +220,33 @@ export async function main(argv) {
         ? initDebugLogger(projectRoot, readCliPackageVersion(), argv)
         : null;
     if (logger) {
-        console.error(`Debug log: "${path.resolve(logger.logPath)}"`);
+        setDebugLogger(logger);
+        // Written directly to stdout — must not appear inside the file it announces
+        console.log(`${formatTime()} info: Debug log: "${path.resolve(logger.logPath)}"`);
     }
 
     // ── export ──────────────────────────────────────────────────────────────
     if (sub === 'export') {
         if (hasTo) {
-            console.error('--to is not valid for export. Did you mean import?');
+            log.error('--to is not valid for export. Did you mean import?');
             return 1;
         }
 
         const des = [values.de ?? []].flat();
         if (des.length === 0) {
-            console.error('export requires at least one --de <customerKey>');
+            log.error('export requires at least one --de <customerKey>');
             return 1;
         }
 
         if (hasFrom && hasPositional) {
-            console.error(
+            log.error(
                 'Cannot mix a positional <credential>/<bu> with --from. Use one or the other.',
             );
             return 1;
         }
 
         if (!hasFrom && !hasPositional) {
-            console.error(
+            log.error(
                 'export requires either a positional <credential>/<bu> or at least one --from <cred>/<bu>.',
             );
             printHelp();
@@ -231,10 +258,20 @@ export async function main(argv) {
             try {
                 sources = fromFlags.map(parseCredBu);
             } catch (ex) {
-                console.error(ex.message);
+                log.error(ex.message);
                 return 1;
             }
             const { mcdevrc, mcdevAuth } = loadProjectConfig(projectRoot);
+            let maxRowsPerFile;
+            try {
+                maxRowsPerFile = parseOptionalPositiveInt(
+                    values['max-rows-per-file'],
+                    '--max-rows-per-file',
+                );
+            } catch (ex) {
+                log.error(ex.message);
+                return 1;
+            }
             await multiBuExport({
                 projectRoot,
                 mcdevrc,
@@ -244,17 +281,29 @@ export async function main(argv) {
                 format: /** @type {'csv'|'tsv'|'json'} */ (fmt),
                 jsonPretty: values['json-pretty'],
                 useGit,
+                maxRowsPerFile,
                 logger,
             });
             return 0;
         }
 
+        let maxRowsPerFile;
+        try {
+            maxRowsPerFile = parseOptionalPositiveInt(
+                values['max-rows-per-file'],
+                '--max-rows-per-file',
+            );
+        } catch (ex) {
+            log.error(ex.message);
+            return 1;
+        }
+
         const { credential, bu } = parseCredBu(credBuRaw);
         const { mcdevrc, mcdevAuth } = loadProjectConfig(projectRoot);
         const { mid, authCred } = resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
         const sdk = new SDK(buildSdkAuthObject(authCred, mid), buildSdkOptions(logger));
         for (const deKey of des) {
-            const { path: out, rowCount } = await exportDataExtensionToFile(sdk, {
+            const { paths: outPaths, rowCount } = await exportDataExtensionToFile(sdk, {
                 projectRoot,
                 credentialName: credential,
                 buName: bu,
@@ -262,8 +311,10 @@ export async function main(argv) {
                 format: /** @type {'csv'|'tsv'|'json'} */ (fmt),
                 jsonPretty: values['json-pretty'],
                 useGit,
+                maxRowsPerFile,
             });
-            console.error(`Exported: "${path.resolve(out)}" (${rowCount} rows)`);
+            const label = outPaths.map((p) => `"${path.resolve(p)}"`).join(', ');
+            log.info(`Exported: ${label} (${rowCount} rows)`);
         }
         return 0;
     }
@@ -272,7 +323,7 @@ export async function main(argv) {
     if (sub === 'import') {
         const mode = values.mode ?? 'upsert';
         if (!['upsert', 'insert'].includes(mode)) {
-            console.error(`Invalid --mode: ${mode} (use upsert or insert)`);
+            log.error(`Invalid --mode: ${mode} (use upsert or insert)`);
             return 1;
         }
 
@@ -282,15 +333,13 @@ export async function main(argv) {
         // ── File-to-multi-BU import: --to + --file (no --from) ─────────────
         if (hasTo && !hasFrom && values.file?.length > 0) {
             if (hasPositional) {
-                console.error(
+                log.error(
                     'Cannot mix a positional <credential>/<bu> with --to/--file. Use one or the other.',
                 );
                 return 1;
             }
             if (values.de?.length > 0) {
-                console.error(
-                    'Cannot mix --de with --file in multi-target import. Use --file only.',
-                );
+                log.error('Cannot mix --de with --file in multi-target import. Use --file only.');
                 return 1;
             }
             const filePaths = values.file;
@@ -298,7 +347,7 @@ export async function main(argv) {
             try {
                 targets = toFlags.map(parseCredBu);
             } catch (ex) {
-                console.error(ex.message);
+                log.error(ex.message);
                 return 1;
             }
             const { mcdevrc, mcdevAuth } = loadProjectConfig(projectRoot);
@@ -323,38 +372,36 @@ export async function main(argv) {
         // ── Cross-BU import (API mode): --from + --to + --de ────────────────
         if (hasFrom || hasTo) {
             if (hasPositional) {
-                console.error(
+                log.error(
                     'Cannot mix a positional <credential>/<bu> with --from/--to. Use one or the other.',
                 );
                 return 1;
             }
             if (!hasFrom) {
-                console.error(
-                    '--to requires --from <cred>/<bu> to specify the source Business Unit.',
-                );
+                log.error('--to requires --from <cred>/<bu> to specify the source Business Unit.');
                 return 1;
             }
             if (!hasTo) {
-                console.error(
+                log.error(
                     '--from requires at least one --to <cred>/<bu> to specify target Business Unit(s).',
                 );
                 return 1;
             }
             if (fromFlags.length > 1) {
-                console.error(
+                log.error(
                     'import accepts exactly one --from <cred>/<bu> (use multiple --to for multiple targets).',
                 );
                 return 1;
             }
             if (values.file?.length > 0) {
-                console.error(
+                log.error(
                     '--file cannot be combined with --from/--to/--de. For file-based multi-target import use --to + --file (without --from).',
                 );
                 return 1;
             }
             const deKeys = [values.de ?? []].flat();
             if (deKeys.length === 0) {
-                console.error('Cross-BU import requires at least one --de <customerKey>.');
+                log.error('Cross-BU import requires at least one --de <customerKey>.');
                 return 1;
             }
             let sourceParsed;
@@ -363,7 +410,7 @@ export async function main(argv) {
                 sourceParsed = parseCredBu(fromFlags[0]);
                 targets = toFlags.map(parseCredBu);
             } catch (ex) {
-                console.error(ex.message);
+                log.error(ex.message);
                 return 1;
             }
             const { mcdevrc, mcdevAuth } = loadProjectConfig(projectRoot);
@@ -389,7 +436,7 @@ export async function main(argv) {
 
         // ── Single-BU import (original behavior) ────────────────────────────
         if (!hasPositional) {
-            console.error(
+            log.error(
                 'import requires either a positional <credential>/<bu> or --from/--to flags.',
             );
             printHelp();
@@ -399,7 +446,7 @@ export async function main(argv) {
         const hasDe = values.de?.length > 0;
         const hasFile = values.file?.length > 0;
         if (hasDe === hasFile) {
-            console.error(
+            log.error(
                 'import requires exactly one of: repeated --de <key> OR repeated --file <path>',
             );
             return 1;
@@ -415,7 +462,7 @@ export async function main(argv) {
             const dataDir = dataDirectoryForBu(projectRoot, credential, bu);
             if (backupBeforeImport === true) {
                 for (const deKey of deKeys) {
-                    const { path: outPath, rowCount } = await exportDataExtensionToFile(sdk, {
+                    const { paths: outPaths, rowCount } = await exportDataExtensionToFile(sdk, {
                         projectRoot,
                         credentialName: credential,
                         buName: bu,
@@ -423,7 +470,8 @@ export async function main(argv) {
                         format: /** @type {'csv'|'tsv'|'json'} */ (fmt),
                         useGit: false,
                     });
-                    console.error(`Backup export: "${path.resolve(outPath)}" (${rowCount} rows)`);
+                    const label = outPaths.map((p) => `"${path.resolve(p)}"`).join(', ');
+                    log.info(`Backup export: ${label} (${rowCount} rows)`);
                 }
             }
             if (clear) {
@@ -436,37 +484,49 @@ export async function main(argv) {
             let anyError = false;
             for (const deKey of deKeys) {
                 const candidates = await findImportCandidates(dataDir, deKey);
-                if (candidates.length === 0) {
-                    console.error(
+                const { paths: importPaths } = await resolveImportSet(candidates);
+                if (importPaths.length === 0) {
+                    log.error(
                         `No import file (csv/tsv/json) found for DE "${deKey}" under "${path.resolve(dataDir)}"`,
                     );
                     return 1;
                 }
-                const filePath =
-                    candidates.length === 1 ? candidates[0] : await pickLatestByMtime(candidates);
+                const detectedFormat = formatFromExtension(importPaths[0]);
+                if (!detectedFormat) {
+                    log.error(
+                        `Cannot determine format for "${importPaths[0]}". Use .csv, .tsv, or .json.`,
+                    );
+                    return 1;
+                }
 
                 const countBefore = await getDeRowCount(sdk, deKey);
-                console.error(
+                log.info(
                     `Row count before import: ${countBefore ?? '(unavailable)'} (DE "${deKey}")`,
                 );
 
+                let clearedSingleDe = false;
                 if (clear) {
                     if (countBefore === 0) {
-                        console.error(
-                            `Skipping clear-data for DE "${deKey}" — DE is already empty.`,
-                        );
+                        log.info(`Skipping clear-data for DE "${deKey}" — DE is already empty.`);
                     } else {
                         await clearDataExtensionRows(sdk.soap, deKey);
-                        console.warn(`Cleared data: DE "${deKey}"`);
+                        clearedSingleDe = true;
+                        log.warn(`Cleared data: DE "${deKey}"`);
                     }
                 }
 
-                const { count: n, requestIds } = await importFromFile(sdk, {
-                    filePath,
+                const rowCount = await countDataRowsFromImportPaths(importPaths, detectedFormat);
+                assertNonEmptyImportRowCount(rowCount, importPaths.join(', '));
+                const totalMemoryBatches = Math.max(1, Math.ceil(rowCount / MAX_OBJECTS_PER_BATCH));
+                const rowSource = streamRowsFromImportPaths(importPaths, detectedFormat);
+                const { count: n, requestIds } = await importRowsStreamingForDe(sdk, {
                     deKey,
+                    rowSource,
                     mode: /** @type {'upsert'|'insert'} */ (mode),
+                    totalMemoryBatches,
                 });
-                console.error(`Imported: "${path.resolve(filePath)}" (${n} rows) -> DE ${deKey}`);
+                const srcLabel = importPaths.map((p) => `"${path.resolve(p)}"`).join(', ');
+                log.info(`Imported: ${srcLabel} (${n} rows) -> DE ${deKey}`);
 
                 const importHadError = await pollAsyncImportCompletion(sdk, requestIds);
                 if (importHadError) {
@@ -474,32 +534,35 @@ export async function main(argv) {
                 }
 
                 const countAfter = await getDeRowCount(sdk, deKey);
-                console.error(
+                log.info(
                     `Row count after import: ${countAfter ?? '(unavailable)'} (DE "${deKey}")`,
                 );
-                if (countAfter === null) {
-                    console.error(`Could not verify import result for DE "${deKey}".`);
-                } else if (countBefore !== null) {
-                    // Insert: expect countBefore + n; upsert on empty: same; upsert on non-empty: expect >= n
-                    const expected =
-                        mode === 'insert' || countBefore === 0 ? (countBefore ?? 0) + n : n;
-                    if (countAfter < expected) {
-                        console.error(
-                            `Import result for DE "${deKey}" looks unexpected: expected at least ${expected} rows, got ${countAfter}.`,
-                        );
-                    }
-                }
+                warnIfImportCountUnexpected({
+                    countBefore,
+                    cleared: clearedSingleDe,
+                    countAfter,
+                    imported: n,
+                    mode: /** @type {'upsert'|'insert'} */ (mode),
+                    label: `DE "${deKey}"`,
+                });
             }
             return anyError ? 1 : 0;
         }
 
         const fileList = values.file ?? [];
-        const keysFromFiles = fileList.map(
-            (fp) => parseExportBasename(path.basename(fp)).customerKey,
-        );
+        /** @type {string[]} */
+        const keysFromFiles = [];
+        const seenKeys = new Set();
+        for (const fp of fileList) {
+            const k = parseExportBasename(path.basename(fp)).customerKey;
+            if (!seenKeys.has(k)) {
+                seenKeys.add(k);
+                keysFromFiles.push(k);
+            }
+        }
         if (backupBeforeImport === true) {
             for (const deKey of keysFromFiles) {
-                const { path: outPath, rowCount } = await exportDataExtensionToFile(sdk, {
+                const { paths: outPaths, rowCount } = await exportDataExtensionToFile(sdk, {
                     projectRoot,
                     credentialName: credential,
                     buName: bu,
@@ -507,7 +570,8 @@ export async function main(argv) {
                     format: /** @type {'csv'|'tsv'|'json'} */ (fmt),
                     useGit: false,
                 });
-                console.error(`Backup export: "${path.resolve(outPath)}" (${rowCount} rows)`);
+                const label = outPaths.map((p) => `"${path.resolve(p)}"`).join(', ');
+                log.info(`Backup export: ${label} (${rowCount} rows)`);
             }
         }
         if (clear) {
@@ -517,33 +581,64 @@ export async function main(argv) {
                 isTTY: process.stdin.isTTY === true,
             });
         }
+        /** @type {Map<string, string[]>} */
+        const pathsByDeKey = new Map();
+        for (const fp of fileList) {
+            const { customerKey } = parseExportBasename(path.basename(fp));
+            const list = pathsByDeKey.get(customerKey);
+            if (list) {
+                list.push(fp);
+            } else {
+                pathsByDeKey.set(customerKey, [fp]);
+            }
+        }
+
         let anyFileError = false;
-        for (const filePath of fileList) {
-            const base = path.basename(filePath);
-            const { customerKey } = parseExportBasename(base);
+        for (const customerKey of keysFromFiles) {
+            const groupPaths = pathsByDeKey.get(customerKey) ?? [];
+            const { paths: importPaths } = await resolveImportSet(groupPaths);
+            if (importPaths.length === 0) {
+                log.error(`No resolvable import files for DE "${customerKey}".`);
+                anyFileError = true;
+                continue;
+            }
+            const detectedFormat = formatFromExtension(importPaths[0]);
+            if (!detectedFormat) {
+                log.error(
+                    `Cannot determine format for "${importPaths[0]}". Use .csv, .tsv, or .json.`,
+                );
+                anyFileError = true;
+                continue;
+            }
 
             const countBefore = await getDeRowCount(sdk, customerKey);
-            console.error(
+            log.info(
                 `Row count before import: ${countBefore ?? '(unavailable)'} (DE "${customerKey}")`,
             );
 
+            let clearedMultiFileDe = false;
             if (clear) {
                 if (countBefore === 0) {
-                    console.error(
-                        `Skipping clear-data for DE "${customerKey}" — DE is already empty.`,
-                    );
+                    log.info(`Skipping clear-data for DE "${customerKey}" — DE is already empty.`);
                 } else {
                     await clearDataExtensionRows(sdk.soap, customerKey);
-                    console.warn(`Cleared data: DE "${customerKey}"`);
+                    clearedMultiFileDe = true;
+                    log.warn(`Cleared data: DE "${customerKey}"`);
                 }
             }
 
-            const { count: n, requestIds } = await importFromFile(sdk, {
-                filePath,
+            const rowCount = await countDataRowsFromImportPaths(importPaths, detectedFormat);
+            assertNonEmptyImportRowCount(rowCount, importPaths.join(', '));
+            const totalMemoryBatches = Math.max(1, Math.ceil(rowCount / MAX_OBJECTS_PER_BATCH));
+            const rowSource = streamRowsFromImportPaths(importPaths, detectedFormat);
+            const { count: n, requestIds } = await importRowsStreamingForDe(sdk, {
                 deKey: customerKey,
+                rowSource,
                 mode: /** @type {'upsert'|'insert'} */ (mode),
+                totalMemoryBatches,
             });
-            console.error(`Imported: "${path.resolve(filePath)}" (${n} rows)`);
+            const srcLabel = importPaths.map((p) => `"${path.resolve(p)}"`).join(', ');
+            log.info(`Imported: ${srcLabel} (${n} rows)`);
 
             const importHadError = await pollAsyncImportCompletion(sdk, requestIds);
             if (importHadError) {
@@ -551,25 +646,22 @@ export async function main(argv) {
             }
 
             const countAfter = await getDeRowCount(sdk, customerKey);
-            console.error(
+            log.info(
                 `Row count after import: ${countAfter ?? '(unavailable)'} (DE "${customerKey}")`,
             );
-            if (countAfter === null) {
-                console.error(`Could not verify import result for DE "${customerKey}".`);
-            } else {
-                const expected =
-                    mode === 'insert' || countBefore === 0 ? (countBefore ?? 0) + n : n;
-                if (countAfter < expected) {
-                    console.error(
-                        `Import result for DE "${customerKey}" looks unexpected: expected at least ${expected} rows, got ${countAfter}.`,
-                    );
-                }
-            }
+            warnIfImportCountUnexpected({
+                countBefore,
+                cleared: clearedMultiFileDe,
+                countAfter,
+                imported: n,
+                mode: /** @type {'upsert'|'insert'} */ (mode),
+                label: `DE "${customerKey}"`,
+            });
         }
         return anyFileError ? 1 : 0;
     }
 
-    console.error(`Unknown command: ${sub}`);
+    log.error(`Unknown command: ${sub}`);
     printHelp();
     return 1;
 }