mcdev 7.10.1 → 8.0.1

package/lib/metadataTypes/Automation.js

@@ -6,6 +6,7 @@ import File from '../util/file.js';
 import Definitions from '../MetadataTypeDefinitions.js';
 import cache from '../util/cache.js';
 import pLimit from 'p-limit';
+import Retriever from '../Retriever.js';
 
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
@@ -92,7 +93,7 @@ class Automation extends MetadataType {
                           id: objectID,
                           uri: '/automation/v1/automations/' + objectID,
                       })),
-                      50,
+                      10,
                       !key
                   )
                 : null;
@@ -125,20 +126,32 @@ class Automation extends MetadataType {
      * helper for {@link this.retrieveRESTcollection}
      *
      * @param {SDKError} ex exception
-     * @param {string} id id or key of item
+     * @param {string} key id or key of item
+     * @param {string} url url to call for retry
      * @returns {Promise.<any>} can return retry-result
      */
-    static async handleRESTErrors(ex, id) {
+    static async handleRESTErrors(ex, key, url) {
         try {
-            if (ex.message == 'socket hang up') {
+            if (ex.message == 'socket hang up' || ex.code == 'ERR_BAD_RESPONSE') {
                 // one more retry; it's a rare case but retrying again should solve the issue gracefully
-                return await this.client.rest.get('/automation/v1/automations/' + id);
+                Util.logger.info(
+                    ` - Connection problem (Code: ${ex.code}). Retrying once
+                    ${
+                        ex.endpoint
+                            ? Util.getGrayMsg(
+                                  ' - ' + ex.endpoint.split('rest.marketingcloudapis.com')[1]
+                              )
+                            : ''
+                    }`
+                );
+                Util.logger.errorStack(ex);
+                return await this.client.rest.get(url);
             }
         } catch {
             // no extra action needed, handled below
         }
         // if we do get here, we should log the error and continue instead of failing to download all automations
-        Util.logger.error(` ☇ skipping Automation ${id}: ${ex.message} ${ex.code}`);
+        Util.logger.error(` ☇ skipping ${this.definition.type} ${key}: ${ex.message} ${ex.code}`);
         return null;
     }
 
@@ -216,6 +229,10 @@ class Automation extends MetadataType {
                         if (extended?.scheduleObject?.id && item.schedule) {
                             // save schedule id in cached metadata for retrieval during scheduling
                             item.schedule.id = extended.scheduleObject.id;
+                            item.schedule.description = extended.scheduleObject.description;
+                            item.schedule.icalRecur ||= extended.scheduleObject.iCalRecur;
+                            item.schedule.startDate ||= extended.scheduleObject.startDate;
+                            item.schedule.timezoneName ||= extended.scheduleObject.timeZone;
                         }
 
                         // add timezone to wait activities
@@ -401,12 +418,14 @@ class Automation extends MetadataType {
     /**
      * Retrieve a specific Automation 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.<AutomationItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         const results = await this.client.soap.retrieve('Program', ['ObjectID', 'Name'], {
             filter: {
                 leftOperand: 'Name',
@@ -717,22 +736,56 @@ class Automation extends MetadataType {
                 Util.logger.info(
                     ` ☇ skipping ${Util.getTypeKeyName(this.definition, item)}: already ${mode === 'schedule' ? 'activated' : 'paused'}.`
                 );
-            } else {
-                // schedule
-                promiseResults.push(
-                    this.#schedulePauseItem(mode, key, item.legacyId, item.schedule.id)
-                );
+                continue;
+            }
+            if (mode === 'schedule') {
+                try {
+                    this._checkSchedule(item.schedule, true);
+                } catch (ex) {
+                    Util.logger.error(
+                        ` ☇ skipping ${this.definition.type} ${key} (${item.schedule.description}): ${ex.message}`
+                    );
+                    continue;
+                }
             }
+
+            // schedule
+            promiseResults.push(
+                this.#schedulePauseItem(
+                    mode,
+                    key,
+                    item.legacyId,
+                    item.schedule.id,
+                    item.schedule.description
+                )
+            );
         }
         const results = await Promise.all(promiseResults);
         const updatedKeyArr = results
             .filter(Boolean)
-            .filter((r) => r.response.id)
+            .filter((r) => r.response?.id)
             .map((r) => r.key);
         Util.logger.info(
             `${mode === 'schedule' ? 'Activated' : 'Paused'} ${updatedKeyArr.length} of ${keyArr.length} items`
         );
 
+        if (updatedKeyArr.length) {
+            Util.logger.info(
+                Util.getGrayMsg(
+                    `Caching ${this.definition.type} post-${mode === 'schedule' ? 'activation' : 'pausing'} to update local files.`
+                )
+            );
+            // re-retrieve the items that were activated / paused
+            const retriever = new Retriever(this.properties, this.buObject);
+            try {
+                await retriever.retrieve([this.definition.type], updatedKeyArr);
+            } catch (ex) {
+                Util.logger.warn(
+                    `Could not re-retrieve ${mode === 'schedule' ? 'activated' : 'paused'} ${this.definition.type}s: ${ex.message}`
+                );
+            }
+        }
+
         return updatedKeyArr;
     }
 
@@ -743,15 +796,39 @@ class Automation extends MetadataType {
      * @param {string} key automation key
      * @param {string} automationLegacyId automation id
      * @param {string} [scheduleLegacyId] schedule id
+     * @param {string} [description] schedule description
      * @returns {Promise.<{key:string, response:object}>} metadata key and API response
      */
-    static async #schedulePauseItem(mode, key, automationLegacyId, scheduleLegacyId) {
+    static async #schedulePauseItem(mode, key, automationLegacyId, scheduleLegacyId, description) {
         if (!scheduleLegacyId) {
             const extended = await this.client.rest.get(
                 `/legacy/v1/beta/bulk/automations/automation/definition/` + automationLegacyId
             );
-            if (extended.scheduleObject?.id) {
-                scheduleLegacyId = extended.scheduleObject.id;
+            /** @type {AutomationSchedule} */
+            const scheduleObjectLegacy = extended.scheduleObject;
+            if (scheduleObjectLegacy?.id) {
+                scheduleLegacyId = scheduleObjectLegacy.id;
+                if (mode === 'schedule') {
+                    // convert legacy API schedule to new schedule
+                    /** @type {AutomationSchedule} */
+                    const scheduleObject = {
+                        id: scheduleObjectLegacy.id,
+                        typeId: null,
+                        endDate: null,
+                        startDate: scheduleObjectLegacy.startDate,
+                        timezoneName: scheduleObjectLegacy.timeZone,
+                        icalRecur: scheduleObjectLegacy.iCalRecur,
+                    };
+                    try {
+                        this._checkSchedule(scheduleObject);
+                    } catch (ex) {
+                        Util.logger.error(
+                            ` ☇ skipping ${this.definition.type} ${key}: ${ex.message}`
+                        );
+                        return null;
+                    }
+                }
+                description = scheduleObjectLegacy.description;
             } else {
                 Util.logger.error(
                     ` ☇ skipping ${this.definition.type} ${key}: no valid schedule settings found.`
@@ -759,21 +836,28 @@ class Automation extends MetadataType {
                 return null;
             }
         }
-        const response = await this.client.rest.post(
-            '/legacy/v1/beta/bulk/automations/automation/definition/?action=' +
-                (mode === 'schedule' ? 'schedule' : 'pauseSchedule'),
-            {
-                id: automationLegacyId,
-                scheduleObject: {
-                    id: scheduleLegacyId,
-                },
+        let response;
+        try {
+            response = await this.client.rest.post(
+                '/legacy/v1/beta/bulk/automations/automation/definition/?action=' +
+                    (mode === 'schedule' ? 'schedule' : 'pauseSchedule'),
+                {
+                    id: automationLegacyId,
+                    scheduleObject: {
+                        id: scheduleLegacyId,
+                    },
+                }
+            );
+            if (response?.id === automationLegacyId) {
+                const item = {};
+                item[this.definition.keyField] = key;
+                Util.logger.info(
+                    ` - ${mode === 'schedule' ? '✅ activated' : '🛑 paused'} scheduled ${Util.getTypeKeyName(this.definition, item)}${mode === 'schedule' ? ' (' + description + ')' : ''}`
+                );
             }
-        );
-        if (response?.id === automationLegacyId) {
-            const item = {};
-            item[this.definition.keyField] = key;
-            Util.logger.info(
-                ` - ${mode === 'schedule' ? '✅ activated' : '🛑 paused'} scheduled ${Util.getTypeKeyName(this.definition, item)}`
+        } catch (ex) {
+            Util.logger.error(
+                ` ☇ error ${mode === 'schedule' ? 'activating' : 'pausing'} ${this.definition.type} ${key} (${description}): ${ex.message}`
             );
         }
 
@@ -1258,15 +1342,6 @@ class Automation extends MetadataType {
                 'Path'
             );
             delete metadata[folderIdField];
-            if (metadata.r__folder_Path !== 'my automations') {
-                Util.logger.verbose(
-                    `- automation '${
-                        metadata[this.definition.nameField]
-                    }' is located in subfolder ${
-                        metadata.r__folder_Path
-                    }. Please note that creating automation folders is not supported via API and hence you will have to create it manually in the GUI if you choose to deploy this automation.`
-                );
-            }
         } catch (ex) {
             Util.logger.warn(
                 ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
@@ -1281,9 +1356,10 @@ class Automation extends MetadataType {
      * based on combination of ical string and start/end dates.
      *
      * @param {AutomationSchedule} scheduleObject child of automation metadata used for scheduling
+     * @param {boolean} [errorOnNotSchedulable] used if run for schedule command
      * @returns {void} throws and error in case of problems
      */
-    static _checkSchedule(scheduleObject) {
+    static _checkSchedule(scheduleObject, errorOnNotSchedulable = false) {
         // build recurrence
         const recurHelper = {};
         // ical values are split by ; then have key values split by =
@@ -1300,7 +1376,6 @@ class Automation extends MetadataType {
                 'The smallest interval you can configure is 5 minutes. Please adjust your schedule.'
             );
         }
-
         if (this.definition.timeZoneMapping[scheduleObject.timezoneName]) {
             scheduleObject.timezoneId =
                 this.definition.timeZoneMapping[scheduleObject.timezoneName];
@@ -1309,6 +1384,28 @@ class Automation extends MetadataType {
                 `Could not find timezone ${scheduleObject.timezoneName} in definition.timeZoneMapping`
             );
         }
+
+        if (recurHelper.COUNT == 1) {
+            const timezoneString = this.definition.timeZoneDifference[scheduleObject.timezoneId];
+            // add tz to input date to ensure Date() creates a date object with the right tz
+            const inputStartDateString = scheduleObject.startDate + timezoneString;
+            if (new Date(inputStartDateString) > new Date()) {
+                const msg =
+                    'The automation will run only once. Please make sure this is intended and that the start date is in the future.';
+                if (errorOnNotSchedulable) {
+                    throw new Error(msg);
+                } else {
+                    Util.logger.warn(msg);
+                }
+            } else {
+                const msg = `The automation will run only once but its start date is in the past. While this can be saved, it cannot be scheduled.`;
+                if (errorOnNotSchedulable) {
+                    throw new Error(msg);
+                } else {
+                    Util.logger.warn(msg);
+                }
+            }
+        }
     }
 
     /**

package/lib/metadataTypes/DataExtension.js

@@ -84,11 +84,6 @@ class DataExtension extends MetadataType {
                 continue;
             }
         }
-        if (metadataToUpdate.length) {
-            Util.logger.info(
-                ' - Please note that Data Retention Policies can only be set during creation, not during update.'
-            );
-        }
         const createLimit = pLimit(10);
         const createResults = (
             await Promise.allSettled(
@@ -316,11 +311,6 @@ class DataExtension extends MetadataType {
                 : null;
             if (cachedVersion) {
                 // UPDATE
-                // 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;
 
                 const existingFields = DataExtension.oldFields[item[this.definition.keyField]];
 
@@ -1503,12 +1493,14 @@ class DataExtension extends MetadataType {
     /**
      * 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: {

package/lib/metadataTypes/DataExtensionField.js

@@ -175,10 +175,9 @@ class DataExtensionField extends MetadataType {
                 // Updating to a new FieldType will result in an error; warn & afterwards remove it
                 if (itemOld.FieldType !== item.FieldType) {
                     // applicable: with or without data but simply ignored by API
-                    Util.logger.warn(
-                        ` - The Field Type of an existing field cannot be changed. Keeping the original value for [${deKey}].[${item.Name}]: '${itemOld.FieldType}'`
+                    Util.logger.error(
+                        ` - The Field Type of an existing field cannot be changed. [${deKey}].[${item.Name}]: '${itemOld.FieldType}'`
                     );
-                    item.FieldType = itemOld.FieldType;
                 }
                 if (item.FieldType !== 'Decimal') {
                     // remove scale - it's only used for "Decimal" to define the digits behind the decimal
@@ -188,17 +187,15 @@ class DataExtensionField extends MetadataType {
 
                 if (itemOld.MaxLength > item.MaxLength) {
                     // applicable: with or without data (Code 310007)
-                    Util.logger.warn(
-                        ` - The length of an existing field cannot be decreased. Keeping the original value for [${deKey}].[${item.Name}]: '${itemOld.MaxLength}'`
+                    Util.logger.error(
+                        ` - The length of an existing field cannot be decreased. [${deKey}].[${item.Name}]: '${itemOld.MaxLength}'`
                     );
-                    item.MaxLength = itemOld.MaxLength;
                 }
                 if (Util.isFalse(itemOld.IsRequired) && Util.isTrue(item.IsRequired)) {
                     // applicable: with or without data (Code 310007)
-                    Util.logger.warn(
-                        ` - A field cannot be changed to be required on update after it was created to allow nulls. Resetting to not equired: [${deKey}].[${item.Name}]`
+                    Util.logger.error(
+                        ` - A field cannot be changed to be required on update after it was created to allow nulls. [${deKey}].[${item.Name}]`
                     );
-                    item.IsRequired = itemOld.IsRequired;
                 }
 
                 // enable renaming
@@ -241,9 +238,8 @@ class DataExtensionField extends MetadataType {
                         item.IsRequired = false;
                     } else {
                         Util.logger.error(
-                            `- You cannot add a new primary key field to an existing table that has data. Removing [${deKey}].[${item.Name}] from deployment`
+                            `- You cannot add a new primary key field to an existing table that has data. [${deKey}].[${item.Name}]`
                         );
-                        deployColumns.splice(i, 1);
                     }
                 }
                 if (item.Name_new) {
@@ -268,15 +264,13 @@ class DataExtensionField extends MetadataType {
             // filter bad manual changes to the json
             if (!Util.isTrue(item.IsRequired) && !Util.isFalse(item.IsRequired)) {
                 Util.logger.error(
-                    `- Invalid value for 'IsRequired' of [${deKey}].[${item.Name}]. Found '${item.IsRequired}' instead of 'true'/'false'. Removing field from deploy!`
+                    `- Invalid value for 'IsRequired' of [${deKey}].[${item.Name}]. Found '${item.IsRequired}' instead of 'true'/'false'.`
                 );
-                deployColumns.splice(i, 1);
             }
             if (!Util.isTrue(item.IsPrimaryKey) && !Util.isFalse(item.IsPrimaryKey)) {
                 Util.logger.error(
-                    `- Invalid value for 'IsPrimaryKey' of [${deKey}].[${item.Name}]. Found '${item.IsPrimaryKey}' instead of 'true'/'false'. Removing field from deploy!`
+                    `- Invalid value for 'IsPrimaryKey' of [${deKey}].[${item.Name}]. Found '${item.IsPrimaryKey}' instead of 'true'/'false'.`
                 );
-                deployColumns.splice(i, 1);
             }
         }
 

package/lib/metadataTypes/DataExtract.js

@@ -50,12 +50,14 @@ class DataExtract extends MetadataType {
     /**
      * 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)
         );

package/lib/metadataTypes/Event.js

@@ -33,6 +33,7 @@ import pLimit from 'p-limit';
  */
 class Event extends MetadataType {
     static reCacheDataExtensions = [];
+    static createdKeys = [];
 
     /**
      * Retrieves Metadata of Event Definition.
@@ -81,12 +82,14 @@ class Event extends MetadataType {
     /**
      * Retrieve a specific Event 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(
             '/interaction/v1/eventDefinitions?name=' + encodeURIComponent(name)
         );
@@ -158,7 +161,10 @@ class Event extends MetadataType {
      */
     static async deploy(metadata, deployDir, retrieveDir) {
         Util.logBeta(this.definition.type);
-        return super.deploy(metadata, deployDir, retrieveDir);
+        const metadataMap = await super.deploy(metadata, deployDir, retrieveDir);
+
+        this.createdKeys.length = 0; // reset createdKeys after deploy to ensure it's not used in future retrieves
+        return metadataMap;
     }
 
     /**
@@ -168,6 +174,7 @@ class Event extends MetadataType {
      * @returns {Promise} Promise
      */
     static create(metadata) {
+        this.createdKeys.push(metadata[this.definition.keyField]);
         return super.createREST(metadata, '/interaction/v1/eventDefinitions/');
     }
 
@@ -215,8 +222,7 @@ class Event extends MetadataType {
                 break;
             }
             case 'SalesforceObjectTriggerV2': {
-                metadata.iconUrl ||=
-                    '/events/js/salesforce-event/events/NetworkMember/images/SF-Event-Icon.svg';
+                metadata.iconUrl ||= '/events/js/salesforce-event/images/SF-Event-Icon.svg';
                 break;
             }
             case 'AutomationAudience': {
@@ -225,6 +231,11 @@ class Event extends MetadataType {
             }
         }
 
+        // filter
+        if (!metadata.filterDefinitionId) {
+            metadata.filterDefinitionId = '00000000-0000-0000-0000-000000000000';
+        }
+
         // automation
         if (metadata.r__automation_key) {
             metadata.automationId = cache.searchForField(
@@ -236,8 +247,14 @@ class Event extends MetadataType {
             if (metadata.arguments) {
                 metadata.arguments.automationId = metadata.automationId;
             }
-            delete metadata.arguments.automationId;
+        } else if (!metadata.automationId) {
+            // if no automation was linked during retrieve we remove the field and hence need to re-set it before deployment
+            metadata.automationId = '00000000-0000-0000-0000-000000000000';
+            if (metadata.arguments) {
+                metadata.arguments.automationId = metadata.automationId;
+            }
         }
+
         // dataExteension
         // is resolved in createOrUpdate
 
@@ -529,28 +546,40 @@ class Event extends MetadataType {
             );
         }
 
+        // filter
+        if (
+            metadata?.filterDefinitionId &&
+            metadata.filterDefinitionId === '00000000-0000-0000-0000-000000000000'
+        ) {
+            // if no filter is linked this placeholder value is set which holds no value
+            delete metadata.filterDefinitionId;
+        }
+
         // automation
-        try {
-            if (
-                metadata?.automationId &&
-                metadata?.automationId !== '00000000-0000-0000-0000-000000000000'
-            ) {
-                metadata.r__automation_key = cache.searchForField(
-                    'automation',
-                    metadata.automationId,
-                    'id',
-                    'key'
-                );
+        if (metadata?.automationId) {
+            if (metadata?.automationId === '00000000-0000-0000-0000-000000000000') {
+                // if no automation is linked this placeholder value is set which holds no value
                 delete metadata.automationId;
-                delete metadata.arguments?.automationId;
+            } else {
+                try {
+                    metadata.r__automation_key = cache.searchForField(
+                        'automation',
+                        metadata.automationId,
+                        'id',
+                        'key'
+                    );
+                    delete metadata.automationId;
+                    delete metadata.arguments?.automationId;
+                } catch (ex) {
+                    Util.logger.warn(
+                        ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                            metadata[this.definition.keyField]
+                        }): ${ex.message}.`
+                    );
+                }
             }
-        } catch (ex) {
-            Util.logger.warn(
-                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
-                    metadata[this.definition.keyField]
-                }): ${ex.message}.`
-            );
         }
+
         // dataExtension
         try {
             metadata.r__dataExtension_key = cache.searchForField(
@@ -578,16 +607,18 @@ class Event extends MetadataType {
         if (metadata.mode === 'Production') {
             delete metadata.mode;
         }
-        if (metadata.interactionCount === 0 && metadata.publishedInteractionCount === 0) {
-            Util.logger.warn(
-                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): is no longer used and could therefore be deleted. Associated Journeys: ${metadata.interactionCount}. Active Journeys: ${metadata.publishedInteractionCount}.`
-            );
-        } else if (metadata.publishedInteractionCount === 0) {
-            Util.logger.info(
-                Util.getGrayMsg(
-                    ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): is currently inactive. Associated Journeys: ${metadata.interactionCount}. Active Journeys: ${metadata.publishedInteractionCount}.`
-                )
-            );
+        if (!this.createdKeys.includes(metadata[this.definition.keyField])) {
+            if (metadata.interactionCount === 0 && metadata.publishedInteractionCount === 0) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): is not used and could therefore be deleted. Associated Journeys: ${metadata.interactionCount}. Active Journeys: ${metadata.publishedInteractionCount}.`
+                );
+            } else if (metadata.publishedInteractionCount === 0) {
+                Util.logger.info(
+                    Util.getGrayMsg(
+                        ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): is currently inactive. Associated Journeys: ${metadata.interactionCount}. Active Journeys: ${metadata.publishedInteractionCount}.`
+                    )
+                );
+            }
         }
 
         try {

package/lib/metadataTypes/FileTransfer.js

@@ -50,12 +50,14 @@ class FileTransfer extends MetadataType {
     /**
      * Retrieve a specific File Transfer 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
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         const res = await this.client.rest.get(
             '/automation/v1/filetransfers/?$filter=name%20eq%20' + encodeURIComponent(name)
         );