mcdev 5.0.1 → 5.1.0

package/lib/metadataTypes/DataExtension.js

@@ -59,8 +59,8 @@ class DataExtension extends MetadataType {
                 // output error & remove from deploy list
                 Util.logger.error(
                     ` ☇ skipping ${this.definition.type} ${
-                        metadataMap[this.definition.keyField]
-                    } / ${metadataMap[this.definition.nameField]}: ${ex.message}`
+                        metadataMap[metadataKey][this.definition.keyField]
+                    } / ${metadataMap[metadataKey][this.definition.nameField]}: ${ex.message}`
                 );
                 delete metadataMap[metadataKey];
                 // skip rest of handling for this DE
@@ -464,9 +464,7 @@ class DataExtension extends MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
                     Util.getKeysString(key)
             );
-            if (this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)) {
-                await this.document(savedMetadata);
-            }
+            await this.runDocumentOnRetrieve(key, savedMetadata);
         }
         return { metadata: metadata, type: 'dataExtension' };
     }
@@ -626,16 +624,16 @@ class DataExtension extends MetadataType {
      * @returns {Promise.<TYPE.DataExtensionItem>} Promise of updated single DE
      */
     static async preDeployTasks(metadata) {
-        if (metadata.Name.startsWith('_')) {
+        if (metadata.Name?.startsWith('_')) {
             throw new Error(`Cannot Upsert Strongly Typed Data Extensions`);
         }
         if (
             this.buObject.eid !== this.buObject.mid &&
-            metadata.r__folder_Path.startsWith('Shared Items')
+            metadata.r__folder_Path?.startsWith('Shared Items')
         ) {
             throw new Error(`Cannot Create/Update a Shared Data Extension from the Child BU`);
         }
-        if (metadata.r__folder_Path.startsWith('Synchronized Data Extensions')) {
+        if (metadata.r__folder_Path?.startsWith('Synchronized Data Extensions')) {
             throw new Error(
                 `Cannot Create/Update a Synchronized Data Extension. Please use Contact Builder to maintain these`
             );

package/lib/metadataTypes/DataExtensionField.js

@@ -170,11 +170,11 @@ class DataExtensionField extends MetadataType {
 
                 // enable renaming
                 if (item.Name_new) {
+                    Util.logger.info(
+                        ` - Found Name_new='${item.Name_new}' for field ${deKey}.${item.Name} - trying to rename.`
+                    );
                     item.Name = item.Name_new;
                     delete item.Name_new;
-                    Util.logger.warn(
-                        ` - Found 'Name_new' value '${item.Name_new}' for ${deKey}.${item.Name} - trying to rename.`
-                    );
                 }
 
                 // check if any changes were found
@@ -210,8 +210,8 @@ class DataExtensionField extends MetadataType {
                     }
                 }
                 if (item.Name_new) {
-                    Util.logger.warn(
-                        ` - Found 'Name_new' value '${item.Name_new}' for ${deKey}.${item.Name} but could not find a corresponding DE field on the server - adding new field instead of updating.`
+                    Util.logger.info(
+                        ` - Found Name_new='${item.Name_new}' for field ${deKey}.${item.Name} but could not find a corresponding DE field on the server - adding new field instead of updating.`
                     );
                     delete item.Name_new;
                 }

package/lib/metadataTypes/Journey.js

@@ -542,12 +542,13 @@ class Journey extends MetadataType {
                     try {
                         // mobileKeyword
                         if (activity.configurationArguments?.keywordId) {
-                            activity.configurationArguments.c__mobileKeyword = cache.searchForField(
-                                'mobileKeyword',
-                                activity.configurationArguments.keywordId,
-                                'id',
-                                'keyword'
-                            );
+                            activity.configurationArguments.r__mobileKeyword_codeKeyword =
+                                cache.searchForField(
+                                    'mobileKeyword',
+                                    activity.configurationArguments.keywordId,
+                                    'id',
+                                    'c__codeKeyword'
+                                );
                             delete activity.configurationArguments.keywordId;
                         }
                     } catch (ex) {
@@ -833,14 +834,14 @@ class Journey extends MetadataType {
                         delete activity.configurationArguments.c__mobileMessage_id;
                     }
                     // mobileKeyword
-                    if (activity.configurationArguments?.c__mobileKeyword) {
+                    if (activity.configurationArguments?.r__mobileKeyword_codeKeyword) {
                         activity.configurationArguments.keywordId = cache.searchForField(
                             'mobileKeyword',
-                            activity.c__mobileKeyword,
-                            'keyword',
+                            activity.r__mobileKeyword_codeKeyword,
+                            'c__codeKeyword',
                             'id'
                         );
-                        delete activity.configurationArguments.c__mobileKeyword;
+                        delete activity.configurationArguments.r__mobileKeyword_codeKeyword;
                     }
                     if (activity.configurationArguments?.c__next_mobileKeyword) {
                         activity.configurationArguments.nextKeywordId = cache.searchForField(

package/lib/metadataTypes/MetadataType.js

@@ -58,15 +58,9 @@ class MetadataType {
                         if (key === fileNameWithoutEnding || listBadKeys) {
                             fileName2FileContent[fileNameWithoutEnding] = fileContent;
                         } else {
-                            Util.metadataLogger(
-                                'error',
-                                this.definition.type,
-                                'getJsonFromFS',
-                                'Name of the Metadata and the External Identifier must match',
-                                JSON.stringify({
-                                    Filename: fileNameWithoutEnding,
-                                    ExternalIdentifier: key,
-                                })
+                            Util.logger.error(
+                                ` ${this.definition.type} ${key}: Name of the metadata file and the JSON-key (${this.definition.keyField}) must match` +
+                                    Util.getGrayMsg(` - ${dir}/${fileName}`)
                             );
                         }
                     }
@@ -460,6 +454,18 @@ class MetadataType {
         return;
     }
 
+    /**
+     * Abstract execute method that needs to be implemented in child metadata type
+     *
+     * @returns {void}
+     */
+    static execute() {
+        Util.logger.error(
+            ` ☇ skipping ${this.definition.type}: execute is not supported yet for ${this.definition.type}`
+        );
+        return;
+    }
+
     /**
      * test if metadata was actually changed or not to potentially skip it during deployment
      *
@@ -650,6 +656,7 @@ class MetadataType {
             metadataMap[metadataKey][this.definition.keyField]
         );
         // Update if it already exists; Create it if not
+        const maxKeyLength = this.definition.maxKeyLength || 36;
         if (
             Util.logger.level === 'debug' &&
             metadataMap[metadataKey][this.definition.idField] &&
@@ -703,11 +710,11 @@ class MetadataType {
                     // NOTE: trim twice while getting the newKey value to remove leading spaces before limiting the length
                     const newKey = (metadataMap[metadataKey][Util.OPTIONS.changeKeyField] + '')
                         .trim()
-                        .slice(0, 36)
+                        .slice(0, maxKeyLength)
                         .trim();
-                    if (metadataMap[metadataKey][Util.OPTIONS.changeKeyField] + '' > 36) {
+                    if (metadataMap[metadataKey][Util.OPTIONS.changeKeyField] + '' > maxKeyLength) {
                         Util.logger.warn(
-                            `Customer Keys may not exceed 36 characters. Truncated the value in field ${Util.OPTIONS.changeKeyField} to ${newKey}`
+                            `${this.definition.type} ${this.definition.keyField} may not exceed ${maxKeyLength} characters. Truncated the value in field ${Util.OPTIONS.changeKeyField} to ${newKey}`
                         );
                     }
                     if (metadataKey == newKey) {
@@ -727,10 +734,10 @@ class MetadataType {
                 }
             } else if (Util.OPTIONS.changeKeyValue) {
                 // NOTE: trim twice while getting the newKey value to remove leading spaces before limiting the length
-                const newKey = Util.OPTIONS.changeKeyValue.trim().slice(0, 36).trim();
-                if (Util.OPTIONS.changeKeyValue.trim().length > 36) {
+                const newKey = Util.OPTIONS.changeKeyValue.trim().slice(0, maxKeyLength).trim();
+                if (Util.OPTIONS.changeKeyValue.trim().length > maxKeyLength) {
                     Util.logger.warn(
-                        `Customer Keys may not exceed 36 characters. Truncated your value to ${newKey}`
+                        `${this.definition.type} ${this.definition.keyField} may not exceed ${maxKeyLength} characters. Truncated your value to ${newKey}`
                     );
                 }
                 if (this.definition.keyField == this.definition.idField) {
@@ -1016,12 +1023,7 @@ class MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
                     Util.getKeysString(singleRetrieve)
             );
-            if (
-                this.buObject &&
-                this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)
-            ) {
-                await this.document(savedMetadata);
-            }
+            await this.runDocumentOnRetrieve(singleRetrieve, savedMetadata);
         }
         return { metadata: metadata, type: this.definition.type };
     }
@@ -1063,6 +1065,7 @@ class MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
                     Util.getKeysString(singleRetrieve)
             );
+            await this.runDocumentOnRetrieve(singleRetrieve, savedMetadata);
         }
 
         return {
@@ -1070,6 +1073,54 @@ class MetadataType {
             type: this.definition.type,
         };
     }
+    /**
+     * Used to execute a query/automation etc.
+     *
+     * @param {string} uri REST endpoint where the POST request should be sent
+     * @param {string} key item key
+     * @returns {Promise.<string>} 'OK' if started execution successfully, otherwise - 'Error'
+     */
+    static async executeREST(uri, key) {
+        try {
+            const response = await this.client.rest.post(uri, {}); // payload is empty for this request
+            if (response === 'OK') {
+                Util.logger.info(`Executed ${this.definition.type}: ${key}`);
+            } else {
+                throw new Error(response);
+            }
+            return response;
+        } catch (ex) {
+            Util.logger.error(`Failed to execute ${this.definition.type} ${key}: ${ex.message}`);
+        }
+    }
+
+    /**
+     * helper for {@link retrieveREST} and {@link retrieveSOAP}
+     *
+     * @param {string|number} [singleRetrieve] key of single item to filter by
+     * @param {TYPE.MetadataTypeMap} metadataMap saved metadata
+     * @returns {Promise.<void>} -
+     */
+    static async runDocumentOnRetrieve(singleRetrieve, metadataMap) {
+        if (
+            this.buObject &&
+            this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)
+        ) {
+            if (!singleRetrieve || (singleRetrieve && !this.definition.documentInOneFile)) {
+                const count = Object.keys(metadataMap).length;
+                Util.logger.debug(
+                    ` - Running document for ${count} record${count === 1 ? '' : 's'}`
+                );
+                await this.document(metadataMap);
+            } else {
+                Util.logger.info(
+                    Util.getGrayMsg(
+                        ` - Skipped running document because you supplied keys and ${this.definition.type} is documented in a single file for all.`
+                    )
+                );
+            }
+        }
+    }
 
     /**
      * Builds map of metadata entries mapped to their keyfields
@@ -1528,7 +1579,10 @@ class MetadataType {
                 // so its in retrieve but not in save. Here we put into the clone so that the original
                 // object used for caching doesnt have the Id removed.
                 const saveClone = JSON.parse(JSON.stringify(results[originalKey]));
-                if (!this.definition.keepId) {
+                if (
+                    !this.definition.keepId &&
+                    this.definition.idField !== this.definition.keyField
+                ) {
                     delete saveClone[this.definition.idField];
                 }
 

package/lib/metadataTypes/MobileKeyword.js

@@ -24,14 +24,12 @@ class MobileKeyword extends MetadataType {
      */
     static retrieve(retrieveDir, _, __, key) {
         try {
+            let queryParams;
+            [key, queryParams] = this.#getRetrieveKeyAndUrl(key);
+
             return super.retrieveREST(
                 retrieveDir,
-                '/legacy/v1/beta/mobile/keyword/' +
-                    (key
-                        ? key.startsWith('id:')
-                            ? key.slice(3)
-                            : `?view=simple&$where=keyword%20eq%20%27${key}%27%20`
-                        : '?view=simple'),
+                '/legacy/v1/beta/mobile/keyword/' + queryParams,
                 null,
                 key
             );
@@ -47,6 +45,109 @@ class MobileKeyword extends MetadataType {
         }
     }
 
+    /**
+     * Builds map of metadata entries mapped to their keyfields
+     *
+     * @param {object} body json of response body
+     * @param {string|number} [singleRetrieve] key of single item to filter by
+     * @returns {TYPE.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 parseResponseBody} that creates a custom key field for this type based on mobileCode and keyword
+     *
+     * @private
+     * @param {TYPE.MetadataType} metadata single item
+     */
+    static #createCustomKeyField(metadata) {
+        metadata.c__codeKeyword = metadata.code.code + '.' + metadata.keyword;
+    }
+
+    /**
+     * helper for {@link preDeployTasks} and {@link createOrUpdate} to ensure we have code & keyword properly set
+     *
+     * @private
+     * @param {TYPE.MetadataType} metadata single item
+     */
+    static #setCodeAndKeyword(metadata) {
+        const [code, keyword] = metadata.c__codeKeyword.split('.');
+
+        // mobileCode
+        metadata.code = {
+            id: cache.searchForField('mobileCode', code, 'code', 'id'),
+        };
+
+        // keyword
+        metadata.keyword = keyword;
+    }
+
+    /**
+     * helper for {@link MetadataType.upsert}
+     *
+     * @param {TYPE.MetadataTypeMap} metadataMap list of metadata
+     * @param {string} metadataKey key of item we are looking at
+     * @param {boolean} hasError error flag from previous code
+     * @param {TYPE.MetadataTypeItemDiff[]} metadataToUpdate list of items to update
+     * @param {TYPE.MetadataTypeItem[]} metadataToCreate list of items to create
+     * @returns {'create' | 'update' | 'skip'} action to take
+     */
+    static createOrUpdate(metadataMap, metadataKey, hasError, metadataToUpdate, metadataToCreate) {
+        const createOrUpdateAction = super.createOrUpdate(
+            metadataMap,
+            metadataKey,
+            hasError,
+            metadataToUpdate,
+            metadataToCreate
+        );
+        if (createOrUpdateAction === 'update') {
+            // in case --changeKeyField or --changeKeyValue was used, let's ensure we set code & keyword here again
+            this.#setCodeAndKeyword(metadataMap[metadataKey]);
+        }
+        return createOrUpdateAction;
+    }
+
     /**
      * Retrieves event definition metadata for caching
      *
@@ -60,26 +161,29 @@ class MobileKeyword extends MetadataType {
     }
 
     /**
-     * Retrieve a specific keyword
+     * retrieve an item and create a template from it
      *
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
-     * @param {string} name name of the metadata file
+     * @param {string} key name of the metadata file
      * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<TYPE.MetadataTypeItemObj>} Promise of metadata
      */
-    static async retrieveAsTemplate(templateDir, name, templateVariables) {
+    static async retrieveAsTemplate(templateDir, key, templateVariables) {
         try {
+            let queryParams;
+            [key, queryParams] = this.#getRetrieveKeyAndUrl(key);
+
             return super.retrieveTemplateREST(
                 templateDir,
-                `/legacy/v1/beta/mobile/keyword/?view=simple&$where=keyword%20eq%20%27${name}%27%20`,
+                `/legacy/v1/beta/mobile/keyword/` + queryParams,
                 templateVariables,
-                name
+                key
             );
         } catch (ex) {
             // if the mobileMessage does not exist, the API returns the error "Request failed with status code 400 (ERR_BAD_REQUEST)" which would otherwise bring execution to a hold
-            if (name && ex.code === 'ERR_BAD_REQUEST') {
+            if (key && ex.code === 'ERR_BAD_REQUEST') {
                 Util.logger.info(
-                    `Downloaded: ${this.definition.type} (0)${Util.getKeysString(name)}`
+                    `Downloaded: ${this.definition.type} (0)${Util.getKeysString(key)}`
                 );
             } else {
                 throw ex;
@@ -88,13 +192,43 @@ class MobileKeyword extends MetadataType {
     }
 
     /**
-     * Creates a single Event Definition
+     * helper for {@link retrieve} and {@link retrieveAsTemplate}
+     *
+     * @private
+     * @param {string} key customer key of single item to retrieve / name of the metadata file
+     * @returns {Array} key, queryParams
+     */
+    static #getRetrieveKeyAndUrl(key) {
+        let queryParams;
+        if (key) {
+            if (key.startsWith('id:')) {
+                // overwrite queryParams
+                queryParams = key.slice(3);
+            } else if (key.includes('.')) {
+                // keywords are always uppercased
+                key = key.toUpperCase();
+                // format: code.keyword
+                const [code, keyword] = key.split('.');
+                queryParams = `?view=simple&$where=keyword%20eq%20%27${keyword}%27%20and%code%20eq%20%27${code}%27%20`;
+            } else {
+                throw new Error(
+                    `key ${key} has unexpected format. Expected 'code.keyword' or 'id:yourId'`
+                );
+            }
+        } else {
+            queryParams = '?view=simple';
+        }
+        return [key, queryParams];
+    }
+
+    /**
+     * Creates a single item
      *
-     * @param {TYPE.MetadataTypeItem} MobileKeyword a single Event Definition
+     * @param {TYPE.MetadataTypeItem} metadata a single item
      * @returns {Promise} Promise
      */
-    static create(MobileKeyword) {
-        return super.createREST(MobileKeyword, '/legacy/v1/beta/mobile/keyword/');
+    static create(metadata) {
+        return super.createREST(metadata, '/legacy/v1/beta/mobile/keyword/');
     }
     /**
      * Updates a single item
@@ -114,9 +248,21 @@ class MobileKeyword extends MetadataType {
      * manages post retrieve steps
      *
      * @param {TYPE.MetadataTypeItem} metadata a single item
-     * @returns {TYPE.CodeExtractItem | TYPE.MetadataTypeItem} Array with one metadata object and one ssjs string
+     * @returns {TYPE.CodeExtractItem | TYPE.MetadataTypeItem | void} Array with one metadata object and one ssjs string; or single metadata object; nothing if filtered
      */
     static postRetrieveTasks(metadata) {
+        try {
+            cache.searchForField('mobileCode', metadata.code.code, 'code', 'id');
+        } catch {
+            // in case the the mobileCode cannot be found, do not save this keyword as its no longer accessible in the UI either
+            Util.logger.debug(
+                ` - skipping ${this.definition.type} ${
+                    metadata[this.definition.keyField]
+                }. Could not find parent mobileCode ${metadata.code.code}`
+            );
+            return;
+        }
+
         if (metadata.responseMessage) {
             // extract message body
             const codeArr = [];
@@ -295,8 +441,7 @@ class MobileKeyword extends MetadataType {
             );
         }
 
-        // mobileCode
-        metadata.code.id = cache.searchForField('mobileCode', metadata.code.code, 'code', 'id');
+        this.#setCodeAndKeyword(metadata);
         return metadata;
     }
     /**

package/lib/metadataTypes/MobileMessage.js

@@ -163,21 +163,17 @@ class MobileMessage extends MetadataType {
 
         // mobileKeyword
         try {
-            if (metadata.keyword?.keyword) {
-                cache.searchForField(
-                    'mobileKeyword',
-                    metadata.keyword.keyword,
-                    'keyword',
-                    'keyword'
-                );
-            }
-            if (metadata.subscriptionKeyword?.keyword) {
-                cache.searchForField(
-                    'mobileKeyword',
-                    metadata.subscriptionKeyword.keyword,
-                    'keyword',
-                    'keyword'
-                );
+            for (const attr of ['keyword', 'subscriptionKeyword', 'nextKeyword']) {
+                if (metadata[attr]?.id) {
+                    metadata[attr] = {
+                        c__codeKeyword: cache.searchForField(
+                            'mobileKeyword',
+                            metadata[attr].id,
+                            'id',
+                            'c__codeKeyword'
+                        ),
+                    };
+                }
             }
         } catch (ex) {
             Util.logger.warn(
@@ -265,20 +261,16 @@ class MobileMessage extends MetadataType {
         metadata.code = code;
 
         // mobileKeyword
-        if (metadata.keyword?.keyword) {
-            const keyword = cache.getByKey('mobileKeyword', metadata.keyword.keyword);
-            if (!keyword) {
-                throw new Error(`mobileKeyword ${metadata.keyword.keyword} not found in cache`);
-            }
-            metadata.keyword = keyword;
-        }
-        if (metadata.subscriptionKeyword?.keyword) {
-            const keyword = cache.getByKey('mobileKeyword', metadata.subscriptionKeyword.keyword);
-            if (!keyword) {
-                throw new Error(`mobileKeyword ${metadata.keyword.keyword} not found in cache`);
+        for (const attr of ['keyword', 'subscriptionKeyword', 'nextKeyword']) {
+            if (metadata[attr]?.c__codeKeyword) {
+                const keywordObj = cache.getByKey('mobileKeyword', metadata[attr].c__codeKeyword);
+                if (!keywordObj) {
+                    throw new Error(
+                        `mobileKeyword ${metadata[attr].c__codeKeyword} not found in cache`
+                    );
+                }
+                metadata[attr] = keywordObj;
             }
-
-            metadata.subscriptionKeyword.keyword = keyword;
         }
 
         // campaign

package/lib/metadataTypes/Query.js

@@ -50,6 +50,32 @@ class Query extends MetadataType {
             key
         );
     }
+    /**
+     * a function to start query execution via API
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {Promise.<boolean>} Returns true if all items were executed successfully, otherwise false
+     */
+    static async execute(keyArr) {
+        const results = [];
+        // works only with objectId
+        let objectId;
+        for (const key of keyArr) {
+            if (key) {
+                objectId = await this._getObjectIdForSingleRetrieve(key);
+                if (!objectId) {
+                    Util.logger.info(`Skipping ${key} - did not find an item with such key`);
+                    break;
+                }
+            }
+            results.push(
+                super.executeREST(`/automation/v1/queries/${objectId}/actions/start/`, key)
+            );
+        }
+        const successCounter = (await Promise.all(results)).filter((r) => r === 'OK').length;
+        Util.logger.info(`Executed ${successCounter} of ${keyArr.length} items`);
+        return successCounter === keyArr.length;
+    }
     /**
      * helper to allow us to select single metadata entries via REST
      *

package/lib/metadataTypes/Role.js

@@ -102,9 +102,8 @@ class Role extends MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
                     Util.getKeysString(key)
             );
-            if (this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)) {
-                await this.document(savedMetadata);
-            }
+
+            await this.runDocumentOnRetrieve(key, savedMetadata);
         }
         return { metadata: parsed, type: this.definition.type };
     }

package/lib/metadataTypes/TransactionalSMS.js

@@ -58,9 +58,9 @@ class TransactionalSMS extends TransactionalMessage {
             // we merely want to be able to show an error if it does not exist
             cache.searchForField(
                 'mobileKeyword',
-                metadata.subscriptions.keyword,
-                'keyword',
-                'keyword'
+                metadata.subscriptions.shortCode + '.' + metadata.subscriptions.keyword,
+                'c__codeKeyword',
+                'id'
             );
         }
         return metadata;
@@ -142,9 +142,9 @@ class TransactionalSMS extends TransactionalMessage {
                 // we merely want to be able to show a warning if it does not exist
                 cache.searchForField(
                     'mobileKeyword',
-                    metadata.subscriptions.keyword,
+                    metadata.subscriptions.shortCode + '.' + metadata.subscriptions.keyword,
                     'keyword',
-                    'keyword'
+                    'id'
                 );
             } catch {
                 Util.logger.warn(