mcdev 3.0.1 → 3.1.1

package/lib/metadataTypes/Folder.js

@@ -13,16 +13,16 @@ class Folder extends MetadataType {
     /**
      * Retrieves metadata of metadata type into local filesystem. executes callback with retrieved metadata
      * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {String[]} [overrideFields] Returns specified fields even if their retrieve definition is not set to true
+     * @param {String[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {Object} buObject properties for auth
      * @returns {Promise} Promise
      */
-    static async retrieve(retrieveDir, overrideFields, buObject) {
-        const queryAllFolders = await this.retrieveHelper(overrideFields, true);
+    static async retrieve(retrieveDir, additionalFields, buObject) {
+        const queryAllFolders = await this.retrieveHelper(additionalFields, true);
         // if this is the parent, no need to query twice as QueryAllAccounts works.
 
         if (buObject.eid !== buObject.mid) {
-            queryAllFolders.push(...(await this.retrieveHelper(overrideFields, false)));
+            queryAllFolders.push(...(await this.retrieveHelper(additionalFields, false)));
         }
         const sortPairs = toposort(queryAllFolders.map((a) => [a.ParentFolder.ID, a.ID]));
         const idMap = {};
@@ -258,39 +258,36 @@ class Folder extends MetadataType {
      * @param {Object} metadata metadata of the folder
      * @returns {Promise} Promise
      */
-    static create(metadata) {
-        const tempCustomerKey = metadata.CustomerKey;
+    static async create(metadata) {
+        if (metadata.Parent && metadata.Parent.ID && metadata.Parent.ID === 0) {
+            Util.logger.error(
+                `${this.definition.type}-${metadata.ContentType}.create:: Cannot create Root Folder: ${metadata.Name}`
+            );
+            return {};
+        }
         const path = metadata.Path;
-        this.removeNotCreateableFields(metadata);
-        return new Promise((resolve) => {
-            if (metadata.Parent && metadata.Parent.ID && metadata.Parent.ID === 0) {
+        try {
+            const response = await super.createSOAP(metadata, 'DataFolder', true);
+            if (response) {
+                response.body.Results[0].Object = metadata;
+                response.body.Results[0].Object.ID = response.body.Results[0].NewID;
+                response.body.Results[0].Object.CustomerKey = metadata.CustomerKey;
+                delete response.body.Results[0].Object.$;
+
+                Util.logger.info(`- created folder: ${path}`);
+                return response;
+            }
+        } catch (ex) {
+            if (ex && ex.results) {
                 Util.logger.error(
-                    `${this.definition.type}-${metadata.ContentType}.create:: Cannot create Root Folder: ${metadata.Name}`
+                    `${this.definition.type}-${metadata.ContentType}.create:: error creating: '${path}'. ${ex.results[0].StatusMessage}`
+                );
+            } else if (ex) {
+                Util.logger.error(
+                    `${this.definition.type}-${metadata.ContentType}.create:: error creating: '${path}'. ${ex.message}`
                 );
-                resolve({});
-            } else {
-                this.client.SoapClient.create('DataFolder', metadata, null, (ex, response) => {
-                    if (ex && ex.results) {
-                        Util.logger.error(
-                            `${this.definition.type}-${metadata.ContentType}.create:: error creating: ${path}. ${ex.results[0].StatusMessage}`
-                        );
-                        resolve();
-                    } else if (ex) {
-                        Util.logger.error(
-                            `${this.definition.type}-${metadata.ContentType}.create:: error creating: ${path}. ${ex.message}`
-                        );
-                        resolve();
-                    } else {
-                        response.body.Results[0].Object = metadata;
-                        response.body.Results[0].Object.ID = response.body.Results[0].NewID;
-                        response.body.Results[0].Object.CustomerKey = tempCustomerKey;
-                        delete response.body.Results[0].Object.$;
-                        Util.logger.info(`- created folder: ${path}`);
-                        resolve(response);
-                    }
-                });
             }
-        });
+        }
     }
 
     /**
@@ -299,30 +296,27 @@ class Folder extends MetadataType {
      * @returns {Promise} Promise
      */
     static async update(metadata) {
-        return await new Promise((resolve) => {
-            const tempCustomerKey = metadata.CustomerKey;
-            const path = metadata.Path;
-            this.removeNotUpdateableFields(metadata);
-            this.client.SoapClient.update('DataFolder', metadata, null, (ex, response) => {
-                if (ex && ex.results) {
-                    Util.logger.error(
-                        `${this.definition.type}-${metadata.ContentType}.update:: error updating: '${path}'. ${ex.results[0].StatusMessage}`
-                    );
-                    resolve();
-                } else if (ex) {
-                    Util.logger.error(
-                        `${this.definition.type}-${metadata.ContentType}.update:: error updating: '${path}'. ${ex.message}`
-                    );
-                    resolve();
-                } else {
-                    response.body.Results[0].Object = metadata;
-                    response.body.Results[0].Object.CustomerKey = tempCustomerKey;
-                    delete response.body.Results[0].Object.$;
-                    Util.logger.info(`- updated folder: ${path}`);
-                    resolve(response);
-                }
-            });
-        });
+        const path = metadata.Path;
+        try {
+            const response = await super.updateSOAP(metadata, 'DataFolder', true);
+            if (response) {
+                response.body.Results[0].Object = metadata;
+                response.body.Results[0].Object.CustomerKey = metadata.CustomerKey;
+                delete response.body.Results[0].Object.$;
+                Util.logger.info(`- updated folder: ${path}`);
+                return response;
+            }
+        } catch (ex) {
+            if (ex && ex.results) {
+                Util.logger.error(
+                    `${this.definition.type}-${metadata.ContentType}.update:: error updating: '${path}'. ${ex.results[0].StatusMessage}`
+                );
+            } else if (ex) {
+                Util.logger.error(
+                    `${this.definition.type}-${metadata.ContentType}.update:: error updating: '${path}'. ${ex.message}`
+                );
+            }
+        }
     }
 
     /**
@@ -451,25 +445,28 @@ class Folder extends MetadataType {
 
     /**
      * Helper to retrieve the folders as promise
-     * @param {String[]} [overrideFields] Returns specified fields even if their retrieve definition is not set to true
+     * @param {String[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {Boolean} [queryAllAccounts] which queryAllAccounts setting to use
      * @returns {Promise<Object>} soap object
      */
-    static async retrieveHelper(overrideFields, queryAllAccounts) {
+    static async retrieveHelper(additionalFields, queryAllAccounts) {
         const options = { queryAllAccounts: !!queryAllAccounts };
         let status = 'MoreDataAvailable';
         const Results = [];
         do {
-            const response = await new Promise((resolve, reject) => {
-                // filtered out path as we need them to be stored locally, but do not want to try and retrieve
-                this.client.SoapClient.retrieve(
-                    'DataFolder',
-                    this.getFieldNamesToRetrieve(overrideFields).filter(
-                        (field) => !field.includes('Path')
-                    ),
-                    options,
-                    (ex, response) => (ex ? reject(ex) : resolve(response))
-                );
+            let response;
+            await Util.retryOnError(`Retrying ${this.definition.type}`, async () => {
+                response = await new Promise((resolve, reject) => {
+                    // filtered out path as we need them to be stored locally, but do not want to try and retrieve
+                    this.client.SoapClient.retrieve(
+                        'DataFolder',
+                        this.getFieldNamesToRetrieve(additionalFields).filter(
+                            (field) => !field.includes('Path')
+                        ),
+                        options,
+                        (ex, response) => (ex ? reject(ex) : resolve(response))
+                    );
+                });
             });
             // merge results with existing
             Results.push(...response.body.Results);

package/lib/metadataTypes/ImportFile.js

@@ -147,12 +147,10 @@ class ImportFile extends MetadataType {
             }
         }
         // When the destinationObjectTypeId is 584 is refers to Mobile Connect which is not supported as an Import Type
-        metadata.destinationObjectTypeId = this.definition.destinationObjectTypeMapping[
-            metadata.c__destinationType
-        ];
-        metadata.subscriberImportTypeId = this.definition.subscriberImportTypeMapping[
-            metadata.c__subscriberImportType
-        ];
+        metadata.destinationObjectTypeId =
+            this.definition.destinationObjectTypeMapping[metadata.c__destinationType];
+        metadata.subscriberImportTypeId =
+            this.definition.subscriberImportTypeMapping[metadata.c__subscriberImportType];
         metadata.updateTypeId = this.definition.updateTypeMapping[metadata.c__dataAction];
         return metadata;
     }

package/lib/metadataTypes/MetadataType.js

@@ -194,16 +194,26 @@ class MetadataType {
     /**
      * Gets metadata from Marketing Cloud
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {string[]} [overrideFields] Returns specified fields even if their retrieve definition is not set to true
+     * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {Util.BuObject} buObject properties for auth
      * @param {string} [subType] optionally limit to a single subtype
      * @returns {Promise<{metadata:MetadataTypeMap,type:string}>} metadata
      */
-    static retrieve(retrieveDir, overrideFields, buObject, subType) {
+    static retrieve(retrieveDir, additionalFields, buObject, subType) {
         Util.metadataLogger('error', this.definition.type, 'retrieve', `Not Supported`);
         const metadata = {};
         return { metadata: null, type: this.definition.type };
     }
+    /**
+     * Gets metadata from Marketing Cloud
+     * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
+     * @param {Util.BuObject} buObject properties for auth
+     * @param {string} [subType] optionally limit to a single subtype
+     * @returns {Promise<{metadata:MetadataTypeMap,type:string}>} metadata
+     */
+    static retrieveChangelog(additionalFields, buObject, subType) {
+        return this.retrieve(null, additionalFields, buObject, subType);
+    }
 
     /**
      * Gets metadata cache with limited fields and does not store value to disk
@@ -304,9 +314,10 @@ class MetadataType {
                         });
                     } else if (this.cache[this.definition.type][normalizedKey]) {
                         // normal way of processing update files
-                        metadata[metadataKey][this.definition.idField] = this.cache[
-                            this.definition.type
-                        ][normalizedKey][this.definition.idField];
+                        metadata[metadataKey][this.definition.idField] =
+                            this.cache[this.definition.type][normalizedKey][
+                                this.definition.idField
+                            ];
                         metadataToUpdate.push({
                             before: this.cache[this.definition.type][normalizedKey],
                             after: metadata[metadataKey],
@@ -403,31 +414,54 @@ class MetadataType {
     /**
      * Creates a single metadata entry via fuel-soap (generic lib not wrapper)
      * @param {MetadataTypeItem} metadataEntry single metadata entry
+     * @param {string} [overrideType] can be used if the API type differs from the otherwise used type identifier
+     * @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 createSOAP(metadataEntry) {
+    static async createSOAP(metadataEntry, overrideType, handleOutside) {
         try {
-            const res = await new Promise((resolve, reject) => {
-                this.removeNotCreateableFields(metadataEntry);
-                this.client.SoapClient.create(
-                    this.definition.type.charAt(0).toUpperCase() + this.definition.type.slice(1),
-                    metadataEntry,
-                    null,
-                    (error, response) => (error ? reject(error) : resolve(response))
-                );
-            });
-            Util.logger.info(
-                `- created ${this.definition.type}: ${metadataEntry[this.definition.keyField]}`
+            this.removeNotCreateableFields(metadataEntry);
+            let response;
+            await Util.retryOnError(
+                `Retrying to create ${this.definition.type}: ${
+                    metadataEntry[this.definition.nameField]
+                }`,
+                async () =>
+                    (response = await new Promise((resolve, reject) => {
+                        this.client.SoapClient.create(
+                            overrideType ||
+                                this.definition.type.charAt(0).toUpperCase() +
+                                    this.definition.type.slice(1),
+                            metadataEntry,
+                            null,
+                            (error, response) => (error ? reject(error) : resolve(response))
+                        );
+                    }))
             );
-            return res;
+            if (!handleOutside) {
+                Util.logger.info(
+                    `- created ${this.definition.type}: ${metadataEntry[this.definition.keyField]}`
+                );
+            }
+            return response;
         } catch (ex) {
-            Util.logger.error(
-                `- error creating ${this.definition.type}: ${
-                    metadataEntry[this.definition.keyField]
-                } (${ex.message})`
-            );
+            if (!handleOutside) {
+                let errorMsg;
+                if (ex.results && ex.results.length) {
+                    errorMsg = `${ex.results[0].StatusMessage} (Code ${ex.results[0].ErrorCode})`;
+                } else {
+                    errorMsg = ex.message;
+                }
+                Util.logger.error(
+                    `- error creating ${this.definition.type} '${
+                        metadataEntry[this.definition.keyField]
+                    }': ${errorMsg}`
+                );
+            } else {
+                throw ex;
+            }
 
-            return null;
+            return {};
         }
     }
 
@@ -451,8 +485,12 @@ class MetadataType {
                 async () => (response = await this.client.RestClient.patch(options))
             );
             this.checkForErrors(response);
+            // some times, e.g. automation dont return a key in their update response and hence we need to fall back to name
             Util.logger.info(
-                `- updated ${this.definition.type}: ${metadataEntry[this.definition.keyField]}`
+                `- updated ${this.definition.type}: ${
+                    metadataEntry[this.definition.keyField] ||
+                    metadataEntry[this.definition.nameField]
+                }`
             );
             return response;
         } catch (ex) {
@@ -468,31 +506,54 @@ class MetadataType {
     /**
      * Updates a single metadata entry via fuel-soap (generic lib not wrapper)
      * @param {MetadataTypeItem} metadataEntry single metadata entry
+     * @param {string} [overrideType] can be used if the API type differs from the otherwise used type identifier
+     * @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 updateSOAP(metadataEntry) {
+    static async updateSOAP(metadataEntry, overrideType, handleOutside) {
+        let response;
         try {
-            const res = await new Promise((resolve, reject) => {
-                this.removeNotUpdateableFields(metadataEntry);
-                this.client.SoapClient.update(
-                    this.definition.type.charAt(0).toUpperCase() + this.definition.type.slice(1),
-                    metadataEntry,
-                    null,
-                    (error, response) => (error ? reject(error) : resolve(response))
-                );
-            });
-            Util.logger.info(
-                `- updated ${this.definition.type}: ${metadataEntry[this.definition.keyField]}`
+            this.removeNotUpdateableFields(metadataEntry);
+            await Util.retryOnError(
+                `Retrying to update ${this.definition.type}: ${
+                    metadataEntry[this.definition.nameField]
+                }`,
+                async () =>
+                    (response = await new Promise((resolve, reject) => {
+                        this.client.SoapClient.update(
+                            overrideType ||
+                                this.definition.type.charAt(0).toUpperCase() +
+                                    this.definition.type.slice(1),
+                            metadataEntry,
+                            null,
+                            (error, response) => (error ? reject(error) : resolve(response))
+                        );
+                    }))
             );
-            return res;
+            if (!handleOutside) {
+                Util.logger.info(
+                    `- updated ${this.definition.type}: ${metadataEntry[this.definition.keyField]}`
+                );
+            }
+            return response;
         } catch (ex) {
-            Util.logger.error(
-                `- error updating ${this.definition.type}: ${
-                    metadataEntry[this.definition.keyField]
-                } (${ex.message})`
-            );
+            if (!handleOutside) {
+                let errorMsg;
+                if (ex.results && ex.results.length) {
+                    errorMsg = `${ex.results[0].StatusMessage} (Code ${ex.results[0].ErrorCode})`;
+                } else {
+                    errorMsg = ex.message;
+                }
+                Util.logger.error(
+                    `- error updating ${this.definition.type} '${
+                        metadataEntry[this.definition.keyField]
+                    }': ${errorMsg}`
+                );
+            } else {
+                throw ex;
+            }
 
-            return null;
+            return {};
         }
     }
     /**
@@ -501,18 +562,24 @@ class MetadataType {
      * @param {Util.BuObject} buObject properties for auth
      * @param {Object} [options] required for the specific request (filter for example)
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
+     * @param {string} [overrideType] can be used if the API type differs from the otherwise used type identifier
      * @returns {Promise<{metadata:MetadataTypeMap,type:string}>} Promise of item map
      */
-    static async retrieveSOAPgeneric(retrieveDir, buObject, options, additionalFields) {
+    static async retrieveSOAPgeneric(
+        retrieveDir,
+        buObject,
+        options,
+        additionalFields,
+        overrideType
+    ) {
         const fields = this.getFieldNamesToRetrieve(additionalFields);
 
-        const metadata = await this.retrieveSOAPBody(fields, options);
+        const metadata = await this.retrieveSOAPBody(fields, options, overrideType);
         if (retrieveDir) {
             const savedMetadata = await this.saveResults(metadata, retrieveDir, null);
             Util.logger.info(
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
             );
-
             if (
                 buObject &&
                 this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)
@@ -536,23 +603,27 @@ class MetadataType {
         options = options || {};
         let metadata = {};
         do {
-            const resultsBatch = await new Promise((resolve) => {
-                this.client.SoapClient.retrieve(
-                    type || this.definition.type,
-                    fields,
-                    options || {},
-                    (error, response) => {
-                        if (error) {
-                            Util.logger.debug(`SOAP.retrieve Error: ${error.message}`);
+            let resultsBatch;
+            await Util.retryOnError(`Retrying ${this.definition.type}`, async () => {
+                resultsBatch = await new Promise((resolve, reject) => {
+                    this.client.SoapClient.retrieve(
+                        type || this.definition.type,
+                        fields,
+                        options || {},
+                        (error, response) => {
+                            if (error) {
+                                Util.logger.debug(`SOAP.retrieve Error: ${error.message}`);
+                                reject(error);
+                            }
+                            if (response) {
+                                resolve(response.body);
+                            } else {
+                                // fallback, lets make sure surrounding methods know we got an empty result back
+                                resolve({});
+                            }
                         }
-                        if (response) {
-                            resolve(response.body);
-                        } else {
-                            // fallback, lets make sure surrounding methods know we got an empty result back
-                            resolve({});
-                        }
-                    }
-                );
+                    );
+                });
             });
             status = resultsBatch.OverallStatus;
             if (status === 'MoreDataAvailable') {
@@ -591,11 +662,9 @@ class MetadataType {
         do {
             options.uri = this.paginate(options.uri, lastPage);
             let response;
-            try {
+            await Util.retryOnError(`Retrying ${this.definition.type}`, async () => {
                 response = await this.client.RestClient.get(options);
-            } catch (ex) {
-                Util.logger.debug(ex.message);
-            }
+            });
             const metadata = this.parseResponseBody(response.body);
             results = Object.assign(results, metadata);
             if (

package/lib/metadataTypes/Query.js

@@ -144,9 +144,8 @@ class Query extends MetadataType {
         } catch (ex) {
             throw new Error(`Query '${metadata.key}': ${ex.message}`);
         }
-        metadata.targetUpdateTypeId = this.definition.targetUpdateTypeMapping[
-            metadata.targetUpdateTypeName
-        ];
+        metadata.targetUpdateTypeId =
+            this.definition.targetUpdateTypeMapping[metadata.targetUpdateTypeName];
         return metadata;
     }
 

package/lib/metadataTypes/Role.js

@@ -107,14 +107,19 @@ class Role extends MetadataType {
             return;
         }
         if (!metadata) {
-            metadata = this.readBUMetadataForType(
-                File.normalizePath([
-                    this.properties.directories.retrieve,
-                    buObject.credential,
-                    Util.parentBuName,
-                ]),
-                true
-            ).role;
+            try {
+                metadata = this.readBUMetadataForType(
+                    File.normalizePath([
+                        this.properties.directories.retrieve,
+                        buObject.credential,
+                        Util.parentBuName,
+                    ]),
+                    true
+                ).role;
+            } catch (ex) {
+                Util.logger.error(ex.message);
+                return;
+            }
         }
         const directory = this.properties.directories.roles;