mcdev 3.1.1 → 4.0.0

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} variables 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, variables) {
-        // 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);
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        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,9 +66,13 @@ 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(JSON.stringify(this.parseMetadata(event[0])), variables)
+                    Util.replaceByObject(
+                        JSON.stringify(this.parseMetadata(event[0])),
+                        templateVariables
+                    )
                 );
                 if (!eventDef.dataExtensionId) {
                     throw new Error(
@@ -65,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('/'),
-                    eventDef.customerKey + '.' + this.definition.type + '-meta',
-                    JSON.parse(Util.replaceByObject(JSON.stringify(eventDef), variables))
-                );
-                Util.logger.info(
-                    `EventDefinition.retrieveAsTemplate:: Written Metadata to filesystem (${name})`
+                    originalKey + '.' + this.definition.type + '-meta',
+                    JSON.parse(Util.replaceByObject(JSON.stringify(eventDef), templateVariables))
                 );
+                Util.logger.info(`- templated ${this.definition.type}: ${name}`);
                 return { metadata: eventDef, type: this.definition.type };
             } else {
                 throw new Error(
@@ -89,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);
@@ -100,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) {
@@ -109,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) {
@@ -129,7 +153,7 @@ class EventDefinition extends MetadataType {
                 this.definition.type,
                 'updateREST',
                 ex,
-                EventDefinition.name
+                metadataEntry.name
             );
             return null;
         }
@@ -137,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',
@@ -154,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',
@@ -168,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,
@@ -182,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;

package/lib/metadataTypes/FileTransfer.js

