mcdev 7.0.4 → 7.1.0

package/lib/index.js

@@ -17,6 +17,8 @@ import Retriever from './Retriever.js';
 import cache from './util/cache.js';
 import ReplaceContentBlockReference from './util/replaceContentBlockReference.js';
 
+import { confirm } from '@inquirer/prompts';
+
 /**
  * @typedef {import('../types/mcdev.d.js').BuObject} BuObject
  * @typedef {import('../types/mcdev.d.js').CodeExtract} CodeExtract
@@ -79,28 +81,34 @@ class Mcdev {
     static setOptions(argv) {
         const knownOptions = [
             'api',
-            'keySuffix',
             'changeKeyField',
             'changeKeyValue',
             'commitHistory',
+            'dependencies',
             'errorLog',
             'execute',
             'filter',
             'fixShared',
             'fromRetrieve',
             'json',
+            'keySuffix',
             'like',
             'noLogColors',
             'noLogFile',
-            'noMidSuffix',
+            'noUpdate',
+            'autoMidSuffix',
+            'publish',
             'referenceFrom',
             'referenceTo',
             'refresh',
-            'skipDeploy',
-            'skipRetrieve',
+            'retrieve',
             'schedule',
+            'skipDeploy',
             'skipInteraction',
+            'skipRetrieve',
+            'skipStatusCheck',
             '_runningTest',
+            '_welcomeMessageShown',
         ];
         for (const option of knownOptions) {
             if (argv[option] !== undefined) {
@@ -139,16 +147,20 @@ class Mcdev {
             return null;
         }
 
-        return argv.filter
-            ? // get source market and source BU from config
-              DevOps.getDeltaList(properties, argv.range, true, argv.filter, argv.commitHistory)
-            : // If no custom filter was provided, use deployment marketLists & templating
-              DevOps.buildDeltaDefinitions(
-                  properties,
-                  argv.range,
-                  argv.diffArr,
-                  argv.commitHistory
-              );
+        try {
+            return await (argv.filter
+                ? // get source market and source BU from config
+                  DevOps.getDeltaList(properties, argv.range, true, argv.filter, argv.commitHistory)
+                : // If no custom filter was provided, use deployment marketLists & templating
+                  DevOps.buildDeltaDefinitions(
+                      properties,
+                      argv.range,
+                      argv.diffArr,
+                      argv.commitHistory
+                  ));
+        } catch (ex) {
+            Util.logger.error(ex.message);
+        }
     }
 
     /**
@@ -189,6 +201,12 @@ class Mcdev {
      * helper to show an off-the-logs message to users
      */
     static #welcomeMessage() {
+        if (Util.OPTIONS._welcomeMessageShown) {
+            // ensure we don't spam the user in case methods are called multiple times
+            return;
+        }
+        Util.OPTIONS._welcomeMessageShown = true;
+
         const color = Util.isRunViaVSCodeExtension
             ? { reset: '', bgWhite: '', fgBlue: '' }
             : Util.color;
