mcdev 3.0.2 → 3.1.2

package/lib/Deployer.js

@@ -81,7 +81,10 @@ class Deployer {
             MetadataTypeInfo[type].client = this.client;
             MetadataTypeInfo[type].properties = this.properties;
             Util.logger.info('Caching dependent Metadata: ' + metadataType);
-            const result = await MetadataTypeInfo[type].retrieveForCache(this.buObject, subType);
+            let result;
+            await Util.retryOnError(`Retrying ${type}`, async () => {
+                result = await MetadataTypeInfo[type].retrieveForCache(this.buObject, subType);
+            });
             this.cache[type] = result.metadata;
         }
         // deploy metadata files, extending cache once deploys

package/lib/MetadataTypeDefinitions.js

@@ -4,6 +4,7 @@
  * Provides access to all metadataType classes
  */
 const MetadataTypeDefinitions = {
+    accountUser: require('./metadataTypes/definitions/AccountUser.definition'),
     asset: require('./metadataTypes/definitions/Asset.definition'),
     attributeGroup: require('./metadataTypes/definitions/AttributeGroup.definition'),
     automation: require('./metadataTypes/definitions/Automation.definition'),

package/lib/MetadataTypeInfo.js

@@ -4,6 +4,7 @@
  * Provides access to all metadataType classes
  */
 const MetadataTypeInfo = {
+    accountUser: require('./metadataTypes/AccountUser'),
     asset: require('./metadataTypes/Asset'),
     attributeGroup: require('./metadataTypes/AttributeGroup'),
     automation: require('./metadataTypes/Automation'),

package/lib/Retriever.js

@@ -40,9 +40,11 @@ class Retriever {
      * @param {String[]} metadataTypes String list of metadata types to retrieve
      * @param {String} [name] name of Metadata to retrieve (in case of templating)
      * @param {Object} [templateVariables] Object of values which can be replaced (in case of templating)
-     * @returns {Promise} Promise
+     * @param {boolean} [changelogOnly] skip saving, only create json in memory
+     * @returns {Promise<Object<string,Object>>} Promise
      */
-    async retrieve(metadataTypes, name, templateVariables) {
+    async retrieve(metadataTypes, name, templateVariables, changelogOnly) {
+        const retrieveChangelog = {};
         for (const metadataType of Util.getMetadataHierachy(metadataTypes)) {
             let result;
             const [type, subType] = metadataType.split('-');
@@ -53,6 +55,10 @@ class Retriever {
 
             try {
                 if (!metadataTypes.includes(type) && !metadataTypes.includes(metadataType)) {
+                    if (changelogOnly) {
+                        // no extra caching needed for list view
+                        continue;
+                    }
                     Util.logger.info(`Caching dependent Metadata: ${metadataType}`);
                     await Util.retryOnError(
                         `Retrying to cache ${metadataType}`,
@@ -61,10 +67,6 @@ class Retriever {
                                 this.buObject,
                                 subType
                             );
-                            if (type == 'list') {
-                                Util.logger.debug('==list==');
-                                Util.logger.debug(JSON.stringify(result));
-                            }
                         },
                         false
                     );
@@ -97,14 +99,24 @@ class Retriever {
                     });
                 } else {
                     Util.logger.info('Retrieving: ' + metadataType);
-                    await Util.retryOnError(`Retrying ${metadataType}`, async () => {
-                        result = await MetadataTypeInfo[type].retrieve(
-                            this.savePath,
-                            null,
-                            this.buObject,
-                            subType
-                        );
-                    });
+                    if (changelogOnly) {
+                        await Util.retryOnError(`Retrying ${metadataType}`, async () => {
+                            result = await MetadataTypeInfo[type].retrieveChangelog(
+                                null,
+                                this.buObject,
+                                subType
+                            );
+                        });
+                    } else {
+                        await Util.retryOnError(`Retrying ${metadataType}`, async () => {
+                            result = await MetadataTypeInfo[type].retrieve(
+                                this.savePath,
+                                null,
+                                this.buObject,
+                                subType
+                            );
+                        });
+                    }
                 }
                 if (result) {
                     if (templateVariables && Array.isArray(result)) {
@@ -112,6 +124,9 @@ class Retriever {
                         this.metadata[type] = result.map((element) => element.metadata);
                     } else {
                         this.metadata[type] = result.metadata;
+                        if (metadataTypes.includes(type) || metadataTypes.includes(metadataType)) {
+                            retrieveChangelog[type] = result.metadata;
+                        }
                     }
                 }
             } catch (ex) {
@@ -122,6 +137,7 @@ class Retriever {
                 }
             }
         }
+        return retrieveChangelog;
     }
 }
 

package/lib/cli.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * CLI entry for SFMC DevTools
+ */
+
+const Util = require('./util/util');
+const yargs = require('yargs');
+const Mcdev = require('./index');
+
+yargs
+    .scriptName('mcdev')
+    .usage('$0 <command> [options]')
+    .command({
+        command: 'retrieve [BU] [TYPE]',
+        aliases: ['r'],
+        desc: 'retrieves metadata of a business unit',
+        // @ts-ignore
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe:
+                        'the business unit to retrieve from (in format "credential name/BU name")',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type that shall be exclusively downloaded',
+                });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.retrieve(argv.BU, argv.TYPE);
+        },
+    })
+    .command({
+        command: 'deploy [BU] [TYPE]',
+        aliases: ['d'],
+        desc: 'deploys local metadata to a business unit',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe:
+                        'the business unit to deploy to (in format "credential name/BU name")',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type that shall be exclusively uploaded',
+                });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.deploy(argv.BU, argv.TYPE);
+        },
+    })
+    .command({
+        command: 'init [credentialsName]',
+        desc: `creates '${Util.configFileName}' in your root or adds additional credentials to the existing one`,
+        builder: (yargs) => {
+            yargs.positional('credentialsName', {
+                type: 'string',
+                describe: 'name of your installed package',
+            });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.initProject(argv.credentialsName, argv.skipInteraction);
+        },
+    })
+    .command({
+        command: 'reloadBUs [credentialsName]',
+        aliases: ['rb'],
+        desc: 'loads the list of available BUs from the server and saves it to your config',
+        builder: (yargs) => {
+            yargs.positional('credentialsName', {
+                type: 'string',
+                describe: 'name of your installed package',
+            });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.findBUs(argv.credentialsName);
+        },
+    })
+    .command({
+        command: 'badKeys [BU]',
+        desc: 'lists metadata with random API names in specified Business Unit directory',
+        builder: (yargs) => {
+            yargs.positional('BU', {
+                type: 'string',
+                describe: 'the business unit to deploy to',
+            });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.badKeys(argv.BU);
+        },
+    })
+    .command({
+        command: 'document <BU> <TYPE>',
+        aliases: ['doc'],
+        desc: 'Creates Markdown or HTML documentation for the selected type',
+        builder: (yargs) => {
+            yargs
+                .positional('TYPE', {
+                    type: 'string',
+                    describe:
+                        'metadata type to generate docs for; currently supported: dataExtension, role',
+                })
+                .positional('BU', {
+                    type: 'string',
+                    describe:
+                        'the business unit to generate docs for (in format "credential name/BU name")',
+                });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.document(argv.BU, argv.TYPE);
+        },
+    })
+    .command({
+        command: 'delete <BU> <TYPE> <EXTERNALKEY>',
+        aliases: ['del'],
+        desc: 'deletes metadata of selected type and external key',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe:
+                        'the business unit to delete from (in format "credential name/BU name")',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type to delete from; currently supported: dataExtension',
+                })
+                .positional('EXTERNALKEY', {
+                    type: 'string',
+                    describe: 'the key to delete',
+                });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.deleteByKey(argv.BU, argv.TYPE, argv.EXTERNALKEY);
+        },
+    })
+    .command({
+        command: 'retrieveAsTemplate <BU> <TYPE> <NAME> <MARKET>',
+        aliases: ['rt'],
+        desc: 'Retrieves a specific metadata file by name for templating',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe:
+                        'the business unit to deploy to (in format "credential name/BU name")',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type',
+                })
+                .positional('NAME', {
+                    type: 'string',
+                    describe: 'name of the metadata component',
+                })
+                .positional('MARKET', {
+                    type: 'string',
+                    describe: 'market used for reverse building template',
+                });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.retrieveAsTemplate(argv.BU, argv.TYPE, argv.NAME, argv.MARKET);
+        },
+    })
+    .command({
+        command: 'buildDefinition <BU> <TYPE> <NAME> <MARKET>',
+        aliases: ['bd'],
+        desc: 'builds metadata definition based on template',
+        builder: (yargs) => {
+            yargs
+                .positional('BU', {
+                    type: 'string',
+                    describe: 'the business unit to deploy to',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type',
+                })
+                .positional('NAME', {
+                    type: 'string',
+                    describe: 'name of the metadata component',
+                })
+                .positional('MARKET', {
+                    type: 'string',
+                    describe: 'the business unit to deploy to',
+                });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.buildDefinition(argv.BU, argv.TYPE, argv.NAME, argv.MARKET);
+        },
+    })
+    .command({
+        command: 'buildDefinitionBulk <LISTNAME> <TYPE> <NAME>',
+        aliases: ['bdb'],
+        desc: 'builds metadata definition based on template en bulk',
+        builder: (yargs) => {
+            yargs
+                .positional('LISTNAME', {
+                    type: 'string',
+                    describe: 'name of list of BU-market combos',
+                })
+                .positional('TYPE', {
+                    type: 'string',
+                    describe: 'metadata type',
+                })
+                .positional('NAME', {
+                    type: 'string',
+                    describe: 'name of the metadata component',
+                });
+        },
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.buildDefinitionBulk(argv.LISTNAME, argv.TYPE, argv.NAME);
+        },
+    })
+    .command({
+        command: 'selectTypes',
+        aliases: ['st'],
+        desc: 'lets you choose what metadata types to retrieve',
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.selectTypes();
+        },
+    })
+    .command({
+        command: 'explainTypes',
+        aliases: ['et'],
+        desc: 'explains metadata types that can be retrieved',
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.explainTypes();
+        },
+    })
+    .command({
+        command: 'createDeltaPkg [range] [filter]',
+        aliases: ['cdp'],
+        desc: 'Copies commit-based file delta into deploy folder',
+        builder: (yargs) => {
+            yargs
+                .positional('range', {
+                    type: 'string',
+                    describe: 'Pull Request target branch or git commit range',
+                })
+                .positional('filter', {
+                    type: 'string',
+                    describe:
+                        'Disable templating & instead filter by the specified file path (comma separated)',
+                });
+        },
+        handler: Mcdev.createDeltaPkg,
+    })
+    .command({
+        command: 'upgrade',
+        aliases: ['up'],
+        desc: 'Add NPM dependencies and IDE configuration files to your project',
+        handler: (argv) => {
+            Mcdev._setLoggingLevel(argv);
+            Mcdev.upgrade(argv.skipInteraction);
+        },
+    })
+    .option('verbose', {
+        type: 'boolean',
+        description: 'Run with verbose CLI output',
+    })
+    .option('debug', {
+        type: 'boolean',
+        description: 'Enable developer & edge-case features',
+    })
+    .option('silent', {
+        type: 'boolean',
+        description: 'Only output errors to CLI',
+    })
+    .option('skipInteraction', {
+        alias: ['yes', 'y'],
+        description: 'Interactive questions where possible and go with defaults instead',
+    })
+    .demandCommand(1, 'Please enter a valid command')
+    .strict()
+    .recommendCommands()
+    .wrap(yargs.terminalWidth())
+    .epilog('Copyright 2021. Accenture.')
+    .help().argv;