mcdev 6.0.2 → 7.0.0

package/lib/metadataTypes/FileTransfer.js

@@ -1,11 +1,23 @@
 '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 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
+ */
+
 /**
  * FileTransfer MetadataType
  *
@@ -17,10 +29,10 @@ class FileTransfer extends MetadataType {
      * Endpoint /automation/v1/filetransfers/ returns all File Transfers
      *
      * @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
+     * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static async retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(retrieveDir, '/automation/v1/filetransfers/', null, key);
@@ -28,7 +40,7 @@ class FileTransfer extends MetadataType {
     /**
      * Retrieves Metadata of  FileTransfer Activity for caching
      *
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
+     * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static async retrieveForCache() {
         return super.retrieveREST(null, '/automation/v1/filetransfers/');
@@ -39,8 +51,8 @@ class FileTransfer 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.<TYPE.MetadataTypeItemObj>} Promise
+     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<MetadataTypeItemObj>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
         const res = await this.client.rest.get(
@@ -61,7 +73,7 @@ class FileTransfer extends MetadataType {
             const originalKey = extended[this.definition.keyField];
             const val = JSON.parse(
                 Util.replaceByObject(
-                    JSON.stringify(this.parseMetadata(extended)),
+                    JSON.stringify(this.postRetrieveTasks(extended)),
                     templateVariables
                 )
             );
@@ -86,21 +98,10 @@ class FileTransfer extends MetadataType {
         }
     }
 
-    /**
-     * manages post retrieve steps
-     *
-     * @param {TYPE.MetadataTypeItem} metadata a single fileTransfer activity definition
-     * @returns {object[]} metadata
-     */
-    static postRetrieveTasks(metadata) {
-        const values = this.parseMetadata(metadata);
-        return values;
-    }
-
     /**
      * Creates a single File Transfer
      *
-     * @param {TYPE.MetadataTypeItem} fileTransfer a single File Transfer
+     * @param {MetadataTypeItem} fileTransfer a single File Transfer
      * @returns {Promise} Promise
      */
     static create(fileTransfer) {
@@ -110,7 +111,7 @@ class FileTransfer extends MetadataType {
     /**
      * Updates a single File Transfer
      *
-     * @param {TYPE.MetadataTypeItem} fileTransfer a single File Transfer
+     * @param {MetadataTypeItem} fileTransfer a single File Transfer
      * @returns {Promise} Promise
      */
     static update(fileTransfer) {
@@ -120,7 +121,7 @@ class FileTransfer extends MetadataType {
     /**
      * prepares a fileTransfer for deployment
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single fileTransfer activity definition
+     * @param {MetadataTypeItem} metadata a single fileTransfer activity definition
      * @returns {Promise} Promise
      */
     static async preDeployTasks(metadata) {
@@ -139,13 +140,14 @@ class FileTransfer extends MetadataType {
         }
         return metadata;
     }
+
     /**
-     * parses retrieved Metadata before saving
+     * manages post retrieve steps
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single fileTransfer activity definition
-     * @returns {TYPE.MetadataTypeItem} parsed metadata
+     * @param {MetadataTypeItem} metadata a single fileTransfer activity definition
+     * @returns {MetadataTypeItem} parsed metadata
      */
-    static parseMetadata(metadata) {
+    static postRetrieveTasks(metadata) {
         try {
             metadata.r__fileLocation_name = cache.searchForField(
                 'fileLocation',
@@ -162,6 +164,40 @@ class FileTransfer extends MetadataType {
 
         return metadata;
     }
+
+    /**
+     * 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) : '';
+        const results = await this.client.rest.get('/automation/v1/filetransfers/' + filter);
+        const items = results?.items || [];
+        const found = items.find((item) =>
+            name ? item[this.definition.nameField] === name : item[this.definition.keyField] === key
+        );
+        return found?.id || 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(` - fileTransfer not found`);
+            return false;
+        }
+        return super.deleteByKeyREST('/automation/v1/filetransfers/' + objectId, customerKey);
+    }
 }
 
 // Assign definition to static attributes

package/lib/metadataTypes/Filter.js

@@ -1,8 +1,20 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.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
+ */
+
 /**
  * Filter MetadataType
  *
@@ -16,10 +28,10 @@ class Filter extends MetadataType {
      * Filters with the endpoint /automation/v1/filters/{id}
      *
      * @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
+     * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static async retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(retrieveDir, '/automation/v1/filters/', null, key);

package/lib/metadataTypes/Folder.js

@@ -1,12 +1,24 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
 import toposort from 'toposort';
 import { Util } from '../util/util.js';
 import File from '../util/file.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
+ */
+
 /**
  * Folder MetadataType
  *
@@ -150,7 +162,7 @@ class Folder extends MetadataType {
     /**
      * Retrieves folder metadata for caching
      *
-     * @param {void} _ unused
+     * @param {void | string[]} [_] parameter not used
      * @param {string[]} [subTypeArr] content type of folder
      * @returns {Promise} Promise
      */
@@ -163,11 +175,11 @@ class Folder extends MetadataType {
      * and comparing to check if create or update operation is needed.
      * Copied due to having a dependency on itself, meaning the created need to be serial
      *
-     * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
+     * @param {MetadataTypeMap} metadata metadata mapped by their keyField
      * @returns {Promise.<object>} Promise of saved metadata
      */
     static async upsert(metadata) {
-        const orignalMetadata = JSON.parse(JSON.stringify(metadata));
+        const orignalMetadata = structuredClone(metadata);
         let updateCount = 0;
         let updateFailedCount = 0;
         let createCount = 0;
@@ -211,13 +223,12 @@ class Folder extends MetadataType {
                                 );
                                 if (
                                     existingId &&
-                                    (metadata[metadataKey]._generated || // of generated, never "update"
-                                        !this.hasChangedGeneric(
-                                            cachedVersion,
-                                            metadata[metadataKey],
-                                            'Path',
-                                            true
-                                        ))
+                                    !this.hasChangedGeneric(
+                                        cachedVersion,
+                                        metadata[metadataKey],
+                                        'Path',
+                                        true
+                                    )
                                 ) {
                                     Util.logger.verbose(
                                         ` - skipping ${this.definition.type} ${
@@ -234,13 +245,12 @@ class Folder extends MetadataType {
                                 existingId = cachedVersion?.ID;
                                 if (
                                     existingId &&
-                                    (metadata[metadataKey]._generated || // of generated, never "update"
-                                        !this.hasChangedGeneric(
-                                            cachedVersion,
-                                            metadata[metadataKey],
-                                            'Path',
-                                            true
-                                        ))
+                                    !this.hasChangedGeneric(
+                                        cachedVersion,
+                                        metadata[metadataKey],
+                                        'Path',
+                                        true
+                                    )
                                 ) {
                                     Util.logger.verbose(
                                         ` - skipping ${this.definition.type} ${
@@ -255,7 +265,7 @@ class Folder extends MetadataType {
 
                             let result;
                             // since deployableMetadata will be modified for deploy, make a copy for reference
-                            const beforeMetadata = JSON.parse(JSON.stringify(deployableMetadata));
+                            const beforeMetadata = structuredClone(deployableMetadata);
                             if (existingId) {
                                 // if an existing folder exists with the same name/path then use that
                                 deployableMetadata.ID = existingId;
@@ -329,7 +339,7 @@ class Folder extends MetadataType {
     /**
      * creates a folder based on metatadata
      *
-     * @param {TYPE.MetadataTypeItem} metadataEntry metadata of the folder
+     * @param {MetadataTypeItem} metadataEntry metadata of the folder
      * @returns {Promise} Promise
      */
     static async create(metadataEntry) {
@@ -341,15 +351,29 @@ class Folder extends MetadataType {
         }
         const path = metadataEntry.Path;
         try {
-            const response = await super.createSOAP(metadataEntry, true);
-            if (response) {
-                response.Results[0].Object = metadataEntry;
-                response.Results[0].Object.ID = response.Results[0].NewID;
-                response.Results[0].Object.CustomerKey = metadataEntry.CustomerKey;
-                delete response.Results[0].Object.$;
+            // * We tried using the SOAP endpoint for creating folders but that did not support folders for automations nor journeys. This rest endpoint seems to cover everything though
+            const restPayload = {
+                parentCatId: metadataEntry.ParentFolder.ID,
+                name: metadataEntry.Name,
+                catType: metadataEntry.ContentType,
+            };
+            const response = await super.createREST(restPayload, '/email/v1/category', true);
+            if (response?.objectId) {
+                // convert the response to the same format as the SOAP response
+                metadataEntry.ID = response.objectId;
+                // the following is a bit of a hack to make the response look like the SOAP response; not sure if we actually need that anywhere like this --> future developers feel free to double check
+                const returnObject = {
+                    Results: [
+                        {
+                            Object: metadataEntry,
+                        },
+                    ],
+                };
 
                 Util.logger.info(` - created folder: ${path}`);
-                return response;
+                return returnObject;
+            } else {
+                throw new Error(response);
             }
         } catch (ex) {
             if (ex?.results) {
@@ -367,7 +391,7 @@ class Folder extends MetadataType {
     /**
      * Updates a single Folder.
      *
-     * @param {TYPE.MetadataTypeItem} metadataEntry single metadata entry
+     * @param {MetadataTypeItem} metadataEntry single metadata entry
      * @returns {Promise} Promise
      */
     static async update(metadataEntry) {
@@ -397,8 +421,8 @@ class Folder extends MetadataType {
     /**
      * prepares a folder for deployment
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single folder definition
-     * @returns {Promise.<TYPE.MetadataTypeItem>} Promise of parsed folder metadata
+     * @param {MetadataTypeItem} metadata a single folder definition
+     * @returns {Promise.<MetadataTypeItem>} Promise of parsed folder metadata
      */
     static async preDeployTasks(metadata) {
         if (!this.definition.deployFolderTypes.includes(metadata.ContentType.toLowerCase())) {
@@ -453,13 +477,17 @@ class Folder extends MetadataType {
      *
      * @param {string} dir directory that contains '.json' files to be read
      * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
-     * @returns {TYPE.MetadataTypeMap} fileName => fileContent map
+     * @returns {Promise.<MetadataTypeMap>} fileName => fileContent map
      */
-    static getJsonFromFS(dir, listBadKeys) {
+    static async getJsonFromFS(dir, listBadKeys) {
         try {
+            /** @type {MetadataTypeMap} */
             const fileName2FileContent = {};
             const directories = File.readDirectoriesSync(dir, 10, true);
             let newCounter = 0;
+            if (!Array.isArray(directories)) {
+                return fileName2FileContent;
+            }
             for (const subdir of directories) {
                 // standardise to / and then remove the stem up until folder as this
                 // should not be in the path for the metadata. In case no split then return empty as this is root
@@ -467,10 +495,10 @@ class Folder extends MetadataType {
                 const standardSubDir = File.reverseFilterIllegalFilenames(
                     subdir.replaceAll('\\', '/').split(/folder\//)[1] || ''
                 );
-                for (const fileName of File.readdirSync(subdir)) {
+                for (const fileName of await File.readdir(subdir)) {
                     try {
                         if (fileName.endsWith('meta.json')) {
-                            const fileContent = File.readJSONFile(subdir, fileName, true, false);
+                            const fileContent = await File.readJSONFile(subdir, fileName, false);
 
                             const fileNameWithoutEnding = File.reverseFilterIllegalFilenames(
                                 fileName.split(/\.(\w|-)+-meta.json/)[0]
@@ -558,18 +586,18 @@ class Folder extends MetadataType {
     /**
      * Gets executed after retreive of metadata type
      *
-     * @param {TYPE.MetadataTypeItem} metadata metadata mapped by their keyField
-     * @returns {TYPE.MetadataTypeItem} cloned metadata
+     * @param {MetadataTypeItem} metadata metadata mapped by their keyField
+     * @returns {MetadataTypeItem} cloned metadata
      */
     static postRetrieveTasks(metadata) {
-        return JSON.parse(JSON.stringify(metadata));
+        return structuredClone(metadata);
     }
     /**
      * Helper for writing Metadata to disk, used for Retrieve and deploy
      *
-     * @param {object} results metadata results from deploy
+     * @param {MetadataTypeMap} results metadata results from deploy
      * @param {string} retrieveDir directory where metadata should be stored after deploy/retrieve
-     * @param {number} mid current mid for this credential / business unit
+     * @param {number | string} mid unused parameter
      * @returns {Promise.<object>} Promise of saved metadata
      */
     static async saveResults(results, retrieveDir, mid) {