mcdev 5.1.0 → 5.3.0

package/lib/metadataTypes/Automation.js

@@ -25,64 +25,53 @@ class Automation extends MetadataType {
      * @returns {Promise.<TYPE.AutomationMapObj>} Promise of metadata
      */
     static async retrieve(retrieveDir, _, __, key) {
-        /** @type {TYPE.SoapRequestParams} */
-        let requestParams = null;
-        if (key) {
-            requestParams = {
-                filter: {
-                    leftOperand: 'CustomerKey',
-                    operator: 'equals',
-                    rightOperand: key,
-                },
-            };
-        }
-        const results = await this.client.soap.retrieveBulk('Program', ['ObjectID'], requestParams);
-        if (results.Results?.length && !key) {
-            // empty results will come back without "Results" defined
-            Util.logger.info(
-                Util.getGrayMsg(
-                    ` - ${results.Results?.length} automation${
-                        results.Results?.length === 1 ? '' : 's'
-                    } found. Retrieving details...`
-                )
+        let metadataMap;
+        if (key && this._cachedMetadataMap?.[key]) {
+            metadataMap = {};
+            metadataMap[key] = this._cachedMetadataMap[key];
+            delete this._cachedMetadataMap;
+        } else if (!key && this._cachedMetadataMap) {
+            metadataMap = this._cachedMetadataMap;
+            delete this._cachedMetadataMap;
+        } else {
+            /** @type {TYPE.SoapRequestParams} */
+            let requestParams = null;
+            if (key) {
+                requestParams = {
+                    filter: {
+                        leftOperand: 'CustomerKey',
+                        operator: 'equals',
+                        rightOperand: key,
+                    },
+                };
+            }
+            const results = await this.client.soap.retrieveBulk(
+                'Program',
+                ['ObjectID'],
+                requestParams
             );
+            // the API seems to handle 50 concurrent requests nicely
+            const response = results?.Results?.length
+                ? await this.retrieveRESTcollection(
+                      results?.Results.map((item) => ({
+                          id: item.ObjectID,
+                          uri: '/automation/v1/automations/' + item.ObjectID,
+                      })),
+                      50,
+                      !key
+                  )
+                : null;
+            metadataMap = response?.metadata || {};
         }
-        const details = results.Results
-            ? await Promise.all(
-                  results.Results.map(async (a) => {
-                      try {
-                          return await this.client.rest.get(
-                              '/automation/v1/automations/' + a.ObjectID
-                          );
-                      } catch (ex) {
-                          try {
-                              if (ex.message == 'socket hang up') {
-                                  // 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/' + a.ObjectID
-                                  );
-                              }
-                          } 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 ${a.ObjectID}: ${ex.message} ${ex.code}`
-                          );
-                          return null;
-                      }
-                  })
-              )
-            : [];
-        let metadataMap = this.parseResponseBody({ items: details });
 
-        if (Object.keys(metadataMap).length) {
+        if (!this._skipNotificationRetrieve && Object.keys(metadataMap).length) {
             // attach notification information to each automation that has any
             await this.#getAutomationNotificationsREST(metadataMap);
         }
 
         // * retrieveDir can be empty when we use it in the context of postDeployTasks
         if (retrieveDir) {
+            this.retrieveDir = retrieveDir;
             metadataMap = await this.saveResults(metadataMap, retrieveDir, null, null);
             Util.logger.info(
                 `Downloaded: ${this.definition.type} (${Object.keys(metadataMap).length})` +
@@ -94,6 +83,27 @@ class Automation extends MetadataType {
         return { metadata: metadataMap, type: this.definition.type };
     }
 
+    /**
+     * helper for {@link this.retrieveRESTcollection}
+     *
+     * @param {Error} ex exception
+     * @param {string} id id or key of item
+     * @returns {null} -
+     */
+    static async handleRESTErrors(ex, id) {
+        try {
+            if (ex.message == 'socket hang up') {
+                // 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);
+            }
+        } 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}`);
+        return null;
+    }
+
     /**
      * helper for {@link Automation.retrieve} to get Automation Notifications
      *
@@ -144,11 +154,19 @@ class Automation extends MetadataType {
                                 }));
                             found++;
                         } else {
-                            throw new TypeError(JSON.stringify(notificationsResult));
+                            if (
+                                !notificationsResult ||
+                                typeof notificationsResult !== 'object' ||
+                                Object.keys(notificationsResult).length !== 1 ||
+                                !notificationsResult?.programId
+                            ) {
+                                throw new TypeError(JSON.stringify(notificationsResult));
+                            }
+                            // * if there are no automation notifications, the API returns a single object with the programId
                         }
                     } catch (ex) {
                         Util.logger.debug(
-                            ` ☇ skipping Notifications for Automation ${automationLegacy.key}: ${ex.message} ${ex.code}`
+                            ` ☇ issue retrieving Notifications for automation ${automationLegacy.key}: ${ex.message} ${ex.code}`
                         );
                         skipped++;
                     }
@@ -215,12 +233,18 @@ class Automation extends MetadataType {
      * @returns {Promise.<TYPE.AutomationMapObj>} Promise of metadata
      */
     static async retrieveForCache() {
-        // get automations for cache
-        const results = await this.client.soap.retrieveBulk('Program', [
-            'ObjectID',
-            'CustomerKey',
-            'Name',
-        ]);
+        let results = {};
+        if (this._cachedMetadataMap) {
+            results.Results = Object.values(this._cachedMetadataMap);
+            delete this._cachedMetadataMap;
+        } else {
+            // get automations for cache
+            results = await this.client.soap.retrieveBulk('Program', [
+                'ObjectID',
+                'CustomerKey',
+                'Name',
+            ]);
+        }
         const resultsConverted = {};
         if (Array.isArray(results?.Results)) {
             // get encodedAutomationID to retrieve notification information
@@ -237,15 +261,16 @@ class Automation extends MetadataType {
 
             // merge encodedAutomationID into results
             for (const m of results.Results) {
-                resultsConverted[m.CustomerKey] = {
-                    id: m.ObjectID,
-                    key: m.CustomerKey,
-                    name: m.Name,
-                    programId: automationsLegacy.metadata[m.CustomerKey]?.id,
+                const key = m.CustomerKey || m.key;
+                resultsConverted[key] = {
+                    id: m.ObjectID || m.id,
+                    key: key,
+                    name: m.Name || m.name,
+                    programId: automationsLegacy.metadata[key]?.id,
+                    status: automationsLegacy.metadata[key]?.status,
                 };
             }
         }
-
         return { metadata: resultsConverted, type: this.definition.type };
     }
 
@@ -318,6 +343,29 @@ class Automation extends MetadataType {
             throw new Error(JSON.stringify(results));
         }
     }
+    /**
+     * helper for {@link Automation.postRetrieveTasks} and {@link Automation.execute}
+     *
+     * @param {TYPE.AutomationItem} metadata a single automation
+     * @returns {boolean} true if the automation schedule is valid
+     */
+    static #isValidSchedule(metadata) {
+        if (metadata.type === 'scheduled' && metadata.schedule?.startDate) {
+            try {
+                if (this.definition.timeZoneMapping[metadata.schedule.timezoneName]) {
+                    // if we found the id in our list, remove the redundant data
+                    delete metadata.schedule.timezoneId;
+                }
+            } catch {
+                Util.logger.debug(
+                    `- Schedule name '${metadata.schedule.timezoneName}' not found in definition.timeZoneMapping`
+                );
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
     /**
      * manages post retrieve steps
      *
@@ -332,34 +380,24 @@ class Automation extends MetadataType {
             if (metadata.type === 'scheduled' && metadata.schedule?.startDate) {
                 // Starting Source == 'Schedule'
 
-                try {
-                    if (this.definition.timeZoneMapping[metadata.schedule.timezoneName]) {
-                        // if we found the id in our list, remove the redundant data
-                        delete metadata.schedule.timezoneId;
-                    }
-                } catch {
-                    Util.logger.debug(
-                        `- Schedule name '${metadata.schedule.timezoneName}' not found in definition.timeZoneMapping`
-                    );
-                }
-                try {
-                    // type 'Running' is temporary status only, overwrite with Scheduled for storage.
-                    if (metadata.type === 'scheduled' && metadata.status === 'Running') {
-                        metadata.status = 'Scheduled';
-                    }
-                } catch {
-                    Util.logger.error(
-                        `- ${this.definition.type} ${metadata.name} does not have a valid schedule setting.`
-                    );
+                if (!this.#isValidSchedule(metadata)) {
                     return;
                 }
+                // type 'Running' is temporary status only, overwrite with Scheduled for storage.
+                if (metadata.type === 'scheduled' && metadata.status === 'Running') {
+                    metadata.status = 'Scheduled';
+                }
             } else if (metadata.type === 'triggered' && metadata.fileTrigger) {
                 // Starting Source == 'File Drop'
                 // Do nothing for now
             }
             if (metadata.steps) {
+                let i = 0;
+
                 for (const step of metadata.steps) {
-                    const stepNumber = step.stepNumber || step.step;
+                    i++;
+
+                    const stepNumber = step.stepNumber || step.step || i;
                     delete step.stepNumber;
                     delete step.step;
 
@@ -387,18 +425,28 @@ class Automation extends MetadataType {
                             activity.activityObjectId == null
                         ) {
                             Util.logger.debug(
-                                ` - skip parsing of activity due to missing activityObjectId: ${JSON.stringify(
-                                    activity
-                                )}`
+                                ` - skipping ${
+                                    metadata[this.definition.keyField]
+                                } activity ${stepNumber}.${
+                                    activity.displayOrder
+                                } due to missing activityObjectId: ${JSON.stringify(activity)}`
                             );
                             // empty if block
+                            continue;
                         } else if (!this.definition.dependencies.includes(activity.r__type)) {
                             Util.logger.debug(
-                                ` - skip parsing because the type is not set up as a dependecy for ${this.definition.type}`
+                                ` - skipping ${
+                                    metadata[this.definition.keyField]
+                                } activity ${stepNumber}.${
+                                    activity.displayOrder
+                                } because the type ${
+                                    activity.r__type
+                                } is not set up as a dependency for ${this.definition.type}`
                             );
+                            continue;
                         }
                         // / if managed by cache we can update references to support deployment
-                        else if (
+                        if (
                             Definitions[activity.r__type]?.['idField'] &&
                             cache.getCache(this.buObject.mid)[activity.r__type]
                         ) {
@@ -445,6 +493,197 @@ class Automation extends MetadataType {
             return null;
         }
     }
+    /**
+     * a function to start query execution via API
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were executed
+     */
+    static async execute(keyArr) {
+        const metadataMap = {};
+        for (const key of keyArr) {
+            if (Util.OPTIONS.schedule) {
+                // schedule
+                const results = await this.retrieve(undefined, undefined, undefined, key);
+                if (Object.keys(results.metadata).length) {
+                    for (const resultKey of Object.keys(results.metadata)) {
+                        if (this.#isValidSchedule(results.metadata[resultKey])) {
+                            metadataMap[resultKey] = results.metadata[resultKey];
+                        } else {
+                            Util.logger.error(
+                                ` - skipping ${this.definition.type} ${results.metadata[resultKey].name}: no valid schedule settings found.`
+                            );
+                        }
+                    }
+                }
+            } else {
+                // runOnce
+                const objectId = await this.#getObjectIdForSingleRetrieve(key);
+                metadataMap[key] = {};
+                metadataMap[key][this.definition.idField] = objectId;
+                metadataMap[key][this.definition.keyField] = key;
+            }
+        }
+        if (!Object.keys(metadataMap).length) {
+            Util.logger.error(`No ${this.definition.type} to execute`);
+            return false;
+        }
+        Util.logger.info(
+            `Starting automations ${
+                Util.OPTIONS.schedule
+                    ? 'according to schedule'
+                    : 'to run once (use --schedule or --execute=schedule to schedule instead)'
+            }: ${Object.keys(metadataMap).length}`
+        );
+        const promiseResults = [];
+        for (const key of Object.keys(metadataMap)) {
+            if (Util.OPTIONS.schedule && metadataMap[key].status === 'Scheduled') {
+                // schedule
+                Util.logger.info(
+                    ` - skipping ${this.definition.type} ${metadataMap[key].name}: already scheduled.`
+                );
+            } else {
+                // schedule + runOnce
+                promiseResults.push(this.#executeItem(metadataMap, key));
+            }
+        }
+        const results = await Promise.all(promiseResults);
+        const executedKeyArr = results
+            .filter(Boolean)
+            .filter((r) => r.response.OverallStatus === 'OK')
+            .map((r) => r.key);
+        Util.logger.info(`Executed ${executedKeyArr.length} of ${keyArr.length} items`);
+        return executedKeyArr;
+    }
+    /**
+     * helper for {@link Automation.execute}
+     *
+     * @param {TYPE.AutomationMap} metadataMap map of metadata
+     * @param {string} key key of the metadata
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
+     */
+    static async #executeItem(metadataMap, key) {
+        if (Util.OPTIONS.schedule) {
+            this.#preDeploySchedule(metadataMap[key]);
+            metadataMap[key].status = 'Scheduled';
+            return this.#scheduleAutomation(metadataMap, metadataMap, key);
+        } else {
+            return this.#runOnce(metadataMap[key]);
+        }
+    }
+
+    /**
+     * helper for {@link Automation.execute}
+     *
+     * @param {TYPE.AutomationItem} metadataEntry metadata object
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
+     */
+    static async #runOnce(metadataEntry) {
+        return super.executeSOAP(metadataEntry);
+    }
+
+    /**
+     *  Standardizes a check for multiple messages but adds query specific filters to error texts
+     *
+     * @param {object} ex response payload from REST API
+     * @returns {string[] | void} formatted Error Message
+     */
+    static getErrorsREST(ex) {
+        const errors = super.getErrorsREST(ex);
+        if (errors?.length > 0) {
+            return errors.map((msg) =>
+                msg
+                    .split('403 Forbidden')
+                    .join('403 Forbidden: Please check if the automation is currently running.')
+            );
+        }
+        return errors;
+    }
+
+    /**
+     * a function to start query execution via API
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<string[]>} Returns list of keys that were paused
+     */
+    static async pause(keyArr) {
+        const metadataMap = {};
+        for (const key of keyArr) {
+            if (key) {
+                const results = await this.retrieve(undefined, undefined, undefined, key);
+                if (Object.keys(results.metadata).length) {
+                    for (const key of Object.keys(results.metadata)) {
+                        if (this.#isValidSchedule(results.metadata[key])) {
+                            metadataMap[key] = results.metadata[key];
+                        } else {
+                            Util.logger.error(
+                                ` - skipping ${this.definition.type} ${results.metadata[key].name}: no valid schedule settings found.`
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        Util.logger.info(`Pausing automations: ${Object.keys(metadataMap).length}`);
+        const promiseResults = [];
+        for (const key of Object.keys(metadataMap)) {
+            if (metadataMap[key].status === 'Scheduled') {
+                promiseResults.push(this.#pauseItem(metadataMap[key]));
+            } else if (metadataMap[key].status === 'PausedSchedule') {
+                Util.logger.info(
+                    ` - skipping ${this.definition.type} ${metadataMap[key].name}: already paused.`
+                );
+            } else {
+                Util.logger.error(
+                    ` - skipping ${this.definition.type} ${
+                        metadataMap[key].name
+                    }: currently ${metadataMap[
+                        key
+                    ].status.toLowerCase()}. Please try again in a few minutes.`
+                );
+            }
+        }
+        const pausedKeyArr = (await Promise.all(promiseResults))
+            .filter(Boolean)
+            .filter((r) => r.response.OverallStatus === 'OK')
+            .map((r) => r.key);
+
+        Util.logger.info(`Paused ${pausedKeyArr.length} of ${keyArr.length} items`);
+        return pausedKeyArr;
+    }
+
+    /**
+     * helper for {@link Automation.pause}
+     *
+     * @param {TYPE.AutomationItem} metadata automation metadata
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
+     */
+    static async #pauseItem(metadata) {
+        const schedule = {};
+        try {
+            const response = await this.client.soap.schedule(
+                'Automation',
+                schedule,
+                {
+                    Interaction: {
+                        ObjectID: metadata[this.definition.idField],
+                    },
+                },
+                'pause',
+                {}
+            );
+            Util.logger.info(
+                ` - paused ${this.definition.type}: ${metadata[this.definition.keyField]} / ${
+                    metadata[this.definition.nameField]
+                }`
+            );
+            return { key: metadata[this.definition.keyField], response };
+        } catch (ex) {
+            this._handleSOAPErrors(ex, 'pausing', metadata, false);
+            return null;
+        }
+    }
 
     /**
      * Deploys automation - the saved file is the original one due to large differences required for deployment
@@ -452,11 +691,10 @@ class Automation extends MetadataType {
      * @param {TYPE.AutomationMap} metadata metadata mapped by their keyField
      * @param {string} targetBU name/shorthand of target businessUnit for mapping
      * @param {string} retrieveDir directory where metadata after deploy should be saved
-     * @param {boolean} [isRefresh] optional flag - so far not used by automation
      * @returns {Promise.<TYPE.AutomationMap>} Promise
      */
-    static async deploy(metadata, targetBU, retrieveDir, isRefresh) {
-        const upsertResults = await this.upsert(metadata, targetBU, isRefresh);
+    static async deploy(metadata, targetBU, retrieveDir) {
+        const upsertResults = await this.upsert(metadata, targetBU);
         const savedMetadata = await this.saveResults(upsertResults, retrieveDir, null);
         if (
             this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type) &&
@@ -488,11 +726,47 @@ class Automation extends MetadataType {
      * @returns {Promise} Promise
      */
     static update(metadata, metadataBefore) {
-        metadata.id = metadataBefore.id;
+        if (metadataBefore.status === 'Running') {
+            Util.logger.error(
+                ` ☇ error updating ${this.definition.type} ${
+                    metadata[this.definition.keyField] || metadata[this.definition.nameField]
+                } / ${
+                    metadata[this.definition.nameField]
+                }: You cannot update an automation that's currently running. Please wait a bit and retry.`
+            );
+            return null;
+        }
         const uri = '/automation/v1/automations/' + metadata.id;
         return super.updateREST(metadata, uri);
     }
 
+    /**
+     * helper for {@link Automation.preDeployTasks} and {@link Automation.execute}
+     *
+     * @param {TYPE.AutomationItem} metadata metadata mapped by their keyField
+     */
+    static #preDeploySchedule(metadata) {
+        delete metadata.schedule.rangeTypeId;
+        delete metadata.schedule.pattern;
+        delete metadata.schedule.scheduledTime;
+        delete metadata.schedule.scheduledStatus;
+        if (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`
+            );
+        }
+
+        // the upsert API needs this to be named scheduleTypeId; the retrieve API returns it as typeId
+        metadata.schedule.scheduleTypeId = metadata.schedule.typeId;
+        delete metadata.schedule.typeId;
+
+        // prep startSource
+        metadata.startSource = { schedule: metadata.schedule, typeId: 1 };
+    }
+
     /**
      * Gets executed before deploying metadata
      *
@@ -516,25 +790,12 @@ class Automation extends MetadataType {
             if (metadata.type === 'scheduled' && metadata?.schedule?.startDate) {
                 // Starting Source == 'Schedule'
 
-                delete metadata.schedule.rangeTypeId;
-                delete metadata.schedule.pattern;
-                delete metadata.schedule.scheduledTime;
-                delete metadata.schedule.scheduledStatus;
-                if (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`
-                    );
-                }
-                delete metadata.schedule.timezoneName;
-                // the upsert API needs this to be named scheduleTypeId; the retrieve API returns it as typeId
-                metadata.schedule.scheduleTypeId = metadata.schedule.typeId;
-                delete metadata.schedule.typeId;
+                this.#preDeploySchedule(metadata);
+                // * run _buildSchedule here but only to check if things look ok - do not use the returned schedule object for deploy
+                this._buildSchedule(metadata.schedule);
 
-                // prep startSource
-                metadata.startSource = { schedule: metadata.schedule, typeId: 1 };
+                delete metadata.schedule.timezoneName;
+                delete metadata.startSource.schedule.timezoneName;
             } else if (metadata.type === 'triggered' && metadata.fileTrigger) {
                 // Starting Source == 'File Drop'
 
@@ -553,6 +814,7 @@ class Automation extends MetadataType {
             delete metadata.schedule;
             delete metadata.type;
             let i = 0;
+            const buName = this.buObject.credential + '/' + this.buObject.businessUnit;
             if (metadata.steps) {
                 for (const step of metadata.steps) {
                     let displayOrder = 0;
@@ -562,6 +824,23 @@ class Automation extends MetadataType {
                             activity.name &&
                             this.definition.dependencies.includes(activity.r__type)
                         ) {
+                            if (
+                                activity.r__type === 'verification' &&
+                                this.createdKeyMap?.[buName]?.verification?.[activity.name]
+                            ) {
+                                Util.logger.info(
+                                    Util.getGrayMsg(
+                                        ` - updated verification activity name from ${
+                                            activity.name
+                                        } to ${
+                                            this.createdKeyMap[buName].verification[activity.name]
+                                        }`
+                                    )
+                                );
+                                // map structure: cred/bu --> type --> old key --> new key
+                                activity.name =
+                                    this.createdKeyMap[buName].verification[activity.name];
+                            }
                             // automations can have empty placeholder for activities with only their type defined
                             activity.activityObjectId = cache.searchForField(
                                 activity.r__type,
@@ -632,6 +911,16 @@ class Automation extends MetadataType {
         }
         return deployable;
     }
+    /**
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP} that removes old files after the key was changed
+     *
+     * @private
+     * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
+     * @returns {void}
+     */
+    static async _postChangeKeyTasks(metadataEntry) {
+        super._postChangeKeyTasks(metadataEntry, true);
+    }
 
     /**
      * Gets executed after deployment of metadata type
@@ -642,21 +931,53 @@ class Automation extends MetadataType {
      */
     static async postDeployTasks(metadataMap, originalMetadataMap) {
         for (const key in metadataMap) {
+            const item = metadataMap[key];
+
+            const oldKey = Util.changedKeysMap?.[this.definition.type]?.[key] || key;
+            delete Util.changedKeysMap?.[this.definition.type]?.[key];
+
+            if (!item.type) {
+                // create response does not return the type attribute
+
+                const scheduleHelper = item.schedule || item.startSource.schedule;
+
+                // el.type
+                item.type = scheduleHelper
+                    ? 'scheduled'
+                    : item.fileTrigger
+                    ? 'triggered'
+                    : undefined;
+
+                // el.schedule.timezoneName
+                if (item.type === 'scheduled') {
+                    // not existing for triggered automations
+                    scheduleHelper.timezoneName ||= Util.inverseGet(
+                        this.definition.timeZoneMapping,
+                        scheduleHelper.timezoneId
+                    );
+                }
+
+                // el.status
+                item.status ||= Util.inverseGet(this.definition.statusMapping, item.statusId);
+            }
             // need to put schedule on here if status is scheduled
-            await Automation.#scheduleAutomation(metadataMap, originalMetadataMap, key);
+            await Automation.#scheduleAutomation(metadataMap, originalMetadataMap, key, oldKey);
 
             // need to update notifications separately if there are any
             await Automation.#updateNotificationInfoREST(metadataMap, key);
 
             // rewrite upsert to retrieve fields
-            const metadata = metadataMap[key];
-            if (metadata.steps) {
-                for (const step of metadata.steps) {
+            if (item.steps) {
+                for (const step of item.steps) {
                     step.name = step.annotation;
                     delete step.annotation;
                 }
             }
         }
+        if (Util.OPTIONS.execute || Util.OPTIONS.schedule) {
+            Util.logger.info(`Executing: ${this.definition.type}`);
+            await this.execute(Object.keys(metadataMap));
+        }
     }
     /**
      * helper for {@link Automation.postDeployTasks}
@@ -706,22 +1027,26 @@ class Automation extends MetadataType {
     }
 
     /**
-     * helper for {@link postDeployTasks}
+     * helper for {@link Automation.postDeployTasks}
      *
      * @param {TYPE.AutomationMap} metadataMap metadata mapped by their keyField
      * @param {TYPE.AutomationMap} originalMetadataMap metadata to be updated (contains additioanl fields)
      * @param {string} key current customer key
+     * @param {string} [oldKey] old customer key before fixKey / changeKeyValue / changeKeyField
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
      */
-    static async #scheduleAutomation(metadataMap, originalMetadataMap, key) {
-        if (originalMetadataMap[key]?.type === 'scheduled') {
+    static async #scheduleAutomation(metadataMap, originalMetadataMap, key, oldKey) {
+        let response = null;
+        oldKey ||= key;
+        if (originalMetadataMap[oldKey]?.type === 'scheduled') {
             // Starting Source == 'Schedule': Try starting the automation
-            if (originalMetadataMap[key].status === 'Scheduled') {
+            if (originalMetadataMap[oldKey].status === 'Scheduled') {
                 let schedule = null;
                 try {
-                    schedule = this._buildSchedule(originalMetadataMap[key].schedule);
+                    schedule = this._buildSchedule(originalMetadataMap[oldKey].schedule);
                 } catch (ex) {
                     Util.logger.error(
-                        `- Could not create schedule for automation '${originalMetadataMap[key].name}' to start it: ${ex.message}`
+                        `- Could not create schedule for automation '${originalMetadataMap[oldKey].name}' to start it: ${ex.message}`
                     );
                 }
                 if (schedule !== null) {
@@ -734,12 +1059,12 @@ class Automation extends MetadataType {
                         const schedule_timezoneString = schedule._timezoneString;
                         delete schedule._timezoneString;
                         // start the automation
-                        await this.client.soap.schedule(
+                        response = await this.client.soap.schedule(
                             'Automation',
                             schedule,
                             {
                                 Interaction: {
-                                    ObjectID: metadataMap[key].id,
+                                    ObjectID: metadataMap[key][this.definition.idField],
                                 },
                             },
                             'start',
@@ -753,21 +1078,22 @@ class Automation extends MetadataType {
                                   (schedule_interval > 1 ? 's' : ''));
                         Util.logger.warn(
                             ` - scheduled automation '${
-                                originalMetadataMap[key].name
+                                originalMetadataMap[oldKey].name
                             }' deployed as Active: runs every ${intervalString} starting ${
                                 schedule_StartDateTime.split('T').join(' ').split('.')[0]
                             } ${schedule_timezoneString}`
                         );
-                    } catch (ex) {
+                    } catch {
+                        // API does not return anything usefull here. We have to know the rules instead
                         Util.logger.error(
-                            `- Could not start scheduled automation '${originalMetadataMap[key].name}': ${ex.message}`
+                            ` ☇ error starting scheduled ${this.definition.type}${key}: Please check schedule settings`
                         );
                     }
                 }
             } else {
                 Util.logger.info(
                     Util.getGrayMsg(
-                        ` - scheduled automation '${originalMetadataMap[key].name}' deployed as Paused`
+                        ` - scheduled automation '${originalMetadataMap[oldKey].name}' deployed as Paused`
                     )
                 );
             }
@@ -781,6 +1107,7 @@ class Automation extends MetadataType {
             metadataMap[key].schedule.typeId = metadataMap[key].schedule.scheduleTypeId;
             delete metadataMap[key].schedule.scheduleTypeId;
         }
+        return { key, response };
     }
 
     /**
@@ -867,6 +1194,9 @@ class Automation extends MetadataType {
             const a = obj.split('=');
             recurHelper[a[0]] = a[1];
         }
+        if (recurHelper.INTERVAL) {
+            recurHelper.INTERVAL = Number.parseInt(recurHelper.INTERVAL);
+        }
         // the ical schedule is all in caps but soap objects require Title Case.
         const keyStem = recurHelper.FREQ.charAt(0) + recurHelper.FREQ.slice(1, -2).toLowerCase();
 
@@ -895,13 +1225,18 @@ class Automation extends MetadataType {
                 'Scheduling automatically not supported for Weekly, Monthly and Yearly, please configure manually.'
             );
         }
+        if (recurHelper.FREQ === 'MINUTELY' && recurHelper.INTERVAL && recurHelper.INTERVAL < 5) {
+            throw new Error(
+                '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];
         } else {
-            Util.logger.error(
-                `- Could not find timezone ${scheduleObject.timezoneName} in definition.timeZoneMapping`
+            throw new Error(
+                `Could not find timezone ${scheduleObject.timezoneName} in definition.timeZoneMapping`
             );
         }
         schedule.TimeZone.ID = scheduleObject.timezoneId;
@@ -995,8 +1330,8 @@ class Automation extends MetadataType {
         // create new Date object reflecting SFMC's servertime
         const dateServer = new Date(utc + 3600000 * offsetServer);
 
-        // return time as a string without trailing "Z"
-        return dateServer.toISOString().slice(0, -1);
+        // return time as a string without trailing "Z" and without miliseconds (separated by .)
+        return dateServer.toISOString().slice(0, -1).split('.')[0];
     }
     /**
      * Experimental: Only working for DataExtensions:
@@ -1023,7 +1358,7 @@ class Automation extends MetadataType {
         const automationType = { scheduled: 'Schedule', triggered: 'File Drop' };
         output += `**Started by:** ${automationType[json.type] || 'Not defined'}\n\n`;
         output += `**Status:** ${json.status}\n\n`;
-        if (json.type === 'scheduled') {
+        if (json.type === 'scheduled' || json.schedule) {
             const tz =
                 this.definition.timeZoneDifference[
                     this.definition.timeZoneMapping[json?.schedule?.timezoneName]
@@ -1033,7 +1368,7 @@ class Automation extends MetadataType {
                 output += `**Schedule:**\n\n`;
                 output += `* Start: ${json.schedule.startDate.split('T').join(' ')} ${tz}\n`;
                 output += `* End: ${json.schedule.endDate.split('T').join(' ')} ${tz}\n`;
-                output += `* Timezone:  ${json.schedule.timezoneName}\n`;
+                output += `* Timezone: ${json.schedule.timezoneName}\n`;
 
                 const ical = {};
                 for (const item of json.schedule.icalRecur.split(';')) {
@@ -1042,9 +1377,20 @@ class Automation extends MetadataType {
                 }
                 const frequency = ical.FREQ.slice(0, -2).toLowerCase();
 
-                output += `* Recurrance: every ${ical.INTERVAL > 1 ? ical.INTERVAL : ''} ${
-                    frequency === 'dai' ? 'day' : frequency
-                }${ical.INTERVAL > 1 ? 's' : ''} ${ical.COUNT ? `for ${ical.COUNT} times` : ''}\n`;
+                output += `* Recurrance: `;
+                output +=
+                    ical.COUNT == 1
+                        ? 'run only once'
+                        : `every${ical.INTERVAL > 1 ? ' ' + ical.INTERVAL : ''} ${
+                              frequency === 'dai' ? 'day' : frequency
+                          }${ical.INTERVAL > 1 ? 's' : ''}${
+                              ical.COUNT
+                                  ? ` for ${ical.COUNT} times`
+                                  : ical.UNTIL
+                                  ? ' until end date'
+                                  : ''
+                          }`;
+                output += '\n';
             } else if (json.schedule) {
                 output += `**Schedule:** Not defined\n`;
             }
@@ -1224,7 +1570,7 @@ class Automation extends MetadataType {
      * @param {string} key customer key
      * @returns {Promise.<string>} objectId or enpty string
      */
-    static async _getObjectIdForSingleRetrieve(key) {
+    static async #getObjectIdForSingleRetrieve(key) {
         const response = await this.client.soap.retrieve('Program', ['ObjectID'], {
             filter: {
                 leftOperand: 'CustomerKey',
@@ -1243,7 +1589,7 @@ class Automation extends MetadataType {
      */
     static async deleteByKey(customerKey) {
         // the delete endpoint returns a general exception if the automation does not exist; handle it gracefully instead by adding a retrieve first
-        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
+        const objectId = customerKey ? await this.#getObjectIdForSingleRetrieve(customerKey) : null;
         if (!objectId) {
             Util.logger.error(` - automation not found`);
             return false;