mcdev 7.5.0 → 7.6.1

package/lib/metadataTypes/Journey.js

@@ -2,6 +2,7 @@
 
 import MetadataType from './MetadataType.js';
 import TransactionalEmail from './TransactionalEmail.js';
+import TriggeredSend from './TriggeredSend.js';
 import Event from './Event.js';
 import { Util } from '../util/util.js';
 import cache from '../util/cache.js';
@@ -187,7 +188,8 @@ class Journey extends MetadataType {
                 [
                     'Interaction matching key not found.',
                     'Must provide a valid ID or Key parameter',
-                ].includes(ex.message)
+                ].includes(ex.message) ||
+                (key && ex.code === 'ERR_BAD_REQUEST')
             ) {
                 Util.logger.info(
                     `Downloaded: ${this.definition.type} (0)${Util.getKeysString(
@@ -209,22 +211,32 @@ class Journey extends MetadataType {
      */
     static async deleteByKey(key) {
         let version;
-        let singleKey = '';
+        let id;
+        let cachedJourney;
 
         if (key.startsWith('id:') || key.startsWith('%23')) {
             // ! allow selecting journeys by ID because that's what users see in the URL
             // if the key started with %23 assume an ID was copied from the URL but the user forgot to prefix it with id:
 
             // remove id: or %23
-            singleKey = key.slice(3);
-            if (singleKey.startsWith('%23')) {
+            id = key.slice(3);
+            if (id.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
-                singleKey = singleKey.slice(3);
+                id = id.slice(3);
             }
-            if (singleKey.includes('/')) {
+            if (id.includes('/')) {
                 // in the journey URL the version is appended after the ID, separated by a forward-slash.
-                [singleKey, version] = singleKey.split('/');
+                [id, version] = id.split('/');
+            }
+            try {
+                const response = await this.client.rest.get(
+                    `/interaction/v1/interactions/${encodeURIComponent(id)}?extras=activities`
+                );
+                const results = this.parseResponseBody(response, key);
+                cachedJourney = results[key];
+            } catch {
+                // handle below
             }
         } else {
             if (key.includes('/')) {
@@ -233,40 +245,75 @@ class Journey extends MetadataType {
             }
 
             // delete by key with specified version does not work, therefore we need to get the ID first
-            const response = await this.client.rest.get(
-                `/interaction/v1/interactions/key:${encodeURIComponent(key)}?extras=`
-            );
-            const results = this.parseResponseBody(response, key);
-            singleKey = results[key].id;
-            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.`
+            try {
+                const response = await this.client.rest.get(
+                    `/interaction/v1/interactions/key:${encodeURIComponent(key)}?extras=activities`
                 );
-                return false;
+                const results = this.parseResponseBody(response, key);
+                cachedJourney = results[key];
+                id = cachedJourney?.id;
+            } catch {
+                // handle below
             }
-            Util.logger.debug(`Deleting interaction ${key} via its ID ${singleKey}`);
         }
-        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;
-            }
+        if (!cachedJourney?.key) {
             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.`
+                ` ☇ skipping deletion of ${this.definition.type} ${key}: not found on server`
             );
+            return false;
         }
+        switch (cachedJourney.definitionType) {
+            case 'Multistep': {
+                if (version && version !== '*' && version > cachedJourney.version) {
+                    Util.logger.error(
+                        `The chosen version (${version}) is higher than the latest known version (${cachedJourney.version}). Please choose a lower version.`
+                    );
+                    return false;
+                }
+                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 super.deleteByKeyREST(
-            '/interaction/v1/interactions/' +
-                singleKey +
-                (version === '*' ? '' : `?versionNumber=${version}`),
-            key,
-            false
-        );
+                return super.deleteByKeyREST(
+                    '/interaction/v1/interactions/' +
+                        id +
+                        (version === '*' ? '' : `?versionNumber=${version}`),
+                    key,
+                    false
+                );
+                // break;
+            }
+            default: {
+                // Quicksend, Transactional dont have versions
+                const response = await super.deleteByKeyREST(
+                    '/interaction/v1/interactions/' + id,
+                    key,
+                    false
+                );
+                if (response && cachedJourney.definitionType === 'Transactional') {
+                    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;
+            }
+        }
     }
 
     /**
@@ -1607,7 +1654,11 @@ class Journey extends MetadataType {
             );
             const cachedVersion = cache.getByKey(this.definition.type, normalizedKey);
             if (cachedVersion) {
-                if (cachedVersion.status === 'Draft') {
+                if (
+                    cachedVersion.status === 'Draft' ||
+                    cachedVersion.definitionType !== 'Multistep'
+                ) {
+                    // we can update journeys either if there is a draft version or if the type is not multistep. transactional and quicksend journeys do not have versions.
                     // add version to ensure we update the correct one
                     metadataMap[metadataKey].version = cachedVersion.version;
                     // update modifiedDate field to bypass API-error "Another user recently modified this journey. Refresh to edit the latest version."
@@ -2335,121 +2386,406 @@ class Journey extends MetadataType {
         let version;
         const endpoint = '/interaction/v1/interactions/stop/';
         const stoppedKeyArr = [];
+        const pauseTransactionalKeyArr = [];
         const apiLimit = pLimit(20);
         const journeyCache = await this.retrieveForCache();
 
+        const stoppableJourneyStatus = ['Paused', 'Published', 'Finishing'];
+
         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}`
-                            );
+                        switch (journeyCache.metadata[key].definitionType) {
+                            case 'Transactional': {
+                                // transactional send journeys cannot be "stopped" but only "paused"
+                                pauseTransactionalKeyArr.push(key);
+                                break;
+                            }
+                            case 'Multistep': {
+                                const toBeStoppedVersions = [];
+                                if (version === '*') {
+                                    const responseAllVersions = await this.client.rest.getBulk(
+                                        '/interaction/v1/interactions/?id=' +
+                                            journeyCache.metadata[key].id +
+                                            '&mostRecentVersionOnly=false',
+                                        this.definition.restPageSize || 500
+                                    );
+                                    if (responseAllVersions?.items?.length) {
+                                        // find all active versions
+                                        const allActiveVersions = responseAllVersions.items
+                                            .filter((item) =>
+                                                stoppableJourneyStatus.includes(item.status)
+                                            )
+                                            .map((item) => item.version);
+                                        if (allActiveVersions.length) {
+                                            toBeStoppedVersions.push(...allActiveVersions);
+                                        }
+                                    }
+                                    if (!toBeStoppedVersions.length) {
+                                        Util.logger.warn(
+                                            ` ☇ skipping stop of ${this.definition.type} ${key}: no active versions found`
+                                        );
+                                    }
+                                } else {
+                                    if (!version) {
+                                        version = journeyCache.metadata[key].version;
+                                        Util.logger.info(
+                                            Util.getGrayMsg(
+                                                ` - ${this.definition.type} ${key}: no version provided. Will try to stop latest version: Version ${version}. To stop all versions, append /* after the key.`
+                                            )
+                                        );
+                                        if (
+                                            !stoppableJourneyStatus.includes(
+                                                journeyCache.metadata[key].status
+                                            )
+                                        ) {
+                                            Util.logger.warn(
+                                                ` ☇ skipping stop of ${this.definition.type} ${key}: version ${version} has status "${journeyCache.metadata[key].status}" which cannot be stopped. To stop all versions, append /* after the key.`
+                                            );
+                                        }
+                                    }
+                                    toBeStoppedVersions.push(version);
+                                }
+                                const rateLimitActivities = pLimit(2);
+                                const stoppedVersions = (
+                                    await Promise.all(
+                                        toBeStoppedVersions.map((version) =>
+                                            rateLimitActivities(async () => {
+                                                try {
+                                                    await this.client.rest.post(
+                                                        endpoint +
+                                                            journeyCache.metadata[key].id +
+                                                            `?versionNumber=${version}`,
+                                                        {}
+                                                    );
+                                                    Util.logger.info(
+                                                        ` - Stopped ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} - Version ${version}`
+                                                    );
+                                                    return version;
+                                                } catch (ex) {
+                                                    Util.logger.error(
+                                                        ` - Stopping ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} - Version ${version} failed: ${ex.message}`
+                                                    );
+                                                    return;
+                                                }
+                                            })
+                                        )
+                                    )
+                                ).filter(Boolean);
+                                if (stoppedVersions.length === toBeStoppedVersions.length) {
+                                    stoppedKeyArr.push(key);
+                                }
+
+                                break;
+                            }
+                            default: {
+                                Util.logger.error(
+                                    ` - Stopping ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: Unsupported definitionType '${journeyCache.metadata[key].definitionType}'`
+                                );
+                            }
                         }
