mcdev 7.1.4 → 7.2.0

package/lib/metadataTypes/Journey.js

@@ -6,6 +6,7 @@ import { Util } from '../util/util.js';
 import cache from '../util/cache.js';
 import File from '../util/file.js';
 import ReplaceCbReference from '../util/replaceContentBlockReference.js';
+import Retriever from '../Retriever.js';
 
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
@@ -427,50 +428,60 @@ class Journey extends MetadataType {
                 // ! transactional (email) journeys only have one activity (type=EMAILV2) which links back to the transactionalEmail ()
                 switch (metadata.channel) {
                     case 'email': {
-                        if (
-                            metadata.activities?.length > 0 &&
-                            metadata.activities[0].configurationArguments?.triggeredSendKey
-                        ) {
+                        if (metadata.activities?.length > 0) {
                             const activity = metadata.activities[0];
                             // trigger found; there can only be one entry in this array
-                            try {
-                                const tEmailKey = cache.searchForField(
-                                    'transactionalEmail',
-                                    activity.configurationArguments?.triggeredSendId,
-                                    'definitionId',
-                                    'definitionKey'
-                                );
-                                if (
-                                    tEmailKey != activity.configurationArguments?.triggeredSendKey
-                                ) {
-                                    throw new Error(
-                                        ` - ${this.definition.type} ${
-                                            metadata[this.definition.nameField]
-                                        } (${
-                                            metadata[this.definition.keyField]
-                                        }): transactionalEmailId not matching Id found on transactionalEmail with key in transactionalEmailKey`
+
+                            if (activity.configurationArguments?.triggeredSendId) {
+                                try {
+                                    const tEmailKey = cache.searchForField(
+                                        'transactionalEmail',
+                                        activity.configurationArguments?.triggeredSendId,
+                                        'definitionId',
+                                        'definitionKey'
                                     );
-                                }
-                                if (
-                                    activity.metaData?.highThroughput?.definitionKey &&
-                                    activity.metaData?.highThroughput?.definitionKey !=
-                                        activity.configurationArguments?.triggeredSendKey
-                                ) {
-                                    throw new Error(
+                                    if (
+                                        activity.configurationArguments?.triggeredSendKey &&
+                                        tEmailKey !=
+                                            activity.configurationArguments?.triggeredSendKey
+                                    ) {
+                                        Util.logger.debug(
+                                            `triggeredSendKey not matching triggeredSendId. Overwriting '${activity.configurationArguments.triggeredSendKey}' with the correct key '${tEmailKey}'.`
+                                        );
+                                    }
+                                    activity.configurationArguments.r__transactionalEmail_key =
+                                        activity.configurationArguments.triggeredSendKey;
+                                    delete activity.configurationArguments.triggeredSendKey;
+                                    delete activity.configurationArguments.triggeredSendId;
+                                } catch (ex) {
+                                    Util.logger.warn(
                                         ` - ${this.definition.type} ${
                                             metadata[this.definition.nameField]
-                                        } (${
-                                            metadata[this.definition.keyField]
-                                        }): metaData.highThroughput.definitionKey not matching key in configurationArguments.transactionalEmailKey`
+                                        } (${metadata[this.definition.keyField]}): ${ex.message}.`
                                     );
                                 }
-                                activity.configurationArguments.r__transactionalEmail_key =
-                                    activity.configurationArguments.triggeredSendKey;
-                                delete activity.configurationArguments.triggeredSendKey;
-                                delete activity.configurationArguments.triggeredSendId;
+                            }
+                            if (
+                                activity.metaData?.highThroughput?.definitionKey &&
+                                activity.configurationArguments?.r__transactionalEmail_key &&
+                                activity.metaData?.highThroughput?.definitionKey !=
+                                    activity.configurationArguments.r__transactionalEmail_key
+                            ) {
+                                Util.logger.warn(
+                                    ` - ${this.definition.type} ${
+                                        metadata[this.definition.nameField]
+                                    } (${metadata[this.definition.keyField]}): activities[0].metaData.highThroughput.definitionKey not matching key in activities[0].configurationArguments.r__transactionalEmail_key.`
+                                );
+                            } else if (
+                                activity.configurationArguments?.r__transactionalEmail_key &&
+                                metadata.status === 'Published'
+                            ) {
+                                // as long as status is Draft, we wont have r__transactionalEmail_key set as that record will not have been created
                                 delete activity.metaData.highThroughput.definitionKey;
+                            }
 
-                                if (activity.metaData?.highThroughput?.dataExtensionId) {
+                            if (activity.metaData?.highThroughput?.dataExtensionId) {
+                                try {
                                     activity.metaData.highThroughput.r__dataExtension_key =
                                         cache.searchForField(
                                             'dataExtension',
@@ -479,13 +490,13 @@ class Journey extends MetadataType {
                                             'CustomerKey'
                                         );
                                     delete activity.metaData.highThroughput.dataExtensionId;
+                                } catch (ex) {
+                                    Util.logger.warn(
+                                        ` - ${this.definition.type} ${
+                                            metadata[this.definition.nameField]
+                                        } (${metadata[this.definition.keyField]}): ${ex.message}.`
+                                    );
                                 }
-                            } catch (ex) {
-                                Util.logger.warn(
-                                    ` - ${this.definition.type} ${
-                                        metadata[this.definition.nameField]
-                                    } (${metadata[this.definition.keyField]}): ${ex.message}.`
-                                );
                             }
                         }
                         // ~~~ ACTIVITIES ~~~~
@@ -1032,15 +1043,32 @@ class Journey extends MetadataType {
                         const activity = metadata.activities[0];
                         if (activity.configurationArguments?.r__transactionalEmail_key) {
                             // trigger found; there can only be one entry in this array
-                            activity.configurationArguments.triggeredSendId = cache.searchForField(
-                                'transactionalEmail',
-                                activity.configurationArguments.r__transactionalEmail_key,
-                                'definitionKey',
-                                'definitionId'
-                            );
-                            activity.configurationArguments.triggeredSendKey =
-                                activity.configurationArguments.r__transactionalEmail_key;
+                            try {
+                                activity.configurationArguments.triggeredSendId =
+                                    cache.searchForField(
+                                        'transactionalEmail',
+                                        activity.configurationArguments.r__transactionalEmail_key,
+                                        'definitionKey',
+                                        'definitionId'
+                                    );
+                                activity.configurationArguments.triggeredSendKey =
+                                    activity.configurationArguments.r__transactionalEmail_key;
+                            } catch (ex) {
+                                const isCreateMode = !cache.getByKey('journey', metadata.key);
+                                if (isCreateMode && !Util.OPTIONS.publish) {
+                                    // no need to add a log entry if the publish-option was provided
+                                    Util.logger.info(
+                                        ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                                            metadata[this.definition.keyField]
+                                        }): To activate this transactional journey (and create the associated transactionalEmail record), please run 'mcdev publish ${this.buObject.credential}/${this.buObject.businessUnit} journey ${metadata.key}' or click on "Activate" in the GUI.`
+                                    );
+                                } else if (!isCreateMode) {
+                                    // block deployment if we are in update mode
+                                    throw ex;
+                                }
+                            }
                             if (activity.metaData?.highThroughput) {
+                                // this is crucial for pinging the /interaction/v1/interactions/transactional/create endpoint that creates the transactionalEmail
                                 activity.metaData.highThroughput.definitionKey =
                                     activity.configurationArguments.r__transactionalEmail_key;
                             }
@@ -1508,113 +1536,224 @@ class Journey extends MetadataType {
      * @returns {Promise.<string[]>} Returns list of updated keys/ids that were published. Success could only be seen with a delay in the UI because the publish-endpoint is async
      */
     static async publish(keyArr) {
-        const results = [];
+        const resultsJourney = [];
+        const resultsTransactional = [];
         // works only with objectId
-        let objectId;
-        let idFound = false;
-        let versionFound = false;
         const statusUrls = [];
+        const executedKeyArr = [];
+        const metadataMap = await this.retrieveForCache();
+
         for (let key of keyArr) {
+            let objectId;
             let version;
-            if (key) {
-                if (key.startsWith('%23')) {
-                    // if the key started with %23 assume an ID was copied from the URL but the user forgot to prefix it with id:
-                    // correct the format
-                    key = 'id:' + key.slice(3);
+            let journey;
+            if (!key) {
+                continue;
+            }
+            if (key.startsWith('%23')) {
+                // if the key started with %23 assume an ID was copied from the URL but the user forgot to prefix it with id:
+                // correct the format
+                key = 'id:' + key.slice(3);
+            }
+            if (key.startsWith('id:')) {
+                // ! allow selecting journeys by ID because that's what users see in the URL
+                // remove id
+                objectId = key.slice(3);
+                if (objectId.startsWith('%23')) {
+                    // in the journey URL the Id is prefixed with an HTML-encoded "#" which could accidentally be copied by users
+                    // despite the slicing above, this still needs testing here because users might have prefixed the ID with id: but did not know to remove the #23
+                    objectId = objectId.slice(3);
+                    // correct the format to ensure we show sth readable in the "Downloaded" log
+                    // objectId =  objectId;
+                    // update this here to show it in the log
+                    key = 'id:' + objectId;
                 }
-                if (key.startsWith('id:')) {
-                    idFound = true;
-                    // ! allow selecting journeys by ID because that's what users see in the URL
-                    // remove id
-                    objectId = key.slice(3);
-                    if (objectId.startsWith('%23')) {
-                        // in the journey URL the Id is prefixed with an HTML-encoded "#" which could accidentally be copied by users
-                        // despite the slicing above, this still needs testing here because users might have prefixed the ID with id: but did not know to remove the #23
-                        objectId = objectId.slice(3);
-                        // correct the format to ensure we show sth readable in the "Downloaded" log
-                        objectId = 'id:' + objectId;
-                        // update this here to show it in the log
-                        key = objectId;
-                    }
-                    if (objectId.includes('/')) {
-                        versionFound = true;
-                        version = objectId.split('/')[1];
-                        // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the ID for caching as we always aim to retrieve the latest version only
-                        objectId = objectId.split('/')[0];
-                    } else {
-                        // if we didn't find a version we need to cache this from the API after all
-                        objectId = null;
-                        if (key.includes('/')) {
-                            // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the key for caching as we always aim to retrieve the latest version only
-                            key = key.split('/')[0];
-                        }
+                if (objectId.includes('/')) {
+                    version = objectId.split('/')[1];
+                    // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the ID for caching as we always aim to retrieve the latest version only
+                    objectId = objectId.split('/')[0];
+                } else {
+                    // if we didn't find a version we need to cache this from the API after all
+                    if (key.includes('/')) {
+                        // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the key for caching as we always aim to retrieve the latest version only
+                        key = key.split('/')[0];
                     }
                 }
-                if (!objectId) {
+                journey = Object.values(metadataMap.metadata).find((el) => el.id === objectId);
+                if (!journey) {
                     Util.logger.info(
-                        ` - getting${!idFound && !versionFound ? ' ID and' : ''} latest version from server`
+                        ` ☇ skipping ${this.definition.type} ${key}: not found on server (1)`
                     );
-                    const metadataMap = await this.retrieveForCache(undefined, undefined, key);
-                    const journey = Object.values(metadataMap.metadata);
-                    if (!journey.length) {
-                        Util.logger.info(`Skipping ${key} - did not find an item with such key`);
-                        continue;
-                    }
-                    objectId = journey[0].id;
-                    version = journey[0].version;
-                    if (!objectId || !version) {
-                        Util.logger.info(`Skipping ${key} - did not find an item with such key`);
-                        continue;
-                    }
+                    continue;
                 }
+            } else {
+                // key assumed
+                journey = metadataMap.metadata[key];
             }
 
-            results.push(
-                (async () => {
-                    try {
-                        const response = await this.client.rest.post(
-                            `/interaction/v1/interactions/publishAsync/${objectId}?versionNumber=${version}`,
-                            {}
-                        ); // payload is empty for this request
-                        if (response.statusUrl && response.statusId) {
-                            Util.logger.info(
-                                ` - queued for publishing ${this.definition.type}: ${key}`
-                            );
-                            statusUrls.push({ key, statusUrl: response.statusUrl });
-                        } else {
-                            throw new Error(response);
-                        }
-                        return key;
-                    } catch (ex) {
-                        if (ex.message === 'Cannot publish interaction in Published status.') {
-                            Util.logger.info(
-                                ` - ${this.definition.type} ${key} is already published`
-                            );
-                        } else if (ex.message === 'Cannot publish interaction in Stopped status.') {
-                            Util.logger.warn(
-                                ` - ${this.definition.type} ${key} is already published but stopped. Please resume it manually.`
-                            );
-                        } else {
-                            Util.logger.error(
-                                `Failed to publish ${this.definition.type} ${key}: ${ex.message}`
-                            );
-                        }
-                    }
-                })()
-            );
+            if (!journey) {
+                Util.logger.info(
+                    ` ☇ skipping ${this.definition.type} ${key}: not found on server (2)`
+                );
+                continue;
+            }
+            if (!version) {
+                version = journey.version;
+            }
+            if (journey.status === 'Published') {
+                // api would return error code 30000 and ask to open a support case when in fact we simply already have a transactionalEmail created based on this status
+                Util.logger.error(
+                    ` ☇ skipping ${this.definition.type} ${
+                        journey[this.definition.nameField]
+                    } (${journey[this.definition.keyField]}): already published`
+                );
+                continue;
+            }
+
+            switch (journey.definitionType) {
+                case 'Transactional': {
+                    resultsTransactional.push(
+                        (async () => {
+                            try {
+                                const response = await this.client.rest.post(
+                                    `/interaction/v1/interactions/transactional/create`,
+                                    { definitionId: journey.id }
+                                );
+                                if (response.errors?.length) {
+                                    throw new Error(JSON.stringify(response));
+                                } else {
+                                    Util.logger.info(
+                                        ` - published ${this.definition.type}: ${
+                                            journey[this.definition.nameField]
+                                        } (${journey[this.definition.keyField]} by creating the matching transactionalEmail`
+                                    );
+                                    statusUrls.push({ key, statusUrl: response.statusUrl });
+                                }
+                                return key;
+                            } catch (ex) {
+                                if (
+                                    ex.response.status === 400 &&
+                                    ex.response?.data?.errors?.length === 1 &&
+                                    ex.response?.data?.errors?.[0]?.errorCode === '121500'
+                                ) {
+                                    Util.logger.error(
+                                        `Failed to publish ${
+                                            journey[this.definition.nameField]
+                                        } (${journey[this.definition.keyField]}): Make sure the Event Definition Key, Data Extension and E-Mail are saved to the journey`
+                                    );
+                                } else {
+                                    Util.logger.error(
+                                        `Failed to publish ${
+                                            journey[this.definition.nameField]
+                                        } (${journey[this.definition.keyField]}): ${ex.message}`
+                                    );
+                                    if (ex.response?.data?.errors?.length) {
+                                        Util.logger.error(
+                                            JSON.stringify(ex.response?.data?.errors, null, 2)
+                                        );
+                                    }
+                                }
+                            }
+                        })()
+                    );
+                    break;
+                }
+                case 'Multistep':
+                case 'Quicksend': {
+                    resultsJourney.push(
+                        (async () => {
+                            try {
+                                const response = await this.client.rest.post(
+                                    `/interaction/v1/interactions/publishAsync/${journey.id}?versionNumber=${version}`,
+                                    {}
+                                ); // payload is empty for this request
+                                if (response.statusUrl && response.statusId) {
+                                    Util.logger.info(
+                                        ` - queued for publishing ${this.definition.type}: ${key}`
+                                    );
+                                    statusUrls.push({ key, statusUrl: response.statusUrl });
+                                } else {
+                                    throw new Error(response);
+                                }
+                                return journey.key;
+                            } catch (ex) {
+                                if (
+                                    ex.message === 'Cannot publish interaction in Published status.'
+                                ) {
+                                    Util.logger.info(
+                                        ` - ${this.definition.type} ${key} is already published`
+                                    );
+                                } else if (
+                                    ex.message === 'Cannot publish interaction in Stopped status.'
+                                ) {
+                                    Util.logger.warn(
+                                        ` - ${this.definition.type} ${key} is already published but stopped. Please resume it manually.`
+                                    );
+                                } else {
+                                    Util.logger.error(
+                                        `Failed to publish ${this.definition.type} ${key}: ${ex.message}`
+                                    );
+                                }
+                            }
+                        })()
+                    );
+                }
+            }
+        } // for loop
+        if (resultsJourney.length) {
+            Util.logger.info(`Found ${resultsJourney.length} journey results`);
+            executedKeyArr.push(...(await Promise.all(resultsJourney)).filter(Boolean));
+
+            if (!Util.OPTIONS.skipStatusCheck && statusUrls.length) {
+                Util.logger.info(
+                    `Checking status of ${statusUrls.length} published item${statusUrls.length === 1 ? '' : 's'}`
+                );
+                executedKeyArr.length = 0;
+                await Util.sleep(5000);
+                for (const item of statusUrls) {
+                    executedKeyArr.push(await this._checkPublishStatus(item.statusUrl, item.key));
+                }
+            }
         }
-        const executedKeyArr = (await Promise.all(results)).filter(Boolean);
+        if (resultsTransactional.length) {
+            Util.logger.info(`Found ${resultsTransactional.length} journey results`);
+            const transactionalKeyArr = (await Promise.all(resultsTransactional)).filter(Boolean);
+            executedKeyArr.push(...transactionalKeyArr);
+
+            Util.logger.info('Retrieving relevant journeys');
+            const retriever = new Retriever(this.properties, this.buObject);
+
+            try {
+                const updatedJourneyRetrieve = await retriever.retrieve(
+                    ['journey'],
+                    transactionalKeyArr
+                );
 
-        if (!Util.OPTIONS.skipStatusCheck && statusUrls.length) {
-            Util.logger.info(
-                `Checking status of ${statusUrls.length} published item${statusUrls.length === 1 ? '' : 's'}`
-            );
-            executedKeyArr.length = 0;
-            await Util.sleep(5000);
-            for (const item of statusUrls) {
-                executedKeyArr.push(await this._checkPublishStatus(item.statusUrl, item.key));
+                /** @type {MetadataTypeItem[]} */
+                const updatedJourneys = Object.values(updatedJourneyRetrieve?.journey[0]);
+                if (updatedJourneys) {
+                    const updatedTransactionalEmails = [];
+                    for (const journey of updatedJourneys) {
+                        updatedTransactionalEmails.push(
+                            journey.activities?.[0]?.configurationArguments
+                                ?.r__transactionalEmail_key
+                        );
+                    }
+                    if (updatedTransactionalEmails.filter(Boolean).length) {
+                        Util.logger.info('Retrieving relevant transactionalEmails');
+                        await retriever.retrieve(
+                            ['transactionalEmail'],
+                            updatedTransactionalEmails.filter(Boolean)
+                        );
+                    } else {
+                        Util.logger.error(
+                            `Could not find transactional Emails for the published journeys`
+                        );
+                    }
+                }
+            } catch (ex) {
+                Util.logger.errorStack(ex, 'retrieve failed');
             }
-            // return executedKeyArr;
         }
         Util.logger.info(
             `Published ${executedKeyArr.filter(Boolean).length} of ${keyArr.length} items`

package/lib/metadataTypes/TransactionalEmail.js

@@ -47,6 +47,24 @@ class TransactionalEmail extends TransactionalMessage {
         return super.update(metadata);
     }
 
+    /**
+     * Updates a single item
+     *
+     * @param {MetadataTypeItem} metadata how the item shall look after the update
+     * @returns {Promise} Promise
+     */
+    static create(metadata) {
+        if (metadata.definitionType === 'Transactional' && metadata.channel === 'email') {
+            // only send this during create or else we might end up with an unexpected outcome
+            Util.logger.warn(
+                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                    metadata[this.definition.keyField]
+                }): While possible, it is not recommended to create transactional journeys via transactionalEmail. Instead, create the journey and then publish it (mcdev deploy cred/bu journey --publish)`
+            );
+        }
+        return super.create(metadata);
+    }
+
     /**
      * prepares for deployment
      *
@@ -124,9 +142,8 @@ class TransactionalEmail extends TransactionalMessage {
     static async postDeployTasks() {
         if (this._createdJourneyKeys?.length) {
             Util.logger.warn(
-                `Please download related journeys via: mcdev r ${this.buObject.credential}/${
-                    this.buObject.businessUnit
-                } journey "${this._createdJourneyKeys.join(',')}"`
+                `Please download related journeys via: mcdev retrieve ${this.buObject.credential}/${this.buObject.businessUnit} -m
+                ${this._createdJourneyKeys.map((el) => `"journey:${el}"`).join(' ')}`
             );
         }
         delete this._createdJourneyKeys;

package/lib/metadataTypes/definitions/Journey.definition.js

@@ -23,7 +23,6 @@ export default {
     dependencyGraph: {
         // classic email cannot be deployed anymore
         event: ['triggers.metaData.r__event_key'],
-        transactionalEmail: ['activities.configurationArguments.r__transactionalEmail_key'],
         dataExtension: [
             'activities.metaData.highThroughput.r__dataExtension_key',
             'activities.configurationArguments.triggeredSend.r__dataExtension_key.domainExclusions',

package/lib/util/file.js

@@ -260,57 +260,61 @@ const File = {
                 // will throw an error falsely assuming bad syntax
                 return await this.beautify_beautyAmp(content, true);
             }
-            // load the right prettier config relative to our file
-            switch (filetype) {
-                case 'htm':
-                case 'html': {
-                    FileFs.prettierConfig.parser = 'html';
-                    break;
-                }
-                case 'ssjs':
-                case 'js': {
-                    FileFs.prettierConfig.parser = 'babel';
-                    break;
-                }
-                case 'json': {
-                    FileFs.prettierConfig.parser = 'json';
-                    break;
-                }
-                case 'yaml':
-                case 'yml': {
-                    FileFs.prettierConfig.parser = 'yaml';
-                    break;
-                }
-                case 'ts': {
-                    FileFs.prettierConfig.parser = 'babel-ts';
-                    break;
-                }
-                case 'css': {
-                    FileFs.prettierConfig.parser = 'css';
-                    break;
-                }
-                case 'less': {
-                    FileFs.prettierConfig.parser = 'less';
-                    break;
-                }
-                case 'sass':
-                case 'scss': {
-                    FileFs.prettierConfig.parser = 'scss';
-                    break;
-                }
-                case 'md': {
-                    FileFs.prettierConfig.parser = 'markdown';
-                    break;
-                }
-                case 'sql': {
-                    FileFs.prettierConfig.parser = 'sql';
-                    FileFs.prettierConfig.plugins = ['prettier-plugin-sql'];
-                    break;
-                }
-                default: {
-                    FileFs.prettierConfig.parser = 'babel';
+
+            if (!FileFs.prettierConfig.parser) {
+                // load the right prettier config relative to our file
+                switch (filetype) {
+                    case 'htm':
+                    case 'html': {
+                        FileFs.prettierConfig.parser = 'html';
+                        break;
+                    }
+                    case 'ssjs':
+                    case 'js': {
+                        FileFs.prettierConfig.parser = 'babel';
+                        break;
+                    }
+                    case 'json': {
+                        FileFs.prettierConfig.parser = 'json';
+                        break;
+                    }
+                    case 'yaml':
+                    case 'yml': {
+                        FileFs.prettierConfig.parser = 'yaml';
+                        break;
+                    }
+                    case 'ts': {
+                        FileFs.prettierConfig.parser = 'babel-ts';
+                        break;
+                    }
+                    case 'css': {
+                        FileFs.prettierConfig.parser = 'css';
+                        break;
+                    }
+                    case 'less': {
+                        FileFs.prettierConfig.parser = 'less';
+                        break;
+                    }
+                    case 'sass':
+                    case 'scss': {
+                        FileFs.prettierConfig.parser = 'scss';
+                        break;
+                    }
+                    case 'md': {
+                        FileFs.prettierConfig.parser = 'markdown';
+                        break;
+                    }
+                    case 'sql': {
+                        FileFs.prettierConfig.parser = 'sql';
+                        FileFs.prettierConfig.plugins = ['prettier-plugin-sql'];
+                        break;
+                    }
+                    default: {
+                        FileFs.prettierConfig.parser = 'babel';
+                    }
                 }
             }
+
             formatted = await prettier.format(content, FileFs.prettierConfig);
         } catch (ex) {
             // save prettier errror into log file