mcdev 4.2.1 → 4.3.1

package/lib/metadataTypes/Asset.js

@@ -19,34 +19,25 @@ class Asset extends MetadataType {
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} _ -
-     * @param {void} __ -
-     * @param {TYPE.AssetSubType} [selectedSubType] optionally limit to a single subtype
+     * @param {TYPE.AssetSubType[]} [subTypeArr] optionally limit to a single subtype
      * @param {string} [key] customer key
      * @returns {Promise.<{metadata: TYPE.AssetMap, type: string}>} Promise
      */
-    static async retrieve(retrieveDir, _, __, selectedSubType, key) {
+    static async retrieve(retrieveDir, _, subTypeArr, key) {
         const items = [];
-        const subTypes = selectedSubType ? [selectedSubType] : this._getSubTypes();
+        subTypeArr = 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 subTypes) {
+        for (const subType of subTypeArr) {
             // each subtype contains multiple different specific types (images contains jpg and png for example)
             // we use await here to limit the risk of too many concurrent api requests at time
-            items.push(
-                ...(await this.requestSubType(
-                    subType,
-                    this.definition.extendedSubTypes[subType],
-                    retrieveDir,
-                    null,
-                    null,
-                    key
-                ))
-            );
+            items.push(...(await this.requestSubType(subType, retrieveDir, null, null, key)));
         }
         const metadata = this.parseResponseBody({ items: items });
         if (retrieveDir) {
             Util.logger.info(
-                `Downloaded: ${this.definition.type} (${Object.keys(metadata).length})`
+                `Downloaded: ${this.definition.type} (${Object.keys(metadata).length})` +
+                    Util.getKeysString(key)
             );
         }
         return { metadata: metadata, type: this.definition.type };
@@ -55,12 +46,12 @@ class Asset extends MetadataType {
     /**
      * Retrieves asset metadata for caching
      *
-     * @param {void} _ -
-     * @param {string} [selectedSubType] optionally limit to a single subtype
+     * @param {void} _ unused
+     * @param {string[]} [subTypeArr] optionally limit to a single subtype
      * @returns {Promise.<{metadata: TYPE.AssetMap, type: string}>} Promise
      */
-    static retrieveForCache(_, selectedSubType) {
-        return this.retrieve(null, null, null, selectedSubType);
+    static retrieveForCache(_, subTypeArr) {
+        return this.retrieve(null, null, subTypeArr);
     }
 
     /**
@@ -81,13 +72,7 @@ class Asset extends MetadataType {
             // each subtype contains multiple different specific types (images contains jpg and png for example)
             // we use await here to limit the risk of too many concurrent api requests at time
             items.push(
-                ...(await this.requestSubType(
-                    subType,
-                    this.definition.extendedSubTypes[subType],
-                    templateDir,
-                    name,
-                    templateVariables
-                ))
+                ...(await this.requestSubType(subType, templateDir, name, templateVariables))
             );
         }
         const metadata = this.parseResponseBody({ items: items });
@@ -146,27 +131,21 @@ class Asset extends MetadataType {
      * Retrieves Metadata of a specific asset type
      *
      * @param {TYPE.AssetSubType} subType group of similar assets to put in a folder (ie. images)
-     * @param {TYPE.AssetSubType[]} subTypeArray list of all asset types within this subtype
      * @param {string} [retrieveDir] target directory for saving assets
      * @param {string} [templateName] name of the metadata file
      * @param {TYPE.TemplateMap} [templateVariables] variables to be replaced in the metadata
      * @param {string} key customer key to filter by
      * @returns {Promise} Promise
      */
-    static async requestSubType(
-        subType,
-        subTypeArray,
-        retrieveDir,
-        templateName,
-        templateVariables,
-        key
-    ) {
+    static async requestSubType(subType, retrieveDir, templateName, templateVariables, key) {
         if (retrieveDir) {
             Util.logger.info(`- Retrieving Subtype: ${subType}`);
         } else {
             Util.logger.info(` - Caching Subtype: ${subType}`);
         }
-        const subtypeIds = subTypeArray?.map(
+        /** @type {TYPE.AssetSubType[]} */
+        const extendedSubTypeArr = this.definition.extendedSubTypes[subType];
+        const subtypeIds = extendedSubTypeArr?.map(
             (subTypeItemName) => Asset.definition.typeMapping[subTypeItemName]
         );
         const uri = '/asset/v1/content/assets/query';
@@ -507,10 +486,9 @@ class Asset extends MetadataType {
      *
      * @param {TYPE.AssetItem} metadata a single asset
      * @param {string} deployDir directory of deploy files
-     * @param {TYPE.BuObject} buObject buObject properties for auth
      * @returns {Promise.<TYPE.AssetItem>} Promise
      */
-    static async preDeployTasks(metadata, deployDir, buObject) {
+    static async preDeployTasks(metadata, deployDir) {
         // additonalattributes fail where the value is "" so we need to remove them from deploy
         if (metadata?.data?.email?.attributes?.length > 0) {
             metadata.data.email.attributes = metadata.data.email.attributes.filter(
@@ -519,10 +497,7 @@ class Asset extends MetadataType {
         }
 
         // folder
-        metadata.category = {
-            id: cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID'),
-        };
-        delete metadata.r__folder_Path;
+        this.setFolderId(metadata);
 
         // restore asset type id which is needed for deploy
         metadata.assetType.id = this.definition.typeMapping[metadata.assetType.name];
@@ -538,13 +513,13 @@ class Asset extends MetadataType {
 
         // only execute #3 if we are deploying / copying from one BU to another, not while using mcdev as a developer tool
         if (
-            buObject.mid &&
-            metadata.memberId !== buObject.mid &&
-            !metadata[this.definition.keyField].endsWith(buObject.mid)
+            this.buObject.mid &&
+            metadata.memberId !== this.buObject.mid &&
+            !metadata[this.definition.keyField].endsWith(this.buObject.mid)
         ) {
             // #3 make sure customer key is unique by suffixing it with target MID (unless we are deploying to the same MID)
             // check if this suffixed with the source MID
-            const suffix = '-' + buObject.mid;
+            const suffix = '-' + this.buObject.mid;
             // for customer key max is 36 chars
             metadata[this.definition.keyField] =
                 metadata[this.definition.keyField].slice(0, Math.max(0, 36 - suffix.length)) +
@@ -610,7 +585,7 @@ class Asset extends MetadataType {
      *
      * @private
      * @param {TYPE.AssetItem} metadata a single asset
-     * @returns {TYPE.AssetSubType} subtype
+     * @returns {TYPE.AssetSubType | void} subtype
      */
     static _getSubtype(metadata) {
         for (const sub in this.definition.extendedSubTypes) {
@@ -790,6 +765,17 @@ class Asset extends MetadataType {
             );
         }
     }
+    /**
+     * Asset-specific script that retrieves the folder ID from cache and updates the given metadata with it before deploy
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single item
+     */
+    static setFolderId(metadata) {
+        metadata.category = {
+            id: cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID'),
+        };
+        delete metadata.r__folder_Path;
+    }
 
     /**
      * helper for {@link preDeployTasks} that loads extracted code content back into JSON
@@ -970,6 +956,7 @@ class Asset extends MetadataType {
 
                 break;
             }
+            case 'template': // template-template
             case 'buttonblock': // block - Button Block
             case 'freeformblock': // block
             case 'htmlblock': // block
@@ -1191,6 +1178,7 @@ class Asset extends MetadataType {
                     subFolder: [customerKey],
                 };
             }
+            case 'template': // template-template
             case 'buttonblock': // block - Button Block
             case 'freeformblock': // block
             case 'htmlblock': // block

package/lib/metadataTypes/AttributeGroup.js

@@ -15,11 +15,10 @@ class AttributeGroup extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static retrieve(retrieveDir, _, __, ___, key) {
+    static retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(
             retrieveDir,
             '/hub/v1/contacts/schema/attributeGroups',

package/lib/metadataTypes/Automation.js

@@ -19,11 +19,10 @@ class Automation extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.AutomationMapObj>} Promise of metadata
      */
-    static async retrieve(retrieveDir, _, __, ___, key) {
+    static async retrieve(retrieveDir, _, __, key) {
         /** @type {TYPE.SoapRequestParams} */
         let requestParams = null;
         if (key) {
@@ -36,12 +35,39 @@ class Automation extends MetadataType {
             };
         }
         const results = await this.client.soap.retrieveBulk('Program', ['ObjectID'], requestParams);
-
+        if (results.Results?.length) {
+            // empty results will come back without "Results" defined
+            Util.logger.info(
+                Util.getGrayMsg(
+                    ` - ${results.Results?.length} Automations found. Retrieving details...`
+                )
+            );
+        }
         const details = results.Results
             ? await Promise.all(
-                  results.Results.map((a) =>
-                      this.client.rest.get('/automation/v1/automations/' + a.ObjectID)
-                  )
+                  results.Results.map(async (a) => {
+                      try {
+                          return await this.client.rest.get(
+                              '/automation/v1/automations/' + a.ObjectID
+                          );
+                      } catch (ex) {
+                          try {
+                              if (ex.message == 'socket hang up') {
+                                  // one more retry; it's a rare case but retrying again should solve the issue gracefully
+                                  return await this.client.rest.get(
+                                      '/automation/v1/automations/' + a.ObjectID
+                                  );
+                              }
+                          } 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 Automation ${a.ObjectID}: ${ex.message} ${ex.code}`
+                          );
+                          return null;
+                      }
+                  })
               )
             : [];
         const parsed = this.parseResponseBody({ items: details });
@@ -49,10 +75,11 @@ class Automation extends MetadataType {
         // * retrieveDir is mandatory in this method as it is not used for caching (there is a seperate method for that)
         const savedMetadata = await this.saveResults(parsed, retrieveDir, null, null);
         Util.logger.info(
-            `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
+            `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
+                Util.getKeysString(key)
         );
         if (this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)) {
-            await this.document(this.buObject, savedMetadata);
+            await this.document(savedMetadata);
         }
         return { metadata: savedMetadata, type: this.definition.type };
     }
@@ -245,28 +272,9 @@ class Automation extends MetadataType {
      */
     static async preDeployTasks(metadata) {
         if (this.validateDeployMetadata(metadata)) {
-            try {
-                metadata.categoryId = cache.searchForField(
-                    'folder',
-                    metadata.r__folder_Path,
-                    'Path',
-                    'ID'
-                );
-                if (metadata.r__folder_Path !== 'my automations') {
-                    Util.logger.warn(
-                        ` - Automation '${
-                            metadata[this.definition.nameField]
-                        }' is located in subfolder ${
-                            metadata.r__folder_Path
-                        }. Please note that creating automation folders is not supported via API and hence you will have to create it manually in the GUI if you choose to deploy this automation.`
-                    );
-                }
-                delete metadata.r__folder_Path;
-            } catch {
-                throw new Error(
-                    `Folder '${metadata.r__folder_Path}' was not found on the server. Please create this manually in the GUI. Automation-folders cannot be deployed automatically.`
-                );
-            }
+            // folder
+            this.setFolderId(metadata);
+
             if (metadata.type === 'scheduled' && metadata?.schedule?.startDate) {
                 // Starting Source == 'Schedule'
 
@@ -493,13 +501,44 @@ class Automation extends MetadataType {
         }
     }
 
+    /**
+     * automation-specific script that retrieves the folder ID from cache and updates the given metadata with it before deploy
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single item
+     */
+    static setFolderId(metadata) {
+        try {
+            metadata.categoryId = cache.searchForField(
+                'folder',
+                metadata.r__folder_Path,
+                'Path',
+                'ID'
+            );
+            if (metadata.r__folder_Path !== 'my automations') {
+                Util.logger.warn(
+                    ` - Automation '${
+                        metadata[this.definition.nameField]
+                    }' is located in subfolder ${
+                        metadata.r__folder_Path
+                    }. Please note that creating automation folders is not supported via API and hence you will have to create it manually in the GUI if you choose to deploy this automation.`
+                );
+            }
+            delete metadata.r__folder_Path;
+        } catch {
+            throw new Error(
+                `Folder '${metadata.r__folder_Path}' was not found on the server. Please create this manually in the GUI. Automation-folders cannot be deployed automatically.`
+            );
+        }
+    }
+
     /**
      * parses retrieved Metadata before saving
      *
      * @param {TYPE.AutomationItem} metadata a single automation definition
-     * @returns {TYPE.AutomationItem} parsed item
+     * @returns {TYPE.AutomationItem | void} parsed item
      */
     static parseMetadata(metadata) {
+        // folder
         this.setFolderPath(metadata);
         // automations are often skipped due to lack of support.
         try {
@@ -895,26 +934,25 @@ class Automation extends MetadataType {
     /**
      * Parses metadata into a readable Markdown/HTML format then saves it
      *
-     * @param {TYPE.BuObject} buObject properties for auth
      * @param {TYPE.AutomationMap} [metadata] a list of dataExtension definitions
      * @returns {Promise.<void>} -
      */
-    static async document(buObject, metadata) {
+    static async document(metadata) {
         if (['md', 'both'].includes(this.properties.options.documentType)) {
             if (!metadata) {
                 metadata = this.readBUMetadataForType(
                     File.normalizePath([
                         this.properties.directories.retrieve,
-                        buObject.credential,
-                        buObject.businessUnit,
+                        this.buObject.credential,
+                        this.buObject.businessUnit,
                     ]),
                     true
                 ).automation;
             }
             const docPath = File.normalizePath([
                 this.properties.directories.retrieve,
-                buObject.credential,
-                buObject.businessUnit,
+                this.buObject.credential,
+                this.buObject.businessUnit,
                 this.definition.type,
             ]);
             if (!metadata || !Object.keys(metadata).length) {

package/lib/metadataTypes/Campaign.js

@@ -17,11 +17,10 @@ class Campaign extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
-    static async retrieve(retrieveDir, _, __, ___, key) {
+    static async retrieve(retrieveDir, _, __, key) {
         const res = await super.retrieveREST(retrieveDir, '/hub/v1/campaigns', null, null, key);
         // get assignments
 
@@ -30,7 +29,9 @@ class Campaign extends MetadataType {
                 this.getAssetTags(retrieveDir, res.metadata[key].id, key)
             )
         );
-        Util.logger.info(`Downloaded: campaignAssets (${campaignAssets.flat().length})`);
+        Util.logger.info(
+            `Downloaded: campaignAssets (${campaignAssets.flat().length})` + Util.getKeysString(key)
+        );
 
         return res;
     }

package/lib/metadataTypes/ContentArea.js

@@ -17,11 +17,10 @@ class ContentArea extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static retrieve(retrieveDir, _, __, ___, key) {
+    static retrieve(retrieveDir, _, __, key) {
         Util.logger.warn(
             ' - Classic Content Areas are deprecated and will be discontinued by SFMC in the near future. Ensure that you migrate any existing Content Areas to Content Builder as soon as possible.'
         );
@@ -37,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, null, requestParams);
+        return super.retrieveSOAP(retrieveDir, requestParams);
     }
     /**
      * manages post retrieve steps