mcdev 7.4.2 → 7.4.3

package/lib/metadataTypes/Journey.js

@@ -854,8 +854,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 +1163,8 @@ class Journey extends MetadataType {
                             delete activity.metaData.highThroughput.r__dataExtension_key;
                         }
 
+                        this._preDeployTasks_activities(metadata);
+
                         break;
                     }
                     default: {
@@ -1306,6 +1321,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 +1858,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/SendClassification.js

@@ -47,6 +47,20 @@ 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);
+        for (const item of Object.values(typeMap.metadata)) {
+            // run postRetrieveTasks to cross-update deliveryProfile cache
+            this.postRetrieveTasks(item);
+        }
+        return typeMap;
+    }
+
     /**
      * Updates a single item
      *
@@ -100,13 +114,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,16 +142,21 @@ class SendClassification extends MetadataType {
         );
         delete metadata.SendClassificationType;
 
-        try {
-            metadata.r__senderProfile_key = cache.searchForField(
-                'senderProfile',
-                metadata.SenderProfile.ObjectID,
-                'ObjectID',
-                'CustomerKey'
-            );
-            delete metadata.SenderProfile;
-        } catch (ex) {
-            Util.logger.warn(` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`);
+        if (cache.getCache().senderProfile) {
+            // 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',
+                    metadata.SenderProfile.ObjectID,
+                    'ObjectID',
+                    'CustomerKey'
+                );
+                delete metadata.SenderProfile;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                );
+            }
         }
         try {
             metadata.r__deliveryProfile_key = cache.searchForField(
@@ -144,6 +165,16 @@ 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
+            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`
+                );
+            }
+
             delete metadata.DeliveryProfile;
         } catch (ex) {
             Util.logger.warn(` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`);

package/lib/metadataTypes/SenderProfile.js

@@ -1,6 +1,7 @@
 'use strict';
 
 import MetadataType from './MetadataType.js';
+import cache from '../util/cache.js';
 import { Util } from '../util/util.js';
 import ReplaceCbReference from '../util/replaceContentBlockReference.js';
 
@@ -77,6 +78,50 @@ class SenderProfile extends MetadataType {
         return super.deleteByKeySOAP(customerKey);
     }
 
+    /**
+     * manages post retrieve steps
+     *
+     * @param {MetadataTypeItem} metadata a single item
+     * @returns {MetadataTypeItem} a single item
+     */
+    static postRetrieveTasks(metadata) {
+        // makes or easier reading
+        if (metadata.Client) {
+            try {
+                metadata.createdBy = cache.searchForField(
+                    'user',
+                    metadata.Client.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.Client.ModifiedBy,
+                    'AccountUserID',
+                    'Name'
+                );
+            } catch (ex) {
+                Util.logger.verbose(
+                    ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                        metadata[this.definition.keyField]
+                    }): ${ex.message}.`
+                );
+            }
+
+            delete metadata.Client;
+        }
+        return metadata;
+    }
+
     /**
      * prepares a single item for deployment
      *
@@ -84,6 +129,10 @@ class SenderProfile extends MetadataType {
      * @returns {Promise.<MetadataTypeItem>} Promise
      */
     static async preDeployTasks(metadata) {
+        // cleanup
+        delete metadata.createdBy;
+        delete metadata.modifiedBy;
+
         if (
             metadata.UseDefaultRMMRules &&
             (metadata.AutoForwardToEmailAddress !== '' || metadata.AutoForwardToName !== '')

package/lib/metadataTypes/User.js

@@ -33,6 +33,7 @@ import cache from '../util/cache.js';
  */
 class User extends MetadataType {
     static userBUassignments;
+    static userIdBuMap;
 
     /**
      * Retrieves SOAP based metadata of metadata type into local filesystem. executes callback with retrieved metadata
@@ -44,7 +45,8 @@ class User extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static async retrieve(retrieveDir, _, __, key) {
-        if (this.buObject.eid !== this.buObject.mid) {
+        if (retrieveDir && this.buObject.eid !== this.buObject.mid) {
+            // only skip if this was not for caching
             Util.logger.info(' - Skipping User retrieval on non-parent BU');
             return;
         }
@@ -217,6 +219,22 @@ class User extends MetadataType {
         return metadata;
     }
 
+    /**
+     * MetadataType upsert, after retrieving from target and comparing to check if create or update operation is needed.
+     *
+     * @param {MetadataTypeMap} metadataMap metadata mapped by their keyField
+     * @param {string} deployDir directory where deploy metadata are saved
+     * @param {boolean} [runUpsertSequentially] when a type has self-dependencies creates need to run one at a time and created/changed keys need to be cached to ensure following creates/updates have thoses keys available
+     * @returns {Promise.<MetadataTypeMap>} keyField => metadata map
+     */
+    static async upsert(metadataMap, deployDir, runUpsertSequentially = false) {
+        if (typeof this.userIdBuMap !== 'object' || Object.keys(this.userIdBuMap).length === 0) {
+            this.cacheBusinessUnitAssignments();
+        }
+
+        return super.upsert(metadataMap, deployDir, runUpsertSequentially);
+    }
+
     /**
      * helper for {@link MetadataType.upsert}
      *
@@ -256,6 +274,7 @@ class User extends MetadataType {
     }
 
     /**
+     * helper for {@link createOrUpdate}
      *
      * @private
      * @param {MetadataTypeItem} metadata single metadata itme
@@ -313,7 +332,7 @@ class User extends MetadataType {
     }
 
     /**
-     * create/update business unit assignments
+     * create/update business unit assignments. helper for {@link postDeployTasks}
      *
      * @private
      * @param {UserDocumentMap} upsertResults metadata mapped by their keyField
@@ -589,7 +608,6 @@ class User extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static async _retrieve(retrieveDir, key) {
-        this.userIdBuMap = {};
         /** @type {SoapRequestParams} */
         const requestParams = {
             QueryAllAccounts: true,
@@ -693,50 +711,18 @@ class User extends MetadataType {
         }
 
         const metadata = this.parseResponseBody(resultsBulk);
-        // get BUs that each users have access to
-        if (resultsBulk?.Results?.length > 0) {
+        if (retrieveDir) {
             if (!singleRetrieve) {
                 Util.logger.info(
                     Util.getGrayMsg(`   - found ${resultsBulk?.Results.length} users`)
                 );
             }
-            // split array resultsBulk?.Results into chunks to avoid not getting all roles
-            const chunkSize = 100;
-            this.userIdBuMap = {};
-            Util.logger.info(` - Caching dependent Metadata: Business Unit assignments`);
-            for (let i = 0; i < resultsBulk?.Results?.length; i += chunkSize) {
-                if (i > 0) {
-                    Util.logger.info(
-                        Util.getGrayMsg(`   - Requesting next batch (retrieved BUs for ${i} users)`)
-                    );
-                }
-                const chunk = resultsBulk?.Results?.slice(i, i + chunkSize);
-                const resultsBatch = (
-                    await this.client.soap.retrieveBulk(
-                        'AccountUserAccount',
-                        ['AccountUser.AccountUserID', 'Account.ID'],
-                        {
-                            filter: {
-                                leftOperand: 'AccountUser.AccountUserID',
-                                operator: chunk.length > 1 ? 'IN' : 'equals', // API does not allow IN for single item
-                                rightOperand: chunk.map((item) => item.AccountUserID),
-                            },
-                        }
-                    )
-                ).Results;
-                for (const item of resultsBatch) {
-                    this.userIdBuMap[item.AccountUser.AccountUserID] ||= [];
-                    // push to array if not already in array
-                    if (
-                        !this.userIdBuMap[item.AccountUser.AccountUserID].includes(item.Account.ID)
-                    ) {
-                        this.userIdBuMap[item.AccountUser.AccountUserID].push(item.Account.ID);
-                    }
-                }
+            if (resultsBulk?.Results?.length > 0) {
+                // get BUs that each users have access to
+                // split array resultsBulk?.Results into chunks to avoid not getting all roles
+                await this.cacheBusinessUnitAssignments(resultsBulk.Results);
             }
-        }
 
-        if (retrieveDir) {
             const savedMetadata = await this.saveResults(metadata, retrieveDir, null);
             Util.logger.info(
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
@@ -771,6 +757,54 @@ class User extends MetadataType {
         return { metadata: metadata, type: this.definition.type };
     }
 
+    /**
+     * helper for {@link retrieveSOAP} and {@link upsert}; populates userIdBuMap
+     *
+     * @param {MetadataTypeItem[]} [metadataList] -
+     * @returns {Promise.<void>} -
+     */
+    static async cacheBusinessUnitAssignments(metadataList) {
+        if (!metadataList) {
+            // if run via upsert() then we won't have the metadataList with AccountUserID anywhere but in cache
+            const cacheUsers = cache.getCache().user;
+            metadataList = cacheUsers ? Object.values(cacheUsers) : [];
+        }
+        const chunkSize = 100;
+        this.userIdBuMap = {};
+        Util.logger.info(` - Caching dependent Metadata: Business Unit assignments`);
+        for (let i = 0; i < metadataList?.length; i += chunkSize) {
+            if (i > 0) {
+                Util.logger.info(
+                    Util.getGrayMsg(`   - Requesting next batch (retrieved BUs for ${i} users)`)
+                );
+            }
+            const accountUserIDList = metadataList
+                .map((item) => item.AccountUserID)
+                .filter(Boolean);
+            const chunk = accountUserIDList?.slice(i, i + chunkSize);
+            const resultsBatch = (
+                await this.client.soap.retrieveBulk(
+                    'AccountUserAccount',
+                    ['AccountUser.AccountUserID', 'Account.ID'],
+                    {
+                        filter: {
+                            leftOperand: 'AccountUser.AccountUserID',
+                            operator: chunk.length > 1 ? 'IN' : 'equals', // API does not allow IN for single item
+                            rightOperand: chunk,
+                        },
+                    }
+                )
+            ).Results;
+            for (const item of resultsBatch) {
+                this.userIdBuMap[item.AccountUser.AccountUserID] ||= [];
+                // push to array if not already in array
+                if (!this.userIdBuMap[item.AccountUser.AccountUserID].includes(item.Account.ID)) {
+                    this.userIdBuMap[item.AccountUser.AccountUserID].push(item.Account.ID);
+                }
+            }
+        }
+    }
+
     /**
      * helper for {@link User.retrieveSOAP}
      *

package/lib/metadataTypes/Verification.js

@@ -217,6 +217,21 @@ class Verification extends MetadataType {
      * @returns {VerificationItem} Array with one metadata object and one sql string
      */
     static postRetrieveTasks(metadata) {
+        try {
+            // @ts-expect-error
+            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.r__dataExtension_key = cache.searchForField(
                 'dataExtension',

package/lib/metadataTypes/definitions/DataExtract.definition.js

@@ -1,6 +1,6 @@
 export default {
     bodyIteratorField: 'items',
-    dependencies: ['dataExtractType'],
+    dependencies: ['dataExtractType', 'user'],
     dependencyGraph: null, // dataExtractType cannot be deployed
     hasExtended: true,
     idField: 'dataExtractDefinitionId',

package/lib/metadataTypes/definitions/Event.definition.js

@@ -1,6 +1,6 @@
 export default {
     bodyIteratorField: 'items',
-    dependencies: ['dataExtension'],
+    dependencies: ['dataExtension', 'user'],
     dependencyGraph: { dataExtension: ['r__dataExtension_key'] },
     hasExtended: false,
     idField: 'id',

package/lib/metadataTypes/definitions/Journey.definition.js

@@ -9,6 +9,7 @@ export default {
         'folder-journey',
         'triggeredSend', // for EMAILV2-activity
         'dataExtension', // for transactionalEmails: EMAILV2-activity
+        'deliveryProfile',
         'event', // for Multistep and Quicksend journeys
         'mobileMessage', // for SMSSYNC-activity
         'mobileCode', // for SMSSYNC-activity
@@ -27,6 +28,7 @@ export default {
             'activities.metaData.highThroughput.r__dataExtension_key',
             'activities.configurationArguments.triggeredSend.r__dataExtension_key.domainExclusions',
         ],
+        deliveryProfile: ['activities.configurationArguments.triggeredSend.r__deliveryProfile_key'],
         list: [
             'activities.configurationArguments.triggeredSend.r__list_PathName.publicationList',
             'activities.configurationArguments.triggeredSend.r__list_PathName.suppressionLists',
@@ -303,6 +305,12 @@ export default {
             retrieving: true,
             template: true,
         },
+        'activities[].configurationArguments.triggeredSend.deliveryProfileId': {
+            isCreateable: true,
+            isUpdateable: true,
+            retrieving: true,
+            template: true,
+        },
         'activities[].configurationArguments.triggeredSend.r__senderProfile_key': {
             isCreateable: false,
             isUpdateable: false,
@@ -315,6 +323,12 @@ export default {
             retrieving: true,
             template: true,
         },
+        'activities[].configurationArguments.triggeredSend.r__deliveryProfile_key': {
+            isCreateable: false,
+            isUpdateable: false,
+            retrieving: true,
+            template: true,
+        },
         'activities[].configurationArguments.triggeredSend.r__sendClassification_key': {
             isCreateable: false,
             isUpdateable: false,

package/lib/metadataTypes/definitions/Script.definition.js

@@ -10,9 +10,9 @@ export default {
     nameField: 'name',
     folderIdField: 'categoryId',
     createdDateField: 'createdDate',
-    createdNameField: 'createdBy',
+    createdNameField: null,
     lastmodDateField: 'modifiedDate',
-    lastmodNameField: 'modifiedBy',
+    lastmodNameField: null,
     restPagination: true,
     type: 'script',
     typeDescription: 'Execute more complex tasks via SSJS or AMPScript.',
@@ -26,6 +26,7 @@ export default {
             template: true,
         },
         createdBy: {
+            // not existing in rest api
             isCreateable: false,
             isUpdateable: false,
             retrieving: false,
@@ -56,6 +57,7 @@ export default {
             template: true,
         },
         modifiedBy: {
+            // not existing in rest api
             isCreateable: false,
             isUpdateable: false,
             retrieving: false,

package/lib/metadataTypes/definitions/SendClassification.definition.js

@@ -104,7 +104,7 @@ export default {
         'DeliveryProfile.ObjectID': {
             isCreateable: false,
             isUpdateable: false,
-            retrieving: false,
+            retrieving: true,
             template: false,
         },
         HonorPublicationListOptOutsForTransactionalSends: {