mcdev 5.0.2 → 5.2.0

package/lib/Deployer.js

@@ -44,17 +44,17 @@ class Deployer {
      * @param {string} businessUnit references credentials from properties.json
      * @param {TYPE.SupportedMetadataTypes[]} [selectedTypesArr] limit deployment to given metadata type
      * @param {string[]} [keyArr] limit deployment to given metadata keys
-     * @param {boolean} [fromRetrieve] optionally deploy whats defined via selectedTypesArr + keyArr directly from retrieve folder instead of from deploy folder
      * @returns {Promise.<Object.<string,TYPE.MultiMetadataTypeMap>>} deployed metadata per BU (first key: bu name, second key: metadata type)
      */
-    static async deploy(businessUnit, selectedTypesArr, keyArr, fromRetrieve) {
+    static async deploy(businessUnit, selectedTypesArr, keyArr) {
         Util.logger.info('mcdev:: Deploy');
         const buMultiMetadataTypeMap = {};
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
             return null;
         }
-        if (fromRetrieve) {
+        const deployDirBak = properties.directories.deploy;
+        if (Util.OPTIONS.fromRetrieve) {
             properties.directories.deploy = properties.directories.retrieve;
         }
         if (Array.isArray(selectedTypesArr)) {
@@ -66,7 +66,7 @@ class Deployer {
             }
         }
         if (
-            fromRetrieve &&
+            Util.OPTIONS.fromRetrieve &&
             (!selectedTypesArr ||
                 !Array.isArray(selectedTypesArr) ||
                 !selectedTypesArr.length ||
@@ -97,13 +97,12 @@ class Deployer {
                     bu,
                     properties,
                     selectedTypesArr,
-                    keyArr,
-                    fromRetrieve
+                    keyArr
                 );
                 buMultiMetadataTypeMap[cred + '/' + bu] = multiMetadataTypeMap;
                 counter_credBu++;
                 Util.logger.info('');
-                Util.restartLogger();
+                Util.startLogger(true);
             }
         } else {
             // anything but "*" passed in
@@ -137,7 +136,7 @@ class Deployer {
                     return;
                 }
                 // valid credential given and -all- BUs targeted
-                Util.logger.info(`\n               :: Deploying all BUs for ${cred}`);
+                Util.logger.info(`:: Deploying all BUs for ${cred}`);
                 let counter_credBu = 0;
                 // for (const bu in properties.credentials[cred].businessUnits) {
                 const deployFolders = await File.readDirectories(
@@ -151,15 +150,14 @@ class Deployer {
                         buPath,
                         properties,
                         selectedTypesArr,
-                        keyArr,
-                        fromRetrieve
+                        keyArr
                     );
                     buMultiMetadataTypeMap[cred + '/' + buPath] = multiMetadataTypeMap;
                     counter_credBu++;
                     Util.logger.info('');
-                    Util.restartLogger();
+                    Util.startLogger(true);
                 }
-                Util.logger.info(`\n               :: ${counter_credBu} BUs for ${cred}\n`);
+                Util.logger.info(` :: ${counter_credBu} BUs for ${cred}\n`);
             } else {
                 // either bad credential or specific BU or no BU given
                 const multiMetadataTypeMap = await this._deployBU(
@@ -167,30 +165,31 @@ class Deployer {
                     bu,
                     properties,
                     selectedTypesArr,
-                    keyArr,
-                    fromRetrieve
+                    keyArr
                 );
                 counter_credBu++;
                 buMultiMetadataTypeMap[cred + '/' + bu] = multiMetadataTypeMap;
             }
         }
+        if (Util.OPTIONS.fromRetrieve) {
+            properties.directories.deploy = deployDirBak;
+        }
         if (counter_credBu !== 0) {
-            Util.logger.info(`\n               :: Deployed ${counter_credBu} BUs\n`);
+            Util.logger.info(`:: Deployed ${counter_credBu} BUs\n`);
         }
         return buMultiMetadataTypeMap;
     }
     /**
-     * helper for {@link deploy}
+     * helper for {@link Deployer.deploy}
      *
      * @param {string} cred name of Credential
      * @param {string} bu name of BU
      * @param {TYPE.Mcdevrc} properties General configuration to be used in retrieve
      * @param {TYPE.SupportedMetadataTypes[]} [typeArr] limit deployment to given metadata type
      * @param {string[]} [keyArr] limit deployment to given metadata keys
-     * @param {boolean} [fromRetrieve] optionally deploy whats defined via selectedTypesArr + keyArr directly from retrieve folder instead of from deploy folder
      * @returns {Promise.<TYPE.MultiMetadataTypeMap>} ensure that BUs are worked on sequentially
      */
-    static async _deployBU(cred, bu, properties, typeArr, keyArr, fromRetrieve) {
+    static async _deployBU(cred, bu, properties, typeArr, keyArr) {
         const buPath = `${cred}/${bu}`;
         Util.logger.info(`:: Deploying to ${buPath}`);
         const buObject = await Cli.getCredentialObject(properties, buPath, null, true);
@@ -201,7 +200,7 @@ class Deployer {
             const deployer = new Deployer(properties, buObject);
             try {
                 // await is required or the calls end up conflicting
-                multiMetadataTypeMap = await deployer._deploy(typeArr, keyArr, fromRetrieve);
+                multiMetadataTypeMap = await deployer._deploy(typeArr, keyArr);
             } catch (ex) {
                 Util.logger.errorStack(ex, 'mcdev.deploy failed');
             }
@@ -214,11 +213,9 @@ class Deployer {
      *
      * @param {TYPE.SupportedMetadataTypes[]} [typeArr] limit deployment to given metadata type (can include subtype)
      * @param {string[]} [keyArr] limit deployment to given metadata keys
-     * @param {boolean} [fromRetrieve] if true, no folders will be updated/created
-     * @param {boolean} [isRefresh] optional flag to indicate that triggeredSend should be refreshed after deployment of assets
      * @returns {Promise.<TYPE.MultiMetadataTypeMap>} Promise of all deployed metadata
      */
-    async _deploy(typeArr, keyArr, fromRetrieve, isRefresh) {
+    async _deploy(typeArr, keyArr) {
         if (await File.pathExists(this.deployDir)) {
             /** @type {TYPE.MultiMetadataTypeMap} */
             this.metadata = Deployer.readBUMetadata(this.deployDir, typeArr);
@@ -252,7 +249,7 @@ class Deployer {
             }
         }
 
-        if (!fromRetrieve) {
+        if (!Util.OPTIONS.fromRetrieve) {
             await Deployer.createFolderDefinitions(
                 this.deployDir,
                 this.metadata,
@@ -292,13 +289,16 @@ class Deployer {
             // 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);
+                Util.logger.info(
+                    'Deploying: ' +
+                        metadataType +
+                        (Util.OPTIONS.fromRetrieve ? ' (from retrieve folder)' : '')
+                );
 
                 const result = await MetadataTypeInfo[type].deploy(
                     this.metadata[type],
                     this.deployDir,
-                    this.retrieveDir,
-                    isRefresh
+                    this.retrieveDir
                 );
                 multiMetadataTypeMap[type] = result;
                 cache.mergeMetadata(type, result);
@@ -312,7 +312,7 @@ class Deployer {
      *
      * @param {string} deployDir root directory of metadata.
      * @param {string[]} [typeArr] limit deployment to given metadata type
-     * @param {boolean} [listBadKeys=false] do not print errors, used for badKeys()
+     * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
      * @returns {TYPE.MultiMetadataTypeMap} Metadata of BU in local directory
      */
     static readBUMetadata(deployDir, typeArr, listBadKeys) {
@@ -387,7 +387,7 @@ class Deployer {
             const allFolders = Object.keys(metadata[metadataType])
                 .filter(
                     // filter out root folders (which would not have a slash in their path)
-                    (key) => metadata[metadataType][key].r__folder_Path.includes('/')
+                    (key) => metadata[metadataType][key].r__folder_Path?.includes('/')
                 )
                 .filter(
                     // filter out dataExtension folders other than standard & shared (--> synchronized / salesforce are not allowed)

package/lib/MetadataTypeDefinitions.js

@@ -6,6 +6,7 @@
 const MetadataTypeDefinitions = {
     asset: require('./metadataTypes/definitions/Asset.definition'),
     attributeGroup: require('./metadataTypes/definitions/AttributeGroup.definition'),
+    attributeSet: require('./metadataTypes/definitions/AttributeSet.definition'),
     automation: require('./metadataTypes/definitions/Automation.definition'),
     campaign: require('./metadataTypes/definitions/Campaign.definition'),
     contentArea: require('./metadataTypes/definitions/ContentArea.definition'),
@@ -32,7 +33,6 @@ const MetadataTypeDefinitions = {
     role: require('./metadataTypes/definitions/Role.definition'),
     script: require('./metadataTypes/definitions/Script.definition'),
     sendClassification: require('./metadataTypes/definitions/SendClassification.definition'),
-    setDefinition: require('./metadataTypes/definitions/SetDefinition.definition'),
     transactionalEmail: require('./metadataTypes/definitions/TransactionalEmail.definition'),
     transactionalPush: require('./metadataTypes/definitions/TransactionalPush.definition'),
     transactionalSMS: require('./metadataTypes/definitions/TransactionalSMS.definition'),

package/lib/MetadataTypeInfo.js

@@ -6,6 +6,7 @@
 const MetadataTypeInfo = {
     asset: require('./metadataTypes/Asset'),
     attributeGroup: require('./metadataTypes/AttributeGroup'),
+    attributeSet: require('./metadataTypes/AttributeSet'),
     automation: require('./metadataTypes/Automation'),
     campaign: require('./metadataTypes/Campaign'),
     contentArea: require('./metadataTypes/ContentArea'),
@@ -32,7 +33,6 @@ const MetadataTypeInfo = {
     role: require('./metadataTypes/Role'),
     script: require('./metadataTypes/Script'),
     sendClassification: require('./metadataTypes/SendClassification'),
-    setDefinition: require('./metadataTypes/SetDefinition'),
     transactionalEmail: require('./metadataTypes/TransactionalEmail'),
     transactionalPush: require('./metadataTypes/TransactionalPush'),
     transactionalSMS: require('./metadataTypes/TransactionalSMS'),

package/lib/Retriever.js

@@ -189,7 +189,7 @@ class Retriever {
     }
 
     /**
-     * helper for {@link retrieve} to get all dependencies of the given types
+     * helper for {@link Retriever.retrieve} to get all dependencies of the given types
      *
      * @param {TYPE.SupportedMetadataTypes[]} metadataTypes list of metadata types to retrieve; can include subtypes!
      * @returns {TYPE.SupportedMetadataTypes[]} unique list dependent metadata types

package/lib/cli.js

@@ -31,6 +31,12 @@ yargs
                 .positional('KEY', {
                     type: 'string',
                     describe: 'metadata keys that shall be exclusively downloaded',
+                })
+                .option('like', {
+                    type: 'string',
+                    group: 'Options for retrieve:',
+                    describe:
+                        'filter metadata components (can include % as wildcard or _ for a single character)',
                 });
         },
         handler: (argv) => {
@@ -59,22 +65,38 @@ yargs
                 })
                 .option('changeKeyField', {
                     type: 'string',
+                    group: 'Options for deploy:',
                     describe:
                         'enables updating the key of the deployed metadata with the value in provided field (e.g. c__newKey). Can be used to sync name and key fields.',
                 })
                 .option('changeKeyValue', {
                     type: 'string',
+                    group: 'Options for deploy:',
                     describe:
                         'allows updating the key of the metadata to the provided value. Only available if a single type and key is deployed',
                 })
                 .option('fromRetrieve', {
                     type: 'boolean',
+                    group: 'Options for deploy:',
                     describe: 'optionally deploy from retrieve folder',
                 })
                 .option('refresh', {
                     type: 'boolean',
+                    group: 'Options for deploy:',
                     describe:
                         'optional for asset-message: runs refresh command for related triggeredSends after deploy',
+                })
+                .option('execute', {
+                    type: 'boolean',
+                    group: 'Options for deploy:',
+                    describe:
+                        'optional: executes item after deploy; this will run the item once immediately',
+                })
+                .option('schedule', {
+                    type: 'boolean',
+                    group: 'Options for deploy:',
+                    describe:
+                        'optionally start existing schedule instead of running item once immediately (only works for automations)',
                 });
         },
         handler: (argv) => {
@@ -307,6 +329,7 @@ yargs
         builder: (yargs) => {
             yargs.option('json', {
                 type: 'boolean',
+                group: 'Options for explainTypes:',
                 describe: 'optionaly return info in json format',
             });
         },
@@ -316,7 +339,7 @@ yargs
         },
     })
     .command({
-        command: 'createDeltaPkg [range] [--filter <BU>] [--commitHistory <number>]',
+        command: 'createDeltaPkg [range]',
         aliases: ['cdp'],
         desc: 'Copies commit-based file delta into deploy folder',
         builder: (yargs) => {
@@ -327,11 +350,13 @@ yargs
                 })
                 .option('filter', {
                     type: 'string',
+                    group: 'Options for createDeltaPkg:',
                     describe:
                         'Disable templating & instead filter by the specified BU path (comma separated), can include subtype, will be prefixed with "retrieve/"',
                 })
                 .option('commitHistory', {
                     type: 'number',
+                    group: 'Options for createDeltaPkg:',
                     describe: 'Number of commits to look back for changes (supersedes config)',
                 });
         },
@@ -389,6 +414,147 @@ yargs
             Mcdev.refresh(argv.BU, argv.TYPE, csvToArray(argv.KEY));
         },
     })
+    .command({
+        command: 'execute <BU> <TYPE> [KEY]',
+        aliases: ['exec', 'start'],
+        desc: 'executes the entity (query/journey/automation etc.)',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe: 'the business unit where to start an item',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type',
+                })
+                .positional('KEY', {
+                    type: 'string',
+                    describe: 'key(s) of the metadata component(s)',
+                })
+                .option('like', {
+                    type: 'string',
+                    group: 'Options for execute:',
+                    describe:
+                        'filter metadata components (can include % as wildcard or _ for a single character)',
+                })
+                .option('schedule', {
+                    type: 'boolean',
+                    group: 'Options for execute:',
+                    describe:
+                        'optionally start existing schedule instead of running item once immediately (only works for automations)',
+                });
+        },
+        handler: (argv) => {
+            Mcdev.setOptions(argv);
+            // ! do not allow multiple types to be passed in here via csvToArray
+            Mcdev.execute(argv.BU, argv.TYPE, csvToArray(argv.KEY));
+        },
+    })
+    .command({
+        command: 'schedule <BU> <TYPE> [KEY]',
+        aliases: ['sched'],
+        desc: 'starts the predefined schedule of the item (shortcut for running execute --schedule)',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe: 'the business unit where to start an item',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type',
+                })
+                .positional('KEY', {
+                    type: 'string',
+                    describe: 'key(s) of the metadata component(s)',
+                })
+                .option('like', {
+                    type: 'string',
+                    group: 'Options for execute:',
+                    describe:
+                        'filter metadata components (can include % as wildcard or _ for a single character)',
+                });
+        },
+        handler: (argv) => {
+            Mcdev.setOptions(argv);
+            // ! do not allow multiple types to be passed in here via csvToArray
+            Mcdev.schedule(argv.BU, argv.TYPE, csvToArray(argv.KEY));
+        },
+    })
+    .command({
+        command: 'pause <BU> <TYPE> [KEY]',
+        aliases: ['p', 'stop'],
+        desc: 'pauses the entity (automation etc.)',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe: 'the business unit where to start an item',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type',
+                })
+                .positional('KEY', {
+                    type: 'string',
+                    describe: 'key(s) of the metadata component(s)',
+                })
+                .option('like', {
+                    type: 'string',
+                    group: 'Options for pause:',
+                    describe:
+                        'filter metadata components (can include % as wildcard or _ for a single character)',
+                });
+        },
+        handler: (argv) => {
+            Mcdev.setOptions(argv);
+            // ! do not allow multiple types to be passed in here via csvToArray
+            Mcdev.pause(argv.BU, argv.TYPE, csvToArray(argv.KEY));
+        },
+    })
+    .command({
+        command: 'fixKeys <BU> <TYPE> [KEY]',
+        aliases: ['fx'],
+        desc: 'changes the key of the items to match the name',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe: 'the business unit where to fix keys',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type',
+                })
+                .positional('KEY', {
+                    type: 'string',
+                    describe: 'key(s) of the metadata component(s)',
+                })
+                .option('like', {
+                    type: 'string',
+                    group: 'Options for fixKeys:',
+                    describe:
+                        'filter metadata components (can include % as wildcard or _ for a single character)',
+                })
+                .option('execute', {
+                    type: 'boolean',
+                    group: 'Options for fixKeys:',
+                    describe:
+                        'optional: executes item after deploy; this will run the item once immediately',
+                })
+                .option('schedule', {
+                    type: 'boolean',
+                    group: 'Options for fixKeys:',
+                    describe:
+                        'optionally start existing schedule instead of running item once immediately (only works for automations)',
+                });
+        },
+        handler: (argv) => {
+            Mcdev.setOptions(argv);
+            Mcdev.fixKeys(argv.BU, argv.TYPE, csvToArray(argv.KEY));
+        },
+    })
     .command({
         command: 'upgrade',
         aliases: ['up'],
@@ -410,6 +576,14 @@ yargs
         type: 'boolean',
         description: 'Only output errors to CLI',
     })
+    .option('noLogColors', {
+        type: 'boolean',
+        description: 'do not use color codes in CLI log output',
+    })
+    .option('noLogFile', {
+        type: 'boolean',
+        description: 'Only output log to CLI but not to files',
+    })
     .option('skipInteraction', {
         alias: ['yes', 'y'],
         description: 'Interactive questions where possible and go with defaults instead',
@@ -438,9 +612,13 @@ function csvToArray(csv) {
     return !csv
         ? null
         : csv.includes(',')
-        ? csv.split(',').map((item) =>
-              // allow whitespace in comma-separated lists
-              item.trim()
-          )
-        : [csv.trim()];
+        ? csv
+              .split(',')
+              .map((item) =>
+                  // allow whitespace in comma-separated lists
+                  item.trim()
+              )
+              // make sure trailing commas are ignored
+              .filter(Boolean)
+        : [csv.trim()].filter(Boolean);
 }