mcdev 6.0.2 → 7.0.0

package/lib/metadataTypes/Script.js

@@ -1,9 +1,28 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
 import File from '../util/file.js';
+import ReplaceCbReference from '../util/replaceContentBlockReference.js';
+
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ * @typedef {import('../../types/mcdev.d.js').ContentBlockConversionTypes} ContentBlockConversionTypes
+ */
+
+/**
+ * @typedef {import('../../types/mcdev.d.js').ScriptItem} ScriptItem
+ * @typedef {import('../../types/mcdev.d.js').ScriptMap} ScriptMap
+ */
 
 /**
  * Script MetadataType
@@ -15,11 +34,11 @@ class Script extends MetadataType {
      * Retrieves Metadata of Script
      * Endpoint /automation/v1/scripts/ return all Scripts with all details.
      *
-     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {string} [retrieveDir] Directory where retrieved metadata directory will be saved
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<{metadata: TYPE.ScriptMap, type: string}>} Promise
+     * @returns {Promise.<{metadata: ScriptMap, type: string}>} Promise
      */
     static async retrieve(retrieveDir, _, __, key) {
         await File.initPrettier('ssjs');
@@ -28,7 +47,7 @@ class Script extends MetadataType {
     /**
      * Retrieves script metadata for caching
      *
-     * @returns {Promise.<{metadata: TYPE.ScriptMap, type: string}>} Promise
+     * @returns {Promise.<{metadata: ScriptMap, type: string}>} Promise
      */
     static async retrieveForCache() {
         return super.retrieveREST(null, '/automation/v1/scripts/');
@@ -39,8 +58,8 @@ class Script extends MetadataType {
      *
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
-     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
-     * @returns {Promise.<{metadata: TYPE.Script, type: string}>} Promise
+     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<{metadata: ScriptItem, type: string}>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
         await File.initPrettier('ssjs');
@@ -51,20 +70,10 @@ class Script extends MetadataType {
         );
     }
 
-    /**
-     * manages post retrieve steps
-     *
-     * @param {TYPE.ScriptItem} metadata a single script
-     * @returns {TYPE.CodeExtractItem} Array with one metadata object and one ssjs string
-     */
-    static postRetrieveTasks(metadata) {
-        return this.parseMetadata(metadata);
-    }
-
     /**
      * Updates a single Script
      *
-     * @param {TYPE.MetadataTypeItem} script a single Script
+     * @param {MetadataTypeItem} script a single Script
      * @returns {Promise} Promise
      */
     static update(script) {
@@ -74,7 +83,7 @@ class Script extends MetadataType {
     /**
      * Creates a single Script
      *
-     * @param {TYPE.MetadataTypeItem} script a single Script
+     * @param {MetadataTypeItem} script a single Script
      * @returns {Promise} Promise
      */
     static create(script) {
@@ -84,7 +93,7 @@ class Script extends MetadataType {
     /**
      * helper for {@link Script.preDeployTasks} that loads extracted code content back into JSON
      *
-     * @param {TYPE.ScriptItem} metadata a single asset definition
+     * @param {ScriptItem} metadata a single asset definition
      * @param {string} deployDir directory of deploy files
      * @param {string} [templateName] name of the template used to built defintion (prior applying templating)
      * @returns {Promise.<string>} content for metadata.script
@@ -104,7 +113,7 @@ class Script extends MetadataType {
                 templateName + '.' + this.definition.type + '-meta',
                 'ssjs'
             );
-            code = `<script runat="server">\n${code}</script>`;
+            code = `<script runat="server">\n${code.trim()}\n</script>`;
         } else if (await File.pathExists(codePath + '.html')) {
             code = await File.readFilteredFilename(
                 [deployDir, this.definition.type],
@@ -119,9 +128,9 @@ class Script extends MetadataType {
     /**
      * prepares a Script for deployment
      *
-     * @param {TYPE.ScriptItem} metadata a single script activity definition
+     * @param {ScriptItem} metadata a single script activity definition
      * @param {string} dir directory of deploy files
-     * @returns {TYPE.ScriptItem} Promise
+     * @returns {Promise.<ScriptItem>} Promise
      */
     static async preDeployTasks(metadata, dir) {
         // folder
@@ -138,8 +147,8 @@ class Script extends MetadataType {
      *
      * @param {string} templateDir Directory where metadata templates are stored
      * @param {string|string[]} targetDir (List of) Directory where built definitions will be saved
-     * @param {TYPE.ScriptItem} metadata main JSON file that was read from file system
-     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @param {ScriptItem} metadata main JSON file that was read from file system
+     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @param {string} templateName name of the template to be built
      * @returns {Promise.<string[][]>} list of extracted files with path-parts provided as an array
      */
@@ -166,8 +175,8 @@ class Script extends MetadataType {
      * @example scripts are saved as 1 json and 1 ssjs file. both files need to be run through templating
      * @param {string} templateDir Directory where metadata templates are stored
      * @param {string|string[]} targetDir (List of) Directory where built definitions will be saved
-     * @param {TYPE.ScriptItem} metadata main JSON file that was read from file system
-     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @param {ScriptItem} metadata main JSON file that was read from file system
+     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @param {string} templateName name of the template to be built
      * @returns {Promise.<string[][]>} list of extracted files with path-parts provided as an array
      */
@@ -194,8 +203,8 @@ class Script extends MetadataType {
      *
      * @param {string} templateDir Directory where metadata templates are stored
      * @param {string|string[]} targetDir (List of) Directory where built definitions will be saved
-     * @param {TYPE.ScriptItem} metadata main JSON file that was read from file system
-     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @param {ScriptItem} metadata main JSON file that was read from file system
+     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @param {string} templateName name of the template to be built
      * @param {'definition'|'template'} mode defines what we use this helper for
      * @returns {Promise.<string[][]>} list of extracted files with path-parts provided as an array
@@ -211,7 +220,7 @@ class Script extends MetadataType {
         // get SSJS from filesystem
         let code = await this._mergeCode(metadata, templateDir, templateName);
         // try to remove script tags and decide on file extension (html/ssjs)
-        const file = Script.prepExtractedCode(code, metadata.name);
+        const file = this.prepExtractedCode(code, metadata.name);
         const fileExt = file.fileExt;
         code = fileExt === 'ssjs' ? file.code.replace(/^\n/, '') : file.code;
         // apply templating
@@ -255,19 +264,28 @@ class Script extends MetadataType {
     }
 
     /**
-     * Splits the script metadata into two parts and parses in a standard manner
+     * manages post retrieve steps
      *
-     * @param {TYPE.ScriptItem} metadata a single script activity definition
-     * @returns {TYPE.CodeExtractItem} a single item with code parts extracted
+     * @param {ScriptItem} metadata a single item
+     * @returns {CodeExtractItem} a single item with code parts extracted
      */
-    static parseMetadata(metadata) {
+    static postRetrieveTasks(metadata) {
         // folder
         super.setFolderPath(metadata);
 
+        return this.getCodeExtractItem(metadata);
+    }
+    /**
+     * manages post retrieve steps
+     *
+     * @param {ScriptItem} metadata a single item
+     * @returns {CodeExtractItem} a single item with code parts extracted
+     */
+    static getCodeExtractItem(metadata) {
         // extract SSJS
         const codeArr = [];
         // keep between tags
-        const { fileExt, code } = Script.prepExtractedCode(metadata.script, metadata.name);
+        const { fileExt, code } = this.prepExtractedCode(metadata.script, metadata.name);
         delete metadata.script;
         codeArr.push({
             subFolder: null,
@@ -278,8 +296,9 @@ class Script extends MetadataType {
 
         return { json: metadata, codeArr: codeArr, subFolder: null };
     }
+
     /**
-     * helper for {@link Script.parseMetadata} and {@link Script._buildForNested}
+     * helper for {@link Script.postRetrieveTasks} and {@link Script._buildForNested}
      *
      * @param {string} metadataScript the code of the file
      * @param {string} metadataName the name of the metadata
@@ -307,9 +326,9 @@ class Script extends MetadataType {
      * additionally, the documentation for dataExtension and automation should be returned
      *
      * @param {string[]} keyArr customerkey of the metadata
-     * @returns {string[]} list of all files that need to be committed in a flat array ['path/file1.ext', 'path/file2.ext']
+     * @returns {Promise.<string[]>} list of all files that need to be committed in a flat array ['path/file1.ext', 'path/file2.ext']
      */
-    static getFilesToCommit(keyArr) {
+    static async getFilesToCommit(keyArr) {
         const path = File.normalizePath([
             this.properties.directories.retrieve,
             this.buObject.credential,
@@ -324,6 +343,75 @@ class Script extends MetadataType {
         ]);
         return fileList;
     }
+    /**
+     * helper to allow us to select single metadata entries via REST
+     *
+     * @private
+     * @param {string} key customer key
+     * @returns {Promise.<string>} objectId or enpty string
+     */
+    static async _getObjectIdForSingleRetrieve(key) {
+        const name = key.startsWith('name:') ? key.slice(5) : null;
+        const filter = name
+            ? '?$filter=name%20eq%20' + encodeURIComponent(name)
+            : '?$filter=key%20eq%20' + encodeURIComponent(key);
+        const results = await this.client.rest.get('/automation/v1/scripts/' + filter);
+        const items = results?.items || [];
+        const found = items.find((item) =>
+            name ? item[this.definition.nameField] === name : item[this.definition.keyField] === key
+        );
+        return found?.ssjsActivityId || null;
+    }
+
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {string} customerKey Identifier of data extension
+     * @returns {Promise.<boolean>} deletion success flag
+     */
+    static async deleteByKey(customerKey) {
+        // delete only works with the query's object id
+        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
+        if (!objectId) {
+            Util.logger.error(` - ${this.definition.type} not found`);
+            return false;
+        }
+        return super.deleteByKeyREST('/automation/v1/scripts/' + objectId, customerKey);
+    }
+    /**
+     * clean up after deleting a metadata item
+     *
+     * @param {string} customerKey Identifier of metadata item
+     * @returns {Promise.<void>} -
+     */
+    static async postDeleteTasks(customerKey) {
+        // delete local copy: retrieve/cred/bu/.../...-meta.json
+        // delete local copy: retrieve/cred/bu/.../...-meta.ssjs
+        // delete local copy: retrieve/cred/bu/.../...-meta.html
+        await super.postDeleteTasks(customerKey, [
+            `${this.definition.type}-meta.ssjs`,
+            `${this.definition.type}-meta.html`,
+        ]);
+    }
+
+    /**
+     *
+     * @param {MetadataTypeItem} item single metadata item
+     * @param {string} retrieveDir directory where metadata is saved
+     * @returns {Promise.<CodeExtractItem>} key of the item that was updated
+     */
+    static async replaceCbReference(item, retrieveDir) {
+        const parentName = `${this.definition.type} ${item[this.definition.keyField]}`;
+
+        const code = await this._mergeCode(item, retrieveDir);
+
+        item.script = ReplaceCbReference.replaceReference(code, parentName);
+
+        // *** finish ***
+        // replaceReference will throw an error if nothing was updated which will end execution here
+        // no error means we have a new item to deploy and need to update the item in our retrieve folder
+        return this.getCodeExtractItem(item);
+    }
 }
 
 // Assign definition & cache to static attributes

package/lib/metadataTypes/SendClassification.js

@@ -1,7 +1,21 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
+import { Util } from '../util/util.js';
+import cache from '../util/cache.js';
+
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ */
 
 /**
  * SendClassification MetadataType
@@ -13,13 +27,13 @@ class SendClassification extends MetadataType {
      * Retrieves SOAP based metadata of metadata type into local filesystem. executes callback with retrieved metadata
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static retrieve(retrieveDir, _, __, key) {
-        /** @type {TYPE.SoapRequestParams} */
+        /** @type {SoapRequestParams} */
         let requestParams = null;
         if (key) {
             requestParams = {
@@ -32,6 +46,107 @@ class SendClassification extends MetadataType {
         }
         return super.retrieveSOAP(retrieveDir, requestParams, key);
     }
+    /**
+     * Updates a single item
+     *
+     * @param {MetadataTypeItem} metadataItem a single item
+     * @returns {Promise} Promise
+     */
+    static update(metadataItem) {
+        return super.updateSOAP(metadataItem);
+    }
+
+    /**
+     * Creates a single item
+     *
+     * @param {MetadataTypeItem} metadataItem a single item
+     * @returns {Promise} Promise
+     */
+    static create(metadataItem) {
+        return super.createSOAP(metadataItem);
+    }
+
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {string} customerKey Identifier of data extension
+     * @returns {Promise.<boolean>} deletion success status
+     */
+    static deleteByKey(customerKey) {
+        return super.deleteByKeySOAP(customerKey);
+    }
+    /**
+     * prepares a import definition for deployment
+     *
+     * @param {MetadataTypeItem} metadata a single importDef
+     * @returns {Promise.<MetadataTypeItem>} Promise
+     */
+    static async preDeployTasks(metadata) {
+        metadata.SendClassificationType =
+            this.definition.sendClassificationTypeMapping[metadata.c__classification];
+        delete metadata.c__classification;
+
+        metadata.SenderProfile = {
+            CustomerKey: cache.searchForField(
+                'senderProfile',
+                metadata.r__senderProfile_key,
+                'CustomerKey',
+                'CustomerKey'
+            ),
+        };
+        delete metadata.r__senderProfile_key;
+
+        metadata.DeliveryProfile = {
+            CustomerKey: cache.searchForField(
+                'deliveryProfile',
+                metadata.r__deliveryProfile_key,
+                'key',
+                'key'
+            ),
+        };
+        delete metadata.r__deliveryProfile_key;
+
+        return metadata;
+    }
+
+    /**
+     * manages post retrieve steps
+     *
+     * @param {MetadataTypeItem} metadata a single item
+     * @returns {MetadataTypeItem} parsed metadata
+     */
+    static postRetrieveTasks(metadata) {
+        metadata.c__classification = Util.inverseGet(
+            this.definition.sendClassificationTypeMapping,
+            metadata.SendClassificationType
+        );
+        delete metadata.SendClassificationType;
+
+        try {
+            metadata.r__senderProfile_key = cache.searchForField(
+                'senderProfile',
+                metadata.SenderProfile.CustomerKey,
+                'CustomerKey',
+                'CustomerKey'
+            );
+            delete metadata.SenderProfile;
+        } catch (ex) {
+            Util.logger.warn(` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`);
+        }
+        try {
+            metadata.r__deliveryProfile_key = cache.searchForField(
+                'deliveryProfile',
+                metadata.DeliveryProfile.CustomerKey,
+                'key',
+                'key'
+            );
+            delete metadata.DeliveryProfile;
+        } catch (ex) {
+            Util.logger.warn(` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`);
+        }
+
+        return metadata;
+    }
 }
 
 // Assign definition to static attributes

package/lib/metadataTypes/SenderProfile.js

@@ -0,0 +1,179 @@
+'use strict';
+
+import MetadataType from './MetadataType.js';
+import { Util } from '../util/util.js';
+import ReplaceCbReference from '../util/replaceContentBlockReference.js';
+
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ */
+
+/**
+ * SenderProfile MetadataType
+ *
+ * @augments MetadataType
+ */
+class SenderProfile extends MetadataType {
+    /**
+     * Retrieves SOAP based metadata of metadata type into local filesystem. executes callback with retrieved metadata
+     *
+     * @param {string} [retrieveDir] Directory where retrieved metadata directory will be saved
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
+     */
+    static async retrieve(retrieveDir, _, __, key) {
+        /** @type {SoapRequestParams} */
+        let requestParams;
+        if (key) {
+            requestParams = {
+                filter: {
+                    leftOperand: 'CustomerKey',
+                    operator: 'equals',
+                    rightOperand: key,
+                },
+            };
+        }
+        return super.retrieveSOAP(retrieveDir, requestParams, key);
+    }
+    /**
+     * Updates a single item
+     *
+     * @param {MetadataTypeItem} metadataItem a single item
+     * @returns {Promise} Promise
+     */
+    static update(metadataItem) {
+        return super.updateSOAP(metadataItem);
+    }
+
+    /**
+     * Creates a single item
+     *
+     * @param {MetadataTypeItem} metadataItem a single item
+     * @returns {Promise} Promise
+     */
+    static create(metadataItem) {
+        return super.createSOAP(metadataItem);
+    }
+
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {string} customerKey Identifier of data extension
+     * @returns {Promise.<boolean>} deletion success status
+     */
+    static deleteByKey(customerKey) {
+        return super.deleteByKeySOAP(customerKey);
+    }
+
+    /**
+     * prepares a single item for deployment
+     *
+     * @param {MetadataTypeItem} metadata a single query activity
+     * @returns {Promise.<MetadataTypeItem>} Promise
+     */
+    static async preDeployTasks(metadata) {
+        if (
+            metadata.UseDefaultRMMRules &&
+            (metadata.AutoForwardToEmailAddress !== '' || metadata.AutoForwardToName !== '')
+        ) {
+            Util.logger.warn(
+                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                    metadata[this.definition.keyField]
+                }): AutoForwardToEmailAddress and AutoForwardToName will be ignored because UseDefaultRMMRules is set to true; setting UseDefaultRMMRules to false`
+            );
+            metadata.UseDefaultRMMRules = false;
+        } else if (
+            !metadata.UseDefaultRMMRules &&
+            (metadata.AutoForwardToEmailAddress === '' || metadata.AutoForwardToName === '')
+        ) {
+            Util.logger.warn(
+                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                    metadata[this.definition.keyField]
+                }): AutoForwardToEmailAddress and AutoForwardToName are required when UseDefaultRMMRules is set to false; setting UseDefaultRMMRules to true`
+            );
+            metadata.UseDefaultRMMRules = true;
+        }
+        return metadata;
+    }
+    /**
+     *
+     * @param {MetadataTypeItem} item single metadata item
+     * @returns {Promise.<MetadataTypeItem>} key of the item that was updated
+     */
+    static async replaceCbReference(item) {
+        const parentName = `${this.definition.type} ${item[this.definition.keyField]}`;
+        let changes = false;
+        let error;
+
+        // *** type specific logic ***
+        try {
+            item.FromName = ReplaceCbReference.replaceReference(item.FromName, parentName);
+            changes = true;
+        } catch (ex) {
+            if (ex.code !== 200) {
+                error = ex;
+            }
+        }
+        try {
+            item.FromAddress = ReplaceCbReference.replaceReference(item.FromAddress, parentName);
+            changes = true;
+        } catch (ex) {
+            if (ex.code !== 200) {
+                error = ex;
+            }
+        }
+        try {
+            item.AutoForwardToEmailAddress = ReplaceCbReference.replaceReference(
+                item.AutoForwardToEmailAddress,
+                parentName
+            );
+            changes = true;
+        } catch (ex) {
+            if (ex.code !== 200) {
+                error = ex;
+            }
+        }
+        try {
+            item.AutoForwardToName = ReplaceCbReference.replaceReference(
+                item.AutoForwardToName,
+                parentName
+            );
+            changes = true;
+        } catch (ex) {
+            if (ex.code !== 200) {
+                error = ex;
+            }
+        }
+        if (error) {
+            throw error;
+        }
+
+        if (!changes) {
+            const ex = new Error('No changes made to the code.');
+            ex.code = 200;
+            throw ex;
+        }
+
+        // *** finish ***
+        // replaceReference will throw an error if nothing was updated which will end execution here
+        // no error means we have a new item to deploy and need to update the item in our retrieve folder
+        return item;
+    }
+}
+
+// Assign definition & cache to static attributes
+import MetadataTypeDefinitions from '../MetadataTypeDefinitions.js';
+SenderProfile.definition = MetadataTypeDefinitions.senderProfile;
+
+export default SenderProfile;