mcdev 4.3.3 → 5.0.0

package/lib/metadataTypes/Asset.js

@@ -25,7 +25,7 @@ class Asset extends MetadataType {
      */
     static async retrieve(retrieveDir, _, subTypeArr, key) {
         const items = [];
-        subTypeArr = subTypeArr || this._getSubTypes();
+        subTypeArr ||= this._getSubTypes();
         await File.initPrettier();
         // loop through subtypes and return results of each subType for caching (saving is handled per subtype)
         for (const subType of subTypeArr) {
@@ -113,6 +113,7 @@ class Asset extends MetadataType {
      * @returns {Promise} Promise
      */
     static create(metadata) {
+        delete metadata.businessUnitAvailability;
         const uri = '/asset/v1/content/assets/';
         return super.createREST(metadata, uri);
     }
@@ -495,6 +496,78 @@ class Asset extends MetadataType {
         return metadata;
     }
 
+    /**
+     * Gets executed after deployment of metadata type
+     *
+     * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
+     * @param {TYPE.MetadataTypeMap} _ originalMetadata to be updated (contains additioanl fields)
+     * @param {{created: number, updated: number}} createdUpdated counter representing successful creates/updates
+     * @param {boolean} [isRefresh] optional flag to indicate that triggeredSend should be refreshed after deployment of assets
+     * @returns {Promise.<void>} -
+     */
+    static async postDeployTasks(metadata, _, createdUpdated, isRefresh) {
+        if (isRefresh) {
+            if (createdUpdated.updated) {
+                // only run this if assets were updated. for created assets we do not expect
+                this._refreshTriggeredSend(metadata);
+            } else {
+                Util.logger.warn(
+                    'You set the --refresh flag but no updated assets found. Skipping refresh of triggeredSendDefinitions.'
+                );
+            }
+        }
+    }
+
+    /**
+     * helper for {@link postDeployTasks}. triggers a refresh of active triggerredSendDefinitions associated with the updated asset-message items. Gets executed if isRefresh is true.
+     *
+     * @private
+     * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
+     * @returns {Promise.<void>} -
+     */
+    static async _refreshTriggeredSend(metadata) {
+        // get legacyData.legacyId from assets to compare to TSD's metadata.Email.ID to
+        const legacyIdArr = Object.keys(metadata)
+            .map((key) => metadata[key]?.legacyData?.legacyId)
+            .filter(Boolean);
+
+        if (!legacyIdArr.length) {
+            Util.logger.warn(
+                'No legacyId found in updated emails. Skipping refresh of triggeredSendDefinitions.'
+            );
+            return;
+        }
+        // prep triggeredSendDefinition class
+        const TriggeredSend = require('./TriggeredSend');
+        TriggeredSend.properties = this.properties;
+        TriggeredSend.buObject = this.buObject;
+        TriggeredSend.client = this.client;
+        try {
+            // find refreshable TSDs
+            const tsdObj = (await TriggeredSend.findRefreshableItems()).metadata;
+
+            const tsdCountInitial = Object.keys(tsdObj).length;
+            const emailCount = legacyIdArr.length;
+            // filter TSDs by legacyId
+            for (const key in tsdObj) {
+                if (!legacyIdArr.includes(tsdObj[key].Email.ID)) {
+                    delete tsdObj[key];
+                }
+            }
+            const tsdCountFiltered = Object.keys(tsdObj).length;
+            Util.logger.info(
+                `Found ${tsdCountFiltered} out of ${tsdCountInitial} total triggeredSendDefinitions for ${emailCount} deployed emails. Commencing validation...`
+            );
+
+            // get keys of TSDs to refresh
+            const keyArr = await TriggeredSend.getKeysForValidTSDs(tsdObj);
+
+            await TriggeredSend.refresh(keyArr);
+        } catch {
+            Util.logger.warn('Failed to refresh triggeredSendDefinition');
+        }
+    }
+
     /**
      * prepares an asset definition for deployment
      *
@@ -818,16 +891,17 @@ class Asset extends MetadataType {
 
                 // metadata.views.html.content (mandatory)
                 // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
+                const fileName = 'views.html.content' + subtypeExtension;
                 if (
                     (await File.pathExists(
-                        File.normalizePath([...readDirArr, `index${subtypeExtension}.html`])
+                        File.normalizePath([...readDirArr, `${fileName}.html`])
                     )) &&
                     metadata.views.html
                 ) {
                     if (!fileListOnly) {
                         metadata.views.html.content = await File.readFilteredFilename(
                             readDirArr,
-                            'index' + subtypeExtension,
+                            fileName,
                             'html'
                         );
                     }
@@ -836,7 +910,7 @@ class Asset extends MetadataType {
                         // to use this method in templating, store a copy of the info in fileList
                         fileList.push({
                             subFolder: [...subDirArr, customerKey],
-                            fileName: 'index' + subtypeExtension,
+                            fileName: fileName,
                             fileExt: 'html',
                             content: metadata.views.html.content,
                         });
@@ -859,6 +933,59 @@ class Asset extends MetadataType {
                 }
                 break;
             }
+            case 'template': {
+                // template-template
+                // this complex type always creates its own subdir per asset
+                subDirArr = [this.definition.type, subType];
+                readDirArr = [deployDir, ...subDirArr, templateName || customerKey];
+                const fileName = 'content' + subtypeExtension;
+
+                const fileExtArr = ['html']; // eslint-disable-line no-case-declarations
+                for (const ext of fileExtArr) {
+                    if (
+                        await File.pathExists(
+                            File.normalizePath([...readDirArr, `${fileName}.${ext}`])
+                        )
+                    ) {
+                        // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
+                        if (!fileListOnly) {
+                            metadata.content = await File.readFilteredFilename(
+                                readDirArr,
+                                fileName,
+                                ext
+                            );
+                        }
+                        if (templateName) {
+                            // to use this method in templating, store a copy of the info in fileList
+                            fileList.push({
+                                subFolder: subDirArr,
+                                fileName: fileName,
+                                fileExt: ext,
+                                content: metadata.content,
+                            });
+                        }
+                        // break loop when found
+                        break;
+                    }
+                }
+
+                // metadata.slots.<>.blocks.<>.content (optional)
+                if (metadata?.slots) {
+                    await this._mergeCode_slots(
+                        'slots',
+                        metadata.slots,
+                        readDirArr,
+                        subtypeExtension,
+                        subDirArr,
+                        fileList,
+                        customerKey,
+                        templateName,
+                        fileListOnly
+                    );
+                }
+
+                break;
+            }
             case 'textonlyemail': {
                 // message
                 // metadata.views.text.content
@@ -970,7 +1097,6 @@ class Asset extends MetadataType {
 
                 break;
             }
-            case 'template': // template-template
             case 'buttonblock': // block - Button Block
             case 'freeformblock': // block
             case 'htmlblock': // block
@@ -983,12 +1109,7 @@ class Asset extends MetadataType {
                 // metadata.content
                 subDirArr = [this.definition.type, subType];
                 readDirArr = [deployDir, ...subDirArr];
-                const fileExtArr = ['html']; // eslint-disable-line no-case-declarations
-                if (metadata.assetType.name === 'codesnippetblock') {
-                    // extracted code snippets should end on the right extension
-                    // we are making a few assumptions during retrieve to pick the right one
-                    fileExtArr.push('amp', 'sjss');
-                }
+                const fileExtArr = ['html', 'ssjs', 'amp']; // eslint-disable-line no-case-declarations
                 for (const ext of fileExtArr) {
                     if (
                         await File.pathExists(
@@ -1005,6 +1126,9 @@ class Asset extends MetadataType {
                                 (templateName || customerKey) + subtypeExtension,
                                 ext
                             );
+                            if (ext === 'ssjs') {
+                                metadata.content = `<script runat="server">\n${metadata.content}</script>`;
+                            }
                         }
                         if (templateName) {
                             // to use this method in templating, store a copy of the info in fileList
@@ -1117,14 +1241,14 @@ class Asset extends MetadataType {
         // unfortunately, asset's key can contain spaces at beginning/end which can break the file system when folders are created with it
         const customerKey = metadata.customerKey.trim();
         switch (metadata.assetType.name) {
-            case 'templatebasedemail': // message
+            case 'templatebasedemail': // message-templatebasedemail
             case 'htmlemail': {
-                // message
+                // message-htmlemail
                 // metadata.views.html.content (mandatory)
                 if (metadata.views?.html?.content?.length) {
                     codeArr.push({
                         subFolder: null,
-                        fileName: 'index',
+                        fileName: 'views.html.content',
                         fileExt: 'html',
                         content: metadata.views.html.content,
                     });
@@ -1142,8 +1266,32 @@ class Asset extends MetadataType {
                     subFolder: [customerKey],
                 };
             }
+            case 'template': {
+                // template-template
+                // metadata.content
+                const fileExt = 'html'; // eslint-disable-line no-case-declarations
+                if (metadata?.content?.length) {
+                    codeArr.push({
+                        subFolder: null,
+                        fileName: 'content',
+                        fileExt: fileExt,
+                        content: metadata.content,
+                    });
+                    delete metadata.content;
+                }
+                // metadata.slots.<>.blocks.<>.content (optional)
+                if (metadata.slots) {
+                    this._extractCode_slots('slots', metadata.slots, codeArr);
+                }
+
+                return {
+                    json: metadata,
+                    codeArr: codeArr,
+                    subFolder: [customerKey],
+                };
+            }
             case 'textonlyemail': {
-                // message
+                // message-textonlyemail
                 // metadata.views.text.content
                 if (metadata.views?.text?.content?.length) {
                     codeArr.push({
@@ -1157,7 +1305,7 @@ class Asset extends MetadataType {
                 return { json: metadata, codeArr: codeArr, subFolder: null };
             }
             case 'webpage': {
-                // asset
+                // asset-webpage
                 // metadata.views.html.content (pre & post 20222)
                 if (metadata.views?.html?.content?.length) {
                     codeArr.push({
@@ -1192,31 +1340,37 @@ class Asset extends MetadataType {
                     subFolder: [customerKey],
                 };
             }
-            case 'template': // template-template
-            case 'buttonblock': // block - Button Block
-            case 'freeformblock': // block
-            case 'htmlblock': // block
-            case 'icemailformblock': // block - Interactive Content Email Form
-            case 'imageblock': // block - Image Block
-            case 'textblock': // block
-            case 'smartcaptureblock': // other
+            case 'buttonblock': // block-buttonblock
+            case 'freeformblock': // block-freeformblock
+            case 'htmlblock': // block-htmlblock
+            case 'icemailformblock': // block-icemailformblock - Interactive Content Email Form
+            case 'imageblock': // block-imageblock - Image Block
+            case 'textblock': // block-textblock
+            case 'smartcaptureblock': // other-smartcaptureblock
             case 'codesnippetblock': {
-                // other
+                // other-codesnippetblock
                 // metadata.content
-                let fileExt = 'html'; // eslint-disable-line no-case-declarations
-                if (
+                let fileExt;
+                let content = metadata?.content;
+                const ssjs = Util.getSsjs(metadata?.content);
+
+                if (ssjs) {
+                    fileExt = 'ssjs';
+                    content = ssjs;
+                } else if (
                     metadata.assetType.name === 'codesnippetblock' && // extracted code snippets should end on the right extension
-                    // we are making a few assumptions during retrieve to pick the right one
-                    metadata?.content?.includes('%%[')
+                    content?.includes('%%[')
                 ) {
                     fileExt = 'amp';
+                } else {
+                    fileExt = 'html';
                 }
-                if (metadata?.content?.length) {
+                if (content?.length) {
                     codeArr.push({
                         subFolder: null,
                         fileName: customerKey,
                         fileExt: fileExt,
-                        content: metadata.content,
+                        content: content,
                     });
                     delete metadata.content;
                 }

package/lib/metadataTypes/AttributeGroup.js

@@ -23,7 +23,6 @@ class AttributeGroup extends MetadataType {
             retrieveDir,
             '/hub/v1/contacts/schema/attributeGroups',
             null,
-            null,
             key
         );
     }

package/lib/metadataTypes/Automation.js

@@ -230,12 +230,11 @@ class Automation extends MetadataType {
      * @param {TYPE.AutomationMap} metadata metadata mapped by their keyField
      * @param {string} targetBU name/shorthand of target businessUnit for mapping
      * @param {string} retrieveDir directory where metadata after deploy should be saved
+     * @param {boolean} [isRefresh] optional flag - so far not used by automation
      * @returns {Promise.<TYPE.AutomationMap>} Promise
      */
-    static async deploy(metadata, targetBU, retrieveDir) {
-        const orignalMetadata = JSON.parse(JSON.stringify(metadata));
-        const upsertResults = await this.upsert(metadata, targetBU);
-        await this.postDeployTasks(upsertResults, orignalMetadata);
+    static async deploy(metadata, targetBU, retrieveDir, isRefresh) {
+        const upsertResults = await this.upsert(metadata, targetBU, isRefresh);
         await this.saveResults(upsertResults, retrieveDir, null);
         return upsertResults;
     }
@@ -868,7 +867,7 @@ class Automation extends MetadataType {
                 row1.push(
                     `| ${column.title}${
                         column.description
-                            ? `<br>_<small>${column.description.replace(/\n/g, '<br>')}</small>_`
+                            ? `<br>_<small>${column.description.replaceAll('\n', '<br>')}</small>_`
                             : ''
                     } `
                 );
@@ -1000,6 +999,50 @@ class Automation extends MetadataType {
             return super.getFilesToCommit(keyArr);
         }
     }
+    /**
+     * helper to allow us to select single metadata entries via REST
+     *
+     * @private
+     * @param {string} key customer key
+     * @returns {Promise.<string>} objectId or enpty string
+     */
+    static async _getObjectIdForSingleRetrieve(key) {
+        const response = await this.client.soap.retrieve('Program', ['ObjectID'], {
+            filter: {
+                leftOperand: 'CustomerKey',
+                operator: 'equals',
+                rightOperand: key,
+            },
+        });
+        return response?.Results?.length ? response.Results[0].ObjectID : null;
+    }
+
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {string} customerKey Identifier of data extension
+     * @returns {boolean} deletion success status
+     */
+    static async deleteByKey(customerKey) {
+        // the delete endpoint returns a general exception if the automation does not exist; handle it gracefully instead by adding a retrieve first
+        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
+        if (!objectId) {
+            Util.logger.error(` - automation not found`);
+            return false;
+        }
+        return super.deleteByKeySOAP(customerKey, 'CustomerKey');
+    }
+    /**
+     * clean up after deleting a metadata item
+     *
+     * @param {string} customerKey Identifier of metadata item
+     * @returns {void}
+     */
+    static async postDeleteTasks(customerKey) {
+        // delete local copy: retrieve/cred/bu/.../...-meta.json
+        // delete local copy: retrieve/cred/bu/.../...-doc.md
+        await super.postDeleteTasks(customerKey, [`${this.definition.type}-doc.md`]);
+    }
 }
 
 // Assign definition to static attributes

package/lib/metadataTypes/Campaign.js

@@ -21,31 +21,44 @@ class Campaign extends MetadataType {
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
     static async retrieve(retrieveDir, _, __, key) {
-        const res = await super.retrieveREST(retrieveDir, '/hub/v1/campaigns', null, null, key);
+        const res = await super.retrieveREST(
+            retrieveDir,
+            '/legacy/v1/beta2/data/campaign/',
+            null,
+            key
+        );
         // get assignments
-
+        Util.logger.info(`Retrieving: campaignAsset`);
         const campaignAssets = await Promise.all(
             Object.keys(res.metadata).map((key) =>
-                this.getAssetTags(retrieveDir, res.metadata[key].id, key)
+                this.getAssetTags(retrieveDir, res.metadata[key].campaignId, key)
             )
         );
         Util.logger.info(
-            `Downloaded: campaignAssets (${campaignAssets.flat().length})` + Util.getKeysString(key)
+            `Downloaded: campaignAsset (${campaignAssets.flat().length})` + Util.getKeysString(key)
         );
 
         return res;
     }
+    /**
+     * Retrieves event definition metadata for caching
+     *
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
+     */
+    static retrieveForCache() {
+        return super.retrieveREST(null, '/legacy/v1/beta2/data/campaign/');
+    }
 
     /**
      * Parses campaign asset response body and returns metadata entries mapped to their id
      *
      * @param {string} retrieveDir folder where to save
-     * @param {string} id of camapaign to retrieve
+     * @param {string} campaignId of camapaign to retrieve
      * @param {string} name of camapaign for saving
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Campaign Asset Object
      */
-    static async getAssetTags(retrieveDir, id, name) {
-        const res = await this.client.rest.getBulk(`/hub/v1/campaigns/${id}/assets`);
+    static async getAssetTags(retrieveDir, campaignId, name) {
+        const res = await this.client.rest.getBulk(`/hub/v1/campaigns/${campaignId}/assets`);
 
         for (const asset of res.items) {
             await File.writeJSONToFile(

package/lib/metadataTypes/ContentArea.js

@@ -36,7 +36,7 @@ class ContentArea extends MetadataType {
             };
         }
         // !dont activate `await File.initPrettier('html');` as we only want to retrieve for migration and formatting might mess with the outcome
-        return super.retrieveSOAP(retrieveDir, requestParams);
+        return super.retrieveSOAP(retrieveDir, requestParams, key);
     }
     /**
      * manages post retrieve steps