mcdev 7.10.1 → 8.0.0

package/lib/metadataTypes/Folder.js

@@ -224,7 +224,9 @@ class Folder extends MetadataType {
                                     'folder',
                                     deployableMetadata.Path,
                                     'Path',
-                                    'ID'
+                                    'ID',
+                                    undefined,
+                                    true
                                 );
                                 const cachedVersion = cache.getByKey(
                                     'folder',
@@ -232,7 +234,9 @@ class Folder extends MetadataType {
                                         'folder',
                                         deployableMetadata.Path,
                                         'Path',
-                                        this.definition.keyField
+                                        this.definition.keyField,
+                                        undefined,
+                                        true
                                     )
                                 );
                                 if (
@@ -371,7 +375,7 @@ class Folder extends MetadataType {
         }
         const path = metadataEntry.Path;
         try {
-            if (this.definition.deployFolderTypesRest.includes(metadataEntry.ContentType)) {
+            if (this.definition.deployFolderTypesEmailRest.includes(metadataEntry.ContentType)) {
                 // * The SOAP endpoint for creating folders does not support folders for automations nor journeys. The Rest endpoint on the other hand errors out on certain characters in the folder names that are actually valid. We therefore only use Rest for the folder types that are not supported by SOAP.
                 const restPayload = {
                     parentCatId: metadataEntry.ParentFolder.ID,
@@ -379,7 +383,7 @@ class Folder extends MetadataType {
                     catType: metadataEntry.ContentType,
                 };
                 const response = await super.createREST(restPayload, '/email/v1/category', true);
-                if (response?.objectId) {
+                if (response?.categoryId) {
                     // convert the response to the same format as the SOAP response
 
                     // set the new folder ID
@@ -400,7 +404,48 @@ class Folder extends MetadataType {
                     Util.logger.info(` - created folder: ${path}`);
                     return returnObject;
                 } else {
-                    throw new Error(response);
+                    throw new Error(JSON.stringify(response));
+                }
+            } else if (
+                this.definition.deployFolderTypesAssetRest.includes(metadataEntry.ContentType)
+            ) {
+                // * The SOAP endpoint for creating folders does not support folders for automations nor journeys. The Rest endpoint on the other hand errors out on certain characters in the folder names that are actually valid. We therefore only use Rest for the folder types that are not supported by SOAP.
+                const restPayload = {
+                    parentId: metadataEntry.ParentFolder.ID,
+                    categoryType: metadataEntry.ContentType,
+                    extendable: 1,
+                    editable: 1,
+                    name: metadataEntry.Name,
+                    description: '',
+                };
+
+                const response = await super.createREST(
+                    restPayload,
+                    '/asset/v1/content/categories',
+                    true
+                );
+                if (response?.id) {
+                    // convert the response to the same format as the SOAP response
+
+                    // set the new folder ID
+                    metadataEntry.ID = response.id;
+                    // set the client ID to ensure we can find the newly created folders as parents for folders created afterwards inside of it
+                    metadataEntry.Client = {
+                        ID: metadataEntry.Client?.ID || this.buObject.mid,
+                    };
+                    // the following is a bit of a hack to make the response look like the SOAP response; not sure if we actually need that anywhere like this --> future developers feel free to double check
+                    const returnObject = {
+                        Results: [
+                            {
+                                Object: metadataEntry,
+                            },
+                        ],
+                    };
+
+                    Util.logger.info(` - created folder: ${path}`);
+                    return returnObject;
+                } else {
+                    throw new Error(JSON.stringify(response));
                 }
             } else {
                 const response = await super.createSOAP(metadataEntry, true);
@@ -446,13 +491,54 @@ class Folder extends MetadataType {
         }
         const path = metadataEntry.Path;
         try {
-            const response = await super.updateSOAP(metadataEntry, true);
-            if (response.Results?.[0]?.StatusCode === 'OK') {
-                response.Results[0].Object = metadataEntry;
-                response.Results[0].Object.CustomerKey = metadataEntry.CustomerKey;
-                delete response.Results[0].Object.$;
-                Util.logger.info(` - updated folder: ${path}`);
-                return response;
+            let response;
+            if (this.definition.deployFolderTypesAssetRest.includes(metadataEntry.ContentType)) {
+                // * The SOAP endpoint for creating folders does not support folders for automations nor journeys. The Rest endpoint on the other hand errors out on certain characters in the folder names that are actually valid. We therefore only use Rest for the folder types that are not supported by SOAP.
+                const restPayload = {
+                    id: metadataEntry.ID,
+                    parentId: metadataEntry.ParentFolder.ID,
+                    // categoryType: metadataEntry.ContentType,
+                    extendable: 1, // ?
+                    editable: 1, // ?
+                    name: metadataEntry.Name,
+                    description: '',
+                };
+                response = await super.updateREST(
+                    restPayload,
+                    '/asset/v1/content/categories/' + metadataEntry.ID,
+                    'put',
+                    true
+                );
+                if (response?.id) {
+                    // convert the response to the same format as the SOAP response
+
+                    // set the client ID to ensure we can find the newly created folders as parents for folders created afterwards inside of it
+                    metadataEntry.Client = {
+                        ID: metadataEntry.Client?.ID || this.buObject.mid,
+                    };
+                    // the following is a bit of a hack to make the response look like the SOAP response; not sure if we actually need that anywhere like this --> future developers feel free to double check
+                    const returnObject = {
+                        Results: [
+                            {
+                                Object: metadataEntry,
+                            },
+                        ],
+                    };
+
+                    Util.logger.info(` - updated folder: ${path}`);
+                    return returnObject;
+                } else {
+                    throw new Error(JSON.stringify(response));
+                }
+            } else {
+                response = await super.updateSOAP(metadataEntry, true);
+                if (response.Results?.[0]?.StatusCode === 'OK') {
+                    response.Results[0].Object = metadataEntry;
+                    response.Results[0].Object.CustomerKey = metadataEntry.CustomerKey;
+                    delete response.Results[0].Object.$;
+                    Util.logger.info(` - updated folder: ${path}`);
+                    return response;
+                }
             }
         } catch (ex) {
             if (ex?.results) {

package/lib/metadataTypes/ImportFile.js

@@ -16,6 +16,7 @@ import cache from '../util/cache.js';
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
  * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ * @typedef {import('../../types/mcdev.d.js').SDKError} SDKError
  */
 
 /**
@@ -85,6 +86,38 @@ class ImportFile extends MetadataType {
         );
     }
 
+    /**
+     * helper for {@link MetadataType.retrieveRESTcollection}
+     *
+     * @param {SDKError} ex exception
+     * @param {string} key id or key of item
+     * @param {string} url url to call for retry
+     * @returns {Promise.<any>} can return retry-result
+     */
+    static async handleRESTErrors(ex, key, url) {
+        try {
+            if (ex.code == 'ERR_BAD_RESPONSE') {
+                // one more retry; it's a rare case but retrying again should solve the issue gracefully
+                Util.logger.info(
+                    ` - Connection problem (Code: ${ex.code}). Retrying once${
+                        ex.endpoint
+                            ? Util.getGrayMsg(
+                                  ' - ' + ex.endpoint.split('rest.marketingcloudapis.com')[1]
+                              )
+                            : ''
+                    }`
+                );
+                Util.logger.errorStack(ex);
+                return await this.client.rest.get(url);
+            }
+        } catch {
+            // no extra action needed, handled below
+        }
+        // if we do get here, we should log the error and continue instead of failing to download all automations
+        Util.logger.error(` ☇ skipping ${this.definition.type} ${key}: ${ex.message} ${ex.code}`);
+        return null;
+    }
+
     /**
      * Retrieves import definition metadata for caching
      *
@@ -228,16 +261,21 @@ class ImportFile extends MetadataType {
      * @returns {Promise.<MetadataTypeItem>} Promise
      */
     static async preDeployTasks(metadata) {
-        const fileLocation = cache.getByKey('fileLocation', metadata.source?.r__fileLocation_name);
-        if (!fileLocation) {
-            throw new Error(
-                `fileLocation ${metadata.source?.r__fileLocation_name} not found in cache`
+        if (metadata.source?.r__fileLocation_name) {
+            const fileLocation = cache.getByKey(
+                'fileLocation',
+                metadata.source?.r__fileLocation_name
             );
-        }
+            if (!fileLocation) {
+                throw new Error(
+                    `fileLocation ${metadata.source?.r__fileLocation_name} not found in cache`
+                );
+            }
 
-        metadata.fileTransferLocationId = fileLocation.id;
-        metadata.fileTransferLocationTypeId = fileLocation.locationTypeId;
-        delete metadata.source.r__fileLocation_name;
+            metadata.fileTransferLocationId = fileLocation.id;
+            metadata.fileTransferLocationTypeId = fileLocation.locationTypeId;
+            delete metadata.source.r__fileLocation_name;
+        }
 
         switch (metadata.destination.c__type) {
             case 'DataExtension': {
@@ -332,18 +370,14 @@ class ImportFile extends MetadataType {
                     delete metadata.source.r__dataExtension_key;
                 }
 
-                Util.logger.debug(
-                    ` - importFile ${metadata[this.definition.keyField]}: Import Destination Type ${
-                        metadata.destination.c__type
-                    } not fully supported. Deploy might fail.`
+                throw new Error(
+                    `Import Destination Type ${metadata.destination.c__type} not fully supported.`
                 );
-                break;
             }
             default: {
-                Util.logger.debug(
-                    ` - importFile ${metadata[this.definition.keyField]}: Import Destination Type ${
-                        metadata.destination.c__type
-                    } not fully supported. Deploy might fail.`
+                // e.g. WhatsApp
+                throw new Error(
+                    `Import Destination Type ${metadata.destination.c__type} not fully supported.`
                 );
             }
         }
@@ -381,18 +415,24 @@ class ImportFile extends MetadataType {
         // destination.c__type SMS & DataExtension both set fileNamingPattern to _CustomObject and they both define a DE as source
         metadata.source = {
             c__type:
-                metadata.fileNamingPattern === '_CustomObject' ? 'DataExtension' : 'File Location',
+                metadata.fileNamingPattern === '_CustomObject' ||
+                metadata.fileSpec === '_CustomObject'
+                    ? 'DataExtension'
+                    : 'File Location',
         };
-        try {
-            metadata.source.r__fileLocation_name = cache.searchForField(
-                'fileLocation',
-                metadata.fileTransferLocationId,
-                'id',
-                'name'
-            );
-            delete metadata.fileTransferLocationId;
-        } catch (ex) {
-            Util.logger.warn(` - importFile ${metadata.customerKey}: ${ex.message}`);
+
+        if (metadata.fileTransferLocationId !== '00000000-0000-0000-0000-000000000000') {
+            try {
+                metadata.source.r__fileLocation_name = cache.searchForField(
+                    'fileLocation',
+                    metadata.fileTransferLocationId,
+                    'id',
+                    'name'
+                );
+                delete metadata.fileTransferLocationId;
+            } catch (ex) {
+                Util.logger.warn(` - importFile ${metadata.customerKey}: ${ex.message}`);
+            }
         }
 
         switch (metadata.destination.c__type) {
@@ -481,6 +521,27 @@ class ImportFile extends MetadataType {
 
                 break;
             }
+            case 'WhatsApp': {
+                if (
+                    metadata.source.c__type === 'DataExtension' &&
+                    metadata.sourceCustomObjectId !== ''
+                ) {
+                    // only happens for dataimport activities (summer24 release)
+                    try {
+                        metadata.source.r__dataExtension_key = cache.searchForField(
+                            'dataExtension',
+                            metadata.sourceCustomObjectId,
+                            'ObjectID',
+                            'CustomerKey'
+                        );
+                        delete metadata.sourceCustomObjectId;
+                        delete metadata.sourceDataExtensionName;
+                    } catch (ex) {
+                        Util.logger.warn(` - importFile ${metadata.customerKey}: ${ex.message}`);
+                    }
+                }
+                break;
+            }
             default: {
                 Util.logger.debug(
                     ` - importFile ${metadata.customerKey}: Destination Type ${metadata.destinationObjectTypeId} not fully supported. Deploy might fail.`
@@ -489,7 +550,7 @@ class ImportFile extends MetadataType {
         }
         delete metadata.destinationObjectTypeId;
 
-        if (metadata.blankFileProcessingType) {
+        if (metadata.blankFileProcessingType !== undefined) {
             // omit this if not set
             metadata.c__blankFileProcessing = Util.inverseGet(
                 this.definition.blankFileProcessingTypeMapping,

package/lib/metadataTypes/Journey.js

@@ -270,14 +270,14 @@ class Journey extends MetadataType {
                 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: ' +
+                            'Version is required for deleting journeys 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.`
+                        `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 journeys on this BU.`
                     );
                 }
 
@@ -639,6 +639,9 @@ class Journey extends MetadataType {
      * @param {MetadataTypeItem} metadata a single item
      */
     static _postRetrieveTasks_activities(metadata) {
+        if (!metadata.activities) {
+            return;
+        }
         for (const activity of metadata.activities) {
             switch (activity.type) {
                 case 'EMAILV2': {
@@ -1407,9 +1410,7 @@ class Journey extends MetadataType {
                     default: {
                         // it is expected that we'll see 'sms' and 'push' here in the future
                         throw new Error(
-                            `channel ${
-                                metadata.channel
-                            } is not supported yet. Please open a ticket at https://github.com/Accenture/sfmc-devtools/issues/new/choose to request it`
+                            `channel ${metadata.channel} is not supported yet. Please open a ticket at https://github.com/Accenture/sfmc-devtools/issues/new/choose to request it`
                         );
                     }
                 }
@@ -1418,9 +1419,7 @@ class Journey extends MetadataType {
             }
             default: {
                 throw new Error(
-                    `definitionType ${
-                        metadata.definitionType
-                    } is not supported yet. Please open a ticket at https://github.com/Accenture/sfmc-devtools/issues/new/choose to request it`
+                    `definitionType ${metadata.definitionType} is not supported yet. Please open a ticket at https://github.com/Accenture/sfmc-devtools/issues/new/choose to request it`
                 );
             }
         }
@@ -2333,8 +2332,8 @@ class Journey extends MetadataType {
                 case 'PublishCompleted': {
                     spinner.stop();
                     const action = statusUrl.includes('/validateStatus')
-                        ? 'validation successful -'
-                        : 'published';
+                        ? '🔎 validation successful -'
+                        : '🚀 published';
 
                     Util.logger.info(` - ${action} ${this.definition.type}: ${key} / ${name}`);
                     this._showPublishStatusDetails(response);
@@ -2567,6 +2566,159 @@ class Journey extends MetadataType {
         return executedKeyArr.filter(Boolean);
     }
 
+    /**
+     * audit latest or given journey version
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were paused
+     */
+    static async audit(keyArr) {
+        let version;
+        const endpoint = '/interaction/v1/interactions/';
+        const auditedKeyArr = [];
+        const apiLimit = pLimit(20);
+        const journeyCache = await this.retrieveForCache();
+
+        const ignoredLogProperties = [
+            'executionMode',
+            'id',
+            'originalDefinitionId',
+            'publishRequestId',
+        ];
+        const preformatedProperties = [
+            'action',
+            'description',
+            'errors',
+            'key',
+            'name',
+            'publishedVersion',
+            'publishStatus',
+            'timeStamp',
+            'user',
+            'versionNumber',
+        ];
+
+        await Promise.allSettled(
+            keyArr.map((key) =>
+                apiLimit(async () => {
+                    [key, version] = key.split('/');
+                    if (!journeyCache.metadata[key]) {
+                        Util.logger.error(
+                            ` ☇ skipping audit log of ${this.definition.type} ${key}: not found on server`
+                        );
+                        return;
+                    }
+                    const toBeAuditedVersions = [];
+                    if (version === '*' || !version) {
+                        switch (journeyCache.metadata[key].definitionType) {
+                            case 'Transactional':
+                            case 'Multistep': {
+                                // transactional send journeys technically only have one version, but if you delete them and then create one with the same key their version number goes up and old audit logs are still available
+                                // multi-step journey versions could be retrieved but then we lose info of any versions that might have been deleted. Therefore we add all versions starting with the latest and counting down to 1
+                                for (let i = journeyCache.metadata[key].version; i > 0; i--) {
+                                    toBeAuditedVersions.push(i);
+                                }
+                            }
+                        }
+                    } else {
+                        toBeAuditedVersions.push(version);
+                    }
+
+                    Util.logger.info(
+                        ` - Audit log for ${this.definition.type} ${key} / ${journeyCache.metadata[key].name}`
+                    );
+                    const rateLimitActivities = pLimit(1);
+                    const auditedVersions = (
+                        await Promise.all(
+                            toBeAuditedVersions.map((version) =>
+                                rateLimitActivities(async () => {
+                                    try {
+                                        const response = await this.client.rest.getBulk(
+                                            endpoint +
+                                                journeyCache.metadata[key].id +
+                                                `/audit/all?versionNumber=${version}`
+                                        );
+
+                                        Util.logger.info(
+                                            ` - Version ${version}:\n  - ` +
+                                                response.items
+                                                    .map((log) => {
+                                                        let msg =
+                                                            `${log.action} version ${log.versionNumber} - ${Util.getGrayMsg(log.timeStamp.replace('T', ' ').slice(0, 19))}: ${log.user.name}\n` +
+                                                            (log.publishedVersion
+                                                                ? `    Published Version: ` +
+                                                                  log.publishedVersion +
+                                                                  '\n'
+                                                                : '') +
+                                                            (log.publishStatus
+                                                                ? `    Publish Status: ` +
+                                                                  log.publishStatus +
+                                                                  '\n'
+                                                                : '') +
+                                                            (log.key === key
+                                                                ? ''
+                                                                : `    Key: ` + log.key + '\n') +
+                                                            (log.name ===
+                                                            journeyCache.metadata[key].name
+                                                                ? ''
+                                                                : `    Key: ` + log.key + '\n') +
+                                                            (log.errors
+                                                                ? `    Errors:\n    • ` +
+                                                                  log.errors
+                                                                      .map((error) =>
+                                                                          error.ErrorDetail.replaceAll(
+                                                                              /[\r\n]/g,
+                                                                              ' '
+                                                                          )
+                                                                      )
+                                                                      .join('\n    • ') +
+                                                                  '\n'
+                                                                : '');
+                                                        for (const key in log) {
+                                                            if (
+                                                                !ignoredLogProperties.includes(
+                                                                    key
+                                                                ) &&
+                                                                !preformatedProperties.includes(key)
+                                                            ) {
+                                                                msg +=
+                                                                    `    ${key}: ` +
+                                                                    log[key] +
+                                                                    '\n';
+                                                            }
+                                                        }
+                                                        return msg;
+                                                    })
+                                                    .join('  - ')
+                                        );
+                                        // Util.logger.info(JSON.stringify(auditLog, null, 2));
+                                        return version;
+                                    } catch (ex) {
+                                        if (journeyCache.metadata[key].version > version) {
+                                            Util.logger.error(
+                                                ` - Retrieving audit log for ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} - Version ${version} failed: Version was not found. The highest available version seems to be ${journeyCache.metadata[key].version}`
+                                            );
+                                        } else {
+                                            Util.logger.error(
+                                                ` - Retrieving audit log for ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} - Version ${version} failed: ${ex.message}`
+                                            );
+                                        }
+                                        return;
+                                    }
+                                })
+                            )
+                        )
+                    ).filter(Boolean);
+                    if (auditedVersions.length === toBeAuditedVersions.length) {
+                        auditedKeyArr.push(key);
+                    }
+                })
+            )
+        );
+
+        return auditedKeyArr;
+    }
+
     /**
      * stops latest journey version
      *
@@ -2577,11 +2729,11 @@ class Journey extends MetadataType {
         let version;
         const endpoint = '/interaction/v1/interactions/stop/';
         const stoppedKeyArr = [];
-        const pauseTransactionalKeyArr = [];
+        const stopTransactionalKeyArr = [];
         const apiLimit = pLimit(20);
         const journeyCache = await this.retrieveForCache();
 
-        const stoppableJourneyStatus = ['Paused', 'Published', 'Finishing'];
+        const stoppableJourneyStatus = ['Paused', 'Published', 'Unpublished']; // 'Unpublished' is shown as 'Finishing' in the UI
 
         await Promise.allSettled(
             keyArr.map((key) =>
@@ -2591,7 +2743,7 @@ class Journey extends MetadataType {
                         switch (journeyCache.metadata[key].definitionType) {
                             case 'Transactional': {
                                 // transactional send journeys cannot be "stopped" but only "paused"
-                                pauseTransactionalKeyArr.push(key);
+                                stopTransactionalKeyArr.push(key);
                                 break;
                             }
                             case 'Multistep': {
@@ -2652,12 +2804,12 @@ class Journey extends MetadataType {
                                                         {}
                                                     );
                                                     Util.logger.info(
-                                                        ` - Stopped ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} - Version ${version}`
+                                                        ` - ⛔ 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}`
+                                                        ` - stopping ${this.definition.type} ${key} / ${journeyCache.metadata[key].name} - Version ${version} failed: ${ex.message}`
                                                     );
                                                     return;
                                                 }
@@ -2685,7 +2837,7 @@ class Journey extends MetadataType {
                 })
             )
         );
-        stoppedKeyArr.push(...(await this.pause(pauseTransactionalKeyArr)));
+        stoppedKeyArr.push(...(await this.pause(stopTransactionalKeyArr)));
 
         return stoppedKeyArr;
     }
@@ -2708,16 +2860,20 @@ class Journey extends MetadataType {
                 apiLimit(async () => {
                     [key, version] = key.split('/');
                     if (journeyCache.metadata[key]) {
-                        if (journeyCache.metadata[key].status === 'Paused') {
+                        if (
+                            (!version || journeyCache.metadata[key].version == version) &&
+                            journeyCache.metadata[key].status === 'Paused'
+                        ) {
                             Util.logger.info(
-                                ` ${this.definition.type} ${
-                                    key
-                                } (${journeyCache.metadata[key].name}): already paused`
+                                ` ${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') {
+                        } else if (
+                            (!version || journeyCache.metadata[key].version == version) &&
+                            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}`
                             );
@@ -2757,7 +2913,7 @@ class Journey extends MetadataType {
                                         {}
                                     );
                                     Util.logger.info(
-                                        ` -- 🛑 paused ${this.definition.type} ${key}/${version} / ${journeyCache.metadata[key].name}`
+                                        ` - 🛑 paused ${this.definition.type} ${key}/${version} / ${journeyCache.metadata[key].name}`
                                     );
                                     pausedKeyArr.push(key);
                                 } catch (ex) {
@@ -2803,7 +2959,10 @@ class Journey extends MetadataType {
                 apiLimit(async () => {
                     [key, version] = key.split('/');
                     if (journeyCache.metadata[key]) {
-                        if (journeyCache.metadata[key].status !== 'Paused') {
+                        if (
+                            (!version || journeyCache.metadata[key].version == version) &&
+                            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}`
                             );