mcdev 7.5.0 → 7.6.0

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,41 +2386,115 @@ 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;
     }
@@ -2381,8 +2506,7 @@ class Journey extends MetadataType {
      */
     static async pause(keyArr) {
         let version;
-        const endpoint = '/interaction/v1/interactions/pause/';
-        const stoppedKeyArr = [];
+        const pausedKeyArr = [];
         const apiLimit = pLimit(20);
         const journeyCache = await this.retrieveForCache();
 
@@ -2391,35 +2515,78 @@ class Journey extends MetadataType {
                 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
+     * @returns {Promise.<string[]>} Returns list of keys that were resumed
      */
     static async execute(keyArr) {
         let version;
@@ -2433,23 +2600,188 @@ class Journey extends MetadataType {
                 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);
+                                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
+                                                        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 +2789,41 @@ class Journey extends MetadataType {
             )
         );
 
-        return resumedKeyArr;
+        // 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);
+
+        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
+     * @returns {Promise.<boolean>} true if refresh was successful
+     */
+    static async _refreshItem(key) {
+        // pause
+        const pausedKeys = await this.pause([key]);
+        if (!pausedKeys?.length || pausedKeys[0] !== key) {
+            Util.logger.error(` - failed to pause ${this.definition.typeName}: ${key}`);
+            return false;
+        }
+
+        // resume
+        const resumedKeys = await this.execute([key]);
+        if (!resumedKeys?.length || resumedKeys[0] !== key) {
+            Util.logger.error(` - failed to resume ${this.definition.typeName}: ${key}`);
+            return false;
+        }
+
+        return true;
     }
 }