mcdev 7.5.0 → 7.6.1

package/lib/cli.js

@@ -734,11 +734,22 @@ yargs(hideBin(process.argv))
                 .positional('KEY', {
                     type: 'string',
                     describe: 'key(s) of the metadata component(s)',
+                })
+                .option('metadata', {
+                    type: 'string',
+                    array: true,
+                    alias: 'm',
+                    group: 'Options for execute:',
+                    describe: 'type or type:key or type:i:id or type:n:name to fix',
                 }),
-        // TODO: add option --metadata
         (argv) => {
             Mcdev.setOptions(argv);
-            Mcdev.refresh(argv.BU, argv.TYPE, csvToArray(argv.KEY));
+            const typeKeyCombo = Mcdev.metadataToTypeKey(argv.metadata);
+            if ('undefined' === typeof typeKeyCombo) {
+                Mcdev.refresh(argv.BU, csvToArray(argv.TYPE), csvToArray(argv.KEY));
+            } else {
+                Mcdev.refresh(argv.BU, typeKeyCombo);
+            }
         }
     )
     .command(

package/lib/index.js

@@ -730,38 +730,12 @@ class Mcdev {
      * ensures triggered sends are restarted to ensure they pick up on changes of the underlying emails
      *
      * @param {string} businessUnit references credentials from properties.json
-     * @param {string} type references credentials from properties.json
-     * @param {string[]} [keyArr] metadata keys
-     * @returns {Promise.<void>} -
+     * @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 refresh(businessUnit, type, keyArr) {
-        Util.startLogger();
-        Util.logger.info('mcdev:: refresh');
-        if (!type || !Util._isValidType(type, true)) {
-            type = 'triggeredSend';
-            Util.logger.info(' - setting type to ' + type);
-        }
-        const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
-        }
-        const buObject = await Cli.getCredentialObject(properties, businessUnit);
-        if (buObject !== null) {
-            try {
-                MetadataTypeInfo[type].client = auth.getSDK(buObject);
-            } catch (ex) {
-                Util.logger.error(ex.message);
-                return;
-            }
-            try {
-                cache.initCache(buObject);
-                MetadataTypeInfo[type].properties = properties;
-                MetadataTypeInfo[type].buObject = buObject;
-                await MetadataTypeInfo[type].refresh(keyArr);
-            } catch (ex) {
-                Util.logger.errorStack(ex, 'mcdev.refresh');
-            }
-        }
+    static async refresh(businessUnit, selectedTypes, keys) {
+        return this.#runMethod('refresh', businessUnit, selectedTypes, keys);
     }
 
     /**
@@ -1127,6 +1101,7 @@ class Mcdev {
                 return;
             }
             if (!Array.isArray(typeKeyCombo[type])) {
+                Util.logger.error('You need to define keys, not just types to run build');
                 // we need an array of keys here
                 return;
             }
@@ -1188,6 +1163,7 @@ class Mcdev {
                 return;
             }
             if (!Array.isArray(selectedTypes[type])) {
+                Util.logger.error('You need to define keys, not just types to run buildTemplate');
                 // we need an array of keys here
                 return;
             }
@@ -1326,6 +1302,7 @@ class Mcdev {
                 return;
             }
             if (!Array.isArray(selectedTypes[type])) {
+                Util.logger.error('You need to define keys, not just types to run buildDefinition');
                 // we need an array of keys here
                 return;
             }
@@ -1381,6 +1358,9 @@ class Mcdev {
                     return;
                 }
                 if (!Array.isArray(selectedTypes[selectedType])) {
+                    Util.logger.error(
+                        'You need to define keys, not just types to run buildDefinitionBulk'
+                    );
                     // we need an array of keys here
                     return;
                 }
@@ -1681,7 +1661,7 @@ class Mcdev {
     /**
      * run a method across BUs
      *
-     * @param {'execute'|'pause'|'stop'|'publish'|'validate'|'fixKeys'|'replaceCbReference'} methodName what to run
+     * @param {'execute'|'pause'|'stop'|'publish'|'validate'|'fixKeys'|'replaceCbReference'|'refresh'} methodName what to run
      * @param {string} businessUnit name of BU
      * @param {string[] | TypeKeyCombo} [selectedTypes] limit to given metadata types
      * @param {string[]} [keys] customerkey of the metadata
@@ -1746,6 +1726,13 @@ class Mcdev {
                 checkMetadataSupport = true;
                 break;
             }
+            case 'refresh': {
+                lang_past = 'refreshed';
+                lang_present = 'refreshing';
+                requireKeyOrLike = false;
+                checkMetadataSupport = true;
+                break;
+            }
         }
 
         /** @typedef {string[]} */
@@ -1899,7 +1886,7 @@ class Mcdev {
     /**
      * helper for Mcdev.#runMethod
      *
-     * @param {'execute'|'pause'|'stop'|'publish'|'validate'|'fixKeys'|'replaceCbReference'} methodName what to run
+     * @param {'execute'|'pause'|'stop'|'publish'|'validate'|'fixKeys'|'replaceCbReference'|'refresh'} 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
@@ -1948,9 +1935,6 @@ class Mcdev {
                     if (Util.OPTIONS.like && Object.keys(Util.OPTIONS.like).length) {
                         keyArr = await this.#retrieveKeysWithLike(type, buObject);
                     }
-                    if (!keyArr || (Array.isArray(keyArr) && !keyArr.length)) {
-                        throw new Error('No keys were provided');
-                    } // result will be undefined (false) if methodName is not supported for the type
                     resultArr.push(...(await MetadataTypeInfo[type][methodName](keyArr)));
                 }
             }
@@ -2215,36 +2199,53 @@ class Mcdev {
         }
         const metadataOptionMap = metadataOption.map((item) => {
             const itemArr = item.split(':');
+            const type = itemArr.shift();
             switch (itemArr.length) {
-                case 1: {
-                    return { type: itemArr[0] };
+                case 0: {
+                    // no ":" found
+                    return { type };
                 }
-                case 2: {
+                case 1: {
+                    // 1 ":" found
                     if (allowedIdentifiers.includes('key')) {
-                        return { type: itemArr[0], key: itemArr[1] };
+                        return { type, key: itemArr[0] };
                     }
                     break;
                 }
-                case 3: {
-                    switch (itemArr[1]) {
+                default: {
+                    // 2 or more ":" found
+                    switch (itemArr[0]) {
                         case 'key':
                         case 'k': {
                             if (allowedIdentifiers.includes('key')) {
-                                return { type: itemArr[0], key: itemArr[2] };
+                                // remove k/key
+                                itemArr.shift();
+                                return { type, key: itemArr.join(':') };
                             }
                             break;
                         }
                         case 'id':
                         case 'i': {
                             if (allowedIdentifiers.includes('id')) {
-                                return { type: itemArr[0], id: itemArr[2] };
+                                // remove i/id
+                                itemArr.shift();
+                                return { type, id: itemArr.join(':') };
                             }
                             break;
                         }
                         case 'name':
                         case 'n': {
                             if (allowedIdentifiers.includes('name')) {
-                                return { type: itemArr[0], name: itemArr[2] };
+                                // remove n/name
+                                itemArr.shift();
+                                return { type, name: itemArr.join(':') };
+                            }
+                            break;
+                        }
+                        default: {
+                            // assume ":" is part of the key (e.g. possible for DE-fields)
+                            if (allowedIdentifiers.includes('key')) {
+                                return { type, key: itemArr.join(':') };
                             }
                         }
                     }

package/lib/metadataTypes/Automation.js

@@ -485,6 +485,22 @@ class Automation extends MetadataType {
         // folder
         this.setFolderPath(metadata);
         // automations are often skipped due to lack of support.
+        if (
+            metadata.type == 'automationtriggered' &&
+            metadata.automationTrigger?.fileTransferLocationId
+        ) {
+            try {
+                metadata.automationTrigger.r__fileLocation_name = cache.searchForField(
+                    'fileLocation',
+                    metadata.automationTrigger.fileTransferLocationId,
+                    'id',
+                    'name'
+                );
+                delete metadata.automationTrigger.fileTransferLocationId;
+            } catch (ex) {
+                Util.logger.warn(` - automation ${metadata.key}: ${ex.message}`);
+            }
+        }
         try {
             if (metadata.type === 'scheduled' && metadata.schedule?.startDate) {
                 // Starting Source == 'Schedule'
@@ -905,6 +921,18 @@ class Automation extends MetadataType {
                 this.notificationUpdates[metadata.key] = [];
             }
         }
+        if (
+            metadata.type == 'automationtriggered' &&
+            metadata.automationTrigger?.r__fileLocation_name
+        ) {
+            metadata.automationTrigger.fileTransferLocationId = cache.searchForField(
+                'fileLocation',
+                metadata.automationTrigger.r__fileLocation_name,
+                'name',
+                'id'
+            );
+            delete metadata.automationTrigger.r__fileLocation_name;
+        }
         if (this.validateDeployMetadata(metadata)) {
             // folder
             this.setFolderId(metadata);

package/lib/metadataTypes/Event.js

@@ -828,7 +828,10 @@ class Event extends MetadataType {
                 if (Util.OPTIONS.ignoreSfFields) {
                     warnings.push(` (--ignoreSfFields) ` + msg);
                 } else {
-                    errors.push(msg);
+                    errors.push(
+                        msg +
+                            ` (you can use --ignoreSfFields to skip this error in case you are convinced it is a false positive)`
+                    );
                 }
             } else {
                 // check if the fields selected in the eventDefinition are actually available