sfmc-dataloader 1.0.0 → 1.2.0

package/README.md

@@ -18,7 +18,7 @@ npm install -g sfmc-dataloader
 
 Run from your mcdev project root (where `.mcdevrc.json` lives).
 
-### Export
+### Export — single BU
 
 ```bash
 mcdata export MyCred/MyBU --de MyDE_CustomerKey --format csv
@@ -26,7 +26,24 @@ mcdata export MyCred/MyBU --de MyDE_CustomerKey --format csv
 
 Writes to `./data/MyCred/MyBU/<encodedKey>+MCDATA+<timestamp>.csv` (TSV/JSON with `--format`).
 
-### Import
+### Export — multiple BUs at once
+
+Use `--from` (repeatable) instead of the positional argument to export the same DE(s) from several BUs in one command:
+
+```bash
+mcdata export --from MyCred/Dev --from MyCred/QA --de Contact_DE --de Order_DE
+```
+
+Creates one timestamped file per BU/DE combination:
+
+```
+./data/MyCred/Dev/Contact_DE+MCDATA+<timestamp>.csv
+./data/MyCred/Dev/Order_DE+MCDATA+<timestamp>.csv
+./data/MyCred/QA/Contact_DE+MCDATA+<timestamp>.csv
+./data/MyCred/QA/Order_DE+MCDATA+<timestamp>.csv
+```
+
+### Import — single BU
 
 ```bash
 mcdata import MyCred/MyBU --de MyDE_CustomerKey --format csv --api async --mode upsert
@@ -40,14 +57,50 @@ Import from explicit paths (DE key is recovered from the `+MCDATA+` filename):
 mcdata import MyCred/MyBU --file ./data/MyCred/MyBU/encoded%2Bkey+MCDATA+2026-04-06T12-00-00.000Z.csv
 ```
 
+### Import — one source BU into multiple target BUs (API mode)
+
+Use `--from` (one source) and `--to` (repeatable targets) for a cross-BU import where rows are fetched live from the source BU:
+
+```bash
+mcdata import --from MyCred/Dev --to MyCred/QA --to MyCred/Prod --de Contact_DE
+```
+
+Before the import starts you will be offered the option to export the current data from each target BU as a timestamped backup. A timestamped download file is also written to each target BU's data directory so there is a traceable record of exactly what was imported.
+
+### Import — local export files into multiple target BUs (file mode)
+
+Use `--to` (repeatable targets) and `--file` (repeatable file paths) to push previously exported data files to multiple BUs without connecting to a source BU. The DE customer key is derived from each filename automatically:
+
+```bash
+mcdata import --to MyCred/QA --to MyCred/Prod \
+  --file ./data/MyCred/Dev/Contact_DE+MCDATA+2026-04-08T10-00-00.000Z.csv
+```
+
+Multiple files can be supplied to push several DEs in one command:
+
+```bash
+mcdata import --to MyCred/QA --to MyCred/Prod \
+  --file ./data/MyCred/Dev/Contact_DE+MCDATA+2026-04-08T10-00-00.000Z.csv \
+  --file ./data/MyCred/Dev/Order_DE+MCDATA+2026-04-08T10-00-00.000Z.csv
+```
+
+A timestamped download file is written to each target BU's data directory, giving a traceable snapshot of exactly what was imported.
+
 ### Clear all rows before import
 
-**Dangerous:** removes every row in the target Data Extension before uploading.
+**Dangerous:** removes every row in the target Data Extension(s) before uploading.
 
+Single-BU:
 ```bash
 mcdata import MyCred/MyBU --de MyKey --clear-before-import
 ```
 
+Cross-BU (warning lists every affected BU):
+```bash
+mcdata import --from MyCred/Dev --to MyCred/QA --to MyCred/Prod \
+  --de Contact_DE --clear-before-import
+```
+
 Interactive: type `YES` when prompted. In CI, add `--i-accept-clear-data-risk` after reviewing the risk.
 
 ## Options
@@ -58,6 +111,8 @@ Interactive: type `YES` when prompted. In CI, add `--i-accept-clear-data-risk` a
 | `--format` | `csv` (default), `tsv`, or `json` |
 | `--api` | `async` (default) or `sync` |
 | `--mode` | `upsert` (default), `insert` and `update` require `--api sync` |
+| `--from <cred>/<bu>` | Export: source BU (repeatable). Import API mode: single source BU (use with `--to` and `--de`) |
+| `--to <cred>/<bu>` | Import: target BU (repeatable). API mode: use with `--from`/`--de`. File mode: use with `--file` (no `--from` needed) |
 | `--clear-before-import` | SOAP `ClearData` before REST import |
 | `--i-accept-clear-data-risk` | Non-interactive consent for clear |
 

package/lib/cli.mjs

@@ -15,13 +15,18 @@ import { parseExportBasename } from './filename.mjs';
 import { importFromFile } from './import-de.mjs';
 import { clearDataExtensionRows } from './clear-de.mjs';
 import { confirmClearBeforeImport } from './confirm-clear.mjs';
+import { multiBuExport } from './multi-bu-export.mjs';
+import { crossBuImport } from './cross-bu-import.mjs';
 
 function printHelp() {
     console.log(`mcdata — SFMC Data Extension export/import (mcdev project)
 
 Usage:
   mcdata export <credential>/<bu> --de <key> [--de <key> ...] [options]
