mcdev 7.0.4 → 7.1.0

package/lib/metadataTypes/Automation.js

@@ -19,6 +19,7 @@ import pLimit from 'p-limit';
  * @typedef {import('../../types/mcdev.d.js').SDKError} SDKError
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
  * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ * @typedef {import('../../types/mcdev.d.js').TypeKeyCombo} TypeKeyCombo
  */
 /**
  * @typedef {import('../../types/mcdev.d.js').AutomationItem} AutomationItem
@@ -1620,6 +1621,39 @@ class Automation extends MetadataType {
         // delete local copy: retrieve/cred/bu/.../...-doc.md
         await super.postDeleteTasks(customerKey, [`${this.definition.type}-doc.md`]);
     }
+
+    /**
+     * helper for {@link MetadataType.getNestedValue} - adjusted for automation activities
+     *
+     * @param {any} obj the metadataItem to search in (or the result)
+     * @param {string[]} nestedKeyParts key in dot-notation split into parts
+     * @param {string} dependentType used for types that need custom handling
+     * @returns {(string) | (string)[]} result
+     */
+    static getNestedValueHelper(obj, nestedKeyParts, dependentType) {
+        if (nestedKeyParts.length == 0) {
+            // key was found; append '' to ensure we always return a string
+            return obj + '';
+        }
+        // get most left key
+        const key = nestedKeyParts.shift();
+        if (!obj[key]) {
+            // key was not found
+            return;
+        }
+        if (Array.isArray(obj[key])) {
+            return obj[key].flatMap((x) =>
+                this.getNestedValueHelper(x, [...nestedKeyParts], dependentType)
+            );
+        } else {
+            if (nestedKeyParts.length == 0) {
+                // key was found if length is 0 and search field (r__type) is equal the current type, else, keep going
+                return obj[key] === dependentType ? obj.r__key : undefined;
+            } else {
+                return this.getNestedValueHelper(obj[key], [...nestedKeyParts], dependentType);
+            }
+        }
+    }
 }
 
 // Assign definition to static attributes

package/lib/metadataTypes/DataExtension.js

@@ -10,7 +10,7 @@ import File from '../util/file.js';
 import auth from '../util/auth.js';
 import cache from '../util/cache.js';
 import pLimit from 'p-limit';
