@pdfbutler/migration-cli 0.0.26 → 0.0.28

package/lib/commands/butler/pb/export.js

@@ -1,355 +1,345 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable complexity */
-/* eslint-disable @typescript-eslint/no-misused-promises */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable sf-plugin/no-missing-messages */
-/* eslint-disable @typescript-eslint/prefer-for-of */
-/* eslint-disable no-await-in-loop */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable no-console */
-const fs_1 = require("fs");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
 const sf_plugins_core_1 = require("@salesforce/sf-plugins-core");
 const core_1 = require("@salesforce/core");
 const AdmZip = require("adm-zip");
-const got_1 = require("got");
-const jsforce = require('jsforce');
-const PATTERN_DOC_CONFIG = /([\w-]{36})/;
-const PATH_EXPORT = '/cadmus_core/DocConfig/Export2/';
-const CUT_AFTER = 150;
-const MSG_SPLITTED_DOC_CONFIGS = 'Number of DocConfig Ids after splitting: [VALUE].';
-const MSG_AUTHORIZATION = 'Authorization with the username: [VALUE].';
-const MSG_EXPORTED_DOC_CONFIGS = 'Number of exported DocConfigs: [VALUE].';
-const MSG_FOLDER_CREATED = 'Folder structure created at: [VALUE].';
-const MSG_DOC_CONFIG_HAS_NO_BACKEND = 'DocConfig with ID - [VALUE], does not have a backend.';
-const MSG_NO_AUTH_PARAMS = 'No authentication parameters provided. Please provide either username or session and instance parameters.';
-const MSG_NO_MATCHING_DOC_CONFIGS = 'No matching Doc Configs ids found.';
-const MSG_CONNECTION_FAILED = 'Connection to Salesforce has been failed.';
-const MSG_EXPORT_FAILED = 'DocConfig export has failed. Check the IDs and try again.';
-const MSG_BACKEND_DATA_ARCHIVED = 'Exported data from backend has been archived.';
-const MSG_BLANK_BACKEND = 'One or more docConfigs have no backend.';
-const MSG_USER_HAS_PERMISSIONS = 'User has read/write permissions.';
-const MSG_USER_HAS_NO_PERMISSIONS = "User doesn't have read/write permissions.";
-const MSG_ARCHIVE_UNZIPPED = 'Archive unzipped and recorded locally.';
-const MSG_ARCHIVE_RECORDED = 'Archive recorded locally.';
-const MSG_CREATION_CONNECTION = 'Creating Connection with the Salesforce org.';
-const MSG_FETCH_DATA = 'Attempting to fetch data from the org.';
-const MSG_UNZIP_FILES = 'Unzipping the files.';
-const MSG_SAVE_AS_ZIP = 'Saving as zip.';
-const MSG_SAVE_BACKEND = 'Saving backend only.';
-const MSG_PARTIAL_EXPORT_ACTIVE = 'The partial export is active. DocConfigs that do not have a backend will not be exported.';
-const MSG_TRY_TO_GET_DOC_CONFIG_BACKEND = 'Trying to get backend of DocConfig with ID: [VALUE]';
-const MSG_START_EXPORT_BACKEND = 'Starting to export DocConfigs backend.';
-const MSG_RUN_AUTH_COMMAND = 'Run the command "sf org login web" before authenticating with the target.';
-const MSG_CHECK_SESSION_INSTANCE = 'Check if the session is up to date and if the instance is correct.';
+const got_1 = __importDefault(require("got"));
+const logger_1 = require("../../../utils/logger");
+const constants_1 = require("../../../utils/constants");
+const authentication_1 = require("../../../utils/authentication");
+const extract_templates_1 = require("../../../utils/extract-templates");
 core_1.Messages.importMessagesDirectory(__dirname);
 const messages = core_1.Messages.loadMessages('@pdfbutler/migration-cli', 'butler.pb.export');
 class ButlerPbExport extends sf_plugins_core_1.SfCommand {
+    static summary = messages.getMessage('summary');
+    static description = messages.getMessage('description');
+    static examples = messages.getMessages('examples');
+    static flags = {
+        name: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.name.summary'),
+            description: messages.getMessage('flags.name.description'),
+            char: 'n',
+            required: false,
+        }),
+        target: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.target.summary'),
+            char: 't',
+            required: false,
+        }),
+        id: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.id.summary'),
+            char: 'i',
+            required: true,
+        }),
+        out: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.out.summary'),
+            // eslint-disable-next-line sf-plugin/dash-o
+            char: 'o',
+            required: true,
+        }),
+        backend: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.backend.summary'),
+            char: 'b',
+        }),
+        'auth-env-var': sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.auth-env-var.summary'),
+            char: 'a',
+        }),
+        endpoint: sf_plugins_core_1.Flags.url({
+            summary: messages.getMessage('flags.endpoint.summary'),
+            char: 'e',
+        }),
+        stage: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.stage.summary'),
+            char: 's',
+            required: true,
+        }),
+        unzip: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.unzip.summary'),
+            char: 'u',
+        }),
+        logs: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.logs.summary'),
+            char: 'l',
+        }),
+        partial: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.partial.summary'),
+            char: 'p',
+        }),
+        session: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.session.summary'),
+        }),
+        instance: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.instance.summary'),
+        }),
+        cut: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.cut.summary'),
+            char: 'c',
+        }),
+        shortpaths: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.shortpaths.summary'),
+        }),
+        templates: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.templates.summary'),
+            char: 'm',
+        }),
+    };
+    static isLogsActive = false;
+    processedIds = new Set();
     static getDocConfigIds(id) {
-        const docConfigIds = id.split(PATTERN_DOC_CONFIG).filter((n) => n);
-        docConfigIds.map((docId) => {
-            if (!docId.trim() || docId.length < 36) {
-                docConfigIds.splice(docConfigIds.indexOf(docId), 1);
-            }
-        });
-        if (this.isLogsActive)
-            this.log(MSG_SPLITTED_DOC_CONFIGS.replace('[VALUE]', docConfigIds.length.toString()));
-        if (docConfigIds.length < 0) {
-            throw new Error(MSG_NO_MATCHING_DOC_CONFIGS);
+        const docConfigIds = id
+            .split(constants_1.PATTERN.DOC_CONFIG)
+            .map((docId) => docId.trim())
+            .filter((docId) => docId.length >= 36);
+        logger_1.Logger.info(constants_1.MESSAGE.SPLITTED_DOC_CONFIGS.replace('[VALUE]', docConfigIds.length.toString()), this.isLogsActive);
+        if (docConfigIds.length === 0) {
+            throw new Error(constants_1.ERROR.NO_MATCHING_DOC_CONFIGS);
         }
         return docConfigIds;
     }
-    static isBlank(value) {
-        return value === ''
-            || value === null
-            || value === undefined;
-    }
-    static log(message, type = 'info') {
-        const prefix = type === 'info' ? '[INFO]' : '[ERROR]';
-        console.log(`${prefix} ${message}`);
-    }
-    static async authenticateWithTarget(username) {
+    static async getDocConfigs(docConfigIds, connection) {
         try {
-            if (this.isLogsActive)
-                this.log(MSG_AUTHORIZATION.replace('[VALUE]', username));
-            const authInfo = await core_1.AuthInfo.create({ username });
-            if (this.isLogsActive)
-                this.log(MSG_CREATION_CONNECTION);
-            const connection = await core_1.Connection.create({ authInfo });
-            this.log(`Connected to ${username} (Org ID: ${authInfo.getFields().orgId})`);
-            return connection;
+            logger_1.Logger.info(constants_1.MESSAGE.FETCH_DATA, ButlerPbExport.isLogsActive);
+            const docConfigPromises = docConfigIds.map((docConfigId) => {
+                const endpoint = `${constants_1.PATH.EXPORT_DOC_CONFIG}${docConfigId}`;
+                return connection.apex.get(endpoint);
+            });
+            return await Promise.all(docConfigPromises);
         }
-        catch (error) {
-            this.log(MSG_RUN_AUTH_COMMAND, 'error');
-            throw new Error(MSG_CONNECTION_FAILED);
+        catch (e) {
+            throw new Error(constants_1.ERROR.EXPORT_FAILED);
         }
     }
-    static async authenticateWitsSession(session, instance) {
-        session = session.trim();
-        instance = instance.trim();
-        const isInstanceBlank = this.isBlank(instance);
-        const isSessionBlank = this.isBlank(session);
-        if (!isInstanceBlank && !isSessionBlank) {
-            const connection = await new jsforce.Connection({
-                instanceUrl: `${instance}`,
-                sessionId: `${session}`,
-            });
-            this.log(`Connected to ${connection.instanceUrl}`);
-            return connection;
+    static convertBufferToUtf8(files) {
+        for (const file of files.getEntries()) {
+            if (file.entryName.endsWith('.json')) {
+                const parsed = JSON.parse(file.getData().toString('utf8'));
+                file.setData(JSON.stringify(parsed, null, 2));
+            }
         }
-        else if (!isSessionBlank && isInstanceBlank) {
-            this.log('Instance URL (--instance) cannot be empty', 'error');
+        return files;
+    }
+    static async logPermissionStatus(outDir) {
+        if (!ButlerPbExport.isLogsActive)
+            return;
+        try {
+            await node_fs_1.promises.access(path.resolve(outDir), node_fs_1.promises.constants.R_OK | node_fs_1.promises.constants.W_OK);
+            logger_1.Logger.info(constants_1.MESSAGE.USER_HAS_PERMISSIONS);
         }
-        else if (isSessionBlank && !isInstanceBlank) {
-            this.log('Session Id (--session) cannot be empty', 'error');
+        catch (err) {
+            logger_1.Logger.error(constants_1.ERROR.USER_NO_PERMISSIONS);
         }
-        else {
-            this.log('Session Id and Instance URL (--session and --instance) cannot be empty', 'error');
+    }
+    static getDocConfigResponse(docConfigId, idsToProcess, docConfigResponses) {
+        const responseIndex = idsToProcess.indexOf(docConfigId);
+        if (responseIndex < 0) {
+            throw new Error(constants_1.ERROR.EXPORT_FAILED);
         }
-        this.log(MSG_CHECK_SESSION_INSTANCE, 'error');
-        throw new Error(MSG_CONNECTION_FAILED);
+        return docConfigResponses[responseIndex];
     }
-    static async authenticate(username, session, instance) {
-        let connection;
-        if (this.isBlank(username) && (this.isBlank(session) || this.isBlank(instance))) {
-            throw new Error(MSG_NO_AUTH_PARAMS);
+    static async fetchBackendZips(idsToProcess, flags, isUseShortPath) {
+        const zipMap = new Map();
+        let lastBuffer = Buffer.from('');
+        if (flags.backend) {
+            return { zipMap, lastBuffer };
         }
-        try {
-            if (this.isBlank(session) || this.isBlank(instance)) {
-                connection = await this.authenticateWithTarget(username);
+        const uniqueIds = Array.from(new Set(idsToProcess));
+        logger_1.Logger.info(constants_1.MESSAGE.START_EXPORT_BACKEND, ButlerPbExport.isLogsActive);
+        const auth = flags['auth-env-var'];
+        const base64Auth = auth?.includes(':') ? Buffer.from(auth, 'utf8').toString('base64') : auth ?? '';
+        logger_1.Logger.info(constants_1.MESSAGE.PARTIAL_EXPORT_ACTIVE, ButlerPbExport.isLogsActive && Boolean(flags.partial));
+        const endpointBaseUrl = flags.endpoint?.toString() ?? '';
+        if (ButlerPbExport.isLogsActive) {
+            logger_1.Logger.info(constants_1.MESSAGE.BACKEND_RETRIEVAL_START.replace('[COUNT]', uniqueIds.length.toString()).replace('[IDS]', JSON.stringify(uniqueIds, null, 2)));
+        }
+        await uniqueIds.reduce(async (chain, docConfigId, index) => {
+            await chain;
+            if (ButlerPbExport.isLogsActive) {
+                logger_1.Logger.info(constants_1.MESSAGE.BACKEND_RETRIEVING.replace('[INDEX]', (index + 1).toString())
+                    .replace('[COUNT]', uniqueIds.length.toString())
+                    .replace('[ID]', docConfigId));
             }
-            else {
-                connection = await this.authenticateWitsSession(session, instance);
+            let finalUrl = `${endpointBaseUrl}config/export-config/${flags.stage}/${docConfigId}`;
+            if (isUseShortPath) {
+                logger_1.Logger.info(constants_1.MESSAGE.USED_SHORT_PATH);
+                finalUrl += '?shortPaths=true';
             }
-            return connection;
-        }
-        catch (error) {
-            throw new Error(MSG_CONNECTION_FAILED);
+            try {
+                lastBuffer = await (0, got_1.default)(finalUrl, {
+                    headers: { Authorization: `Basic ${base64Auth}` },
+                }).buffer();
+                zipMap.set(docConfigId, new AdmZip(lastBuffer));
+                if (ButlerPbExport.isLogsActive) {
+                    logger_1.Logger.success(constants_1.MESSAGE.BACKEND_RETRIEVED.replace('[INDEX]', (index + 1).toString())
+                        .replace('[COUNT]', uniqueIds.length.toString())
+                        .replace('[ID]', docConfigId));
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : JSON.stringify(err);
+                logger_1.Logger.error(message);
+                logger_1.Logger.error(constants_1.MESSAGE.DOC_CONFIG_NO_BACKEND.replace('[VALUE]', docConfigId), ButlerPbExport.isLogsActive);
+                if (!flags.partial) {
+                    throw new Error(constants_1.ERROR.BLANK_BACKEND);
+                }
+            }
+        }, Promise.resolve());
+        if (uniqueIds.length > 0) {
+            logger_1.Logger.info(constants_1.MESSAGE.BACKEND_DATA_ARCHIVED_PROGRESS
+                .replace('[EXPORTED]', zipMap.size.toString())
+                .replace('[TOTAL]', uniqueIds.length.toString()), ButlerPbExport.isLogsActive);
         }
+        return { zipMap, lastBuffer };
     }
-    static async getDocConfigs(docConfigIds, connection) {
-        let docConfigPromises;
-        let responses = [];
-        try {
-            if (ButlerPbExport.isLogsActive)
-                this.log(MSG_FETCH_DATA);
-            docConfigPromises = docConfigIds.map(async (docConfigId) => {
-                const endpoint = `${PATH_EXPORT}${docConfigId}`;
-                return connection.apex.get(endpoint);
-            });
-            responses = await Promise.all(docConfigPromises);
-        }
-        catch (e) {
-            throw new Error(MSG_EXPORT_FAILED);
-        }
-        return responses;
+    static async writeBackendOnly(idsToProcess, docConfigResponses, outDir) {
+        const tasks = idsToProcess.map(async (docId) => {
+            const data = JSON.stringify(ButlerPbExport.getDocConfigResponse(docId, idsToProcess, docConfigResponses), null, 2);
+            await node_fs_1.promises.writeFile(path.join(outDir, 'sfdc', `${docId}.json`), data);
+        });
+        await Promise.all(tasks);
+        logger_1.Logger.success(constants_1.MESSAGE.SAVE_BACKEND);
     }
-    static convertBufferToUtf8(files) {
-        files.getEntries().forEach((file) => {
-            if (file.entryName.endsWith('.json')) {
-                file.setData(JSON.stringify(JSON.parse(file.getData().toString('utf8')), null, 2));
-            }
+    static async processZipMapUnzip(zipMap, idsToProcess, docConfigResponses, outDir, shouldExtractTemplates) {
+        const entryTasks = Array.from(zipMap.entries()).map(async ([key, value]) => {
+            const extractionPath = path.join(outDir, key);
+            ButlerPbExport.convertBufferToUtf8(value).extractAllTo(extractionPath, false);
+            const foundIds = shouldExtractTemplates
+                ? await (0, extract_templates_1.extractTemplateIds)(extractionPath)
+                : [];
+            const data = JSON.stringify(ButlerPbExport.getDocConfigResponse(key, idsToProcess, docConfigResponses), null, 2);
+            await node_fs_1.promises.writeFile(path.join(outDir, 'sfdc', `${key}.json`), data);
+            return foundIds;
         });
-        return files;
+        const discoveredTemplateIds = await Promise.all(entryTasks);
+        return discoveredTemplateIds.flat();
     }
-    async run() {
-        const { flags } = await this.parse(ButlerPbExport);
-        ButlerPbExport.isLogsActive = flags.logs;
-        const outDir = flags.out;
-        const isUseShortPath = flags.shortpaths;
-        let docConfigIds = [];
-        let docConfigResponses = [];
-        const targetUsername = flags.target;
-        const session = flags.session;
-        const instance = flags.instance;
-        docConfigIds = ButlerPbExport.getDocConfigIds(flags.id);
-        ButlerPbExport.log(JSON.stringify(docConfigIds, null, 2));
-        const connection = await ButlerPbExport.authenticate(targetUsername, session, instance);
-        docConfigResponses = await ButlerPbExport.getDocConfigs(docConfigIds, connection);
-        if (ButlerPbExport.isLogsActive)
-            ButlerPbExport.log(MSG_EXPORTED_DOC_CONFIGS.replace('[VALUE]', docConfigResponses.length.toString()));
-        if (docConfigResponses.length < 1)
-            throw new Error(MSG_NO_MATCHING_DOC_CONFIGS);
-        let zipMap = new Map();
-        let result = Buffer.from('');
-        if (!flags.backend) {
-            if (ButlerPbExport.isLogsActive)
-                ButlerPbExport.log(MSG_START_EXPORT_BACKEND);
-            const auth = flags['auth-env-var'];
-            let base64Auth = auth;
-            if (auth?.indexOf(':')) {
-                base64Auth = Buffer.from(auth).toString('base64');
+    static async processZipMapZip(zipMap, idsToProcess, docConfigResponses, flags, outDir, shouldExtractTemplates) {
+        const entryTasks = Array.from(zipMap.entries()).map(async ([key, value]) => {
+            const zipToExport = new AdmZip();
+            let foundIds = [];
+            if (shouldExtractTemplates) {
+                const tempExtractPath = path.join(outDir, `.temp_${key}`);
+                ButlerPbExport.convertBufferToUtf8(value).extractAllTo(tempExtractPath, false);
+                foundIds = await (0, extract_templates_1.extractTemplateIds)(tempExtractPath);
+                await node_fs_1.promises.rm(tempExtractPath, { recursive: true, force: true });
             }
-            if (ButlerPbExport.isLogsActive && flags.partial)
-                ButlerPbExport.log(MSG_PARTIAL_EXPORT_ACTIVE);
-            for (const docConfigId of docConfigIds) {
-                if (ButlerPbExport.isLogsActive)
-                    ButlerPbExport.log(MSG_TRY_TO_GET_DOC_CONFIG_BACKEND.replace('[VALUE]', docConfigId));
-                let finalUrl = `${flags.endpoint?.toString()}config/export-config/${flags.stage}/${docConfigId}`;
-                if (isUseShortPath) {
-                    ButlerPbExport.log('Short paths are used.');
-                    finalUrl += '?shortPaths=true';
-                }
-                try {
-                    result = await (0, got_1.default)(finalUrl, {
-                        headers: {
-                            Authorization: `Basic ${base64Auth}`,
-                        },
-                    }).buffer();
-                    zipMap.set(docConfigId, new AdmZip(result));
-                    if (ButlerPbExport.isLogsActive)
-                        ButlerPbExport.log(MSG_BACKEND_DATA_ARCHIVED);
-                }
-                catch (err) {
-                    ButlerPbExport.log(err, 'error');
-                    if (ButlerPbExport.isLogsActive)
-                        ButlerPbExport.log(MSG_DOC_CONFIG_HAS_NO_BACKEND.replace('[VALUE]', docConfigId));
-                    if (!flags.partial) {
-                        throw new Error(MSG_BLANK_BACKEND);
-                    }
+            for (const entry of value.getEntries()) {
+                let entryName = entry.entryName;
+                const fileName = entryName.substring(Number(entryName.lastIndexOf('/')) + 1, entryName.lastIndexOf('.'));
+                entryName = flags.cut ? entryName.replace(fileName, fileName.substring(0, constants_1.CUT.AFTER)) : entryName;
+                const entryData = value.readFile(entry);
+                if (!entryData) {
+                    logger_1.Logger.error(constants_1.ERROR.FAILED_TO_SAVE_FILE);
+                    continue;
                 }
+                zipToExport.addFile(entryName, entryData);
             }
+            zipToExport.addFile('sfdc/docconfig.json', Buffer.from(JSON.stringify(ButlerPbExport.getDocConfigResponse(key, idsToProcess, docConfigResponses), null, 2)));
+            const zipData = new Uint8Array(zipToExport.toBuffer());
+            await node_fs_1.promises.writeFile(path.join(outDir, `${key}.zip`), zipData);
+            const data = JSON.stringify(ButlerPbExport.getDocConfigResponse(key, idsToProcess, docConfigResponses), null, 2);
+            await node_fs_1.promises.writeFile(path.join(outDir, 'sfdc', `${key}.json`), data);
+            return foundIds;
+        });
+        const discoveredTemplateIds = await Promise.all(entryTasks);
+        return discoveredTemplateIds.flat();
+    }
+    static async processZipMap(zipMap, idsToProcess, docConfigResponses, flags, outDir, shouldExtractTemplates) {
+        if (zipMap.size === 0) {
+            await ButlerPbExport.writeBackendOnly(idsToProcess, docConfigResponses, outDir);
+            return [];
         }
-        else {
-            zipMap = new Map();
+        if (flags.unzip) {
+            logger_1.Logger.info(constants_1.MESSAGE.UNZIP_FILES, ButlerPbExport.isLogsActive);
+            const discoveredTemplateIds = await ButlerPbExport.processZipMapUnzip(zipMap, idsToProcess, docConfigResponses, outDir, shouldExtractTemplates);
+            logger_1.Logger.success(constants_1.MESSAGE.ARCHIVE_UNZIPPED, ButlerPbExport.isLogsActive);
+            return discoveredTemplateIds;
         }
-        if (ButlerPbExport.isLogsActive)
-            ButlerPbExport.log(MSG_FOLDER_CREATED.replace('[VALUE]', `./${outDir}/sfdc`));
-        await fs_1.promises.mkdir(`./${outDir}/sfdc`, { recursive: true });
-        if (ButlerPbExport.isLogsActive) {
-            try {
-                await fs_1.promises.access(`./${outDir}`, fs_1.promises.constants.R_OK | fs_1.promises.constants.W_OK);
-                ButlerPbExport.log(MSG_USER_HAS_PERMISSIONS);
+        logger_1.Logger.info(constants_1.MESSAGE.SAVE_AS_ZIP, ButlerPbExport.isLogsActive);
+        const discoveredTemplateIds = await ButlerPbExport.processZipMapZip(zipMap, idsToProcess, docConfigResponses, flags, outDir, shouldExtractTemplates);
+        logger_1.Logger.success(constants_1.MESSAGE.ARCHIVE_RECORDED);
+        return discoveredTemplateIds;
+    }
+    async run() {
+        const parsed = (await this.parse(ButlerPbExport));
+        const flags = parsed.flags;
+        ButlerPbExport.isLogsActive = Boolean(flags.logs);
+        const outDir = flags.out;
+        const isUseShortPath = Boolean(flags.shortpaths);
+        const shouldExtractTemplates = Boolean(flags.templates);
+        const targetUsername = flags.target ?? '';
+        const session = flags.session ?? '';
+        const instance = flags.instance ?? '';
+        const connection = await (0, authentication_1.authenticate)(targetUsername, session, instance);
+        const initialBatch = ButlerPbExport.getDocConfigIds(flags.id);
+        let result = Buffer.from('');
+        const processBatch = async (batch) => {
+            const idsToProcess = batch.filter((id) => !this.processedIds.has(id));
+            if (idsToProcess.length === 0)
+                return;
+            for (const id of idsToProcess) {
+                this.processedIds.add(id);
             }
-            catch (err) {
-                ButlerPbExport.log(MSG_USER_HAS_NO_PERMISSIONS);
+            const uniqueIds = Array.from(new Set(idsToProcess));
+            const docConfigResponses = await ButlerPbExport.getDocConfigs(uniqueIds, connection);
+            logger_1.Logger.info(constants_1.MESSAGE.EXPORTED_DOC_CONFIGS.replace('[VALUE]', docConfigResponses.length.toString()), ButlerPbExport.isLogsActive);
+            if (docConfigResponses.length < 1) {
+                throw new Error(constants_1.ERROR.NO_MATCHING_DOC_CONFIGS);
             }
-        }
-        if (zipMap.size > 0) {
-            if (flags.unzip) {
-                if (ButlerPbExport.isLogsActive)
-                    ButlerPbExport.log(MSG_UNZIP_FILES);
-                const extractionAndWritePromises = Array.from(zipMap.entries()).map(async ([key, value]) => {
-                    ButlerPbExport.convertBufferToUtf8(value).extractAllTo(`./${outDir}/${key}`, false);
-                    const filePath = `./${outDir}/sfdc/${key}.json`;
-                    const data = JSON.stringify(docConfigResponses[docConfigIds.indexOf(key)], null, 2);
-                    await fs_1.promises.writeFile(filePath, data);
-                });
-                await Promise.all(extractionAndWritePromises);
-                if (ButlerPbExport.isLogsActive)
-                    ButlerPbExport.log(MSG_ARCHIVE_UNZIPPED);
+            const { zipMap, lastBuffer } = await ButlerPbExport.fetchBackendZips(uniqueIds, flags, isUseShortPath);
+            if (lastBuffer.length > 0) {
+                result = lastBuffer;
             }
-            else {
-                if (ButlerPbExport.isLogsActive)
-                    ButlerPbExport.log(MSG_SAVE_AS_ZIP);
-                const zipAndWritePromises = Array.from(zipMap.entries()).map(async ([key, value]) => {
-                    const zipToExport = new AdmZip();
-                    for (const entry of value.getEntries()) {
-                        let entryName = entry.entryName;
-                        const fileName = entryName.substring(Number(entryName.lastIndexOf('/')) + 1, entryName.lastIndexOf('.'));
-                        entryName = flags.cut ?
-                            entryName.replace(fileName, fileName.substring(0, CUT_AFTER))
-                            : entryName;
-                        zipToExport.addFile(entryName, value.readFile(entry));
-                    }
-                    zipToExport.addFile('sfdc/docconfig.json', Buffer.from(JSON.stringify(docConfigResponses[docConfigIds.indexOf(key)], null, 2)));
-                    const zipPromise = fs_1.promises.writeFile(`./${outDir}/${key}.zip`, zipToExport.toBuffer());
-                    const jsonPromise = fs_1.promises.writeFile(`./${outDir}/sfdc/${key}.json`, JSON.stringify(docConfigResponses[docConfigIds.indexOf(key)], null, 2));
-                    await Promise.all([zipPromise, jsonPromise]);
-                });
-                await Promise.all(zipAndWritePromises);
-                if (ButlerPbExport.isLogsActive)
-                    ButlerPbExport.log(MSG_ARCHIVE_RECORDED);
+            await node_fs_1.promises.mkdir(path.join(outDir, 'sfdc'), { recursive: true });
+            await ButlerPbExport.logPermissionStatus(outDir);
+            const discoveredTemplateIds = await ButlerPbExport.processZipMap(zipMap, uniqueIds, docConfigResponses, flags, outDir, shouldExtractTemplates);
+            const nextBatch = discoveredTemplateIds.filter((id) => !this.processedIds.has(id));
+            if (nextBatch.length > 0) {
+                logger_1.Logger.info(constants_1.MESSAGE.NEW_TEMPLATES_FOUND.replace('[VALUE]', nextBatch.length.toString()), ButlerPbExport.isLogsActive);
             }
-        }
-        else {
-            const writePromises = docConfigIds.map(async (docConfigId) => {
-                const filePath = `./${outDir}/sfdc/${docConfigId}.json`;
-                const data = JSON.stringify(docConfigResponses[docConfigIds.indexOf(docConfigId)], null, 2);
-                await fs_1.promises.writeFile(filePath, data);
-            });
-            await Promise.all(writePromises);
-            if (ButlerPbExport.isLogsActive)
-                ButlerPbExport.log(MSG_SAVE_BACKEND);
-        }
+            await processBatch(nextBatch);
+        };
+        await processBatch(initialBatch);
         return result;
     }
 }
-ButlerPbExport.summary = messages.getMessage('summary');
-ButlerPbExport.description = messages.getMessage('description');
-ButlerPbExport.examples = messages.getMessages('examples');
-ButlerPbExport.flags = {
-    name: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.name.summary'),
-        description: messages.getMessage('flags.name.description'),
-        char: 'n',
-        required: false,
-    }),
-    target: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.target.summary'),
-        char: 't',
-        required: false,
-    }),
-    id: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.id.summary'),
-        char: 'i',
-        required: true,
-    }),
-    out: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.out.summary'),
-        // eslint-disable-next-line sf-plugin/dash-o
-        char: 'o',
-        required: true,
-    }),
-    backend: sf_plugins_core_1.Flags.boolean({
-        summary: messages.getMessage('flags.backend.summary'),
-        char: 'b',
-    }),
-    'auth-env-var': sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.auth-env-var.summary'),
-        char: 'a',
-    }),
-    endpoint: sf_plugins_core_1.Flags.url({
-        summary: messages.getMessage('flags.endpoint.summary'),
-        char: 'e',
-    }),
-    stage: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.stage.summary'),
-        char: 's',
-        required: true,
-    }),
-    unzip: sf_plugins_core_1.Flags.boolean({
-        summary: messages.getMessage('flags.unzip.summary'),
-        char: 'u',
-    }),
-    logs: sf_plugins_core_1.Flags.boolean({
-        summary: messages.getMessage('flags.logs.summary'),
-        char: 'l',
-    }),
-    partial: sf_plugins_core_1.Flags.boolean({
-        summary: messages.getMessage('flags.partial.summary'),
-        char: 'p',
-    }),
-    session: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.session.summary'),
-    }),
-    instance: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.instance.summary'),
-    }),
-    cut: sf_plugins_core_1.Flags.boolean({
-        summary: messages.getMessage('flags.cut.summary'),
-        char: 'c',
-    }),
-    shortpaths: sf_plugins_core_1.Flags.boolean({
-        summary: messages.getMessage('flags.shortpaths.summary'),
-    }),
-};
-ButlerPbExport.isLogsActive = false;
 exports.default = ButlerPbExport;
 //# sourceMappingURL=export.js.map