+  mcdata export --from <cred>/<bu> [--from <cred>/<bu> ...] --de <key> [--de <key> ...] [options]
   mcdata import <credential>/<bu> (--de <key> ... | --file <path> ...) [options]
+  mcdata import --from <cred>/<bu> --to <cred>/<bu> [--to <cred>/<bu> ...] --de <key> ... [options]
+  mcdata import --to <cred>/<bu> [--to <cred>/<bu> ...] --file <path> [--file <path> ...] [options]
 
 Options:
   -p, --project <dir>     mcdev project root (default: cwd)
@@ -34,10 +39,17 @@ Import options:
   --clear-before-import   SOAP ClearData before import (destructive; see below)
   --i-accept-clear-data-risk  Non-interactive acknowledgement for --clear-before-import
 
+Multi-BU options:
+  --from <cred>/<bu>      Export: source BU (repeatable for multiple sources)
+                          Import (API mode): single source BU (use with --to and --de)
+  --to <cred>/<bu>        Import: target BU (repeatable for multiple targets)
+                          Import (file mode): use with --file only (no --from needed)
+
 Notes:
   Exports are written under ./data/<credential>/<bu>/ with "+MCDATA+" in the filename.
   Import with --de resolves the latest matching file in that folder (by mtime).
   Import with --file parses the DE key from the basename (+MCDATA+ prefix).
+  Cross-BU import stores a timestamped download file in each target BU's data directory.
 
 Clear data warning:
   --clear-before-import deletes ALL existing rows in the target DE(s) before upload.
