mcdev 7.10.1 → 8.0.1

package/lib/metadataTypes/Folder.js

@@ -101,8 +101,8 @@ class Folder extends MetadataType {
                         idMap[id].Path = idMap[id].Name;
                     }
                 } else {
-                    Util.logger.warn(
-                        ` - Skipping folder ${idMap[id].Name} (${id}, type: ${idMap[id].ContentType}): Cannot find parent folder (${idMap[id].ParentFolder.ID})`
+                    Util.logger.info(
+                        ` ☇ skipping folder ${idMap[id].Name} (${id}, type: ${idMap[id].ContentType}): Cannot find parent folder (${idMap[id].ParentFolder.ID})`
                     );
                 }
             }
@@ -110,7 +110,7 @@ class Folder extends MetadataType {
             else if (idMap[id].Name !== '<ROOT>') {
                 idMap[id].Path = '';
                 Util.logger.warn(
-                    ` - Skipping folder ${idMap[id].Name} (${id}, type: ${idMap[id].ContentType}): Does not have a parent folder`
+                    ` ☇ skipping folder ${idMap[id].Name} (${id}, type: ${idMap[id].ContentType}): Does not have a parent folder`
                 );
             }
         }
@@ -220,21 +220,11 @@ class Folder extends MetadataType {
                             let existingId;
                             try {
                                 // perform a secondary check based on path
-                                existingId = cache.searchForField(
-                                    'folder',
-                                    deployableMetadata.Path,
-                                    'Path',
-                                    'ID'
-                                );
-                                const cachedVersion = cache.getByKey(
-                                    'folder',
-                                    cache.searchForField(
-                                        'folder',
-                                        deployableMetadata.Path,
-                                        'Path',
-                                        this.definition.keyField
-                                    )
+
+                                const cachedVersion = cache.getFolderByPath(
+                                    deployableMetadata.Path
                                 );
+                                existingId = cachedVersion?.ID;
                                 if (
                                     existingId &&
                                     !this.hasChangedGeneric(
@@ -371,7 +361,7 @@ class Folder extends MetadataType {
         }
         const path = metadataEntry.Path;
         try {
-            if (this.definition.deployFolderTypesRest.includes(metadataEntry.ContentType)) {
+            if (this.definition.deployFolderTypesEmailRest.includes(metadataEntry.ContentType)) {
                 // * The SOAP endpoint for creating folders does not support folders for automations nor journeys. The Rest endpoint on the other hand errors out on certain characters in the folder names that are actually valid. We therefore only use Rest for the folder types that are not supported by SOAP.
                 const restPayload = {
                     parentCatId: metadataEntry.ParentFolder.ID,
@@ -379,7 +369,7 @@ class Folder extends MetadataType {
                     catType: metadataEntry.ContentType,
                 };
                 const response = await super.createREST(restPayload, '/email/v1/category', true);
-                if (response?.objectId) {
+                if (response?.categoryId) {
                     // convert the response to the same format as the SOAP response
 
                     // set the new folder ID
@@ -400,7 +390,48 @@ class Folder extends MetadataType {
                     Util.logger.info(` - created folder: ${path}`);
                     return returnObject;
                 } else {
-                    throw new Error(response);
+                    throw new Error(JSON.stringify(response));
+                }
+            } else if (
+                this.definition.deployFolderTypesAssetRest.includes(metadataEntry.ContentType)
+            ) {
+                // * The SOAP endpoint for creating folders does not support folders for automations nor journeys. The Rest endpoint on the other hand errors out on certain characters in the folder names that are actually valid. We therefore only use Rest for the folder types that are not supported by SOAP.
+                const restPayload = {
+                    parentId: metadataEntry.ParentFolder.ID,
+                    categoryType: metadataEntry.ContentType,
+                    extendable: 1,
+                    editable: 1,
+                    name: metadataEntry.Name,
+                    description: '',
+                };
+
+                const response = await super.createREST(
+                    restPayload,
+                    '/asset/v1/content/categories',
+                    true
+                );
+                if (response?.id) {
+                    // convert the response to the same format as the SOAP response
+
+                    // set the new folder ID
+                    metadataEntry.ID = response.id;
+                    // set the client ID to ensure we can find the newly created folders as parents for folders created afterwards inside of it
+                    metadataEntry.Client = {
+                        ID: metadataEntry.Client?.ID || this.buObject.mid,
+                    };
+                    // 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: [
+                            {
+                                Object: metadataEntry,
+                            },
+                        ],
+                    };
+
+                    Util.logger.info(` - created folder: ${path}`);
+                    return returnObject;
+                } else {
+                    throw new Error(JSON.stringify(response));
                 }
             } else {
                 const response = await super.createSOAP(metadataEntry, true);
@@ -446,13 +477,54 @@ class Folder extends MetadataType {
         }
         const path = metadataEntry.Path;
         try {
-            const response = await super.updateSOAP(metadataEntry, true);
-            if (response.Results?.[0]?.StatusCode === 'OK') {
-                response.Results[0].Object = metadataEntry;
-                response.Results[0].Object.CustomerKey = metadataEntry.CustomerKey;
-                delete response.Results[0].Object.$;
-                Util.logger.info(` - updated folder: ${path}`);
-                return response;
+            let response;
+            if (this.definition.deployFolderTypesAssetRest.includes(metadataEntry.ContentType)) {
+                // * The SOAP endpoint for creating folders does not support folders for automations nor journeys. The Rest endpoint on the other hand errors out on certain characters in the folder names that are actually valid. We therefore only use Rest for the folder types that are not supported by SOAP.
+                const restPayload = {
+                    id: metadataEntry.ID,
+                    parentId: metadataEntry.ParentFolder.ID,
+                    // categoryType: metadataEntry.ContentType,
+                    extendable: 1, // ?
+                    editable: 1, // ?
+                    name: metadataEntry.Name,
+                    description: '',
+                };
+                response = await super.updateREST(
+                    restPayload,
+                    '/asset/v1/content/categories/' + metadataEntry.ID,
+                    'put',
+                    true
+                );
+                if (response?.id) {
+                    // convert the response to the same format as the SOAP response
+
+                    // set the client ID to ensure we can find the newly created folders as parents for folders created afterwards inside of it
+                    metadataEntry.Client = {
+                        ID: metadataEntry.Client?.ID || this.buObject.mid,
+                    };
+                    // 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: [
+                            {
+                                Object: metadataEntry,
+                            },
+                        ],
+                    };
+
+                    Util.logger.info(` - updated folder: ${path}`);
+                    return returnObject;
+                } else {
+                    throw new Error(JSON.stringify(response));
+                }
+            } else {
+                response = await super.updateSOAP(metadataEntry, true);
+                if (response.Results?.[0]?.StatusCode === 'OK') {
+                    response.Results[0].Object = metadataEntry;
+                    response.Results[0].Object.CustomerKey = metadataEntry.CustomerKey;
+                    delete response.Results[0].Object.$;
+                    Util.logger.info(` - updated folder: ${path}`);
+                    return response;
+                }
             }
         } catch (ex) {
             if (ex?.results) {

package/lib/metadataTypes/ImportFile.js

@@ -16,6 +16,7 @@ import cache from '../util/cache.js';
  * @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').SDKError} SDKError
  */
 
 /**
@@ -85,6 +86,38 @@ class ImportFile extends MetadataType {
         );
     }
 
+    /**
+     * helper for {@link MetadataType.retrieveRESTcollection}
+     *
+     * @param {SDKError} ex exception
+     * @param {string} key id or key of item
+     * @param {string} url url to call for retry
+     * @returns {Promise.<any>} can return retry-result
+     */
+    static async handleRESTErrors(ex, key, url) {
+        try {
+            if (ex.code == 'ERR_BAD_RESPONSE') {
+                // one more retry; it's a rare case but retrying again should solve the issue gracefully
+                Util.logger.info(
+                    ` - Connection problem (Code: ${ex.code}). Retrying once${
+                        ex.endpoint
+                            ? Util.getGrayMsg(
+                                  ' - ' + ex.endpoint.split('rest.marketingcloudapis.com')[1]
+                              )
+                            : ''
+                    }`
+                );
+                Util.logger.errorStack(ex);
+                return await this.client.rest.get(url);
+            }
+        } catch {
+            // no extra action needed, handled below
+        }
+        // if we do get here, we should log the error and continue instead of failing to download all automations
+        Util.logger.error(` ☇ skipping ${this.definition.type} ${key}: ${ex.message} ${ex.code}`);
+        return null;
+    }
+
     /**
      * Retrieves import definition metadata for caching
      *
@@ -100,12 +133,14 @@ class ImportFile extends MetadataType {
     /**
      * Retrieve a specific Import Definition by Name
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<MetadataTypeItemObj>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         // using '?$filter=name%20eq%20' + encodeURIComponent(name) would also work but that just retrieves more data for no reason
         const cache = await this.retrieveForCache(null, null, 'name:' + name);
         const metadataArr = Object.values(cache?.metadata);
@@ -228,16 +263,21 @@ class ImportFile extends MetadataType {
      * @returns {Promise.<MetadataTypeItem>} Promise
      */
     static async preDeployTasks(metadata) {
-        const fileLocation = cache.getByKey('fileLocation', metadata.source?.r__fileLocation_name);
-        if (!fileLocation) {
-            throw new Error(
-                `fileLocation ${metadata.source?.r__fileLocation_name} not found in cache`
+        if (metadata.source?.r__fileLocation_name) {
+            const fileLocation = cache.getByKey(
+                'fileLocation',
+                metadata.source?.r__fileLocation_name
             );
-        }
+            if (!fileLocation) {
+                throw new Error(
+                    `fileLocation ${metadata.source?.r__fileLocation_name} not found in cache`
+                );
+            }
 
-        metadata.fileTransferLocationId = fileLocation.id;
-        metadata.fileTransferLocationTypeId = fileLocation.locationTypeId;
-        delete metadata.source.r__fileLocation_name;
+            metadata.fileTransferLocationId = fileLocation.id;
+            metadata.fileTransferLocationTypeId = fileLocation.locationTypeId;
+            delete metadata.source.r__fileLocation_name;
+        }
 
         switch (metadata.destination.c__type) {
             case 'DataExtension': {
@@ -332,18 +372,14 @@ class ImportFile extends MetadataType {
                     delete metadata.source.r__dataExtension_key;
                 }
 
-                Util.logger.debug(
-                    ` - importFile ${metadata[this.definition.keyField]}: Import Destination Type ${
-                        metadata.destination.c__type
-                    } not fully supported. Deploy might fail.`
+                throw new Error(
+                    `Import Destination Type ${metadata.destination.c__type} not fully supported.`
                 );
-                break;
             }
             default: {
-                Util.logger.debug(
-                    ` - importFile ${metadata[this.definition.keyField]}: Import Destination Type ${
-                        metadata.destination.c__type
-                    } not fully supported. Deploy might fail.`
+                // e.g. WhatsApp
+                throw new Error(
+                    `Import Destination Type ${metadata.destination.c__type} not fully supported.`
                 );
             }
         }
@@ -381,18 +417,24 @@ class ImportFile extends MetadataType {
         // destination.c__type SMS & DataExtension both set fileNamingPattern to _CustomObject and they both define a DE as source
         metadata.source = {
             c__type:
-                metadata.fileNamingPattern === '_CustomObject' ? 'DataExtension' : 'File Location',
+                metadata.fileNamingPattern === '_CustomObject' ||
+                metadata.fileSpec === '_CustomObject'
+                    ? 'DataExtension'
+                    : 'File Location',
         };
-        try {
-            metadata.source.r__fileLocation_name = cache.searchForField(
-                'fileLocation',
-                metadata.fileTransferLocationId,
-                'id',
-                'name'
-            );
-            delete metadata.fileTransferLocationId;
-        } catch (ex) {
-            Util.logger.warn(` - importFile ${metadata.customerKey}: ${ex.message}`);
+
+        if (metadata.fileTransferLocationId !== '00000000-0000-0000-0000-000000000000') {
+            try {
+                metadata.source.r__fileLocation_name = cache.searchForField(
+                    'fileLocation',
+                    metadata.fileTransferLocationId,
+                    'id',
+                    'name'
+                );
+                delete metadata.fileTransferLocationId;
+            } catch (ex) {
+                Util.logger.warn(` - importFile ${metadata.customerKey}: ${ex.message}`);
+            }
         }
 
         switch (metadata.destination.c__type) {
@@ -481,6 +523,27 @@ class ImportFile extends MetadataType {
 
                 break;
             }
+            case 'WhatsApp': {
+                if (
+                    metadata.source.c__type === 'DataExtension' &&
+                    metadata.sourceCustomObjectId !== ''
+                ) {
+                    // only happens for dataimport activities (summer24 release)
+                    try {
+                        metadata.source.r__dataExtension_key = cache.searchForField(
+                            'dataExtension',
+                            metadata.sourceCustomObjectId,
+                            'ObjectID',
+                            'CustomerKey'
+                        );
+                        delete metadata.sourceCustomObjectId;
+                        delete metadata.sourceDataExtensionName;
+                    } catch (ex) {
+                        Util.logger.warn(` - importFile ${metadata.customerKey}: ${ex.message}`);
+                    }
+                }
+                break;
+            }
             default: {
                 Util.logger.debug(
                     ` - importFile ${metadata.customerKey}: Destination Type ${metadata.destinationObjectTypeId} not fully supported. Deploy might fail.`
@@ -489,7 +552,7 @@ class ImportFile extends MetadataType {
         }
         delete metadata.destinationObjectTypeId;
 
-        if (metadata.blankFileProcessingType) {
+        if (metadata.blankFileProcessingType !== undefined) {
             // omit this if not set
             metadata.c__blankFileProcessing = Util.inverseGet(
                 this.definition.blankFileProcessingTypeMapping,