mcdev 7.0.4 → 7.1.0

package/lib/metadataTypes/Journey.js

@@ -86,7 +86,7 @@ class Journey extends MetadataType {
                 // caching or single retrieve
                 return await super.retrieveREST(
                     retrieveDir,
-                    `${uri}${singleKey}?extras=${extras}`,
+                    `${uri}${singleKey}?extras=${extras}${key && key.includes('/') ? '&versionNumber=' + key.split('/')[1] : ''}`,
                     null,
                     key
                 );
@@ -106,46 +106,52 @@ class Journey extends MetadataType {
                 }
                 // full details for retrieve
                 const extras = extrasDefault;
+                let parsed;
+                if (retrieveDir) {
+                    // get extra details for saving this
+                    const details = results.items
+                        ? await Promise.all(
+                              results.items.map(async (a) => {
+                                  try {
+                                      return await this.client.rest.get(
+                                          `${uri}key:${a[this.definition.keyField]}?extras=${extras}` +
+                                              `&versionNumber=${a.version}`
+                                      );
+                                  } catch (ex) {
+                                      // if we do get here, we should log the error and continue instead of failing to download all automations
+                                      Util.logger.warn(
+                                          ` ☇ skipping ${this.definition.type} ${
+                                              a[this.definition.nameField]
+                                          } (${a[this.definition.keyField]}): ${ex.message} (${
+                                              ex.code
+                                          })${
+                                              ex.endpoint
+                                                  ? Util.getGrayMsg(
+                                                        ' - ' +
+                                                            ex.endpoint.split(
+                                                                'rest.marketingcloudapis.com'
+                                                            )[1]
+                                                    )
+                                                  : ''
+                                          }`
+                                      );
+                                      return null;
+                                  }
+                              })
+                          )
+                        : [];
+                    parsed = this.parseResponseBody({ items: details.filter(Boolean) });
+                    // * retrieveDir is mandatory in this method as it is not used for caching (there is a seperate method for that)
+                    const savedMetadata = await this.saveResults(parsed, retrieveDir, null, null);
+                    Util.logger.info(
+                        `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
+                            Util.getKeysString(key)
+                    );
+                } else {
+                    // limit to main details for caching
+                    parsed = this.parseResponseBody(results);
+                }
 
-                const details = results.items
-                    ? await Promise.all(
-                          results.items.map(async (a) => {
-                              try {
-                                  return await this.client.rest.get(
-                                      `${uri}key:${a[this.definition.keyField]}?extras=${extras}` +
-                                          `&versionNumber=${a.version}`
-                                  );
-                              } catch (ex) {
-                                  // if we do get here, we should log the error and continue instead of failing to download all automations
-                                  Util.logger.warn(
-                                      ` ☇ skipping ${this.definition.type} ${
-                                          a[this.definition.nameField]
-                                      } (${a[this.definition.keyField]}): ${ex.message} (${
-                                          ex.code
-                                      })${
-                                          ex.endpoint
-                                              ? Util.getGrayMsg(
-                                                    ' - ' +
-                                                        ex.endpoint.split(
-                                                            'rest.marketingcloudapis.com'
-                                                        )[1]
-                                                )
-                                              : ''
-                                      }`
-                                  );
-                                  return null;
-                              }
-                          })
-                      )
-                    : [];
-                const parsed = this.parseResponseBody({ items: details.filter(Boolean) });
-
-                // * retrieveDir is mandatory in this method as it is not used for caching (there is a seperate method for that)
-                const savedMetadata = await this.saveResults(parsed, retrieveDir, null, null);
-                Util.logger.info(
-                    `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
-                        Util.getKeysString(key)
-                );
                 return {
                     metadata: parsed,
                     type: this.definition.type,
@@ -332,7 +338,7 @@ class Journey extends MetadataType {
                 // event / definitionType==='Multistep' && channel==='' && triggers[].type === 'EmailAudience'|'APIEvent'
                 if (
                     metadata.triggers?.length > 0 &&
-                    metadata.triggers[0].metaData?.eventDefinitionKey
+                    metadata.triggers[0].metaData?.eventDefinitionId
                 ) {
                     // trigger found; there can only be one entry in this array
                     try {
@@ -346,8 +352,10 @@ class Journey extends MetadataType {
                             Util.logger.debug(
                                 `eventDefinitionKey not matching eventDefinitionId. Overwriting '${metadata.triggers[0].metaData.eventDefinitionKey}' with the correct key '${edKey}'.`
                             );
-                            metadata.triggers[0].metaData.eventDefinitionKey = edKey;
                         }
+                        metadata.triggers[0].metaData.r__event_key = edKey;
+
+                        delete metadata.triggers[0].metaData.eventDefinitionKey;
                         delete metadata.triggers[0].metaData.eventDefinitionId;
                     } catch (ex) {
                         Util.logger.warn(
@@ -486,6 +494,7 @@ class Journey extends MetadataType {
                     const configurationArguments = activity.configurationArguments;
                     if (configurationArguments) {
                         try {
+                            // configurationArguments.triggeredSendKey && configurationArguments.triggeredSendId are only set on a running journey; if a journey is new, they do not exist
                             if (configurationArguments.triggeredSendId) {
                                 // triggeredSendKey is not always set but triggeredSendId is
                                 const tsKey = cache.searchForField(
@@ -536,6 +545,38 @@ class Journey extends MetadataType {
                     if (triggeredSend) {
                         // this section is likely only relevant for QuickSends and not for Multi-Step Journeys
 
+                        // triggeredSend key
+                        if (triggeredSend.id) {
+                            // triggeredSendKey is not always set but id is
+                            const tsKey = cache.searchForField(
+                                'triggeredSend',
+                                triggeredSend.id,
+                                'ObjectID',
+                                'CustomerKey'
+                            );
+                            if (triggeredSend.key != tsKey) {
+                                Util.logger.debug(
+                                    `key not matching id. Overwriting '${triggeredSend.key}' with the correct key '${tsKey}'.`
+                                );
+                                triggeredSend.key = tsKey;
+                            }
+                            triggeredSend.r__triggeredSend_key = triggeredSend.key;
+                            delete triggeredSend.key;
+                            delete triggeredSend.id;
+                        } else if (triggeredSend.key) {
+                            // very rare case but it's been seen that no id was saved
+                            Util.logger.debug(
+                                `key found on triggeredSend but no id present on journey activity. Checking key directly...`
+                            );
+                            triggeredSend.r__triggeredSend_key = cache.searchForField(
+                                'triggeredSend',
+                                triggeredSend.key,
+                                'CustomerKey',
+                                'CustomerKey'
+                            );
+                            delete triggeredSend.key;
+                        }
+
                         // List (optional)
                         triggeredSend.r__list_PathName = {};
                         if (triggeredSend.publicationListId) {
@@ -838,17 +879,17 @@ class Journey extends MetadataType {
                 // ~~~ TRIGGERS ~~~~
 
                 // event / definitionType==='Multistep' && channel==='' && triggers[].type === 'EmailAudience'|'APIEvent'
-                if (
-                    metadata.triggers?.length > 0 &&
-                    metadata.triggers[0].metaData?.eventDefinitionKey
-                ) {
+                if (metadata.triggers?.length > 0 && metadata.triggers[0].metaData?.r__event_key) {
                     // trigger found; there can only be one entry in this array
                     metadata.triggers[0].metaData.eventDefinitionId = cache.searchForField(
                         'event',
-                        metadata.triggers[0].metaData.eventDefinitionKey,
+                        metadata.triggers[0].metaData.r__event_key,
                         'eventDefinitionKey',
                         'id'
                     );
+                    metadata.triggers[0].metaData.eventDefinitionKey =
+                        metadata.triggers[0].metaData.r__event_key;
+                    delete metadata.triggers[0].metaData.r__event_key;
                 }
 
                 // transactionalEmail / definitionType==='Transactional' && channel==='email' && triggers[].type === 'transactional-api'
@@ -949,7 +990,7 @@ class Journey extends MetadataType {
                     // triggeredSend + email+asset
                     // TODO email / asset
                     const configurationArguments = activity.configurationArguments;
-                    if (configurationArguments && configurationArguments.r__triggeredSend_key) {
+                    if (configurationArguments?.r__triggeredSend_key) {
                         // triggeredSendKey is not always set but triggeredSendId is
                         configurationArguments.triggeredSendId = cache.searchForField(
                             'triggeredSend',
@@ -963,6 +1004,19 @@ class Journey extends MetadataType {
                     }
                     const triggeredSend = configurationArguments?.triggeredSend;
                     if (triggeredSend) {
+                        // triggeredSend key
+                        if (triggeredSend.r__triggeredSend_key) {
+                            // key is not always set but id is
+                            triggeredSend.id = cache.searchForField(
+                                'triggeredSend',
+                                triggeredSend.r__triggeredSend_key,
+                                'CustomerKey',
+                                'ObjectID'
+                            );
+                            triggeredSend.key = triggeredSend.r__triggeredSend_key;
+                            delete triggeredSend.r__triggeredSend_key;
+                        }
+
                         // List (optional)
                         if (triggeredSend.r__list_PathName) {
                             if (triggeredSend.r__list_PathName.publicationList) {
@@ -1175,9 +1229,11 @@ class Journey extends MetadataType {
     /**
      *
      * @param {MetadataTypeItem} item single metadata item
+     * @param {string} [_] parameter not used
+     * @param {Set.<string>} [findAssetKeys] list of keys that were found referenced via ContentBlockByX; if set, method only gets keys and runs no updates
      * @returns {Promise.<MetadataTypeItem>} key of the item that was updated
      */
-    static async replaceCbReference(item) {
+    static async replaceCbReference(item, _, findAssetKeys) {
         const parentName = `${this.definition.type} ${item[this.definition.keyField]}`;
         let changes = false;
         let error;
@@ -1198,7 +1254,8 @@ class Journey extends MetadataType {
                 try {
                     activity.arguments.emailSubjectDataBound = ReplaceCbReference.replaceReference(
                         activity.arguments.emailSubjectDataBound,
-                        parentName
+                        parentName,
+                        findAssetKeys
                     );
                     changes = true;
                 } catch (ex) {
@@ -1213,7 +1270,8 @@ class Journey extends MetadataType {
                 try {
                     triggeredSend.bccEmail = ReplaceCbReference.replaceReference(
                         triggeredSend.bccEmail,
-                        parentName
+                        parentName,
+                        findAssetKeys
                     );
                     changes = true;
                 } catch (ex) {
@@ -1224,7 +1282,8 @@ class Journey extends MetadataType {
                 try {
                     triggeredSend.ccEmail = ReplaceCbReference.replaceReference(
                         triggeredSend.ccEmail,
-                        parentName
+                        parentName,
+                        findAssetKeys
                     );
                     changes = true;
                 } catch (ex) {
@@ -1235,7 +1294,8 @@ class Journey extends MetadataType {
                 try {
                     triggeredSend.dynamicEmailSubject = ReplaceCbReference.replaceReference(
                         triggeredSend.dynamicEmailSubject,
-                        parentName
+                        parentName,
+                        findAssetKeys
                     );
                     changes = true;
                 } catch (ex) {
@@ -1246,7 +1306,8 @@ class Journey extends MetadataType {
                 try {
                     triggeredSend.emailSubject = ReplaceCbReference.replaceReference(
                         triggeredSend.emailSubject,
-                        parentName
+                        parentName,
+                        findAssetKeys
                     );
                     changes = true;
                 } catch (ex) {
@@ -1257,7 +1318,8 @@ class Journey extends MetadataType {
                 try {
                     triggeredSend.preHeader = ReplaceCbReference.replaceReference(
                         triggeredSend.preHeader,
-                        parentName
+                        parentName,
+                        findAssetKeys
                     );
                     changes = true;
                 } catch (ex) {
@@ -1268,7 +1330,8 @@ class Journey extends MetadataType {
                 try {
                     triggeredSend.exclusionFilter = ReplaceCbReference.replaceReference(
                         triggeredSend.exclusionFilter,
-                        parentName
+                        parentName,
+                        findAssetKeys
                     );
                     changes = true;
                 } catch (ex) {
@@ -1295,6 +1358,217 @@ class Journey extends MetadataType {
         // no error means we have a new item to deploy and need to update the item in our retrieve folder
         return item;
     }
+    /**
+     * Gets executed after deployment of metadata type
+     *
+     * @param {MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
+     */
+    static async postDeployTasks(upsertResults) {
+        if (Util.OPTIONS.publish) {
+            Util.logger.info(`Publishing: ${this.definition.type}`);
+            // pubslih
+            const idArr = Object.values(upsertResults).map(
+                (item) => 'id:' + item.id + '/' + item.version
+            );
+            await this.publish(idArr);
+        }
+    }
+    /**
+     * a function to publish the journey via API
+     *
+     * @param {string[]} keyArr keys or ids of the metadata
+     * @returns {Promise.<string[]>} Returns list of updated keys/ids that were published. Success could only be seen with a delay in the UI because the publish-endpoint is async
+     */
+    static async publish(keyArr) {
+        const results = [];
+        // works only with objectId
+        let objectId;
+        let idFound = false;
+        let versionFound = false;
+        const statusUrls = [];
+        for (let key of keyArr) {
+            let version;
+            if (key) {
+                if (key.startsWith('%23')) {
+                    // if the key started with %23 assume an ID was copied from the URL but the user forgot to prefix it with id:
+                    // correct the format
+                    key = 'id:' + key.slice(3);
+                }
+                if (key.startsWith('id:')) {
+                    idFound = true;
+                    // ! allow selecting journeys by ID because that's what users see in the URL
+                    // remove id
+                    objectId = key.slice(3);
+                    if (objectId.startsWith('%23')) {
+                        // in the journey URL the Id is prefixed with an HTML-encoded "#" which could accidentally be copied by users
+                        // despite the slicing above, this still needs testing here because users might have prefixed the ID with id: but did not know to remove the #23
+                        objectId = objectId.slice(3);
+                        // correct the format to ensure we show sth readable in the "Downloaded" log
+                        objectId = 'id:' + objectId;
+                        // update this here to show it in the log
+                        key = objectId;
+                    }
+                    if (objectId.includes('/')) {
+                        versionFound = true;
+                        version = objectId.split('/')[1];
+                        // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the ID for caching as we always aim to retrieve the latest version only
+                        objectId = objectId.split('/')[0];
+                    } else {
+                        // if we didn't find a version we need to cache this from the API after all
+                        objectId = null;
+                        if (key.includes('/')) {
+                            // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the key for caching as we always aim to retrieve the latest version only
+                            key = key.split('/')[0];
+                        }
+                    }
+                }
+                if (!objectId) {
+                    Util.logger.info(
+                        ` - getting${!idFound && !versionFound ? ' ID and' : ''} latest version from server`
+                    );
+                    const metadataMap = await this.retrieveForCache(undefined, undefined, key);
+                    const journey = Object.values(metadataMap.metadata);
+                    if (!journey.length) {
+                        Util.logger.info(`Skipping ${key} - did not find an item with such key`);
+                        continue;
+                    }
+                    objectId = journey[0].id;
+                    version = journey[0].version;
+                    if (!objectId || !version) {
+                        Util.logger.info(`Skipping ${key} - did not find an item with such key`);
+                        continue;
+                    }
+                }
+            }
+
+            results.push(
+                (async () => {
+                    try {
+                        const response = await this.client.rest.post(
+                            `/interaction/v1/interactions/publishAsync/${objectId}?versionNumber=${version}`,
+                            {}
+                        ); // payload is empty for this request
+                        if (response.statusUrl && response.statusId) {
+                            Util.logger.info(
+                                ` - queued for publishing ${this.definition.type}: ${key}`
+                            );
+                            statusUrls.push({ key, statusUrl: response.statusUrl });
+                        } else {
+                            throw new Error(response);
+                        }
+                        return key;
+                    } catch (ex) {
+                        if (ex.message === 'Cannot publish interaction in Published status.') {
+                            Util.logger.info(
+                                ` - ${this.definition.type} ${key} is already published`
+                            );
+                        } else if (ex.message === 'Cannot publish interaction in Stopped status.') {
+                            Util.logger.warn(
+                                ` - ${this.definition.type} ${key} is already published but stopped. Please resume it manually.`
+                            );
+                        } else {
+                            Util.logger.error(
+                                `Failed to publish ${this.definition.type} ${key}: ${ex.message}`
+                            );
+                        }
+                    }
+                })()
+            );
+        }
+        const executedKeyArr = (await Promise.all(results)).filter(Boolean);
+
+        if (!Util.OPTIONS.skipStatusCheck && statusUrls.length) {
+            Util.logger.info(
+                `Checking status of ${statusUrls.length} published item${statusUrls.length === 1 ? '' : 's'}`
+            );
+            executedKeyArr.length = 0;
+            await Util.sleep(5000);
+            for (const item of statusUrls) {
+                executedKeyArr.push(await this._checkPublishStatus(item.statusUrl, item.key));
+            }
+            // return executedKeyArr;
+        }
+        Util.logger.info(
+            `Published ${executedKeyArr.filter(Boolean).length} of ${keyArr.length} items`
+        );
+        return executedKeyArr.filter(Boolean);
+    }
+    /**
+     * helper for {@link Journey.publish}
+     *
+     * @param {string} statusUrl URL to check the status of the publish request
+     * @param {string} key key or id for log messages
+     * @param {number} [tries] number of tries used to check the status
+     * @returns {Promise.<string>} key of the item that was published successfully
+     */
+    static async _checkPublishStatus(statusUrl, key, tries = 1) {
+        try {
+            const response = await this.client.rest.get(statusUrl);
+            switch (response.status) {
+                case 'PublishCompleted': {
+                    Util.logger.info(` - ${this.definition.type} ${key}: publishing succeeded`);
+                    this._showPublishStatusDetails(response);
+                    return key;
+                }
+                case 'PublishInProcess': {
+                    Util.logger.info(
+                        ` - ${this.definition.type} ${key}: publishing still in progress`
+                    );
+                    if (tries < 50) {
+                        await (tries < 10 ? Util.sleep(2000) : Util.sleep(5000));
+                        return await this._checkPublishStatus(statusUrl, key, tries + 1);
+                    } else {
+                        return;
+                    }
+                }
+                case 'Error': {
+                    Util.logger.error(` - ${this.definition.type} ${key}: publishing failed.`);
+                    this._showPublishStatusDetails(response);
+                    return;
+                }
+                // No default
+            }
+        } catch (ex) {
+            Util.logger.error(`Failed to check status of ${key}: ${ex.message}`);
+        }
+    }
+
+    /**
+     * helper for {@link Journey._checkPublishStatus}
+     *
+     * @param {{status:string, errors:Array, warnings:Array}} response publishStatus response
+     */
+    static _showPublishStatusDetails(response) {
+        const types = { errors: 'Errors', warnings: 'Warnings' };
+        const messages = { errors: [], warnings: [] };
+        for (const type in types) {
+            let counter = 1;
+            if (response[type] && response[type].length) {
+                messages[type].push(`   ${types[type]}:`);
+                for (const msg of response[type]) {
+                    messages[type].push(
+                        `     #${counter++}`,
+                        `     Code: ${msg.errorCode}`,
+                        `     Details: ${msg.errorDetail}`
+                    );
+                    if (msg.additionalInfo && Object.keys(msg.additionalInfo).length) {
+                        messages[type].push(`     Additional Info:`);
+                        for (const key in msg.additionalInfo) {
+                            messages[type].push(`       ${key}: ${msg.additionalInfo[key]}`);
+                        }
+                    }
+                    // add spacer line
+                    messages[type].push('');
+                }
+            }
+        }
+        for (const msg of messages.errors) {
+            Util.logger.error(msg);
+        }
+        for (const msg of messages.warnings) {
+            Util.logger.warn(' ' + msg);
+        }
+    }
 }
 
 // Assign definition to static attributes