@pdfbutler/migration-cli 0.0.26 → 0.0.28

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

@@ -1,33 +1,124 @@
 "use strict";
+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/restrict-template-expressions */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable no-console */
 const path = require("path");
 const fs = require("graceful-fs");
 const sf_plugins_core_1 = require("@salesforce/sf-plugins-core");
 const core_1 = require("@salesforce/core");
 const FormData = require("form-data");
 const AdmZip = require("adm-zip");
-const got_1 = require("got");
-const jsforce = require('jsforce');
-const MSG_CONNECTION_FAILED = 'Connection to Salesforce has been failed.';
-const MSG_CREATION_CONNECTION = 'Creating Connection with the Salesforce org.';
-const MSG_AUTHORIZATION = 'Authorization with the username: [VALUE].';
-const MSG_NO_AUTH_PARAMS = 'No authentication parameters provided. Please provide either username or session and instance parameters.';
-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 RESULT_STATUS_FAILED = 'FAILED';
-const RESULT_STATUS_SUCCESS = 'SUCCESS';
-const RESULT_STATUS_SUCCESS_WITH_WARNINGS = 'SUCCESS_WITH_WARNINGS';
+const got_1 = __importDefault(require("got"));
+const logger_1 = require("../../../utils/logger");
+const authentication_1 = require("../../../utils/authentication");
+const constants_1 = require("../../../utils/constants");
+const extract_templates_1 = require("../../../utils/extract-templates");
 core_1.Messages.importMessagesDirectory(__dirname);
 const messages = core_1.Messages.loadMessages('@pdfbutler/migration-cli', 'butler.pb.import');
 class ButlerPbImport 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,
