mcdev 4.3.4 → 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) {
@@ -496,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
      *

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