mcdev 7.6.3 → 7.7.1

package/lib/metadataTypes/Journey.js

@@ -47,10 +47,6 @@ class Journey extends MetadataType {
      */
     static async retrieve(retrieveDir, _, __, key) {
         const extrasDefault = 'activities';
-        if (retrieveDir) {
-            // only print this during retrieve, not during retrieveForCache
-            Util.logBeta(this.definition.type);
-        }
 
         let singleKey = '';
         let mode = 'all';
@@ -294,31 +290,48 @@ class Journey extends MetadataType {
                 );
                 // break;
             }
-            default: {
-                // Quicksend, Transactional dont have versions
-                const response = await super.deleteByKeyREST(
+            case 'Quicksend': {
+                // Quicksend doesnt have versions
+                const isDeleted = await super.deleteByKeyREST(
+                    '/interaction/v1/interactions/' + id,
+                    key,
+                    false
+                );
+                return isDeleted;
+            }
+            case 'Transactional': {
+                //  Transactional dont have versions
+                const isDeleted = await super.deleteByKeyREST(
                     '/interaction/v1/interactions/' + id,
                     key,
                     false
                 );
-                if (response && cachedJourney.definitionType === 'Transactional') {
+                const transactionalEmailKey =
+                    cachedJourney.activities[0]?.configurationArguments?.triggeredSendKey;
+                if (isDeleted) {
                     const msg = [];
                     if (cachedJourney.activities[0]?.configurationArguments?.triggeredSendKey) {
                         msg.push(
                             `transactionalEmail "${cachedJourney.activities[0].configurationArguments.triggeredSendKey}"`
                         );
                     }
-                    if (msg.length) {
-                        Util.logger.info(` - Remember to also delete linked ${msg.join(' and ')}`);
-                    }
                 }
-                return response;
+                if (isDeleted && transactionalEmailKey) {
+                    Util.logger.info(
+                        ` - deleted ${TransactionalEmail.definition.type}: ${transactionalEmailKey} (SFMC auto-deletes the related transactionalEmail of ${this.definition.type} ${key})`
+                    );
+                    TransactionalEmail.buObject = this.buObject;
+                    TransactionalEmail.properties = this.properties;
+                    TransactionalEmail.client = this.client;
+                    TransactionalEmail.postDeleteTasks(transactionalEmailKey);
+                }
+                return isDeleted;
             }
         }
     }
 
     /**
-     * Deploys metadata - merely kept here to be able to print {@link Util.logBeta} once per deploy
+     * Deploys metadata
      *
      * @param {MetadataTypeMap} metadataMap metadata mapped by their keyField
      * @param {string} deployDir directory where deploy metadata are saved
@@ -420,6 +433,10 @@ class Journey extends MetadataType {
      */
     static async postRetrieveTasks(metadata) {
         // folder
+        if (metadata.r__folder_Path && Util.OPTIONS.publish) {
+            // if we re-retrieve this as part of deploy with --publish then the cached version will already have been processed
+            return metadata;
+        }
         super.setFolderPath(metadata);
 
         switch (metadata.definitionType) {
@@ -536,7 +553,7 @@ class Journey extends MetadataType {
                                         );
                                     }
                                     activity.configurationArguments.r__transactionalEmail_key =
-                                        activity.configurationArguments.triggeredSendKey;
+                                        tEmailKey;
                                     delete activity.configurationArguments.triggeredSendKey;
                                     delete activity.configurationArguments.triggeredSendId;
                                 } catch (ex) {
@@ -1298,8 +1315,31 @@ class Journey extends MetadataType {
             }
             case 'Transactional': {
                 const cachedVersion = cache.getByKey('journey', metadata.key);
-                if (cachedVersion.status === 'Published') {
-                    throw new Error(`Cannot update transactional-send journey in Published status`);
+                if (cachedVersion?.status === 'Published') {
+                    if (Util.OPTIONS.publish) {
+                        Util.logger.info(
+                            ` - ${this.definition.type} ${metadata.key}: --publish option used. Automatically pausing journey to allow for updates.`
+                        );
+
+                        const pausedKeys = await this.pause([metadata.key], {
+                            metadata: cache.getCache().journey,
+                            type: this.definition.type,
+                        });
+                        if (!pausedKeys?.length || pausedKeys[0] !== metadata.key) {
+                            Util.logger.error(
+                                ` - failed to pause ${this.definition.typeName}: ${metadata.key}`
+                            );
+                            throw new Error(
+                                `Cannot update transactional-send journey in Published status. Automatic pausing failed.`
+                            );
+                        }
+
+                        cachedVersion.status = 'Paused';
+                    } else {
+                        throw new Error(
+                            `Cannot update transactional-send journey in Published status. Run depoy with --publish to auto-pause & republish the journey.`
+                        );
+                    }
                 }
 
                 // Transactional Send Journey
@@ -1353,6 +1393,7 @@ class Journey extends MetadataType {
                         }
 
                         if (activity.metaData?.highThroughput?.r__dataExtension_key) {
+                            // if this is set during create, we expect that the DE is already present (part of current deployment or already existing)
                             activity.metaData.highThroughput.dataExtensionId = cache.searchForField(
                                 'dataExtension',
                                 activity.metaData.highThroughput.r__dataExtension_key,
@@ -1880,7 +1921,7 @@ class Journey extends MetadataType {
      * a function to publish the journey via API
      *
      * @param {string[]} keyArr keys or ids of the metadata
-     * @param {MetadataTypeMap} [upsertResults] metadata mapped by their keyField as returned by update/create
+     * @param {MetadataTypeMap} [upsertResults] metadata mapped by their keyField as returned by update/create; needs to be refreshed after publish
      * @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, upsertResults) {
@@ -1892,243 +1933,286 @@ class Journey extends MetadataType {
         const metadataMap = upsertResults
             ? { metadata: upsertResults }
             : await this.retrieveForCache();
-        const spinnerTransactional = yoctoSpinner({
-            text: `Publishing transactional journey…`,
-        });
 
-        for (let key of keyArr) {
-            let objectId;
-            let version;
-            let journey;
-            if (!key) {
-                continue;
-            }
-            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:')) {
-                // ! 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 =  objectId;
-                    // update this here to show it in the log
-                    key = 'id:' + objectId;
+        const publishedJourneyCounter = {
+            multiStep: 0,
+            transactional: 0,
+        };
+
+        // does not matter definitionType we run first, but the logs look bad if we dont sort them
+        const processingOrder = {
+            Transactional: `Publishing transactional journey…`,
+            Multistep: `Publishing multi-step journey…`,
+        };
+        for (const definitionType of Object.keys(processingOrder)) {
+            const spinner = yoctoSpinner({
+                text: processingOrder[definitionType],
+            });
+
+            for (let key of keyArr) {
+                let objectId;
+                let version;
+                let journey;
+                if (!key) {
+                    continue;
                 }
-                if (objectId.includes('/')) {
-                    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];
+                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:')) {
+                    // ! 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 =  objectId;
+                        // update this here to show it in the log
+                        key = 'id:' + objectId;
+                    }
+                    if (objectId.includes('/')) {
+                        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
+                        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];
+                        }
+                    }
+                    journey = Object.values(metadataMap.metadata).find((el) => el.id === objectId);
+                    if (!journey) {
+                        Util.logger.info(
+                            ` ☇ skipping ${this.definition.type} ${key}: not found on server (1)`
+                        );
+                        continue;
+                    }
                 } else {
-                    // if we didn't find a version we need to cache this from the API after all
-                    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];
+                    // key assumed
+                    journey = metadataMap.metadata[key];
+                }
+
+                if (journey && journey.definitionType !== definitionType) {
+                    // to allow consistent log output we enforce publishing is sorted by definitionType
+                    if (!processingOrder[journey.definitionType]) {
+                        throw new Error(
+                            `${this.definition.type} type ${journey.definitionType} not supported yet by publish method`
+                        );
                     }
+                    continue;
                 }
-                journey = Object.values(metadataMap.metadata).find((el) => el.id === objectId);
+
                 if (!journey) {
                     Util.logger.info(
-                        ` ☇ skipping ${this.definition.type} ${key}: not found on server (1)`
+                        ` ☇ skipping ${this.definition.type} ${key}: not found on server (2)`
                     );
                     continue;
                 }
-            } else {
-                // key assumed
-                journey = metadataMap.metadata[key];
-            }
 
-            if (!journey) {
-                Util.logger.info(
-                    ` ☇ skipping ${this.definition.type} ${key}: not found on server (2)`
-                );
-                continue;
-            }
-            if (!version) {
-                version = journey.version;
-            }
-            if (journey.status === 'Published') {
-                // api would return error code 30000 and ask to open a support case when in fact we simply already have a transactionalEmail created based on this status
-                if (journey.definitionType === 'Transactional') {
+                if (!version) {
+                    version = journey.version;
+                }
+                if (journey.status === 'Published') {
+                    // api would return error code 30000 and ask to open a support case when in fact we simply already have a transactionalEmail created based on this status
+                    if (journey.definitionType === 'Transactional') {
+                        Util.logger.info(
+                            ` ☇ skipping ${this.definition.type} ${
+                                journey[this.definition.nameField]
+                            } (${journey[this.definition.keyField]}): already published. Queueing for refresh.`
+                        );
+                        refreshTransactionalKeys.push(journey.key);
+                    } else {
+                        Util.logger.warn(
+                            ` ☇ skipping ${this.definition.type} ${
+                                journey[this.definition.nameField]
+                            } (${journey[this.definition.keyField]}): already published.`
+                        );
+                    }
+                    continue;
+                } else if (
+                    journey.status === 'Paused' &&
+                    journey.definitionType === 'Transactional'
+                ) {
                     Util.logger.info(
                         ` ☇ skipping ${this.definition.type} ${
                             journey[this.definition.nameField]
-                        } (${journey[this.definition.keyField]}): already published. Queueing for refresh.`
+                        } (${journey[this.definition.keyField]}): currently paused. Queueing for refresh.`
                     );
                     refreshTransactionalKeys.push(journey.key);
-                } else {
-                    Util.logger.warn(
-                        ` ☇ skipping ${this.definition.type} ${
-                            journey[this.definition.nameField]
-                        } (${journey[this.definition.keyField]}): already published.`
-                    );
+                    continue;
                 }
-                continue;
-            }
 
-            switch (journey.definitionType) {
-                case 'Transactional': {
-                    resultsTransactional.push(
-                        (async () => {
-                            spinnerTransactional.start();
-                            try {
-                                const response = await this.client.rest.post(
-                                    `/interaction/v1/interactions/transactional/create`,
-                                    { definitionId: journey.id }
-                                );
-                                if (response.errors?.length) {
-                                    throw new Error(JSON.stringify(response));
-                                } else {
-                                    spinnerTransactional.stop();
-                                    Util.logger.info(
-                                        ` - published ${this.definition.type}: ${
-                                            journey[this.definition.nameField]
-                                        } (${journey[this.definition.keyField]}) by creating the matching transactionalEmail`
-                                    );
-                                    statusUrls.push({ key, statusUrl: response.statusUrl });
-                                }
-                                spinnerTransactional.start();
-                                return journey[this.definition.keyField];
-                            } catch (ex) {
-                                spinnerTransactional.stop();
-                                if (
-                                    ex.response.status === 400 &&
-                                    ex.response?.data?.errors?.length === 1 &&
-                                    ex.response?.data?.errors?.[0]?.errorCode === '121500'
-                                ) {
-                                    Util.logger.error(
-                                        `Failed to publish ${
-                                            journey[this.definition.nameField]
-                                        } (${journey[this.definition.keyField]}): Make sure the Event Definition Key, Data Extension and E-Mail are saved to the journey`
-                                    );
-                                } else {
-                                    Util.logger.error(
-                                        `Failed to publish ${
-                                            journey[this.definition.nameField]
-                                        } (${journey[this.definition.keyField]}): ${ex.message}`
+                switch (journey.definitionType) {
+                    case 'Transactional': {
+                        resultsTransactional.push(
+                            (async () => {
+                                spinner.start();
+                                try {
+                                    const response = await this.client.rest.post(
+                                        `/interaction/v1/interactions/transactional/create`,
+                                        { definitionId: journey.id }
                                     );
-                                    if (ex.response?.data?.errors?.length) {
+                                    if (response.errors?.length) {
+                                        throw new Error(JSON.stringify(response));
+                                    } else {
+                                        spinner.stop();
+                                        Util.logger.info(
+                                            ` - published ${this.definition.type}: ${
+                                                journey[this.definition.nameField]
+                                            } (${journey[this.definition.keyField]}) by creating the matching transactionalEmail`
+                                        );
+                                        statusUrls.push({ key, statusUrl: response.statusUrl });
+                                    }
+                                    spinner.start();
+                                    return journey[this.definition.keyField];
+                                } catch (ex) {
+                                    spinner.stop();
+                                    if (
+                                        ex.response.status === 400 &&
+                                        ex.response?.data?.errors?.length === 1 &&
+                                        ex.response?.data?.errors?.[0]?.errorCode === '121500'
+                                    ) {
+                                        Util.logger.error(
+                                            `Failed to publish ${
+                                                journey[this.definition.nameField]
+                                            } (${journey[this.definition.keyField]}): Make sure the Event Definition Key, Data Extension and E-Mail are saved to the journey`
+                                        );
+                                    } else {
                                         Util.logger.error(
-                                            JSON.stringify(ex.response?.data?.errors, null, 2)
+                                            `Failed to publish ${
+                                                journey[this.definition.nameField]
+                                            } (${journey[this.definition.keyField]}): ${ex.message}`
                                         );
+                                        if (ex.response?.data?.errors?.length) {
+                                            Util.logger.error(
+                                                JSON.stringify(ex.response?.data?.errors, null, 2)
+                                            );
+                                        }
                                     }
+                                    spinner.start();
                                 }
-                                spinnerTransactional.start();
-                            }
-                        })()
-                    );
-                    break;
-                }
-                case 'Multistep': {
-                    // SF Event, Api Event Journeys
-                    // ! for SF-triggered journeys this cannot be asynchronous or it will cause a race-condition (see #1627 for details); the requests are accepted but then processed sequentually anyways, eliminating potential speed gains.
-                    // It is unknown if the same would happen for API-event journeys but given that it's the same endpoint, lets not risk it and run this sequentially
-                    let statusUrl;
-                    try {
-                        const response = await this.client.rest.post(
-                            `/interaction/v1/interactions/publishAsync/${journey.id}?versionNumber=${version}`,
-                            {}
-                        ); // payload is empty for this request
-                        if (response.statusUrl && response.statusId) {
-                            Util.logger.info(
-                                ` - ${this.definition.type} queued for publishing: ${journey[this.definition.keyField]}/${version} / ${journey[this.definition.nameField]}`
-                            );
-                            statusUrl = response.statusUrl;
-                        } else {
-                            throw new Error(response);
-                        }
-                        if (Util.OPTIONS.skipStatusCheck) {
-                            Util.logger.warn(
-                                ` - Skipping status check for publishing journey ${key} due to --skipStatusCheck flag`
-                            );
-                        }
-                        if (!Util.OPTIONS.skipStatusCheck && statusUrl) {
-                            const spinner = yoctoSpinner({
-                                text: `Publishing journey…`,
-                            }).start();
-
-                            await Util.sleep(1000);
-                            executedKeyArr.push(
-                                await this._checkPublishStatus(
-                                    statusUrl,
-                                    journey[this.definition.keyField],
-                                    journey[this.definition.nameField],
-                                    spinner
-                                )
-                            );
-                        } else {
-                            // no guarantees if the journey was actually published
-                            executedKeyArr.push(key);
-                        }
-                    } catch (ex) {
-                        switch (ex.message) {
-                            case 'Cannot publish interaction in Published status.': {
+                            })()
+                        );
+                        break;
+                    }
+                    case 'Multistep': {
+                        // SF Event, Api Event Journeys
+                        // ! for SF-triggered journeys this cannot be asynchronous or it will cause a race-condition (see #1627 for details); the requests are accepted but then processed sequentually anyways, eliminating potential speed gains.
+                        // It is unknown if the same would happen for API-event journeys but given that it's the same endpoint, lets not risk it and run this sequentially
+                        let statusUrl;
+                        try {
+                            const response = await this.client.rest.post(
+                                `/interaction/v1/interactions/publishAsync/${journey.id}?versionNumber=${version}`,
+                                {}
+                            ); // payload is empty for this request
+                            if (response.statusUrl && response.statusId) {
                                 Util.logger.info(
-                                    ` - ${this.definition.type} ${key}/${version} is already published.`
+                                    ` - ${this.definition.type} queued for publishing: ${journey[this.definition.keyField]}/${version} / ${journey[this.definition.nameField]}`
                                 );
-
-                                break;
+                                statusUrl = response.statusUrl;
+                            } else {
+                                throw new Error(response);
                             }
-                            case 'Cannot publish interaction in Stopped status.': {
+                            if (Util.OPTIONS.skipStatusCheck) {
                                 Util.logger.warn(
-                                    ` - ${this.definition.type} ${key}/${version} is stopped. Please create a new version and publish that.`
+                                    ` - Skipping status check for publishing journey ${key} due to --skipStatusCheck flag`
                                 );
-
-                                break;
                             }
-                            case 'Cannot publish interaction in Paused status.': {
-                                Util.logger.warn(
-                                    ` - ${this.definition.type} ${key}/${version} is already published but currently paused. Run 'mcdev resume' instead.`
+                            if (!Util.OPTIONS.skipStatusCheck && statusUrl) {
+                                spinner.start();
+
+                                await Util.sleep(1000);
+                                executedKeyArr.push(
+                                    await this._checkPublishStatus(
+                                        statusUrl,
+                                        journey[this.definition.keyField],
+                                        journey[this.definition.nameField],
+                                        spinner
+                                    )
                                 );
-
-                                break;
+                                publishedJourneyCounter.multiStep++;
+                            } else {
+                                // no guarantees if the journey was actually published
+                                executedKeyArr.push(key);
+                                publishedJourneyCounter.multiStep++;
                             }
-                            default: {
-                                Util.logger.error(
-                                    `Failed to publish ${this.definition.type} ${key}: ${ex.message}`
-                                );
+                        } catch (ex) {
+                            switch (ex.message) {
+                                case 'Cannot publish interaction in Published status.': {
+                                    Util.logger.info(
+                                        ` - ${this.definition.type} ${key}/${version} is already published.`
+                                    );
+
+                                    break;
+                                }
+                                case 'Cannot publish interaction in Stopped status.': {
+                                    Util.logger.warn(
+                                        ` - ${this.definition.type} ${key}/${version} is stopped. Please create a new version and publish that.`
+                                    );
+
+                                    break;
+                                }
+                                case 'Cannot publish interaction in Paused status.': {
+                                    Util.logger.warn(
+                                        ` - ${this.definition.type} ${key}/${version} is already published but currently paused. Run 'mcdev resume' instead.`
+                                    );
+
+                                    break;
+                                }
+                                default: {
+                                    Util.logger.error(
+                                        `Failed to publish ${this.definition.type} ${key}: ${ex.message}`
+                                    );
+                                }
                             }
                         }
+                        break;
+                    }
+                    default: {
+                        throw new Error(
+                            `${this.definition.type} type ${journey.definitionType} not supported yet by publish method`
+                        );
+                    }
+                }
+            } // for loop
+
+            // when all relevant keys have been iterated over per definitionType, ensure we wait for async tasks and update the counter
+            switch (definitionType) {
+                case 'Transactional': {
+                    if (resultsTransactional.length) {
+                        const transactionalKeyArr = (
+                            await Promise.all(resultsTransactional)
+                        ).filter(Boolean);
+                        spinner.stop();
+
+                        // if all publish actions failed, we don't need to re-retrieve anything here
+                        if (transactionalKeyArr.length) {
+                            executedKeyArr.push(...transactionalKeyArr);
+                            publishedJourneyCounter.transactional = transactionalKeyArr.length;
+                            // reset transactionalEmail cache to trigger re-caching it.
+                            cache.clearCache(this.buObject.mid, 'transactionalEmail');
+                        }
                     }
                     break;
                 }
-                default: {
-                    throw new Error(
-                        `${this.definition.type} type ${journey.definitionType} not supported yet by publish method`
-                    );
+                case 'Multistep': {
+                    // all done; executed synchronously
+                    break;
                 }
             }
-        } // for loop
-
-        const publishedJourneyCounter = {
-            multiStep: executedKeyArr.filter(Boolean).length,
-            transactional: 0,
-        };
-        // Transactional Send Journeys
-        if (resultsTransactional.length) {
-            const transactionalKeyArr = (await Promise.all(resultsTransactional)).filter(Boolean);
-            spinnerTransactional.stop();
-
-            // if all publish actions failed, we don't need to re-retrieve anything here
-            if (transactionalKeyArr.length) {
-                executedKeyArr.push(...transactionalKeyArr);
-                publishedJourneyCounter.transactional = transactionalKeyArr.length;
-                // reset transactionalEmail cache to trigger re-caching it.
-                cache.clearCache(this.buObject.mid, 'transactionalEmail');
-            }
-        }
+        } // processing order
 
         // reload published journeys including their events/transactionalEmails
         await this._reRetrieve(
             executedKeyArr,
             publishedJourneyCounter.transactional,
-            publishedJourneyCounter.multiStep
+            publishedJourneyCounter.multiStep,
+            upsertResults
         );
 
         Util.logger.info(
@@ -2137,9 +2221,13 @@ class Journey extends MetadataType {
 
         if (refreshTransactionalKeys.length) {
             // in case we tried to publish a transactional journey that was already published we will instead run a refresh for those
-            executedKeyArr.push(...(await this.refresh(refreshTransactionalKeys)));
+            executedKeyArr.push(
+                ...(await this.refresh(refreshTransactionalKeys, null, upsertResults))
+            );
         }
-        return executedKeyArr.filter(Boolean);
+
+        // good practice to return the published keys in alphabetical order
+        return executedKeyArr.filter(Boolean).sort();
     }
 
     /**
@@ -2147,9 +2235,15 @@ class Journey extends MetadataType {
      * @param {string[]} executedKeyArr list of journey keys
      * @param {number} transactionalCounter how many transactiona-send journeys did we expect to refresh
      * @param {number} multiStepCounter how many multi-step journeys did we expect to refresh
+     * @param {MetadataTypeMap} [upsertResults] metadata mapped by their keyField returned by update/create; needs to be refreshed after publish
      * @returns {Promise.<void>} -
      */
-    static async _reRetrieve(executedKeyArr, transactionalCounter, multiStepCounter) {
+    static async _reRetrieve(
+        executedKeyArr,
+        transactionalCounter,
+        multiStepCounter,
+        upsertResults
+    ) {
         if (!executedKeyArr.filter(Boolean).length) {
             return;
         }
@@ -2179,6 +2273,11 @@ class Journey extends MetadataType {
                 const updatedEvents = [];
                 const updatedTransactionalEmails = [];
                 for (const journey of updatedJourneys) {
+                    if (upsertResults?.[journey[this.definition.keyField]]) {
+                        // update upsertResults with journeys retrieved here to ensure we save the right thing to disk - if it was provided to the method
+                        upsertResults[journey[this.definition.keyField]] = journey;
+                    }
+
                     // multi-step journeys
                     updatedEvents.push(journey.triggers?.[0]?.metaData?.r__event_key);
                     // transactional-send journeys
@@ -2210,6 +2309,7 @@ class Journey extends MetadataType {
                             toBeRetrievedTypes.map((item) => item + 's').join(', ')
                     );
                     await retriever.retrieve(toBeRetrievedTypes, eventTransEmailCombo);
+                    // TODO find r__automation_key in events and retrieve these automations as well
                 }
             }
         } catch (ex) {
@@ -2290,14 +2390,15 @@ class Journey extends MetadataType {
                 messages[type].push(`   ${types[type]}:`);
                 for (const msg of response[type]) {
                     messages[type].push(
-                        `     #${counter++}`,
-                        `     Code: ${msg.errorCode}`,
-                        `     Details: ${msg.errorDetail.split(' EmailID: ').join('\n       EmailID: ').split(' Personalization error: ').join('\n       Personalization error: ')}`
+                        `     #${counter++}: ${msg.errorDetail.split(' EmailID: ').join('\n       EmailID: ').split(' Personalization error: ').join('\n       Personalization error: ')}`,
+                        Util.getGrayMsg(`     Code: ${msg.errorCode}`)
                     );
                     if (msg.additionalInfo && Object.keys(msg.additionalInfo).length) {
-                        messages[type].push(`     Additional Info:`);
+                        messages[type].push(Util.getGrayMsg(`     Additional Info:`));
                         for (const key in msg.additionalInfo) {
-                            messages[type].push(`       ${key}: ${msg.additionalInfo[key]}`);
+                            messages[type].push(
+                                Util.getGrayMsg(`       ${key}: ${msg.additionalInfo[key]}`)
+                            );
                         }
                     }
                     // add spacer line
@@ -2610,7 +2711,16 @@ class Journey extends MetadataType {
                 apiLimit(async () => {
                     [key, version] = key.split('/');
                     if (journeyCache.metadata[key]) {
-                        if (journeyCache.metadata[key].status !== 'Published') {
+                        if (journeyCache.metadata[key].status === 'Paused') {
+                            Util.logger.info(
+                                ` ${this.definition.type} ${
+                                    key
+                                } (${journeyCache.metadata[key].name}): already paused`
+                            );
+                            // still add this key because technically this method is supposed to pause a journey and this journey is paused. mission accomplished. Also, we need that for _refreshItem() to function
+                            pausedKeyArr.push(key);
+                            return;
+                        } else if (journeyCache.metadata[key].status !== 'Published') {
                             Util.logger.error(
                                 ` - Pausing ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: Cannot pause a journey in status ${journeyCache.metadata[key].status}`
                             );
@@ -2768,9 +2878,11 @@ class Journey extends MetadataType {
      * TSD-specific refresh method that finds active TSDs and refreshes them
      *
      * @param {string[]} keyArr metadata keys
+     * @param {boolean} [_] whether to check if the key is valid
+     * @param {MetadataTypeMap} [upsertResults] metadata mapped by their keyField as returned by update/create; needs to be refreshed after publish
      * @returns {Promise.<string[]>} Returns list of keys that were refreshed
      */
-    static async refresh(keyArr) {
+    static async refresh(keyArr, _, upsertResults) {
         console.time('Time'); // eslint-disable-line no-console
         if (!Array.isArray(keyArr) || !keyArr.length) {
             Util.logger.error('No refresh-keys provided');
@@ -2778,7 +2890,9 @@ class Journey extends MetadataType {
             // keyArr = await this.getKeysForValidTSDs((await this.findRefreshableItems()).metadata);
             // checkKey = false;
         }
-        const journeyCache = await this.retrieveForCache();
+        const journeyCache = upsertResults
+            ? { metadata: upsertResults, type: this.definition.type }
+            : await this.retrieveForCache();
         // then executes pause, publish, start on them.
         Util.logger.info(`Refreshing ${keyArr.length} ${this.definition.typeName}...`);
         Util.logger.debug(`Refreshing keys: ${keyArr.join(', ')}`);
@@ -2797,7 +2911,9 @@ class Journey extends MetadataType {
                     }
                     switch (journeyCache.metadata[key].definitionType) {
                         case 'Transactional': {
-                            if (journeyCache.metadata[key]?.status === 'Published') {
+                            if (
+                                ['Paused', 'Published'].includes(journeyCache.metadata[key]?.status)
+                            ) {
                                 const result = await this._refreshItem(key, journeyCache);
                                 if (result) {
                                     refreshedKeyArr.push(key);