@@ -482,7 +500,11 @@ class Mcdev {
         Util.startLogger();
         Util.logger.info('mcdev:: Setting up project');
         const properties = await config.getProperties(!!credentialsName, true);
-        await Init.initProject(properties, credentialsName);
+        try {
+            await Init.initProject(properties, credentialsName);
+        } catch (ex) {
+            Util.logger.error(ex.message);
+        }
     }
     /**
      * Clones an existing project from git repository and installs it
@@ -492,7 +514,11 @@ class Mcdev {
     static async joinProject() {
         Util.startLogger();
         Util.logger.info('mcdev:: Joining an existing project');
-        await Init.joinProject();
+        try {
+            await Init.joinProject();
+        } catch (ex) {
+            Util.logger.error(ex.message);
+        }
     }
 
     /**
@@ -706,6 +732,54 @@ class Mcdev {
             }
         }
     }
+    /**
+     * method for contributors to get details on SOAP objects
+     *
+     * @param {string} type references credentials from properties.json
+     * @param {string} [businessUnit] defaults to first credential's ParentBU
+     * @returns {Promise.<void>} -
+     */
+    static async describeSoap(type, businessUnit) {
+        Util.startLogger();
+        Util.logger.info('mcdev:: describe SOAP');
+        const properties = await config.getProperties();
+        if (!(await config.checkProperties(properties))) {
+            return null;
+        }
+        const credential = Object.keys(properties.credentials)[0];
+        businessUnit ||=
+            credential + '/' + Object.keys(properties.credentials[credential].businessUnits)[0];
+        const buObject = await Cli.getCredentialObject(properties, businessUnit);
+        if (!buObject) {
+            return;
+        }
+        try {
+            const client = auth.getSDK(buObject);
+            const response = await client.soap.describe(type);
+            if (response?.ObjectDefinition?.Properties) {
+                Util.logger.info(
+                    `Properties for SOAP object ${response.ObjectDefinition.ObjectType}:`
+                );
+                const properties = response.ObjectDefinition.Properties.map((prop) => {
+                    delete prop.PartnerKey;
+                    delete prop.ObjectID;
+                    return prop;
+                });
+                if (Util.OPTIONS.json) {
+                    console.log(JSON.stringify(properties, null, 2)); // eslint-disable-line no-console
+                } else {
+                    console.table(properties); // eslint-disable-line no-console
+                }
+                return properties;
+            } else {
+                throw new Error(
+                    `Soap object ${type} not found. Please check the spelling and retry`
+                );
+            }
+        } catch (ex) {
+            Util.logger.error(ex.message);
+        }
+    }
 
     /**
      * Converts metadata to legacy format. Output is saved in 'converted' directory
@@ -821,6 +895,172 @@ class Mcdev {
             }
         }
     }
+    /**
+     * @param {string} businessUnit references credentials from properties.json
+     * @param {TypeKeyCombo} selectedTypes limit retrieval to given metadata type
+     * @returns {Promise.<TypeKeyCombo>} selected types including dependencies
+     */
+    static async addDependentCbReferences(businessUnit, selectedTypes) {
+        if (!Util.OPTIONS.dependencies) {
+            return;
+        }
+        const initialAssetNumber = selectedTypes['asset']?.length || 0;
+        const properties = await config.getProperties();
+        const buObject = await Cli.getCredentialObject(properties, businessUnit);
+        Util.logger.info(
+            'Searching for additional dependencies that were linked via ContentBlockByKey, ContentBlockByName and ContentBlockById'
+        );
+
+        await ReplaceContentBlockReference.createCacheMap(properties, buObject, true);
+
+        // because we re-use the replaceReference logic here we need to manually set this value
+        /** @type {ContentBlockConversionTypes[]} */
+        Util.OPTIONS.referenceFrom = ['key', 'name', 'id'];
+        /** @type {ContentBlockConversionTypes} */
+        Util.OPTIONS.referenceTo = 'key';
+
+        /** @type {Set.<string>} */
+        const assetDependencies = new Set();
+        const retrieveDir = File.filterIllegalPathChars(
+            File.normalizePath([
+                properties.directories.retrieve,
+                buObject.credential,
+                buObject.businessUnit,
+            ])
+        );
+        // check all non-asset types for dependencies
+        for (const depType in selectedTypes) {
+            if (
+                !Object.prototype.hasOwnProperty.call(
+                    MetadataTypeInfo[depType],
+                    'replaceCbReference'
+                ) ||
+                depType === 'asset'
+            ) {
+                continue;
+            }
+            MetadataTypeInfo[depType].properties = properties;
+            MetadataTypeInfo[depType].buObject = buObject;
+            await MetadataTypeInfo[depType].getCbReferenceKeys(
+                selectedTypes[depType],
+                retrieveDir,
+                assetDependencies
+            );
+        }
+        // add dependencies to selectedTypes
+        if (assetDependencies.size) {
+            const depType = 'asset';
+            if (selectedTypes[depType]) {
+                selectedTypes[depType].push(...assetDependencies);
+            } else {
+                selectedTypes[depType] = [...assetDependencies];
+            }
+            // remove duplicates in main object after adding dependencies
+            selectedTypes[depType] = [...new Set(selectedTypes[depType])];
+        }
+
+        // check all assets for dependencies recursively
+        if (selectedTypes.asset?.length) {
+            const depType = 'asset';
+            const Asset = MetadataTypeInfo[depType];
+            Asset.properties = properties;
+            Asset.buObject = buObject;
+            const additionalAssetDependencies = [
+                ...(await Asset.getCbReferenceKeys(
+                    selectedTypes[depType],
+                    retrieveDir,
+                    new Set(selectedTypes[depType])
+                )),
+            ];
+            if (additionalAssetDependencies.length) {
+                Util.logger.info(
+                    `Found ${additionalAssetDependencies.length - initialAssetNumber} additional assets linked via ContentBlockByX.`
+                );
+            }
+            // reset cache in case this is used progammatically somehow
+            Asset.getJsonFromFSCache = null;
+
+            // remove duplicates in main object after adding dependencies
+            selectedTypes[depType] = [...new Set(selectedTypes[depType])];
+        }
+
+        return selectedTypes;
+    }
+
+    /**
+     *
+     * @param {string} businessUnit references credentials from properties.json
+     * @param {TypeKeyCombo} selectedTypes limit retrieval to given metadata type
+     * @returns {Promise.<TypeKeyCombo>} dependencies
+     */
+    static async addDependencies(businessUnit, selectedTypes) {
+        if (!Util.OPTIONS.dependencies) {
+            return;
+        }
+        Util.logger.info(
+            'You might see warnings about items not being found if you have not re-retrieved everything lately.'
+        );
+
+        // try re-retrieve without passing selectedTypes to ensure we find all dependencies
+        await this._reRetrieve(businessUnit, true);
+
+        Util.logger.info(
+            'Searching for selected items and their dependencies in your project folder'
+        );
+        /** @type {TypeKeyCombo} */
+        const dependencies = {};
+        /** @type {TypeKeyCombo} */
+        const notFoundList = {};
+        const initiallySelectedTypesArr = Object.keys(selectedTypes);
+
+        const properties = await config.getProperties();
+        const buObject = await Cli.getCredentialObject(properties, businessUnit);
+        for (const type of initiallySelectedTypesArr) {
+            MetadataTypeInfo[type].properties = properties;
+            MetadataTypeInfo[type].buObject = buObject;
+            await MetadataTypeInfo[type].getDependentFiles(
+                selectedTypes[type],
+                dependencies,
+                notFoundList,
+                true
+            );
+        }
+        if (Util.getTypeKeyCount(notFoundList)) {
+            // if we have missing items, we need to retrieve them
+            Util.logger.warn(
+                `We recommend you retrieve the missing items with the following command and then re-run buildDefinition:`
+            );
+            Util.logger.warn(
+                `   mcdev retrieve ${businessUnit} ${Util.convertTypeKeyToCli(notFoundList)}`
+            );
+        }
+
+        // remove duplicates & empty types
+        for (const type in dependencies) {
+            if (dependencies[type].length) {
+                dependencies[type] = [...new Set(dependencies[type])];
+            } else {
+                delete dependencies[type];
+            }
+        }
+
+        // add dependencies to selectedTypes
+        if (Object.keys(dependencies).length) {
+            Util.logger.info(
+                `Found ${Util.getTypeKeyCount(dependencies)} items across ${Object.keys(dependencies).length} types.`
+            );
+            for (const type in dependencies) {
+                if (selectedTypes[type]) {
+                    selectedTypes[type].push(...dependencies[type]);
+                } else {
+                    selectedTypes[type] = dependencies[type];
+                }
+                // remove duplicates in main object after adding dependencies
+                selectedTypes[type] = [...new Set(selectedTypes[type])];
+            }
+        }
+        return dependencies;
+    }
 
     /**
      * Build a template based on a list of metadata files in the retrieve folder.
@@ -847,6 +1087,20 @@ class Mcdev {
             );
             return;
         }
+        const properties = await config.getProperties();
+        if (!Util.checkMarket(marketTemplate, properties)) {
+            return;
+        }
+        // check if types are valid
+        for (const type of Object.keys(typeKeyCombo)) {
+            if (!Util._isValidType(type)) {
+                return;
+            }
+            if (!Array.isArray(typeKeyCombo[type])) {
+                // we need an array of keys here
+                return;
+            }
+        }
 
         Util.logger.info('mcdev:: Build Template & Build Definition');
         await this.buildTemplate(businessUnitTemplate, typeKeyCombo, null, marketTemplate);
@@ -864,37 +1118,86 @@ class Mcdev {
      * @returns {Promise.<MultiMetadataTypeList>} -
      */
     static async buildTemplate(businessUnit, selectedTypes, keyArr, market) {
+        this.#welcomeMessage();
+
         Util.startLogger();
         Util.logger.info('mcdev:: Build Template from retrieved files');
-        let selectedTypesArr;
+        const properties = await config.getProperties();
+        if (!Util.checkMarket(market, properties)) {
+            return;
+        }
         if ('string' === typeof selectedTypes) {
-            selectedTypesArr = [selectedTypes];
-        } else {
-            selectedTypesArr = Object.keys(selectedTypes);
-            // check if types are valid
-            for (const selectedType of selectedTypesArr) {
-                if (!Util._isValidType(selectedType)) {
-                    return;
-                }
-                if (!Array.isArray(selectedTypes[selectedType])) {
-                    // we need an array of keys here
-                    return;
-                }
+            // ensure we have TypeKeyCombo here
+            selectedTypes = Util.createTypeKeyCombo(selectedTypes, keyArr);
+        }
+        // check if types are valid
+        for (const type of Object.keys(selectedTypes)) {
+            if (!Util._isValidType(type)) {
+                return;
+            }
+            if (!Array.isArray(selectedTypes[type])) {
+                // we need an array of keys here
+                return;
             }
         }
+
+        if (!Util.OPTIONS.dependencies) {
+            await this._reRetrieve(businessUnit, false, selectedTypes);
+        }
+
+        // if dependencies are enabled, we need to search for them and add them to our
+        await this.addDependencies(businessUnit, selectedTypes);
+        await this.addDependentCbReferences(businessUnit, selectedTypes);
+
         /** @type {MultiMetadataTypeList} */
         const returnObj = {};
-        for (const selectedType of selectedTypesArr) {
+        for (const type of Object.keys(selectedTypes)) {
             const result = await Builder.buildTemplate(
                 businessUnit,
-                selectedType,
-                'string' === typeof selectedTypes ? keyArr : selectedTypes[selectedType],
+                type,
+                selectedTypes[type],
                 market
             );
-            returnObj[selectedType] = result[selectedType];
+            returnObj[type] = result[type];
+        }
+        Util.logger.info(`Templated ${Util.getTypeKeyCount(returnObj)} items`);
+        if (Util.OPTIONS.dependencies) {
+            Util.logger.info(
+                `You can now run buildDefinition to create the deployment package. Don't forget to adjust the BU and market!`
+            );
+            Util.logger.info(
+                `   mcdev bd ${businessUnit} ${Util.convertTypeKeyToCli(selectedTypes)} --market ${market}`
+            );
         }
         return returnObj;
     }
+
+    /**
+     * Build a specific metadata file based on a template.
+     *
+     * @param {string} businessUnit references credentials from properties.json
+     * @param {boolean} [alwaysAsk] by default this code only runs if --retrieve is set; this flag allows to always ask
+     * @param {TypeKeyCombo} [selectedTypes] limit retrieval to given metadata type
+     * @returns {Promise.<void>} -
+     */
+    static async _reRetrieve(businessUnit, alwaysAsk = false, selectedTypes) {
+        let runRetrieveNow;
+        if (!Util.OPTIONS.skipInteraction && !Util.OPTIONS.retrieve && alwaysAsk) {
+            runRetrieveNow = await confirm({
+                message: `Do you want to re-retrieve ${selectedTypes ? Util.convertTypeKeyToString(selectedTypes) : 'all metadata'} for ${businessUnit} now?`,
+                default: false,
+            });
+        }
+        if (runRetrieveNow || Util.OPTIONS.retrieve) {
+            Util.logger.info(
+                `Re-retrieving ${businessUnit}: ${selectedTypes ? Util.convertTypeKeyToString(selectedTypes) : 'all metadata'}`
+            );
+            // we need to work with a clone here because retrieve() modifies the object passed in as 2nd parameter
+            const retrieveTypes = structuredClone(selectedTypes);
+            await this.retrieve(businessUnit, retrieveTypes);
+        }
+    }
+
     /**
      * Build a specific metadata file based on a template.
      *
@@ -905,34 +1208,39 @@ class Mcdev {
      * @returns {Promise.<MultiMetadataTypeList>} -
      */
     static async buildDefinition(businessUnit, selectedTypes, nameArr, market) {
+        this.#welcomeMessage();
+
         Util.startLogger();
         Util.logger.info('mcdev:: Build Definition from Template');
-        let selectedTypesArr;
+        const properties = await config.getProperties();
+        if (!Util.checkMarket(market, properties)) {
+            return;
+        }
         if ('string' === typeof selectedTypes) {
-            selectedTypesArr = [selectedTypes];
-        } else {
-            selectedTypesArr = Object.keys(selectedTypes);
-            // check if types are valid
-            for (const selectedType of selectedTypesArr) {
-                if (!Util._isValidType(selectedType)) {
-                    return;
-                }
-                if (!Array.isArray(selectedTypes[selectedType])) {
-                    // we need an array of keys here
-                    return;
-                }
+            // ensure we have TypeKeyCombo here
+            selectedTypes = Util.createTypeKeyCombo(selectedTypes, nameArr);
+        }
+
+        // check if types are valid
+        for (const type of Object.keys(selectedTypes)) {
+            if (!Util._isValidType(type)) {
+                return;
+            }
+            if (!Array.isArray(selectedTypes[type])) {
+                // we need an array of keys here
+                return;
             }
         }
         /** @type {MultiMetadataTypeList} */
         const returnObj = {};
-        for (const selectedType of selectedTypesArr) {
+        for (const type of Object.keys(selectedTypes)) {
             const result = await Builder.buildDefinition(
                 businessUnit,
-                selectedType,
-                'string' === typeof selectedTypes ? nameArr : selectedTypes[selectedType],
+                type,
+                selectedTypes[type],
                 market
             );
-            returnObj[selectedType] = result[selectedType];
+            returnObj[type] = result[type];
         }
         return returnObj;
     }
@@ -946,6 +1254,8 @@ class Mcdev {
      * @returns {Promise.<object>} -
      */
     static async buildDefinitionBulk(listName, selectedTypes, nameArr) {
+        this.#welcomeMessage();
+
         Util.startLogger();
         Util.logger.info('mcdev:: Build Definition from Template Bulk');
         let selectedTypesArr;
@@ -1011,35 +1321,46 @@ class Mcdev {
      * Schedule an item (shortcut for execute --schedule)
      *
      * @param {string} businessUnit name of BU
-     * @param {string} [selectedType] limit to given metadata types
+     * @param {string[] | TypeKeyCombo} [selectedTypes] limit to given metadata types
      * @param {string[]} [keys] customerkey of the metadata
-     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of scheduled item keys
+     * @returns {Promise.<Object.<string, Object.<string, string[]>>>} key: business unit name, key2: type, value: list of affected item keys
      */
-    static async schedule(businessUnit, selectedType, keys) {
+    static async schedule(businessUnit, selectedTypes, keys) {
         this.setOptions({ schedule: true });
-        return this.#runMethod('execute', businessUnit, selectedType, keys);
+        return this.#runMethod('execute', businessUnit, selectedTypes, keys);
+    }
+    /**
+     * Publish an item
+     *
+     * @param {string} businessUnit name of BU
+     * @param {string[] | TypeKeyCombo} selectedTypes limit to given metadata types
+     * @param {string[]} [keys] customerkey of the metadata
+     * @returns {Promise.<Object.<string, Object.<string, string[]>>>} key: business unit name, key2: type, value: list of affected item keys
+     */
+    static async publish(businessUnit, selectedTypes, keys) {
+        return this.#runMethod('publish', businessUnit, selectedTypes, keys);
     }
     /**
      * Start/execute an item
      *
      * @param {string} businessUnit name of BU
-     * @param {string} [selectedType] limit to given metadata types
+     * @param {string[] | TypeKeyCombo} [selectedTypes] limit to given metadata types
      * @param {string[]} [keys] customerkey of the metadata
-     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of executed item keys
+     * @returns {Promise.<Object.<string, Object.<string, string[]>>>} key: business unit name, key2: type, value: list of affected item keys
      */
-    static async execute(businessUnit, selectedType, keys) {
-        return this.#runMethod('execute', businessUnit, selectedType, keys);
+    static async execute(businessUnit, selectedTypes, keys) {
+        return this.#runMethod('execute', businessUnit, selectedTypes, keys);
     }
     /**
      * pause an item
      *
      * @param {string} businessUnit name of BU
-     * @param {string} [selectedType] limit to given metadata types
+     * @param {string[] | TypeKeyCombo} [selectedTypes] limit to given metadata types
      * @param {string[]} [keys] customerkey of the metadata
-     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of paused item keys
+     * @returns {Promise.<Object.<string, Object.<string, string[]>>>} key: business unit name, key2: type, value: list of affected item keys
      */
-    static async pause(businessUnit, selectedType, keys) {
-        return this.#runMethod('pause', businessUnit, selectedType, keys);
+    static async pause(businessUnit, selectedTypes, keys) {
+        return this.#runMethod('pause', businessUnit, selectedTypes, keys);
     }
     /**
      * Updates the key to match the name field
@@ -1121,19 +1442,11 @@ class Mcdev {
             ).join(', ')}`
         );
 
-        const response = {};
-        for (const selectedType of Array.isArray(selectedTypesArr)
-            ? selectedTypesArr
-            : Object.keys(selectedTypesObj)) {
-            const temp = await this.#runMethod(
-                'replaceCbReference',
-                businessUnit,
-                selectedType,
-                Array.isArray(selectedTypesArr) ? null : selectedTypesObj[selectedType]
-            );
-            response[businessUnit] ||= {};
-            response[businessUnit][selectedType] = temp[businessUnit];
-        }
+        const response = await this.#runMethod(
+            'replaceCbReference',
+            businessUnit,
+            selectedTypesArr || selectedTypesObj
+        );
 
         return response;
     }
@@ -1192,30 +1505,20 @@ class Mcdev {
                 skipInteraction: { fixKeysReretrieve: false },
             });
         }
-
-        const response = {};
-        for (const selectedType of selectedTypesArr || Object.keys(selectedTypesObj)) {
-            if (selectedType === 'event') {
-                Util.logger.warn(
-                    `Type 'event' is not supported for fixKeys for compatibility reasons. Draft Journeys would otherwise be broken after the key change. If you do need to update an event key, use deploy --changeKeyValue or --changeKeyField instead.`
-                );
-                if (Array.isArray(selectedTypes)) {
-                    selectedTypes = selectedTypes.filter((type) => type !== 'event');
-                } else {
-                    delete selectedTypes.event;
-                }
-                continue;
-            }
-            const temp = await this.#runMethod(
-                'fixKeys',
-                businessUnit,
-                selectedType,
-                selectedTypesArr ? keys : selectedTypesObj[selectedType]
-            );
-            response[businessUnit] ||= {};
-            response[businessUnit][selectedType] = temp[businessUnit];
+        // `Type 'event' is not supported for fixKeys for compatibility reasons. Draft Journeys would otherwise be broken after the key change. If you do need to update an event key, use deploy --changeKeyValue or --changeKeyField instead.`;
+        if (Array.isArray(selectedTypes) && selectedTypes.includes('event')) {
+            selectedTypesArr = selectedTypes.filter((type) => type !== 'event');
+        } else if (selectedTypesObj && selectedTypesObj.event) {
+            delete selectedTypesObj.event;
         }
 
+        const response = await this.#runMethod(
+            'fixKeys',
+            businessUnit,
+            selectedTypesArr || selectedTypesObj,
+            keys
+        );
+
         if (reRetrieveAll) {
             // only done if selectedTypesArr is set as fallback
             Util.logger.info(
@@ -1230,19 +1533,19 @@ class Mcdev {
     /**
      * run a method across BUs
      *
-     * @param {'execute'|'pause'|'fixKeys'|'replaceCbReference'} methodName what to run
+     * @param {'execute'|'pause'|'publish'|'fixKeys'|'replaceCbReference'} methodName what to run
      * @param {string} businessUnit name of BU
-     * @param {string} [selectedType] limit to given metadata types
+     * @param {string[] | TypeKeyCombo} [selectedTypes] limit to given metadata types
      * @param {string[]} [keys] customerkey of the metadata
-     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of affected item keys
+     * @returns {Promise.<Object.<string, Object.<string, string[]>>>} key: business unit name, key2: type, value: list of affected item keys
      */
-    static async #runMethod(methodName, businessUnit, selectedType, keys) {
+    static async #runMethod(methodName, businessUnit, selectedTypes, keys) {
         Util.startLogger();
         let lang_past;
         let lang_present;
         let requireKeyOrLike;
         let checkMetadataSupport;
-        /** @type {Object.<string, string[]>} */
+        /** @type {Object.<string, Object.<string, string[]>>} */
         const resultObj = {};
 
         switch (methodName) {
@@ -1260,6 +1563,13 @@ class Mcdev {
                 checkMetadataSupport = true;
                 break;
             }
+            case 'publish': {
+                lang_past = 'published';
+                lang_present = 'publishing';
+                requireKeyOrLike = true;
+                checkMetadataSupport = true;
+                break;
+            }
             case 'fixKeys': {
                 lang_past = 'fixed keys';
                 lang_present = 'fixing keys';
@@ -1275,125 +1585,148 @@ class Mcdev {
                 break;
             }
         }
-
-        Util.logger.info(`mcdev:: ${methodName} ${selectedType}`);
+        /** @typedef {string[]} */
+        let selectedTypesArr;
+        /** @typedef {TypeKeyCombo} */
+        let selectedTypesObj;
+        if (selectedTypes) {
+            // check if types are valid
+            for (const selectedType of Array.isArray(selectedTypes)
+                ? selectedTypes
+                : Object.keys(selectedTypes)) {
+                if (!Util._isValidType(selectedType)) {
+                    return resultObj;
+                }
+                if (
+                    checkMetadataSupport &&
+                    !Object.prototype.hasOwnProperty.call(
+                        MetadataTypeInfo[selectedType],
+                        methodName
+                    )
+                ) {
+                    Util.logger.error(
+                        ` ☇ skipping ${selectedType}: ${methodName} is not supported yet for ${selectedType}`
+                    );
+                    return resultObj;
+                }
+            }
+            if (Array.isArray(selectedTypes)) {
+                selectedTypesArr = selectedTypes;
+            } else {
+                selectedTypesObj = selectedTypes;
+            }
+        }
         const properties = await config.getProperties();
-        let counter_credBu = 0;
-        let counter_credKeys = 0;
         if (!(await config.checkProperties(properties))) {
             // return null here to avoid seeing 2 error messages for the same issue
             return resultObj;
         }
-        if (!Util._isValidType(selectedType)) {
-            return resultObj;
-        }
-        if (
-            checkMetadataSupport &&
-            !Object.prototype.hasOwnProperty.call(MetadataTypeInfo[selectedType], methodName)
-        ) {
-            Util.logger.error(
-                ` ☇ skipping ${selectedType}: ${methodName} is not supported yet for ${selectedType}`
-            );
-            return resultObj;
-        }
-
-        if (
-            requireKeyOrLike &&
-            (!Array.isArray(keys) || !keys.length) &&
-            (!Util.OPTIONS.like || !Object.keys(Util.OPTIONS.like).length)
-        ) {
-            Util.logger.error('At least one key or a --like filter is required.');
-            return resultObj;
-        } else if (
-            Array.isArray(keys) &&
-            keys.length &&
-            Util.OPTIONS.like &&
-            Object.keys(Util.OPTIONS.like).length
-        ) {
-            Util.logger.error('You can either specify keys OR a --like filter.');
-            return resultObj;
-        }
+        for (const selectedType of selectedTypesArr || Object.keys(selectedTypesObj)) {
+            Util.logger.info(`mcdev:: ${methodName} ${selectedType}`);
+            let counter_credBu = 0;
+            let counter_credKeys = 0;
+            const keyArr = selectedTypesArr ? keys : selectedTypesObj[selectedType];
+            if (
+                requireKeyOrLike &&
+                (!Array.isArray(keyArr) || !keyArr.length) &&
+                (!Util.OPTIONS.like || !Object.keys(Util.OPTIONS.like).length)
+            ) {
+                Util.logger.error('At least one key or a --like filter is required.');
+                return resultObj;
+            } else if (
+                Array.isArray(keyArr) &&
+                keyArr.length &&
+                Util.OPTIONS.like &&
+                Object.keys(Util.OPTIONS.like).length
+            ) {
+                Util.logger.error('You can either specify keys OR a --like filter.');
+                return resultObj;
+            }
 
-        if (businessUnit === '*') {
-            Util.OPTIONS._multiBuExecution = true;
-            Util.logger.info(
-                `:: ${lang_present} the ${selectedType} on all BUs for all credentials`
-            );
-            let counter_credTotal = 0;
-            for (const cred in properties.credentials) {
-                Util.logger.info(`:: ${lang_present} ${selectedType} on all BUs for ${cred}`);
-                // reset counter per cred
-                counter_credKeys = 0;
-                counter_credBu = 0;
-                for (const bu in properties.credentials[cred].businessUnits) {
-                    resultObj[cred + '/' + bu] = await this.#runOnBU(
-                        methodName,
-                        cred,
-                        bu,
-                        selectedType,
-                        keys
+            if (businessUnit === '*') {
+                Util.OPTIONS._multiBuExecution = true;
+                Util.logger.info(
+                    `:: ${lang_present} the ${selectedType} on all BUs for all credentials`
+                );
+                let counter_credTotal = 0;
+                for (const cred in properties.credentials) {
+                    Util.logger.info(`:: ${lang_present} ${selectedType} on all BUs for ${cred}`);
+                    // reset counter per cred
+                    counter_credKeys = 0;
+                    counter_credBu = 0;
+                    for (const bu in properties.credentials[cred].businessUnits) {
+                        resultObj[cred + '/' + bu] ||= {};
+                        resultObj[cred + '/' + bu][selectedType] = await this.#runOnBU(
+                            methodName,
+                            cred,
+                            bu,
+                            selectedType,
+                            keyArr
+                        );
+                        counter_credBu++;
+                        counter_credKeys += resultObj[cred + '/' + bu][selectedType].length;
+                        Util.startLogger(true);
+                    }
+                    counter_credTotal += counter_credBu;
+                    Util.logger.info(
+                        `:: ${lang_past} for ${counter_credKeys} ${selectedType}s on ${counter_credBu} BUs for ${cred}`
                     );
-                    counter_credBu++;
-                    counter_credKeys += resultObj[cred + '/' + bu].length;
-                    Util.startLogger(true);
                 }
-                counter_credTotal += counter_credBu;
                 Util.logger.info(
-                    `:: ${lang_past} for ${counter_credKeys} ${selectedType}s on ${counter_credBu} BUs for ${cred}`
+                    `:: ${lang_past} ${selectedType} on ${counter_credTotal} BUs in total\n`
                 );
-            }
-            Util.logger.info(
-                `:: ${lang_past} ${selectedType} on ${counter_credTotal} BUs in total\n`
-            );
-        } else {
-            let [cred, bu] = businessUnit ? businessUnit.split('/') : [null, null];
-            // to allow all-BU via user selection we need to run this here already
-            if (
-                properties.credentials &&
-                (!properties.credentials[cred] ||
-                    (bu !== '*' && !properties.credentials[cred].businessUnits[bu]))
-            ) {
-                const buObject = await Cli.getCredentialObject(
-                    properties,
-                    cred === null ? null : cred + '/' + bu,
-                    null,
-                    true
-                );
-                if (buObject === null) {
-                    return resultObj;
-                } else {
-                    cred = buObject.credential;
-                    bu = buObject.businessUnit;
+            } else {
+                let [cred, bu] = businessUnit ? businessUnit.split('/') : [null, null];
+                // to allow all-BU via user selection we need to run this here already
+                if (
+                    properties.credentials &&
+                    (!properties.credentials[cred] ||
+                        (bu !== '*' && !properties.credentials[cred].businessUnits[bu]))
+                ) {
+                    const buObject = await Cli.getCredentialObject(
+                        properties,
+                        cred === null ? null : cred + '/' + bu,
+                        null,
+                        true
+                    );
+                    if (buObject === null) {
+                        return resultObj;
+                    } else {
+                        cred = buObject.credential;
+                        bu = buObject.businessUnit;
+                    }
                 }
-            }
-            if (bu === '*' && properties.credentials && properties.credentials[cred]) {
-                Util.OPTIONS._multiBuExecution = true;
-                Util.logger.info(`:: ${lang_present} ${selectedType} on all BUs for ${cred}`);
-                for (const bu in properties.credentials[cred].businessUnits) {
-                    resultObj[cred + '/' + bu] = await this.#runOnBU(
+                if (bu === '*' && properties.credentials && properties.credentials[cred]) {
+                    Util.OPTIONS._multiBuExecution = true;
+                    Util.logger.info(`:: ${lang_present} ${selectedType} on all BUs for ${cred}`);
+                    for (const bu in properties.credentials[cred].businessUnits) {
+                        resultObj[cred + '/' + bu] ||= {};
+                        resultObj[cred + '/' + bu][selectedType] = await this.#runOnBU(
+                            methodName,
+                            cred,
+                            bu,
+                            selectedType,
+                            keyArr
+                        );
+                        counter_credBu++;
+                        counter_credKeys += resultObj[cred + '/' + bu][selectedType].length;
+                        Util.startLogger(true);
+                    }
+                    Util.logger.info(
+                        `:: ${lang_past} for ${counter_credKeys} ${selectedType}s on ${counter_credBu} BUs for ${cred}`
+                    );
+                } else {
+                    // execute runMethod for the entity on one BU only
+                    resultObj[cred + '/' + bu] ||= {};
+                    resultObj[cred + '/' + bu][selectedType] = await this.#runOnBU(
                         methodName,
                         cred,
                         bu,
                         selectedType,
-                        keys
+                        keyArr
                     );
-                    counter_credBu++;
-                    counter_credKeys += resultObj[cred + '/' + bu].length;
-                    Util.startLogger(true);
+                    Util.logger.info(`:: Done`);
                 }
-                Util.logger.info(
-                    `:: ${lang_past} for ${counter_credKeys} ${selectedType}s on ${counter_credBu} BUs for ${cred}`
-                );
-            } else {
-                // execute runMethod for the entity on one BU only
-                resultObj[cred + '/' + bu] = await this.#runOnBU(
-                    methodName,
-                    cred,
-                    bu,
-                    selectedType,
-                    keys
-                );
-                Util.logger.info(`:: Done`);
             }
         }
         return resultObj;
@@ -1401,7 +1734,7 @@ class Mcdev {
     /**
      * helper for Mcdev.#runMethod
      *
-     * @param {'execute'|'pause'|'fixKeys'|'replaceCbReference'} methodName what to run
+     * @param {'execute'|'pause'|'publish'|'fixKeys'|'replaceCbReference'} methodName what to run
      * @param {string} cred name of Credential
      * @param {string} bu name of BU
      * @param {string} [type] limit execution to given metadata type