mcdev 3.1.1 → 4.0.0

package/lib/metadataTypes/ImportFile.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');
 
 /**
  * ImportFile MetadataType
+ *
  * @augments MetadataType
  */
 class ImportFile extends MetadataType {
@@ -13,72 +16,79 @@ class ImportFile extends MetadataType {
      * Retrieves Metadata of Import File.
      * Endpoint /automation/v1/imports/ return all Import Files with all details.
      * Currently it is not needed to loop over Imports with endpoint /automation/v1/imports/{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 retrieve(retrieveDir) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/imports/', null);
+    static retrieve(retrieveDir, _, __, ___, key) {
+        return super.retrieveREST(retrieveDir, '/automation/v1/imports/', null, null, key);
     }
 
     /**
      * Retrieves import definition metadata for caching
-     * @returns {Promise} Promise
+     *
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
     static async retrieveForCache() {
-        return super.retrieveREST(null, '/automation/v1/imports/', null);
+        return super.retrieveREST(null, '/automation/v1/imports/');
     }
 
     /**
      * Retrieve a specific Import 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/imports/?$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/imports/?$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;
             }
-
+            const originalKey = metadata[this.definition.keyField];
             const val = JSON.parse(
-                Util.replaceByObject(JSON.stringify(this.parseMetadata(metadata)), variables)
+                Util.replaceByObject(
+                    JSON.stringify(this.parseMetadata(metadata)),
+                    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(
-                `ImportFile.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} importDef a single importDef
-     * @returns {Object[]} metadata
+     *
+     * @param {TYPE.MetadataTypeItem} importDef a single importDef
+     * @returns {TYPE.MetadataTypeItem} metadata
      */
     static postRetrieveTasks(importDef) {
         const val = this.parseMetadata(importDef);
@@ -87,7 +97,8 @@ class ImportFile extends MetadataType {
 
     /**
      * Creates a single Import File
-     * @param {Object} importFile a single Import File
+     *
+     * @param {TYPE.MetadataTypeItem} importFile a single Import File
      * @returns {Promise} Promise
      */
     static create(importFile) {
@@ -96,7 +107,8 @@ class ImportFile extends MetadataType {
 
     /**
      * Updates a single Import File
-     * @param {Object} importFile a single Import File
+     *
+     * @param {TYPE.MetadataTypeItem} importFile a single Import File
      * @returns {Promise} Promise
      */
     static update(importFile) {
@@ -108,12 +120,12 @@ class ImportFile extends MetadataType {
 
     /**
      * prepares a import definition for deployment
-     * @param {Object} metadata a single importDef
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single importDef
      * @returns {Promise} Promise
      */
     static async preDeployTasks(metadata) {
-        metadata.fileTransferLocationId = Util.getFromCache(
-            this.cache,
+        metadata.fileTransferLocationId = cache.searchForField(
             'ftpLocation',
             metadata.r__ftpLocation_name,
             'name',
@@ -122,29 +134,21 @@ class ImportFile extends MetadataType {
         delete metadata.r__ftpLocation_name;
 
         if (metadata.c__destinationType === 'DataExtension') {
-            try {
-                metadata.destinationObjectId = Util.getFromCache(
-                    this.cache,
-                    'dataExtension',
-                    metadata.r__dataExtension_CustomerKey,
-                    'CustomerKey',
-                    'ObjectID'
-                );
-                delete metadata.r__dataExtension_CustomerKey;
-            } catch (ex) {
-                throw new Error(`ImportFile ${metadata.customerKey}: ${ex.message}`);
-            }
+            metadata.destinationObjectId = cache.searchForField(
+                'dataExtension',
+                metadata.r__dataExtension_CustomerKey,
+                'CustomerKey',
+                'ObjectID'
+            );
+            delete metadata.r__dataExtension_CustomerKey;
         } else if (metadata.c__destinationType === 'List') {
-            try {
-                metadata.destinationObjectId = Util.getListObjectIdFromCache(
-                    this.cache,
-                    metadata.r__list_PathName,
-                    'ObjectID'
-                );
-                delete metadata.r__list_PathName;
-            } catch (ex) {
-                throw new Error(`ImportFile ${metadata.customerKey}: ${ex.message}`);
-            }
+            metadata.destinationObjectId = cache.getListObjectId(
+                metadata.r__list_PathName,
+                'ObjectID'
+            );
+            // destinationId is also needed for List types
+            metadata.destinationId = cache.getListObjectId(metadata.r__list_PathName, 'ID');
+            delete metadata.r__list_PathName;
         }
         // When the destinationObjectTypeId is 584 is refers to Mobile Connect which is not supported as an Import Type
         metadata.destinationObjectTypeId =
@@ -157,12 +161,12 @@ class ImportFile extends MetadataType {
 
     /**
      * parses retrieved Metadata before saving
-     * @param {Object} metadata a single import definition
-     * @returns {Object} parsed metadata definition
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single import definition
+     * @returns {TYPE.MetadataTypeItem} parsed metadata definition
      */
     static parseMetadata(metadata) {
-        metadata.r__ftpLocation_name = Util.getFromCache(
-            this.cache,
+        metadata.r__ftpLocation_name = cache.searchForField(
             'ftpLocation',
             metadata.fileTransferLocationId,
             'id',
@@ -178,8 +182,7 @@ class ImportFile extends MetadataType {
         delete metadata.destinationObjectTypeId;
         if (metadata.c__destinationType === 'DataExtension') {
             try {
-                metadata.r__dataExtension_CustomerKey = Util.getFromCache(
-                    this.cache,
+                metadata.r__dataExtension_CustomerKey = cache.searchForField(
                     'dataExtension',
                     metadata.destinationObjectId,
                     'ObjectID',
@@ -187,18 +190,17 @@ class ImportFile extends MetadataType {
                 );
                 delete metadata.destinationObjectId;
             } catch (ex) {
-                Util.logger.error(`ImportFile ${metadata.customerKey}: ${ex.message}`);
+                Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
             }
         } else if (metadata.c__destinationType === 'List') {
             try {
-                metadata.r__list_PathName = Util.getListPathNameFromCache(
-                    this.cache,
+                metadata.r__list_PathName = cache.getListPathName(
                     metadata.destinationObjectId,
                     'ObjectID'
                 );
                 delete metadata.destinationObjectId;
             } catch (ex) {
-                Util.logger.error(`ImportFile ${metadata.customerKey}: ${ex.message}`);
+                Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
             }
         }
 
@@ -218,7 +220,5 @@ class ImportFile extends MetadataType {
 
 // Assign definition to static attributes
 ImportFile.definition = require('../MetadataTypeDefinitions').importFile;
-ImportFile.cache = {};
-ImportFile.client = undefined;
 
 module.exports = ImportFile;

package/lib/metadataTypes/Interaction.js

@@ -1,20 +1,35 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 
 /**
  * Script MetadataType
+ *
  * @augments MetadataType
  */
 class Interaction extends MetadataType {
     /**
      * Retrieves Metadata of Interaction
      * Endpoint /interaction/v1/interactions?extras=all&pageSize=50000 return 50000 Scripts with all details.
-     * @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 retrieve(retrieveDir) {
-        return super.retrieveREST(retrieveDir, '/interaction/v1/interactions?extras=all', null);
+    static retrieve(retrieveDir, _, __, ___, key) {
+        return super.retrieveREST(
+            retrieveDir,
+            `/interaction/v1/interactions${
+                key ? '/key:' + encodeURIComponent(key) : ''
+            }?extras=all`,
+            null,
+            null,
+            key
+        );
     }
 }
 

package/lib/metadataTypes/List.js

@@ -1,24 +1,53 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
+const cache = require('../util/cache');
 
 /**
  * List MetadataType
+ *
  * @augments MetadataType
  */
 class List extends MetadataType {
     /**
      * Retrieves Metadata of Lists
-     * @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 retrieve(retrieveDir) {
-        return super.retrieveSOAPgeneric(retrieveDir);
+    static retrieve(retrieveDir, _, __, ___, key) {
+        /** @type {TYPE.SoapRequestParams} */
+        let requestParams = null;
+        if (key) {
+            requestParams = {
+                filter: {
+                    leftOperand: {
+                        leftOperand: 'CustomerKey',
+                        operator: 'equals',
+                        rightOperand: key,
+                    },
+                    operator: 'OR',
+                    rightOperand: {
+                        // deviating from standard here by allowing to search without the rather weird key which includes the folder name!
+                        leftOperand: 'ListName',
+                        operator: 'equals',
+                        rightOperand: key,
+                    },
+                },
+            };
+        }
+        return super.retrieveSOAP(retrieveDir, null, requestParams);
     }
     /**
      * Gets metadata cache with limited fields and does not store value to disk
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
     static async retrieveForCache() {
         const results = await this.retrieve(null);
@@ -28,24 +57,36 @@ class List extends MetadataType {
         return results;
     }
 
+    /**
+     * 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);
+    }
+
     /**
      * manages post retrieve steps
-     * @param {Object} list a single list
-     * @returns {Object[]} metadata
+     *
+     * @param {TYPE.MetadataTypeItem} list a single list
+     * @returns {TYPE.MetadataTypeItem} metadata
      */
     static postRetrieveTasks(list) {
         return this.parseMetadata(list);
     }
     /**
      * parses retrieved Metadata before saving
-     * @param {Object} metadata a single list definition
-     * @param {Boolean} [parseForCache] if set to true, the Category ID is kept
-     * @returns {Array} Array with one metadata object and one sql string
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single list definition
+     * @param {boolean} [parseForCache] if set to true, the Category ID is kept
+     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one sql string
      */
     static parseMetadata(metadata, parseForCache) {
         try {
-            metadata.r__folder_Path = Util.getFromCache(
-                this.cache,
+            metadata.r__folder_Path = cache.searchForField(
                 'folder',
                 metadata.Category,
                 'ID',
@@ -56,7 +97,7 @@ class List extends MetadataType {
             }
             return metadata;
         } catch (ex) {
-            Util.logger.warn(`List ${metadata.ID}: '${metadata.CustomerKey}': ${ex.message}`);
+            Util.logger.warn(` - List ${metadata.ID}: '${metadata.CustomerKey}': ${ex.message}`);
         }
     }
 }