mcdev 7.0.3 → 7.0.4

package/lib/index.js

@@ -557,39 +557,74 @@ class Mcdev {
      * deletes metadata from MC instance by key
      *
      * @param {string} businessUnit references credentials from properties.json
-     * @param {string} type supported metadata type
-     * @param {string} customerKey Identifier of metadata
+     * @param {string | TypeKeyCombo} selectedTypes supported metadata type (single) or complex object
+     * @param {string[] | string} [keyArr] Identifier of metadata
      * @returns {Promise.<boolean>} true if successful, false otherwise
      */
-    static async deleteByKey(businessUnit, type, customerKey) {
+    static async deleteByKey(businessUnit, selectedTypes, keyArr) {
         Util.startLogger();
         Util.logger.info('mcdev:: delete');
-        if (!Util._isValidType(type)) {
-            return;
+        /** @typedef {string[]} */
+        let selectedTypesArr;
+        /** @typedef {TypeKeyCombo} */
+        let selectedTypesObj;
+        if ('string' === typeof keyArr) {
+            keyArr = [keyArr];
+        }
+        if ('string' === typeof selectedTypes) {
+            selectedTypesArr = [selectedTypes];
+        } else {
+            selectedTypesObj = selectedTypes;
+            // reset keys array because it will be overriden by values from selectedTypesObj
+            keyArr = null;
+        }
+        // check if types are valid
+        for (const selectedType of selectedTypesArr || Object.keys(selectedTypesObj)) {
+            if (!Util._isValidType(selectedType)) {
+                return;
+            }
         }
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
             return null;
         }
         const buObject = await Cli.getCredentialObject(properties, businessUnit);
-        if (buObject !== null) {
-            try {
-                MetadataTypeInfo[type].client = auth.getSDK(buObject);
-            } catch (ex) {
-                Util.logger.error(ex.message);
+        if (!buObject) {
+            return;
+        }
+        let client;
+        try {
+            client = auth.getSDK(buObject);
+        } catch (ex) {
+            Util.logger.error(ex.message);
+            return;
+        }
+        let status = true;
+        for (const type of selectedTypesArr || Object.keys(selectedTypesObj)) {
+            keyArr = selectedTypesArr ? keyArr : selectedTypesObj[type];
+            if (!keyArr) {
+                Util.logger.error(`No keys set for ${type}`);
                 return;
             }
-            Util.logger.info(
-                Util.getGrayMsg(` - Deleting ${type} ${customerKey} on BU ${businessUnit}`)
-            );
-            try {
-                MetadataTypeInfo[type].properties = properties;
-                MetadataTypeInfo[type].buObject = buObject;
-                return await MetadataTypeInfo[type].deleteByKey(customerKey);
-            } catch (ex) {
-                Util.logger.errorStack(ex, ` - Deleting ${type} failed`);
+            for (const key of keyArr) {
+                MetadataTypeInfo[type].client = client;
+
+                Util.logger.info(
+                    Util.getGrayMsg(` - Deleting ${type} ${key} on BU ${businessUnit}`)
+                );
+                try {
+                    MetadataTypeInfo[type].properties = properties;
+                    MetadataTypeInfo[type].buObject = buObject;
+                    const result = await MetadataTypeInfo[type].deleteByKey(key);
+                    status &&= result;
+                } catch (ex) {
+                    Util.logger.errorStack(ex, ` - Deleting ${type} failed`);
+                    status = false;
+                }
             }
         }
+
+        return status;
     }
     /**
      * get name & key for provided id
@@ -1010,13 +1045,12 @@ class Mcdev {
      * Updates the key to match the name field
      *
      * @param {string} businessUnit name of BU
-     * @param {TypeKeyCombo|undefined} selectedTypesArr limit retrieval to given metadata type
-     * @param {ContentBlockConversionTypes} to what to replace with
-     * @param {ContentBlockConversionTypes[]} [fromList] what to replace
+     * @param {TypeKeyCombo | undefined} selectedTypesObj limit retrieval to given metadata type
+     * @param {string} to what to replace with
+     * @param {string[]} [fromList] what to replace
      * @returns {Promise.<Object.<string, object>>} key1: business unit name, key2:type value: list of fixed item keys
      */
-    static async replaceCbReference(businessUnit, selectedTypesArr, to, fromList) {
-        /** @type {ContentBlockConversionTypes[]} */
+    static async replaceCbReference(businessUnit, selectedTypesObj, to, fromList) {
         const allowedFromTo = ['key', 'name', 'id'];
         if (!allowedFromTo.includes(to)) {
             Util.logger.error(
@@ -1053,9 +1087,11 @@ class Mcdev {
         if (!Util._isValidBU(properties, businessUnit)) {
             return;
         }
-        if (selectedTypesArr) {
+        /** @typedef {string[]} */
+        let selectedTypesArr;
+        if (selectedTypesObj) {
             // check if types are valid
-            for (const selectedType of Object.keys(selectedTypesArr)) {
+            for (const selectedType of Object.keys(selectedTypesObj)) {
                 if (!Util._isValidType(selectedType)) {
                     return;
                 }
@@ -1081,19 +1117,19 @@ class Mcdev {
                 selectedTypesArr
             )
                 ? selectedTypesArr
-                : Object.keys(selectedTypesArr)
+                : Object.keys(selectedTypesObj)
             ).join(', ')}`
         );
 
         const response = {};
         for (const selectedType of Array.isArray(selectedTypesArr)
             ? selectedTypesArr
-            : Object.keys(selectedTypesArr)) {
+            : Object.keys(selectedTypesObj)) {
             const temp = await this.#runMethod(
                 'replaceCbReference',
                 businessUnit,
                 selectedType,
-                Array.isArray(selectedTypesArr) ? null : selectedTypesArr[selectedType]
+                Array.isArray(selectedTypesArr) ? null : selectedTypesObj[selectedType]
             );
             response[businessUnit] ||= {};
             response[businessUnit][selectedType] = temp[businessUnit];
@@ -1106,22 +1142,31 @@ class Mcdev {
      * Updates the key to match the name field
      *
      * @param {string} businessUnit name of BU
-     * @param {string[] | TypeKeyCombo} selectedTypesArr limit retrieval to given metadata type
+     * @param {string[] | TypeKeyCombo} selectedTypes limit retrieval to given metadata type
      * @param {string[]} [keys] customerkey of the metadata
      * @returns {Promise.<Object.<string, object>>} key1: business unit name, key2:type value: list of fixed item keys
      */
-    static async fixKeys(businessUnit, selectedTypesArr, keys) {
+    static async fixKeys(businessUnit, selectedTypes, keys) {
         const properties = await config.getProperties();
         let reRetrieveAll = false;
-        if (selectedTypesArr) {
+        /** @typedef {string[]} */
+        let selectedTypesArr;
+        /** @typedef {TypeKeyCombo} */
+        let selectedTypesObj;
+        if (selectedTypes) {
             // check if types are valid
-            for (const selectedType of Array.isArray(selectedTypesArr)
-                ? selectedTypesArr
-                : Object.keys(selectedTypesArr)) {
+            for (const selectedType of Array.isArray(selectedTypes)
+                ? selectedTypes
+                : Object.keys(selectedTypes)) {
                 if (!Util._isValidType(selectedType)) {
                     return;
                 }
             }
+            if (Array.isArray(selectedTypes)) {
+                selectedTypesArr = selectedTypes;
+            } else {
+                selectedTypesObj = selectedTypes;
+            }
         } else {
             // do it for all standard retrieve types
             selectedTypesArr = [];
@@ -1139,7 +1184,9 @@ class Mcdev {
                         )
                 )
             );
-            Util.logger.info(`:: Fixing keys for ${selectedTypesArr.join(', ')}`);
+            Util.logger.info(
+                `:: Fixing keys for ${selectedTypesArr ? selectedTypesArr.join(', ') : Object.keys(selectedTypesObj).join(', ')}`
+            );
             reRetrieveAll = true;
             this.setOptions({
                 skipInteraction: { fixKeysReretrieve: false },
@@ -1147,17 +1194,15 @@ class Mcdev {
         }
 
         const response = {};
-        for (const selectedType of Array.isArray(selectedTypesArr)
-            ? selectedTypesArr
-            : Object.keys(selectedTypesArr)) {
+        for (const selectedType of selectedTypesArr || Object.keys(selectedTypesObj)) {
             if (selectedType === 'event') {
                 Util.logger.warn(
                     `Type 'event' is not supported for fixKeys for compatibility reasons. Draft Journeys would otherwise be broken after the key change. If you do need to update an event key, use deploy --changeKeyValue or --changeKeyField instead.`
                 );
-                if (Array.isArray(selectedTypesArr)) {
-                    selectedTypesArr = selectedTypesArr.filter((type) => type !== 'event');
+                if (Array.isArray(selectedTypes)) {
+                    selectedTypes = selectedTypes.filter((type) => type !== 'event');
                 } else {
-                    delete selectedTypesArr.event;
+                    delete selectedTypes.event;
                 }
                 continue;
             }
@@ -1165,13 +1210,14 @@ class Mcdev {
                 'fixKeys',
                 businessUnit,
                 selectedType,
-                Array.isArray(selectedTypesArr) ? keys : selectedTypesArr[selectedType]
+                selectedTypesArr ? keys : selectedTypesObj[selectedType]
             );
             response[businessUnit] ||= {};
             response[businessUnit][selectedType] = temp[businessUnit];
         }
 
         if (reRetrieveAll) {
+            // only done if selectedTypesArr is set as fallback
             Util.logger.info(
                 `Retrieving latest versions of ${selectedTypesArr.join(', ')} from server`
             );

package/lib/metadataTypes/Asset.js

@@ -2217,6 +2217,7 @@ class Asset extends MetadataType {
 
         if (!changes) {
             const ex = new Error('No changes made to the code.');
+            // @ts-expect-error TODO: create custom Error object
             ex.code = 200;
             throw ex;
         }

package/lib/metadataTypes/DataExtension.js

@@ -278,10 +278,11 @@ class DataExtension extends MetadataType {
      * Updates a single dataExtension. Also updates their columns in 'dataExtension.columns'
      *
      * @param {DataExtensionItem} metadata single metadata entry
+     * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
      * @returns {Promise} Promise
      */
-    static async update(metadata) {
-        return super.updateSOAP(metadata);
+    static async update(metadata, handleOutside) {
+        return super.updateSOAP(metadata, handleOutside);
     }
     /**
      * Gets executed after deployment of metadata type
@@ -678,7 +679,6 @@ class DataExtension extends MetadataType {
                 ],
             },
         };
-        // @ts-expect-error SFMC-SDK typing error
         await this.client.soap.update(Util.capitalizeFirstLetter(soapType), payload, null);
         return randomSuffix;
     }

package/lib/metadataTypes/DataExtensionField.js

@@ -315,7 +315,6 @@ class DataExtensionField extends MetadataType {
         };
         try {
             // ! we really do need to delete from DataExtension not DataExtensionField here!
-            // @ts-expect-error wrong jsdoc for 2nd parameter in SFMC-SDK
             this.client.soap.delete('DataExtension', keyObj, null);
 
             if (!fieldId) {

package/lib/metadataTypes/Event.js

@@ -4,6 +4,7 @@ import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
 import File from '../util/file.js';
 import cache from '../util/cache.js';
+import deepEqual from 'deep-equal';
 
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
@@ -24,6 +25,7 @@ import cache from '../util/cache.js';
  * @augments MetadataType
  */
 class Event extends MetadataType {
+    static reCacheDataExtensions = [];
     /**
      * Retrieves Metadata of Event Definition.
      * Endpoint /interaction/v1/eventDefinitions return all Event Definitions with all details.
@@ -92,30 +94,26 @@ class Event extends MetadataType {
                 );
             } else if (event?.length === 1) {
                 const originalKey = event[0][this.definition.keyField];
-                const eventDef = JSON.parse(
-                    Util.replaceByObject(
-                        JSON.stringify(this.postRetrieveTasks(event[0])),
-                        templateVariables
-                    )
+                const metadataItemTemplated = Util.replaceByObject(
+                    this.postRetrieveTasks(event[0]),
+                    templateVariables
                 );
-                if (!eventDef.dataExtensionId) {
+
+                if (!metadataItemTemplated.r__dataExtension_key) {
                     throw new Error(
-                        `Event.postRetrieveTasks:: ` +
-                            `No Data Extension found for ` +
-                            `event: ${eventDef.name}. ` +
-                            `This cannot be templated`
+                        `Event.postRetrieveTasks:: No Data Extension found for ${this.definition.type}: ${metadataItemTemplated.name}. This cannot be templated.`
                     );
                 }
 
                 // remove all fields listed in Definition for templating
-                this.keepTemplateFields(eventDef);
+                this.keepTemplateFields(metadataItemTemplated);
                 await File.writeJSONToFile(
                     [templateDir, this.definition.type].join('/'),
                     originalKey + '.' + this.definition.type + '-meta',
-                    JSON.parse(Util.replaceByObject(JSON.stringify(eventDef), templateVariables))
+                    metadataItemTemplated
                 );
-                Util.logger.info(`- templated ${this.definition.type}: ${name}`);
-                return { metadata: eventDef, type: this.definition.type };
+                Util.logger.info(` - templated ${this.definition.type}: ${name}`);
+                return { metadata: metadataItemTemplated, type: this.definition.type };
             } else {
                 throw new Error(
                     `Encountered unknown error when retrieveing ${
@@ -175,7 +173,8 @@ class Event extends MetadataType {
     static async update(metadataEntry) {
         return super.updateREST(
             metadataEntry,
-            '/interaction/v1/eventDefinitions/' + metadataEntry.id,
+            '/interaction/v1/eventDefinitions/key:' +
+                encodeURIComponent(metadataEntry[this.definition.keyField]),
             'put'
         );
     }
@@ -187,25 +186,8 @@ class Event extends MetadataType {
      * @returns {MetadataTypeItem} parsed version
      */
     static preDeployTasks(metadata) {
-        if (metadata.r__dataExtension_key) {
-            metadata.dataExtensionId = cache.searchForField(
-                'dataExtension',
-                metadata.r__dataExtension_key,
-                'CustomerKey',
-                'ObjectID'
-            );
-            metadata.dataExtensionName = cache.searchForField(
-                'dataExtension',
-                metadata.r__dataExtension_key,
-                'CustomerKey',
-                'Name'
-            );
-            metadata.arguments.dataExtensionId = metadata.dataExtensionId;
-            if (metadata.schema) {
-                metadata.schema.id = metadata.dataExtensionId;
-                metadata.schema.name = metadata.dataExtensionName;
-            }
-        }
+        // Note: lots has to be done in createOrUpdate based on what action is required
+        metadata.arguments ||= {};
         metadata.arguments.eventDefinitionKey = metadata.eventDefinitionKey;
 
         // standard values
@@ -214,6 +196,187 @@ class Event extends MetadataType {
         metadata.mode = 'Production'; // potentially needs to be set to "1" instead
         return metadata;
     }
+    /**
+     * helper for {@link MetadataType.upsert}
+     *
+     * @param {MetadataTypeMap} metadataMap list of metadata
+     * @param {string} metadataKey key of item we are looking at
+     * @param {boolean} hasError error flag from previous code
+     * @param {MetadataTypeItemDiff[]} metadataToUpdate list of items to update
+     * @param {MetadataTypeItem[]} metadataToCreate list of items to create
+     * @returns {Promise.<'create'|'update'|'skip'>} action to take
+     */
+    static async createOrUpdate(
+        metadataMap,
+        metadataKey,
+        hasError,
+        metadataToUpdate,
+        metadataToCreate
+    ) {
+        const createOrUpdateAction = await super.createOrUpdate(
+            metadataMap,
+            metadataKey,
+            hasError,
+            metadataToUpdate,
+            metadataToCreate
+        );
+        const metadataItem = metadataMap[metadataKey];
+        if (createOrUpdateAction === 'update') {
+            if (metadataItem.r__dataExtension_key) {
+                metadataItem.dataExtensionId = cache.searchForField(
+                    'dataExtension',
+                    metadataItem.r__dataExtension_key,
+                    'CustomerKey',
+                    'ObjectID'
+                );
+                metadataItem.dataExtensionName = cache.searchForField(
+                    'dataExtension',
+                    metadataItem.r__dataExtension_key,
+                    'CustomerKey',
+                    'Name'
+                );
+                metadataItem.arguments.dataExtensionId = metadataItem.dataExtensionId;
+                if (metadataItem.schema) {
+                    metadataItem.schema.id = metadataItem.dataExtensionId;
+                    metadataItem.schema.name = metadataItem.dataExtensionName;
+                }
+            }
+            if (metadataItem.schema?.fields?.length) {
+                const normalizedKey = File.reverseFilterIllegalFilenames(
+                    metadataMap[metadataKey][this.definition.keyField]
+                );
+                const cachedVersion = cache.getByKey(this.definition.type, normalizedKey);
+                if (cachedVersion?.schema?.fields?.length) {
+                    const cacheClone = structuredClone(cachedVersion);
+                    cacheClone.schema.fields = cacheClone.schema.fields.map((field) => {
+                        delete field.isDevicePreference;
+                        return field;
+                    });
+                    if (!deepEqual(metadataItem?.schema?.fields, cacheClone?.schema?.fields)) {
+                        Util.logger.warn(
+                            ` - ${this.definition.type} ${metadataItem[this.definition.keyField]}: schema fields differ from server version. Resetting as this will not be reflected on dataExtension.`
+                        );
+                        metadataItem.schema.fields = cacheClone.schema.fields;
+                    }
+                }
+            }
+        } else if (createOrUpdateAction === 'create') {
+            try {
+                if (metadataItem.r__dataExtension_key) {
+                    metadataItem.dataExtensionId = cache.searchForField(
+                        'dataExtension',
+                        metadataItem.r__dataExtension_key,
+                        'CustomerKey',
+                        'ObjectID'
+                    );
+                    metadataItem.dataExtensionName = cache.searchForField(
+                        'dataExtension',
+                        metadataItem.r__dataExtension_key,
+                        'CustomerKey',
+                        'Name'
+                    );
+                    if (metadataItem.schema) {
+                        delete metadataItem.schema;
+                        Util.logger.info(
+                            ` - ${this.definition.type} ${metadataItem[this.definition.keyField]}: dataExtension ${metadataItem.r__dataExtension_key} found, ignoring schema-section in ${this.definition.type} json`
+                        );
+                    }
+                }
+            } catch {
+                // no action
+            }
+            if (metadataItem.schema) {
+                if (metadataItem.r__dataExtension_key) {
+                    metadataItem.schema.name = metadataItem.r__dataExtension_key;
+                }
+                Util.logger.warn(
+                    `Data Extension ${metadataItem.schema.name || metadataItem[this.definition.keyField]} not found on BU. Creating it automatically based on schema-definition.`
+                );
+                // we want the event api to create the DE for us based on the schema
+                this.reCacheDataExtensions.push({
+                    eventKey: metadataItem[this.definition.keyField],
+                    deKey: metadataItem.schema.name || metadataItem[this.definition.keyField],
+                });
+            }
+        }
+        return createOrUpdateAction;
+    }
+    /**
+     * Gets executed after deployment of metadata type
+     *
+     * @param {MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
+     * @param {MetadataTypeMap} originalMetadata metadata to be updated (contains additioanl fields)
+     * @param {{created: number, updated: number}} createdUpdated counter representing successful creates/updates
+     * @returns {Promise.<void>} -
+     */
+    static async postDeployTasks(upsertResults, originalMetadata, createdUpdated) {
+        // CREATE ONLY - if dataExtensions were auto-
+        if (this.reCacheDataExtensions.length && createdUpdated.created > 0) {
+            Util.logger.warn(' - Re-caching dependent Metadata: dataExtension');
+            const deRetrieve = await DataExtension.retrieveForCache();
+            cache.setMetadata('dataExtension', deRetrieve.metadata);
+            const reDownloadDeKeys = [];
+            // try to update key & name of the auto-generated dataExtension
+            for (const { eventKey, deKey } of this.reCacheDataExtensions) {
+                if (!upsertResults[eventKey]) {
+                    continue;
+                }
+                const eventItem = upsertResults[eventKey];
+                const newDeKey = cache.searchForField(
+                    'dataExtension',
+                    eventItem.dataExtensionId,
+                    'ObjectID',
+                    'CustomerKey'
+                );
+                // get dataExtension from cache which conveniently already has the ObjectID set
+                const deObj = cache.getByKey('dataExtension', newDeKey);
+                const oldName = deObj[DataExtension.definition.nameField];
+                // prepare a clone of the DE to update name & key to match the event
+                const clone = structuredClone(deObj);
+                clone[DataExtension.definition.keyField] = deKey;
+                clone[DataExtension.definition.nameField] = deKey;
+                try {
+                    // update DE on server
+                    await DataExtension.update(clone, true);
+                    Util.logger.info(
+                        ` - changed dataExtension ${newDeKey} (${oldName}) key/name to ${deKey}`
+                    );
+                    // update cache
+                    deObj[DataExtension.definition.keyField] = deKey;
+                    deObj[DataExtension.definition.nameField] = deKey;
+
+                    reDownloadDeKeys.push(deObj[DataExtension.definition.keyField]);
+                } catch {
+                    // fallback, set DE key to value of DE name
+                    const clone = structuredClone(deObj);
+                    clone[DataExtension.definition.keyField] = oldName;
+                    try {
+                        // update DE on server
+                        await DataExtension.update(clone, true);
+                        Util.logger.info(
+                            ` - changed dataExtension ${newDeKey} (${oldName}) key to ${oldName}`
+                        );
+                        // update cache
+                        deObj[DataExtension.definition.keyField] =
+                            deObj[DataExtension.definition.nameField];
+
+                        reDownloadDeKeys.push(deObj[DataExtension.definition.keyField]);
+                    } catch {
+                        Util.logger.debug(
+                            ` - failed to change dataExtension ${newDeKey} (${oldName}) key/name`
+                        );
+                    }
+                }
+            }
+            this.reCacheDataExtensions.length = 0;
+
+            // ensure we have downloaded auto-created DEs
+            if (reDownloadDeKeys.length) {
+                const retriever = new Retriever(this.properties, this.buObject);
+                await retriever.retrieve(['dataExtension'], reDownloadDeKeys);
+            }
+        }
+    }
 
     /**
      * parses retrieved Metadata before saving
@@ -234,7 +397,6 @@ class Event extends MetadataType {
             delete metadata.arguments.dataExtensionId;
             if (metadata.schema) {
                 delete metadata.schema.id;
-                delete metadata.schema.name;
             }
         } catch (ex) {
             Util.logger.verbose(
@@ -249,6 +411,8 @@ class Event extends MetadataType {
 
 // Assign definition to static attributes
 import MetadataTypeDefinitions from '../MetadataTypeDefinitions.js';
+import DataExtension from './DataExtension.js';
+import Retriever from './../Retriever.js';
 Event.definition = MetadataTypeDefinitions.event;
 
 export default Event;

package/lib/metadataTypes/Folder.js

@@ -361,7 +361,7 @@ class Folder extends MetadataType {
                 const response = await super.createREST(restPayload, '/email/v1/category', true);
                 if (response?.objectId) {
                     // convert the response to the same format as the SOAP response
-                    metadataEntry.ID = response.objectId;
+                    metadataEntry.ID = response.categoryId;
                     // the following is a bit of a hack to make the response look like the SOAP response; not sure if we actually need that anywhere like this --> future developers feel free to double check
                     const returnObject = {
                         Results: [

package/lib/metadataTypes/Journey.js

@@ -49,7 +49,11 @@ class Journey extends MetadataType {
         let singleKey = '';
         let mode = 'key';
         if (key) {
-            if (key.startsWith('id:') || key.startsWith('%23')) {
+            if (key.startsWith('%23')) {
+                // correct the format
+                key = 'id:' + key.slice(3);
+            }
+            if (key.startsWith('id:')) {
                 // ! allow selecting journeys by ID because that's what users see in the URL
                 // if the key started with %23 assume an ID was copied from the URL but the user forgot to prefix it with id:
 
@@ -59,6 +63,8 @@ class Journey extends MetadataType {
                     // in the journey URL the Id is prefixed with an HTML-encoded "#" which could accidentally be copied by users
                     // despite the slicing above, this still needs testing here because users might have prefixed the ID with id: but did not know to remove the #23
                     singleKey = singleKey.slice(3);
+                    // correct the format to ensure we show sth readable in the "Downloaded" log
+                    key = 'id:' + singleKey;
                 }
                 if (singleKey.includes('/')) {
                     // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the ID for the retrieve as we always aim to retrieve the latest version only
@@ -89,7 +95,7 @@ class Journey extends MetadataType {
                 const results = this.definition.restPagination
                     ? await this.client.rest.getBulk(uri, this.definition.restPageSize || 500)
                     : await this.client.rest.get(uri);
-                // const results = this.parseResponseBody(response);
+
                 if (results.items?.length) {
                     // empty results will come back without "items" defined
                     Util.logger.info(
@@ -1182,6 +1188,7 @@ class Journey extends MetadataType {
         const activities = item.activities.filter((activity) => activity.type === 'EMAILV2');
         if (!activities) {
             const ex = new Error('No changes made to the code.');
+            // @ts-expect-error custom error object
             ex.code = 200;
             throw ex;
         }
@@ -1278,6 +1285,7 @@ class Journey extends MetadataType {
 
         if (!changes) {
             const ex = new Error('No changes made to the code.');
+            // @ts-expect-error custom error object
             ex.code = 200;
             throw ex;
         }

package/lib/metadataTypes/MetadataType.js

@@ -26,7 +26,7 @@ import Mustache from 'mustache';
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
  * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
- * @typedef {import('../../types/mcdev.d.js').SDK} SDK
+ * @typedef {import('sfmc-sdk').default} SDK
  * @typedef {import('../../types/mcdev.d.js').SDKError} SDKError
  * @typedef {import('../../types/mcdev.d.js').SOAPError} SOAPError
  * @typedef {import('../../types/mcdev.d.js').RestError} RestError
@@ -148,9 +148,9 @@ class MetadataType {
      * @param {MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
      * @param {MetadataTypeMap} originalMetadata metadata to be updated (contains additioanl fields)
      * @param {{created: number, updated: number}} createdUpdated counter representing successful creates/updates
-     * @returns {void}
+     * @returns {Promise.<void>} -
      */
-    static postDeployTasks(upsertResults, originalMetadata, createdUpdated) {}
+    static async postDeployTasks(upsertResults, originalMetadata, createdUpdated) {}
 
     /**
      * helper for {@link MetadataType.createREST}
@@ -2229,7 +2229,6 @@ class MetadataType {
         metadata[overrideKeyField || this.definition.keyField] = customerKey;
         const soapType = this.definition.soapType || this.definition.type;
         try {
-            // @ts-expect-error - wrong jsdoc in SFMC-SDK
             await this.client.soap.delete(Util.capitalizeFirstLetter(soapType), metadata, null);
             if (!handleOutside) {
                 Util.logger.info(` - deleted ${this.definition.type}: ${customerKey}`);