mcdev 7.0.3 → 7.1.0

package/lib/metadataTypes/Folder.js

@@ -17,6 +17,10 @@ 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').ListItem} ListItem
+ * @typedef {import('../../types/mcdev.d.js').ListMap} ListMap
+ * @typedef {import('../../types/mcdev.d.js').ListIdMap} ListIdMap
  */
 
 /**
@@ -32,20 +36,27 @@ class Folder extends MetadataType {
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {string[]} [subTypeArr] content type of folder
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise} Promise
+     * @returns {Promise.<{metadata: ListMap, type: string}>} Promise
      */
     static async retrieve(retrieveDir, additionalFields, subTypeArr, key) {
         if (key) {
             Util.logger.error(`Folder.retrieve() does not support key parameter`);
         }
-        const queryAllFolders = await this.retrieveHelper(additionalFields, true, subTypeArr);
-
+        /** @type {ListItem[]} */
+        const queryAllFolders = await this.retrieveHelper(additionalFields, false, subTypeArr);
         if (this.buObject.eid !== this.buObject.mid) {
-            queryAllFolders.push(
-                ...(await this.retrieveHelper(additionalFields, false, subTypeArr))
-            );
+            const selectedParentTypes = subTypeArr?.length
+                ? subTypeArr.filter((item) => this.definition.folderTypesFromParent.includes(item))
+                : subTypeArr;
+            if (!subTypeArr?.length || selectedParentTypes.length) {
+                queryAllFolders.push(
+                    ...(await this.retrieveHelper(additionalFields, true, selectedParentTypes))
+                );
+            }
         }
+
         const sortPairs = toposort(queryAllFolders.map((a) => [a.ParentFolder.ID, a.ID]));
+        /** @type {ListIdMap} */
         const idMap = {};
         for (const val of queryAllFolders) {
             // Contact Builder Lists create a folder called "Audiences" with the same Customer Key as the
@@ -64,6 +75,7 @@ class Folder extends MetadataType {
         }
 
         // create root node for attaching, but will be deleted later
+        // @ts-expect-error we set an incomplete ListItem for ID==0 which is flagged by ts
         idMap[0] = {
             Name: '<ROOT>',
         };
@@ -113,6 +125,7 @@ class Folder extends MetadataType {
         }
 
         // build a new map using the customer key instead of id
+        /** @type {ListMap} */
         const metadata = {};
         for (const id in idMap) {
             // remove keys which are listed in other BUs and skip root
@@ -156,7 +169,7 @@ class Folder extends MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
             );
         }
-        return { metadata: metadata, type: this.definition.type };
+        return { metadata, type: this.definition.type };
     }
 
     /**
@@ -164,7 +177,7 @@ class Folder extends MetadataType {
      *
      * @param {void | string[]} [_] parameter not used
      * @param {string[]} [subTypeArr] content type of folder
-     * @returns {Promise} Promise
+     * @returns {Promise.<{metadata: ListMap, type: string}>} Promise
      */
     static retrieveForCache(_, subTypeArr) {
         return this.retrieve(null, null, subTypeArr, null);
@@ -175,8 +188,8 @@ class Folder extends MetadataType {
      * and comparing to check if create or update operation is needed.
      * Copied due to having a dependency on itself, meaning the created need to be serial
      *
-     * @param {MetadataTypeMap} metadata metadata mapped by their keyField
-     * @returns {Promise.<object>} Promise of saved metadata
+     * @param {ListMap} metadata metadata mapped by their keyField
+     * @returns {Promise.<ListMap>} Promise of saved metadata
      */
     static async upsert(metadata) {
         const orignalMetadata = structuredClone(metadata);
@@ -185,6 +198,7 @@ class Folder extends MetadataType {
         let createCount = 0;
         let createFailedCount = 0;
         let filteredByPreDeploy = 0;
+        /** @type {ListMap} */
         const upsertResults = {};
         const sortPairs = toposort(
             Object.keys(metadata).map((customerKey) => [
@@ -262,6 +276,15 @@ class Folder extends MetadataType {
                                     continue;
                                 }
                             }
+                            if (existingId && Util.OPTIONS.noUpdate) {
+                                Util.logger.verbose(
+                                    ` - skipping ${this.definition.type} ${
+                                        deployableMetadata?.Path ||
+                                        deployableMetadata[this.definition.nameField]
+                                    }: --noUpdate flag is set`
+                                );
+                                continue;
+                            }
 
                             let result;
                             // since deployableMetadata will be modified for deploy, make a copy for reference
@@ -339,12 +362,12 @@ class Folder extends MetadataType {
     /**
      * creates a folder based on metatadata
      *
-     * @param {MetadataTypeItem} metadataEntry metadata of the folder
-     * @returns {Promise} Promise
+     * @param {ListItem} metadataEntry metadata of the folder
+     * @returns {Promise.<any>} Promise of api response
      */
     static async create(metadataEntry) {
-        if (metadataEntry?.Parent?.ID === 0) {
-            Util.logger.error(
+        if (metadataEntry?.ParentFolder?.ID === 0) {
+            Util.logger.debug(
                 `${this.definition.type}-${metadataEntry.ContentType}.create:: Cannot create Root Folder: ${metadataEntry.Name}`
             );
             return {};
@@ -361,7 +384,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: [
@@ -405,7 +428,7 @@ class Folder extends MetadataType {
      * Updates a single Folder.
      *
      * @param {MetadataTypeItem} metadataEntry single metadata entry
-     * @returns {Promise} Promise
+     * @returns {Promise.<any>} Promise of api response
      */
     static async update(metadataEntry) {
         const path = metadataEntry.Path;
@@ -434,8 +457,8 @@ class Folder extends MetadataType {
     /**
      * prepares a folder for deployment
      *
-     * @param {MetadataTypeItem} metadata a single folder definition
-     * @returns {Promise.<MetadataTypeItem>} Promise of parsed folder metadata
+     * @param {ListItem} metadata a single folder definition
+     * @returns {Promise.<ListItem>} Promise of parsed folder metadata
      */
     static async preDeployTasks(metadata) {
         if (!this.definition.deployFolderTypes.includes(metadata.ContentType.toLowerCase())) {
@@ -467,12 +490,7 @@ class Folder extends MetadataType {
         }
         // retreive ID based on the matching Path of the parent folder
         else if (metadata?.ParentFolder?.Path) {
-            metadata.ParentFolder.ID = cache.searchForField(
-                'folder',
-                metadata.ParentFolder.Path,
-                'Path',
-                'ID'
-            );
+            metadata.ParentFolder.ID = cache.getFolderId(metadata.ParentFolder.Path);
             return metadata;
         } else {
             Util.metadataLogger(
@@ -488,13 +506,13 @@ class Folder extends MetadataType {
     /**
      * Returns file contents mapped to their filename without '.json' ending
      *
-     * @param {string} dir directory that contains '.json' files to be read
+     * @param {string} dir directory with json files, e.g. /retrieve/cred/bu/folder, /deploy/cred/bu/folder, /template/folder
      * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
-     * @returns {Promise.<MetadataTypeMap>} fileName => fileContent map
+     * @returns {Promise.<ListMap>} fileName => fileContent map
      */
     static async getJsonFromFS(dir, listBadKeys) {
         try {
-            /** @type {MetadataTypeMap} */
+            /** @type {ListMap} */
             const fileName2FileContent = {};
             const directories = File.readDirectoriesSync(dir, 10, true);
             let newCounter = 0;
@@ -564,28 +582,24 @@ class Folder extends MetadataType {
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {boolean} [queryAllAccounts] which queryAllAccounts setting to use
      * @param {string[]} [contentTypeList] content type of folder
-     * @returns {Promise.<object>} soap object
+     * @returns {Promise.<ListItem[]>} soap object
      */
     static async retrieveHelper(additionalFields, queryAllAccounts, contentTypeList) {
         const options = { QueryAllAccounts: !!queryAllAccounts };
         if (contentTypeList) {
-            for (const contentType of contentTypeList) {
-                options.filter = options.filter
-                    ? {
-                          leftOperand: {
-                              leftOperand: 'ContentType',
-                              operator: 'equals',
-                              rightOperand: contentType,
-                          },
-                          operator: 'OR',
-                          rightOperand: options.filter,
-                      }
-                    : {
-                          leftOperand: 'ContentType',
-                          operator: 'equals',
-                          rightOperand: contentType,
-                      };
-            }
+            const newFilter = {
+                leftOperand: 'ContentType',
+                operator: contentTypeList.length === 1 ? 'equals' : 'IN',
+                rightOperand:
+                    contentTypeList.length === 1 ? contentTypeList[0] : contentTypeList.sort(),
+            };
+            options.filter = options.filter
+                ? {
+                      leftOperand: newFilter,
+                      operator: 'OR',
+                      rightOperand: options.filter,
+                  }
+                : newFilter;
         }
         const response = await this.client.soap.retrieveBulk(
             'DataFolder',
@@ -599,8 +613,8 @@ class Folder extends MetadataType {
     /**
      * Gets executed after retreive of metadata type
      *
-     * @param {MetadataTypeItem} metadata metadata mapped by their keyField
-     * @returns {MetadataTypeItem} cloned metadata
+     * @param {ListItem} metadata metadata mapped by their keyField
+     * @returns {ListItem} cloned metadata
      */
     static postRetrieveTasks(metadata) {
         return structuredClone(metadata);
@@ -608,12 +622,13 @@ class Folder extends MetadataType {
     /**
      * Helper for writing Metadata to disk, used for Retrieve and deploy
      *
-     * @param {MetadataTypeMap} results metadata results from deploy
+     * @param {ListMap} results metadata results from deploy
      * @param {string} retrieveDir directory where metadata should be stored after deploy/retrieve
      * @param {number | string} mid unused parameter
-     * @returns {Promise.<object>} Promise of saved metadata
+     * @returns {Promise.<ListMap>} Promise of saved metadata
      */
     static async saveResults(results, retrieveDir, mid) {
+        /** @type {ListMap} */
         const savedResults = {};
         for (const metadataEntry in results) {
             try {