mcdev 4.2.1 → 4.3.0

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 retrieving 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

package/lib/metadataTypes/DataExtension.js

@@ -21,16 +21,33 @@ class DataExtension extends MetadataType {
      * if create or update operation is needed.
      *
      * @param {TYPE.DataExtensionMap} desToDeploy dataExtensions mapped by their customerKey
-     * @param {void} _ unused parameter
-     * @param {TYPE.BuObject} buObject properties for auth
      * @returns {Promise} Promise
      */
-    static async upsert(desToDeploy, _, buObject) {
+    static async upsert(desToDeploy) {
         // get dataExtensions from target BU for add/update decision
         /** @type {TYPE.DataExtensionMap} */
         const targetMetadata = cache.getCache().dataExtension || {};
-        // get existing de-fields to properly handle add/update/delete of fields
-        await this._attachFields(targetMetadata);
+        // get existing DE-fields for DE-keys in deployment package to properly handle add/update/delete of fields
+        const fieldOptions = {};
+        for (const key of Object.keys(desToDeploy)) {
+            fieldOptions.filter = fieldOptions.filter
+                ? {
+                      leftOperand: {
+                          leftOperand: 'DataExtension.CustomerKey',
+                          operator: 'equals',
+                          rightOperand: key,
+                      },
+                      operator: 'OR',
+                      rightOperand: fieldOptions.filter,
+                  }
+                : {
+                      leftOperand: 'DataExtension.CustomerKey',
+                      operator: 'equals',
+                      rightOperand: key,
+                  };
+        }
+        Util.logger.info(` - Caching dependent Metadata: dataExtensionField`);
+        await this._attachFields(desToDeploy, fieldOptions);
 
         /** @type {Promise[]} */
         const deCreatePromises = [];
@@ -46,7 +63,7 @@ class DataExtension extends MetadataType {
                 continue;
             }
             if (
-                buObject.eid !== buObject.mid &&
+                this.buObject.eid !== this.buObject.mid &&
                 desToDeploy[dataExtension].r__folder_Path.startsWith('Shared Items')
             ) {
                 // this needs to be run before executing preDeployTasks()
@@ -304,12 +321,11 @@ class DataExtension extends MetadataType {
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
-     * @param {TYPE.BuObject} buObject properties for auth
      * @param {void} [_] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<{metadata: TYPE.DataExtensionMap, type: string}>} Promise of item map
      */
-    static async retrieve(retrieveDir, additionalFields, buObject, _, key) {
+    static async retrieve(retrieveDir, additionalFields, _, key) {
         /** @type {TYPE.SoapRequestParams} */
         let requestParams = null;
         /** @type {TYPE.SoapRequestParams} */
@@ -336,17 +352,17 @@ class DataExtension extends MetadataType {
             // get fields from API
             await this._attachFields(metadata, fieldOptions, additionalFields);
         }
-        if (!retrieveDir && buObject.eid !== buObject.mid) {
+        if (!retrieveDir && this.buObject.eid !== this.buObject.mid) {
             // for caching, we want to retrieve shared DEs as well from the instance parent BU
             Util.logger.info(
                 ' - Caching dependent Metadata: dataExtension (shared via _ParentBU_)'
             );
             /** @type {TYPE.BuObject} */
             const buObjectParentBu = {
-                eid: this.properties.credentials[buObject.credential].eid,
-                mid: this.properties.credentials[buObject.credential].eid,
+                eid: this.properties.credentials[this.buObject.credential].eid,
+                mid: this.properties.credentials[this.buObject.credential].eid,
                 businessUnit: Util.parentBuName,
-                credential: buObject.credential,
+                credential: this.buObject.credential,
             };
             try {
                 this.client = auth.getSDK(buObjectParentBu);
@@ -357,17 +373,16 @@ class DataExtension extends MetadataType {
             const metadataParentBu = await this._retrieveAll(additionalFields);
 
             // get shared folders to match our shared / synched Data Extensions
+            const subTypeArr = this.definition.dependencies
+                .filter((item) => item.startsWith('folder-'))
+                .map((item) => item.slice(7));
             Util.logger.info(' - Caching dependent Metadata: folder (shared via _ParentBU_)');
+            Util.logSubtypes(subTypeArr);
             Folder.client = this.client;
+            Folder.buObject = buObjectParentBu;
             Folder.properties = this.properties;
-            const result = await Folder.retrieveForCache(buObjectParentBu, [
-                'shared_data',
-                'synchronizeddataextension',
-                'salesforcedataextension',
-                'shared_dataextension',
-                'dataextension',
-            ]);
-            cache.mergeMetadata('folder', result.metadata, buObject.eid);
+            const result = await Folder.retrieveForCache(null, subTypeArr);
+            cache.mergeMetadata('folder', result.metadata, this.buObject.eid);
 
             // get the types and clean out non-shared ones
             const folderTypesFromParent = require('../MetadataTypeDefinitions').folder
@@ -380,7 +395,7 @@ class DataExtension extends MetadataType {
                         metadataParentBu[metadataEntry].CategoryID,
                         'ID',
                         'ContentType',
-                        buObject.eid
+                        this.buObject.eid
                     );
                     if (!folderTypesFromParent.includes(folderContentType)) {
                         Util.logger.verbose(
@@ -406,10 +421,11 @@ class DataExtension extends MetadataType {
         if (retrieveDir) {
             const savedMetadata = await super.saveResults(metadata, retrieveDir, 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(buObject, savedMetadata);
+                await this.document(savedMetadata);
             }
         }
         return { metadata: metadata, type: 'dataExtension' };
@@ -452,11 +468,10 @@ class DataExtension extends MetadataType {
     /**
      * Retrieves dataExtension metadata. Afterwards starts retrieval of dataExtensionColumn metadata retrieval
      *
-     * @param {TYPE.BuObject} [buObject] properties for auth
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @returns {Promise.<{metadata: TYPE.DataExtensionMap, type: string}>} Promise of item map
      */
-    static async retrieveChangelog(buObject, additionalFields) {
+    static async retrieveChangelog(additionalFields) {
         const metadata = await this._retrieveAll(additionalFields);
         return { metadata: metadata, type: 'dataExtension' };
     }
@@ -533,8 +548,7 @@ class DataExtension extends MetadataType {
      */
     static async preDeployTasks(metadata) {
         // folder
-        metadata.CategoryID = cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID');
-        delete metadata.r__folder_Path;
+        super.setFolderId(metadata);
 
         // DataExtensionTemplate
         if (metadata.r__dataExtensionTemplate_Name) {
@@ -741,18 +755,17 @@ class DataExtension extends MetadataType {
     /**
      * Parses metadata into a readable Markdown/HTML format then saves it
      *
-     * @param {TYPE.BuObject} buObject properties for auth
      * @param {TYPE.DataExtensionMap} [metadata] a list of dataExtension definitions
      * @returns {Promise.<void>} -
      */
-    static async document(buObject, metadata) {
+    static async document(metadata) {
         try {
             if (!metadata) {
                 metadata = this.readBUMetadataForType(
                     File.normalizePath([
                         this.properties.directories.retrieve,
-                        buObject.credential,
-                        buObject.businessUnit,
+                        this.buObject.credential,
+                        this.buObject.businessUnit,
                     ]),
                     true
                 ).dataExtension;
@@ -763,8 +776,8 @@ class DataExtension extends MetadataType {
         }
         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) {
@@ -821,27 +834,25 @@ class DataExtension extends MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of data extension
      * @returns {Promise.<boolean>} deletion success status
      */
-    static deleteByKey(buObject, customerKey) {
-        return super.deleteByKeySOAP(buObject, customerKey, false);
+    static deleteByKey(customerKey) {
+        return super.deleteByKeySOAP(customerKey, false);
     }
 
     /**
      * clean up after deleting a metadata item
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of metadata item
      * @returns {void}
      */
-    static async postDeleteTasks(buObject, customerKey) {
+    static async postDeleteTasks(customerKey) {
         // delete local copy: retrieve/cred/bu/dataExtension/...json
         const jsonFile = File.normalizePath([
             this.properties.directories.retrieve,
-            buObject.credential,
-            buObject.businessUnit,
+            this.buObject.credential,
+            this.buObject.businessUnit,
             this.definition.type,
             `${customerKey}.${this.definition.type}-meta.json`,
         ]);
@@ -850,8 +861,8 @@ class DataExtension extends MetadataType {
         const mdFile = File.normalizePath([
             this.properties.directories.docs,
             'dataExtension',
-            buObject.credential,
-            buObject.businessUnit,
+            this.buObject.credential,
+            this.buObject.businessUnit,
             `${customerKey}.${this.definition.type}.md`,
         ]);
         await File.remove(mdFile);
@@ -860,11 +871,10 @@ class DataExtension extends MetadataType {
     /**
      * Retrieves folder metadata into local filesystem. Also creates a uniquePath attribute for each folder.
      *
-     * @param {TYPE.BuObject} buObject properties for auth
      * @returns {Promise.<{metadata: TYPE.DataExtensionMap, type: string}>} Promise
      */
-    static async retrieveForCache(buObject) {
-        return this.retrieve(null, ['ObjectID', 'CustomerKey', 'Name'], buObject, null, null);
+    static async retrieveForCache() {
+        return this.retrieve(null, ['ObjectID', 'CustomerKey', 'Name'], this.buObject, null, null);
     }
     /**
      * Retrieves dataExtension metadata in template format.
@@ -978,7 +988,6 @@ class DataExtension extends MetadataType {
             }
         }
     }
-
     /**
      * parses retrieved Metadata before saving
      *
@@ -1028,7 +1037,7 @@ class DataExtension extends MetadataType {
      * @returns {Promise.<TYPE.DataExtensionMap>} keyField => metadata map
      */
     static async _retrieveAll(additionalFields, options) {
-        const { metadata } = await super.retrieveSOAP(null, null, options, additionalFields);
+        const { metadata } = await super.retrieveSOAP(null, options, additionalFields);
         for (const key in metadata) {
             // some system data extensions do not have CategoryID which throws errors in other places. These do not need to be parsed
             if (metadata[key].CategoryID) {

package/lib/metadataTypes/DataExtensionField.js

@@ -15,11 +15,10 @@ class DataExtensionField extends MetadataType {
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
-     * @param {TYPE.BuObject} buObject properties for auth
      * @returns {Promise.<{metadata: TYPE.DataExtensionFieldMap, type: string}>} Promise of items
      */
-    static async retrieve(retrieveDir, additionalFields, buObject) {
-        return super.retrieveSOAP(retrieveDir, buObject, null, additionalFields);
+    static async retrieve(retrieveDir, additionalFields) {
+        return super.retrieveSOAP(retrieveDir, null, additionalFields);
     }
     /**
      * Retrieves all records for caching
@@ -29,7 +28,7 @@ class DataExtensionField extends MetadataType {
      * @returns {Promise.<{metadata: TYPE.DataExtensionFieldMap, type: string}>} Promise of items
      */
     static async retrieveForCache(requestParams, additionalFields) {
-        return super.retrieveSOAP(null, null, requestParams, additionalFields);
+        return super.retrieveSOAP(null, requestParams, additionalFields);
     }
     /**
      * helper for {@link DataExtension._retrieveFieldsForSingleDe} that sorts the fields into an array
@@ -242,8 +241,8 @@ class DataExtensionField extends MetadataType {
             }
         }
 
-        Util.logger.debug(
-            `${deployColumns.length} Fields added/updated for [${deKey}]${
+        Util.logger.info(
+            ` - Found ${deployColumns.length} added/updated Fields for ${deKey}${
                 deployColumns.length ? ': ' : ''
             }` + deployColumns.map((item) => item.Name).join(', ')
         );
@@ -253,23 +252,21 @@ class DataExtensionField extends MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of data extension
      * @returns {Promise.<boolean>} deletion success status
      */
-    static deleteByKey(buObject, customerKey) {
-        return this.deleteByKeySOAP(buObject, customerKey, false);
+    static deleteByKey(customerKey) {
+        return this.deleteByKeySOAP(customerKey, false);
     }
 
     /**
      * Delete a data extension from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of metadata
      * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
      * @returns {boolean} deletion success flag
      */
-    static async deleteByKeySOAP(buObject, customerKey, handleOutside) {
+    static async deleteByKeySOAP(customerKey, handleOutside) {
         const [deKey, fieldKey] = customerKey.split('.');
         customerKey = `[${deKey}].[${fieldKey}]`;
 
@@ -309,7 +306,7 @@ class DataExtensionField extends MetadataType {
             if (!handleOutside) {
                 Util.logger.info(`- deleted ${this.definition.type}: ${customerKey}`);
             }
-            this.postDeleteTasks(buObject, customerKey);
+            this.postDeleteTasks(customerKey);
             return true;
         } catch (ex) {
             if (handleOutside) {

package/lib/metadataTypes/DataExtensionTemplate.js

@@ -15,11 +15,10 @@ class DataExtensionTemplate 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) {
         /** @type {TYPE.SoapRequestParams} */
         let requestParams = null;
         if (key) {
@@ -31,7 +30,7 @@ class DataExtensionTemplate extends MetadataType {
                 },
             };
         }
-        return super.retrieveSOAP(retrieveDir, null, requestParams);
+        return super.retrieveSOAP(retrieveDir, requestParams);
     }
 }
 

package/lib/metadataTypes/DataExtract.js

@@ -19,11 +19,10 @@ class DataExtract 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 async retrieve(retrieveDir, _, __, ___, key) {
+    static async retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(retrieveDir, '/automation/v1/dataextracts/', null, null, key);
     }
     /**

package/lib/metadataTypes/DataExtractType.js

@@ -17,11 +17,10 @@ class DataExtractType 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, '/automation/v1/dataextracttypes/', null, null, key);
     }
     /**

package/lib/metadataTypes/Discovery.js

@@ -16,16 +16,15 @@ class Discovery extends MetadataType {
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] not used
-     * @param {TYPE.BuObject} buObject properties for auth
-     * @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, _, buObject, ___, key) {
+    static async retrieve(retrieveDir, _, __, key) {
         if (key) {
             Util.logger.error('Discovery.retrieve() does not support key parameter');
         }
-        if (buObject.eid === buObject.mid) {
+        if (this.buObject.eid === this.buObject.mid) {
             const res = await this.client.rest.getCollection(
                 Object.keys(this.definition.endPointMapping).map(
                     (endpoint) => this.definition.endPointMapping[endpoint]