mcdev 3.1.1 → 4.0.0

package/lib/metadataTypes/Discovery.js

@@ -1,41 +1,47 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
 
 /**
  * ImportFile MetadataType
+ *
  * @augments MetadataType
  */
 class Discovery extends MetadataType {
     /**
      * Retrieves API endpoint
      * documentation: https://developer.salesforce.com/docs/atlas.en-us.noversion.mc-apis.meta/mc-apis/routes.htm
-     * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {String[]} [_] not used
-     * @param {Object} buObject properties for auth
-     * @returns {Promise} Promise
+     *
+     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
+     * @param {void} [_] not used
+     * @param {TYPE.BuObject} buObject properties for auth
+     * @param {void} [___] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
-    static async retrieve(retrieveDir, _, buObject) {
+    static async retrieve(retrieveDir, _, buObject, ___, key) {
+        if (key) {
+            Util.logger.error('Discovery.retrieve() does not support key parameter');
+        }
         if (buObject.eid !== buObject.mid) {
             // don't run for BUs other than Parent BU
-            Util.logger.warn('Skipping Discovery retrieval on non-parent BU');
+            Util.logger.warn(' - Skipping Discovery retrieval on non-parent BU');
             return;
         } else {
-            const res = await Promise.all(
-                Object.keys(this.definition.endPointMapping).map((endpoint) =>
-                    this.client.RestClient.get({
-                        uri: this.definition.endPointMapping[endpoint],
-                        headers: {},
-                    })
+            const res = await this.client.rest.getCollection(
+                Object.keys(this.definition.endPointMapping).map(
+                    (endpoint) => this.definition.endPointMapping[endpoint]
                 )
             );
+
             const metadataStructure = {};
             for (const [i, v] of res.entries()) {
-                v.body.key = Object.keys(this.definition.endPointMapping)[i];
-                metadataStructure[v.body.key] = v.body;
+                v.key = Object.keys(this.definition.endPointMapping)[i];
+                metadataStructure[v.key] = v;
             }
-            await this.saveResults(metadataStructure, retrieveDir, null);
+            await super.saveResults(metadataStructure, retrieveDir, null);
             Util.logger.info('Downloaded: ' + this.definition.type);
             return { metadata: metadataStructure, type: this.definition.type };
         }
@@ -44,6 +50,5 @@ class Discovery extends MetadataType {
 
 // Assign definition to static attributes
 Discovery.definition = require('../MetadataTypeDefinitions').discovery;
-Discovery.client = undefined;
 
 module.exports = Discovery;

package/lib/metadataTypes/Email.js

@@ -1,43 +1,63 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
+const cache = require('../util/cache');
 
 /**
  * Email MetadataType
+ *
  * @augments MetadataType
  */
 class Email 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
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @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) {
+    static retrieve(retrieveDir, _, __, ___, key) {
         Util.logger.warn(
-            'Classic E-Mails are deprecated and will be discontinued by SFMC in the near future. Ensure that you migrate any existing E-Mails to Content Builder as soon as possible.'
+            ' - Classic E-Mails are deprecated and will be discontinued by SFMC in the near future. Ensure that you migrate any existing E-Mails to Content Builder as soon as possible.'
         );
+        /** @type {TYPE.SoapRequestParams} */
+        let requestParams = null;
+        if (key) {
+            requestParams = {
+                filter: {
+                    leftOperand: 'CustomerKey',
+                    operator: 'equals',
+                    rightOperand: key,
+                },
+            };
+        }
         // !dont activate `await File.initPrettier('html');` as we only want to retrieve for migration and formatting might mess with the outcome
-        return super.retrieveSOAPgeneric(retrieveDir, null);
+        return super.retrieveSOAP(retrieveDir, null, requestParams);
     }
     /**
      * manages post retrieve steps
-     * @param {Object} metadata a single query
-     * @returns {Object[]} Array with one metadata object and one query string
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single query
+     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one query string
      */
     static postRetrieveTasks(metadata) {
         return this.parseMetadata(metadata);
     }
     /**
      * parses retrieved Metadata before saving
-     * @param {Object} metadata a single query activity definition
-     * @returns {Array} Array with one metadata object and one sql string
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single query activity definition
+     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one sql string
      */
     static parseMetadata(metadata) {
         // folder
         try {
-            metadata.r__folder_Path = Util.getFromCache(
-                this.cache,
+            metadata.r__folder_Path = cache.searchForField(
                 'folder',
                 metadata.CategoryID,
                 'ID',
@@ -46,7 +66,7 @@ class Email extends MetadataType {
             delete metadata.CategoryID;
         } catch (ex) {
             Util.logger.warn(
-                `Classic E-Mail '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
+                ` - Classic E-Mail '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
             );
         }
 

package/lib/metadataTypes/EmailSendDefinition.js

@@ -1,22 +1,29 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
+const cache = require('../util/cache');
 
 /**
  * MessageSendActivity MetadataType
+ *
  * @augments MetadataType
  */
 class EmailSendDefinition 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} _ -
-     * @param {Object} buObject properties for auth
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @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, _, buObject) {
-        const options = {
+    static retrieve(retrieveDir, _, __, ___, key) {
+        /** @type {TYPE.SoapRequestParams} */
+        let requestParams = {
             filter: {
                 leftOperand: {
                     // somehow that parameter controls visible (non deleted?) email send activities
@@ -32,12 +39,27 @@ class EmailSendDefinition extends MetadataType {
                 },
             },
         };
-        return super.retrieveSOAPgeneric(retrieveDir, buObject, options);
+        if (key) {
+            // move original filter down one level into rightOperand and add key filter into leftOperand
+            requestParams = {
+                filter: {
+                    leftOperand: {
+                        leftOperand: 'CustomerKey',
+                        operator: 'equals',
+                        rightOperand: key,
+                    },
+                    operator: 'AND',
+                    rightOperand: requestParams.filter,
+                },
+            };
+        }
+        return super.retrieveSOAP(retrieveDir, null, requestParams);
     }
 
     /**
      * Updates a single item
-     * @param {Object} metadataItem a single item
+     *
+     * @param {TYPE.MetadataTypeItem} metadataItem a single item
      * @returns {Promise} Promise
      */
     static update(metadataItem) {
@@ -46,62 +68,54 @@ class EmailSendDefinition extends MetadataType {
 
     /**
      * Creates a single item
-     * @param {Object} metadataItem a single item
+     *
+     * @param {TYPE.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 {TYPE.BuObject} buObject references credentials
+     * @param {string} customerKey Identifier of data extension
+     * @returns {Promise.<boolean>} deletion success status
+     */
+    static deleteByKey(buObject, customerKey) {
+        return super.deleteByKeySOAP(buObject, customerKey, false);
+    }
+
     /**
      * prepares a single item for deployment
-     * @param {Object} metadata a single script activity definition
-     * @returns {Promise} Promise
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
+     * @returns {Promise.<TYPE.MetadataTypeItem>} Promise
      */
     static async preDeployTasks(metadata) {
         // re-add IsPlatformObject, required for visibility
         metadata.IsPlatformObject = false;
         // folder
-        try {
-            metadata.CategoryID = Util.getFromCache(
-                this.cache,
-                'folder',
-                metadata.r__folder_Path,
-                'Path',
-                'ID'
-            );
-            delete metadata.r__folder_Path;
-        } catch (ex) {
-            Util.logger.error(`${this.definition.typeName} '${metadata.key}': ${ex.message}`);
-        }
+        metadata.CategoryID = cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID');
+        delete metadata.r__folder_Path;
         // email
-        try {
-            metadata.Email = {};
-            if (metadata.r__email_Name) {
-                // classic
-                metadata.Email.ID = Util.getFromCache(
-                    this.cache,
-                    'email',
-                    metadata.r__email_Name,
-                    'Name',
-                    'ID'
-                );
-                delete metadata.r__email_Name;
-            } else if (metadata.r__assetMessage_Key) {
-                // content builder
-                // * this ignores r__assetMessage_Name on purpose as that is only unique per parent folder but useful during PR reviews
-                metadata.Email.ID = Util.getFromCache(
-                    this.cache,
-                    'asset',
-                    metadata.r__assetMessage_Key,
-                    'customerKey',
-                    'legacyData.legacyId'
-                );
-                delete metadata.r__assetMessage_Key;
-                delete metadata.r__assetMessage_Name;
-            }
-        } catch (ex) {
-            Util.logger.error(`${this.definition.typeName} '${metadata.key}': ${ex.message}`);
+        metadata.Email = {};
+        if (metadata.r__email_Name) {
+            // classic
+            metadata.Email.ID = cache.searchForField('email', metadata.r__email_Name, 'Name', 'ID');
+            delete metadata.r__email_Name;
+        } else if (metadata.r__assetMessage_Key) {
+            // content builder
+            // * this ignores r__assetMessage_Name on purpose as that is only unique per parent folder but useful during PR reviews
+            metadata.Email.ID = cache.searchForField(
+                'asset',
+                metadata.r__assetMessage_Key,
+                'customerKey',
+                'legacyData.legacyId'
+            );
+            delete metadata.r__assetMessage_Key;
+            delete metadata.r__assetMessage_Name;
         }
         // Target Audience DataExtension
         // normalize first because this can be an array
@@ -121,8 +135,7 @@ class EmailSendDefinition extends MetadataType {
                         `Skipping ${metadata.Name} (${metadata.CustomerKey}): Expecting DataSourceTypeID to equal 'CustomObject' when r__dataExtension_Key is defined; Found '${sdl.DataSourceTypeID}'`
                     );
                 }
-                sdl.CustomObjectID = Util.getFromCache(
-                    this.cache,
+                sdl.CustomObjectID = cache.searchForField(
                     'dataExtension',
                     sdl.r__dataExtension_Key,
                     'CustomerKey',
@@ -137,7 +150,7 @@ class EmailSendDefinition extends MetadataType {
             // get List (required)
             if (sdl.r__list_PathName) {
                 sdl.List = {
-                    ID: Util.getListObjectIdFromCache(this.cache, sdl.r__list_PathName, 'ID'),
+                    ID: cache.getListObjectId(sdl.r__list_PathName, 'ID'),
                 };
                 delete sdl.r__list_PathName;
             } else {
@@ -152,24 +165,25 @@ class EmailSendDefinition extends MetadataType {
 
     /**
      * manages post retrieve steps
-     * @param {Object} metadata a single query
-     * @returns {Object[]} Array with one metadata object and one query string
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single query
+     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one query string
      */
     static postRetrieveTasks(metadata) {
         return this.parseMetadata(metadata);
     }
     /**
      * parses retrieved Metadata before saving
-     * @param {Object} metadata a single query activity definition
-     * @returns {Array} Array with one metadata object and one sql string
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single query activity definition
+     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one sql string
      */
     static parseMetadata(metadata) {
         // remove IsPlatformObject, always has to be 'false'
         delete metadata.IsPlatformObject;
         // folder
         try {
-            metadata.r__folder_Path = Util.getFromCache(
-                this.cache,
+            metadata.r__folder_Path = cache.searchForField(
                 'folder',
                 metadata.CategoryID,
                 'ID',
@@ -178,34 +192,26 @@ class EmailSendDefinition extends MetadataType {
             delete metadata.CategoryID;
         } catch (ex) {
             Util.logger.warn(
-                `${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
+                ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
             );
         }
         // email
         try {
             // classic
-            const classicEmail = Util.getFromCache(
-                this.cache,
-                'email',
-                metadata.Email.ID,
-                'ID',
-                'Name'
-            );
+            const classicEmail = cache.searchForField('email', metadata.Email.ID, 'ID', 'Name');
             metadata.r__email_Name = classicEmail;
             delete metadata.Email;
-        } catch (ex) {
+        } catch {
             try {
                 // content builder
-                const contentBuilderEmailName = Util.getFromCache(
-                    this.cache,
+                const contentBuilderEmailName = cache.searchForField(
                     'asset',
                     metadata.Email.ID,
                     'legacyData.legacyId',
                     'name'
                 );
                 metadata.r__assetMessage_Name = contentBuilderEmailName;
-                const contentBuilderEmailKey = Util.getFromCache(
-                    this.cache,
+                const contentBuilderEmailKey = cache.searchForField(
                     'asset',
                     metadata.Email.ID,
                     'legacyData.legacyId',
@@ -213,9 +219,9 @@ class EmailSendDefinition extends MetadataType {
                 );
                 metadata.r__assetMessage_Key = contentBuilderEmailKey;
                 delete metadata.Email;
-            } catch (ex) {
+            } catch {
                 Util.logger.warn(
-                    `${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find email with ID ${metadata.Email.ID} in Classic nor in Content Builder.`
+                    ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find email with ID ${metadata.Email.ID} in Classic nor in Content Builder.`
                 );
             }
         }
@@ -231,27 +237,26 @@ class EmailSendDefinition extends MetadataType {
             // get DataExtension keys
             if (sdl.CustomObjectID) {
                 try {
-                    sdl.r__dataExtension_Key = Util.getFromCache(
-                        this.cache,
+                    sdl.r__dataExtension_Key = cache.searchForField(
                         'dataExtension',
                         sdl.CustomObjectID,
                         'ObjectID',
                         'CustomerKey'
                     );
                     delete sdl.CustomObjectID;
-                } catch (ex) {
+                } catch {
                     Util.logger.warn(
-                        `${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find Target Audience (DataExtension) with ObjectID ${sdl.CustomObjectID}.`
+                        ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': Could not find Target Audience (DataExtension) with ObjectID ${sdl.CustomObjectID}.`
                     );
                 }
             }
             // List
             try {
-                sdl.r__list_PathName = Util.getListPathNameFromCache(this.cache, sdl.List.ID, 'ID');
+                sdl.r__list_PathName = cache.getListPathName(sdl.List.ID, 'ID');
                 delete sdl.List;
             } catch (ex) {
                 Util.logger.warn(
-                    `${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
+                    ` - ${this.definition.typeName} '${metadata.Name}'/'${metadata.CustomerKey}': ${ex.message}`
                 );
             }
         }