+                    } else {
+                        Util.logger.error(
+                            ` ☇ skipping stop of ${this.definition.type} ${key}: not found on server`
+                        );
                     }
                 })
             )
         );
+        stoppedKeyArr.push(...(await this.pause(pauseTransactionalKeyArr)));
 
         return stoppedKeyArr;
     }
+
     /**
      * pauses selected journey versions
      *
      * @param {string[]} keyArr customerkey of the metadata
+     * @param {MetadataTypeMapObj} [journeyCache] metadata cache used by refresh to avoid recaching
      * @returns {Promise.<string[]>} Returns list of keys that were paused
      */
-    static async pause(keyArr) {
+    static async pause(keyArr, journeyCache) {
         let version;
-        const endpoint = '/interaction/v1/interactions/pause/';
-        const stoppedKeyArr = [];
+        const pausedKeyArr = [];
         const apiLimit = pLimit(20);
-        const journeyCache = await this.retrieveForCache();
+        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) {
+                        if (journeyCache.metadata[key].status !== 'Published') {
                             Util.logger.error(
-                                ` - Pausing ${this.definition.type} ${key} failed: ${ex.message}`
+                                ` - Pausing ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: Cannot pause a journey in status ${journeyCache.metadata[key].status}`
                             );
+                            return;
                         }
+                        switch (journeyCache.metadata[key].definitionType) {
+                            case 'Transactional': {
+                                try {
+                                    const response = await this.client.rest.post(
+                                        '/interaction/v1/interactions/transactional/pause',
+                                        { definitionId: journeyCache.metadata[key].id }
+                                    );
+                                    if (response.errors?.length) {
+                                        throw new Error(JSON.stringify(response));
+                                    } else {
+                                        Util.logger.info(
+                                            ` - 🛑 paused ${this.definition.type} ${key} / ${journeyCache.metadata[key].name}`
+                                        );
+                                        pausedKeyArr.push(key);
+                                    }
+                                } catch (ex) {
+                                    Util.logger.error(
+                                        ` - Pausing ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: ${ex.message}`
+                                    );
+                                }
+                                break;
+                            }
+                            case 'Multistep': {
+                                version ||= journeyCache.metadata[key].version;
+                                try {
+                                    await this.client.rest.post(
+                                        '/interaction/v1/interactions/pause/' +
+                                            journeyCache.metadata[key].id +
+                                            (version === '*'
+                                                ? '?allVersions=true'
+                                                : `?versionNumber=${version}`),
+                                        {}
+                                    );
+                                    Util.logger.info(
+                                        ` -- 🛑 paused ${this.definition.type} ${key}/${version} / ${journeyCache.metadata[key].name}`
+                                    );
+                                    pausedKeyArr.push(key);
+                                } catch (ex) {
+                                    Util.logger.error(
+                                        ` - Pausing ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: ${ex.message}`
+                                    );
+                                }
+                                break;
+                            }
+                            default: {
+                                Util.logger.error(
+                                    ` - Pausing ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: Unsupported definitionType '${journeyCache.metadata[key].definitionType}'`
+                                );
+                            }
+                        }
+                    } else {
+                        Util.logger.error(
+                            ` ☇ skipping pause of ${this.definition.type} ${key}: not found on server`
+                        );
                     }
                 })
             )
         );
 
