mcdev 7.10.1 → 8.0.0

package/lib/metadataTypes/Asset.js

@@ -410,6 +410,9 @@ class Asset extends MetadataType {
                 'availableViews',
                 'data',
                 'tags',
+
+                'meta',
+                'content',
             ];
         }
 
@@ -502,7 +505,7 @@ class Asset extends MetadataType {
                 await this.requestAndSaveExtended(items, subType, retrieveDir, templateVariables);
             }
             // always show the summary even if we already had the progress bar in the console
-            Util.logger.info(`  Downloaded asset-${subType}: ${items.length}`);
+            Util.logger.info(`  Downloaded asset${subType ? '-' + subType : ''}: ${items.length}`);
         }
 
         return items;
@@ -766,6 +769,44 @@ class Asset extends MetadataType {
             }
         }
 
+        // get asset-asset
+        try {
+            if (metadata.meta?.thumbnailRefAssetId) {
+                // cloudpages', 'landingpage', 'microsite', 'interactivecontent'
+                metadata.meta.r__asset_key = cache.searchForField(
+                    'asset',
+                    metadata.meta?.thumbnailRefAssetId,
+                    'id',
+                    'customerKey'
+                );
+                delete metadata.meta.thumbnailRefAssetId;
+            }
+        } catch {
+            Util.logger.warn(
+                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                    metadata[this.definition.keyField]
+                }): Could not find associated cloudpage content with id (${metadata.meta.thumbnailRefAssetId})`
+            );
+        }
+        if (
+            ['landingpage', 'microsite', 'interactivecontent'].includes(metadata.assetType.name) &&
+            typeof metadata.content === 'string'
+        ) {
+            // cloudpages', 'landingpage', 'microsite', 'interactivecontent'
+            metadata.content = JSON.parse(metadata.content);
+        }
+
+        if (typeof metadata.data?.site?.content === 'string') {
+            // for all xx-coderesource types
+            metadata.data.site.content = JSON.parse(metadata.data.site.content);
+        }
+
+        if (metadata.meta?.cloudPages) {
+            metadata.meta.cloudPages.c__published = metadata.meta.cloudPages.publishDate
+                ? true
+                : false;
+        }
+
         // extract HTML for selected subtypes and convert payload for easier processing in MetadataType.saveResults()
         return this._extractCode(metadata);
     }
@@ -858,14 +899,22 @@ class Asset extends MetadataType {
         // folder
         this.setFolderId(metadata);
 
-        if (
-            metadata.assetType.name === 'webpage' &&
-            !cache.getByKey(this.definition.type, metadata[this.definition.keyField])
-        ) {
-            // we are attempting to CREATE a cloudpage asset which needs to be prevented.
-            throw new Error(
-                'CloudPages cannot be created via mcdev. Please create it via the UI first, then change its key to the value required by you, and finally, re-run this deployment.'
-            );
+        if (!cache.getByKey(this.definition.type, metadata[this.definition.keyField])) {
+            if (metadata.assetType.name === 'webpage') {
+                // we are attempting to CREATE a cloudpage asset which needs to be prevented.
+                throw new Error(
+                    'CloudPage content cannot be created via mcdev. Please create it via the UI first, then you can update the content or key.'
+                );
+            }
+            if (
+                this.definition.extendedSubTypes.cloudpage.includes(metadata.assetType.name) ||
+                this.definition.extendedSubTypes.coderesource.includes(metadata.assetType.name)
+            ) {
+                // if we do create those, we get the error "Asset <id> not found" because the internal endpoint internal/v2/cloudpages/sites won't find it.
+                throw new Error(
+                    'CloudPage assets cannot be created via mcdev. Please create it via the UI first, then you can update the content or key.'
+                );
+            }
         }
 
         // template-based emails
@@ -901,6 +950,33 @@ class Asset extends MetadataType {
             delete metadata.views.html.template.r__asset_key;
         }
 
+        if (metadata.meta?.r__asset_key) {
+            // cloudpages: 'landingpage', 'microsite', 'interactivecontent'
+            // get asset-asset
+            metadata.meta.thumbnailRefAssetId = cache.searchForField(
+                'asset',
+                metadata.meta.r__asset_key,
+                'customerKey',
+                'id'
+            );
+            delete metadata.meta.r__asset_key;
+        }
+        if (metadata.meta?.cloudPages?.c__published) {
+            // TODO: removal should be done via asset.definition instead
+            delete metadata.meta.cloudPages.c__published;
+        }
+        if (
+            ['landingpage', 'microsite', 'interactivecontent'].includes(metadata.assetType.name) &&
+            typeof metadata.content === 'object'
+        ) {
+            // cloudpages: 'landingpage', 'microsite', 'interactivecontent'
+            metadata.content = JSON.stringify(metadata.content);
+        }
+        if (typeof metadata.data?.site?.content === 'object') {
+            // coderesource: for all xx-coderesource types
+            metadata.data.site.content = JSON.stringify(metadata.data.site.content);
+        }
+
         // restore asset type id which is needed for deploy
         metadata.assetType.id = this.definition.typeMapping[metadata.assetType.name];
 
@@ -1575,6 +1651,12 @@ class Asset extends MetadataType {
 
                 break;
             }
+            case 'jscoderesource': // coderesource
+            case 'csscoderesource': // coderesource
+            case 'jsoncoderesource': // coderesource
+            case 'rsscoderesource': // coderesource
+            case 'textcoderesource': // coderesource
+            case 'xmlcoderesource': // coderesource
             case 'buttonblock': // block - Button Block
             case 'freeformblock': // block
             case 'htmlblock': // block
@@ -1587,7 +1669,17 @@ class Asset extends MetadataType {
                 // metadata.content
                 subDirArr = [this.definition.type, subType];
                 readDirArr = [deployDir, ...subDirArr];
-                const fileExtArr = ['html', 'ssjs', 'amp'];
+                const fileExtArr = [
+                    'html',
+                    'ssjs',
+                    'amp',
+                    'js',
+                    'css',
+                    'rss',
+                    'txt',
+                    'xml',
+                    'jsonc',
+                ];
                 for (const ext of fileExtArr) {
                     if (
                         await File.pathExists(
@@ -1858,6 +1950,30 @@ class Asset extends MetadataType {
                     subFolder: [customerKey],
                 };
             }
+            case 'jscoderesource': // coderesource
+            case 'csscoderesource': // coderesource
+            case 'jsoncoderesource': // coderesource
+            case 'rsscoderesource': // coderesource
+            case 'textcoderesource': // coderesource
+            case 'xmlcoderesource': {
+                // metadata.content
+                const content = metadata?.content;
+                const fileExt = metadata.assetType.name
+                    .replace('coderesource', '')
+                    .replace('text', 'txt')
+                    .replace('json', 'jsonc');
+
+                if (content?.length) {
+                    codeArr.push({
+                        subFolder: null,
+                        fileName: customerKey,
+                        fileExt: fileExt,
+                        content: content,
+                    });
+                    delete metadata.content;
+                }
+                return { json: metadata, codeArr: codeArr, subFolder: null };
+            }
             case 'buttonblock': // block-buttonblock
             case 'freeformblock': // block-freeformblock
             case 'htmlblock': // block-htmlblock

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
@@ -717,22 +734,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 +794,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 +834,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 +1340,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 +1354,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 +1374,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 +1382,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]];
 

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/Event.js

@@ -225,6 +225,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 +241,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 +540,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(