mcdev 4.2.1 → 4.3.1

package/lib/metadataTypes/List.js

@@ -18,12 +18,11 @@ class List extends MetadataType {
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
-     * @param {TYPE.BuObject} buObject properties for auth
-     * @param {void} [___] unused parameter
+     * @param {void} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
-    static async retrieve(retrieveDir, _, buObject, ___, key) {
+    static async retrieve(retrieveDir, _, __, key) {
         /** @type {TYPE.SoapRequestParams} */
         let requestParams = null;
         if (key) {
@@ -44,29 +43,31 @@ class List extends MetadataType {
                 },
             };
         }
-        const results = await super.retrieveSOAP(retrieveDir, null, requestParams);
-        return await this._retrieveParentAllSubs(buObject, results);
+        const results = await super.retrieveSOAP(retrieveDir, requestParams);
+        return await this._retrieveParentAllSubs(results);
     }
     /**
      * Gets metadata cache with limited fields and does not store value to disk
      *
-     * @param {TYPE.BuObject} buObject properties for auth
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static async retrieveForCache(buObject) {
-        const results = await this.retrieve(null, null, buObject);
+    static async retrieveForCache() {
+        const results = await this.retrieve();
         if (!cache.getCache()?.folder) {
-            Util.logger.debug('folders not cached but required for list');
-            Util.logger.info(' - Caching dependent Metadata: folder');
-            Folder.client = this.client;
-            Folder.properties = this.properties;
-            const result = await Folder.retrieveForCache(buObject, [
+            const subTypeArr = [
                 'list',
                 'mysubs',
                 'suppression_list',
                 'publication',
                 'contextual_suppression_list',
-            ]);
+            ];
+            Util.logger.debug('folders not cached but required for list');
+            Util.logger.info(' - Caching dependent Metadata: folder');
+            Util.logSubtypes(subTypeArr);
+            Folder.client = this.client;
+            Folder.buObject = this.buObject;
+            Folder.properties = this.properties;
+            const result = await Folder.retrieveForCache(null, subTypeArr);
             cache.setMetadata('folder', result.metadata);
         }
         for (const metadataEntry in results.metadata) {
@@ -78,27 +79,30 @@ class List extends MetadataType {
     /**
      * helper for @link retrieveForCache and @link retrieve
      *
-     * @param {TYPE.BuObject} buObject properties for auth
+     * @private
      * @param {TYPE.MetadataTypeMapObj} results metadata from retrieve for current BU
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
-    static async _retrieveParentAllSubs(buObject, results) {
-        if (buObject.eid !== buObject.mid) {
+    static async _retrieveParentAllSubs(results) {
+        if (this.buObject.eid !== this.buObject.mid) {
             // for caching, we want to get the All Subscriber List from the Parent Account
             Util.logger.debug(' - Checking MasterUnsubscribeBehavior for current BU');
             /** @type {TYPE.BuObject} */
             const buObjectParentBu = {
-                eid: this.properties.credentials[buObject.credential].eid,
-                mid: this.properties.credentials[buObject.credential].eid,
+                eid: this.properties.credentials[this.buObject.credential].eid,
+                mid: this.properties.credentials[this.buObject.credential].eid,
                 businessUnit: Util.parentBuName,
-                credential: buObject.credential,
+                credential: this.buObject.credential,
             };
+            const clientBackup = this.client;
+            const buObjectBackup = this.buObject;
             try {
                 this.client = auth.getSDK(buObjectParentBu);
             } catch (ex) {
                 Util.logger.error(ex.message);
                 return;
             }
+            this.buObject = buObjectParentBu;
             const buResult = await this.client.soap.retrieve(
                 'BusinessUnit',
                 ['MasterUnsubscribeBehavior'],
@@ -107,7 +111,7 @@ class List extends MetadataType {
                     filter: {
                         leftOperand: 'ID',
                         operator: 'equals',
-                        rightOperand: this.properties.credentials[buObject.credential].eid,
+                        rightOperand: this.properties.credentials[this.buObject.credential].eid,
                     },
                 }
             );
@@ -117,13 +121,8 @@ class List extends MetadataType {
                 Util.logger.info(
                     ' - Caching dependent Metadata: All Subscriber list (on _ParentBU_)'
                 );
-                const metadataParentBu = await this.retrieve(
-                    null,
-                    null,
-                    buObjectParentBu,
-                    null,
-                    'All Subscribers'
-                );
+                // do not use retrieveForCache here because (a) it does not support key-filtering and (b) it would cache folders on top which we do not need for the global all subscriber list
+                const metadataParentBu = await this.retrieve(null, null, null, 'All Subscribers');
                 // manually set folder path of parent's All Subscriber List to avoid retrieving folders
                 for (const key of Object.keys(metadataParentBu.metadata)) {
                     metadataParentBu.metadata[key].r__folder_Path = 'my subscribers';
@@ -136,16 +135,21 @@ class List extends MetadataType {
                     }
                 }
 
+                // revert to current default
+                this.client = clientBackup;
+                this.buObject = buObjectBackup;
+
                 // make sure to overwrite parent bu DEs with local ones
                 return {
                     metadata: { ...metadataParentBu.metadata, ...results.metadata },
                     type: results.type,
                 };
             } else if (masterUnsubscribeBehavior === 'BUSINESS_UNIT_ONLY') {
+                // revert client to current default
+                this.client = clientBackup;
+
                 Util.logger.debug(' - BU uses own All Subscriber List');
             }
-            // revert client to current default
-            this.client = auth.getSDK(this.buObject);
         }
         return results;
     }
@@ -153,12 +157,11 @@ class List extends MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of data extension
      * @returns {Promise.<boolean>} deletion success status
      */
-    static deleteByKey(buObject, customerKey) {
-        return super.deleteByKeySOAP(buObject, customerKey, false);
+    static deleteByKey(customerKey) {
+        return super.deleteByKeySOAP(customerKey, false);
     }
 
     /**