mcdev 4.2.1 → 4.3.1

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]

package/lib/metadataTypes/Email.js

@@ -16,14 +16,10 @@ class Email 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) {
-        Util.logger.warn(
-            ' - Classic E-Mails are deprecated and will be discontinued by SFMC in the near future. Ensure that you migrate any existing E-Mails to Content Builder as soon as possible.'
-        );
+    static retrieve(retrieveDir, _, __, key) {
         /** @type {TYPE.SoapRequestParams} */
         let requestParams = null;
         if (key) {
@@ -36,7 +32,25 @@ class Email 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);
+    }
+    /**
+     * Helper for writing Metadata to disk, used for Retrieve and deploy
+     *
+     * @param {TYPE.MetadataTypeMap} results metadata results from deploy
+     * @param {string} retrieveDir directory where metadata should be stored after deploy/retrieve
+     * @param {string} [overrideType] for use when there is a subtype (such as folder-queries)
+     * @param {TYPE.TemplateMap} [templateVariables] variables to be replaced in the metadata
+     * @returns {Promise.<TYPE.MetadataTypeMap>} Promise of saved metadata
+     */
+    static async saveResults(results, retrieveDir, overrideType, templateVariables) {
+        if (Object.keys(results).length) {
+            // only execute the following if records were found
+            Util.logger.warn(
+                ' - Classic E-Mails are deprecated and will be discontinued by SFMC in the near future. Ensure that you migrate any existing E-Mails to Content Builder as soon as possible.'
+            );
+        }
+        return super.saveResults(results, retrieveDir, overrideType, templateVariables);
     }
     /**
      * manages post retrieve steps

package/lib/metadataTypes/EmailSendDefinition.js

@@ -17,11 +17,10 @@ class EmailSendDefinition 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 = {
             filter: {
@@ -53,7 +52,7 @@ class EmailSendDefinition extends MetadataType {
                 },
             };
         }
-        return super.retrieveSOAP(retrieveDir, null, requestParams);
+        return super.retrieveSOAP(retrieveDir, requestParams);
     }
 
     /**
@@ -79,12 +78,11 @@ class EmailSendDefinition 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);
     }
 
     /**
@@ -97,8 +95,7 @@ class EmailSendDefinition extends MetadataType {
         // re-add IsPlatformObject, required for visibility
         metadata.IsPlatformObject = false;
         // folder
-        metadata.CategoryID = cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID');
-        delete metadata.r__folder_Path;
+        super.setFolderId(metadata);
         // email
         metadata.Email = {};
         if (metadata.r__email_Name) {
@@ -185,33 +182,35 @@ class EmailSendDefinition extends MetadataType {
         super.setFolderPath(metadata);
 
         // email
-        try {
-            // classic
-            const classicEmail = cache.searchForField('email', metadata.Email.ID, 'ID', 'Name');
-            metadata.r__email_Name = classicEmail;
-            delete metadata.Email;
-        } catch {
+        if (metadata.Email?.ID) {
             try {
-                // content builder
-                const contentBuilderEmailName = cache.searchForField(
-                    'asset',
-                    metadata.Email.ID,
-                    'legacyData.legacyId',
-                    'name'
-                );
-                metadata.r__assetMessage_Name = contentBuilderEmailName;
-                const contentBuilderEmailKey = cache.searchForField(
-                    'asset',
-                    metadata.Email.ID,
-                    'legacyData.legacyId',
-                    'customerKey'
-                );
-                metadata.r__assetMessage_Key = contentBuilderEmailKey;
+                // classic
+                const classicEmail = cache.searchForField('email', metadata.Email.ID, 'ID', 'Name');
+                metadata.r__email_Name = classicEmail;
                 delete metadata.Email;
             } catch {
-                Util.logger.warn(
-                    ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find email with ID ${metadata.Email.ID} in Classic nor in Content Builder.`
-                );
+                try {
+                    // content builder
+                    const contentBuilderEmailName = cache.searchForField(
+                        'asset',
+                        metadata.Email.ID,
+                        'legacyData.legacyId',
+                        'name'
+                    );
+                    metadata.r__assetMessage_Name = contentBuilderEmailName;
+                    const contentBuilderEmailKey = cache.searchForField(
+                        'asset',
+                        metadata.Email.ID,
+                        'legacyData.legacyId',
+                        'customerKey'
+                    );
+                    metadata.r__assetMessage_Key = contentBuilderEmailKey;
+                    delete metadata.Email;
+                } catch {
+                    Util.logger.warn(
+                        ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find email with ID ${metadata.Email.ID} in Classic nor in Content Builder.`
+                    );
+                }
             }
         }
         // Target Audience DataExtension
@@ -240,13 +239,15 @@ class EmailSendDefinition extends MetadataType {
                 }
             }
             // List
-            try {
-                sdl.r__list_PathName = cache.getListPathName(sdl.List.ID, 'ID');
-                delete sdl.List;
-            } catch (ex) {
-                Util.logger.warn(
-                    ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
-                );
+            if (sdl.List?.ID) {
+                try {
+                    sdl.r__list_PathName = cache.getListPathName(sdl.List.ID, 'ID');
+                    delete sdl.List;
+                } catch (ex) {
+                    Util.logger.warn(
+                        ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
+                    );
+                }
             }
         }
 

package/lib/metadataTypes/EventDefinition.js

@@ -20,11 +20,11 @@ class EventDefinition 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.logBeta(this.definition.type);
         return super.retrieveREST(
             retrieveDir,
             `/interaction/v1/EventDefinitions${
@@ -54,6 +54,7 @@ class EventDefinition extends MetadataType {
      * @returns {Promise.<TYPE.MetadataTypeItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logBeta(this.definition.type);
         const res = await this.client.rest.get(
             '/interaction/v1/EventDefinitions?name=' + encodeURIComponent(name)
         );
@@ -116,6 +117,32 @@ class EventDefinition extends MetadataType {
         this.keepRetrieveFields(val);
         return val;
     }
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {string} key Identifier of item
+     * @returns {Promise.<boolean>} deletion success status
+     */
+    static deleteByKey(key) {
+        Util.logBeta(this.definition.type);
+        return super.deleteByKeyREST(
+            '/interaction/v1/eventDefinitions/key:' + encodeURIComponent(key),
+            key,
+            false
+        );
+    }
+    /**
+     * Deploys metadata - merely kept here to be able to print {@link Util.logBeta} once per deploy
+     *
+     * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
+     * @param {string} deployDir directory where deploy metadata are saved
+     * @param {string} retrieveDir directory where metadata after deploy should be saved
+     * @returns {Promise.<TYPE.MetadataTypeMap>} Promise of keyField => metadata map
+     */
+    static async deploy(metadata, deployDir, retrieveDir) {
+        Util.logBeta(this.definition.type);
+        return super.deploy(metadata, deployDir, retrieveDir);
+    }
 
     /**
      * Creates a single Event Definition

package/lib/metadataTypes/FileTransfer.js

@@ -19,11 +19,10 @@ class FileTransfer 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) {
         return super.retrieveREST(retrieveDir, '/automation/v1/filetransfers/', null, null, key);
     }
     /**

package/lib/metadataTypes/Filter.js

@@ -18,11 +18,10 @@ class Filter 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) {
         return super.retrieveREST(retrieveDir, '/automation/v1/filters/', null, null, key);
     }
 }