-import inquirer from 'inquirer';
+import { checkbox } from '@inquirer/prompts';
 
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
@@ -33,7 +33,7 @@ import inquirer from 'inquirer';
  * @augments MetadataType
  */
 class DataExtension extends MetadataType {
-    /** @type {DataExtensionFieldMap} */
+    /** @type {Object.<string, DataExtensionFieldMap>} key: deKey, value: deFieldMap */
     static oldFields;
     /**
      * Upserts dataExtensions after retrieving them from source and target to compare
@@ -100,16 +100,26 @@ class DataExtension extends MetadataType {
             .filter((r) => r !== undefined && r !== null)
             .filter(this.#filterUpsertResults);
 
+        if (Util.OPTIONS.noUpdate && metadataToUpdate.length > 0) {
+            Util.logger.info(
+                ` ☇ skipping update of ${metadataToUpdate.length} ${this.definition.type}${metadataToUpdate.length == 1 ? '' : 's'}: --noUpdate flag is set`
+            );
+        }
+
         const updateLimit = pLimit(10);
-        const updateResults = (
-            await Promise.allSettled(
-                metadataToUpdate
-                    .filter((r) => r !== undefined && r !== null)
-                    .map((metadataEntry) => updateLimit(() => this.update(metadataEntry.after)))
-            )
-        )
-            .filter((r) => r !== undefined && r !== null)
-            .filter(this.#filterUpsertResults);
+        const updateResults = Util.OPTIONS.noUpdate
+            ? []
+            : (
+                  await Promise.allSettled(
+                      metadataToUpdate
+                          .filter((r) => r !== undefined && r !== null)
+                          .map((metadataEntry) =>
+                              updateLimit(() => this.update(metadataEntry.after))
+                          )
+                  )
+              )
+                  .filter((r) => r !== undefined && r !== null)
+                  .filter(this.#filterUpsertResults);
 
         const successfulResults = [...createResults, ...updateResults];
         Util.logger.info(
@@ -119,8 +129,8 @@ class DataExtension extends MetadataType {
         let upsertResults;
         if (successfulResults.length > 0) {
             const metadataResults = successfulResults
-                // @ts-expect-error not sure why this produces a type error. looks 100% correct
-                .map((r) => r.value.Results[0].Object)
+                .map((r) => (r.status === 'fulfilled' ? r.value.Results[0].Object : null))
+                .filter(Boolean)
                 .map((r) => {
                     // if only one fields added will return object otherwise array
                     if (Array.isArray(r?.Fields?.Field)) {
@@ -172,7 +182,6 @@ class DataExtension extends MetadataType {
             DataExtensionField.client = this.client;
             DataExtensionField.properties = this.properties;
             DataExtension.oldFields ||= {};
-            // @ts-expect-error not sure why this produces a type error. looks 100% correct
             DataExtension.oldFields[metadataMap[metadataKey][this.definition.keyField]] =
                 await DataExtensionField.prepareDeployColumnsOnUpdate(
                     metadataMap[metadataKey].Fields,
@@ -486,24 +495,19 @@ class DataExtension extends MetadataType {
             value: name,
             checked: fixBuPreselected.includes(name),
         }));
-        const questions = [
-            {
-                type: 'checkbox',
-                name: 'businessUnits',
+        let answer = null;
+
+        try {
+            answer = await checkbox({
                 message:
                     'Please select BUs that have access to the updated Shared Data Extensions:',
                 pageSize: 10,
                 choices: buList,
-            },
-        ];
-        let responses = null;
-
-        try {
-            responses = await inquirer.prompt(questions);
+            });
         } catch (ex) {
             Util.logger.info(ex);
         }
-        return responses.businessUnits;
+        return answer;
     }
 
     /**
@@ -821,9 +825,10 @@ class DataExtension extends MetadataType {
         // get shared folders to match our shared / synched Data Extensions
         const subTypeArr = this.definition.dependencies
             .filter((item) => item.startsWith('folder-'))
-            .map((item) => item.slice(7));
+            .map((item) => item.slice(7))
+            .filter((item) => Folder.definition.folderTypesFromParent.includes(item));
         Util.logger.info(' - Caching dependent Metadata: folder (shared via _ParentBU_)');
-        Util.logSubtypes(subTypeArr);
+        Util.logSubtypes(subTypeArr, '  ');
         Folder.client = this.client;
         Folder.buObject = this.buObject;
         Folder.properties = this.properties;
@@ -1325,7 +1330,7 @@ class DataExtension extends MetadataType {
                         newJsonElement[field] = element[field];
                     }
                 }
-                // @ts-ignore hard to tell ts that this is in fact a DataExtensionFieldItem
+                // @ts-ignore for document the fields have less values and that leads to an error here.
                 newJson.push(newJsonElement);
             }
             fieldsJson = newJson;

package/lib/metadataTypes/DataExtensionField.js

@@ -97,7 +97,7 @@ class DataExtensionField extends MetadataType {
      *
      * @param {DataExtensionFieldItem[]} deployColumns Columns of data extension that will be deployed
      * @param {string} deKey external/customer key of Data Extension
-     * @returns {Promise.<Object.<string, DataExtensionFieldItem>>} existing fields by their original name to allow re-adding FieldType after update
+     * @returns {Promise.<DataExtensionFieldMap>} existing fields by their original name to allow re-adding FieldType after update
      */
     static async prepareDeployColumnsOnUpdate(deployColumns, deKey) {
         // create list of DE keys that had changes to their fields to be able to use it as a filter in the --fixShared logic
@@ -132,7 +132,7 @@ class DataExtensionField extends MetadataType {
         const fieldsObj = response.metadata;
 
         // ensure fields can be updated properly by their adding ObjectId based on Name-matching
-        /** @type {Object.<string, DataExtensionFieldItem>} */
+        /** @type {DataExtensionFieldMap} */
         const existingFieldByName = {};
 
         for (const key of Object.keys(fieldsObj)) {

package/lib/metadataTypes/Event.js

@@ -192,8 +192,27 @@ class Event extends MetadataType {
 
         // standard values
         metadata.isVisibleInPicker ||= false;
-        metadata.isPlatformObject = false;
-        metadata.mode = 'Production'; // potentially needs to be set to "1" instead
+        if (metadata.isVisibleInPicker && !metadata.sourceApplicationExtensionId) {
+            Util.logger.warn(
+                ` - ${this.definition.type} ${metadata[this.definition.keyField]}: isVisibleInPicker is true but sourceApplicationExtensionId is missing. Setting isVisibleInPicker to false.`
+            );
+            metadata.isVisibleInPicker = false;
+        }
+        metadata.isPlatformObject ||= false;
+        metadata.mode ||= 'Production';
+        switch (metadata.type) {
+            case 'APIEvent': {
+                metadata.entrySourceGroupConfigUrl ||=
+                    'jb:///data/entry/api-event/entrysourcegroupconfig.json';
+                metadata.iconUrl ||= '/images/icon_journeyBuilder-event-api-blue.svg';
+                break;
+            }
+            case 'SalesforceObjectTriggerV2': {
+                metadata.iconUrl ||= '/jbint-events/events/SalesforceData/images/SF-Event-Icon.svg';
+                break;
+            }
+        }
+
         return metadata;
     }
     /**
@@ -405,6 +424,13 @@ class Event extends MetadataType {
                 }): ${ex.message}.`
             );
         }
+        if (!metadata.isPlatformObject) {
+            delete metadata.isPlatformObject;
+        }
+        if (metadata.mode === 'Production') {
+            delete metadata.mode;
+        }
+
         return metadata;
     }
 }

package/lib/metadataTypes/Folder.js

@@ -17,6 +17,10 @@ import cache from '../util/cache.js';
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
  * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ *
+ * @typedef {import('../../types/mcdev.d.js').ListItem} ListItem
+ * @typedef {import('../../types/mcdev.d.js').ListMap} ListMap
+ * @typedef {import('../../types/mcdev.d.js').ListIdMap} ListIdMap
  */
 
 /**
@@ -32,20 +36,27 @@ class Folder extends MetadataType {
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {string[]} [subTypeArr] content type of folder
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise} Promise
+     * @returns {Promise.<{metadata: ListMap, type: string}>} Promise
      */
     static async retrieve(retrieveDir, additionalFields, subTypeArr, key) {
         if (key) {
             Util.logger.error(`Folder.retrieve() does not support key parameter`);
         }
-        const queryAllFolders = await this.retrieveHelper(additionalFields, true, subTypeArr);
-
+        /** @type {ListItem[]} */
+        const queryAllFolders = await this.retrieveHelper(additionalFields, false, subTypeArr);
         if (this.buObject.eid !== this.buObject.mid) {
-            queryAllFolders.push(
-                ...(await this.retrieveHelper(additionalFields, false, subTypeArr))
-            );
+            const selectedParentTypes = subTypeArr?.length
+                ? subTypeArr.filter((item) => this.definition.folderTypesFromParent.includes(item))
+                : subTypeArr;
+            if (!subTypeArr?.length || selectedParentTypes.length) {
+                queryAllFolders.push(
+                    ...(await this.retrieveHelper(additionalFields, true, selectedParentTypes))
+                );
+            }
         }
+
         const sortPairs = toposort(queryAllFolders.map((a) => [a.ParentFolder.ID, a.ID]));
+        /** @type {ListIdMap} */
         const idMap = {};
         for (const val of queryAllFolders) {
             // Contact Builder Lists create a folder called "Audiences" with the same Customer Key as the
@@ -64,6 +75,7 @@ class Folder extends MetadataType {
         }
 
         // create root node for attaching, but will be deleted later
+        // @ts-expect-error we set an incomplete ListItem for ID==0 which is flagged by ts
         idMap[0] = {
             Name: '<ROOT>',
         };
@@ -113,6 +125,7 @@ class Folder extends MetadataType {
         }
 
         // build a new map using the customer key instead of id
+        /** @type {ListMap} */
         const metadata = {};
         for (const id in idMap) {
             // remove keys which are listed in other BUs and skip root
@@ -156,7 +169,7 @@ class Folder extends MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
             );
         }
-        return { metadata: metadata, type: this.definition.type };
+        return { metadata, type: this.definition.type };
     }
 
     /**
@@ -164,7 +177,7 @@ class Folder extends MetadataType {
      *
      * @param {void | string[]} [_] parameter not used
      * @param {string[]} [subTypeArr] content type of folder
-     * @returns {Promise} Promise
+     * @returns {Promise.<{metadata: ListMap, type: string}>} Promise
      */
     static retrieveForCache(_, subTypeArr) {
         return this.retrieve(null, null, subTypeArr, null);
@@ -175,8 +188,8 @@ 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 {MetadataTypeMap} metadata metadata mapped by their keyField
-     * @returns {Promise.<object>} Promise of saved metadata
+     * @param {ListMap} metadata metadata mapped by their keyField
+     * @returns {Promise.<ListMap>} Promise of saved metadata
      */
     static async upsert(metadata) {
         const orignalMetadata = structuredClone(metadata);
@@ -185,6 +198,7 @@ class Folder extends MetadataType {
         let createCount = 0;
         let createFailedCount = 0;
         let filteredByPreDeploy = 0;
+        /** @type {ListMap} */
         const upsertResults = {};
         const sortPairs = toposort(
             Object.keys(metadata).map((customerKey) => [
@@ -262,6 +276,15 @@ class Folder extends MetadataType {
                                     continue;
                                 }
                             }
+                            if (existingId && Util.OPTIONS.noUpdate) {
+                                Util.logger.verbose(
+                                    ` - skipping ${this.definition.type} ${
+                                        deployableMetadata?.Path ||
+                                        deployableMetadata[this.definition.nameField]
+                                    }: --noUpdate flag is set`
+                                );
+                                continue;
+                            }
 
                             let result;
                             // since deployableMetadata will be modified for deploy, make a copy for reference
@@ -339,12 +362,12 @@ class Folder extends MetadataType {
     /**
      * creates a folder based on metatadata
      *
-     * @param {MetadataTypeItem} metadataEntry metadata of the folder
-     * @returns {Promise} Promise
+     * @param {ListItem} metadataEntry metadata of the folder
+     * @returns {Promise.<any>} Promise of api response
      */
     static async create(metadataEntry) {
-        if (metadataEntry?.Parent?.ID === 0) {
-            Util.logger.error(
+        if (metadataEntry?.ParentFolder?.ID === 0) {
+            Util.logger.debug(
                 `${this.definition.type}-${metadataEntry.ContentType}.create:: Cannot create Root Folder: ${metadataEntry.Name}`
             );
             return {};
@@ -405,7 +428,7 @@ class Folder extends MetadataType {
      * Updates a single Folder.
      *
      * @param {MetadataTypeItem} metadataEntry single metadata entry
-     * @returns {Promise} Promise
+     * @returns {Promise.<any>} Promise of api response
      */
     static async update(metadataEntry) {
         const path = metadataEntry.Path;
@@ -434,8 +457,8 @@ class Folder extends MetadataType {
     /**
      * prepares a folder for deployment
      *
-     * @param {MetadataTypeItem} metadata a single folder definition
-     * @returns {Promise.<MetadataTypeItem>} Promise of parsed folder metadata
+     * @param {ListItem} metadata a single folder definition
+     * @returns {Promise.<ListItem>} Promise of parsed folder metadata
      */
     static async preDeployTasks(metadata) {
         if (!this.definition.deployFolderTypes.includes(metadata.ContentType.toLowerCase())) {
@@ -467,12 +490,7 @@ class Folder extends MetadataType {
         }
         // retreive ID based on the matching Path of the parent folder
         else if (metadata?.ParentFolder?.Path) {
-            metadata.ParentFolder.ID = cache.searchForField(
-                'folder',
-                metadata.ParentFolder.Path,
-                'Path',
-                'ID'
-            );
+            metadata.ParentFolder.ID = cache.getFolderId(metadata.ParentFolder.Path);
             return metadata;
         } else {
             Util.metadataLogger(
@@ -488,13 +506,13 @@ class Folder extends MetadataType {
     /**
      * Returns file contents mapped to their filename without '.json' ending
      *
-     * @param {string} dir directory that contains '.json' files to be read
+     * @param {string} dir directory with json files, e.g. /retrieve/cred/bu/folder, /deploy/cred/bu/folder, /template/folder
      * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
-     * @returns {Promise.<MetadataTypeMap>} fileName => fileContent map
+     * @returns {Promise.<ListMap>} fileName => fileContent map
      */
     static async getJsonFromFS(dir, listBadKeys) {
         try {
-            /** @type {MetadataTypeMap} */
+            /** @type {ListMap} */
             const fileName2FileContent = {};
             const directories = File.readDirectoriesSync(dir, 10, true);
             let newCounter = 0;
@@ -564,28 +582,24 @@ class Folder extends MetadataType {
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @param {boolean} [queryAllAccounts] which queryAllAccounts setting to use
      * @param {string[]} [contentTypeList] content type of folder
-     * @returns {Promise.<object>} soap object
+     * @returns {Promise.<ListItem[]>} soap object
      */
     static async retrieveHelper(additionalFields, queryAllAccounts, contentTypeList) {
         const options = { QueryAllAccounts: !!queryAllAccounts };
         if (contentTypeList) {
-            for (const contentType of contentTypeList) {
-                options.filter = options.filter
-                    ? {
-                          leftOperand: {
-                              leftOperand: 'ContentType',
-                              operator: 'equals',
-                              rightOperand: contentType,
-                          },
-                          operator: 'OR',
-                          rightOperand: options.filter,
-                      }
-                    : {
-                          leftOperand: 'ContentType',
-                          operator: 'equals',
-                          rightOperand: contentType,
-                      };
-            }
+            const newFilter = {
+                leftOperand: 'ContentType',
+                operator: contentTypeList.length === 1 ? 'equals' : 'IN',
+                rightOperand:
+                    contentTypeList.length === 1 ? contentTypeList[0] : contentTypeList.sort(),
+            };
+            options.filter = options.filter
+                ? {
+                      leftOperand: newFilter,
+                      operator: 'OR',
+                      rightOperand: options.filter,
+                  }
+                : newFilter;
         }
         const response = await this.client.soap.retrieveBulk(
             'DataFolder',
@@ -599,8 +613,8 @@ class Folder extends MetadataType {
     /**
      * Gets executed after retreive of metadata type
      *
-     * @param {MetadataTypeItem} metadata metadata mapped by their keyField
-     * @returns {MetadataTypeItem} cloned metadata
+     * @param {ListItem} metadata metadata mapped by their keyField
+     * @returns {ListItem} cloned metadata
      */
     static postRetrieveTasks(metadata) {
         return structuredClone(metadata);
@@ -608,12 +622,13 @@ class Folder extends MetadataType {
     /**
      * Helper for writing Metadata to disk, used for Retrieve and deploy
      *
-     * @param {MetadataTypeMap} results metadata results from deploy
+     * @param {ListMap} results metadata results from deploy
      * @param {string} retrieveDir directory where metadata should be stored after deploy/retrieve
      * @param {number | string} mid unused parameter
-     * @returns {Promise.<object>} Promise of saved metadata
+     * @returns {Promise.<ListMap>} Promise of saved metadata
      */
     static async saveResults(results, retrieveDir, mid) {
+        /** @type {ListMap} */
         const savedResults = {};
         for (const metadataEntry in results) {
             try {