mcdev 7.2.0 → 7.3.0

package/lib/metadataTypes/Journey.js

@@ -2,11 +2,13 @@
 
 import MetadataType from './MetadataType.js';
 import TransactionalEmail from './TransactionalEmail.js';
+import Event from './Event.js';
 import { Util } from '../util/util.js';
 import cache from '../util/cache.js';
 import File from '../util/file.js';
 import ReplaceCbReference from '../util/replaceContentBlockReference.js';
 import Retriever from '../Retriever.js';
+import pLimit from 'p-limit';
 
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
@@ -235,7 +237,7 @@ class Journey extends MetadataType {
             );
             const results = this.parseResponseBody(response, key);
             singleKey = results[key].id;
-            if (version && version > results[key].version) {
+            if (version && version !== '*' && version > results[key].version) {
                 Util.logger.error(
                     `The chosen version (${version}) is higher than the latest known version (${results[key].version}). Please choose a lower version.`
                 );
@@ -243,20 +245,24 @@ class Journey extends MetadataType {
             }
             Util.logger.debug(`Deleting interaction ${key} via its ID ${singleKey}`);
         }
-        if (!/^\d+$/.test(version)) {
-            Util.logger.error(
-                'Version is required for deleting interactions to avoid accidental deletion of the wrong item. Please append it at the end of the key or id, separated by forward-slash. Example for deleting version 4: ' +
-                    key +
-                    '/4'
+        if (version !== '*') {
+            if (!/^\d+$/.test(version)) {
+                Util.logger.error(
+                    'Version is required for deleting interactions to avoid accidental deletion of the wrong item. Please append it at the end of the key or id, separated by forward-slash. Example for deleting version 4: ' +
+                        key +
+                        '/4'
+                );
+                return false;
+            }
+            Util.logger.warn(
+                `Deleting Journeys via this command breaks following retrieve-by-key/id requests until you've deployed/created a new draft version! You can get still get the latest available version of your journey by retrieving all interactions on this BU.`
             );
-            return false;
         }
-        Util.logger.warn(
-            `Deleting Journeys via this command breaks following retrieve-by-key/id requests until you've deployed/created a new draft version! You can get still get the latest available version of your journey by retrieving all interactions on this BU.`
-        );
 
         return super.deleteByKeyREST(
-            '/interaction/v1/interactions/' + singleKey + `?versionNumber=${version}`,
+            '/interaction/v1/interactions/' +
+                singleKey +
+                (version === '*' ? '' : `?versionNumber=${version}`),
             key,
             false
         );
@@ -342,12 +348,11 @@ class Journey extends MetadataType {
 
     /**
      * manages post retrieve steps
-     * ! BETA RELEASE of journey support (v4.3.0); it so far only resolves a limited amount of dependencies and will likely break during cross-BU deployments!
      *
      * @param {MetadataTypeItem} metadata a single item
-     * @returns {MetadataTypeItem} Array with one metadata object
+     * @returns {Promise.<MetadataTypeItem>} Array with one metadata object
      */
-    static postRetrieveTasks(metadata) {
+    static async postRetrieveTasks(metadata) {
         // folder
         super.setFolderPath(metadata);
 
@@ -408,6 +413,18 @@ class Journey extends MetadataType {
                             }
                         }
                     }
+                    try {
+                        await Event.postRetrieveTasks_SalesforceEntryEvents(
+                            metadata.triggers[0].type,
+                            metadata.triggers[0].configurationArguments,
+                            metadata.key,
+                            this.definition.type
+                        );
+                    } catch (ex) {
+                        Util.logger.warn(
+                            ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): ${ex.message}`
+                        );
+                    }
                 }
                 // ~~~ ACTIVITIES ~~~~
 
@@ -588,6 +605,15 @@ class Journey extends MetadataType {
                             );
                         }
                     }
+                    if (
+                        configurationArguments?.triggeredSend &&
+                        'string' === typeof configurationArguments?.triggeredSend
+                    ) {
+                        // sometimes, the API returns this object as a string for unknown reasons. Good job, product team!
+                        configurationArguments.triggeredSend = JSON.parse(
+                            configurationArguments?.triggeredSend
+                        );
+                    }
                     const triggeredSend = configurationArguments?.triggeredSend;
                     if (triggeredSend) {
                         // this section is likely only relevant for QuickSends and not for Multi-Step Journeys
@@ -617,36 +643,34 @@ class Journey extends MetadataType {
 
                             if (linkedTS.SenderProfile?.CustomerKey) {
                                 try {
-                                    cache.searchForField(
+                                    const spKey = cache.searchForField(
                                         'senderProfile',
-                                        linkedTS.SenderProfile.CustomerKey,
-                                        'CustomerKey',
+                                        linkedTS.SenderProfile.ObjectID,
+                                        'ObjectID',
                                         'CustomerKey'
                                     );
-                                    triggeredSend.r__senderProfile_key =
-                                        linkedTS.SenderProfile.CustomerKey;
+                                    triggeredSend.r__senderProfile_key = spKey;
                                     delete triggeredSend.senderProfileId;
                                 } catch (ex) {
                                     Util.logger.warn(
-                                        ` - ${this.definition.type} ${linkedTS.CustomerKey}: ${ex.message}`
+                                        ` - triggeredSend ${linkedTS.CustomerKey}: ${ex.message} (senderProfile key ${linkedTS.SenderProfile.CustomerKey})`
                                     );
                                 }
                             }
                             // send classification
                             if (linkedTS.SendClassification?.CustomerKey) {
                                 try {
-                                    cache.searchForField(
+                                    const scKey = cache.searchForField(
                                         'sendClassification',
-                                        linkedTS.SendClassification.CustomerKey,
-                                        'CustomerKey',
+                                        linkedTS.SendClassification.ObjectID,
+                                        'ObjectID',
                                         'CustomerKey'
                                     );
-                                    triggeredSend.r__sendClassification_key =
-                                        linkedTS.SendClassification.CustomerKey;
+                                    triggeredSend.r__sendClassification_key = scKey;
                                     delete triggeredSend.sendClassificationId;
                                 } catch (ex) {
                                     Util.logger.warn(
-                                        ` - ${this.definition.type} ${linkedTS.CustomerKey}: ${ex.message}`
+                                        ` - triggeredSend ${linkedTS.CustomerKey}: ${ex.message} (sendClassification key ${linkedTS.SendClassification.CustomerKey})`
                                     );
                                 }
                             }
@@ -1010,6 +1034,10 @@ class Journey extends MetadataType {
                             delete config.r__dataExtension_key;
                         }
                     }
+                    Event.preDeployTasks_SalesforceEntryEvents(
+                        metadata.triggers[0].type,
+                        metadata.triggers[0].configurationArguments
+                    );
                 }
 
                 // transactionalEmail / definitionType==='Transactional' && channel==='email' && triggers[].type === 'transactional-api'
@@ -1018,13 +1046,6 @@ class Journey extends MetadataType {
 
                 this._preDeployTasks_activities(metadata);
 
-                // TODO: Filters / activities[].type === 'MULTICRITERIADECISION'
-                // - activities[].arguments.filterResult
-                // - activities[].arguments.configurationArguments.criteria
-
-                // TODO: wait activity / activities[].type === 'WAIT'
-
-                // TODO: journey template id? / metaData.templateId
                 break;
             }
             case 'Transactional': {
@@ -1837,6 +1858,96 @@ class Journey extends MetadataType {
             Util.logger.warn(' ' + msg);
         }
     }
+    /**
+     * stops latest journey version
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were paused
+     */
+    static async stop(keyArr) {
+        let version;
+        const endpoint = '/interaction/v1/interactions/stop/';
+        const stoppedKeyArr = [];
+        const apiLimit = pLimit(20);
+        const journeyCache = await this.retrieveForCache();
+
+        await Promise.allSettled(
+            keyArr.map((key) =>
+                apiLimit(async () => {
+                    [key, version] = key.split('/');
+                    if (journeyCache.metadata[key]) {
+                        version ||= journeyCache.metadata[key].version;
+                        if (version === '*') {
+                            Util.logger.warn(
+                                ` ☇ skipping ${this.definition.type} ${key}: Cannot stop all versions at once. The highest version is ${journeyCache.metadata[key].version}`
+                            );
+                            return;
+                        }
+                        try {
+                            await this.client.rest.post(
+                                endpoint +
+                                    journeyCache.metadata[key].id +
+                                    `?versionNumber=${version}`,
+                                {}
+                            );
+                            Util.logger.info(
+                                ` - Stopped ${this.definition.type} ${key}/${version}`
+                            );
+                            stoppedKeyArr.push(key);
+                        } catch (ex) {
+                            Util.logger.error(
+                                ` - Stopping ${this.definition.type} ${key} failed: ${ex.message}`
+                            );
+                        }
+                    }
+                })
+            )
+        );
+
+        return stoppedKeyArr;
+    }
+    /**
+     * pauses all journey versions
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were paused
+     */
+    static async pause(keyArr) {
+        let version;
+        const endpoint = '/interaction/v1/interactions/pause/';
+        const stoppedKeyArr = [];
+        const apiLimit = pLimit(20);
+        const journeyCache = await this.retrieveForCache();
+
+        await Promise.allSettled(
+            keyArr.map((key) =>
+                apiLimit(async () => {
+                    [key, version] = key.split('/');
+                    if (journeyCache.metadata[key]) {
+                        version ||= journeyCache.metadata[key].version;
+                        try {
+                            await this.client.rest.post(
+                                endpoint +
+                                    journeyCache.metadata[key].id +
+                                    (version === '*'
+                                        ? '?allVersions=true'
+                                        : `?versionNumber=${version}`),
+                                {}
+                            );
+                            Util.logger.info(` - Paused ${this.definition.type} ${key}/${version}`);
+                            stoppedKeyArr.push(key);
+                        } catch (ex) {
+                            Util.logger.error(
+                                ` - Pausing ${this.definition.type} ${key} failed: ${ex.message}`
+                            );
+                        }
+                    }
+                })
+            )
+        );
+
+        return stoppedKeyArr;
+    }
 }
 
 // Assign definition to static attributes

package/lib/metadataTypes/MetadataType.js

@@ -622,6 +622,19 @@ class MetadataType {
         return [];
     }
 
+    /**
+     * Abstract stop method that needs to be implemented in child metadata type
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were stopped
+     */
+    static async stop(keyArr) {
+        Util.logger.error(
+            ` ☇ skipping ${this.definition.type}: stop is not supported yet for ${this.definition.type}`
+        );
+        return [];
+    }
+
     /**
      * test if metadata was actually changed or not to potentially skip it during deployment
      *
@@ -1899,9 +1912,10 @@ class MetadataType {
                     templateVariables
                 );
             } catch (ex) {
+                Util.logger.debug(JSON.stringify(savedResults[originalKey]));
                 Util.logger.errorStack(
                     ex,
-                    ` - Saving ${this.definition.type} ${originalKey} failed`
+                    ` - Saving ${this.definition.type} ${originalKey} / ${results[originalKey][this.definition.nameField]} failed`
                 );
             }
         }
@@ -2349,7 +2363,7 @@ class MetadataType {
                     ? `${ex.results[0].StatusMessage} (Code ${ex.results[0].ErrorCode})`
                     : ex.message;
                 Util.logger.error(
-                    `- error deleting ${this.definition.type} '${customerKey}': ${errorMsg}`
+                    ` - Deleting ${this.definition.type} '${customerKey}' failed: ${errorMsg}`
                 );
             }
 

package/lib/metadataTypes/MobileKeyword.js

@@ -537,7 +537,7 @@ class MobileKeyword extends MetadataType {
         // get id from cache
         const { metadata } = await this.retrieveForCache(undefined, undefined, key);
         if (!metadata[key]) {
-            Util.logger.error(`Could not find ${this.definition.type} with key ${key}.`);
+            Util.logger.error(` - mobileKeyword ${key} not found`);
             return false;
         }
         const id = metadata[key][this.definition.idField];

package/lib/metadataTypes/Query.js

@@ -456,7 +456,7 @@ class Query extends MetadataType {
         // delete only works with the query's object id
         const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
         if (!objectId) {
-            Util.logger.error(` - query not found`);
+            Util.logger.error(` - query ${customerKey} not found`);
             return false;
         }
         return super.deleteByKeyREST('/automation/v1/queries/' + objectId, customerKey);

package/lib/metadataTypes/Script.js

@@ -379,7 +379,7 @@ class Script extends MetadataType {
         // delete only works with the query's object id
         const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
         if (!objectId) {
-            Util.logger.error(` - ${this.definition.type} not found`);
+            Util.logger.error(` - ${this.definition.type} ${customerKey} not found`);
             return false;
         }
         return super.deleteByKeyREST('/automation/v1/scripts/' + objectId, customerKey);

package/lib/metadataTypes/SendClassification.js

@@ -88,13 +88,15 @@ class SendClassification extends MetadataType {
             this.definition.sendClassificationTypeMapping[metadata.c__classification];
         delete metadata.c__classification;
 
+        const spId = cache.searchForField(
+            'senderProfile',
+            metadata.r__senderProfile_key,
+            'CustomerKey',
+            'ObjectID'
+        );
         metadata.SenderProfile = {
-            CustomerKey: cache.searchForField(
-                'senderProfile',
-                metadata.r__senderProfile_key,
-                'CustomerKey',
-                'CustomerKey'
-            ),
+            ObjectID: spId,
+            CustomerKey: metadata.r__senderProfile_key,
         };
         delete metadata.r__senderProfile_key;
 
@@ -127,8 +129,8 @@ class SendClassification extends MetadataType {
         try {
             metadata.r__senderProfile_key = cache.searchForField(
                 'senderProfile',
-                metadata.SenderProfile.CustomerKey,
-                'CustomerKey',
+                metadata.SenderProfile.ObjectID,
+                'ObjectID',
                 'CustomerKey'
             );
             delete metadata.SenderProfile;

package/lib/metadataTypes/TriggeredSend.js

@@ -168,36 +168,36 @@ class TriggeredSend extends MetadataType {
         }
 
         // sender profile
-        if (metadata.SenderProfile?.CustomerKey) {
+        if (metadata.SenderProfile?.ObjectID) {
             try {
-                cache.searchForField(
+                const spKey = cache.searchForField(
                     'senderProfile',
-                    metadata.SenderProfile.CustomerKey,
-                    'CustomerKey',
+                    metadata.SenderProfile.ObjectID,
+                    'ObjectID',
                     'CustomerKey'
                 );
-                metadata.r__senderProfile_key = metadata.SenderProfile.CustomerKey;
+                metadata.r__senderProfile_key = spKey;
                 delete metadata.SenderProfile;
             } catch (ex) {
                 Util.logger.warn(
-                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message} (senderProfile key ${metadata.SenderProfile.CustomerKey})`
                 );
             }
         }
         // send classification
-        if (metadata.SendClassification?.CustomerKey) {
+        if (metadata.SendClassification?.ObjectID) {
             try {
-                cache.searchForField(
+                const scKey = cache.searchForField(
                     'sendClassification',
-                    metadata.SendClassification.CustomerKey,
-                    'CustomerKey',
+                    metadata.SendClassification.ObjectID,
+                    'ObjectID',
                     'CustomerKey'
                 );
-                metadata.r__sendClassification_key = metadata.SendClassification.CustomerKey;
+                metadata.r__sendClassification_key = scKey;
                 delete metadata.SendClassification;
             } catch (ex) {
                 Util.logger.warn(
-                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message} (sendClassification key ${metadata.SendClassification.CustomerKey})`
                 );
             }
         }
@@ -268,26 +268,28 @@ class TriggeredSend extends MetadataType {
         }
         // sender profile
         if (metadata.r__senderProfile_key) {
-            cache.searchForField(
+            const spId = cache.searchForField(
                 'senderProfile',
                 metadata.r__senderProfile_key,
                 'CustomerKey',
-                'CustomerKey'
+                'ObjectID'
             );
             metadata.SenderProfile = {
+                ObjectID: spId,
                 CustomerKey: metadata.r__senderProfile_key,
             };
             delete metadata.r__senderProfile_key;
         }
         // send classification
         if (metadata.r__sendClassification_key) {
-            cache.searchForField(
+            const scId = cache.searchForField(
                 'sendClassification',
                 metadata.r__sendClassification_key,
                 'CustomerKey',
-                'CustomerKey'
+                'ObjectID'
             );
             metadata.SendClassification = {
+                ObjectID: scId,
                 CustomerKey: metadata.r__sendClassification_key,
             };
             delete metadata.r__sendClassification_key;

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

@@ -123,8 +123,8 @@ export default {
             template: false,
         },
         CreatedDate: {
-            isCreateable: false,
-            isUpdateable: false,
+            isCreateable: true,
+            isUpdateable: true,
             retrieving: true,
             template: false,
         },
@@ -189,8 +189,8 @@ export default {
             template: true,
         },
         ModifiedDate: {
-            isCreateable: false,
-            isUpdateable: false,
+            isCreateable: true,
+            isUpdateable: true,
             retrieving: true,
             template: false,
         },

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

@@ -81,8 +81,8 @@ export default {
             templating: false,
         },
         CreatedDate: {
-            isCreateable: false,
-            isUpdateable: false,
+            isCreateable: true,
+            isUpdateable: true,
             retrieving: true,
             templating: false,
         },
@@ -333,8 +333,8 @@ export default {
             templating: false,
         },
         ModifiedDate: {
-            isCreateable: false,
-            isUpdateable: false,
+            isCreateable: true,
+            isUpdateable: true,
             retrieving: true,
             templating: false,
         },