@@ -64,6 +76,8 @@ export async function main(argv) {
                 file: { type: 'string', multiple: true },
                 api: { type: 'string' },
                 mode: { type: 'string' },
+                from: { type: 'string', multiple: true },
+                to: { type: 'string', multiple: true },
                 'clear-before-import': { type: 'boolean', default: false },
                 'i-accept-clear-data-risk': { type: 'boolean', default: false },
                 'json-pretty': { type: 'boolean', default: false },
@@ -88,12 +102,7 @@ export async function main(argv) {
     }
 
     const sub = positionals[0];
-    const credBuRaw = positionals[1];
-    if (!credBuRaw) {
-        console.error('Missing <credential>/<businessUnit>.');
-        printHelp();
-        return 1;
-    }
+    const credBuRaw = positionals[1]; // May be undefined when --from/--to flags are used
 
     const projectRoot = path.resolve(values.project ?? process.cwd());
     const fmt = values.format ?? 'csv';
@@ -102,18 +111,63 @@ export async function main(argv) {
         return 1;
     }
 
-    const { mcdevrc, mcdevAuth } = loadMcdevProject(projectRoot);
-    const { credential, bu } = parseCredBu(credBuRaw);
-    const { mid, authCred } = resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
-    const authObj = buildSdkAuthObject(authCred, mid);
-    const sdk = new SDK(authObj, { requestAttempts: 3 });
+    const fromFlags = values.from ?? [];
+    const toFlags = values.to ?? [];
+    const hasFrom = fromFlags.length > 0;
+    const hasTo = toFlags.length > 0;
+    const hasPositional = !!credBuRaw;
 
+    // ── export ──────────────────────────────────────────────────────────────
     if (sub === 'export') {
+        if (hasTo) {
+            console.error('--to is not valid for export. Did you mean import?');
+            return 1;
+        }
+
         const des = [].concat(values.de ?? []);
         if (des.length === 0) {
             console.error('export requires at least one --de <customerKey>');
             return 1;
         }
+
+        if (hasFrom && hasPositional) {
+            console.error('Cannot mix a positional <credential>/<bu> with --from. Use one or the other.');
+            return 1;
+        }
+
+        if (!hasFrom && !hasPositional) {
+            console.error('export requires either a positional <credential>/<bu> or at least one --from <cred>/<bu>.');
+            printHelp();
+            return 1;
+        }
+
+        if (hasFrom) {
+            // Multi-BU export
+            let sources;
+            try {
+                sources = fromFlags.map(parseCredBu);
+            } catch (e) {
+                console.error(e.message);
+                return 1;
+            }
+            const { mcdevrc, mcdevAuth } = loadMcdevProject(projectRoot);
+            await multiBuExport({
+                projectRoot,
+                mcdevrc,
+                mcdevAuth,
+                sources,
+                deKeys: des,
+                format: /** @type {'csv'|'tsv'|'json'} */ (fmt),
+                jsonPretty: values['json-pretty'],
+            });
+            return 0;
+        }
+
+        // Single-BU export (original behavior)
+        const { credential, bu } = parseCredBu(credBuRaw);
+        const { mcdevrc, mcdevAuth } = loadMcdevProject(projectRoot);
+        const { mid, authCred } = resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
+        const sdk = new SDK(buildSdkAuthObject(authCred, mid), { requestAttempts: 3 });
         for (const deKey of des) {
             const out = await exportDataExtensionToFile(sdk, {
                 projectRoot,
@@ -128,6 +182,7 @@ export async function main(argv) {
         return 0;
     }
 
+    // ── import ──────────────────────────────────────────────────────────────
     if (sub === 'import') {
         const api = values.api ?? 'async';
         const mode = values.mode ?? 'upsert';
@@ -140,6 +195,107 @@ export async function main(argv) {
             return 1;
         }
 
+        const clear = values['clear-before-import'];
+        const acceptRisk = values['i-accept-clear-data-risk'];
+
+        // ── File-to-multi-BU import: --to + --file (no --from) ─────────────
+        // Rows are read from local export files; no source BU auth needed.
+        if (hasTo && !hasFrom && values.file?.length > 0) {
+            if (hasPositional) {
+                console.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.');
+                return 1;
+            }
+            const filePaths = values.file;
+            let targets;
+            try {
+                targets = toFlags.map(parseCredBu);
+            } catch (e) {
+                console.error(e.message);
+                return 1;
+            }
+            const { mcdevrc, mcdevAuth } = loadMcdevProject(projectRoot);
+            await crossBuImport({
+                projectRoot,
+                mcdevrc,
+                mcdevAuth,
+                filePaths,
+                targets,
+                format: /** @type {'csv'|'tsv'|'json'} */ (fmt),
+                api: /** @type {'async'|'sync'} */ (api),
+                mode: /** @type {'upsert'|'insert'|'update'} */ (mode),
+                clearBeforeImport: clear,
+                acceptRiskFlag: acceptRisk,
+                isTTY: process.stdin.isTTY === true,
+            });
+            return 0;
+        }
+
+        // ── Cross-BU import (API mode): --from + --to + --de ────────────────
+        if (hasFrom || hasTo) {
+            if (hasPositional) {
+                console.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.');
+                return 1;
+            }
+            if (!hasTo) {
+                console.error('--from requires at least one --to <cred>/<bu> to specify target Business Unit(s).');
+                return 1;
+            }
+            if (fromFlags.length > 1) {
+                console.error('import accepts exactly one --from <cred>/<bu> (use multiple --to for multiple targets).');
+                return 1;
+            }
+            if (values.file?.length > 0) {
+                console.error('--file cannot be combined with --from/--to/--de. For file-based multi-target import use --to + --file (without --from).');
+                return 1;
+            }
+            const deKeys = [].concat(values.de ?? []);
+            if (deKeys.length === 0) {
+                console.error('Cross-BU import requires at least one --de <customerKey>.');
+                return 1;
+            }
+            let sourceParsed;
+            let targets;
+            try {
+                sourceParsed = parseCredBu(fromFlags[0]);
+                targets = toFlags.map(parseCredBu);
+            } catch (e) {
+                console.error(e.message);
+                return 1;
+            }
+            const { mcdevrc, mcdevAuth } = loadMcdevProject(projectRoot);
+            await crossBuImport({
+                projectRoot,
+                mcdevrc,
+                mcdevAuth,
+                sourceCred: sourceParsed.credential,
+                sourceBu: sourceParsed.bu,
+                targets,
+                deKeys,
+                format: /** @type {'csv'|'tsv'|'json'} */ (fmt),
+                api: /** @type {'async'|'sync'} */ (api),
+                mode: /** @type {'upsert'|'insert'|'update'} */ (mode),
+                clearBeforeImport: clear,
+                acceptRiskFlag: acceptRisk,
+                isTTY: process.stdin.isTTY === true,
+            });
+            return 0;
+        }
+
+        // ── Single-BU import (original behavior) ────────────────────────────
+        if (!hasPositional) {
+            console.error('import requires either a positional <credential>/<bu> or --from/--to flags.');
+            printHelp();
+            return 1;
+        }
+
         const hasDe = values.de?.length > 0;
         const hasFile = values.file?.length > 0;
         if (hasDe === hasFile) {
@@ -147,8 +303,10 @@ export async function main(argv) {
             return 1;
         }
 
-        const clear = values['clear-before-import'];
-        const acceptRisk = values['i-accept-clear-data-risk'];
+        const { credential, bu } = parseCredBu(credBuRaw);
+        const { mcdevrc, mcdevAuth } = loadMcdevProject(projectRoot);
+        const { mid, authCred } = resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
+        const sdk = new SDK(buildSdkAuthObject(authCred, mid), { requestAttempts: 3 });
 
         if (hasDe) {
             const deKeys = [].concat(values.de ?? []);

package/lib/confirm-clear.mjs

@@ -1,17 +1,22 @@
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 
+/**
+ * @typedef {{ credential: string, bu: string }} CredBuTarget
+ */
+
 /**
  * @param {object} opts
  * @param {string[]} opts.deKeys
  * @param {boolean} opts.acceptRiskFlag
  * @param {boolean} opts.isTTY
+ * @param {CredBuTarget[]} [opts.targets]  When present, renders a per-BU breakdown.
  * @param {NodeJS.ReadableStream} [opts.stdin]
  * @param {NodeJS.WritableStream} [opts.stdout]
  * @returns {Promise<void>}
  */
 export async function confirmClearBeforeImport(opts) {
-    const { deKeys, acceptRiskFlag, isTTY } = opts;
+    const { deKeys, targets, acceptRiskFlag, isTTY } = opts;
     const stdin = opts.stdin ?? input;
     const stdout = opts.stdout ?? output;
     if (acceptRiskFlag) {
@@ -23,12 +28,27 @@ export async function confirmClearBeforeImport(opts) {
                 'All rows in the target Data Extension(s) would be permanently deleted.'
         );
     }
-    const msg =
-        '\n*** DANGER: CLEAR DATA ***\n' +
-        'This will permanently DELETE ALL ROWS in:\n' +
-        deKeys.map((k) => `  - ${k}\n`).join('') +
-        'This cannot be undone. Enterprise 2.0 / admin / shared-DE rules may apply.\n' +
-        'Type YES to continue, anything else to abort: ';
+    let msg;
+    if (targets && targets.length > 0) {
+        msg =
+            '\n*** DANGER: CLEAR DATA ***\n' +
+            `This will permanently DELETE ALL ROWS across ${targets.length} Business Unit(s):\n\n` +
+            targets
+                .map(
+                    ({ credential, bu }) =>
+                        `  ${credential}/${bu}:\n` + deKeys.map((k) => `    - ${k}\n`).join('')
+                )
+                .join('') +
+            '\nThis cannot be undone. Enterprise 2.0 / admin / shared-DE rules may apply.\n' +
+            'Type YES to continue, anything else to abort: ';
+    } else {
+        msg =
+            '\n*** DANGER: CLEAR DATA ***\n' +
+            'This will permanently DELETE ALL ROWS in:\n' +
+            deKeys.map((k) => `  - ${k}\n`).join('') +
+            'This cannot be undone. Enterprise 2.0 / admin / shared-DE rules may apply.\n' +
+            'Type YES to continue, anything else to abort: ';
+    }
     stdout.write(msg);
     const rl = readline.createInterface({ input: stdin, output: stdout });
     try {

package/lib/cross-bu-import.mjs

@@ -0,0 +1,199 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import SDK from 'sfmc-sdk';
+import { resolveCredentialAndMid, buildSdkAuthObject } from './config.mjs';
+import { fetchAllRowObjects, serializeRows } from './export-de.mjs';
+import { exportDataExtensionToFile } from './export-de.mjs';
+import { importRowsForDe } from './import-de.mjs';
+import { readRowsFromFile } from './read-rows.mjs';
+import { clearDataExtensionRows } from './clear-de.mjs';
+import { confirmClearBeforeImport } from './confirm-clear.mjs';
+import { dataDirectoryForBu } from './paths.mjs';
+import { buildExportBasename, filesystemSafeTimestamp, parseExportBasename } from './filename.mjs';
+
+/**
+ * @typedef {{ credential: string, bu: string }} CredBuTarget
+ */
+
+/**
+ * In TTY mode, asks the user whether to export target DE data as backup
+ * before importing.  Returns true when the user answers YES.
+ *
+ * @param {object} opts
+ * @param {CredBuTarget[]} opts.targets
+ * @param {string[]} opts.deKeys
+ * @param {NodeJS.ReadableStream} [opts.stdin]
+ * @param {NodeJS.WritableStream} [opts.stdout]
+ * @returns {Promise<boolean>}
+ */
+async function offerPreExportBackup({ targets, deKeys, stdin: stdinStream, stdout: stdoutStream }) {
+    const stdinSrc = stdinStream ?? input;
+    const stdoutSrc = stdoutStream ?? output;
+    const targetList = targets.map(({ credential, bu }) => `${credential}/${bu}`).join(', ');
+    const msg =
+        '\nBefore importing, would you like to export the current data from target BU(s) as a backup?\n' +
+        'This creates timestamped files that will not be overwritten by the following import.\n\n' +
+        `  Target(s): ${targetList}\n` +
+        `  Data Extensions: ${deKeys.join(', ')}\n\n` +
+        'Type YES to export first, or press Enter to skip: ';
+    stdoutSrc.write(msg);
+    const rl = readline.createInterface({ input: stdinSrc, output: stdoutSrc });
+    try {
+        const line = await rl.question('');
+        return line.trim() === 'YES';
+    } finally {
+        rl.close();
+    }
+}
+
+/**
+ * Imports Data Extension rows from a single source BU into one or more target
+ * BUs.
+ *
+ * Two source modes are supported:
+ *
+ * **API mode** (default): rows are fetched live from the source BU via the
+ * SFMC REST API.  Requires `sourceCred`, `sourceBu`, and `deKeys`.
+ *
+ * **File mode**: rows are read from local export files (e.g. previously
+ * created by `mcdata export`).  Requires `filePaths`; `deKeys` and
+ * `sourceCred`/`sourceBu` must be omitted.  The DE customer key is derived
+ * from each filename via `parseExportBasename`.
+ *
+ * Before the import each target BU:
+ * 1. Optionally exports its current DE data as a timestamped backup (TTY only).
+ * 2. Optionally clears all existing rows (with danger warning covering every target).
+ * 3. Receives the source rows written to a timestamped "download" file in its
+ *    own `./data/<credential>/<bu>/` directory (mirroring mcdev retrieve).
+ * 4. Has the rows imported via the REST API.
+ *
+ * @param {object} params
+ * @param {string} params.projectRoot
+ * @param {import('./config.mjs').Mcdevrc} params.mcdevrc
+ * @param {Record<string, import('./config.mjs').AuthCredential>} params.mcdevAuth
+ * @param {string} [params.sourceCred] - API mode only
+ * @param {string} [params.sourceBu]   - API mode only
+ * @param {string[]} [params.deKeys]   - API mode only
+ * @param {string[]} [params.filePaths] - File mode only; mutually exclusive with sourceCred/sourceBu/deKeys
+ * @param {CredBuTarget[]} params.targets
+ * @param {'csv'|'tsv'|'json'} params.format
+ * @param {'async'|'sync'} params.api
+ * @param {'upsert'|'insert'|'update'} params.mode
+ * @param {boolean} params.clearBeforeImport
+ * @param {boolean} params.acceptRiskFlag
+ * @param {boolean} params.isTTY
+ * @param {NodeJS.ReadableStream} [params.stdin]  Override for testing
+ * @param {NodeJS.WritableStream} [params.stdout] Override for testing
+ * @returns {Promise<void>}
+ */
+export async function crossBuImport(params) {
+    const {
+        projectRoot,
+        mcdevrc,
+        mcdevAuth,
+        targets,
+        format,
+        api,
+        mode,
+        clearBeforeImport,
+        acceptRiskFlag,
+        isTTY,
+    } = params;
+    const stdin = params.stdin;
+    const stdout = params.stdout;
+
+    // Determine source mode
+    const filePaths = params.filePaths ?? null;
+    const isFileBased = filePaths !== null && filePaths.length > 0;
+
+    // Derive DE keys: from explicit list (API mode) or from filenames (file mode)
+    const deKeys = isFileBased
+        ? filePaths.map((fp) => parseExportBasename(path.basename(fp)).customerKey)
+        : (params.deKeys ?? []);
+
+    // Build a lookup map from deKey → filePath for file mode
+    /** @type {Map<string, string>} */
+    const fileByDeKey = new Map();
+    if (isFileBased) {
+        for (const fp of filePaths) {
+            fileByDeKey.set(parseExportBasename(path.basename(fp)).customerKey, fp);
+        }
+    }
+
+    // Validate all target BU configurations upfront
+    for (const { credential, bu } of targets) {
+        resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
+    }
+
+    // Connect to source BU (API mode only)
+    let srcSdk = null;
+    if (!isFileBased) {
+        const { mid: srcMid, authCred: srcAuth } = resolveCredentialAndMid(
+            mcdevrc, mcdevAuth, params.sourceCred, params.sourceBu
+        );
+        srcSdk = new SDK(buildSdkAuthObject(srcAuth, srcMid), { requestAttempts: 3 });
+    }
+
+    // Optional pre-import backup of target BU data
+    if (isTTY) {
+        const doBackup = await offerPreExportBackup({ targets, deKeys, stdin, stdout });
+        if (doBackup) {
+            for (const { credential, bu } of targets) {
+                const { mid, authCred } = resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
+                const tgtSdk = new SDK(buildSdkAuthObject(authCred, mid), { requestAttempts: 3 });
+                for (const deKey of deKeys) {
+                    const outPath = await exportDataExtensionToFile(tgtSdk, {
+                        projectRoot,
+                        credentialName: credential,
+                        buName: bu,
+                        deKey,
+                        format,
+                    });
+                    console.error(`Backup export: ${outPath}`);
+                }
+            }
+        }
+    }
+
+    // Single up-front clear confirmation covering all targets + all DE keys
+    if (clearBeforeImport) {
+        await confirmClearBeforeImport({ deKeys, targets, acceptRiskFlag, isTTY, stdin, stdout });
+    }
+
+    // Load rows once per DE then fan out to every target
+    for (const deKey of deKeys) {
+        const rows = isFileBased
+            ? await readRowsFromFile(fileByDeKey.get(deKey), format)
+            : await fetchAllRowObjects(srcSdk, deKey);
+
+        // Clear targets before import (rows already confirmed above)
+        if (clearBeforeImport) {
+            for (const { credential, bu } of targets) {
+                const { mid, authCred } = resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
+                const tgtSdk = new SDK(buildSdkAuthObject(authCred, mid), { requestAttempts: 3 });
+                await clearDataExtensionRows(tgtSdk.soap, deKey);
+            }
+        }
+
+        for (const { credential, bu } of targets) {
+            const { mid, authCred } = resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
+            const tgtSdk = new SDK(buildSdkAuthObject(authCred, mid), { requestAttempts: 3 });
+
+            // Write a timestamped "download" file in the target BU's data directory.
+            // This mirrors what mcdev retrieve / mcdata export produces, giving a
+            // traceable snapshot of exactly what was imported.
+            const dir = dataDirectoryForBu(projectRoot, credential, bu);
+            await fs.mkdir(dir, { recursive: true });
+            const ts = filesystemSafeTimestamp();
+            const basename = buildExportBasename(deKey, ts, format);
+            const snapshotPath = path.join(dir, basename);
+            await fs.writeFile(snapshotPath, serializeRows(rows, format, false), 'utf8');
+            console.error(`Download stored: ${snapshotPath}`);
+
+            await importRowsForDe(tgtSdk, { deKey, rows, api, mode });
+            console.error(`Imported -> ${credential}/${bu} DE ${deKey}`);
+        }
+    }
+}

package/lib/index.mjs

@@ -3,3 +3,5 @@ export { filterIllegalFilenames, reverseFilterIllegalFilenames, parseExportBasen
 export { chunkItemsForPayload, DEFAULT_MAX_BODY_BYTES, MAX_OBJECTS_PER_BATCH } from './batch.mjs';
 export { resolveImportRoute, rowsetGetPath, asyncUpsertPath } from './import-routes.mjs';
 export { loadMcdevProject, parseCredBu, resolveCredentialAndMid, buildSdkAuthObject } from './config.mjs';
+export { multiBuExport } from './multi-bu-export.mjs';
+export { crossBuImport } from './cross-bu-import.mjs';

package/lib/multi-bu-export.mjs

@@ -0,0 +1,44 @@
+import SDK from 'sfmc-sdk';
+import { resolveCredentialAndMid, buildSdkAuthObject } from './config.mjs';
+import { exportDataExtensionToFile } from './export-de.mjs';
+
+/**
+ * @typedef {{ credential: string, bu: string }} CredBuSource
+ */
+
+/**
+ * Exports one or more Data Extensions from multiple source BUs in a single
+ * pass.  Each source BU gets its own timestamped file per DE key under
+ * `./data/<credential>/<bu>/`.
+ *
+ * @param {object} params
+ * @param {string} params.projectRoot
+ * @param {import('./config.mjs').Mcdevrc} params.mcdevrc
+ * @param {Record<string, import('./config.mjs').AuthCredential>} params.mcdevAuth
+ * @param {CredBuSource[]} params.sources
+ * @param {string[]} params.deKeys
+ * @param {'csv'|'tsv'|'json'} params.format
+ * @param {boolean} [params.jsonPretty]
+ * @returns {Promise<string[]>} Paths of all written files
+ */
+export async function multiBuExport({ projectRoot, mcdevrc, mcdevAuth, sources, deKeys, format, jsonPretty = false }) {
+    /** @type {string[]} */
+    const exported = [];
+    for (const { credential, bu } of sources) {
+        const { mid, authCred } = resolveCredentialAndMid(mcdevrc, mcdevAuth, credential, bu);
+        const sdk = new SDK(buildSdkAuthObject(authCred, mid), { requestAttempts: 3 });
+        for (const deKey of deKeys) {
+            const outPath = await exportDataExtensionToFile(sdk, {
+                projectRoot,
+                credentialName: credential,
+                buName: bu,
+                deKey,
+                format,
+                jsonPretty,
+            });
+            console.error(`Exported: ${outPath}`);
+            exported.push(outPath);
+        }
+    }
+    return exported;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sfmc-dataloader",
-    "version": "1.0.0",
+    "version": "1.2.0",
     "description": "CLI (mcdata) to export and import Marketing Cloud Data Extension rows using mcdev project config and sfmc-sdk",
     "author": "Jörn Berkefeld <joern.berkefeld@gmail.com>",
     "license": "MIT",