mcdev 9.0.2 → 10.0.0

package/lib/metadataTypes/DataExtension.js

@@ -1,6 +1,6 @@
 'use strict';
 
-import jsonToTable from 'json-to-table';
+import jsonToTable from '../util/jsonToTable.js';
 import MetadataType from './MetadataType.js';
 import AttributeSet from './AttributeSet.js';
 import DataExtensionField from './DataExtensionField.js';
@@ -19,6 +19,7 @@ import { checkbox } from '@inquirer/prompts';
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
  * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ * @typedef {import('../../types/mcdev.d.js').TypeKeyCombo} TypeKeyCombo
  */
 
 /**
@@ -176,6 +177,7 @@ class DataExtension extends MetadataType {
             // Modify columns for update call
             DataExtensionField.client = this.client;
             DataExtensionField.properties = this.properties;
+            DataExtensionField.buObject = this.buObject;
             DataExtension.oldFields ||= {};
             DataExtension.oldFields[metadataMap[metadataKey][this.definition.keyField]] =
                 await DataExtensionField.prepareDeployColumnsOnUpdate(
@@ -269,15 +271,16 @@ class DataExtension extends MetadataType {
      */
     static #cleanupRetentionPolicyFields(metadata) {
         if (
-            metadata.DataRetentionPeriodLength &&
-            metadata.DataRetentionPeriodUnitOfMeasure &&
-            metadata.RetainUntil !== ''
+            !(metadata.DataRetentionPeriodLength && metadata.DataRetentionPeriodUnitOfMeasure) ||
+            metadata.RetainUntil === ''
         ) {
-            metadata.RetainUntil = '';
-            Util.logger.warn(
-                ` - RetainUntil date was reset automatically because RetentionPeriod info was found in: ${metadata.CustomerKey}`
-            );
+            return;
         }
