mcdev 4.1.3 → 4.1.5

package/lib/Retriever.js

@@ -74,8 +74,8 @@ class Retriever {
             try {
                 let result;
                 if (!metadataTypes.includes(type) && !metadataTypes.includes(metadataType)) {
-                    if (changelogOnly) {
-                        // no extra caching needed for list view
+                    if (changelogOnly && type !== 'folder') {
+                        // no extra caching needed for list view except for folders
                         continue;
                     }
                     Util.logger.info(`Caching dependent Metadata: ${metadataType}`);
@@ -115,6 +115,12 @@ class Retriever {
                                   )
                               )
                           ));
+                    if (changelogOnly) {
+                        // add folder to changelog
+                        for (const key of Object.keys(result.metadata)) {
+                            MetadataTypeInfo[type].setFolderPath(result.metadata[key]);
+                        }
+                    }
                 }
                 if (result) {
                     if (Array.isArray(result)) {

package/lib/cli.js

@@ -81,7 +81,7 @@ yargs
         handler: (argv) => {
             Mcdev.setSkipInteraction(argv.skipInteraction);
             Mcdev.setLoggingLevel(argv);
-            Mcdev.initProject(argv.credentialsName, argv.skipInteraction);
+            Mcdev.initProject(argv.credentialsName);
         },
     })
     .command({

package/lib/index.js

@@ -50,12 +50,10 @@ class Mcdev {
     into deploy directory
      * @param {string} [argv.filter] filter file paths that start with any
      * @param {TYPE.DeltaPkgItem[]} [argv.diffArr] list of files to include in delta package (skips git diff when provided)
-     * @param {TYPE.skipInteraction} [argv.skipInteraction] allows to skip interactive wizard
      * @returns {Promise.<TYPE.DeltaPkgItem[]>} list of changed items
      */
     static async createDeltaPkg(argv) {
         Util.logger.info('Create Delta Package ::');
-        Mcdev.setSkipInteraction(argv.skipInteraction);
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
             return null;
@@ -65,12 +63,7 @@ class Mcdev {
             ? // get source market and source BU from config
               DevOps.getDeltaList(properties, argv.range, true, argv.filter)
             : // If no custom filter was provided, use deployment marketLists & templating
-              DevOps.buildDeltaDefinitions(
-                  properties,
-                  argv.range,
-                  argv.diffArr,
-                  argv.skipInteraction
-              );
+              DevOps.buildDeltaDefinitions(properties, argv.range, argv.diffArr);
     }
 
     /**
@@ -90,17 +83,15 @@ class Mcdev {
         Cli.explainTypes();
     }
     /**
-     * @param {boolean | TYPE.skipInteraction} [skipInteraction] signals what to insert automatically for things usually asked via wizard
      * @returns {Promise.<boolean>} success flag
      */
-    static async upgrade(skipInteraction) {
-        Mcdev.setSkipInteraction(skipInteraction);
+    static async upgrade() {
         const properties = await config.getProperties();
         if (!properties) {
             Util.logger.error('No config found. Please run mcdev init');
             return false;
         }
-        if ((await InitGit.initGitRepo(skipInteraction)).status === 'error') {
+        if ((await InitGit.initGitRepo()).status === 'error') {
             return false;
         }
 
@@ -295,14 +286,12 @@ class Mcdev {
      * Creates template file for properties.json
      *
      * @param {string} [credentialsName] identifying name of the installed package / project
-     * @param {boolean | TYPE.skipInteraction} [skipInteraction] signals what to insert automatically for things usually asked via wizard
      * @returns {Promise.<void>} -
      */
-    static async initProject(credentialsName, skipInteraction) {
+    static async initProject(credentialsName) {
         Util.logger.info('mcdev:: Setting up project');
-        Mcdev.setSkipInteraction(skipInteraction);
         const properties = await config.getProperties(!!credentialsName);
-        await Init.initProject(properties, credentialsName, skipInteraction);
+        await Init.initProject(properties, credentialsName);
     }
 
     /**

package/lib/metadataTypes/Asset.js

@@ -755,15 +755,12 @@ class Asset extends MetadataType {
             }
         }
     }
-
     /**
-     * parses retrieved Metadata before saving
+     * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
      *
-     * @param {TYPE.AssetItem} metadata a single asset definition
-     * @returns {TYPE.CodeExtractItem} parsed metadata definition
+     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
      */
-    static parseMetadata(metadata) {
-        // folder
+    static setFolderPath(metadata) {
         try {
             metadata.r__folder_Path = cache.searchForField(
                 'folder',
@@ -773,12 +770,23 @@ class Asset extends MetadataType {
             );
             delete metadata.category;
         } catch (ex) {
-            // ! if we don't catch this error here we end up saving the actual asset but not its corresponding JSON
-            Util.logger.debug(ex.message);
             Util.logger.warn(
-                ` - Could not find folder with ID ${metadata.category.id} for '${metadata.name}' (${metadata.customerKey})`
+                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                    metadata[this.definition.keyField]
+                }): Could not find folder (${ex.message})`
             );
         }
+    }
+
+    /**
+     * parses retrieved Metadata before saving
+     *
+     * @param {TYPE.AssetItem} metadata a single asset definition
+     * @returns {TYPE.CodeExtractItem} parsed metadata definition
+     */
+    static parseMetadata(metadata) {
+        // folder
+        this.setFolderPath(metadata);
         // extract HTML for selected subtypes and convert payload for easier processing in MetadataType.saveResults()
         metadata = this._extractCode(metadata);
         return metadata;

package/lib/metadataTypes/Automation.js

@@ -73,6 +73,7 @@ class Automation extends MetadataType {
                               'ProgramID',
                               'Name',
                               'CustomerKey',
+                              'CategoryID',
                               'LastSaveDate',
                               'LastSavedBy',
                               'CreatedBy',
@@ -457,23 +458,23 @@ class Automation extends MetadataType {
             }
         }
     }
-
     /**
-     * parses retrieved Metadata before saving
+     * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
      *
-     * @param {TYPE.AutomationItem} metadata a single automation definition
-     * @returns {TYPE.AutomationItem} parsed item
+     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
      */
-    static parseMetadata(metadata) {
-        // automations are often skipped due to lack of support.
+    static setFolderPath(metadata) {
+        const folderIdField = metadata[this.definition.folderIdField]
+            ? this.definition.folderIdField
+            : 'CategoryID';
         try {
             metadata.r__folder_Path = cache.searchForField(
                 'folder',
-                metadata.categoryId,
+                metadata[folderIdField],
                 'ID',
                 'Path'
             );
-            delete metadata.categoryId;
+            delete metadata[folderIdField];
             if (metadata.r__folder_Path !== 'my automations') {
                 Util.logger.verbose(
                     `- automation '${
@@ -484,13 +485,23 @@ class Automation extends MetadataType {
                 );
             }
         } catch (ex) {
-            // * don't exit on missing folder for automation
             Util.logger.warn(
-                ` - ${this.definition.typeName} '${metadata[this.definition.nameField]}': ${
-                    ex.message
-                }`
+                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                    metadata[this.definition.keyField]
+                }): Could not find folder (${ex.message})`
             );
         }
+    }
+
+    /**
+     * parses retrieved Metadata before saving
+     *
+     * @param {TYPE.AutomationItem} metadata a single automation definition
+     * @returns {TYPE.AutomationItem} parsed item
+     */
+    static parseMetadata(metadata) {
+        this.setFolderPath(metadata);
+        // automations are often skipped due to lack of support.
         try {
             if (metadata.type === 'scheduled' && metadata.schedule?.startDate) {
                 // Starting Source == 'Schedule'

package/lib/metadataTypes/ContentArea.js

@@ -49,27 +49,40 @@ class ContentArea extends MetadataType {
         return this.parseMetadata(metadata);
     }
     /**
-     * parses retrieved Metadata before saving
+     * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single item
-     * @returns {TYPE.MetadataTypeItem} parsed item
+     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
      */
-    static parseMetadata(metadata) {
-        // folder
+    static setFolderPath(metadata) {
         try {
             metadata.r__folder_Path = cache.searchForField(
                 'folder',
-                metadata.CategoryID,
+                metadata[this.definition.folderIdField],
                 'ID',
                 'Path'
             );
+            delete metadata[this.definition.folderIdField];
         } catch (ex) {
-            Util.logger.debug(`Classic Content Area '${metadata.CustomerKey}': ${ex.message}`);
+            Util.logger.debug(
+                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                    metadata[this.definition.keyField]
+                }): Could not find folder (${ex.message})`
+            );
             // classic content blocks that reside in the main folder are
             // saved with CategoryID=0, instead of to the actual ID of
             // their parent root folder.
             metadata.r__folder_Path = 'my contents';
         }
+    }
+    /**
+     * parses retrieved Metadata before saving
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single item
+     * @returns {TYPE.MetadataTypeItem} parsed item
+     */
+    static parseMetadata(metadata) {
+        // folder
+        this.setFolderPath(metadata);
 
         // extract code
         const codeArr = [

package/lib/metadataTypes/DataExtension.js

@@ -914,22 +914,20 @@ class DataExtension extends MetadataType {
 
         return { metadata: metadata[customerKey], type: 'dataExtension' };
     }
-
     /**
-     * parses retrieved Metadata before saving
+     * dataExtension logic that retrieves the folder path from cache and updates the given metadata with it after retrieve
+     * it also sets the content type which is basically the subtype
      *
-     * @private
-     * @param {TYPE.DataExtensionItem} metadata a single dataExtension definition
-     * @returns {TYPE.DataExtensionItem} a single dataExtension definition
+     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
      */
-    static _parseMetadata(metadata) {
+    static setFolderPath(metadata) {
         let error = false;
         let verbose = false;
         // data extension type (from folder)
         try {
             metadata.r__folder_ContentType = cache.searchForField(
                 'folder',
-                metadata.CategoryID,
+                metadata[this.definition.folderIdField],
                 'ID',
                 'ContentType'
             );
@@ -939,22 +937,26 @@ class DataExtension extends MetadataType {
                 metadata.r__folder_ContentType = 'synchronizeddataextension';
             } else {
                 error = true;
-                Util.logger.warn(` - dataExtension '${metadata.Name}': ${ex.message}`);
+                Util.logger.warn(
+                    ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                        metadata[this.definition.keyField]
+                    }): Could not find folder (${ex.message})`
+                );
             }
         }
         // folder
         try {
             metadata.r__folder_Path = cache.searchForField(
                 'folder',
-                metadata.CategoryID,
+                metadata[this.definition.folderIdField],
                 'ID',
                 'Path'
             );
-            delete metadata.CategoryID;
+            delete metadata[this.definition.folderIdField];
         } catch (ex) {
             if (/(_Salesforce)(_\d\d?\d?)?$/.test(metadata.Name)) {
                 metadata.r__folder_Path = 'Synchronized Data Extensions';
-                delete metadata.CategoryID;
+                delete metadata[this.definition.folderIdField];
 
                 if (!verbose) {
                     Util.logger.verbose(
@@ -962,9 +964,25 @@ class DataExtension extends MetadataType {
                     );
                 }
             } else if (!error) {
-                Util.logger.error(`Data Extension '${metadata.Name}': ${ex.message}`);
+                Util.logger.error(
+                    ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                        metadata[this.definition.keyField]
+                    }): ${ex.message}`
+                );
             }
         }
+    }
+
+    /**
+     * parses retrieved Metadata before saving
+     *
+     * @private
+     * @param {TYPE.DataExtensionItem} metadata a single dataExtension definition
+     * @returns {TYPE.DataExtensionItem} a single dataExtension definition
+     */
+    static _parseMetadata(metadata) {
+        this.setFolderPath(metadata);
+
         // DataExtensionTemplate
         if (metadata.Template?.CustomerKey) {
             try {

package/lib/metadataTypes/Email.js

@@ -3,7 +3,6 @@
 const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
-const cache = require('../util/cache');
 
 /**
  * Email MetadataType
@@ -56,19 +55,7 @@ class Email extends MetadataType {
      */
     static parseMetadata(metadata) {
         // folder
-        try {
-            metadata.r__folder_Path = cache.searchForField(
-                'folder',
-                metadata.CategoryID,
-                'ID',
-                'Path'
-            );
-            delete metadata.CategoryID;
-        } catch (ex) {
-            Util.logger.warn(
-                ` - Classic E-Mail '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
-            );
-        }
+        super.setFolderPath(metadata);
 
         // extract code
         const codeArr = [

package/lib/metadataTypes/EmailSendDefinition.js

@@ -182,19 +182,8 @@ class EmailSendDefinition extends MetadataType {
         // remove IsPlatformObject, always has to be 'false'
         delete metadata.IsPlatformObject;
         // folder
-        try {
-            metadata.r__folder_Path = cache.searchForField(
-                'folder',
-                metadata.CategoryID,
-                'ID',
-                'Path'
-            );
-            delete metadata.CategoryID;
-        } catch (ex) {
-            Util.logger.warn(
-                ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
-            );
-        }
+        super.setFolderPath(metadata);
+
         // email
         try {
             // classic

package/lib/metadataTypes/MetadataType.js

@@ -141,6 +141,32 @@ class MetadataType {
     static postRetrieveTasks(metadata, targetDir, isTemplating) {
         return JSON.parse(JSON.stringify(metadata));
     }
+    /**
+     * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
+     */
+    static setFolderPath(metadata) {
+        if (!this.definition.folderIdField) {
+            return;
+        }
+        try {
+            metadata.r__folder_Path = cache.searchForField(
+                'folder',
+                metadata[this.definition.folderIdField],
+                'ID',
+                'Path'
+            );
+            delete metadata[this.definition.folderIdField];
+        } catch (ex) {
+            Util.logger.warn(
+                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                    metadata[this.definition.keyField]
+                }): Could not find folder (${ex.message})`
+            );
+        }
+    }
+
     /**
      * Gets metadata from Marketing Cloud
      *

package/lib/metadataTypes/Query.js

@@ -2,7 +2,6 @@
 
 const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
-const Util = require('../util/util');
 const File = require('../util/file');
 const cache = require('../util/cache');
 const Mustache = require('mustache');
@@ -287,17 +286,7 @@ class Query extends MetadataType {
      */
     static parseMetadata(metadata) {
         // folder
-        try {
-            metadata.r__folder_Path = cache.searchForField(
-                'folder',
-                metadata.categoryId,
-                'ID',
-                'Path'
-            );
-            delete metadata.categoryId;
-        } catch (ex) {
-            Util.logger.warn(` - Query '${metadata.key}': ${ex.message}`);
-        }
+        super.setFolderPath(metadata);
 
         // extract SQL
         const codeArr = [

package/lib/metadataTypes/Script.js

@@ -261,17 +261,7 @@ class Script extends MetadataType {
      */
     static parseMetadata(metadata) {
         // folder
-        try {
-            metadata.r__folder_Path = cache.searchForField(
-                'folder',
-                metadata.categoryId,
-                'ID',
-                'Path'
-            );
-            delete metadata.categoryId;
-        } catch (ex) {
-            Util.logger.warn(` - Script '${metadata.key}': ${ex.message}`);
-        }
+        super.setFolderPath(metadata);
 
         // extract SSJS
         const codeArr = [];

package/lib/metadataTypes/TriggeredSendDefinition.js

@@ -137,19 +137,8 @@ class TriggeredSendDefinition extends MetadataType {
         // remove IsPlatformObject, always has to be 'false'
         delete metadata.IsPlatformObject;
         // folder
-        try {
-            metadata.r__folder_Path = cache.searchForField(
-                'folder',
-                metadata.CategoryID,
-                'ID',
-                'Path'
-            );
-            delete metadata.CategoryID;
-        } catch (ex) {
-            Util.logger.warn(
-                ` - Triggered Send '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
-            );
-        }
+        super.setFolderPath(metadata);
+
         // email
         try {
             // classic

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

@@ -40,6 +40,7 @@ module.exports = {
     idField: 'id',
     keyField: 'key',
     nameField: 'name',
+    folderIdField: 'categoryId',
     createdDateField: 'createdDate',
     createdNameField: 'createdByName',
     lastmodDateField: 'lastSavedDate',

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

@@ -6,6 +6,7 @@ module.exports = {
     keepId: true,
     keyField: 'CustomerKey',
     nameField: 'Name',
+    folderIdField: 'CategoryID',
     restPagination: null,
     type: 'contentArea',
     typeDescription:

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

@@ -80,6 +80,7 @@ module.exports = {
     idField: 'ObjectID',
     keyField: 'CustomerKey',
     nameField: 'Name',
+    folderIdField: 'CategoryID',
     createdDateField: 'CreatedDate',
     createdNameField: null,
     lastmodDateField: 'ModifiedDate',

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

@@ -6,6 +6,7 @@ module.exports = {
     keepId: true,
     keyField: 'CustomerKey',
     nameField: 'Name',
+    folderIdField: 'CategoryID',
     restPagination: null,
     type: 'email',
     typeDescription:

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

@@ -7,6 +7,7 @@ module.exports = {
     keepId: true,
     keyField: 'CustomerKey',
     nameField: 'Name',
+    folderIdField: 'CategoryID',
     createdDateField: 'CreatedDate',
     createdNameField: null,
     lastmodDateField: 'ModifiedDate',

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

@@ -9,6 +9,7 @@ module.exports = {
     idField: 'queryDefinitionId',
     keyField: 'key',
     nameField: 'name',
+    folderIdField: 'categoryId',
     createdDateField: 'createdDate',
     createdNameField: null,
     lastmodDateField: 'modifiedDate',

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

@@ -6,6 +6,7 @@ module.exports = {
     idField: 'ssjsActivityId',
     keyField: 'key',
     nameField: 'name',
+    folderIdField: 'categoryId',
     createdDateField: 'createdDate',
     createdNameField: 'createdBy',
     lastmodDateField: 'modifiedDate',

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

@@ -7,6 +7,7 @@ module.exports = {
     keepId: true,
     keyField: 'CustomerKey',
     nameField: 'Name',
+    folderIdField: 'CategoryID',
     createdDateField: 'CreatedDate',
     createdNameField: null,
     lastmodDateField: 'ModifiedDate',

package/lib/util/cli.js

@@ -18,26 +18,25 @@ const Cli = {
      * used when initially setting up a project.
      * loads default config and adds first credential
      *
-     * @param {TYPE.skipInteraction} [skipInteraction] signals what to insert automatically for things usually asked via wizard
      * @returns {Promise.<boolean>} success of init
      */
-    async initMcdevConfig(skipInteraction) {
+    async initMcdevConfig() {
         Util.logger.info('-- Initialising server connection --');
         Util.logger.info('Please enter a name for your "Installed Package" credentials:');
         const propertiesTemplate = await config.getDefaultProperties();
         delete propertiesTemplate.credentials.default;
 
         // wait for the interaction to finish or else an outer await will run before this is done
-        return this._setCredential(propertiesTemplate, null, skipInteraction);
+        return this._setCredential(propertiesTemplate, null);
     },
     /**
      * Extends template file for properties.json
      *
      * @param {TYPE.Mcdevrc} properties config file's json
-     * @param {TYPE.skipInteraction} [skipInteraction] signals what to insert automatically for things usually asked via wizard
      * @returns {Promise.<void>} -
      */
-    async addExtraCredential(properties, skipInteraction) {
+    async addExtraCredential(properties) {
+        const skipInteraction = Util.skipInteraction;
         if (!(await config.checkProperties(properties))) {
             // return null here to avoid seeing 2 error messages for the same issue
             return null;
@@ -54,7 +53,7 @@ const Cli = {
                     `Credential '${skipInteraction.credentialName}' already existing. If you tried updating please provide run 'mcdev init ${skipInteraction.credentialName}'`
                 );
             }
-            return this._setCredential(properties, null, skipInteraction);
+            return this._setCredential(properties, null);
         }
     },
     /**
@@ -63,15 +62,15 @@ const Cli = {
      *
      * @param {TYPE.Mcdevrc} properties config file's json
      * @param {string} credName name of credential that needs updating
-     * @param {TYPE.skipInteraction} [skipInteraction] signals what to insert automatically for things usually asked via wizard
      * @returns {Promise.<boolean>} success of update
      */
-    async updateCredential(properties, credName, skipInteraction) {
+    async updateCredential(properties, credName) {
+        const skipInteraction = Util.skipInteraction;
         if (credName) {
             if (!skipInteraction) {
                 Util.logger.info(`Please enter the details for '${credName}'`);
             }
-            return await this._setCredential(properties, credName, skipInteraction);
+            return await this._setCredential(properties, credName);
         }
     },
     /**
@@ -226,10 +225,10 @@ const Cli = {
      *
      * @param {TYPE.Mcdevrc} properties from config file
      * @param {string} [credName] name of credential that needs updating
-     * @param {TYPE.skipInteraction} [skipInteraction] signals what to insert automatically for things usually asked via wizard
      * @returns {Promise.<boolean | string>} success of refresh or credential name
      */
-    async _setCredential(properties, credName, skipInteraction) {
+    async _setCredential(properties, credName) {
+        const skipInteraction = Util.skipInteraction;
         // Get user input
         let credentialsGood = null;
         let inputData;

package/lib/util/devops.js

@@ -249,10 +249,10 @@ const DevOps = {
      * @param {TYPE.Mcdevrc} properties project config file
      * @param {string} range git commit range
      * @param {TYPE.DeltaPkgItem[]} [diffArr] instead of running git diff the method can also get a list of files to process
-     * @param {TYPE.SkipInteraction} [skipInteraction] allows to skip interactive wizard
      * @returns {Promise.<TYPE.DeltaPkgItem[]>} -
      */
-    async buildDeltaDefinitions(properties, range, diffArr, skipInteraction) {
+    async buildDeltaDefinitions(properties, range, diffArr) {
+        const skipInteraction = Util.skipInteraction;
         // check if sourceTargetMapping is valid
         if (
             !properties.options.deployment.sourceTargetMapping ||