mcdev 4.2.1 → 4.3.1

package/lib/Deployer.js

@@ -238,38 +238,44 @@ class Deployer {
                 Object.keys(this.metadata)
             );
         }
-        const foundDeployTypes = Object.keys(this.metadata).map((item) =>
-            item === 'asset' && Util.includesStartsWith(typeArr, item)
-                ? typeArr[Util.includesStartsWithIndex(typeArr, item)]
-                : item
-        );
+        const foundDeployTypes = Object.keys(this.metadata)
+            .map((type) =>
+                type === 'asset' && Util.includesStartsWith(typeArr, type)
+                    ? typeArr[Util.includesStartsWithIndex(typeArr, type)]
+                    : type
+            )
+            // remove empty types
+            .filter((type) => Object.keys(this.metadata[type]).length);
+        if (!foundDeployTypes.length) {
+            throw new Error('No metadata found for deployment');
+        }
         const deployOrder = Util.getMetadataHierachy(foundDeployTypes);
         // build cache, including all metadata types which will be deployed (Avoids retrieve later)
-        for (const metadataType of deployOrder) {
-            const [type, subType] = metadataType.split('-');
+        for (const metadataType in deployOrder) {
+            const type = metadataType;
+            const subTypeArr = deployOrder[metadataType];
             // add metadata & client to metadata process class instead of passing cache/mapping every time
             MetadataTypeInfo[type].client = auth.getSDK(this.buObject);
             MetadataTypeInfo[type].properties = this.properties;
             MetadataTypeInfo[type].buObject = this.buObject;
-            Util.logger.info('Caching dependent Metadata: ' + metadataType);
-            const result = await MetadataTypeInfo[type].retrieveForCache(this.buObject, subType);
+            Util.logger.info(`Caching dependent Metadata: ${metadataType}`);
+            Util.logSubtypes(subTypeArr);
+            const result = await MetadataTypeInfo[type].retrieveForCache(null, subTypeArr);
             cache.setMetadata(type, result.metadata);
         }
         /** @type {TYPE.MultiMetadataTypeMap} */
         const multiMetadataTypeMap = {};
         // deploy metadata files, extending cache once deploys
-        for (const metadataType of deployOrder) {
-            // TODO rewrite to allow deploying only a specific sub-type
-            // const [type, subType] = metadataType.split('-');
-            const type = metadataType.split('-')[0];
+        for (const metadataType in deployOrder) {
+            // TODO rewrite to allow deploying only a specific sub-type; currently, subtypes are ignored when executing deploy
+            const type = metadataType;
             if (this.metadata[type]) {
                 Util.logger.info('Deploying: ' + metadataType);
 
                 const result = await MetadataTypeInfo[type].deploy(
                     this.metadata[type],
                     this.deployDir,
-                    this.retrieveDir,
-                    this.buObject
+                    this.retrieveDir
                 );
                 multiMetadataTypeMap[type] = result;
                 cache.mergeMetadata(type, result);

package/lib/Retriever.js

@@ -59,75 +59,82 @@ class Retriever {
             // assuming TypeKeyCombo was provided
             typeKeyMap = namesOrKeys;
         }
-        // defined colors for optionally printing the keys we filtered by
-        const color = {
-            reset: '\x1B[0m',
-            dim: '\x1B[2m',
-        };
         // ensure we know which real dependencies we have to ensure we cache those completely
         const dependencies = this._getTypeDependencies(metadataTypes);
-
-        for (const metadataType of Util.getMetadataHierachy(metadataTypes)) {
-            const [type, subType] = metadataType.split('-');
+        const deployOrder = Util.getMetadataHierachy(metadataTypes);
+        for (const type in deployOrder) {
+            const subTypeArr = deployOrder[type];
             // if types were added by getMetadataHierachy() for caching, make sure the key-list is set to [null] for them which will retrieve all
-            typeKeyMap[metadataType] = typeKeyMap[metadataType] || [null];
+            typeKeyMap[type] = typeKeyMap[type] || [null];
             // add client to metadata process class instead of passing every time
             MetadataTypeInfo[type].client = auth.getSDK(this.buObject);
             MetadataTypeInfo[type].properties = this.properties;
             MetadataTypeInfo[type].buObject = this.buObject;
             try {
                 let result;
-                if (!metadataTypes.includes(type) && !metadataTypes.includes(metadataType)) {
+                if (
+                    !metadataTypes.includes(type) &&
+                    (!Array.isArray(subTypeArr) ||
+                        (Array.isArray(subTypeArr) &&
+                            !metadataTypes.includes(`${type}-${subTypeArr?.[0]}`)))
+                ) {
+                    // type not in list of types to retrieve, but is a dependency of one of them
                     if (changelogOnly && type !== 'folder') {
                         // no extra caching needed for list view except for folders
                         continue;
                     }
-                    Util.logger.info(`Caching dependent Metadata: ${metadataType}`);
-                    result = await MetadataTypeInfo[type].retrieveForCache(this.buObject, subType);
+                    Util.logger.info(`Caching dependent Metadata: ${type}`);
+                    Util.logSubtypes(subTypeArr);
+                    result = await MetadataTypeInfo[type].retrieveForCache(null, subTypeArr);
                 } else if (templateVariables) {
-                    Util.logger.info(`Retrieving as Template: ${metadataType}`);
-
+                    // type is in list of types to retrieve and we have template variables
+                    Util.logger.info(`Retrieving as Template: ${type}`);
+                    if (subTypeArr?.length > 1) {
+                        Util.logger.warn(
+                            `retrieveAsTemplate only works with one subtype, ignoring all but first subtype from your list: ${subTypeArr.join(
+                                ', '
+                            )}`
+                        );
+                    }
                     result = await Promise.all(
-                        typeKeyMap[metadataType].map((name) =>
+                        typeKeyMap[type].map((name) =>
                             MetadataTypeInfo[type].retrieveAsTemplate(
                                 this.templateDir,
                                 name,
                                 templateVariables,
-                                subType
+                                subTypeArr?.[0]
                             )
                         )
                     );
                 } else {
+                    // type is in list of types to retrieve and we don't have template variables
                     let cacheResult = null;
                     if (
-                        (typeKeyMap[metadataType].length > 1 ||
-                            typeKeyMap[metadataType][0] !== null) &&
-                        (dependencies.includes(type) || dependencies.includes(metadataType))
+                        (typeKeyMap[type].length > 1 || typeKeyMap[type][0] !== null) &&
+                        (dependencies.includes(type) || dependencies.includes(type))
                     ) {
                         // if we have a key-list and the type is a dependency, we need to cache the whole type
-                        Util.logger.info(`Caching dependent Metadata: ${metadataType}`);
+                        Util.logger.info(`Caching dependent Metadata: ${type}`);
+                        Util.logSubtypes(subTypeArr);
                         cacheResult = await MetadataTypeInfo[type].retrieveForCache(
-                            this.buObject,
-                            subType
+                            null,
+                            subTypeArr
                         );
                     }
                     Util.logger.info(
-                        `Retrieving: ${metadataType}` +
-                            (typeKeyMap[metadataType][0] === null
+                        `Retrieving: ${type}` +
+                            (typeKeyMap[type][0] === null
                                 ? ''
-                                : ` ${color.dim}(Keys: ${typeKeyMap[metadataType].join(', ')})${
-                                      color.reset
-                                  }`)
+                                : Util.getKeysString(typeKeyMap[type]))
                     );
                     result = await (changelogOnly
-                        ? MetadataTypeInfo[type].retrieveChangelog(this.buObject, null, subType)
+                        ? MetadataTypeInfo[type].retrieveChangelog(null, subTypeArr)
                         : Promise.all(
-                              typeKeyMap[metadataType].map((key) =>
+                              typeKeyMap[type].map((key) =>
                                   MetadataTypeInfo[type].retrieve(
                                       this.savePath,
                                       null,
-                                      this.buObject,
-                                      subType,
+                                      subTypeArr,
                                       key
                                   )
                               )
@@ -150,14 +157,14 @@ class Retriever {
                                 cache.mergeMetadata(type, result_i.metadata);
                             }
                         }
-                        if (metadataTypes.includes(type) || metadataTypes.includes(metadataType)) {
+                        if (metadataTypes.includes(type) || metadataTypes.includes(type)) {
                             retrieveChangelog[type] = result
                                 .filter((el) => !!el)
                                 .map((element) => element.metadata);
                         }
                     } else {
                         cache.setMetadata(type, result.metadata);
-                        if (metadataTypes.includes(type) || metadataTypes.includes(metadataType)) {
+                        if (metadataTypes.includes(type) || metadataTypes.includes(type)) {
                             retrieveChangelog[type] = result.metadata;
                         }
                     }
@@ -171,7 +178,7 @@ class Retriever {
                     Util.logger.error(ex.message);
                     break;
                 } else {
-                    Util.logger.errorStack(ex, ` - Retrieving ${metadataType} failed`);
+                    Util.logger.errorStack(ex, ` - Retrieving ${type} failed`);
                 }
             }
         }

package/lib/cli.js

@@ -84,6 +84,15 @@ yargs
             Mcdev.initProject(argv.credentialsName);
         },
     })
+    .command({
+        command: 'join',
+        desc: `clones an existing project from git`,
+        handler: (argv) => {
+            Mcdev.setSkipInteraction(argv.skipInteraction);
+            Mcdev.setLoggingLevel(argv);
+            Mcdev.joinProject();
+        },
+    })
     .command({
         command: 'reloadBUs [credentialsName]',
         aliases: ['rb'],
@@ -221,9 +230,7 @@ yargs
         handler: (argv) => {
             Mcdev.setSkipInteraction(argv.skipInteraction);
             Mcdev.setLoggingLevel(argv);
-            const keyArr = csvToArray(argv.KEY);
-
-            Mcdev.buildTemplate(argv.BU, argv.TYPE, keyArr, argv.MARKET);
+            Mcdev.buildTemplate(argv.BU, argv.TYPE, csvToArray(argv.KEY), argv.MARKET);
         },
     })
     .command({
@@ -345,9 +352,32 @@ yargs
         handler: (argv) => {
             Mcdev.setSkipInteraction(argv.skipInteraction);
             Mcdev.setLoggingLevel(argv);
-            const keyArr = csvToArray(argv.KEY);
-
-            Mcdev.getFilesToCommit(argv.BU, argv.TYPE, keyArr);
+            Mcdev.getFilesToCommit(argv.BU, argv.TYPE, csvToArray(argv.KEY));
+        },
+    })
+    .command({
+        command: 'refresh <BU> [TYPE] [KEY]',
+        aliases: ['re'],
+        desc: 'ensures that updates are properly published',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe: 'the business unit to execute the refresh on',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type',
+                })
+                .positional('KEY', {
+                    type: 'string',
+                    describe: 'key(s) of the metadata component(s)',
+                });
+        },
+        handler: (argv) => {
+            Mcdev.setSkipInteraction(argv.skipInteraction);
+            Mcdev.setLoggingLevel(argv);
+            Mcdev.refresh(argv.BU, argv.TYPE, csvToArray(argv.KEY));
         },
     })
     .command({

package/lib/index.js

@@ -147,7 +147,7 @@ class Mcdev {
             if (
                 properties.credentials &&
                 (!properties.credentials[cred] ||
-                    (bu !== '*' && properties.credentials[cred].businessUnits[bu]))
+                    (bu !== '*' && !properties.credentials[cred].businessUnits[bu]))
             ) {
                 const buObject = await Cli.getCredentialObject(
                     properties,
@@ -220,7 +220,7 @@ class Mcdev {
                 for (const selectedType of Array.isArray(selectedTypesArr)
                     ? selectedTypesArr
                     : Object.keys(selectedTypesArr)) {
-                    const [type, subType] = selectedType ? selectedType.split('-') : [];
+                    const [type, subType] = Util.getTypeAndSubType(selectedType);
                     const removePathArr = [properties.directories.retrieve, cred, bu, type];
                     if (
                         type &&
@@ -293,6 +293,15 @@ class Mcdev {
         const properties = await config.getProperties(!!credentialsName, true);
         await Init.initProject(properties, credentialsName);
     }
+    /**
+     * Clones an existing project from git repository and installs it
+     *
+     * @returns {Promise.<void>} -
+     */
+    static async joinProject() {
+        Util.logger.info('mcdev:: Joining an existing project');
+        await Init.joinProject();
+    }
 
     /**
      * Refreshes BU names and ID's from MC instance
@@ -338,7 +347,8 @@ class Mcdev {
             );
             if (buObject !== null) {
                 MetadataTypeInfo[type].properties = properties;
-                MetadataTypeInfo[type].document(buObject);
+                MetadataTypeInfo[type].buObject = buObject;
+                MetadataTypeInfo[type].document();
             }
         } catch (ex) {
             Util.logger.error('mcdev.document ' + ex.message);
@@ -350,25 +360,59 @@ class Mcdev {
     }
 
     /**
-     * Creates docs for supported metadata types in Markdown and/or HTML format
+     * deletes metadata from MC instance by key
      *
      * @param {string} businessUnit references credentials from properties.json
      * @param {string} type supported metadata type
-     * @param {string} customerKey Identifier of data extension
+     * @param {string} customerKey Identifier of metadata
      * @returns {Promise.<void>} -
      */
     static async deleteByKey(businessUnit, type, customerKey) {
         Util.logger.info('mcdev:: delete');
+        if (!Util._isValidType(type)) {
+            return;
+        }
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
             return null;
         }
         const buObject = await Cli.getCredentialObject(properties, businessUnit);
         if (buObject !== null) {
-            if ('string' !== typeof type) {
-                Util.logger.error('mcdev.delete failed: Bad metadata type passed in');
+            try {
+                MetadataTypeInfo[type].client = auth.getSDK(buObject);
+            } catch (ex) {
+                Util.logger.error(ex.message);
                 return;
             }
+            try {
+                MetadataTypeInfo[type].properties = properties;
+                MetadataTypeInfo[type].buObject = buObject;
+                await MetadataTypeInfo[type].deleteByKey(customerKey);
+            } catch (ex) {
+                Util.logger.errorStack(ex, ` - Deleting ${type} failed`);
+            }
+        }
+    }
+    /**
+     * ensures triggered sends are restarted to ensure they pick up on changes of the underlying emails
+     *
+     * @param {string} businessUnit references credentials from properties.json
+     * @param {string} type references credentials from properties.json
+     * @param {string[]} [keyArr] metadata keys
+     * @returns {Promise.<void>} -
+     */
+    static async refresh(businessUnit, type, keyArr) {
+        Util.logger.info('mcdev:: refresh');
+        if (!type || !Util._isValidType(type, true)) {
+            type = 'triggeredSendDefinition';
+            Util.logger.info(' - setting type to ' + type);
+        }
+        const properties = await config.getProperties();
+        if (!(await config.checkProperties(properties))) {
+            return null;
+        }
+        const buObject = await Cli.getCredentialObject(properties, businessUnit);
+        if (buObject !== null) {
             try {
                 MetadataTypeInfo[type].client = auth.getSDK(buObject);
             } catch (ex) {
@@ -376,10 +420,12 @@ class Mcdev {
                 return;
             }
             try {
+                cache.initCache(buObject);
                 MetadataTypeInfo[type].properties = properties;
-                MetadataTypeInfo[type].deleteByKey(buObject, customerKey);
+                MetadataTypeInfo[type].buObject = buObject;
+                await MetadataTypeInfo[type].refresh(keyArr);
             } catch (ex) {
-                Util.logger.error('mcdev.delete ' + ex.message);
+                Util.logger.errorStack(ex, 'mcdev.refresh ' + ex.message);
             }
         }
     }
@@ -472,7 +518,7 @@ class Mcdev {
         if (!Util._isValidType(selectedType)) {
             return;
         }
-        const [type, subType] = selectedType ? selectedType.split('-') : [];
+        const [type, subType] = Util.getTypeAndSubType(selectedType);
 
         let retrieveTypesArr;
         if (

package/lib/metadataTypes/AccountUser.js

@@ -16,37 +16,34 @@ class AccountUser 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 of metadata
      */
-    static async retrieve(retrieveDir, _, buObject, ___, key) {
-        if (buObject.eid !== buObject.mid) {
+    static async retrieve(retrieveDir, _, __, key) {
+        if (this.buObject.eid !== this.buObject.mid) {
             Util.logger.info(' - Skipping User retrieval on non-parent BU');
             return;
         }
-        return this._retrieve(retrieveDir, buObject, key);
+        return this._retrieve(retrieveDir, key);
     }
     /**
      * Retrieves SOAP based metadata of metadata type into local filesystem. executes callback with retrieved metadata
      *
-     * @param {TYPE.BuObject} buObject properties for auth
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static async retrieveChangelog(buObject) {
-        return this._retrieve(null, buObject, null);
+    static async retrieveChangelog() {
+        return this._retrieve();
     }
     /**
      * Retrieves SOAP based metadata of metadata type into local filesystem. executes callback with retrieved metadata
      *
      * @private
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {TYPE.BuObject} buObject properties for auth
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static async _retrieve(retrieveDir, buObject, key) {
+    static async _retrieve(retrieveDir, key) {
         Util.logger.info(' - Caching dependent Metadata: AccountUserAccount');
 
         // get BUs that each users have access to
@@ -113,7 +110,7 @@ class AccountUser extends MetadataType {
             };
         }
         Util.logger.info(` - Loading ${this.definition.type}. This might take a while...`);
-        return super.retrieveSOAP(retrieveDir, buObject, requestParams);
+        return super.retrieveSOAP(retrieveDir, requestParams);
     }
     /**
      *
@@ -175,24 +172,21 @@ class AccountUser extends MetadataType {
     /**
      * helper to print bu names
      *
-     * @param {TYPE.BuObject} buObject needed for eid
-     * @param {string} buObject.eid needed to check for parent bu
      * @param {number} id bu id
      * @returns {string} "bu name (bu id)""
      */
-    static getBuName(buObject, id) {
-        const name = buObject.eid == id ? '_ParentBU_' : this.buIdName[id];
+    static getBuName(id) {
+        const name = this.buObject.eid == id ? '_ParentBU_' : this.buIdName[id];
         return `<nobr>${name} (${id})</nobr>`;
     }
     /**
      * Creates markdown documentation of all roles
      *
-     * @param {TYPE.BuObject} buObject properties for auth
      * @param {TYPE.MetadataTypeMap} [metadata] user list
      * @returns {Promise.<void>} -
      */
-    static async document(buObject, metadata) {
-        if (buObject.eid !== buObject.mid) {
+    static async document(metadata) {
+        if (this.buObject.eid !== this.buObject.mid) {
             Util.logger.error(
                 `Users can only be retrieved & documented for the ${Util.parentBuName}`
             );
@@ -204,7 +198,7 @@ class AccountUser extends MetadataType {
                 metadata = this.readBUMetadataForType(
                     File.normalizePath([
                         this.properties.directories.retrieve,
-                        buObject.credential,
+                        this.buObject.credential,
                         Util.parentBuName,
                     ]),
                     true
@@ -252,12 +246,12 @@ class AccountUser extends MetadataType {
             if (user.AssociatedBusinessUnits__c) {
                 associatedBus = user.AssociatedBusinessUnits__c.map((item) => {
                     this.buIdName[item.ID] = item.Name;
-                    return this.getBuName(buObject, item.ID);
+                    return this.getBuName(item.ID);
                 })
                     .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
                     .join(',<br> ');
             }
-            const defaultBUName = this.getBuName(buObject, user.DefaultBusinessUnit);
+            const defaultBUName = this.getBuName(user.DefaultBusinessUnit);
             users.push({
                 TYPE: user.type__c,
                 UserID: user.UserID,
@@ -297,7 +291,7 @@ class AccountUser extends MetadataType {
             ['Modified Date', 'ModifiedDate'],
             ['Created Date', 'CreatedDate'],
         ];
-        let output = `# User Overview - ${buObject.credential}`;
+        let output = `# User Overview - ${this.buObject.credential}`;
         output += this._generateDocMd(
             users.filter((user) => user.TYPE === 'User' && user.ActiveFlag === '✓'),
             'User',
@@ -316,7 +310,7 @@ class AccountUser extends MetadataType {
         const docPath = File.normalizePath([this.properties.directories.docs, 'user']);
 
         try {
-            const filename = buObject.credential;
+            const filename = this.buObject.credential;
             // write to disk
             await File.writeToFile(docPath, filename + '.accountUsers', 'md', output);
             Util.logger.info(`Created ${File.normalizePath([docPath, filename])}.accountUsers.md`);