mcdev 3.0.3 → 3.1.3

package/lib/metadataTypes/Automation.js

@@ -92,14 +92,10 @@ class Automation extends MetadataType {
      * @returns {Promise<{metadata:AutomationMap,type:string}>} Promise of metadata
      */
     static async retrieve(retrieveDir) {
-        const results = await new Promise((resolve) => {
-            this.client.SoapClient.retrieve('Program', ['ObjectID'], (error, response) => {
-                if (error) {
-                    throw new Error(error);
-                } else {
-                    resolve(response.body.Results);
-                }
-            });
+        const results = await new Promise((resolve, reject) => {
+            this.client.SoapClient.retrieve('Program', ['ObjectID'], (ex, response) =>
+                ex ? reject(ex) : resolve(response.body.Results)
+            );
         });
         const details = (
             await Promise.all(
@@ -116,6 +112,60 @@ class Automation extends MetadataType {
         Util.logger.info(
             `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
         );
+        return { metadata: savedMetadata, type: this.definition.type };
+    }
+    /**
+     * Retrieves Metadata of Automation
+     * @returns {Promise<{metadata:AutomationMap,type:string}>} Promise of metadata
+     */
+    static async retrieveChangelog() {
+        const results = await new Promise((resolve, reject) => {
+            this.client.SoapClient.retrieve(
+                'Program',
+                ['ObjectID'],
+
+                (ex, response) => (ex ? reject(ex) : resolve(response.body.Results))
+            );
+        });
+        const details = [];
+        (
+            await Promise.all(
+                results.map(async (a) => {
+                    const options = {
+                        filter: {
+                            leftOperand: 'ProgramID',
+                            operator: 'equals',
+                            rightOperand: a.ObjectID,
+                        },
+                    };
+
+                    return new Promise((resolve, reject) => {
+                        this.client.SoapClient.retrieve(
+                            'Automation',
+                            [
+                                'ProgramID',
+                                'Name',
+                                'CustomerKey',
+                                'LastSaveDate',
+                                'LastSavedBy',
+                                'CreatedBy',
+                                'CreatedDate',
+                            ],
+                            options,
+                            (ex, response) => (ex ? reject(ex) : resolve(response.body.Results))
+                        );
+                    });
+                })
+            )
+        ).forEach((item) => {
+            details.push(...item);
+        });
+        details.map((item) => {
+            item.key = item.CustomerKey;
+        });
+
+        const parsed = this.parseResponseBody({ items: details });
+
         return { metadata: parsed, type: this.definition.type };
     }
 
@@ -152,10 +202,10 @@ class Automation extends MetadataType {
      * Retrieve a specific Automation Definition by Name
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
-     * @param {Util.TemplateMap} variables variables to be replaced in the metadata
+     * @param {Util.TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise<{metadata:AutomationMap,type:string}>} Promise of metadata
      */
-    static async retrieveAsTemplate(templateDir, name, variables) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
         const results = await new Promise((resolve) => {
             this.client.SoapClient.retrieve(
                 'Program',
@@ -189,12 +239,14 @@ class Automation extends MetadataType {
                 })
             ).body;
             let val = null;
+            let originalKey;
             // if parsing fails, we should just save what we get
             try {
                 const parsedDetails = this.parseMetadata(details);
+                originalKey = parsedDetails[this.definition.keyField];
                 if (parsedDetails !== null) {
                     val = JSON.parse(
-                        Util.replaceByObject(JSON.stringify(parsedDetails), variables)
+                        Util.replaceByObject(JSON.stringify(parsedDetails), templateVariables)
                     );
                 }
             } catch (ex) {
@@ -209,7 +261,7 @@ class Automation extends MetadataType {
             this.keepTemplateFields(val);
             File.writeJSONToFile(
                 [templateDir, this.definition.type].join('/'),
-                val[this.definition.keyField] + '.' + this.definition.type + '-meta',
+                originalKey + '.' + this.definition.type + '-meta',
                 val
             );
             Util.logger.info(
@@ -315,9 +367,8 @@ class Automation extends MetadataType {
                 delete metadata.schedule.scheduledTime;
                 delete metadata.schedule.scheduledStatus;
                 if (this.definition.timeZoneMapping[metadata.schedule.timezoneName]) {
-                    metadata.schedule.timezoneId = this.definition.timeZoneMapping[
-                        metadata.schedule.timezoneName
-                    ];
+                    metadata.schedule.timezoneId =
+                        this.definition.timeZoneMapping[metadata.schedule.timezoneName];
                 } else {
                     Util.logger.error(
                         `Could not find timezone ${metadata.schedule.timezoneName} in definition.timeZoneMapping`
@@ -435,44 +486,56 @@ class Automation extends MetadataType {
                     }
                     if (schedule !== null) {
                         try {
-                            await new Promise((resolve, reject) => {
-                                this.client.SoapClient.schedule(
-                                    'Automation',
-                                    schedule,
-                                    {
-                                        Interaction: {
-                                            ObjectID: metadata[key].id,
-                                        },
-                                    },
-                                    'start',
-                                    null,
-                                    (error, response) => {
-                                        if (
-                                            error ||
-                                            (response.body.Results &&
-                                                response.body.Results[0] &&
-                                                response.body.Results[0].StatusCode &&
-                                                response.body.Results[0].StatusCode === 'Error')
-                                        ) {
-                                            reject(error || response.body.Results[0].StatusMessage);
-                                        } else {
-                                            resolve(response.body.Results);
-                                        }
-                                    }
-                                );
-                            });
-                            const intervalString =
-                                (schedule._interval > 1 ? `${schedule._interval} ` : '') +
-                                (schedule.RecurrenceType === 'Daily'
-                                    ? 'Day'
-                                    : schedule.RecurrenceType.slice(0, -2) +
-                                      (schedule._interval > 1 ? 's' : ''));
-                            Util.logger.warn(
-                                `Automation '${
-                                    originalMetadata[key].name
-                                }' deployed Active: runs every ${intervalString} starting ${
-                                    schedule._StartDateTime.split('T').join(' ').split('.')[0]
-                                } ${schedule._timezoneString}`
+                            await Util.retryOnError(
+                                `Retrying ${this.definition.type}`,
+                                async () => {
+                                    await new Promise((resolve, reject) => {
+                                        this.client.SoapClient.schedule(
+                                            'Automation',
+                                            schedule,
+                                            {
+                                                Interaction: {
+                                                    ObjectID: metadata[key].id,
+                                                },
+                                            },
+                                            'start',
+                                            null,
+                                            (error, response) => {
+                                                if (
+                                                    error ||
+                                                    (response.body.Results &&
+                                                        response.body.Results[0] &&
+                                                        response.body.Results[0].StatusCode &&
+                                                        response.body.Results[0].StatusCode ===
+                                                            'Error')
+                                                ) {
+                                                    reject(
+                                                        error ||
+                                                            response.body.Results[0].StatusMessage
+                                                    );
+                                                } else {
+                                                    resolve(response.body.Results);
+                                                }
+                                            }
+                                        );
+                                    });
+                                    const intervalString =
+                                        (schedule._interval > 1 ? `${schedule._interval} ` : '') +
+                                        (schedule.RecurrenceType === 'Daily'
+                                            ? 'Day'
+                                            : schedule.RecurrenceType.slice(0, -2) +
+                                              (schedule._interval > 1 ? 's' : ''));
+                                    Util.logger.warn(
+                                        `Automation '${
+                                            originalMetadata[key].name
+                                        }' deployed Active: runs every ${intervalString} starting ${
+                                            schedule._StartDateTime
+                                                .split('T')
+                                                .join(' ')
+                                                .split('.')[0]
+                                        } ${schedule._timezoneString}`
+                                    );
+                                }
                             );
                         } catch (ex) {
                             Util.logger.error(
@@ -684,9 +747,8 @@ class Automation extends MetadataType {
         }
 
         if (this.definition.timeZoneMapping[scheduleObject.timezoneName]) {
-            scheduleObject.timezoneId = this.definition.timeZoneMapping[
-                scheduleObject.timezoneName
-            ];
+            scheduleObject.timezoneId =
+                this.definition.timeZoneMapping[scheduleObject.timezoneName];
         } else {
             Util.logger.error(
                 `Could not find timezone ${scheduleObject.timezoneName} in definition.timeZoneMapping`
@@ -780,6 +842,9 @@ class Automation extends MetadataType {
 // Assign definition to static attributes
 Automation.definition = Definitions.automation;
 Automation.cache = {};
+/**
+ * @type {Util.ET_Client}
+ */
 Automation.client = undefined;
 
 module.exports = Automation;

package/lib/metadataTypes/DataExtension.js

@@ -3,6 +3,7 @@
 const jsonToTable = require('json-to-table');
 const MetadataType = require('./MetadataType');
 const DataExtensionField = require('./DataExtensionField');
+const Folder = require('./Folder');
 const Util = require('../util/util');
 const File = require('../util/file');
 
@@ -43,7 +44,7 @@ class DataExtension extends MetadataType {
      */
     static async upsert(desToDeploy, _, buObject) {
         Util.logger.info('- Retrieve target metadata for comparison with deploy metadata');
-        const results = await this.retrieveForCache(buObject);
+        const results = await this.retrieveForCache(buObject, null, true);
         const targetMetadata = results.metadata;
         Util.logger.info('- Retrieved target metadata');
         /** @type {Promise[]} */
@@ -89,21 +90,7 @@ class DataExtension extends MetadataType {
                 // skip rest of handling for this DE
                 continue;
             }
-            // Error if SendableSubscriberField.Name = '_SubscriberKey' even though it is retrieved like that
-            // Therefore map it to 'Subscriber Key'. Retrieving afterward still results in '_SubscriberKey'
-            if (
-                desToDeploy[dataExtension].SendableSubscriberField &&
-                desToDeploy[dataExtension].SendableSubscriberField.Name === '_SubscriberKey'
-            ) {
-                desToDeploy[dataExtension].SendableSubscriberField.Name = 'Subscriber Key';
-            }
             if (targetMetadata[dataExtension]) {
-                // Update dataExtension + Columns if they already exist; Create them if not
-                // Modify columns for update call
-                DataExtension.prepareDeployColumnsOnUpdate(
-                    desToDeploy[dataExtension].Fields,
-                    targetMetadata[dataExtension].Fields
-                );
                 // data extension already exists in target and needs to be updated
                 deUpdatePromises.push(DataExtension.update(desToDeploy[dataExtension]));
             } else {
@@ -113,7 +100,7 @@ class DataExtension extends MetadataType {
         }
         if (deUpdatePromises.length) {
             Util.logger.info(
-                'Please note that Data Retention Policies can only be set during creation, not during update.'
+                '- Please note that Data Retention Policies can only be set during creation, not during update.'
             );
         }
 
@@ -123,6 +110,7 @@ class DataExtension extends MetadataType {
         const updateResults = (await Promise.allSettled(deUpdatePromises)).filter(
             this._filterUpsertResults
         );
+
         const successfulResults = [...createResults, ...updateResults];
 
         Util.metadataLogger(
@@ -160,6 +148,10 @@ class DataExtension extends MetadataType {
             // promise rejects, whole request failed
             Util.logger.error('- error upserting dataExtension: ' + res.reason);
             return false;
+        } else if (res.value == undefined || Object.keys(res.value).length === 0) {
+            // in case of returning empty result handle gracefully
+            // TODO: consider if SOAP handler for this should really return empty object
+            return false;
         } else if (res.value.results) {
             Util.logger.error(
                 '- error upserting dataExtension: ' +
@@ -177,39 +169,6 @@ class DataExtension extends MetadataType {
         }
     }
 
-    /**
-     * Mofifies passed deployColumns for update by mapping ObjectID to their target column's values.
-     * Removes FieldType field if its the same in deploy and target column, because it results in an error even if its of the same type
-     *
-     * @param {DataExtensionField.DataExtensionFieldItem[]} deployColumns Columns of data extension that will be deployed
-     * @param {DataExtensionField.DataExtensionFieldItem[]} targetColumns Columns of data extension that currently exists in target
-     * @returns {void}
-     */
-    static prepareDeployColumnsOnUpdate(deployColumns, targetColumns) {
-        // Map data extension column ObjectIDs to their target, because they are environment specific
-        for (const column in deployColumns) {
-            const deployColumn = deployColumns[column];
-            // Check if column exists in target
-            if (targetColumns[column]) {
-                // Map ObjectID to value of target, because DataExtensionField updates are based on ObjectID
-                deployColumn.ObjectID = targetColumns[column].ObjectID;
-                // Remove FieldType if it is the same in target, because an error occurs if a FieldTypes gets passed on a field update (even if its the same type)
-                if (targetColumns[column].FieldType === deployColumn.FieldType) {
-                    delete deployColumn.FieldType;
-                } else {
-                    // Updating to a new FieldType will result in an error
-                    Util.logger.warn(
-                        'DataExtension.prepareDeployColumnsOnUpdate:: Cannot update FieldType of field: ' +
-                            deployColumn.CustomerKey
-                    );
-                }
-            } else {
-                // Field doesn't exist in target, therefore Remove ObjectID if present
-                delete deployColumn.ObjectID;
-            }
-        }
-    }
-
     /**
      * Create a single dataExtension. Also creates their columns in 'dataExtension.columns'
      * @param {DataExtensionItem} metadata single metadata entry
@@ -256,33 +215,17 @@ class DataExtension extends MetadataType {
      * @returns {Promise} Promise
      */
     static async update(metadata) {
-        // retrieve existing fields to enable updating them
-        const fieldsObj = await this._retrieveFields(['Name', 'ObjectID'], {
-            filter: {
-                leftOperand: 'DataExtension.CustomerKey',
-                operator: 'equals',
-                rightOperand: metadata.CustomerKey,
-            },
-        });
-
-        // ensure fields can be updated properly by their adding ObjectId based on Name-matching
-        const existingFieldObj = {};
-        Object.keys(fieldsObj).forEach((key) => {
-            existingFieldObj[fieldsObj[key].Name] = fieldsObj[key].ObjectID;
-        });
-        metadata.Fields.map((item) => {
-            if (existingFieldObj[item.Name]) {
-                // field is getting updated ---
-                // remove FieldType as it cannot be updated mostly and will lead to an API error
-                delete item.FieldType;
-
-                // set the ObjectId for clear identification
-                item.ObjectID = existingFieldObj[item.Name];
-            } else {
-                // field is getting added ---
-                delete item.ObjectID; // make sure this is gone or it will cause issues on new fields!
-            }
-        });
+        // Update dataExtension + Columns if they already exist; Create them if not
+        // Modify columns for update call
+        DataExtensionField.cache = this.metadata;
+        DataExtensionField.client = this.client;
+        DataExtensionField.properties = this.properties;
+        DataExtension.oldFields = DataExtension.oldFields || {};
+        DataExtension.oldFields[metadata.CustomerKey] =
+            await DataExtensionField.prepareDeployColumnsOnUpdate(
+                metadata.Fields,
+                metadata.CustomerKey
+            );
 
         // convert simple array into object.Array.object format to cope with how the XML body in the SOAP call needs to look like:
         // <Fields>
@@ -295,25 +238,70 @@ class DataExtension extends MetadataType {
         metadata.Fields = { Field: metadata.Fields };
         return super.updateSOAP(metadata);
     }
+    /**
+     * Gets executed after deployment of metadata type
+     * @param {DataExtensionMap} upsertedMetadata metadata mapped by their keyField
+     * @returns {void}
+     */
+    static postDeployTasks(upsertedMetadata) {
+        if (!DataExtension.oldFields) {
+            // only run postDeploy if we are in update mode
+            return;
+        }
+        // somewhat of a workardoun but it ensures we get the field list from the server rather than whatever we might have in cache got returned during update/add. This ensures a complete and correctly ordered field list
+        for (const key in upsertedMetadata) {
+            const item = upsertedMetadata[key];
+            const isUpdate =
+                this.cache &&
+                this.cache.dataExtension &&
+                this.cache.dataExtension[item.CustomerKey];
+            if (isUpdate) {
+                const cachedVersion = this.cache.dataExtension[item.CustomerKey];
+                // restore retention values that are typically not returned by the update call
+                item.RowBasedRetention = cachedVersion.RowBasedRetention;
+                item.ResetRetentionPeriodOnImport = cachedVersion.ResetRetentionPeriodOnImport;
+                item.DeleteAtEndOfRetentionPeriod = cachedVersion.DeleteAtEndOfRetentionPeriod;
+                item.RetainUntil = cachedVersion.RetainUntil;
+
+                // ensure we have th
+                const existingFields = DataExtension.oldFields[item[this.definition.nameField]];
+                if (item.Fields !== '' && existingFields) {
+                    // TODO should be replaced by a manual sort using existingFields
+                    // ! this is inefficient because it triggers a new download of the fields during the saveResults() step
+                    item.Fields.length = 0;
+                }
+                // sort Fields entry to the end of the object for saving in .json
+                const fieldsBackup = item.Fields;
+                delete item.Fields;
+                item.Fields = fieldsBackup;
+            }
+        }
+    }
 
     /**
      * Retrieves dataExtension metadata. Afterwards starts retrieval of dataExtensionColumn metadata retrieval
      * @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 {Util.BuObject} buObject properties for auth
+     * @param {void} [_] -
+     * @param {boolean} [isDeploy] used to signal that fields shall be retrieve in caching mode
      * @returns {Promise<{metadata:DataExtensionMap,type:string}>} Promise of item map
      */
-    static async retrieve(retrieveDir, additionalFields, buObject) {
+    static async retrieve(retrieveDir, additionalFields, buObject, _, isDeploy) {
         let metadata = await this._retrieveAll(additionalFields);
         // in case of cache dont get fields
-        if (metadata && retrieveDir) {
+        if (isDeploy || (metadata && retrieveDir)) {
             // get fields from API
-            const fieldsObj = await this._retrieveFields(additionalFields);
+            const fieldsObj = await this._retrieveFields(null, additionalFields);
             const fieldKeys = Object.keys(fieldsObj);
             // add fields to corresponding DE
             fieldKeys.forEach((key) => {
                 const field = fieldsObj[key];
-                metadata[field.DataExtension.CustomerKey].Fields.push(field);
+                if (metadata[field?.DataExtension?.CustomerKey]) {
+                    metadata[field.DataExtension.CustomerKey].Fields.push(field);
+                } else {
+                    Util.logger.warn(`Issue retrieving data extension fields. key='${key}'`);
+                }
             });
 
             // sort fields by Ordinal value (API returns field unsorted)
@@ -336,9 +324,7 @@ class DataExtension extends MetadataType {
                 clientSecret: this.properties.credentials[buObject.credential].clientSecret,
                 tenant: this.properties.credentials[buObject.credential].tenant,
                 eid: this.properties.credentials[buObject.credential].eid,
-                mid: this.properties.credentials[buObject.credential].businessUnits[
-                    Util.parentBuName
-                ],
+                mid: this.properties.credentials[buObject.credential].eid,
                 businessUnit: Util.parentBuName,
                 credential: buObject.credential,
             };
@@ -351,6 +337,16 @@ class DataExtension extends MetadataType {
             }
             const metadataParentBu = await this._retrieveAll(additionalFields);
 
+            // get shared folders to match our shared / synched Data Extensions
+            Util.logger.info('- Caching dependent Metadata: folder (shared via _ParentBU_)');
+            Folder.cache = {};
+            Folder.client = this.client;
+            Folder.properties = this.properties;
+            const result = await Folder.retrieveForCache(buObjectParentBu);
+            const parentCache = {
+                folder: result.metadata,
+            };
+
             // get the types and clean out non-shared ones
             const folderTypesFromParent = require('../MetadataTypeDefinitions').folder
                 .folderTypesFromParent;
@@ -358,22 +354,30 @@ class DataExtension extends MetadataType {
                 try {
                     // get the data extension type from the folder
                     const folderContentType = Util.getFromCache(
-                        this.cache,
+                        parentCache,
                         'folder',
                         metadataParentBu[metadataEntry].CategoryID,
                         'ID',
                         'ContentType'
                     );
                     if (!folderTypesFromParent.includes(folderContentType)) {
+                        Util.logger.verbose(
+                            `removing ${metadataEntry} because r__folder_ContentType '${folderContentType}' identifies this DE as not being shared`
+                        );
                         delete metadataParentBu[metadataEntry];
                     }
                 } catch (ex) {
+                    Util.logger.debug(
+                        `removing ${metadataEntry} because of error while retrieving r__folder_ContentType: ${ex.message}`
+                    );
                     delete metadataParentBu[metadataEntry];
                 }
             }
 
             // revert client to current default
             this.client = clientBackup;
+            Folder.client = clientBackup;
+            Folder.cache = this.cache;
 
             // make sure to overwrite parent bu DEs with local ones
             metadata = { ...metadataParentBu, ...metadata };
@@ -390,6 +394,15 @@ class DataExtension extends MetadataType {
         }
         return { metadata: metadata, type: 'dataExtension' };
     }
+    /**
+     * Retrieves dataExtension metadata. Afterwards starts retrieval of dataExtensionColumn metadata retrieval
+     * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
+     * @returns {Promise<{metadata:DataExtensionMap,type:string}>} Promise of item map
+     */
+    static async retrieveChangelog(additionalFields) {
+        const metadata = await this._retrieveAll(additionalFields);
+        return { metadata: metadata, type: 'dataExtension' };
+    }
     /**
      * manages post retrieve steps
      * @param {DataExtensionItem} metadata a single dataExtension
@@ -410,17 +423,25 @@ class DataExtension extends MetadataType {
                 'Ensure that Queries that write into this DE are updated with the new key before deployment.';
             this.overrideKeyWithName(metadata, warningMsg);
         }
+        // Error during deploy if SendableSubscriberField.Name = '_SubscriberKey' even though it is retrieved like that
+        // Therefore map it to 'Subscriber Key'. Retrieving afterward still results in '_SubscriberKey'
+        if (
+            metadata.SendableSubscriberField &&
+            metadata.SendableSubscriberField.Name === '_SubscriberKey'
+        ) {
+            metadata.SendableSubscriberField.Name = 'Subscriber Key';
+        }
         return this._parseMetadata(JSON.parse(JSON.stringify(metadata)));
     }
 
     /**
      * Helper to retrieve Data Extension Fields
      * @private
-     * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {Object} [options] options (e.g. continueRequest)
+     * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @returns {Promise<DataExtensionField.DataExtensionFieldMap>} Promise of items
      */
-    static async _retrieveFields(additionalFields, options) {
+    static async _retrieveFields(options, additionalFields) {
         if (!options) {
             // dont print this during updates or templating which retrieves fields DE-by-DE
             Util.logger.info('- Caching dependent Metadata: dataExtensionField');
@@ -447,7 +468,7 @@ class DataExtension extends MetadataType {
                 rightOperand: customerKey,
             },
         };
-        const fieldsObj = await this._retrieveFields(null, fieldOptions);
+        const fieldsObj = await this._retrieveFields(fieldOptions);
 
         DataExtensionField.cache = this.metadata;
         DataExtensionField.client = this.client;
@@ -524,6 +545,16 @@ class DataExtension extends MetadataType {
         // contenttype
         delete metadata.r__folder_ContentType;
 
+        // Error if SendableSubscriberField.Name = '_SubscriberKey' even though it is retrieved like that
+        // Therefore map it to 'Subscriber Key'. Retrieving afterward still results in '_SubscriberKey'
+        // TODO remove from preDeploy with release of version 4, keep until then to help with migration of old metadata
+        if (
+            metadata.SendableSubscriberField &&
+            metadata.SendableSubscriberField.Name === '_SubscriberKey'
+        ) {
+            metadata.SendableSubscriberField.Name = 'Subscriber Key';
+        }
+
         return metadata;
     }
 
@@ -826,19 +857,21 @@ class DataExtension extends MetadataType {
     /**
      * Retrieves folder metadata into local filesystem. Also creates a uniquePath attribute for each folder.
      * @param {Object} buObject properties for auth
+     * @param {void} [_] -
+     * @param {boolean} [isDeploy] used to signal that fields shall be retrieve in caching mode
      * @returns {Promise} Promise
      */
-    static async retrieveForCache(buObject) {
-        return this.retrieve(null, ['ObjectID', 'CustomerKey', 'Name'], buObject);
+    static async retrieveForCache(buObject, _, isDeploy) {
+        return this.retrieve(null, ['ObjectID', 'CustomerKey', 'Name'], buObject, null, isDeploy);
     }
     /**
      * Retrieves dataExtension metadata in template format.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata item
-     * @param {Util.TemplateMap} variables variables to be replaced in the metadata
+     * @param {Util.TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise<{metadata:DataExtensionMap,type:string}>} Promise of items
      */
-    static async retrieveAsTemplate(templateDir, name, variables) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
         const options = {
             filter: {
                 leftOperand: 'Name',
@@ -863,20 +896,20 @@ class DataExtension extends MetadataType {
                 // API returns field unsorted
                 metadata[key].Fields.sort((a, b) => a.Ordinal - b.Ordinal);
 
+                const originalKey = key;
                 const metadataCleaned = JSON.parse(
-                    JSON.stringify(await this.postRetrieveTasks(metadata[key], null, !!variables))
+                    JSON.stringify(
+                        await this.postRetrieveTasks(metadata[key], null, !!templateVariables)
+                    )
                 );
 
                 this.keepTemplateFields(metadataCleaned);
                 const metadataTemplated = JSON.parse(
-                    Util.replaceByObject(JSON.stringify(metadataCleaned), variables)
+                    Util.replaceByObject(JSON.stringify(metadataCleaned), templateVariables)
                 );
                 File.writeJSONToFile(
                     [templateDir, this.definition.type].join('/'),
-                    metadataTemplated[this.definition.keyField] +
-                        '.' +
-                        this.definition.type +
-                        '-meta',
+                    originalKey + '.' + this.definition.type + '-meta',
                     metadataTemplated
                 );
             } catch (ex) {
@@ -993,6 +1026,9 @@ class DataExtension extends MetadataType {
 
 // Assign definition to static attributes
 DataExtension.definition = require('../MetadataTypeDefinitions').dataExtension;
+/**
+ * @type {Util.ET_Client}
+ */
 DataExtension.client = undefined;
 DataExtension.cache = {};