mcdev 4.2.1 → 4.3.0

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,16 +59,12 @@ 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 metadataType in deployOrder) {
+            const type = metadataType;
+            const subTypeArr = deployOrder[metadataType];
             // 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];
             // add client to metadata process class instead of passing every time
@@ -78,26 +74,36 @@ class Retriever {
             try {
                 let result;
                 if (!metadataTypes.includes(type) && !metadataTypes.includes(metadataType)) {
+                    // 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.logSubtypes(subTypeArr);
+                    result = await MetadataTypeInfo[type].retrieveForCache(null, subTypeArr);
                 } else if (templateVariables) {
+                    // type is in list of types to retrieve and we have template variables
                     Util.logger.info(`Retrieving as Template: ${metadataType}`);
-
+                    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) =>
                             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 ||
@@ -106,28 +112,26 @@ class Retriever {
                     ) {
                         // 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.logSubtypes(subTypeArr);
                         cacheResult = await MetadataTypeInfo[type].retrieveForCache(
-                            this.buObject,
-                            subType
+                            null,
+                            subTypeArr
                         );
                     }
                     Util.logger.info(
                         `Retrieving: ${metadataType}` +
                             (typeKeyMap[metadataType][0] === null
                                 ? ''
-                                : ` ${color.dim}(Keys: ${typeKeyMap[metadataType].join(', ')})${
-                                      color.reset
-                                  }`)
+                                : Util.getKeysString(typeKeyMap[metadataType]))
                     );
                     result = await (changelogOnly
-                        ? MetadataTypeInfo[type].retrieveChangelog(this.buObject, null, subType)
+                        ? MetadataTypeInfo[type].retrieveChangelog(null, subTypeArr)
                         : Promise.all(
                               typeKeyMap[metadataType].map((key) =>
                                   MetadataTypeInfo[type].retrieve(
                                       this.savePath,
                                       null,
-                                      this.buObject,
-                                      subType,
+                                      subTypeArr,
                                       key
                                   )
                               )

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`);

package/lib/metadataTypes/Asset.js

@@ -19,17 +19,16 @@ class Asset extends MetadataType {
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} _ -
-     * @param {void} __ -
-     * @param {TYPE.AssetSubType} [selectedSubType] optionally limit to a single subtype
+     * @param {TYPE.AssetSubType[]} [subTypeArr] optionally limit to a single subtype
      * @param {string} [key] customer key
      * @returns {Promise.<{metadata: TYPE.AssetMap, type: string}>} Promise
      */
-    static async retrieve(retrieveDir, _, __, selectedSubType, key) {
+    static async retrieve(retrieveDir, _, subTypeArr, key) {
         const items = [];
-        const subTypes = selectedSubType ? [selectedSubType] : this._getSubTypes();
+        subTypeArr = subTypeArr || this._getSubTypes();
         await File.initPrettier();
         // loop through subtypes and return results of each subType for caching (saving is handled per subtype)
-        for (const subType of subTypes) {
+        for (const subType of subTypeArr) {
             // each subtype contains multiple different specific types (images contains jpg and png for example)
             // we use await here to limit the risk of too many concurrent api requests at time
             items.push(
@@ -46,7 +45,8 @@ class Asset extends MetadataType {
         const metadata = this.parseResponseBody({ items: items });
         if (retrieveDir) {
             Util.logger.info(
-                `Downloaded: ${this.definition.type} (${Object.keys(metadata).length})`
+                `Downloaded: ${this.definition.type} (${Object.keys(metadata).length})` +
+                    Util.getKeysString(key)
             );
         }
         return { metadata: metadata, type: this.definition.type };
@@ -55,12 +55,12 @@ class Asset extends MetadataType {
     /**
      * Retrieves asset metadata for caching
      *
-     * @param {void} _ -
-     * @param {string} [selectedSubType] optionally limit to a single subtype
+     * @param {void} _ unused
+     * @param {string[]} [subTypeArr] optionally limit to a single subtype
      * @returns {Promise.<{metadata: TYPE.AssetMap, type: string}>} Promise
      */
-    static retrieveForCache(_, selectedSubType) {
-        return this.retrieve(null, null, null, selectedSubType);
+    static retrieveForCache(_, subTypeArr) {
+        return this.retrieve(null, null, subTypeArr);
     }
 
     /**
@@ -507,10 +507,9 @@ class Asset extends MetadataType {
      *
      * @param {TYPE.AssetItem} metadata a single asset
      * @param {string} deployDir directory of deploy files
-     * @param {TYPE.BuObject} buObject buObject properties for auth
      * @returns {Promise.<TYPE.AssetItem>} Promise
      */
-    static async preDeployTasks(metadata, deployDir, buObject) {
+    static async preDeployTasks(metadata, deployDir) {
         // additonalattributes fail where the value is "" so we need to remove them from deploy
         if (metadata?.data?.email?.attributes?.length > 0) {
             metadata.data.email.attributes = metadata.data.email.attributes.filter(
@@ -519,10 +518,7 @@ class Asset extends MetadataType {
         }
 
         // folder
-        metadata.category = {
-            id: cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID'),
-        };
-        delete metadata.r__folder_Path;
+        this.setFolderId(metadata);
 
         // restore asset type id which is needed for deploy
         metadata.assetType.id = this.definition.typeMapping[metadata.assetType.name];
@@ -538,13 +534,13 @@ class Asset extends MetadataType {
 
         // only execute #3 if we are deploying / copying from one BU to another, not while using mcdev as a developer tool
         if (
-            buObject.mid &&
-            metadata.memberId !== buObject.mid &&
-            !metadata[this.definition.keyField].endsWith(buObject.mid)
+            this.buObject.mid &&
+            metadata.memberId !== this.buObject.mid &&
+            !metadata[this.definition.keyField].endsWith(this.buObject.mid)
         ) {
             // #3 make sure customer key is unique by suffixing it with target MID (unless we are deploying to the same MID)
             // check if this suffixed with the source MID
-            const suffix = '-' + buObject.mid;
+            const suffix = '-' + this.buObject.mid;
             // for customer key max is 36 chars
             metadata[this.definition.keyField] =
                 metadata[this.definition.keyField].slice(0, Math.max(0, 36 - suffix.length)) +
@@ -610,7 +606,7 @@ class Asset extends MetadataType {
      *
      * @private
      * @param {TYPE.AssetItem} metadata a single asset
-     * @returns {TYPE.AssetSubType} subtype
+     * @returns {TYPE.AssetSubType | void} subtype
      */
     static _getSubtype(metadata) {
         for (const sub in this.definition.extendedSubTypes) {
@@ -790,6 +786,17 @@ class Asset extends MetadataType {
             );
         }
     }
+    /**
+     * Asset-specific script that retrieves the folder ID from cache and updates the given metadata with it before deploy
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single item
+     */
+    static setFolderId(metadata) {
+        metadata.category = {
+            id: cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID'),
+        };
+        delete metadata.r__folder_Path;
+    }
 
     /**
      * helper for {@link preDeployTasks} that loads extracted code content back into JSON

package/lib/metadataTypes/AttributeGroup.js

@@ -15,11 +15,10 @@ class AttributeGroup extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @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 retrieve(retrieveDir, _, __, ___, key) {
+    static retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(
             retrieveDir,
             '/hub/v1/contacts/schema/attributeGroups',