mcdev 3.0.2 → 3.1.2

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)
@@ -538,7 +605,7 @@ class MetadataType {
         do {
             let resultsBatch;
             await Util.retryOnError(`Retrying ${this.definition.type}`, async () => {
-                resultsBatch = await new Promise((resolve) => {
+                resultsBatch = await new Promise((resolve, reject) => {
                     this.client.SoapClient.retrieve(
                         type || this.definition.type,
                         fields,
@@ -546,7 +613,7 @@ class MetadataType {
                         (error, response) => {
                             if (error) {
                                 Util.logger.debug(`SOAP.retrieve Error: ${error.message}`);
-                                throw error;
+                                reject(error);
                             }
                             if (response) {
                                 resolve(response.body);
@@ -1005,11 +1072,11 @@ class MetadataType {
         const savedResults = {};
         const subtypeExtension = '.' + (overrideType || this.definition.type) + '-meta';
         let filterCounter = 0;
-        for (const metadataEntry in results) {
+        for (const originalKey in results) {
             try {
                 if (
-                    this.isFiltered(results[metadataEntry], true) ||
-                    this.isFiltered(results[metadataEntry], false)
+                    this.isFiltered(results[originalKey], true) ||
+                    this.isFiltered(results[originalKey], false)
                 ) {
                     // if current metadata entry is filtered don't save it
                     filterCounter++;
@@ -1018,21 +1085,21 @@ class MetadataType {
                 // define directory into which the current metdata shall be saved
                 const baseDir = [retrieveDir, ...(overrideType || this.definition.type).split('-')];
 
-                results[metadataEntry] = await this.postRetrieveTasks(
-                    results[metadataEntry],
+                results[originalKey] = await this.postRetrieveTasks(
+                    results[originalKey],
                     retrieveDir,
                     templateVariables ? true : false
                 );
-                if (!results[metadataEntry] || results[metadataEntry] === null) {
+                if (!results[originalKey] || results[originalKey] === null) {
                     // we encountered a situation in our postRetrieveTasks that made us want to filter this record
-                    delete results[metadataEntry];
+                    delete results[originalKey];
                     filterCounter++;
                     continue;
                 }
 
                 if (
-                    this.isFilteredFolder(results[metadataEntry], true) ||
-                    this.isFilteredFolder(results[metadataEntry], false)
+                    this.isFilteredFolder(results[originalKey], true) ||
+                    this.isFilteredFolder(results[originalKey], false)
                 ) {
                     // if current metadata entry is filtered don't save it
                     filterCounter++;
@@ -1040,20 +1107,20 @@ class MetadataType {
                 }
 
                 // for complex types like asset, script, query we need to save the scripts that were extracted from the JSON
-                if (results[metadataEntry].json && results[metadataEntry].codeArr) {
+                if (results[originalKey].json && results[originalKey].codeArr) {
                     // replace market values with template variable placeholders (do not do it on .codeArr)
                     if (templateVariables) {
-                        results[metadataEntry].json = Util.replaceByObject(
-                            results[metadataEntry].json,
+                        results[originalKey].json = Util.replaceByObject(
+                            results[originalKey].json,
                             templateVariables
                         );
-                        results[metadataEntry].subFolder = Util.replaceByObject(
-                            results[metadataEntry].subFolder,
+                        results[originalKey].subFolder = Util.replaceByObject(
+                            results[originalKey].subFolder,
                             templateVariables
                         );
                     }
 
-                    const postRetrieveData = results[metadataEntry];
+                    const postRetrieveData = results[originalKey];
                     if (postRetrieveData.subFolder) {
                         // very complex types have their own subfolder
                         baseDir.push(...postRetrieveData.subFolder);
@@ -1074,13 +1141,13 @@ class MetadataType {
                         );
                     }
                     // normalize results[metadataEntry]
-                    results[metadataEntry] = postRetrieveData.json;
+                    results[originalKey] = postRetrieveData.json;
                 } else {
                     // not a complex type, run the the entire JSON through templating
                     // replace market values with template variable placeholders
                     if (templateVariables) {
-                        results[metadataEntry] = Util.replaceByObject(
-                            results[metadataEntry],
+                        results[originalKey] = Util.replaceByObject(
+                            results[originalKey],
                             templateVariables
                         );
                     }
@@ -1089,7 +1156,7 @@ class MetadataType {
                 // we dont store Id on local disk, but we need it for caching logic,
                 // so its in retrieve but not in save. Here we put into the clone so that the original
                 // object used for caching doesnt have the Id removed.
-                const saveClone = JSON.parse(JSON.stringify(results[metadataEntry]));
+                const saveClone = JSON.parse(JSON.stringify(results[originalKey]));
                 if (!this.definition.keepId) {
                     delete saveClone[this.definition.idField];
                 }
@@ -1099,22 +1166,16 @@ class MetadataType {
                 } else {
                     this.keepRetrieveFields(saveClone);
                 }
-                savedResults[metadataEntry] = saveClone;
+                savedResults[originalKey] = saveClone;
                 File.writeJSONToFile(
                     // manage subtypes
                     baseDir,
-                    saveClone[this.definition.keyField] + subtypeExtension,
+                    originalKey + subtypeExtension,
                     saveClone
                 );
             } catch (ex) {
                 console.log(ex.stack);
-                Util.metadataLogger(
-                    'error',
-                    this.definition.type,
-                    'saveResults',
-                    ex,
-                    metadataEntry
-                );
+                Util.metadataLogger('error', this.definition.type, 'saveResults', ex, originalKey);
             }
         }
         if (filterCounter) {

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;
 

package/lib/metadataTypes/Script.js

@@ -178,12 +178,12 @@ class Script extends MetadataType {
         templateName
     ) {
         // get SSJS from filesystem
-        let code = this._mergeCode(metadata, templateDir, templateName);
-
+        let code = await this._mergeCode(metadata, templateDir, templateName);
         // replace template variables with their values
         try {
             code = Mustache.render(code, variables);
         } catch (ex) {
+            Util.logger.debug('script.buildDefinitionForExtracts: ' + ex.message);
             throw new Error(
                 `${this.definition.type}:: Error applying template variables on ${
                     metadata[this.definition.keyField] + '.' + this.definition.type

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

@@ -0,0 +1,227 @@
+module.exports = {
+    bodyIteratorField: 'Results',
+    dependencies: [],
+    folderType: null,
+    hasExtended: false,
+    idField: 'ID',
+    keyField: 'CustomerKey',
+    nameField: 'Name',
+    type: 'accountUser',
+    typeDescription: 'Marketing Cloud users',
+    typeName: 'User',
+    typeRetrieveByDefault: false,
+    fields: {
+        AccountUserID: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        ActiveFlag: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        AssociatedBusinessUnits: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: null,
+        },
+        BusinessUnit: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: null,
+        },
+        ChallengeAnswer: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        ChallengePhrase: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        Client: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        CorrelationID: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: null,
+        },
+        CreatedDate: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        CustomerKey: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        DefaultApplication: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: null,
+        },
+        DefaultBusinessUnit: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        DefaultBusinessUnitObject: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: null,
+        },
+        Delete: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        Email: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        ID: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        IsAPIUser: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        IsLocked: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        LanguageLocale: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: null,
+        },
+        LastSuccessfulLogin: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        Locale: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        ModifiedDate: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        MustChangePassword: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        Name: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        NotificationEmailAddress: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        ObjectID: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        ObjectState: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        Owner: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        PartnerKey: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        PartnerProperties: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: null,
+        },
+        Password: { isCreateable: null, isUpdateable: null, retrieving: false, template: false },
+        Roles: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        'Roles.Role': {
+            skipValidation: false,
+        },
+        'Roles.Role[].Client': {
+            skipValidation: false,
+        },
+        SsoIdentities: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: null,
+        },
+        TimeZone: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        Unlock: { isCreateable: null, isUpdateable: null, retrieving: false, template: null },
+        UserID: { isCreateable: null, isUpdateable: null, retrieving: true, template: false },
+        UserPermissions: {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: true,
+            template: false,
+        },
+        'UserPermissions.PartnerKey': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions.ID': {
+            skipValidation: true,
+        },
+        'UserPermissions.ObjectID': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions.Name': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions.Value': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions.Description': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions.Delete': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions[].PartnerKey': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions[].ID': {
+            skipValidation: true,
+        },
+        'UserPermissions[].ObjectID': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions[].Name': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions[].Value': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions[].Description': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        'UserPermissions[].Delete': {
+            isCreateable: null,
+            isUpdateable: null,
+            retrieving: false,
+            template: false,
+        },
+        type__c: {
+            skipValidation: true,
+        },
+        AssociatedBusinessUnits__c: {
+            skipValidation: true,
+        },
+    },
+};

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

@@ -677,6 +677,7 @@ module.exports = {
         ],
     },
     typeMapping: {
+        ai: 16,
         psd: 17,
         pdd: 18,
         eps: 19,

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

@@ -167,7 +167,7 @@ module.exports = {
         ModifiedDate: {
             isCreateable: false,
             isUpdateable: false,
-            retrieving: false,
+            retrieving: true,
             template: false,
         },
         Name: {