mcdev 3.1.3 → 4.0.1

package/jsconfig.json

@@ -1,3 +1,3 @@
 {
-    "include": ["lib/**/*.js"]
+    "include": ["lib/**/*.js", "types/**/*.js"]
 }

package/lib/Builder.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const TYPE = require('../types/mcdev.d');
 const Util = require('./util/util');
-
+const File = require('./util/file');
+const config = require('./util/config');
+const Cli = require('./util/cli');
+const auth = require('./util/auth');
 const MetadataTypeInfo = require('./MetadataTypeInfo');
 // @ts-ignore
 
@@ -12,50 +16,46 @@ class Builder {
     /**
      * Creates a Builder, uses v2 auth if v2AuthOptions are passed.
      *
-     * @param {Object} properties properties for auth
-     * @param {String} properties.clientId clientId for FuelSDK auth
-     * @param {String} properties.clientSecret clientSecret for FuelSDK auth
-     * @param {Object} properties.directories list of default directories
-     * @param {String} properties.directories.template where templates are saved
-     * @param {String} properties.directories.templateBuilds where template-based deployment definitions are saved
-     * @param {String} properties.tenant v2 Auth Tenant Information
-     * @param {String} properties.businessUnits ID of Business Unit to authenticate with
-     * @param {Object} buObject properties for auth
-     * @param {String} buObject.clientId clientId for FuelSDK auth
-     * @param {String} buObject.clientSecret clientSecret for FuelSDK auth
-     * @param {Object} buObject.credential clientId for FuelSDK auth
-     * @param {String} buObject.tenant v2 Auth Tenant Information
-     * @param {String} buObject.mid ID of Business Unit to authenticate with
-     * @param {String} buObject.businessUnit name of Business Unit to authenticate with
-     * @param {Util.ET_Client} client fuel client
+     * @param {TYPE.Mcdevrc} properties properties for auth
+saved
+     * @param {TYPE.BuObject} buObject properties for auth
      */
-    constructor(properties, buObject, client) {
-        this.client = client;
+    constructor(properties, buObject) {
         this.properties = properties;
         this.templateDir = properties.directories.template;
+        this.retrieveDir = File.normalizePath([
+            properties.directories.retrieve,
+            buObject.credential,
+            buObject.businessUnit,
+        ]);
+        this.buObject = buObject;
 
         // allow multiple target directories
         const templateBuildsArr = Array.isArray(properties.directories.templateBuilds)
             ? properties.directories.templateBuilds
             : [properties.directories.templateBuilds];
-
         this.targetDir = templateBuildsArr.map(
             (directoriesTemplateBuilds) =>
                 directoriesTemplateBuilds + buObject.credential + '/' + buObject.businessUnit
         );
 
+        /**
+         * @type {TYPE.MultiMetadataTypeList}
+         */
         this.metadata = {};
     }
 
     /**
      * Builds a specific metadata file by name
-     * @param {String} metadataType metadata type to build
-     * @param {String} name name of metadata to build
-     * @param {Object} variables variables to be replaced in the metadata
-     * @returns {Promise} Promise
+     *
+     * @param {string} metadataType metadata type to build
+     * @param {string} name name of metadata to build
+     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<TYPE.MultiMetadataTypeList>} Promise
      */
-    async buildDefinition(metadataType, name, variables) {
+    async _buildDefinition(metadataType, name, templateVariables) {
         let nameArr;
+        /* eslint-disable unicorn/prefer-ternary */
         if (name.includes(',')) {
             nameArr = name.split(',').map((item) =>
                 // allow whitespace in comma-separated lists
@@ -64,6 +64,8 @@ class Builder {
         } else {
             nameArr = [name.trim()];
         }
+        /* eslint-enable unicorn/prefer-ternary */
+
         const type = metadataType;
         try {
             const result = await Promise.all(
@@ -72,78 +74,173 @@ class Builder {
                     // we hence require users to put %20 in their stead and have to convert that back
                     name = name.split('%20').join(' ');
 
-                    MetadataTypeInfo[type].cache = null;
-                    MetadataTypeInfo[type].client = this.client;
+                    MetadataTypeInfo[type].client = auth.getSDK(this.buObject);
                     MetadataTypeInfo[type].properties = this.properties;
+                    MetadataTypeInfo[type].buObject = this.buObject;
                     return MetadataTypeInfo[type].buildDefinition(
                         this.templateDir,
                         this.targetDir,
                         name,
-                        variables
+                        templateVariables
                     );
                 })
             );
             if (result) {
                 this.metadata[result[0].type] = [];
-                result.forEach((element) => {
+                for (const element of result) {
                     this.metadata[result[0].type].push(element.metadata);
-                });
+                }
             }
         } catch (ex) {
-            Util.logger.error('mcdev.buildDefinition:' + ex.message);
-            Util.logger.debug(ex.stack);
-            if (Util.logger.level === 'debug') {
-                console.log(ex.stack);
+            Util.logger.errorStack(ex, 'mcdev.buildDefinition');
+        }
+        return this.metadata;
+    }
+    /**
+     * Build a template based on a list of metadata files in the retrieve folder.
+     *
+     * @param {string} businessUnit references credentials from properties.json
+     * @param {string} selectedType supported metadata type
+     * @param {string[]} keyArr customerkey of the metadata
+     * @param {string} market market localizations
+     * @returns {Promise.<TYPE.MultiMetadataTypeList>} -
+     */
+    static async buildTemplate(businessUnit, selectedType, keyArr, market) {
+        const properties = await config.getProperties();
+        if (!(await config.checkProperties(properties))) {
+            return null;
+        }
+        if (!Util._isValidType(selectedType)) {
+            return;
+        }
+        if (selectedType.includes('-')) {
+            Util.logger.error(
+                `:: '${selectedType}' is not a valid metadata type. Please don't include subtypes.`
+            );
+            return;
+        }
+        const buObject = await Cli.getCredentialObject(properties, businessUnit);
+        if (buObject !== null) {
+            const builder = new Builder(properties, buObject);
+            if (Util.checkMarket(market, properties)) {
+                return builder._buildTemplate(selectedType, keyArr, properties.markets[market]);
             }
         }
+    }
+    /**
+     * Build a template based on a list of metadata files in the retrieve folder.
+     *
+     * @param {string} metadataType metadata type to create a template of
+     * @param {string[]} keyArr customerkey of metadata to create a template of
+     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<TYPE.MultiMetadataTypeList>} Promise
+     */
+    async _buildTemplate(metadataType, keyArr, templateVariables) {
+        const type = metadataType;
+        try {
+            /** @type {TYPE.MetadataTypeItemObj[]} */
+            const result = await Promise.all(
+                keyArr.map((key) => {
+                    MetadataTypeInfo[type].client = this.client;
+                    MetadataTypeInfo[type].properties = this.properties;
+                    MetadataTypeInfo[type].buObject = this.buObject;
+
+                    /** @type {TYPE.MetadataTypeItemObj} */
+                    return MetadataTypeInfo[type].buildTemplate(
+                        this.retrieveDir,
+                        this.templateDir,
+                        key,
+                        templateVariables
+                    );
+                })
+            );
+            if (result) {
+                this.metadata[result[0].type] = result.map((element) => element.metadata);
+            }
+        } catch (ex) {
+            Util.logger.errorStack(ex, 'mcdev.buildTemplate');
+        }
         return this.metadata;
     }
     /**
-     * ensure provided MarketList exists and it's content including markets and BUs checks out
-     * @param {String} mlName name of marketList
-     * @param {Object} properties General configuration to be used in retrieve
-     * @param {Object} properties.markets list of template variable combos
-     * @param {Object} properties.marketList list of bu-market combos
-     * @param {Object} properties.credentials list of credentials and their BUs
-     * @returns {void} throws errors if problems were found
+     * Build a specific metadata file based on a template.
+     *
+     * @param {string} businessUnit references credentials from properties.json
+     * @param {string} selectedType supported metadata type
+     * @param {string} name name of the metadata
+     * @param {string} market market localizations
+     * @returns {Promise.<TYPE.MultiMetadataTypeList>} -
      */
-    static verifyMarketList(mlName, properties) {
-        if (!properties.marketList[mlName]) {
-            // ML does not exist
-            throw new Error(`Market List ${mlName} is not defined`);
-        } else {
-            // ML exists, check if it is properly set up
+    static async buildDefinition(businessUnit, selectedType, name, market) {
+        const properties = await config.getProperties();
+        if (!(await config.checkProperties(properties))) {
+            return null;
+        }
+        if (!Util._isValidType(selectedType)) {
+            return;
+        }
+        if (selectedType.includes('-')) {
+            Util.logger.error(
+                `:: '${selectedType}' is not a valid metadata type. Please don't include subtypes.`
+            );
+            return;
+        }
+        const buObject = await Cli.getCredentialObject(properties, businessUnit);
+        if (buObject !== null) {
+            const builder = new Builder(properties, buObject);
+            if (Util.checkMarket(market, properties)) {
+                return builder._buildDefinition(selectedType, name, properties.markets[market]);
+            }
+        }
+    }
+    /**
+     * Build a specific metadata file based on a template using a list of bu-market combos
+     *
+     * @param {string} listName name of list of BU-market combos
+     * @param {string} type supported metadata type
+     * @param {string} name name of the metadata
+     * @returns {Promise.<TYPE.MultiMetadataTypeList[]>} -
+     */
+    static async buildDefinitionBulk(listName, type, name) {
+        const properties = await config.getProperties();
+        if (!(await config.checkProperties(properties))) {
+            return null;
+        }
+        Util.verifyMarketList(listName, properties);
+        if (type && !MetadataTypeInfo[type]) {
+            Util.logger.error(`:: '${type}' is not a valid metadata type`);
+            return;
+        }
+        let i = 0;
+        const bdPromises = [];
 
-            // check if BUs in marketList are valid
-            let buCounter = 0;
-            for (const businessUnit in properties.marketList[mlName]) {
-                if (businessUnit !== 'description') {
-                    buCounter++;
-                    const [cred, bu] = businessUnit ? businessUnit.split('/') : [null, null];
-                    if (
-                        !properties.credentials[cred] ||
-                        !properties.credentials[cred].businessUnits[bu]
-                    ) {
-                        throw new Error(`'${businessUnit}' in Market ${mlName} is not defined.`);
-                    }
-                    // check if markets are valid
-                    let marketArr = properties.marketList[mlName][businessUnit];
-                    if ('string' === typeof marketArr) {
-                        marketArr = [marketArr];
-                    }
-                    for (const market of marketArr) {
-                        if (!properties.markets[market]) {
-                            throw new Error(`Market '${market}' is not defined.`);
-                        } else {
-                            // * markets can be empty or include variables. Nothing we can test here
-                        }
-                    }
-                }
+        for (const businessUnit in properties.marketList[listName]) {
+            if (businessUnit === 'description') {
+                // skip, it's just a metadata on this list and not a BU
+                continue;
+            }
+            i++;
+            const market = properties.marketList[listName][businessUnit];
+            let marketList = [];
+            if ('string' === typeof market) {
+                marketList.push(market);
+            } else {
+                marketList = market;
             }
-            if (!buCounter) {
-                throw new Error(`No BUs defined in marketList ${mlName}`);
+            for (const market of marketList) {
+                if (Util.checkMarket(market, properties)) {
+                    Util.logger.info(`Executing for '${businessUnit}': '${market}'`);
+                    // omitting "await" to speed up creation
+                    bdPromises.push(this.buildDefinition(businessUnit, type, name, market));
+                }
             }
         }
+        const response = await Promise.all(bdPromises);
+
+        if (!i) {
+            Util.logger.error('Please define properties.marketList in your config');
+        }
+        return response;
     }
 }