+        }),
+        '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',
+        }),
+        config: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.config.summary'),
+            char: 'f',
+            required: true,
+        }),
+        logs: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.logs.summary'),
+            char: 'l',
+        }),
+        id: sf_plugins_core_1.Flags.string({
+            summary: messages.getMessage('flags.id.summary'),
+            char: 'i',
+            required: true,
+        }),
+        clone: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.clone.summary'),
+            char: 'c',
+        }),
+        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'),
+        }),
+        templates: sf_plugins_core_1.Flags.boolean({
+            summary: messages.getMessage('flags.templates.summary'),
+            char: 'm',
+        }),
+    };
+    static isLogsActive = false;
+    static logIdMappings(entity, idMap) {
+        if (!ButlerPbImport.isLogsActive)
+            return;
+        for (const [oldId, newId] of Object.entries(idMap)) {
+            if (!oldId || !newId || oldId === newId)
+                continue;
+            logger_1.Logger.info(constants_1.MESSAGE.DOC_CONFIG_ID_MAPPED_BLOCK.replace('[ENTITY]', entity)
+                .replace('[OLD_ID]', oldId)
+                .replace('[NEW_ID]', newId));
+        }
+    }
+    static applyIdMap(value, idMap) {
+        if (Array.isArray(value)) {
+            return value.map((item) => ButlerPbImport.applyIdMap(item, idMap));
+        }
+        if (value && typeof value === 'object') {
+            const entries = Object.entries(value);
+            const next = {};
+            for (const [key, val] of entries) {
+                next[key] = ButlerPbImport.applyIdMap(val, idMap);
+            }
+            return next;
+        }
+        if (typeof value === 'string' && idMap[value]) {
+            return idMap[value];
+        }
+        return value;
+    }
+    static updateZipJsonEntries(zip, idMap) {
+        if (Object.keys(idMap).length === 0)
+            return;
+        for (const entry of zip.getEntries()) {
+            if (!entry.entryName.endsWith('.json'))
+                continue;
+            try {
+                const raw = zip.readFile(entry).toString('utf8');
+                const json = JSON.parse(raw);
+                const updated = ButlerPbImport.applyIdMap(json, idMap);
+                zip.updateFile(entry, Buffer.from(JSON.stringify(updated, null, 2)));
+            }
+            catch (e) {
+                // ignore non-JSON or invalid JSON files
+            }
+        }
+    }
     static getTargetPath(recordType) {
         switch (recordType) {
             case 'EXCEL':
@@ -43,25 +134,82 @@ class ButlerPbImport extends sf_plugins_core_1.SfCommand {
             case 'CSV':
                 return 'config/csv/import-config';
         }
-        throw new Error('Unsupported record type');
+        throw new Error(constants_1.ERROR.UNSUPPORTED_RECORD_TYPE);
+    }
+    static getMainZipPath(configDir, docConfigId) {
+        const zipPath = path.join(configDir, `${docConfigId}.zip`);
+        if (fs.existsSync(zipPath))
+            return zipPath;
+        const folderPath = path.join(configDir, docConfigId);
+        if (fs.existsSync(folderPath))
+            return folderPath;
+        return undefined;
     }
-    static getFiles(dir, docConfigIds, files) {
-        const fileList = fs.readdirSync(dir, { withFileTypes: true });
-        for (const file of fileList) {
-            const name = `${dir}/${file.name}`;
-            if (fs.statSync(name).isDirectory() && file.name === 'sfdc') {
-                ButlerPbImport.getFiles(name, docConfigIds, files);
+    static async importSfdcJsons(connection, jsonPaths, isClone, idMap = {}) {
+        if (jsonPaths.length === 0)
+            return {};
+        const responses = await Promise.all(jsonPaths.map(async (jsonFile) => {
+            const sfdcConfig = JSON.parse(await fs.promises.readFile(jsonFile, 'utf8'));
+            const transformedConfig = ButlerPbImport.applyIdMap(sfdcConfig, idMap);
+            return connection.apex.post(`/cadmus_core/DocConfig/Import/?isInsert=${isClone ? 'true' : 'false'}`, transformedConfig, { headers: { 'content-type': 'application/json' } });
+        }));
+        const responseIdMap = {};
+        for (const element of responses) {
+            if (typeof element === 'object' && element !== null) {
+                for (const [key, value] of Object.entries(element)) {
+                    if (typeof value === 'string')
+                        responseIdMap[key] = value;
+                }
             }
-            else {
-                if (!docConfigIds.includes(path.parse(file.name).name))
-                    continue;
-                files.push(name);
+        }
+        return responseIdMap;
+    }
+    static async sendZip(zipName, baseUrl, base64Auth, stage, idMap, shouldClone) {
+        let zip = new AdmZip();
+        if (zipName.endsWith('zip')) {
+            zip = new AdmZip(zipName);
+        }
+        else {
+            zip.addLocalFolder(zipName);
+        }
+        const zipToSend = new AdmZip();
+        for (const entry of zip.getEntries()) {
+            if (entry != null) {
+                zipToSend.addFile(entry.entryName, zip.readFile(entry));
             }
         }
-        if (files.length <= 0) {
-            throw new Error('No matching files found');
+        ButlerPbImport.updateZipJsonEntries(zipToSend, idMap);
+        const txt = zipToSend.readAsText('doc-config.json');
+        const recordType = JSON.parse(txt).recordType;
+        const targetPath = ButlerPbImport.getTargetPath(recordType);
+        const finalUrl = `${baseUrl}${targetPath}`;
+        const fd = new FormData();
+        fd.append('zip', zipToSend.toBuffer(), { filename: 'zip' });
+        fd.append('metadata', JSON.stringify({
+            stage,
+            version: 'v10.0',
+        }), { contentType: 'application/json' });
+        const res = await got_1.default.post(finalUrl, {
+            body: fd,
+            headers: { Authorization: `Basic ${base64Auth}` },
+            responseType: 'json',
+        });
+        const body = res.body;
+        const description = String(body?.issues?.[0]?.description ?? constants_1.MESSAGE.UNDEFINED);
+        switch (ButlerPbImport.getLogLvl(body?.result)) {
+            case 'info':
+                logger_1.Logger.info(description);
+                break;
+            case 'success':
+                logger_1.Logger.success(description);
+                break;
+            default:
+                if (!shouldClone) {
+                    logger_1.Logger.warn(constants_1.MESSAGE.CLONE_LINKED_ORGS_WARNING);
+                }
+                logger_1.Logger.error(description);
+                break;
         }
-        return files;
     }
     static getDocConfigIds(id) {
         const docConfigIds = id.split(/([\w-]{36})/).filter((n) => n);
@@ -71,274 +219,259 @@ class ButlerPbImport extends sf_plugins_core_1.SfCommand {
             }
         });
         if (docConfigIds.length <= 0) {
-            throw new Error('No matching Doc Configs ids found');
+            throw new Error(constants_1.ERROR.NO_MATCHING_DOC_CONFIGS);
         }
         return docConfigIds;
     }
-    static isBlank(value) {
-        return value?.trim() === ''
-            || value === null
-            || value === undefined;
-    }
-    static log(message, type = 'info') {
-        let prefix = '';
-        let color = '';
-        switch (type) {
-            case 'error':
-                prefix = '[ERROR]';
-                color = this.colors.red;
-                break;
-            case 'success':
-                prefix = '[SUCCESS]';
-                color = this.colors.green;
-                break;
-            default:
-                prefix = '[INFO]';
-                color = this.colors.reset;
-                break;
+    static getLogLvl(result) {
+        if (result === constants_1.RESULT.FAILED) {
+            return 'error';
         }
-        console.log(`${color}${prefix} ${message}${this.colors.reset}`);
-    }
-    static async authenticateWithTarget(username) {
-        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;
-        }
-        catch (error) {
-            this.log(MSG_RUN_AUTH_COMMAND, 'error');
-            throw new Error(MSG_CONNECTION_FAILED);
+        else if (result === constants_1.RESULT.SUCCESS || result === constants_1.RESULT.SUCCESS_WITH_WARNINGS) {
+            return 'success';
+        }
+        else {
+            return 'info';
         }
     }
-    static async authenticateWitsSession(session, instance) {
-        if (!this.isBlank(instance) && !this.isBlank(session)) {
-            const connection = await new jsforce.Connection({
-                instanceUrl: `${instance}`,
-                sessionId: `${session}`,
-            });
-            this.log(`Connected to ${connection.instanceUrl}`);
-            return connection;
+    static buildEndpointAuth(flags) {
+        if (flags.endpoint && !flags['auth-env-var']) {
+            logger_1.Logger.error(constants_1.ERROR.AUTH_ENV_VAR_REQUIRED);
+            return null;
         }
-        else if (!this.isBlank(session) && this.isBlank(instance)) {
-            this.log('Instance URL (--instance) cannot be empty', 'error');
+        const auth = flags['auth-env-var'];
+        let base64Auth = auth ?? '';
+        if (auth?.indexOf(':')) {
+            base64Auth = Buffer.from(auth).toString('base64');
         }
-        else if (this.isBlank(session) && !this.isBlank(instance)) {
-            this.log('Session Id (--session) cannot be empty', 'error');
+        const baseUrl = flags.endpoint ? `${flags.endpoint.toString()}` : '';
+        if (flags.endpoint && ButlerPbImport.isLogsActive) {
+            logger_1.Logger.info(constants_1.MESSAGE.ENDPOINT_URL.replace('[URL]', baseUrl));
         }
-        else {
-            this.log('Session Id and Instance URL (--session and --instance) cannot be empty', 'error');
+        return { baseUrl, base64Auth };
+    }
+    static getTemplatePaths(configDir, templateIds) {
+        const templateJsonPaths = templateIds
+            .map((id) => path.join(configDir, 'sfdc', `${id}.json`))
+            .filter((p) => fs.existsSync(p));
+        const templateZipTargets = templateIds
+            .map((id) => ButlerPbImport.getMainZipPath(configDir, id))
+            .filter((p) => typeof p === 'string' && fs.existsSync(p));
+        return { templateJsonPaths, templateZipTargets };
+    }
+    static extractTemplateIdsFromZip(zipPath) {
+        const templateIds = new Set();
+        const validRecordTypes = ['DOCUMENT_V3', 'DOCUMENT_V2', 'DOCUMENT_V1'];
+        const zip = new AdmZip(zipPath);
+        const collectFromRecord = (value) => {
+            if (!value || typeof value !== 'object')
+                return;
+            const rec = value;
+            const recordType = rec.recordType;
+            const templateId = rec.documentConfigTemplateId;
+            if (typeof recordType === 'string' && validRecordTypes.includes(recordType)) {
+                if (typeof templateId === 'string')
+                    templateIds.add(templateId);
+            }
+        };
+        for (const entry of zip.getEntries()) {
+            if (entry.isDirectory)
+                continue;
+            if (!entry.entryName.includes('ConfigTypes/') || !entry.entryName.endsWith('.json'))
+                continue;
+            try {
+                const raw = zip.readFile(entry);
+                if (!raw)
+                    continue;
+                const json = JSON.parse(raw.toString('utf8'));
+                const records = Array.isArray(json) ? json : [json];
+                for (const rec of records) {
+                    collectFromRecord(rec);
+                }
+            }
+            catch (e) {
+                logger_1.Logger.error(constants_1.MESSAGE.JSON_PARSE_FAILED.replace('[PATH]', entry.entryName));
+            }
         }
-        this.log(MSG_CHECK_SESSION_INSTANCE, 'error');
-        throw new Error(MSG_CONNECTION_FAILED);
+        return Array.from(templateIds);
     }
-    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 getTemplateIdsFromMain(mainZipPath) {
+        if (mainZipPath.endsWith('.zip')) {
+            return ButlerPbImport.extractTemplateIdsFromZip(mainZipPath);
         }
+        return (0, extract_templates_1.extractTemplateIds)(mainZipPath);
+    }
+    static async processTemplates(params) {
+        const { connection, templateIds, cloneTemplates, shouldClone, baseUrl, base64Auth, stage, hasEndpoint, configDir, } = params;
+        if (templateIds.length === 0)
+            return {};
+        const { templateJsonPaths, templateZipTargets } = ButlerPbImport.getTemplatePaths(configDir, templateIds);
+        let templateIdMap = {};
         try {
-            if (this.isBlank(session) || this.isBlank(instance)) {
-                connection = await this.authenticateWithTarget(username);
-            }
-            else {
-                connection = await this.authenticateWitsSession(session, instance);
+            if (ButlerPbImport.isLogsActive)
+                logger_1.Logger.info(constants_1.MESSAGE.IMPORT_TEMPLATES_SFDC);
+            templateIdMap = await ButlerPbImport.importSfdcJsons(connection, templateJsonPaths, cloneTemplates);
+            if (templateJsonPaths.length > 0 && ButlerPbImport.isLogsActive) {
+                logger_1.Logger.success(constants_1.MESSAGE.SUCCESS_DATA_WRITTEN);
             }
-            return connection;
         }
-        catch (error) {
-            throw new Error(MSG_CONNECTION_FAILED);
+        catch (e) {
+            throw new Error(constants_1.ERROR.WRITE_DATA);
         }
-    }
-    static getLogLvl(result) {
-        if (result === RESULT_STATUS_FAILED) {
-            return 'error';
+        if (hasEndpoint && templateZipTargets.length > 0) {
+            if (ButlerPbImport.isLogsActive)
+                logger_1.Logger.info(constants_1.MESSAGE.IMPORT_TEMPLATES_ZIP);
+            await templateZipTargets.reduce(async (previous, zipTarget, index) => {
+                await previous;
+                try {
+                    if (ButlerPbImport.isLogsActive) {
+                        const templateId = path.parse(zipTarget).name;
+                        logger_1.Logger.info(constants_1.MESSAGE.IMPORTING_ZIP_PROGRESS.replace('[INDEX]', String(index + 1))
+                            .replace('[COUNT]', String(templateZipTargets.length))
+                            .replace('[ID]', templateId));
+                        const mappedTemplateId = templateIdMap[templateId] ?? templateId;
+                        ButlerPbImport.logIdMappings('Template DocConfig', { [templateId]: mappedTemplateId });
+                    }
+                    await ButlerPbImport.sendZip(zipTarget, baseUrl, base64Auth, stage, cloneTemplates ? templateIdMap : {}, shouldClone);
+                }
+                catch (e) {
+                    throw new Error(constants_1.ERROR.WRITE_DATA_TO_PDF);
+                }
+            }, Promise.resolve());
         }
-        else if (result === RESULT_STATUS_SUCCESS || RESULT_STATUS_SUCCESS_WITH_WARNINGS) {
-            return 'success';
+        return templateIdMap;
+    }
+    static async importMainSfdc(connection, mainJsonPath, shouldClone, idMap) {
+        try {
+            if (ButlerPbImport.isLogsActive)
+                logger_1.Logger.info(constants_1.MESSAGE.IMPORT_MAIN_SFDC);
+            const mainIdMap = await ButlerPbImport.importSfdcJsons(connection, [mainJsonPath], shouldClone, idMap);
+            if (ButlerPbImport.isLogsActive)
+                logger_1.Logger.success(constants_1.MESSAGE.SUCCESS_DATA_WRITTEN);
+            return mainIdMap;
         }
-        else {
-            return 'info';
+        catch (e) {
+            throw new Error(constants_1.ERROR.WRITE_DATA);
         }
     }
-    async run() {
-        const { flags } = await this.parse(ButlerPbImport);
-        const docConfigIds = ButlerPbImport.getDocConfigIds(flags.id);
-        const zipArray = [];
-        const jsonArray = [];
-        const files = ButlerPbImport.getFiles(flags.config, docConfigIds, []);
-        ButlerPbImport.isLogsActive = flags.logs;
-        await Promise.all(files.map((fileName) => {
-            const fullPath = fileName;
-            if (fileName.endsWith('.json')) {
-                jsonArray.push(fullPath);
-            }
-            else {
-                zipArray.push(fullPath);
-            }
-        }));
-        const targetUsername = flags.target;
-        const session = flags.session;
-        const instance = flags.instance;
-        const connection = await ButlerPbImport.authenticate(targetUsername, session, instance);
-        let responses;
+    static async sendMainZip(params) {
+        const { sourceMainId, mainId, mainZipPath, baseUrl, base64Auth, stage, idMap, shouldClone } = params;
         try {
-            if (jsonArray.length > 0) {
-                // eslint-disable-next-line @typescript-eslint/no-misused-promises
-                responses = await Promise.all(jsonArray.map(async (jsonFile) => {
-                    const sfdcConfig = JSON.parse(await fs.promises.readFile(jsonFile, 'utf8'));
-                    return connection.apex.post(`/cadmus_core/DocConfig/Import/?isInsert=${flags.clone === undefined ? 'false' : 'true'}`, sfdcConfig, {
-                        headers: { 'content-type': 'application/json' },
-                    })
-                        .then((data) => data);
-                }));
-                if (ButlerPbImport.isLogsActive)
-                    ButlerPbImport.log('Data successfully written to the target Salesforce org');
+            if (ButlerPbImport.isLogsActive) {
+                logger_1.Logger.info(constants_1.MESSAGE.IMPORTING_ZIP_WITH_ID.replace('[ID]', mainId));
+                ButlerPbImport.logIdMappings('Main DocConfig', { [sourceMainId]: mainId });
             }
+            await ButlerPbImport.sendZip(mainZipPath, baseUrl, base64Auth, stage, idMap, shouldClone);
         }
         catch (e) {
-            throw new Error('Failed to write data to the target Salesforce org');
+            throw new Error(constants_1.ERROR.WRITE_DATA_TO_PDF);
         }
-        if (ButlerPbImport.isLogsActive)
-            ButlerPbImport.log(`zipArray.length - ${zipArray.length}`);
-        if (zipArray.length === 0 || !flags.endpoint) {
-            return { success: false };
+    }
+    static async processMainImport(params) {
+        const { connection, flags, mainId, index, total, baseUrl, base64Auth, cloneTemplates, shouldClone, shouldProcessTemplates, globalTemplateIdMap, } = params;
+        if (ButlerPbImport.isLogsActive) {
+            logger_1.Logger.info(constants_1.MESSAGE.START_IMPORT_MAIN.replace('[INDEX]', String(index))
+                .replace('[COUNT]', String(total))
+                .replace('[ID]', mainId));
+        }
+        const mainJsonPath = path.join(flags.config, 'sfdc', `${mainId}.json`);
+        if (!fs.existsSync(mainJsonPath)) {
+            throw new Error(constants_1.ERROR.NO_MATCHING_FILES);
         }
-        if (flags.endpoint) {
-            if (!flags['auth-env-var']) {
-                ButlerPbImport.log('auth-env-var parameter is required when endpoint is provided', 'error');
-                return { success: false };
+        const mainZipPath = ButlerPbImport.getMainZipPath(flags.config, mainId);
+        let templateIdMap = {};
+        if (mainZipPath) {
+            const foundTemplateIds = await ButlerPbImport.getTemplateIdsFromMain(mainZipPath);
+            const existingTemplateMap = {};
+            for (const id of foundTemplateIds) {
+                if (globalTemplateIdMap[id])
+                    existingTemplateMap[id] = globalTemplateIdMap[id];
             }
-            const auth = flags['auth-env-var'];
-            let base64Auth = auth;
-            if (auth?.indexOf(':')) {
-                base64Auth = Buffer.from(auth).toString('base64');
+            templateIdMap = { ...existingTemplateMap };
+            if (shouldClone && !shouldProcessTemplates && foundTemplateIds.length > 0) {
+                logger_1.Logger.warn(constants_1.MESSAGE.TEMPLATES_DETECTED_WARNING.replace('[ID]', mainId).replace('[TEMPLATES]', foundTemplateIds.join(', ')));
             }
-            const baseUrl = `${flags.endpoint.toString()}`;
-            if (ButlerPbImport.isLogsActive)
-                ButlerPbImport.log(`Endpoint base URL - ${baseUrl}`);
-            zipArray.map(async (zipName) => {
-                let zip = new AdmZip();
-                if (zipName.endsWith('zip')) {
-                    zip = new AdmZip(zipName);
-                }
-                else {
-                    zip.addLocalFolder(zipName);
-                }
-                const zipToSend = new AdmZip();
-                for (const entry of zip.getEntries()) {
-                    if (entry != null) {
-                        zipToSend.addFile(entry.entryName, zip.readFile(entry));
-                        if (flags.clone && entry.entryName === 'doc-config.json') {
-                            const fileContent = zip.readFile(entry);
-                            /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-                            const docConfig = JSON.parse(fileContent.toString('utf-8'));
-                            responses.forEach((element) => {
-                                if (typeof element === 'object' && element !== null) {
-                                    const elementObj = element;
-                                    if (elementObj[docConfig.customerDocumentConfigId] !== undefined) {
-                                        docConfig.customerDocumentConfigId = elementObj[docConfig.customerDocumentConfigId];
-                                    }
-                                }
-                            });
-                            zipToSend.updateFile(entry, Buffer.from(JSON.stringify(docConfig)));
-                        }
+            if (shouldProcessTemplates) {
+                const newTemplateIds = foundTemplateIds.filter((id) => !globalTemplateIdMap[id]);
+                if (ButlerPbImport.isLogsActive) {
+                    if (foundTemplateIds.length > 0) {
+                        logger_1.Logger.info(constants_1.MESSAGE.FOUND_TEMPLATES.replace('[COUNT]', String(foundTemplateIds.length)));
+                    }
+                    else {
+                        logger_1.Logger.info(constants_1.MESSAGE.NO_TEMPLATES_FOUND);
                     }
                 }
-                const txt = zip.readAsText('doc-config.json');
-                if (ButlerPbImport.isLogsActive)
-                    ButlerPbImport.log(`doc-config.json length - ${txt.length}`);
-                const recordType = JSON.parse(txt).recordType;
-                const targetPath = ButlerPbImport.getTargetPath(recordType);
-                const finalUrl = `${baseUrl}${targetPath}`;
-                if (ButlerPbImport.isLogsActive)
-                    ButlerPbImport.log(`Final URL - ${finalUrl}`);
-                const fd = new FormData();
-                fd.append('zip', zipToSend.toBuffer(), { filename: 'zip' });
-                fd.append('metadata', JSON.stringify({
+                const newTemplateIdMap = await ButlerPbImport.processTemplates({
+                    connection,
+                    templateIds: newTemplateIds,
+                    cloneTemplates,
+                    shouldClone,
+                    baseUrl,
+                    base64Auth,
                     stage: flags.stage,
-                    version: 'v10.0',
-                }), { contentType: 'application/json' });
-                try {
-                    const res = await got_1.default.post(finalUrl, {
-                        body: fd,
-                        headers: { Authorization: `Basic ${base64Auth}` },
-                        responseType: 'json',
-                    });
-                    const body = res.body;
-                    ButlerPbImport.log(body?.issues?.[0]?.description, ButlerPbImport.getLogLvl(body?.result));
-                }
-                catch (e) {
-                    throw new Error('Failed to write data to the PDF Butler system');
-                }
-            });
+                    hasEndpoint: Boolean(flags.endpoint),
+                    configDir: flags.config,
+                });
+                Object.assign(globalTemplateIdMap, newTemplateIdMap);
+                Object.assign(templateIdMap, newTemplateIdMap);
+            }
+        }
+        if (cloneTemplates && Object.keys(templateIdMap).length > 0 && ButlerPbImport.isLogsActive) {
+            logger_1.Logger.info(constants_1.MESSAGE.UPDATE_MAIN_WITH_TEMPLATE_IDS);
         }
+        const mainIdMap = await ButlerPbImport.importMainSfdc(connection, mainJsonPath, shouldClone, templateIdMap);
+        const importedMainId = mainIdMap[mainId] ?? mainId;
+        if (!flags.endpoint || !mainZipPath) {
+            throw new Error(constants_1.ERROR.WRITE_DATA_TO_PDF);
+        }
+        await ButlerPbImport.sendMainZip({
+            sourceMainId: mainId,
+            mainId: importedMainId,
+            mainZipPath,
+            baseUrl,
+            base64Auth,
+            stage: flags.stage,
+            idMap: { ...templateIdMap, ...mainIdMap },
+            shouldClone,
+        });
+    }
+    async run() {
+        const { flags } = (await this.parse(ButlerPbImport));
+        const docConfigIds = ButlerPbImport.getDocConfigIds(flags.id);
+        ButlerPbImport.isLogsActive = flags.logs === true;
+        if (ButlerPbImport.isLogsActive) {
+            logger_1.Logger.info(constants_1.MESSAGE.SPLITTED_DOC_CONFIGS.replace('[VALUE]', String(docConfigIds.length)));
+        }
+        const targetUsername = flags.target;
+        const session = flags.session;
+        const instance = flags.instance;
+        const connection = (await (0, authentication_1.authenticate)(targetUsername, session, instance));
+        const shouldClone = flags.clone === true;
+        const shouldProcessTemplates = flags.templates === true;
+        const cloneTemplates = shouldProcessTemplates ? shouldClone : false;
+        const endpointAuth = ButlerPbImport.buildEndpointAuth(flags);
+        if (!endpointAuth)
+            return { success: false };
+        const { baseUrl, base64Auth } = endpointAuth;
+        const globalTemplateIdMap = {};
+        await docConfigIds.reduce(async (previous, mainId, index) => {
+            await previous;
+            await ButlerPbImport.processMainImport({
+                connection,
+                flags,
+                mainId,
+                index: index + 1,
+                total: docConfigIds.length,
+                baseUrl,
+                base64Auth,
+                cloneTemplates,
+                shouldClone,
+                shouldProcessTemplates,
+                globalTemplateIdMap,
+            });
+        }, Promise.resolve());
         return { success: true };
     }
 }
-ButlerPbImport.summary = messages.getMessage('summary');
-ButlerPbImport.description = messages.getMessage('description');
-ButlerPbImport.examples = messages.getMessages('examples');
-ButlerPbImport.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,
-    }),
-    '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',
-    }),
-    config: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.config.summary'),
-        char: 'f',
-        required: true,
-    }),
-    logs: sf_plugins_core_1.Flags.boolean({
-        summary: messages.getMessage('flags.logs.summary'),
-        char: 'l',
-    }),
-    id: sf_plugins_core_1.Flags.string({
-        summary: messages.getMessage('flags.id.summary'),
-        char: 'i',
-        required: true,
-    }),
-    clone: sf_plugins_core_1.Flags.boolean({
-        // eslint-disable-next-line sf-plugin/no-missing-messages
-        summary: messages.getMessage('flags.clone.summary'),
-        char: 'c',
-    }),
-    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'),
-    }),
-};
-ButlerPbImport.colors = {
-    blue: '\x1b[34m',
-    green: '\x1b[32m',
-    red: '\x1b[31m',
-    reset: '\x1b[0m',
-};
-ButlerPbImport.isLogsActive = false;
 exports.default = ButlerPbImport;
 //# sourceMappingURL=import.js.map