mcdev 7.1.1 → 7.1.2

package/lib/index.js

@@ -93,6 +93,7 @@ class Mcdev {
             'json',
             'keySuffix',
             'like',
+            'matchName',
             'noLogColors',
             'noLogFile',
             'noUpdate',
@@ -731,7 +732,7 @@ class Mcdev {
                 MetadataTypeInfo[type].buObject = buObject;
                 await MetadataTypeInfo[type].refresh(keyArr);
             } catch (ex) {
-                Util.logger.errorStack(ex, 'mcdev.refresh ' + ex.message);
+                Util.logger.errorStack(ex, 'mcdev.refresh');
             }
         }
     }

package/lib/metadataTypes/Asset.js

@@ -237,9 +237,9 @@ class Asset extends MetadataType {
         const subtypeIdsList = key
             ? [null]
             : Util.chunk(
-                  extendedSubTypeArr?.map(
-                      (subTypeItemName) => this.definition.typeMapping[subTypeItemName]
-                  ),
+                  extendedSubTypeArr
+                      ?.map((subTypeItemName) => this.definition.typeMapping[subTypeItemName])
+                      .sort((a, b) => a - b),
                   50
               );
         const uri = '/asset/v1/content/assets/query' + (loadShared ? '?scope=shared' : '');
@@ -779,22 +779,24 @@ class Asset extends MetadataType {
                 metadata[this.definition.keyField].slice(0, Math.max(0, 36 - suffix.length)) +
                 suffix;
         }
-        // #4 make sure the name is unique
-        const assetCache = cache.getCache()[this.definition.type];
-        const namesInFolder = Object.keys(assetCache)
-            .filter((key) => assetCache[key].category.id === metadata.category.id)
-            .map((key) => ({
-                type: this.#getMainSubtype(assetCache[key].assetType.name),
-                key: key,
-                name: assetCache[key].name,
-            }));
-        // if the name is already in the folder for a different key, add a number to the end
-        metadata[this.definition.nameField] = this._findUniqueName(
-            metadata[this.definition.keyField],
-            metadata[this.definition.nameField],
-            this.#getMainSubtype(metadata.assetType.name),
-            namesInFolder
-        );
+        if (!Util.OPTIONS.matchName) {
+            // #4 make sure the name is unique
+            const assetCache = cache.getCache()[this.definition.type];
+            const namesInFolder = Object.keys(assetCache)
+                .filter((key) => assetCache[key].category.id === metadata.category.id)
+                .map((key) => ({
+                    type: this.#getMainSubtype(assetCache[key].assetType.name),
+                    key: key,
+                    name: assetCache[key].name,
+                }));
+            // if the name is already in the folder for a different key, add a number to the end
+            metadata[this.definition.nameField] = this._findUniqueName(
+                metadata[this.definition.keyField],
+                metadata[this.definition.nameField],
+                this.#getMainSubtype(metadata.assetType.name),
+                namesInFolder
+            );
+        }
         return metadata;
     }
     /**
@@ -2431,7 +2433,10 @@ class Asset extends MetadataType {
                 } catch (ex) {
                     if (ex.code !== 200) {
                         // dont print error if we simply did not find relevant content blocks
-                        Util.logger.errorStack(ex, ex.message);
+                        Util.logger.errorStack(
+                            ex,
+                            'issue with ' + this.definition.type + ' ' + key
+                        );
                     }
                     if (!findAssetKeys) {
                         Util.logger.info(
@@ -2539,6 +2544,67 @@ class Asset extends MetadataType {
             }
         }
     }
+    /**
+     * helper for {@link MetadataType.createOrUpdate}
+     *
+     * @param {MetadataTypeItem} metadataItem to be deployed item
+     * @returns {MetadataTypeItem} cached item or undefined
+     */
+    static getCacheMatchedByName(metadataItem) {
+        let cacheMatchedByName;
+
+        if (Util.OPTIONS.matchName) {
+            // make sure to run the search ONLY if OPTIONS.matchName is true and definition.allowMatchingByName signals support
+            const assetCache = cache.getCache()?.asset;
+            const potentials = [];
+            for (const key in assetCache) {
+                const cachedAsset = assetCache[key];
+                if (
+                    cachedAsset[this.definition.nameField] ===
+                        metadataItem[this.definition.nameField] &&
+                    cachedAsset.assetType.id === metadataItem.assetType.id
+                ) {
+                    potentials.push(cachedAsset);
+                }
+            }
+            if (potentials.length > 1) {
+                throw new Error(
+                    `found multiple name matches in cache for ${this.definition.type} ${metadataItem[this.definition.keyField]} / ${metadataItem[this.definition.nameField]}. Check their keys for more details: ${potentials.map((p) => p[this.definition.keyField]).join(', ')}`
+                );
+            } else if (potentials.length === 1) {
+                const deployFolderPath = cache.searchForField(
+                    'folder',
+                    metadataItem.category.id,
+                    'ID',
+                    'Path'
+                );
+                if (potentials[0].category.id === metadataItem.category.id) {
+                    cacheMatchedByName = potentials[0];
+
+                    Util.logger.info(
+                        Util.getGrayMsg(
+                            ` - found ${this.definition.type} ${metadataItem[this.definition.keyField]} in cache by name "${metadataItem[this.definition.nameField]}" and folder "${deployFolderPath}": ${cacheMatchedByName[this.definition.keyField]}`
+                        )
+                    );
+                } else {
+                    const cacheFolderPath = cache.searchForField(
+                        'folder',
+                        potentials[0].category.id,
+                        'ID',
+                        'Path'
+                    );
+                    throw new Error(
+                        `found ${this.definition.type} ${metadataItem[this.definition.keyField]} in cache by name "${metadataItem[this.definition.nameField]}" but in different folders: "${deployFolderPath}" vs "${cacheFolderPath}": ${potentials[0][this.definition.keyField]}`
+                    );
+                }
+            } else {
+                Util.logger.debug(
+                    ` - no name-match found for ${this.definition.type} ${metadataItem[this.definition.keyField]}. Creating new asset instead.`
+                );
+            }
+        }
+        return cacheMatchedByName;
+    }
 }
 
 // Assign definition to static attributes