-        return stoppedKeyArr;
+        return pausedKeyArr;
     }
     /**
      * resumes selected journey versions
      *
      * @param {string[]} keyArr customerkey of the metadata
-     * @returns {Promise.<string[]>} Returns list of keys that were paused
+     * @param {MetadataTypeMapObj} [journeyCache] metadata cache used by refresh to avoid recaching
+     * @returns {Promise.<string[]>} Returns list of keys that were resumed
      */
-    static async execute(keyArr) {
+    static async execute(keyArr, journeyCache) {
         let version;
         const endpoint = '/interaction/v1/interactions/resume/';
         const resumedKeyArr = [];
         const apiLimit = pLimit(20);
-        const journeyCache = await this.retrieveForCache();
+        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}`),
-                                {}
+                        if (journeyCache.metadata[key].status !== 'Paused') {
+                            Util.logger.error(
+                                ` - Resuming ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: Cannot pause a journey in status ${journeyCache.metadata[key].status}`
                             );
-                            Util.logger.info(
-                                ` - Resumed ${this.definition.type} ${key}/${version}`
+                            return;
+                        }
+                        switch (journeyCache.metadata[key].definitionType) {
+                            case 'Transactional': {
+                                try {
+                                    const response = await this.client.rest.post(
+                                        '/interaction/v1/interactions/transactional/resume',
+                                        { definitionId: journeyCache.metadata[key].id }
+                                    );
+                                    if (response.errors?.length) {
+                                        throw new Error(JSON.stringify(response));
+                                    } else {
+                                        Util.logger.info(
+                                            ` - ✅ resumed ${this.definition.type} ${key} / ${journeyCache.metadata[key].name}`
+                                        );
+                                        resumedKeyArr.push(key);
+                                    }
+                                } catch (ex) {
+                                    Util.logger.error(
+                                        ` - Resuming ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: ${ex.message}`
+                                    );
+                                }
+                                break;
+                            }
+                            case 'Multistep': {
+                                version ||= journeyCache.metadata[key].version;
+                                try {
+                                    await this.client.rest.post(
+                                        endpoint +
+                                            journeyCache.metadata[key].id +
+                                            (version === '*'
+                                                ? '?allVersions=true'
+                                                : `?versionNumber=${version}`),
+                                        {}
+                                    );
+                                    Util.logger.info(
+                                        ` - ✅ resumed ${this.definition.type} ${key}/${version}`
+                                    );
+                                    resumedKeyArr.push(key);
+                                } catch (ex) {
+                                    Util.logger.error(
+                                        ` - Resuming ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: ${ex.message}`
+                                    );
+                                }
+                                break;
+                            }
+                            default: {
+                                Util.logger.error(
+                                    ` - Resuming ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: Unsupported definitionType '${journeyCache.metadata[key].definitionType}'`
+                                );
+                            }
+                        }
+                    } else {
+                        Util.logger.error(
+                            ` ☇ skipping resume of ${this.definition.type} ${key}: not found on server`
+                        );
+                    }
+                })
+            )
+        );
+
+        return resumedKeyArr;
+    }
+
+    /**
+     * TSD-specific refresh method that finds active TSDs and refreshes them
+     *
+     * @param {string[]} keyArr metadata keys
+     * @param {boolean} [checkKey] whether to check if the key is valid
+     * @returns {Promise.<string[]>} Returns list of keys that were refreshed
+     */
+    static async refresh(keyArr, checkKey = true) {
+        console.time('Time'); // eslint-disable-line no-console
+        if (!keyArr) {
+            Util.logger.error('No refresh-keys provided');
+            return [];
+            // keyArr = await this.getKeysForValidTSDs((await this.findRefreshableItems()).metadata);
+            // checkKey = false;
+        }
+        let journeyCache;
+        if (checkKey) {
+            journeyCache = 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(', ')}`);
+        const refreshedKeyArr = [];
+        const tsKeys = [];
+        const rateLimit = pLimit(10);
+        await Promise.all(
+            keyArr.map((key) =>
+                rateLimit(async () => {
+                    if (checkKey && !journeyCache.metadata[key]) {
+                        Util.logger.error(
+                            ` ☇ skipping refresh of ${this.definition.type} ${key}: not found on server`
+                        );
+                        return;
+                    }
+                    switch (journeyCache.metadata[key].definitionType) {
+                        case 'Transactional': {
+                            if (checkKey && journeyCache.metadata[key]?.status !== 'Published') {
+                                Util.logger.error(
+                                    ` ☇ skipping refresh of ${this.definition.type} ${key}: Can only refresh journeys with status 'Published'. Found status: ${journeyCache.metadata[key]?.status}`
+                                );
+                            } else {
+                                const result = await this._refreshItem(key, journeyCache);
+                                if (result) {
+                                    refreshedKeyArr.push(key);
+                                }
+                            }
+                            break;
+                        }
+                        case 'Multistep': {
+                            // find all published & paused versions
+                            const responseAllVersions = await this.client.rest.getBulk(
+                                '/interaction/v1/interactions/?id=' +
+                                    journeyCache.metadata[key].id +
+                                    '&mostRecentVersionOnly=false',
+                                this.definition.restPageSize || 500
                             );
-                            resumedKeyArr.push(key);
-                        } catch (ex) {
+                            if (responseAllVersions?.items?.length) {
+                                const allActiveVersions = responseAllVersions.items
+                                    .filter(
+                                        (item) =>
+                                            item.status === 'Paused' || item.status === 'Published'
+                                    )
+                                    .map((item) => item.version);
+                                if (allActiveVersions.length) {
+                                    Util.logger.info(
+                                        Util.getGrayMsg(
+                                            ` - journey ${key} / ${journeyCache.metadata[key].name} Paused/Published version numbers: ` +
+                                                allActiveVersions.join(', ')
+                                        )
+                                    );
+                                    // get TS keys from email activities of paused/published versions
+                                    const rateLimitActivities = pLimit(2);
+                                    tsKeys.push(
+                                        ...(
+                                            await Promise.all(
+                                                allActiveVersions.map((version) =>
+                                                    rateLimitActivities(async () => {
+                                                        const journey = await this.client.rest.get(
+                                                            '/interaction/v1/interactions/' +
+                                                                journeyCache.metadata[key]?.id +
+                                                                '?extras=activities&versionNumber=' +
+                                                                version
+                                                        );
+                                                        // return all triggeredSends
+                                                        // ! if somebody changed the key of the triggeredSend then the journey would have wrong info in triggeredSendKey. There is the alternative field triggeredSendId but that would be too costly to use here because we would need to retrieve all TSs to find the correct one. Also, changing TS keys is not a common practice.
+                                                        return journey.activities
+                                                            .filter(
+                                                                (activity) =>
+                                                                    activity.type === 'EMAILV2' &&
+                                                                    activity.configurationArguments
+                                                                        ?.triggeredSendKey
+                                                            )
+                                                            .map(
+                                                                (activity) =>
+                                                                    activity.configurationArguments
+                                                                        ?.triggeredSendKey
+                                                            );
+                                                    })
+                                                )
+                                            )
+                                        ).flat()
+                                    );
+
+                                    refreshedKeyArr.push(key);
+                                } else {
+                                    Util.logger.error(
+                                        ` ☇ skipping refresh of ${this.definition.type} ${key}: no published/paused versions found`
+                                    );
+                                }
+                            }
+                            break;
+                        }
+                        default: {
                             Util.logger.error(
-                                ` - Resuming ${this.definition.type} ${key} failed: ${ex.message}`
+                                ` - Refreshing ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} failed: Unsupported definitionType '${journeyCache.metadata[key].definitionType}'`
                             );
                         }
                     }
@@ -2457,7 +2793,49 @@ class Journey extends MetadataType {
             )
         );
 
-        return resumedKeyArr;
+        if (tsKeys.length) {
+            // refresh TriggeredSends
+            TriggeredSend.buObject = this.buObject;
+            TriggeredSend.client = this.client;
+            TriggeredSend.properties = this.properties;
+            // hard-refresh all triggeredSends even if the TS was paused (inactive) before
+            await TriggeredSend.refresh(tsKeys, false);
+        } else {
+            Util.logger.info(Util.getGrayMsg('No triggeredSends found to refresh'));
+        }
+
+        Util.logger.info(
+            `Refreshed ${refreshedKeyArr.length} of ${keyArr.length} ${this.definition.type}`
+        );
+        console.timeEnd('Time'); // eslint-disable-line no-console
+        return refreshedKeyArr;
+    }
+    /**
+     * helper for {@link Journey.refresh} that pauses, publishes and starts a triggered send
+     *
+     * @param {string} key external key of triggered send item
+     * @param {MetadataTypeMapObj} journeyCache metadata cache
+     * @returns {Promise.<boolean>} true if refresh was successful
+     */
+    static async _refreshItem(key, journeyCache) {
+        // pause
+        const pausedKeys = await this.pause([key], journeyCache);
+        if (!pausedKeys?.length || pausedKeys[0] !== key) {
+            Util.logger.error(` - failed to pause ${this.definition.typeName}: ${key}`);
+            return false;
+        }
+
+        // update cache or else resume (execute) will fail
+        journeyCache.metadata[key].status = 'Paused';
+
+        // resume
+        const resumedKeys = await this.execute([key], journeyCache);
+        if (!resumedKeys?.length || resumedKeys[0] !== key) {
+            Util.logger.error(` - failed to resume ${this.definition.typeName}: ${key}`);
+            return false;
+        }
+
+        return true;
     }
 }