@@ -1,86 +1,97 @@
 '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');
 
 /**
  * FileTransfer MetadataType
+ *
  * @augments MetadataType
  */
 class FileTransfer extends MetadataType {
     /**
      * Retrieves Metadata of FileTransfer Activity.
      * Endpoint /automation/v1/filetransfers/ returns all File Transfers
-     * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @returns {Promise} Promise
+     *
+     * @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
      */
-    static async retrieve(retrieveDir) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/filetransfers/', null);
+    static async retrieve(retrieveDir, _, __, ___, key) {
+        return super.retrieveREST(retrieveDir, '/automation/v1/filetransfers/', null, null, key);
     }
     /**
      * Retrieves Metadata of  FileTransfer Activity for caching
-     * @returns {Promise} Promise
+     *
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
     static async retrieveForCache() {
-        return super.retrieveREST(null, '/automation/v1/filetransfers/', null);
+        return super.retrieveREST(null, '/automation/v1/filetransfers/');
     }
 
     /**
      * Retrieve a specific File Transfer Definition by Name
-     * @param {String} templateDir Directory where retrieved metadata directory will be saved
-     * @param {String} name name of the metadata file
-     * @param {Object} variables variables to be replaced in the metadata
-     * @returns {Promise} Promise
+     *
+     * @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
      */
-    static async retrieveAsTemplate(templateDir, name, variables) {
-        const options = {
-            uri: '/automation/v1/filetransfers/?$filter=name%20eq%20' + name.split(' ').join('%20'),
-        };
-
-        const res = await this.client.RestClient.get(options);
-        if (res.body && Array.isArray(res.body.items) && res.body.items.length) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        const res = await this.client.rest.get(
+            '/automation/v1/filetransfers/?$filter=name%20eq%20' + encodeURIComponent(name)
+        );
+        if (Array.isArray(res?.items) && res?.items?.length) {
             // eq-operator returns a similar, not exact match and hence might return more than 1 entry
-            const [metadata] = res.body.items.filter((item) => item.name === name);
+            const metadata = res.items.find((item) => item.name === name);
             if (!metadata) {
                 Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
                 return;
             }
 
             // get full definition
-            const extended = await this.client.RestClient.get({
-                uri: '/automation/v1/filetransfers/' + metadata.id,
-            });
+            const extended = await this.client.rest.get(
+                '/automation/v1/filetransfers/' + metadata[this.definition.idField]
+            );
+            const originalKey = extended[this.definition.keyField];
             const val = JSON.parse(
-                Util.replaceByObject(JSON.stringify(this.parseMetadata(extended.body)), variables)
+                Util.replaceByObject(
+                    JSON.stringify(this.parseMetadata(extended)),
+                    templateVariables
+                )
             );
 
             // remove all fields listed in Definition for templating
             this.keepTemplateFields(val);
-            File.writeJSONToFile(
+            await File.writeJSONToFile(
                 [templateDir, this.definition.type].join('/'),
-                val.customerKey + '.' + this.definition.type + '-meta',
-                JSON.parse(Util.replaceByObject(JSON.stringify(val), variables))
-            );
-            Util.logger.info(
-                `FileTransfer.retrieveAsTemplate:: Written Metadata to filesystem (${name})`
+                originalKey + '.' + this.definition.type + '-meta',
+                JSON.parse(Util.replaceByObject(JSON.stringify(val), templateVariables))
             );
+            Util.logger.info(`- templated ${this.definition.type}: ${name}`);
             return { metadata: val, type: this.definition.type };
-        } else if (res.body && res.body.items) {
+        } else if (res?.items) {
             Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
         } else {
             throw new Error(
                 `Encountered unknown error when retrieveing ${
                     this.definition.typeName
-                } "${name}": ${JSON.stringify(res.body)}`
+                } "${name}": ${JSON.stringify(res)}`
             );
         }
     }
 
     /**
      * manages post retrieve steps
-     * @param {Object} metadata a single fileTransfer activity definition
-     * @returns {Object[]} metadata
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single fileTransfer activity definition
+     * @returns {object[]} metadata
      */
     static postRetrieveTasks(metadata) {
         const values = this.parseMetadata(metadata);
@@ -89,7 +100,8 @@ class FileTransfer extends MetadataType {
 
     /**
      * Creates a single File Transfer
-     * @param {Object} fileTransfer a single File Transfer
+     *
+     * @param {TYPE.MetadataTypeItem} fileTransfer a single File Transfer
      * @returns {Promise} Promise
      */
     static create(fileTransfer) {
@@ -98,7 +110,8 @@ class FileTransfer extends MetadataType {
 
     /**
      * Updates a single File Transfer
-     * @param {Object} fileTransfer a single File Transfer
+     *
+     * @param {TYPE.MetadataTypeItem} fileTransfer a single File Transfer
      * @returns {Promise} Promise
      */
     static update(fileTransfer) {
@@ -107,40 +120,51 @@ class FileTransfer extends MetadataType {
 
     /**
      * prepares a fileTransfer for deployment
-     * @param {Object} metadata a single fileTransfer activity definition
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single fileTransfer activity definition
      * @returns {Promise} Promise
      */
     static async preDeployTasks(metadata) {
-        metadata.fileTransferLocationId = Util.getFromCache(
-            this.cache,
-            'ftpLocation',
-            metadata.r__ftpLocation_name,
-            'name',
-            'id'
-        );
+        if (metadata.r__ftpLocation_name) {
+            metadata.fileTransferLocationId = cache.searchForField(
+                'ftpLocation',
+                metadata.r__ftpLocation_name,
+                'name',
+                'id'
+            );
+        } else {
+            throw new Error(
+                'r__ftpLocation_name not set. Please ensure the source is properly set up and re-retrieve it first.'
+            );
+        }
         return metadata;
     }
     /**
      * parses retrieved Metadata before saving
-     * @param {Object} metadata a single fileTransfer activity definition
-     * @returns {Array} Array with one metadata object and one sql string
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single fileTransfer activity definition
+     * @returns {TYPE.MetadataTypeItem} parsed metadata
      */
     static parseMetadata(metadata) {
-        metadata.r__ftpLocation_name = Util.getFromCache(
-            this.cache,
-            'ftpLocation',
-            metadata.fileTransferLocationId,
-            'id',
-            'name'
-        );
-        delete metadata.fileTransferLocationId;
+        try {
+            metadata.r__ftpLocation_name = cache.searchForField(
+                'ftpLocation',
+                metadata.fileTransferLocationId,
+                'id',
+                'name'
+            );
+            delete metadata.fileTransferLocationId;
+        } catch (ex) {
+            Util.logger.warn(
+                ` - FileTransfer '${metadata[this.definition.keyField]}': ${ex.message}`
+            );
+        }
+
         return metadata;
     }
 }
 
 // Assign definition to static attributes
 FileTransfer.definition = require('../MetadataTypeDefinitions').fileTransfer;
-FileTransfer.cache = {};
-FileTransfer.client = undefined;
 
 module.exports = FileTransfer;

package/lib/metadataTypes/Filter.js

@@ -1,9 +1,11 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 
 /**
  * Filter MetadataType
+ *
  * @augments MetadataType
  */
 class Filter extends MetadataType {
@@ -12,11 +14,16 @@ class Filter extends MetadataType {
      * Endpoint /automation/v1/filters/ returns all Filters,
      * but only with some of the fields. So it is needed to loop over
      * Filters with the endpoint /automation/v1/filters/{id}
-     * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @returns {Promise} Promise
+     *
+     * @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
      */
-    static async retrieve(retrieveDir) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/filters/', null);
+    static async retrieve(retrieveDir, _, __, ___, key) {
+        return super.retrieveREST(retrieveDir, '/automation/v1/filters/', null, null, key);
     }
 }