package/lib/metadataTypes/Folder.js

@@ -331,10 +331,7 @@ class Folder extends MetadataType {
                             }
                         }
                     } catch (ex) {
-                        Util.logger.errorStack(
-                            ex,
-                            `Upserting ${this.definition.type} failed: ${ex.message}`
-                        );
+                        Util.logger.errorStack(ex, `Upserting ${this.definition.type} failed`);
                     }
                 }
             }
@@ -431,10 +428,16 @@ class Folder extends MetadataType {
      * @returns {Promise.<any>} Promise of api response
      */
     static async update(metadataEntry) {
+        if (metadataEntry?.ParentFolder?.ID === 0) {
+            Util.logger.debug(
+                `${this.definition.type}-${metadataEntry.ContentType}.create:: Cannot create Root Folder: ${metadataEntry.Name}`
+            );
+            return {};
+        }
         const path = metadataEntry.Path;
         try {
             const response = await super.updateSOAP(metadataEntry, true);
-            if (response) {
+            if (response.Results?.[0]?.StatusCode === 'OK') {
                 response.Results[0].Object = metadataEntry;
                 response.Results[0].Object.CustomerKey = metadataEntry.CustomerKey;
                 delete response.Results[0].Object.$;
@@ -488,9 +491,14 @@ class Folder extends MetadataType {
             );
             return;
         }
-        // retreive ID based on the matching Path of the parent folder
+        // retrieve ID based on the matching Path of the parent folder
         else if (metadata?.ParentFolder?.Path) {
-            metadata.ParentFolder.ID = cache.getFolderId(metadata.ParentFolder.Path);
+            // do not allow mapping folders to other BUs during deploy
+            metadata.ParentFolder.ID = cache.getFolderId(
+                metadata.ParentFolder.Path,
+                undefined,
+                false
+            );
             return metadata;
         } else {
             Util.metadataLogger(

package/lib/metadataTypes/Journey.js

@@ -545,13 +545,6 @@ class Journey extends MetadataType {
                                 );
                                 delete configurationArguments.triggeredSendKey;
                             }
-                            if (
-                                configurationArguments.triggeredSendKey &&
-                                configurationArguments.triggeredSend
-                            ) {
-                                // assumption is, that this stores potentially outdated triggeredSend info from the first version of the journey
-                                delete configurationArguments.triggeredSend;
-                            }
                         } catch (ex) {
                             Util.logger.warn(
                                 ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
@@ -1315,6 +1308,8 @@ class Journey extends MetadataType {
                 if (cachedVersion.status === 'Draft') {
                     // add version to ensure we update the correct one
                     metadataMap[metadataKey].version = cachedVersion.version;
+                    // update modifiedDate field to bypass API-error "Another user recently modified this journey. Refresh to edit the latest version."
+                    metadataMap[metadataKey].modifiedDate = cachedVersion.modifiedDate;
                 } else {
                     // remove last entry from metadataToUpdate again
                     metadataToUpdate.pop();
@@ -1655,7 +1650,7 @@ class Journey extends MetadataType {
                     messages[type].push(
                         `     #${counter++}`,
                         `     Code: ${msg.errorCode}`,
-                        `     Details: ${msg.errorDetail}`
+                        `     Details: ${msg.errorDetail.split(' EmailID: ').join('\n       EmailID: ').split(' Personalization error: ').join('\n       Personalization error: ')}`
                     );
                     if (msg.additionalInfo && Object.keys(msg.additionalInfo).length) {
                         messages[type].push(`     Additional Info:`);

package/lib/metadataTypes/MetadataType.js

@@ -549,7 +549,10 @@ class MetadataType {
                 } catch (ex) {
                     if (ex.code !== 200) {
                         // dont print error if we simply did not find relevant content blocks
-                        Util.logger.errorStack(ex, ex.message);
+                        Util.logger.errorStack(
+                            ex,
+                            'issue with ' + this.definition.type + ' ' + key
+                        );
                     }
                     if (!findAssetKeys) {
                         Util.logger.info(
@@ -626,17 +629,19 @@ class MetadataType {
      * test if metadata was actually changed or not to potentially skip it during deployment
      *
      * @param {MetadataTypeItem} cachedVersion cached version from the server
-     * @param {MetadataTypeItem} metadata item to upload
+     * @param {MetadataTypeItem} metadataItem item to upload
      * @param {string} [fieldName] optional field name to use for identifying the record in logs
      * @param {boolean} [silent] optionally suppress logging
      * @returns {boolean} true on first identified deviation or false if none are found
      */
-    static hasChangedGeneric(cachedVersion, metadata, fieldName, silent) {
+    static hasChangedGeneric(cachedVersion, metadataItem, fieldName, silent) {
         if (!cachedVersion) {
             return true;
         }
         // we do need the full set in other places and hence need to work with a clone here
-        const clonedMetada = structuredClone(metadata);
+        const clonedMetada = structuredClone(metadataItem);
+        // keep copy of identifier in case it is among the non-updateable fields
+        const identifier = clonedMetada[fieldName || this.definition.keyField];
         this.removeNotUpdateableFields(clonedMetada);
         // iterate over what we want to upload rather than what we cached to avoid false positives
         for (const prop in clonedMetada) {
@@ -652,7 +657,7 @@ class MetadataType {
                 if (clonedMetada[prop] != cachedVersion[prop]) {
                     Util.logger.debug(
                         `${this.definition.type}:: ${
-                            clonedMetada[fieldName || this.definition.keyField]
+                            identifier
                         }.${prop} changed: '${cachedVersion[prop]}' to '${clonedMetada[prop]}'`
                     );
                     return true;
@@ -661,7 +666,7 @@ class MetadataType {
                 // test complex objects here
                 Util.logger.debug(
                     `${this.definition.type}:: ${
-                        clonedMetada[fieldName || this.definition.keyField]
+                        identifier
                     }.${prop} changed: '${cachedVersion[prop]}' to '${clonedMetada[prop]}'`
                 );
                 return true;
@@ -669,8 +674,8 @@ class MetadataType {
         }
         if (!silent) {
             Util.logger.verbose(
-                ` ☇ skipping ${this.definition.type} ${clonedMetada[this.definition.keyField]} / ${
-                    clonedMetada[fieldName || this.definition.nameField]
+                ` ☇ skipping ${this.definition.type} ${identifier} / ${
+                    clonedMetada[this.definition.nameField] || ''
                 }: no change detected`
             );
         }
@@ -702,10 +707,13 @@ class MetadataType {
                     // do this in case something went wrong during pre-deploy steps to ensure the total counter is correct
                     hasError = true;
                     deployableMetadata = metadataMap[metadataKey];
-                    Util.logger.error(
+
+                    // * include ": ${ex.message}" in the error if this is ever turned back into Util.logger.error()
+                    Util.logger.errorStack(
+                        ex,
                         ` ☇ skipping ${this.definition.type} ${
                             deployableMetadata[this.definition.keyField]
-                        } / ${deployableMetadata[this.definition.nameField]}: ${ex.message}`
+                        } / ${deployableMetadata[this.definition.nameField]}`
                     );
                 }
                 // if preDeploy returns nothing then it cannot be deployed so skip deployment
@@ -723,10 +731,7 @@ class MetadataType {
                     filteredByPreDeploy++;
                 }
             } catch (ex) {
-                Util.logger.errorStack(
-                    ex,
-                    `Upserting ${this.definition.type} failed: ${ex.message}`
-                );
+                Util.logger.errorStack(ex, `Upserting ${this.definition.type} failed`);
             }
         }
         const createLimit = pLimit(10);
@@ -827,6 +832,11 @@ class MetadataType {
 
             normalizedKey = File.reverseFilterIllegalFilenames(newKey);
         }
+        const cacheMatchedByKey = cache.getByKey(this.definition.type, normalizedKey);
+        const cacheMatchedByName = cacheMatchedByKey
+            ? null
+            : this.getCacheMatchedByName(metadataMap[metadataKey]);
+
         if (
             Util.logger.level === 'debug' &&
             metadataMap[metadataKey][this.definition.idField] &&
@@ -849,9 +859,9 @@ class MetadataType {
                 });
                 return 'update';
             }
-        } else if (cache.getByKey(this.definition.type, normalizedKey)) {
+        } else if (cacheMatchedByKey || cacheMatchedByName) {
             // normal way of processing update files
-            const cachedVersion = cache.getByKey(this.definition.type, normalizedKey);
+            const cachedVersion = cacheMatchedByKey || cacheMatchedByName;
             if (!this.hasChanged(cachedVersion, metadataMap[metadataKey])) {
                 hasError = true;
             }
@@ -1002,6 +1012,17 @@ class MetadataType {
         }
     }
 
+    /**
+     * helper for {@link MetadataType.createOrUpdate}
+     *
+     * @param {MetadataTypeItem} metadataItem to be deployed item
+     * @returns {MetadataTypeItem} cached item or undefined
+     */
+    static getCacheMatchedByName(metadataItem) {
+        // not supported generically
+        return null;
+    }
+
     /**
      * Creates a single metadata entry via REST
      *

package/lib/metadataTypes/definitions/Asset.definition.js

@@ -9,6 +9,7 @@ export default {
     keyIsFixed: false,
     keyField: 'customerKey',
     nameField: 'name',
+    folderIdField: 'category.id',
     createdDateField: 'createdDate',
     createdNameField: 'createdBy.name',
     lastmodDateField: 'modifiedDate',
@@ -20,6 +21,7 @@ export default {
     typeRetrieveByDefault: ['asset', 'code', 'textfile', 'block', 'message', 'template', 'other'],
     typeName: 'Asset-[Subtype]',
     stringifyFieldsBeforeTemplate: ['memberId', 'enterpriseId'],
+    allowMatchingByName: true,
     fields: {
         activeDate: {
             isCreateable: false,

package/lib/metadataTypes/definitions/Event.definition.js

@@ -263,14 +263,14 @@ export default {
             template: true,
         },
         'configurationArguments.relatedObjectFilterCriteria': {
-            isCreateable: false,
-            isUpdateable: false,
+            isCreateable: true,
+            isUpdateable: true,
             retrieving: true,
             template: true,
         },
         'configurationArguments.relatedObjectFilterSummary': {
-            isCreateable: false,
-            isUpdateable: false,
+            isCreateable: true,
+            isUpdateable: true,
             retrieving: true,
             template: true,
         },