mcdev 3.1.3 → 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}`
                 );
             }
         }

package/lib/metadataTypes/EventDefinition.js

@@ -1,11 +1,14 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
 const File = require('../util/file');
+const cache = require('../util/cache');
 
 /**
  * EventDefinition MetadataType
+ *
  * @augments MetadataType
  */
 class EventDefinition extends MetadataType {
@@ -13,35 +16,48 @@ class EventDefinition extends MetadataType {
      * Retrieves Metadata of Event Definition.
      * Endpoint /interaction/v1/EventDefinitions return all Event Definitions with all details.
      * Currently it is not needed to loop over Imports with endpoint /interaction/v1/EventDefinitions/{id}
-     * @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) {
-        return super.retrieveREST(retrieveDir, '/interaction/v1/EventDefinitions/', null);
+    static retrieve(retrieveDir, _, __, ___, key) {
+        return super.retrieveREST(
+            retrieveDir,
+            `/interaction/v1/EventDefinitions${
+                key ? '/key:' + encodeURIComponent(key) : ''
+            }?extras=all`,
+            null,
+            null,
+            key
+        );
     }
 
     /**
      * Retrieves event definition metadata for caching
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
     static retrieveForCache() {
-        return super.retrieveREST(null, '/interaction/v1/EventDefinitions/', null);
+        return super.retrieveREST(null, '/interaction/v1/EventDefinitions/');
     }
 
     /**
      * Retrieve a specific Event Definition by Name
-     * @param {String} templateDir Directory where retrieved metadata directory will be saved
-     * @param {String} name name of the metadata file
-     * @param {Object} templateVariables variables to be replaced in the metadata
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @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.<TYPE.MetadataTypeItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
-        // todo template based on name
-        const options = {
-            uri: '/interaction/v1/EventDefinitions?name=' + encodeURIComponent(name),
-        };
-        const res = await this.client.RestClient.get(options);
-        const event = res.body.items.filter((item) => item.name === name);
+        const res = await this.client.rest.get(
+            '/interaction/v1/EventDefinitions?name=' + encodeURIComponent(name)
+        );
+        const event = res.items.filter((item) => item.name === name);
         try {
             if (!event || event.length === 0) {
                 throw new Error(`No Event Definitions Found with name "${name}"`);
@@ -50,7 +66,7 @@ class EventDefinition extends MetadataType {
                     `Multiple Event Definitions with name "${name}"` +
                         `please rename to be unique to avoid issues`
                 );
-            } else if (event && event.length === 1) {
+            } else if (event?.length === 1) {
                 const originalKey = event[0][this.definition.keyField];
                 const eventDef = JSON.parse(
                     Util.replaceByObject(
@@ -69,14 +85,12 @@ class EventDefinition extends MetadataType {
 
                 // remove all fields listed in Definition for templating
                 this.keepTemplateFields(eventDef);
-                File.writeJSONToFile(
+                await File.writeJSONToFile(
                     [templateDir, this.definition.type].join('/'),
                     originalKey + '.' + this.definition.type + '-meta',
                     JSON.parse(Util.replaceByObject(JSON.stringify(eventDef), templateVariables))
                 );
-                Util.logger.info(
-                    `EventDefinition.retrieveAsTemplate:: Written Metadata to filesystem (${name})`
-                );
+                Util.logger.info(`- templated ${this.definition.type}: ${name}`);
                 return { metadata: eventDef, type: this.definition.type };
             } else {
                 throw new Error(
@@ -93,8 +107,9 @@ class EventDefinition extends MetadataType {
 
     /**
      * manages post retrieve steps
-     * @param {Object} eventDef a single importDef
-     * @returns {Object[]} metadata
+     *
+     * @param {TYPE.MetadataTypeItem} eventDef a single item of Event Definition
+     * @returns {TYPE.MetadataTypeItem} metadata
      */
     static postRetrieveTasks(eventDef) {
         const val = this.parseMetadata(eventDef);
@@ -104,7 +119,8 @@ class EventDefinition extends MetadataType {
 
     /**
      * Creates a single Event Definition
-     * @param {Object} EventDefinition a single Event Definition
+     *
+     * @param {TYPE.MetadataTypeItem} EventDefinition a single Event Definition
      * @returns {Promise} Promise
      */
     static create(EventDefinition) {
@@ -113,18 +129,22 @@ class EventDefinition extends MetadataType {
 
     /**
      * Updates a single Event Definition (using PUT method since PATCH isn't supported)
-     * @param {Object} EventDefinition a single Event Definition
+     *
+     * @param {TYPE.MetadataTypeItem} metadataEntry a single Event Definition
      * @returns {Promise} Promise
      */
-    static async update(EventDefinition) {
-        this.removeNotUpdateableFields(EventDefinition);
+    static async update(metadataEntry) {
+        if (metadataEntry === null || metadataEntry === undefined) {
+            return null;
+        }
+        this.removeNotUpdateableFields(metadataEntry);
         const options = {
-            uri: '/interaction/v1/EventDefinitions/' + EventDefinition.id,
-            json: EventDefinition,
+            uri: '/interaction/v1/EventDefinitions/' + metadataEntry.id,
+            json: metadataEntry,
             headers: {},
         };
         try {
-            const response = await this.client.RestClient.put(options);
+            const response = await this.client.rest.put(options);
             super.checkForErrors(response);
             return response;
         } catch (ex) {
@@ -133,7 +153,7 @@ class EventDefinition extends MetadataType {
                 this.definition.type,
                 'updateREST',
                 ex,
-                EventDefinition.name
+                metadataEntry.name
             );
             return null;
         }
@@ -141,12 +161,12 @@ class EventDefinition extends MetadataType {
 
     /**
      * prepares an event definition for deployment
-     * @param {Object} metadata a single eventDefinition
-     * @returns {Promise} Promise
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single eventDefinition
+     * @returns {TYPE.MetadataTypeItem} parsed version
      */
-    static async preDeployTasks(metadata) {
-        metadata.dataExtensionId = Util.getFromCache(
-            this.cache,
+    static preDeployTasks(metadata) {
+        metadata.dataExtensionId = cache.searchForField(
             'dataExtension',
             metadata.dataExtensionName,
             'Name',
@@ -158,13 +178,13 @@ class EventDefinition extends MetadataType {
 
     /**
      * parses retrieved Metadata before saving
-     * @param {Object} metadata a single event definition
-     * @returns {Array} Array with one metadata object and one sql string
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single event definition
+     * @returns {TYPE.MetadataTypeItem} parsed metadata
      */
     static parseMetadata(metadata) {
         try {
-            metadata.dataExtensionId = Util.getFromCache(
-                this.cache,
+            metadata.dataExtensionId = cache.searchForField(
                 'dataExtension',
                 metadata.dataExtensionId,
                 'ObjectID',
@@ -172,7 +192,7 @@ class EventDefinition extends MetadataType {
             );
             metadata.arguments.dataExtensionId = metadata.dataExtensionId;
             return JSON.parse(JSON.stringify(metadata));
-        } catch (ex) {
+        } catch {
             Util.metadataLogger(
                 'verbose',
                 this.definition.type,
@@ -186,7 +206,5 @@ class EventDefinition extends MetadataType {
 
 // Assign definition to static attributes
 EventDefinition.definition = require('../MetadataTypeDefinitions').eventDefinition;
-EventDefinition.cache = {};
-EventDefinition.client = undefined;
 
 module.exports = EventDefinition;