mcdev 7.8.0 → 7.10.0

package/boilerplate/files/eslint.config.js

@@ -16,6 +16,31 @@ export default [
     {
         plugins: { jsdoc },
         rules: {
+            'unicorn/better-regex': 'off',
+            'unicorn/prefer-string-raw': 'off',
+            'unicorn/catch-error-name': [
+                'error',
+                {
+                    name: 'ex'
+                }
+            ],
+            'unicorn/explicit-length-check': 'off',
+            'unicorn/no-null': 'off',
+            'unicorn/prefer-module': 'off',
+            'unicorn/prevent-abbreviations': 'off',
+            'unicorn/filename-case': 'off',
+            'unicorn/no-array-callback-reference': 'off',
+            'unicorn/no-array-reduce': 'off',
+            'unicorn/no-await-expression-member': 'off',
+            'unicorn/no-hex-escape': 'off',
+            'unicorn/no-nested-ternary': 'off',
+            'unicorn/no-static-only-class': 'off',
+            'unicorn/no-unused-properties': 'warn',
+            'unicorn/numeric-separators-style': 'off',
+            'unicorn/prefer-array-some': 'off',
+            'unicorn/prefer-set-has': 'off',
+            'unicorn/prefer-spread': 'off',
+            'unicorn/prefer-string-replace-all': 'error',
             'padded-blocks': 'off',
             'prefer-rest-params': 'off',
             'prefer-spread': 'off',
@@ -49,7 +74,11 @@ export default [
     },
     {
         ...sfmcSsjs.configs.recommended,
-        files: ['**/*.ssjs']
+        files: ['**/*.ssjs'],
+        rules: {
+            'unicorn/text-encoding-identifier-case': 'off',
+            'unicorn/prefer-string-replace-all': 'off'
+        }
     },
     {
         files: ['**/*.js'],
@@ -106,32 +135,6 @@ export default [
 
         rules: {
             'logical-assignment-operators': ['error', 'always'],
-            'unicorn/better-regex': 'off',
-
-            'unicorn/catch-error-name': [
-                'error',
-                {
-                    name: 'ex'
-                }
-            ],
-
-            'unicorn/explicit-length-check': 'off',
-            'unicorn/no-null': 'off',
-            'unicorn/prefer-module': 'off',
-            'unicorn/prevent-abbreviations': 'off',
-            'unicorn/filename-case': 'off',
-            'unicorn/no-array-callback-reference': 'off',
-            'unicorn/no-array-reduce': 'off',
-            'unicorn/no-await-expression-member': 'off',
-            'unicorn/no-hex-escape': 'off',
-            'unicorn/no-nested-ternary': 'off',
-            'unicorn/no-static-only-class': 'off',
-            'unicorn/no-unused-properties': 'warn',
-            'unicorn/numeric-separators-style': 'off',
-            'unicorn/prefer-array-some': 'off',
-            'unicorn/prefer-set-has': 'off',
-            'unicorn/prefer-spread': 'off',
-            'unicorn/prefer-string-replace-all': 'error',
             'arrow-body-style': ['error', 'as-needed'],
             curly: 'error',
 

package/boilerplate/forcedUpdates.json

@@ -1,4 +1,8 @@
 [
+    {
+        "version": "7.9.1",
+        "files": ["eslint.config.js"]
+    },
     {
         "version": "7.7.2",
         "files": [".vscode/extensions.json"]

package/lib/index.js

@@ -1030,7 +1030,7 @@ class Mcdev {
         );
 
         // try re-retrieve without passing selectedTypes to ensure we find all dependencies
-        await this._reRetrieve(businessUnit, true);
+        await this._reRetrieve(businessUnit, true, null, typeKeyList);
 
         Util.logger.info(
             'Searching for selected items and their dependencies in your project folder'
@@ -1313,11 +1313,17 @@ class Mcdev {
      * @param {string} businessUnit references credentials from properties.json
      * @param {boolean} [alwaysAsk] by default this code only runs if --retrieve is set; this flag allows to always ask
      * @param {TypeKeyCombo} [selectedTypes] limit retrieval to given metadata type
+     * @param {TypeKeyCombo} [defaultPlusTheseTypes] if we run build for a non-standard type we need to tell it what to download on top
      * @returns {Promise.<void>} -
      */
-    static async _reRetrieve(businessUnit, alwaysAsk = false, selectedTypes) {
+    static async _reRetrieve(
+        businessUnit,
+        alwaysAsk = false,
+        selectedTypes,
+        defaultPlusTheseTypes
+    ) {
         let runRetrieveNow;
-        if (!Util.OPTIONS.skipInteraction && !Util.OPTIONS.retrieve && alwaysAsk) {
+        if (!Util.OPTIONS.skipInteraction && Util.OPTIONS.retrieve === undefined && alwaysAsk) {
             runRetrieveNow = await confirm({
                 message: `Do you want to re-retrieve ${selectedTypes ? Util.convertTypeKeyToString(selectedTypes) : 'all metadata'} for ${businessUnit} now?`,
                 default: false,
@@ -1327,8 +1333,25 @@ class Mcdev {
             Util.logger.info(
                 `Re-retrieving ${businessUnit}: ${selectedTypes ? Util.convertTypeKeyToString(selectedTypes) : 'all metadata'}`
             );
-            // we need to work with a clone here because retrieve() modifies the object passed in as 2nd parameter
-            const retrieveTypes = structuredClone(selectedTypes);
+            /** @type {TypeKeyCombo | string[]} */
+            let retrieveTypes = selectedTypes ? structuredClone(selectedTypes) : null;
+            if (defaultPlusTheseTypes) {
+                if (selectedTypes) {
+                    // we need to work with a clone here because retrieve() modifies the object passed in as 2nd parameter
+                    retrieveTypes = Object.assign(
+                        retrieveTypes,
+                        structuredClone(defaultPlusTheseTypes)
+                    );
+                } else {
+                    const properties = await config.getProperties();
+                    retrieveTypes = [
+                        ...new Set(
+                            properties.metaDataTypes.retrieve.map((type) => type.split('-')[0])
+                        ),
+                    ];
+                    retrieveTypes.push(...Object.keys(defaultPlusTheseTypes));
+                }
+            }
             await this.retrieve(businessUnit, retrieveTypes);
         }
     }

package/lib/metadataTypes/Automation.js

@@ -987,7 +987,6 @@ class Automation extends MetadataType {
             delete metadata.schedule;
             delete metadata.type;
             let i = 0;
-            const buName = this.buObject.credential + '/' + this.buObject.businessUnit;
             if (metadata.steps) {
                 for (const step of metadata.steps) {
                     let displayOrder = 0;
@@ -997,23 +996,6 @@ class Automation extends MetadataType {
                             activity.r__key &&
                             this.definition.dependencies.includes(activity.r__type)
                         ) {
-                            if (
-                                activity.r__type === 'verification' &&
-                                this.createdKeyMap?.[buName]?.verification?.[activity.r__key]
-                            ) {
-                                Util.logger.debug(
-                                    Util.getGrayMsg(
-                                        ` - updated verification activity name from ${
-                                            activity.r__key
-                                        } to ${
-                                            this.createdKeyMap[buName].verification[activity.r__key]
-                                        }`
-                                    )
-                                );
-                                // map structure: cred/bu --> type --> old key --> new key
-                                activity.r__key =
-                                    this.createdKeyMap[buName].verification[activity.r__key];
-                            }
                             // automations can have empty placeholder for activities with only their type defined
                             activity.activityObjectId = cache.searchForField(
                                 activity.r__type,

package/lib/metadataTypes/DomainVerification.js

@@ -54,7 +54,60 @@ class DomainVerification extends MetadataType {
      * @returns {Promise} Promise
      */
     static create(metadataItem) {
-        return super.createREST(metadataItem, '/messaging/v1/domainverification/');
+        return metadataItem.domain === 'bulk' &&
+            (Array.isArray(metadataItem.addresses) ||
+                (metadataItem.deTable && metadataItem.deColumn))
+            ? this.createRESTBulk(metadataItem, '/messaging/v1/domainverification/') // bulk/insert
+            : super.createREST(metadataItem, '/messaging/v1/domainverification/');
+    }
+
+    /**
+     * Creates a multiple metadata entries via REST
+     *
+     * @param {MetadataTypeItem} metadataEntry a single metadata Entry
+     * @param {string} uri rest endpoint for POST
+     * @returns {Promise.<object> | null} Promise of API response or null in case of an error
+     */
+    static async createRESTBulk(metadataEntry, uri) {
+        if (metadataEntry.deTable || metadataEntry.deColumn) {
+            Util.logger.error(
+                'It seems the deTable/deColumn approach does not work. Supply emails via addresses-array instead'
+            );
+            return;
+        }
+        const createResults = {};
+        for (const address of metadataEntry.addresses) {
+            if (cache.getByKey(this.definition.type, address)) {
+                Util.logger.warn(` - ${this.definition.type} ${address} already exists`);
+                continue;
+            }
+            const item = { domain: address };
+            if (await this.createREST(item, uri)) {
+                createResults[address] = true;
+            }
+        }
+        if (Object.keys(createResults).length) {
+            // trigger re-retrieve to get all fields
+            await this.postDeployTasks(createResults);
+            await this.saveResults(
+                createResults,
+                [
+                    this.properties.directories.retrieve,
+                    this.buObject.credential,
+                    this.buObject.businessUnit,
+                ].join('/'),
+                null
+            );
+        }
+        Util.logger.info(
+            `${this.definition.type} bulk load: ${Object.keys(createResults).length} of ${metadataEntry.addresses.length} created`
+        );
+        if (Object.keys(createResults).length) {
+            Util.logger.warn('Please ignore the next message about filtering 1 item');
+            return `bulk successfully added.`;
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -121,9 +174,13 @@ class DomainVerification extends MetadataType {
      * manages post retrieve steps
      *
      * @param {DomainVerificationItem} metadataItem a single item
-     * @returns {DomainVerificationItem} metadata
+     * @returns {DomainVerificationItem|void} metadata
      */
     static postRetrieveTasks(metadataItem) {
+        if (typeof metadataItem === 'string' && metadataItem === 'bulk successfully added.') {
+            // this is a hack for bulk-creation only
+            return;
+        }
         if (metadataItem.status !== 'Verified') {
             Util.logger.warn(
                 Util.getMsgPrefix(this.definition, metadataItem) +
@@ -146,6 +203,9 @@ class DomainVerification extends MetadataType {
      */
     static async postDeployTasks(upsertResults) {
         // re-retrieve all upserted items to ensure we have all fields (createdDate and modifiedDate are otherwise not present)
+        if (!Object.keys(upsertResults).length) {
+            return;
+        }
         Util.logger.debug(
             `Caching all ${this.definition.type} post-deploy to ensure we have all fields`
         );

package/lib/metadataTypes/MetadataType.js

@@ -198,9 +198,10 @@ class MetadataType {
      *
      * @param {MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
+     * @param {MetadataTypeItem} metadataEntryWithAllFields like metadataEntry but before non-creatable fields were stripped
      * @returns {Promise.<object>} apiResponse, potentially modified
      */
-    static postUpdateTasks(metadataEntry, apiResponse) {
+    static postUpdateTasks(metadataEntry, apiResponse, metadataEntryWithAllFields) {
         return apiResponse;
     }
 
@@ -1262,13 +1263,14 @@ class MetadataType {
      * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async updateREST(metadataEntry, uri, httpMethod = 'patch') {
+        const metadataClone = structuredClone(metadataEntry);
         this.removeNotUpdateableFields(metadataEntry);
         try {
             // set to empty object in case API returned nothing to be able to update it in helper classes
             let response = (await this.client.rest[httpMethod](uri, metadataEntry)) || {};
             await this._postChangeKeyTasks(metadataEntry);
             this.getErrorsREST(response);
-            response = await this.postUpdateTasks(metadataEntry, response);
+            response = await this.postUpdateTasks(metadataEntry, response, metadataClone);
             // some times, e.g. automation dont return a key in their update response and hence we need to fall back to name
             Util.logger.info(` - updated ${Util.getTypeKeyName(this.definition, metadataEntry)}`);
             return response;
@@ -1327,6 +1329,7 @@ class MetadataType {
      */
     static async updateSOAP(metadataEntry, handleOutside) {
         const soapType = this.definition.soapType || this.definition.type;
+        const metadataClone = structuredClone(metadataEntry);
         this.removeNotUpdateableFields(metadataEntry);
         try {
             let response = await this.client.soap.update(
@@ -1340,7 +1343,7 @@ class MetadataType {
                 );
             }
             await this._postChangeKeyTasks(metadataEntry);
-            response = await this.postUpdateTasks(metadataEntry, response);
+            response = await this.postUpdateTasks(metadataEntry, response, metadataClone);
 
             return response;
         } catch (ex) {
@@ -1515,6 +1518,7 @@ class MetadataType {
             : [];
         const results = {};
         for (const item of metadataArr) {
+            this.createCustomKeyField(item);
             const key = item[this.definition.keyField];
             results[key] = item;
         }
@@ -1617,6 +1621,13 @@ class MetadataType {
         }
     }
 
+    /**
+     * helper for {@link parseResponseBody} that creates a custom key field for this type based on mobileCode and keyword
+     *
+     * @param {MetadataTypeItem} metadata single item
+     */
+    static createCustomKeyField(metadata) {}
+
     /**
      * Builds map of metadata entries mapped to their keyfields
      *
@@ -1632,18 +1643,21 @@ class MetadataType {
             if (Array.isArray(body)) {
                 // in some cases data is just an array
                 for (const item of body) {
+                    this.createCustomKeyField(item);
                     const key = item[keyField];
                     metadataStructure[key] = item;
                 }
             } else if (body[bodyIteratorField]) {
                 for (const item of body[bodyIteratorField]) {
+                    this.createCustomKeyField(item);
                     const key = item[keyField];
                     metadataStructure[key] = item;
                 }
             } else if (singleRetrieve) {
                 // some types will return a single item intead of an array if the key is supported by their api
+                this.createCustomKeyField(body);
                 // ! currently, the id: prefix is only supported by journey (interaction)
-                if ('string' === typeof singleRetrieve && singleRetrieve.startsWith('id:')) {
+                if (singleRetrieve.startsWith('id:')) {
                     singleRetrieve = body[keyField];
                 }
                 metadataStructure[singleRetrieve] = body;

package/lib/metadataTypes/MobileKeyword.js

@@ -60,61 +60,11 @@ class MobileKeyword extends MetadataType {
     }
 
     /**
-     * Builds map of metadata entries mapped to their keyfields
-     *
-     * @param {object} body json of response body
-     * @param {string} [singleRetrieve] key of single item to filter by
-     * @returns {MetadataTypeMap} keyField => metadata map
-     */
-    static parseResponseBody(body, singleRetrieve) {
-        const bodyIteratorField = this.definition.bodyIteratorField;
-        const keyField = this.definition.keyField;
-        const metadataStructure = {};
-        if (body !== null) {
-            if (Array.isArray(body)) {
-                // in some cases data is just an array
-                for (const item of body) {
-                    this.#createCustomKeyField(item);
-                    const key = item[keyField];
-                    metadataStructure[key] = item;
-                }
-            } else if (body[bodyIteratorField]) {
-                for (const item of body[bodyIteratorField]) {
-                    this.#createCustomKeyField(item);
-                    const key = item[keyField];
-                    metadataStructure[key] = item;
-                }
-            } else if (singleRetrieve) {
-                // some types will return a single item intead of an array if the key is supported by their api
-                this.#createCustomKeyField(body);
-                // ! currently, the id: prefix is only supported by journey (interaction)
-                if (singleRetrieve.startsWith('id:')) {
-                    singleRetrieve = body[keyField];
-                }
-                metadataStructure[singleRetrieve] = body;
-                return metadataStructure;
-            }
-            if (
-                metadataStructure[singleRetrieve] &&
-                (typeof singleRetrieve === 'string' || typeof singleRetrieve === 'number')
-            ) {
-                // in case we really just wanted one entry but couldnt do so in the api call, filter it here
-                const single = {};
-                single[singleRetrieve] = metadataStructure[singleRetrieve];
-                return single;
-            } else if (singleRetrieve) {
-                return {};
-            }
-        }
-        return metadataStructure;
-    }
-
-    /**
-     * helper for {@link MobileKeyword.parseResponseBody} that creates a custom key field for this type based on mobileCode and keyword
+     * helper for {@link parseResponseBody} that creates a custom key field for this type based on mobileCode and keyword
      *
      * @param {MetadataTypeItem} metadata single item
      */
-    static #createCustomKeyField(metadata) {
+    static createCustomKeyField(metadata) {
         metadata.c__codeKeyword = metadata.code.code + '.' + metadata.keyword;
     }
 

package/lib/metadataTypes/Verification.js

@@ -29,6 +29,7 @@ import cache from '../util/cache.js';
  * @augments MetadataType
  */
 class Verification extends MetadataType {
+    static verificationIdKeyMap;
     /**
      * Retrieves Metadata of Data Verification Activity.
      *
@@ -39,51 +40,63 @@ class Verification extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static async retrieve(retrieveDir, _, __, key) {
-        let paramArr = [];
-        if (key?.startsWith('id:')) {
-            paramArr = [key.slice(3)];
-        } else if (key) {
-            paramArr = [key];
+        const paramArr = [];
+        let automationKey;
+        if (key) {
+            const regex = /^(.*?)__s\d{1,3}\.\d{1,3}$/;
+            const match = key.match(regex);
+            if (match) {
+                // automation key found
+                automationKey = match[1];
+            } else {
+                // invalid key, unset it
+                Util.logger.error(`Invalid key: ${key}`);
+                return;
+            }
         }
-        if (!paramArr.length) {
-            // there is no API endpoint to retrieve all dataVerification items, so we need to retrieve all automations and iterate over their activities
-            Util.logger.info(` - Caching dependent Metadata: automation`);
-            Automation.client = this.client;
-            Automation.buObject = this.buObject;
-            Automation.properties = this.properties;
-            Automation._skipNotificationRetrieve = true;
-            delete Automation._cachedMetadataMap;
-            const automationsMapObj = await Automation.retrieve();
-            delete Automation._skipNotificationRetrieve;
-            if (automationsMapObj?.metadata && Object.keys(automationsMapObj?.metadata).length) {
-                if (!key) {
-                    // if we are not retrieving a single item, cache the automations for later use during retrieval of automations
-                    Automation._cachedMetadataMap = automationsMapObj?.metadata;
-                }
-                // automations found, lets iterate over their activities to find the dataVerification items
-                const dataVerificationIds = [];
-                for (const automation of Object.values(automationsMapObj.metadata)) {
-                    if (automation.steps) {
-                        for (const step of automation.steps) {
-                            for (const activity of step.activities) {
-                                if (
-                                    activity.objectTypeId === 1000 &&
-                                    activity.activityObjectId &&
-                                    activity.activityObjectId !==
-                                        '00000000-0000-0000-0000-000000000000'
-                                ) {
-                                    dataVerificationIds.push(activity.activityObjectId);
-                                }
+        const results = {};
+        // there is no API endpoint to retrieve all dataVerification items, so we need to retrieve all automations and iterate over their activities
+        Util.logger.info(` - Caching dependent Metadata: automation`);
+        Automation.client = this.client;
+        Automation.buObject = this.buObject;
+        Automation.properties = this.properties;
+        Automation._skipNotificationRetrieve = true;
+        delete Automation._cachedMetadataMap;
+        const automationsMapObj = automationKey
+            ? await Automation.retrieve(undefined, undefined, undefined, automationKey)
+            : await Automation.retrieve();
+        delete Automation._skipNotificationRetrieve;
+        if (automationsMapObj?.metadata && Object.keys(automationsMapObj?.metadata).length) {
+            if (!key) {
+                // if we are not retrieving a single item, cache the automations for later use during retrieval of automations
+                Automation._cachedMetadataMap = automationsMapObj?.metadata;
+            }
+            // automations found, lets iterate over their activities to find the dataVerification items
+            this.verificationIdKeyMap = {};
+            for (const automation of Object.values(automationsMapObj.metadata)) {
+                if (automation.steps) {
+                    for (const step of automation.steps) {
+                        // ideally one would use activity.displayOrder here but that doesnt always start at 1 nor is it always sequential. To avoid cross-BU issues, we use a custom order
+                        let order = 1;
+                        for (const activity of step.activities) {
+                            if (
+                                activity.objectTypeId === 1000 &&
+                                activity.activityObjectId &&
+                                activity.activityObjectId !== '00000000-0000-0000-0000-000000000000'
+                            ) {
+                                // log the verification id
+                                this.verificationIdKeyMap[activity.activityObjectId] =
+                                    `${automation.key}__s${step.step}.${order}`;
                             }
+                            order++;
                         }
                     }
                 }
-                if (dataVerificationIds.length) {
-                    paramArr.push(...dataVerificationIds);
-                }
+            }
+            if (Object.keys(this.verificationIdKeyMap).length) {
+                paramArr.push(...Object.keys(this.verificationIdKeyMap));
             }
         }
-        const results = {};
         if (paramArr.length) {
             const response = await this.retrieveRESTcollection(
                 paramArr.map((id) => ({ id, uri: '/automation/v1/dataverifications/' + id })),
@@ -131,7 +144,7 @@ class Verification extends MetadataType {
     }
 
     /**
-     * Retrieves Metadata of  Data Extract Activity for caching
+     * Retrieves Metadata of item for caching
      *
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
@@ -140,9 +153,9 @@ class Verification extends MetadataType {
     }
 
     /**
-     * Creates a single Data Extract
+     * Creates a single item
      *
-     * @param {VerificationItem} metadata a single Data Extract
+     * @param {VerificationItem} metadata a single item
      * @returns {Promise} Promise
      */
     static create(metadata) {
@@ -161,31 +174,41 @@ class Verification extends MetadataType {
         if (!apiResponse?.[this.definition.idField]) {
             return;
         }
-        Util.logger.warn(
-            ` - ${this.definition.type} ${
-                metadataEntryWithAllFields?.[this.definition.idField]
-            }: new key ${
-                apiResponse?.[this.definition.idField]
-            } automatically assigned during creation`
-        );
+        // update apiResponse to ensure the new metadata is saved correctly on disk
+        apiResponse[this.definition.keyField] =
+            metadataEntryWithAllFields?.[this.definition.keyField];
+
+        // update info on metadataEntry to allow for proper logs
+        metadataEntry[this.definition.keyField] =
+            metadataEntryWithAllFields?.[this.definition.keyField];
         metadataEntry[this.definition.idField] = apiResponse?.[this.definition.idField];
 
-        // map structure: cred/bu --> type --> old key --> new key
-        const buName = this.buObject.credential + '/' + this.buObject.businessUnit;
-        Automation.createdKeyMap ||= {};
-        Automation.createdKeyMap[buName] ||= {};
-        Automation.createdKeyMap[buName][this.definition.type] ||= {};
-        Automation.createdKeyMap[buName][this.definition.type][
-            metadataEntryWithAllFields[this.definition.idField]
-        ] = metadataEntry[this.definition.idField];
+        return apiResponse;
+    }
+    /**
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP}
+     *
+     * @param {MetadataTypeItem} metadataEntry a single metadata Entry
+     * @param {object} apiResponse varies depending on the API call
+     * @param {MetadataTypeItem} metadataEntryWithAllFields like metadataEntry but before non-creatable fields were stripped
+     * @returns {Promise.<object>} apiResponse, potentially modified
+     */
+    static postUpdateTasks(metadataEntry, apiResponse, metadataEntryWithAllFields) {
+        // update apiResponse to ensure the new metadata is saved correctly on disk
+        apiResponse[this.definition.keyField] =
+            metadataEntryWithAllFields?.[this.definition.keyField];
 
+        // update info on metadataEntry to allow for proper logs
+        metadataEntry[this.definition.keyField] =
+            metadataEntryWithAllFields?.[this.definition.keyField];
+        metadataEntry[this.definition.idField] = apiResponse?.[this.definition.idField];
         return apiResponse;
     }
 
     /**
-     * Updates a single Data Extract
+     * Updates a single item
      *
-     * @param {VerificationItem} metadata a single Data Extract
+     * @param {VerificationItem} metadata a single item
      * @returns {Promise} Promise
      */
     static update(metadata) {
@@ -209,9 +232,22 @@ class Verification extends MetadataType {
             'ObjectID'
         );
         delete metadata.r__dataExtension_key;
+
         return metadata;
     }
 
+    /**
+     * helper for {@link parseResponseBody} that creates a custom key field for this type based on mobileCode and keyword
+     *
+     * @param {MetadataTypeItem} metadata single item
+     */
+    static createCustomKeyField(metadata) {
+        if (this.verificationIdKeyMap[metadata[this.definition.idField]]) {
+            metadata[this.definition.keyField] =
+                this.verificationIdKeyMap[metadata[this.definition.idField]];
+        }
+    }
+
     /**
      * parses retrieved Metadata before saving
      *

package/lib/metadataTypes/definitions/TriggeredSend.definition.js

@@ -39,9 +39,9 @@ export default {
     maxKeyLength: 36, // confirmed max length
     type: 'triggeredSend',
     soapType: 'triggeredSendDefinition',
-    typeDescription: 'DEPRECATED: Sends emails via API or DataExtension Event.',
-    typeRetrieveByDefault: true,
-    typeCdpByDefault: true,
+    typeDescription: 'Used by Journey Builder to send triggered emails',
+    typeRetrieveByDefault: false,
+    typeCdpByDefault: false,
     typeName: 'Triggered Send',
     priorityMapping: {
         High: 3,