+
+        metadata.RetainUntil = '';
+        Util.logger.warn(
+            ` - RetainUntil date was reset automatically because RetentionPeriod info was found in: ${metadata.CustomerKey}`
+        );
     }
 
     /**
@@ -1012,7 +1015,7 @@ class DataExtension extends MetadataType {
      */
     static async _retrieveFields(options, additionalFields) {
         if (!options) {
-            // dont print this during updates or templating which retrieves fields DE-by-DE
+            // don't print this during filtered field retrieval, such as updates
             Util.logger.info(' - Caching dependent Metadata: dataExtensionField');
         }
         DataExtensionField.client = this.client;
@@ -1022,38 +1025,6 @@ class DataExtension extends MetadataType {
         return response.metadata;
     }
 
-    /**
-     * helps retrieving fields during templating and deploy where we dont want the full list
-     *
-     * @private
-     * @param {DataExtensionMap} metadata list of DEs
-     * @param {string} customerKey external key of single DE
-     * @returns {Promise.<void>} -
-     */
-    static async _retrieveFieldsForSingleDe(metadata, customerKey) {
-        /** @type {SoapRequestParams} */
-        const fieldOptions = {
-            filter: {
-                leftOperand: 'DataExtension.CustomerKey',
-                operator: 'equals',
-                rightOperand: customerKey,
-            },
-        };
-        const fieldsObj = await this._retrieveFields(fieldOptions);
-
-        DataExtensionField.client = this.client;
-        DataExtensionField.properties = this.properties;
-        const fieldArr = DataExtensionField.convertToSortedArray(fieldsObj);
-
-        // remove attributes that we do not want to retrieve
-        // * do this after sorting on the DE's field list
-        for (const field of fieldArr) {
-            DataExtensionField.postRetrieveTasksDE(field);
-        }
-
-        metadata[customerKey].Fields = fieldArr;
-    }
-
     /**
      * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP} that removes old files after the key was changed
      *
@@ -1357,7 +1328,7 @@ class DataExtension extends MetadataType {
                     if (field === 'MaxLength' && element.FieldType === 'Decimal') {
                         newJsonElement.MaxLength = `${element.MaxLength},${element.Scale}`;
                     } else {
-                        newJsonElement[field] = element[field];
+                        newJsonElement[field] = element[field] ?? '';
                     }
                 }
                 // @ts-ignore for document the fields have less values and that leads to an error here.
@@ -1384,7 +1355,7 @@ class DataExtension extends MetadataType {
      * Parses metadata into a readable Markdown/HTML format then saves it
      *
      * @param {DataExtensionMap} [metadataMap] a list of dataExtension definitions
-     * @returns {Promise.<any>} -
+     * @returns {Promise.<void[]|void>} documentation writes or no result when no metadata exists
      */
     static async document(metadataMap) {
         try {
@@ -1428,40 +1399,30 @@ class DataExtension extends MetadataType {
 
         return Promise.all(
             Object.keys(metadataMap).map((key) => {
-                if (metadataMap[key]?.Fields?.length) {
-                    for (const field of metadataMap[key].Fields) {
-                        field.IsNullable = !Util.isTrue(field.IsRequired);
-                        for (const prop of columnsToIterateThrough) {
-                            if (Util.isTrue(field[prop])) {
-                                field[prop] = '+';
-                            } else if (Util.isFalse(field[prop])) {
-                                field[prop] = '-';
-                            }
+                if (!metadataMap[key]?.Fields?.length) {
+                    return;
+                }
+
+                for (const field of metadataMap[key].Fields) {
+                    field.IsNullable = !Util.isTrue(field.IsRequired);
+                    for (const prop of columnsToIterateThrough) {
+                        if (Util.isTrue(field[prop])) {
+                            field[prop] = '+';
+                        } else if (Util.isFalse(field[prop])) {
+                            field[prop] = '-';
                         }
                     }
+                }
 
-                    if (['html', 'both'].includes(this.properties.options.documentType)) {
-                        return docLimit(() =>
-                            this._writeDoc(
-                                docPath + '/',
-                                key,
-                                metadataMap[key],
-                                'html',
-                                columnsToPrint
-                            )
-                        );
-                    }
-                    if (['md', 'both'].includes(this.properties.options.documentType)) {
-                        return docLimit(() =>
-                            this._writeDoc(
-                                docPath + '/',
-                                key,
-                                metadataMap[key],
-                                'md',
-                                columnsToPrint
-                            )
-                        );
-                    }
+                if (['html', 'both'].includes(this.properties.options.documentType)) {
+                    return docLimit(() =>
+                        this._writeDoc(docPath + '/', key, metadataMap[key], 'html', columnsToPrint)
+                    );
+                }
+                if (['md', 'both'].includes(this.properties.options.documentType)) {
+                    return docLimit(() =>
+                        this._writeDoc(docPath + '/', key, metadataMap[key], 'md', columnsToPrint)
+                    );
                 }
             })
         );
@@ -1498,64 +1459,6 @@ class DataExtension extends MetadataType {
         return this.retrieve(null, ['ObjectID', 'CustomerKey', 'Name']);
     }
 
-    /**
-     * Retrieves dataExtension metadata in template format.
-     *
-     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
-     * @param {string} templateDir Directory where retrieved metadata directory will be saved
-     * @param {string} name name of the metadata item
-     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
-     * @returns {Promise.<{metadata: DataExtensionItem, type: string}>} Promise of items
-     */
-    static async retrieveAsTemplate(templateDir, name, templateVariables) {
-        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
-        /** @type {SoapRequestParams} */
-        const options = {
-            filter: {
-                leftOperand: 'Name',
-                operator: 'equals',
-                rightOperand: name,
-            },
-        };
-
-        const metadata = await this._retrieveAll(null, options);
-
-        if (!Object.keys(metadata).length) {
-            Util.logger.error(`${this.definition.type} '${name}' not found on server.`);
-            Util.logger.info('Downloaded: dataExtension (0)');
-            return { metadata: null, type: 'dataExtension' };
-        }
-        const customerKey = Object.keys(metadata)[0];
-        await this._retrieveFieldsForSingleDe(metadata, customerKey);
-
-        for (const key in metadata) {
-            try {
-                // API returns field unsorted
-                metadata[key].Fields.sort((a, b) => a.Ordinal - b.Ordinal);
-
-                const originalKey = key;
-                const metadataCleaned = structuredClone(
-                    await this.postRetrieveTasks(metadata[key])
-                );
-
-                this.keepTemplateFields(metadataCleaned);
-                const metadataTemplated = JSON.parse(
-                    Util.replaceByObject(JSON.stringify(metadataCleaned), templateVariables)
-                );
-                await File.writeJSONToFile(
-                    [templateDir, this.definition.type].join('/'),
-                    originalKey + '.' + this.definition.type + '-meta',
-                    metadataTemplated
-                );
-            } catch (ex) {
-                Util.metadataLogger('error', this.definition.type, 'retrieve', ex, key);
-            }
-        }
-        Util.logger.info(`- templated ${this.definition.type}: ${customerKey}`);
-
-        return { metadata: metadata[customerKey], type: 'dataExtension' };
-    }
-
     /**
      * dataExtension logic that retrieves the folder path from cache and updates the given metadata with it after retrieve
      * it also sets the content type which is basically the subtype
@@ -1663,6 +1566,63 @@ class DataExtension extends MetadataType {
             return super.getFilesToCommit(keyArr);
         }
     }
+    /**
+     * Hook called when dependency keys were not found in the child BU retrieve folder.
+     * Checks the `_ParentBU_` folder for shared or synchronized dataExtensions and emits
+     * readable warnings. Does NOT add the found items to the deployment package.
+     * Only active when running on a child BU (eid !== mid).
+     * Used by {@link MetadataType.getDependentFiles}.
+     *
+     * @param {string[]} notFound keys that were not found in the child BU retrieve folder
+     * @returns {Promise.<string[]>} keys that should still trigger the default "not found" warning
+     */
+    static async handleNotFoundDependencies(notFound) {
+        // on parent BU, shared DE check is not applicable
+        if (this.buObject.eid === this.buObject.mid) {
+            return notFound;
+        }
+        const parentBUPath = File.normalizePath([
+            this.properties.directories.retrieve,
+            this.buObject.credential,
+            Util.parentBuName,
+            this.definition.type,
+        ]);
+        const stillNotFound = [];
+        for (const key of notFound) {
+            const filePath = File.normalizePath([
+                parentBUPath,
+                File.filterIllegalFilenames(key) + '.' + this.definition.type + '-meta.json',
+            ]);
+            let metadataItem;
+            try {
+                metadataItem = await File.readJson(filePath);
+            } catch {
+                stillNotFound.push(key);
+                continue;
+            }
+            const contentType = metadataItem.r__folder_ContentType;
+            if (contentType === 'shared_dataextension') {
+                Util.logger.warn(
+                    `dataExtension '${key}' is a shared dataExtension stored in _ParentBU_. It cannot be included in the child BU deployment package.`
+                );
+                Util.logger.warn(
+                    `References to it may need to be changed during deployment via mcdev templating or manually. To update the shared dataExtension itself, run build for the parent BU and deploy it separately.`
+                );
+            } else if (contentType === 'synchronizeddataextension') {
+                Util.logger.warn(
+                    `dataExtension '${key}' is a synchronized dataExtension stored in _ParentBU_. It cannot be included in the child BU deployment package.`
+                );
+                Util.logger.warn(
+                    `The reference to it likely needs to be changed during deployment via mcdev templating or manually.`
+                );
+            } else {
+                // regular dataExtension found on parent BU cannot be used from a child BU; treat as not found
+                stillNotFound.push(key);
+            }
+        }
+        return stillNotFound;
+    }
+
     /**
      * helper for {@link MetadataType.createOrUpdate}
      *

package/lib/metadataTypes/DataExtensionField.js

@@ -4,6 +4,7 @@ import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
 import DataExtension from './DataExtension.js';
 import { confirm } from '@inquirer/prompts';
+import auth from '../util/auth.js';
 
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
@@ -75,6 +76,95 @@ class DataExtensionField extends MetadataType {
         }, {});
     }
 
+    /**
+     * determines if a dataExtension is shared (from parent BU) by checking its folder's ContentType in the parent BU folder cache
+     *
+     * @param {string} customerKey external key of single DE
+     * @returns {boolean} true if the DE is shared (stored on parent BU)
+     */
+    static isSharedDe(customerKey) {
+        if (this.buObject.eid === this.buObject.mid) {
+            // already on parent BU, no shared DEs possible
+            return false;
+        }
+        const categoryId = cache.getCache().dataExtension?.[customerKey]?.CategoryID;
+        if (!categoryId) {
+            return false;
+        }
+        try {
+            const contentType = cache.searchForField(
+                'folder',
+                categoryId,
+                'ID',
+                'ContentType',
+                this.buObject.eid
+            );
+            return MetadataTypeDefinitions.folder.folderTypesFromParent.includes(contentType);
+        } catch {
+            // folder not found in parent BU cache → local DE
+            return false;
+        }
+    }
+
+    /**
+     * helps retrieving fields for a single DE from parent BU.
+     * Use when the DE is shared (stored on parent BU) and its fields are not in the current BU's cache.
+     *
+     * @param {string} customerKey external key of single DE
+     * @returns {Promise.<object>} Promise of items
+     */
+    static async retrieveFieldsForSingleSharedDe(customerKey) {
+        if (this.buObject.eid === this.buObject.mid) {
+            // already on parent BU, shared retrieval is not needed - all DEs are local here
+            Util.logger.debug(
+                `DataExtensionField.retrieveFieldsForSingleSharedDe: already on parent BU, skipping for ${customerKey}`
+            );
+            return {};
+        }
+        if (!this.properties.credentials[this.buObject.credential]) {
+            Util.logger.error(
+                `DataExtensionField.retrieveFieldsForSingleSharedDe: credential '${this.buObject.credential}' not found in properties`
+            );
+            return {};
+        }
+        const buObjectBak = this.buObject;
+        const clientBak = this.client;
+        /** @type {BuObject} */
+        const buObjectParentBu = {
+            eid: this.properties.credentials[this.buObject.credential].eid,
+            mid: this.properties.credentials[this.buObject.credential].eid,
+            businessUnit: Util.parentBuName,
+            credential: this.buObject.credential,
+        };
+        try {
+            this.buObject = buObjectParentBu;
+            this.client = auth.getSDK(buObjectParentBu);
+        } catch (ex) {
+            Util.logger.error(ex.message);
+            this.buObject = buObjectBak;
+            this.client = clientBak;
+            return {};
+        }
+        const fields = await this.retrieveFieldsForSingleDe(customerKey);
+        // revert client to current default
+        this.buObject = buObjectBak;
+        this.client = clientBak;
+        return fields;
+    }
+
+    /**
+     * Routes field retrieval to the correct method depending on whether the DE is local or shared.
+     * Use this instead of duplicating the isSharedDe() check at each call site.
+     *
+     * @param {string} customerKey external key of single DE
+     * @returns {Promise.<object>} Promise of items
+     */
+    static async retrieveFieldsForSingleDeAuto(customerKey) {
+        return this.isSharedDe(customerKey)
+            ? this.retrieveFieldsForSingleSharedDe(customerKey)
+            : this.retrieveFieldsForSingleDe(customerKey);
+    }
+
     /**
      * Retrieves all records for caching
      *
@@ -187,6 +277,10 @@ class DataExtensionField extends MetadataType {
             // make sure we stringify the name in case it looked numeric and then lowercase it for easy comparison as the server is comparing field names case-insensitive
             existingFieldByName[(fieldsObj[key].Name + '').toLowerCase()] = fieldsObj[key];
         }
+        // capture field names from deploy payload before the loop modifies them (for renamed fields, the original name is used)
+        const deployColumnNames = new Set(
+            deployColumns.map((item) => (item.Name + '').toLowerCase())
+        );
         for (let i = deployColumns.length - 1; i >= 0; i--) {
             const item = deployColumns[i];
             // make sure we stringify the name in case it looked numeric and then lowercase it for easy comparison as the server is comparing field names case-insensitive
@@ -304,6 +398,26 @@ class DataExtensionField extends MetadataType {
             )
         );
 
+        // warn about fields that exist on the server but are not in the deploy payload
+        // these fields are NOT auto-deleted to prevent unintended data loss
+        const removedFieldNames = Object.values(existingFieldByName)
+            .filter((field) => !deployColumnNames.has((field.Name + '').toLowerCase()))
+            .map((field) => field.Name)
+            .toSorted();
+        if (removedFieldNames.length > 0) {
+            Util.logger.warn(
+                ` - dataExtension ${deKey}: found ${removedFieldNames.length} field${removedFieldNames.length > 1 ? 's' : ''} on the server but not in the deploy payload. Fields cannot be auto-deleted due to potential data loss. To delete them, please run:`
+            );
+            Util.logger.info(
+                Util.getGrayMsg(
+                    `mcdev delete ${this.buObject.credential}/${this.buObject.businessUnit} -m ` +
+                        removedFieldNames
+                            .map((name) => `dataExtensionField:"${deKey}.${name}"`)
+                            .join(' ')
+                )
+            );
+        }
+
         return existingFieldByName;
     }
 
@@ -325,7 +439,7 @@ class DataExtensionField extends MetadataType {
      * @returns {Promise.<boolean>} deletion success flag
      */
     static async deleteByKeySOAP(customerKey, fieldId) {
-        const [deKey, fieldName] = customerKey.split('.');
+        const [deKey, fieldName] = customerKey.split('.', 2);
         customerKey = `[${deKey}].[${fieldName}]`;
 
         let fieldObjectID = fieldId;

package/lib/metadataTypes/DataExtract.js

@@ -2,7 +2,6 @@
 
 import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
-import File from '../util/file.js';
 import cache from '../util/cache.js';
 
 /**
@@ -35,7 +34,7 @@ class DataExtract extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static async retrieve(retrieveDir, _, __, key) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/dataextracts/', null, key);
+        return super.retrieveREST(retrieveDir, '/automation/v1/dataextracts/', key);
     }
 
     /**
@@ -47,60 +46,6 @@ class DataExtract extends MetadataType {
         return super.retrieveREST(null, '/automation/v1/dataextracts/');
     }
 
-    /**
-     * Retrieve a specific dataExtract Definition by Name
-     *
-     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
-     * @param {string} templateDir Directory where retrieved metadata directory will be saved
-     * @param {string} name name of the metadata file
-     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
-     * @returns {Promise.<MetadataTypeItemObj>} Promise of metadata
-     */
-    static async retrieveAsTemplate(templateDir, name, templateVariables) {
-        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
-        const res = await this.client.rest.get(
-            '/automation/v1/dataextracts/?$filter=name%20eq%20' + encodeURIComponent(name)
-        );
-        if (Array.isArray(res.items) && res.items.length) {
-            // eq-operator returns a similar, not exact match and hence might return more than 1 entry
-            const metadata = res.items.find((item) => item.name === name);
-            if (!metadata) {
-                Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
-                return;
-            }
-
-            // get full definition
-            const extended = await this.client.rest.get(
-                '/automation/v1/dataextracts/' + metadata[this.definition.idField]
-            );
-            const originalKey = extended[this.definition.keyField];
-            const val = JSON.parse(
-                Util.replaceByObject(
-                    JSON.stringify(this.postRetrieveTasks(extended)),
-                    templateVariables
-                )
-            );
-
-            // remove all fields listed in Definition for templating
-            this.keepTemplateFields(val);
-            await File.writeJSONToFile(
-                [templateDir, this.definition.type].join('/'),
-                originalKey + '.' + this.definition.type + '-meta',
-                JSON.parse(Util.replaceByObject(JSON.stringify(val), templateVariables))
-            );
-            Util.logger.info(`- templated ${this.definition.type}: ${name}`);
-            return { metadata: val, type: this.definition.type };
-        } else if (res?.items) {
-            Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
-        } else {
-            throw new Error(
-                `Encountered unknown error when retrieveing ${
-                    this.definition.typeName
-                } "${name}": ${JSON.stringify(res)}`
-            );
-        }
-    }
-
     /**
      * Creates a single Data Extract
      *

package/lib/metadataTypes/DataExtractType.js

@@ -33,7 +33,7 @@ class DataExtractType extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static retrieve(retrieveDir, _, __, key) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/dataextracttypes/', null, key);
+        return super.retrieveREST(retrieveDir, '/automation/v1/dataextracttypes/', key);
     }
 
     /**

package/lib/metadataTypes/DataFilter.js

@@ -5,7 +5,6 @@ import { Util } from '../util/util.js';
 import cache from '../util/cache.js';
 import DataExtensionField from './DataExtensionField.js';
 import Folder from './Folder.js';
-import { XMLBuilder, XMLParser } from 'fast-xml-parser';
 import File from '../util/file.js';
 
 /**
@@ -28,6 +27,8 @@ import File from '../util/file.js';
  * @typedef {import('../../types/mcdev.d.js').FilterCondition} FilterCondition
  */
 
+let xmlParserModulesPromise;
+
 /**
  * DataFilter (FilterDefinition) MetadataType
  *
@@ -37,6 +38,17 @@ class DataFilter extends MetadataType {
     static cache = {}; // type internal cache for various things
     static deIdKeyMap;
     static hidden = false;
+
+    /**
+     * Loads and caches XML conversion classes at the asynchronous DataFilter boundary.
+     *
+     * @returns {Promise.<typeof import('fast-xml-parser')>} XML parser module
+     */
+    static _loadXmlParserModules() {
+        xmlParserModulesPromise ||= import('fast-xml-parser');
+        return xmlParserModulesPromise;
+    }
+
     /**
      * Retrieves all records and saves it to disk
      *
@@ -56,7 +68,6 @@ class DataFilter extends MetadataType {
             const metadataMapSingle = await super.retrieveREST(
                 null,
                 '/email/v1/filters/filterdefinition/' + objectId,
-                null,
                 key
             );
             Object.assign(filterDefinitionMap, metadataMapSingle.metadata);
@@ -69,15 +80,16 @@ class DataFilter extends MetadataType {
                     'email/v1/filters/filterdefinition/category/' +
                         folderId +
                         '?derivedFromType=1,2,3,4&',
-                    null,
                     key
                 );
-                if (Object.keys(metadataMapFolder.metadata).length) {
-                    Object.assign(filterDefinitionMap, metadataMapFolder.metadata);
-                    if (filterDefinitionMap[key]) {
-                        // if key was found we can stop checking other folders
-                        break;
-                    }
+                if (!Object.keys(metadataMapFolder.metadata).length) {
+                    continue;
+                }
+
+                Object.assign(filterDefinitionMap, metadataMapFolder.metadata);
+                if (filterDefinitionMap[key]) {
+                    // if key was found we can stop checking other folders
+                    break;
                 }
             }
         }
@@ -355,6 +367,7 @@ class DataFilter extends MetadataType {
         super.setFolderPath(metadata);
 
         // parse XML filter for further processing in JSON format
+        const { XMLParser } = await this._loadXmlParserModules();
         const xmlToJson = new XMLParser({
             preserveOrder: false, // XML parser returns undefined if this is true
             ignoreAttributes: false,
@@ -619,6 +632,7 @@ class DataFilter extends MetadataType {
             delete metadata.r__source_dataExtension_key;
         }
 
+        const { XMLBuilder } = await this._loadXmlParserModules();
         const jsonToXml = new XMLBuilder({
             preserveOrder: false, // XML Builder  returns undefined if this is true
             ignoreAttributes: false,

package/lib/metadataTypes/DeliveryProfile.js

@@ -31,12 +31,7 @@ class DeliveryProfile extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static retrieve(retrieveDir, _, __, key) {
-        return super.retrieveREST(
-            retrieveDir,
-            '/legacy/v1/beta/messaging/deliverypolicy/',
-            null,
-            key
-        );
+        return super.retrieveREST(retrieveDir, '/legacy/v1/beta/messaging/deliverypolicy/', key);
     }
 }
 

package/lib/metadataTypes/DomainVerification.js

@@ -35,7 +35,7 @@ class DomainVerification extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static async retrieve(retrieveDir, _, __, key) {
-        return super.retrieveREST(retrieveDir, '/messaging/v1/domainverification/', null, key);
+        return super.retrieveREST(retrieveDir, '/messaging/v1/domainverification/', key);
     }
 
     /**

package/lib/metadataTypes/Email.js

@@ -13,7 +13,6 @@ import { Util } from '../util/util.js';
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
- * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
  */
 
 /**
@@ -53,17 +52,16 @@ class Email extends MetadataType {
      * @param {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 {TemplateMap} [templateVariables] variables to be replaced in the metadata
      * @returns {Promise.<MetadataTypeMap>} Promise of saved metadata
      */
-    static async saveResults(results, retrieveDir, overrideType, templateVariables) {
+    static async saveResults(results, retrieveDir, overrideType) {
         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);
+        return super.saveResults(results, retrieveDir, overrideType);
     }
 
     /**