mcdev 7.4.2 → 7.4.4

package/boilerplate/files/eslint.config.js

@@ -65,6 +65,24 @@ export default [
             'prettier/prettier': 'warn'
         }
     },
+    {
+        files: ['.mcdev-validations.js'],
+
+        languageOptions: {
+            globals: {
+                ...globals.nodeBuiltin
+            },
+
+            ecmaVersion: 2022,
+            sourceType: 'module'
+        },
+
+        rules: {
+            'no-var': 'error',
+            'prefer-const': 'error',
+            'prettier/prettier': 'warn'
+        }
+    },
     {
         files: ['eslint.config.js'],
 

package/boilerplate/forcedUpdates.json

@@ -1,4 +1,8 @@
 [
+    {
+        "version": "7.4.3",
+        "files": ["eslint.config.js", ".prettierrc"]
+    },
     {
         "version": "7.4.2",
         "files": [".vscode/settings.json"]

package/lib/metadataTypes/DataExtension.js

@@ -53,12 +53,8 @@ class DataExtension extends MetadataType {
         let filteredByPreDeploy = 0;
         for (const metadataKey in metadataMap) {
             try {
+                await this.validation('deploy', metadataMap[metadataKey], deployDir);
                 metadataMap[metadataKey] = await this.preDeployTasks(metadataMap[metadataKey]);
-                metadataMap[metadataKey] = await this.validation(
-                    'deploy',
-                    metadataMap[metadataKey],
-                    deployDir
-                );
             } catch (ex) {
                 // output error & remove from deploy list
                 Util.logger.error(

package/lib/metadataTypes/DataExtract.js

@@ -146,6 +146,35 @@ class DataExtract extends MetadataType {
      * @returns {MetadataTypeItem} metadata
      */
     static postRetrieveTasks(metadata) {
+        try {
+            metadata.createdBy = cache.searchForField(
+                'user',
+                metadata.createdBy,
+                'AccountUserID',
+                'Name'
+            );
+        } catch (ex) {
+            Util.logger.verbose(
+                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                    metadata[this.definition.keyField]
+                }): ${ex.message}.`
+            );
+        }
+
+        try {
+            metadata.modifiedBy = cache.searchForField(
+                'user',
+                metadata.modifiedBy,
+                'AccountUserID',
+                'Name'
+            );
+        } catch (ex) {
+            Util.logger.verbose(
+                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                    metadata[this.definition.keyField]
+                }): ${ex.message}.`
+            );
+        }
         try {
             metadata.r__dataExtractType_name = cache.searchForField(
                 'dataExtractType',

package/lib/metadataTypes/Event.js

@@ -418,6 +418,36 @@ class Event extends MetadataType {
      * @returns {Promise.<MetadataTypeItem>} parsed metadata
      */
     static async postRetrieveTasks(metadata) {
+        try {
+            metadata.createdBy = cache.searchForField(
+                'user',
+                metadata.createdBy,
+                'AccountUserID',
+                'Name'
+            );
+        } catch (ex) {
+            Util.logger.verbose(
+                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                    metadata[this.definition.keyField]
+                }): ${ex.message}.`
+            );
+        }
+
+        try {
+            metadata.modifiedBy = cache.searchForField(
+                'user',
+                metadata.modifiedBy,
+                'AccountUserID',
+                'Name'
+            );
+        } catch (ex) {
+            Util.logger.verbose(
+                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                    metadata[this.definition.keyField]
+                }): ${ex.message}.`
+            );
+        }
+
         try {
             metadata.r__dataExtension_key = cache.searchForField(
                 'dataExtension',
@@ -531,7 +561,7 @@ class Event extends MetadataType {
                 this.sfObjects.objectFields['Lead'] &&
                 !this.sfObjects.workflowObjects.includes(contactLeadName)
             ) {
-                Util.logger.info(
+                Util.logger.verbose(
                     Util.getGrayMsg(' - Constructing Common / Contacts and Leads object')
                 );
                 // add fake entry to workflowObjects to allow testing for this easily
@@ -622,7 +652,7 @@ class Event extends MetadataType {
         if (this.sfObjects.objectFields[objectAPIName] || objectAPIName === 'Common') {
             return;
         }
-        Util.logger.info(
+        Util.logger.verbose(
             Util.getGrayMsg(' - Caching Fields for Salesforce Object ' + objectAPIName)
         );
 
@@ -870,8 +900,10 @@ class Event extends MetadataType {
         // throw error if problems were found
         if (errors?.length) {
             // add a line break
-            errors.unshift(``);
-            throw new Error(errors.join('\n    - ')); // eslint-disable-line unicorn/error-message
+            if (errors.length > 1) {
+                errors.unshift(``);
+            }
+            throw new Error(errors.join('\n        · ')); // eslint-disable-line unicorn/error-message
         }
     }
 

package/lib/metadataTypes/Journey.js

@@ -272,14 +272,31 @@ class Journey extends MetadataType {
     /**
      * Deploys metadata - merely kept here to be able to print {@link Util.logBeta} once per deploy
      *
-     * @param {MetadataTypeMap} metadata metadata mapped by their keyField
+     * @param {MetadataTypeMap} metadataMap metadata mapped by their keyField
      * @param {string} deployDir directory where deploy metadata are saved
      * @param {string} retrieveDir directory where metadata after deploy should be saved
      * @returns {Promise.<MetadataTypeMap>} Promise of keyField => metadata map
      */
-    static async deploy(metadata, deployDir, retrieveDir) {
+    static async deploy(metadataMap, deployDir, retrieveDir) {
         Util.logBeta(this.definition.type);
-        return super.deploy(metadata, deployDir, retrieveDir);
+
+        let needTransactionalEmail = false;
+        for (const key in metadataMap) {
+            if (metadataMap[key].definitionType == 'Transactional') {
+                needTransactionalEmail = true;
+                break;
+            }
+        }
+        if (needTransactionalEmail && !cache.getCache()?.transactionalEmail) {
+            // ! interaction and transactionalEmail both link to each other. caching transactionalEmail here "manually", assuming that it's quicker than the other way round
+            Util.logger.info(' - Caching dependent Metadata: transactionalEmail');
+            TransactionalEmail.buObject = this.buObject;
+            TransactionalEmail.client = this.client;
+            TransactionalEmail.properties = this.properties;
+            const result = await TransactionalEmail.retrieveForCache();
+            cache.setMetadata('transactionalEmail', result.metadata);
+        }
+        return super.deploy(metadataMap, deployDir, retrieveDir);
     }
 
     /**
@@ -499,6 +516,8 @@ class Journey extends MetadataType {
                                 delete activity.metaData.highThroughput.definitionKey;
                             }
 
+                            this._postRetrieveTasks_activities(metadata);
+
                             if (activity.metaData?.highThroughput?.dataExtensionId) {
                                 try {
                                     activity.metaData.highThroughput.r__dataExtension_key =
@@ -518,9 +537,6 @@ class Journey extends MetadataType {
                                 }
                             }
                         }
-                        // ~~~ ACTIVITIES ~~~~
-
-                        this._postRetrieveTasks_activities(metadata);
 
                         break;
                     }
@@ -618,9 +634,120 @@ class Journey extends MetadataType {
                     const triggeredSend = configurationArguments?.triggeredSend;
                     if (triggeredSend) {
                         // this section is likely only relevant for QuickSends and not for Multi-Step Journeys
-
                         // triggeredSend key
-                        if (configurationArguments.r__triggeredSend_key) {
+                        if (configurationArguments.r__transactionalEmail_key) {
+                            const linkedTE = cache.getByKey(
+                                'transactionalEmail',
+                                configurationArguments.r__transactionalEmail_key
+                            );
+                            if (linkedTE) {
+                                if (linkedTE.subscriptions) {
+                                    triggeredSend.autoAddSubscribers =
+                                        linkedTE.subscriptions.autoAddSubscriber;
+                                    triggeredSend.autoUpdateSubscribers =
+                                        linkedTE.subscriptions.updateSubscriber;
+
+                                    // List
+                                    if (linkedTE.subscriptions?.list) {
+                                        triggeredSend.publicationListId = cache.searchForField(
+                                            'list',
+                                            linkedTE.subscriptions.list,
+                                            'CustomerKey',
+                                            'ID'
+                                        );
+                                    } else if (linkedTE.subscriptions.r__list_PathName) {
+                                        delete triggeredSend.publicationListId;
+                                        triggeredSend.r__list_PathName = {
+                                            publicationList:
+                                                linkedTE.subscriptions.r__list_PathName,
+                                        };
+                                    }
+
+                                    // dataExtension
+                                    if (linkedTE.subscriptions.dataExtension) {
+                                        try {
+                                            activity.metaData.highThroughput.r__dataExtension_key =
+                                                cache.searchForField(
+                                                    'dataExtension',
+                                                    linkedTE.subscriptions.dataExtension,
+                                                    'CustomerKey',
+                                                    'CustomerKey'
+                                                );
+                                            delete activity.metaData.highThroughput.dataExtensionId;
+                                        } catch (ex) {
+                                            Util.logger.warn(
+                                                ` - ${this.definition.type} ${
+                                                    metadata[this.definition.nameField]
+                                                } (${metadata[this.definition.keyField]}): ${ex.message}.`
+                                            );
+                                        }
+                                    } else if (linkedTE.subscriptions.r__dataExtension_key) {
+                                        activity.metaData.highThroughput.r__dataExtension_key =
+                                            linkedTE.subscriptions.r__dataExtension_key;
+                                        delete activity.metaData.highThroughput.dataExtensionId;
+                                    }
+                                }
+                                if (linkedTE.options) {
+                                    triggeredSend.isTrackingClicks = linkedTE.options.trackLinks;
+                                }
+
+                                // send classification
+                                if (linkedTE.classification) {
+                                    try {
+                                        const scKey = cache.searchForField(
+                                            'sendClassification',
+                                            linkedTE.classification,
+                                            'CustomerKey',
+                                            'CustomerKey'
+                                        );
+                                        triggeredSend.r__sendClassification_key = scKey;
+                                        delete triggeredSend.sendClassificationId;
+                                    } catch (ex) {
+                                        Util.logger.warn(
+                                            ` - transactionalEmail ${linkedTE.definitionKey}: ${ex.message} (sendClassification key ${linkedTE.classification})`
+                                        );
+                                    }
+                                } else if (linkedTE.r__sendClassification_key) {
+                                    triggeredSend.r__sendClassification_key =
+                                        linkedTE.r__sendClassification_key;
+                                }
+
+                                // senderProfile + deliveryProfile from sendClassification
+                                if (triggeredSend.r__sendClassification_key) {
+                                    const sc = cache.getByKey(
+                                        'sendClassification',
+                                        triggeredSend.r__sendClassification_key
+                                    );
+
+                                    if (sc.SenderProfile?.ObjectID) {
+                                        triggeredSend.r__senderProfile_key = cache.searchForField(
+                                            'senderProfile',
+                                            sc.SenderProfile.ObjectID,
+                                            'ObjectID',
+                                            'CustomerKey'
+                                        );
+                                        delete triggeredSend.senderProfileId;
+                                    } else if (sc.r__senderProfile_key) {
+                                        triggeredSend.r__senderProfile_key =
+                                            sc.r__senderProfile_key;
+                                        delete triggeredSend.senderProfileId;
+                                    }
+                                    if (sc.DeliveryProfile?.ObjectID) {
+                                        triggeredSend.r__deliveryProfile_key = cache.searchForField(
+                                            'deliveryProfile',
+                                            sc.DeliveryProfile.ObjectID,
+                                            'ObjectID',
+                                            'key'
+                                        );
+                                        delete triggeredSend.deliveryProfileId;
+                                    } else if (sc.r__deliveryProfile_key) {
+                                        triggeredSend.r__deliveryProfile_key =
+                                            sc.r__deliveryProfile_key;
+                                        delete triggeredSend.deliveryProfileId;
+                                    }
+                                }
+                            }
+                        } else if (configurationArguments.r__triggeredSend_key) {
                             // if we have a key set outside of this detailed triggeredSend config then lets overwrite what we've got here with what we cached from the related TS as it will be more current; but we cannot retrieve all info unfortunately
                             triggeredSend.r__triggeredSend_key =
                                 configurationArguments.r__triggeredSend_key;
@@ -628,7 +755,7 @@ class Journey extends MetadataType {
                             delete triggeredSend.key;
                             const linkedTS = cache.getByKey(
                                 'triggeredSend',
-                                triggeredSend.r__triggeredSend_key
+                                configurationArguments.r__triggeredSend_key
                             );
                             if (linkedTS) {
                                 triggeredSend.emailId = linkedTS.Email?.ID;
@@ -647,6 +774,7 @@ class Journey extends MetadataType {
                                 // triggeredSend.fromName = linkedTS.FromName;
                                 // triggeredSend.fromAddress = linkedTS.FromAddress;
 
+                                // List
                                 if (linkedTS.List?.ID) {
                                     triggeredSend.publicationListId = linkedTS.List.ID;
                                 } else if (linkedTS.r__list_PathName) {
@@ -854,8 +982,21 @@ class Journey extends MetadataType {
                         }
                         // delivery profile
                         if (triggeredSend.deliveryProfileId) {
-                            // remove it because we cannot resolve it and it should be set by selecting the sendClassification
-                            delete triggeredSend.deliveryProfileId;
+                            try {
+                                triggeredSend.r__deliveryProfile_key = cache.searchForField(
+                                    'deliveryProfile',
+                                    triggeredSend.deliveryProfileId,
+                                    'ObjectID',
+                                    'key'
+                                );
+                                delete triggeredSend.deliveryProfileId;
+                            } catch {
+                                Util.logger.warn(
+                                    ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                                        metadata[this.definition.keyField]
+                                    }): Dependent deliveryProfile was not found. Please note that this can only be resolved if you have at least ONE Send Classification set up on the target BU that uses this Delivery Profile.`
+                                );
+                            }
                         }
                         // message priority
                         if (triggeredSend.priority) {
@@ -1150,6 +1291,8 @@ class Journey extends MetadataType {
                             delete activity.metaData.highThroughput.r__dataExtension_key;
                         }
 
+                        this._preDeployTasks_activities(metadata);
+
                         break;
                     }
                     default: {
@@ -1306,6 +1449,25 @@ class Journey extends MetadataType {
                             );
                             delete triggeredSend.r__sendClassification_key;
                         }
+                        // delivery profile
+                        if (triggeredSend.r__deliveryProfile_key) {
+                            // remove it because we cannot resolve it and it should be set by selecting the sendClassification
+                            try {
+                                triggeredSend.deliveryProfileId = cache.searchForField(
+                                    'deliveryProfile',
+                                    triggeredSend.r__deliveryProfile_key,
+                                    'key',
+                                    'ObjectID'
+                                );
+                                delete triggeredSend.r__deliveryProfile_key;
+                            } catch (ex) {
+                                Util.logger.error(
+                                    `Could not find the ID for Delivery Profile '${triggeredSend.r__deliveryProfile_key}'. Please note that this can only be resolved if you have at least ONE Send Classification set up on the target BU that uses a Delivery Profile with this key.`
+                                );
+                                throw ex;
+                            }
+                        }
+
                         // message priority
                         if (triggeredSend.c__priority) {
                             triggeredSend.priority =
@@ -1824,41 +1986,54 @@ class Journey extends MetadataType {
             }).start();
             const transactionalKeyArr = (await Promise.all(resultsTransactional)).filter(Boolean);
             spinner.success('done.');
-            executedKeyArr.push(...transactionalKeyArr);
 
-            Util.logger.info('Retrieving relevant journeys');
-            const retriever = new Retriever(this.properties, this.buObject);
+            // if all publish actions failed, we don't need to re-retrieve anything here
+            if (transactionalKeyArr.length) {
+                executedKeyArr.push(...transactionalKeyArr);
 
-            try {
-                const updatedJourneyRetrieve = await retriever.retrieve(
-                    ['journey'],
-                    transactionalKeyArr
-                );
+                Util.logger.info('Retrieving relevant journeys');
+                const retriever = new Retriever(this.properties, this.buObject);
 
-                /** @type {MetadataTypeItem[]} */
-                const updatedJourneys = Object.values(updatedJourneyRetrieve?.journey[0]);
-                if (updatedJourneys) {
-                    const updatedTransactionalEmails = [];
-                    for (const journey of updatedJourneys) {
-                        updatedTransactionalEmails.push(
-                            journey.activities?.[0]?.configurationArguments
-                                ?.r__transactionalEmail_key
-                        );
-                    }
-                    if (updatedTransactionalEmails.filter(Boolean).length) {
-                        Util.logger.info('Retrieving relevant transactionalEmails');
-                        await retriever.retrieve(
-                            ['transactionalEmail'],
-                            updatedTransactionalEmails.filter(Boolean)
-                        );
-                    } else {
-                        Util.logger.error(
-                            `Could not find transactional Emails for the published journeys`
-                        );
+                try {
+                    const updatedJourneyRetrieve = await retriever.retrieve(
+                        ['journey'],
+                        transactionalKeyArr
+                    );
+
+                    /** @type {MetadataTypeItem[]} */
+                    const updatedJourneys =
+                        updatedJourneyRetrieve?.journey?.length > 1
+                            ? Object.values(
+                                  updatedJourneyRetrieve?.journey.reduce(
+                                      (previousValue, currentValue) =>
+                                          Object.assign(previousValue, currentValue),
+                                      {}
+                                  )
+                              )
+                            : Object.values(updatedJourneyRetrieve?.journey[0]);
+                    if (updatedJourneys) {
+                        const updatedTransactionalEmails = [];
+                        for (const journey of updatedJourneys) {
+                            updatedTransactionalEmails.push(
+                                journey.activities?.[0]?.configurationArguments
+                                    ?.r__transactionalEmail_key
+                            );
+                        }
+                        if (updatedTransactionalEmails.filter(Boolean).length) {
+                            Util.logger.info('Retrieving relevant transactionalEmails');
+                            await retriever.retrieve(
+                                ['transactionalEmail'],
+                                updatedTransactionalEmails.filter(Boolean)
+                            );
+                        } else {
+                            Util.logger.error(
+                                `Could not find transactional Emails for the published journeys`
+                            );
+                        }
                     }
+                } catch (ex) {
+                    Util.logger.errorStack(ex, 'retrieve failed');
                 }
-            } catch (ex) {
-                Util.logger.errorStack(ex, 'retrieve failed');
             }
         }
         Util.logger.info(

package/lib/metadataTypes/MetadataType.js

@@ -730,16 +730,11 @@ class MetadataType {
                 // preDeployTasks parsing
                 let deployableMetadata;
                 try {
+                    await this.validation('deploy', metadataMap[metadataKey], deployDir);
                     deployableMetadata = await this.preDeployTasks(
                         metadataMap[metadataKey],
                         deployDir
                     );
-
-                    deployableMetadata = await this.validation(
-                        'deploy',
-                        deployableMetadata,
-                        deployDir
-                    );
                 } catch (ex) {
                     // do this in case something went wrong during pre-deploy steps to ensure the total counter is correct
                     hasError = true;
@@ -1969,11 +1964,7 @@ class MetadataType {
                     filterCounter++;
                     continue;
                 }
-                results[originalKey] = await this.validation(
-                    'retrieve',
-                    results[originalKey],
-                    retrieveDir
-                );
+                await this.validation('retrieve', results[originalKey], retrieveDir);
 
                 savedResults[originalKey] = await this.saveToDisk(
                     results,
@@ -2800,11 +2791,13 @@ class MetadataType {
      * @returns {Promise.<MetadataTypeItem | CodeExtractItem>} Promise of a single metadata item
      */
     static async validation(method, item, targetDir) {
+        item = structuredClone(item);
         if (!this.properties.options?.validation?.[method]) {
             return item;
         }
         /** @type {MetadataTypeItem} */
         const metadataItem = item.json && item.codeArr ? item.json : item;
+        const codeArr = item.codeArr || null;
         /** @type {ValidationRules} */
         const validationConfig = structuredClone(this.properties.options?.validation?.[method]);
 
@@ -2827,9 +2820,15 @@ class MetadataType {
 
         // get default and custom validation rules
         const definition = this.definition;
-        const validationRules = await validationsRules(this.definition, metadataItem, targetDir);
+        const validationRules = await validationsRules(
+            this.definition,
+            metadataItem,
+            targetDir,
+            codeArr
+        );
 
         // run validation rules
+        const warnings = [];
         for (const rule of Object.keys(validationRules)) {
             if (
                 validationConfig[rule] &&
@@ -2840,14 +2839,17 @@ class MetadataType {
                 if (!Util.OPTIONS.skipValidation && validationConfig[rule] === 'error') {
                     throw new Error(validationRules[rule].failedMsg);
                 } else if (Util.OPTIONS.skipValidation || validationConfig[rule] === 'warn') {
-                    Util.logger.warn(
-                        ` - ${this.definition.type} ${metadataItem[this.definition.nameField]} (${
-                            metadataItem[this.definition.keyField]
-                        }): ${validationRules[rule].failedMsg}`
-                    );
+                    warnings.push(validationRules[rule].failedMsg);
                 }
             }
         }
+        if (warnings.length) {
+            Util.logger.warn(
+                ` - ${this.definition.type} ${metadataItem[this.definition.nameField]} (${
+                    metadataItem[this.definition.keyField]
+                }):${warnings.length > 1 ? '\n        ·' : ''} ${warnings.join('\n        · ')}`
+            );
+        }
         return item;
     }
 }

package/lib/metadataTypes/SendClassification.js

@@ -47,6 +47,22 @@ class SendClassification extends MetadataType {
         return super.retrieveSOAP(retrieveDir, requestParams, key);
     }
 
+    /**
+     * Retrieves event definition metadata for caching
+     *
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
+     */
+    static async retrieveForCache() {
+        const typeMap = await this.retrieve(null);
+        if (cache.getCache().deliveryProfile) {
+            for (const item of Object.values(typeMap.metadata)) {
+                // run postRetrieveTasks to cross-update deliveryProfile cache
+                this.updateDeliveryProfileIdInCache(item);
+            }
+        }
+        return typeMap;
+    }
+
     /**
      * Updates a single item
      *
@@ -100,13 +116,15 @@ class SendClassification extends MetadataType {
         };
         delete metadata.r__senderProfile_key;
 
+        const dpId = cache.searchForField(
+            'deliveryProfile',
+            metadata.r__deliveryProfile_key,
+            'key',
+            'ObjectID'
+        );
         metadata.DeliveryProfile = {
-            CustomerKey: cache.searchForField(
-                'deliveryProfile',
-                metadata.r__deliveryProfile_key,
-                'key',
-                'key'
-            ),
+            ObjectID: dpId,
+            CustomerKey: metadata.r__deliveryProfile_key,
         };
         delete metadata.r__deliveryProfile_key;
 
@@ -126,6 +144,7 @@ class SendClassification extends MetadataType {
         );
         delete metadata.SendClassificationType;
 
+        // when sendClassification was only cached it can happen that we don't have the senderProfile cache yet
         try {
             metadata.r__senderProfile_key = cache.searchForField(
                 'senderProfile',
@@ -144,6 +163,9 @@ class SendClassification extends MetadataType {
                 'key',
                 'key'
             );
+            // add ObjectID to deliveryProfile cache because it cannot be retrieved any other way and this way we can resolve it in journeys
+            this.updateDeliveryProfileIdInCache(metadata);
+
             delete metadata.DeliveryProfile;
         } catch (ex) {
             Util.logger.warn(` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`);
@@ -151,6 +173,22 @@ class SendClassification extends MetadataType {
 
         return metadata;
     }
+
+    /**
+     * this is the only known way to get the object ID for a deliveryProfile
+     *
+     * @param {MetadataTypeItem} metadata a single sendClassification item
+     */
+    static updateDeliveryProfileIdInCache(metadata) {
+        const dp = cache.getByKey('deliveryProfile', metadata.DeliveryProfile.CustomerKey);
+        if (dp) {
+            dp.ObjectID = metadata.DeliveryProfile.ObjectID;
+        } else {
+            Util.logger.debug(
+                ` - ${this.definition.type} ${metadata.CustomerKey}: Could not find deliveryProfile ${metadata.DeliveryProfile.CustomerKey} in cache`
+            );
+        }
+    }
 }
 
 // Assign definition to static attributes