mcdev 6.0.2 → 7.0.0

package/lib/metadataTypes/Automation.js

@@ -1,13 +1,34 @@
 'use strict';
 
 import MetadataType from './MetadataType.js';
-import TYPE from '../../types/mcdev.d.js';
 import { Util } from '../util/util.js';
 import File from '../util/file.js';
 import Definitions from '../MetadataTypeDefinitions.js';
 import cache from '../util/cache.js';
 import pLimit from 'p-limit';
 
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SDKError} SDKError
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ */
+/**
+ * @typedef {import('../../types/mcdev.d.js').AutomationItem} AutomationItem
+ * @typedef {import('../../types/mcdev.d.js').AutomationItemObj} AutomationItemObj
+ * @typedef {import('../../types/mcdev.d.js').AutomationMap} AutomationMap
+ * @typedef {import('../../types/mcdev.d.js').AutomationMapObj} AutomationMapObj
+ * @typedef {import('../../types/mcdev.d.js').AutomationSchedule} AutomationSchedule
+ * @typedef {import('../../types/mcdev.d.js').AutomationScheduleSoap} AutomationScheduleSoap
+ */
+
 /**
  * Automation MetadataType
  *
@@ -15,14 +36,18 @@ import pLimit from 'p-limit';
  */
 class Automation extends MetadataType {
     static notificationUpdates = {};
+    static createdKeyMap;
+    static _skipNotificationRetrieve = false;
+    /** @type {AutomationMap} */
+    static _cachedMetadataMap;
     /**
      * Retrieves Metadata of Automation
      *
-     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {string} [retrieveDir] Directory where retrieved metadata directory will be saved
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<TYPE.AutomationMapObj>} Promise of metadata
+     * @returns {Promise.<AutomationMapObj>} Promise of metadata
      */
     static async retrieve(retrieveDir, _, __, key) {
         let metadataMap;
@@ -34,9 +59,12 @@ class Automation extends MetadataType {
             metadataMap = this._cachedMetadataMap;
             delete this._cachedMetadataMap;
         } else {
-            /** @type {TYPE.SoapRequestParams} */
+            /** @type {SoapRequestParams} */
             let requestParams = null;
-            if (key) {
+            const objectIds = [];
+            if (key?.startsWith('id:')) {
+                objectIds.push(key.slice(3));
+            } else if (key) {
                 requestParams = {
                     filter: {
                         leftOperand: 'CustomerKey',
@@ -50,12 +78,16 @@ class Automation extends MetadataType {
                 ['ObjectID'],
                 requestParams
             );
+            if (results?.Results?.length) {
+                objectIds.push(...results.Results.map((item) => item.ObjectID));
+            }
+
             // the API seems to handle 50 concurrent requests nicely
-            const response = results?.Results?.length
+            const response = objectIds.length
                 ? await this.retrieveRESTcollection(
-                      results?.Results.map((item) => ({
-                          id: item.ObjectID,
-                          uri: '/automation/v1/automations/' + item.ObjectID,
+                      objectIds.map((objectID) => ({
+                          id: objectID,
+                          uri: '/automation/v1/automations/' + objectID,
                       })),
                       50,
                       !key
@@ -86,9 +118,9 @@ class Automation extends MetadataType {
     /**
      * helper for {@link this.retrieveRESTcollection}
      *
-     * @param {Error} ex exception
+     * @param {SDKError} ex exception
      * @param {string} id id or key of item
-     * @returns {null} -
+     * @returns {Promise.<any>} can return retry-result
      */
     static async handleRESTErrors(ex, id) {
         try {
@@ -107,9 +139,8 @@ class Automation extends MetadataType {
     /**
      * helper for {@link Automation.retrieve} to get Automation Notifications
      *
-     * @private
-     * @param {TYPE.MetadataTypeMap} metadataMap keyField => metadata map
-     * @returns {Promise.<void>} Promise of nothing
+     * @param {MetadataTypeMap} metadataMap keyField => metadata map
+     * @returns {Promise.<object>} Promise of automation legacy api response
      */
     static async #getAutomationNotificationsREST(metadataMap) {
         Util.logger.info(Util.getGrayMsg(` Retrieving Automation Notification information...`));
@@ -185,7 +216,7 @@ class Automation extends MetadataType {
     /**
      * Retrieves Metadata of Automation
      *
-     * @returns {Promise.<TYPE.AutomationMapObj>} Promise of metadata
+     * @returns {Promise.<AutomationMapObj>} Promise of metadata
      */
     static async retrieveChangelog() {
         const results = await this.client.soap.retrieveBulk('Program', ['ObjectID']);
@@ -230,7 +261,7 @@ class Automation extends MetadataType {
     /**
      * Retrieves automation metadata for caching
      *
-     * @returns {Promise.<TYPE.AutomationMapObj>} Promise of metadata
+     * @returns {Promise.<AutomationMapObj>} Promise of metadata
      */
     static async retrieveForCache() {
         let results = {};
@@ -245,6 +276,7 @@ class Automation extends MetadataType {
                 'Name',
             ]);
         }
+        /** @type {AutomationMap} */
         const resultsConverted = {};
         if (Array.isArray(results?.Results)) {
             // get encodedAutomationID to retrieve notification information
@@ -279,8 +311,8 @@ class Automation extends MetadataType {
      *
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
-     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
-     * @returns {Promise.<TYPE.AutomationItemObj>} Promise of metadata
+     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<AutomationItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
         const results = await this.client.soap.retrieve('Program', ['ObjectID', 'Name'], {
@@ -319,7 +351,7 @@ class Automation extends MetadataType {
                     );
                 }
             } catch {
-                val = JSON.parse(JSON.stringify(details));
+                val = structuredClone(details);
             }
             if (val === null) {
                 throw new Error(
@@ -346,7 +378,7 @@ class Automation extends MetadataType {
     /**
      * helper for {@link Automation.postRetrieveTasks} and {@link Automation.execute}
      *
-     * @param {TYPE.AutomationItem} metadata a single automation
+     * @param {AutomationItem} metadata a single automation
      * @returns {boolean} true if the automation schedule is valid
      */
     static #isValidSchedule(metadata) {
@@ -369,8 +401,8 @@ class Automation extends MetadataType {
     /**
      * manages post retrieve steps
      *
-     * @param {TYPE.AutomationItem} metadata a single automation
-     * @returns {TYPE.AutomationItem | void} parsed item
+     * @param {AutomationItem} metadata a single automation
+     * @returns {AutomationItem | void} parsed item
      */
     static postRetrieveTasks(metadata) {
         // folder
@@ -448,23 +480,16 @@ class Automation extends MetadataType {
                         // / if managed by cache we can update references to support deployment
                         if (
                             Definitions[activity.r__type]?.['idField'] &&
-                            cache.getCache(this.buObject.mid)[activity.r__type]
+                            cache.getCache()[activity.r__type]
                         ) {
                             try {
-                                // this will override the name returned by the API in case this activity's name was changed since the automation was last updated, keeping things nicely in sync for mcdev
-                                const name = cache.searchForField(
+                                activity.r__key = cache.searchForField(
                                     activity.r__type,
                                     activity.activityObjectId,
                                     Definitions[activity.r__type].idField,
-                                    Definitions[activity.r__type].nameField
+                                    Definitions[activity.r__type].keyField
                                 );
-                                if (name !== activity.name) {
-                                    Util.logger.debug(
-                                        ` - updated name of step ${stepNumber}.${activity.displayOrder}` +
-                                            ` in Automation '${metadata.name}' from ${activity.name} to ${name}`
-                                    );
-                                    activity.name = name;
-                                }
+                                delete activity.name;
                             } catch (ex) {
                                 // getFromCache throws error where the dependent metadata is not found
                                 Util.logger.warn(
@@ -483,7 +508,7 @@ class Automation extends MetadataType {
                     }
                 }
             }
-            return JSON.parse(JSON.stringify(metadata));
+            return structuredClone(metadata);
         } catch (ex) {
             Util.logger.warn(
                 ` - ${this.definition.typeName} '${metadata[this.definition.nameField]}': ${
@@ -500,6 +525,7 @@ class Automation extends MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were executed
      */
     static async execute(keyArr) {
+        /** @type {AutomationMap} */
         const metadataMap = {};
         for (const key of keyArr) {
             if (Util.OPTIONS.schedule) {
@@ -519,14 +545,13 @@ class Automation extends MetadataType {
             } else {
                 // runOnce
                 const objectId = await this.#getObjectIdForSingleRetrieve(key);
-                metadataMap[key] = {};
-                metadataMap[key][this.definition.idField] = objectId;
-                metadataMap[key][this.definition.keyField] = key;
+                /** @type {AutomationItem} */
+                metadataMap[key] = { key, id: objectId };
             }
         }
         if (!Object.keys(metadataMap).length) {
             Util.logger.error(`No ${this.definition.type} to execute`);
-            return false;
+            return;
         }
         Util.logger.info(
             `Starting automations ${
@@ -558,7 +583,7 @@ class Automation extends MetadataType {
     /**
      * helper for {@link Automation.execute}
      *
-     * @param {TYPE.AutomationMap} metadataMap map of metadata
+     * @param {AutomationMap} metadataMap map of metadata
      * @param {string} key key of the metadata
      * @returns {Promise.<{key:string, response:object}>} metadata key and API response
      */
@@ -575,7 +600,7 @@ class Automation extends MetadataType {
     /**
      * helper for {@link Automation.execute}
      *
-     * @param {TYPE.AutomationItem} metadataEntry metadata object
+     * @param {AutomationItem} metadataEntry metadata object
      * @returns {Promise.<{key:string, response:object}>} metadata key and API response
      */
     static async #runOnce(metadataEntry) {
@@ -586,7 +611,7 @@ class Automation extends MetadataType {
      *  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
+     * @returns {string[]} formatted Error Message
      */
     static getErrorsREST(ex) {
         const errors = super.getErrorsREST(ex);
@@ -656,7 +681,7 @@ class Automation extends MetadataType {
     /**
      * helper for {@link Automation.pause}
      *
-     * @param {TYPE.AutomationItem} metadata automation metadata
+     * @param {AutomationItem} metadata automation metadata
      * @returns {Promise.<{key:string, response:object}>} metadata key and API response
      */
     static async #pauseItem(metadata) {
@@ -688,10 +713,10 @@ class Automation extends MetadataType {
     /**
      * Deploys automation - the saved file is the original one due to large differences required for deployment
      *
-     * @param {TYPE.AutomationMap} metadata metadata mapped by their keyField
+     * @param {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
-     * @returns {Promise.<TYPE.AutomationMap>} Promise
+     * @returns {Promise.<AutomationMap>} Promise
      */
     static async deploy(metadata, targetBU, retrieveDir) {
         const upsertResults = await this.upsert(metadata, targetBU);
@@ -710,7 +735,7 @@ class Automation extends MetadataType {
     /**
      * Creates a single automation
      *
-     * @param {TYPE.AutomationItem} metadata single metadata entry
+     * @param {AutomationItem} metadata single metadata entry
      * @returns {Promise} Promise
      */
     static create(metadata) {
@@ -721,8 +746,8 @@ class Automation extends MetadataType {
     /**
      * Updates a single automation
      *
-     * @param {TYPE.AutomationItem} metadata single metadata entry
-     * @param {TYPE.AutomationItem} metadataBefore metadata mapped by their keyField
+     * @param {AutomationItem} metadata single metadata entry
+     * @param {AutomationItem} metadataBefore metadata mapped by their keyField
      * @returns {Promise} Promise
      */
     static update(metadata, metadataBefore) {
@@ -743,7 +768,7 @@ class Automation extends MetadataType {
     /**
      * helper for {@link Automation.preDeployTasks} and {@link Automation.execute}
      *
-     * @param {TYPE.AutomationItem} metadata metadata mapped by their keyField
+     * @param {AutomationItem} metadata metadata mapped by their keyField
      */
     static #preDeploySchedule(metadata) {
         delete metadata.schedule.rangeTypeId;
@@ -770,14 +795,14 @@ class Automation extends MetadataType {
     /**
      * Gets executed before deploying metadata
      *
-     * @param {TYPE.AutomationItem} metadata metadata mapped by their keyField
-     * @returns {Promise.<TYPE.AutomationItem>} Promise
+     * @param {AutomationItem} metadata metadata mapped by their keyField
+     * @returns {Promise.<AutomationItem>} Promise
      */
     static async preDeployTasks(metadata) {
         if (metadata.notifications) {
             this.notificationUpdates[metadata.key] = metadata.notifications;
         } else {
-            const cached = cache.getByKey(metadata.key);
+            const cached = cache.getByKey(this.definition.type, metadata.key);
             if (cached?.notifications) {
                 // if notifications existed but are no longer present in the deployment package, we need to run an empty update call to remove them
                 this.notificationUpdates[metadata.key] = [];
@@ -802,8 +827,8 @@ class Automation extends MetadataType {
                 // prep startSource
                 metadata.startSource = {
                     fileDrop: {
-                        filenamePattern: metadata.fileTrigger.fileNamingPattern,
-                        filenamePatternTypeId: metadata.fileTrigger.fileNamePatternTypeId,
+                        fileNamePattern: metadata.fileTrigger.fileNamingPattern,
+                        fileNamePatternTypeId: metadata.fileTrigger.fileNamePatternTypeId,
                         folderLocation: metadata.fileTrigger.folderLocationText,
                         queueFiles: metadata.fileTrigger.queueFiles,
                     },
@@ -844,8 +869,8 @@ class Automation extends MetadataType {
                             // automations can have empty placeholder for activities with only their type defined
                             activity.activityObjectId = cache.searchForField(
                                 activity.r__type,
-                                activity.name,
-                                Definitions[activity.r__type].nameField,
+                                activity.r__key,
+                                Definitions[activity.r__type].keyField,
                                 Definitions[activity.r__type].idField
                             );
                         }
@@ -869,7 +894,7 @@ class Automation extends MetadataType {
      * Validates the automation to be sure it can be deployed.
      * Whitelisted Activites are deployed but require configuration
      *
-     * @param {TYPE.AutomationItem} metadata single automation record
+     * @param {AutomationItem} metadata single automation record
      * @returns {boolean} result if automation can be deployed based on steps
      */
     static validateDeployMetadata(metadata) {
@@ -914,9 +939,8 @@ class Automation extends MetadataType {
     /**
      * 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}
+     * @param {MetadataTypeItem} metadataEntry a single metadata Entry
+     * @returns {Promise.<void>} -
      */
     static async _postChangeKeyTasks(metadataEntry) {
         super._postChangeKeyTasks(metadataEntry, true);
@@ -925,8 +949,8 @@ class Automation extends MetadataType {
     /**
      * Gets executed after deployment of metadata type
      *
-     * @param {TYPE.AutomationMap} metadataMap metadata mapped by their keyField
-     * @param {TYPE.AutomationMap} originalMetadataMap metadata to be updated (contains additioanl fields)
+     * @param {AutomationMap} metadataMap metadata mapped by their keyField
+     * @param {AutomationMap} originalMetadataMap metadata to be updated (contains additioanl fields)
      * @returns {Promise.<void>} -
      */
     static async postDeployTasks(metadataMap, originalMetadataMap) {
@@ -957,7 +981,7 @@ class Automation extends MetadataType {
                     );
                 }
 
-                // el.status
+                // @ts-expect-error - string vs enum
                 item.status ||= Util.inverseGet(this.definition.statusMapping, item.statusId);
             }
             // need to put schedule on here if status is scheduled
@@ -982,7 +1006,7 @@ class Automation extends MetadataType {
     /**
      * helper for {@link Automation.postDeployTasks}
      *
-     * @param {TYPE.AutomationMap} metadataMap metadata mapped by their keyField
+     * @param {AutomationMap} metadataMap metadata mapped by their keyField
      * @param {string} key current customer key
      * @returns {Promise.<void>} -
      */
@@ -1029,8 +1053,8 @@ class Automation extends MetadataType {
     /**
      * 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 {AutomationMap} metadataMap metadata mapped by their keyField
+     * @param {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
@@ -1113,7 +1137,7 @@ class Automation extends MetadataType {
     /**
      * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
+     * @param {MetadataTypeItem} metadata a single script activity definition
      */
     static setFolderPath(metadata) {
         const folderIdField = metadata[this.definition.folderIdField]
@@ -1148,7 +1172,7 @@ class Automation extends MetadataType {
     /**
      * automation-specific script that retrieves the folder ID from cache and updates the given metadata with it before deploy
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single item
+     * @param {MetadataTypeItem} metadata a single item
      */
     static setFolderId(metadata) {
         try {
@@ -1179,14 +1203,19 @@ class Automation extends MetadataType {
      * Builds a schedule object to be used for scheduling an automation
      * based on combination of ical string and start/end dates.
      *
-     * @param {TYPE.AutomationSchedule} scheduleObject child of automation metadata used for scheduling
-     * @returns {TYPE.AutomationScheduleSoap} Schedulable object for soap API (currently not rest supported)
+     * @param {AutomationSchedule} scheduleObject child of automation metadata used for scheduling
+     * @returns {AutomationScheduleSoap} Schedulable object for soap API (currently not rest supported)
      */
     static _buildSchedule(scheduleObject) {
         /**
-         * @type {TYPE.AutomationScheduleSoap}
+         * @type {AutomationScheduleSoap}
          */
-        const schedule = { Recurrence: {}, TimeZone: { IDSpecified: true } };
+        const schedule = {
+            Recurrence: {},
+            TimeZone: { ID: null, IDSpecified: true },
+            RecurrenceRangeType: null,
+            StartDateTime: null,
+        };
         // build recurrence
         const recurHelper = {};
         // ical values are split by ; then have key values split by =
@@ -1245,10 +1274,12 @@ class Automation extends MetadataType {
         // add tz to input date to ensure Date() creates a date object with the right tz
         const inputStartDateString = scheduleObject.startDate + schedule._timezoneString;
 
+        /** @type {Date | string} */
+        let startDateTime;
         if (new Date(inputStartDateString) > new Date()) {
             // if start date is in future take this
-            schedule.StartDateTime = scheduleObject.startDate;
-            schedule._StartDateTime = schedule.StartDateTime; // store copy for CLI output
+            startDateTime = scheduleObject.startDate;
+            schedule._StartDateTime = scheduleObject.startDate; // store copy for CLI output
         } else {
             // if start date is in past calculate new start date
             const scheduledDate = new Date(inputStartDateString);
@@ -1288,16 +1319,16 @@ class Automation extends MetadataType {
                 // No default
             }
             // return time as Dateobject
-            schedule.StartDateTime = futureDate;
-            const localTimezoneOffset = schedule.StartDateTime.getTimezoneOffset() / -60;
-            schedule._StartDateTime = this._calcTime(localTimezoneOffset, schedule.StartDateTime); // store copy for CLI output
+            startDateTime = futureDate;
+            const localTimezoneOffset = futureDate.getTimezoneOffset() / -60;
+            schedule._StartDateTime = this._calcTime(localTimezoneOffset, futureDate); // store copy for CLI output
         }
 
         // The Create/Update API expects dates to be in US-Central time
         // The retrieve API returns the date in whatever timezone one chose, hence we need to convert this upon upsert
         schedule.StartDateTime = this._calcTime(
             this.properties.options.serverTimeOffset,
-            schedule.StartDateTime,
+            startDateTime,
             schedule._timezoneString
         );
 
@@ -1339,7 +1370,7 @@ class Automation extends MetadataType {
      * The json's first level of keys must represent the rows and the secend level the columns
      *
      * @private
-     * @param {TYPE.AutomationItem} json dataextension
+     * @param {AutomationItem} json dataextension
      * @param {object[][]} tabled prepped array for output in tabular format
      * @returns {string} file content
      */
@@ -1440,8 +1471,10 @@ class Automation extends MetadataType {
             }
             output += row1.join('') + `|\n${tableSeparator}|\n`;
             for (let i = 1; i < tabled.length; i++) {
-                for (const field of tabled[i]) {
-                    output += field ? `| _${field.i}: ${field.type}_<br>${field.name} ` : '| - ';
+                for (const activity of tabled[i]) {
+                    output += activity
+                        ? `| _${activity.i}: ${activity.type}_<br>${activity.key} `
+                        : '| - ';
                 }
                 output += '|\n';
             }
@@ -1455,9 +1488,9 @@ class Automation extends MetadataType {
      * @private
      * @param {string} directory directory the file will be written to
      * @param {string} filename name of the file without '.json' ending
-     * @param {TYPE.AutomationItem} json dataextension.columns
+     * @param {AutomationItem} json dataextension.columns
      * @param {'html'|'md'} mode html or md
-     * @returns {Promise.<boolean>} Promise of success of saving the file
+     * @returns {Promise.<void>} Promise of success of saving the file
      */
     static async _writeDoc(directory, filename, json, mode) {
         await File.ensureDir(directory);
@@ -1482,7 +1515,7 @@ class Automation extends MetadataType {
                         step.activities[activityIndex]
                             ? {
                                   i: stepIndex + 1 + '.' + (activityIndex + 1),
-                                  name: step.activities[activityIndex].name,
+                                  key: step.activities[activityIndex].r__key,
                                   type: step.activities[activityIndex].r__type,
                               }
                             : null
@@ -1504,13 +1537,13 @@ class Automation extends MetadataType {
     /**
      * Parses metadata into a readable Markdown/HTML format then saves it
      *
-     * @param {TYPE.AutomationMap} [metadata] a list of dataExtension definitions
+     * @param {AutomationMap} [metadata] a list of dataExtension definitions
      * @returns {Promise.<void>} -
      */
     static async document(metadata) {
         if (['md', 'both'].includes(this.properties.options.documentType)) {
             if (!metadata) {
-                metadata = this.readBUMetadataForType(
+                metadata = await this.readBUMetadataForType(
                     File.normalizePath([
                         this.properties.directories.retrieve,
                         this.buObject.credential,
@@ -1529,7 +1562,7 @@ class Automation extends MetadataType {
                 // as part of retrieve & manual execution we could face an empty folder
                 return;
             }
-            return await Promise.all(
+            await Promise.all(
                 Object.keys(metadata).map((key) =>
                     this._writeDoc(docPath + '/', key, metadata[key], 'md')
                 )
@@ -1541,9 +1574,9 @@ class Automation extends MetadataType {
      * additionally, the documentation for dataExtension and automation should be returned
      *
      * @param {string[]} keyArr customerkey of the metadata
-     * @returns {string[]} list of all files that need to be committed in a flat array ['path/file1.ext', 'path/file2.ext']
+     * @returns {Promise.<string[]>} list of all files that need to be committed in a flat array ['path/file1.ext', 'path/file2.ext']
      */
-    static getFilesToCommit(keyArr) {
+    static async getFilesToCommit(keyArr) {
         if (this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)) {
             // document automation is active. assume we want to commit the MD file as well
             const path = File.normalizePath([
@@ -1566,7 +1599,6 @@ class Automation extends MetadataType {
     /**
      * helper to allow us to select single metadata entries via REST
      *
-     * @private
      * @param {string} key customer key
      * @returns {Promise.<string>} objectId or enpty string
      */
@@ -1585,7 +1617,7 @@ class Automation extends MetadataType {
      * Delete a metadata item from the specified business unit
      *
      * @param {string} customerKey Identifier of data extension
-     * @returns {boolean} deletion success status
+     * @returns {Promise.<boolean>} deletion success status
      */
     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
@@ -1600,7 +1632,7 @@ class Automation extends MetadataType {
      * clean up after deleting a metadata item
      *
      * @param {string} customerKey Identifier of metadata item
-     * @returns {void}
+     * @returns {Promise.<void>} -
      */
     static async postDeleteTasks(customerKey) {
         // delete local copy: retrieve/cred/bu/.../...-meta.json

package/lib/metadataTypes/Campaign.js

@@ -1,10 +1,22 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
 import File from '../util/file.js';
 
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ */
+
 /**
  * Campaign MetadataType
  *
@@ -15,10 +27,10 @@ class Campaign extends MetadataType {
      * Retrieves Metadata of campaigns. Afterwards, starts metadata retrieval for their campaign assets
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
+     * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static async retrieve(retrieveDir, _, __, key) {
         const res = await super.retrieveREST(
@@ -43,7 +55,7 @@ class Campaign extends MetadataType {
     /**
      * Retrieves event definition metadata for caching
      *
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static retrieveForCache() {
         return super.retrieveREST(null, '/legacy/v1/beta2/data/campaign/');
@@ -55,7 +67,7 @@ class Campaign extends MetadataType {
      * @param {string} retrieveDir folder where to save
      * @param {string} campaignId of camapaign to retrieve
      * @param {string} name of camapaign for saving
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Campaign Asset Object
+     * @returns {Promise.<MetadataTypeMapObj>} Campaign Asset Object
      */
     static async getAssetTags(retrieveDir, campaignId, name) {
         const res = await this.client.rest.getBulk(`/hub/v1/campaigns/${campaignId}/assets`);