mcdev 7.3.0 → 7.3.1

package/.github/ISSUE_TEMPLATE/bug.yml

@@ -39,6 +39,7 @@ body:
           label: Version
           description: What version of our software are you running? (mcdev --version)
           options:
+              - 7.3.1
               - 7.3.0
               - 7.2.0
               - 7.1.4

package/.github/PULL_REQUEST_TEMPLATE/pr_template_release.md

@@ -5,9 +5,8 @@
 ### Before merge
 
 - [ ] Wiki updated with info in ticket listed under **Documentation**
-- [ ] ran `npm audit fix`
-- [ ] ran `npm run lint-ts`
-- [ ] ran `npm run lint:fix`
+- [ ] ran `npm run prepare-release` (which runs `npm audit fix`, `npm run lint-ts`, `npm run lint:fix`, `git add`, `git commit`)
+- [ ] pushed potential changes made by prepare-release
 
 ### After merge
 
@@ -15,6 +14,7 @@
 - [ ] updated [bug template](/.github/ISSUE_TEMPLATE/bug.yml) to include the new version
 - [ ] updated [.mcdevrc](/test/mockRoot/.mcdevrc.json) for tests to the new version
 - [ ] ran `npm run version:major/minor/patch`
+- [ ] pushed version-prep commits
 - [ ] merged main branch into develop branch
 - [ ] closed GitHub milestone
 - [ ] created [new GitHub Release](https://github.com/Accenture/sfmc-devtools/releases/new)

package/.vscode/settings.json

@@ -20,7 +20,7 @@
     "sql-formatter.indent": "    ",
     "sql-formatter.uppercase": true,
     "[html]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
+        "editor.defaultFormatter": "FiB.beautyAmp"
     },
     "[javascript]": {
         "editor.defaultFormatter": "esbenp.prettier-vscode"

package/@types/lib/metadataTypes/Event.d.ts

@@ -114,6 +114,13 @@ declare class Event extends MetadataType {
      * @param {any} ca trigger[0].configurationArguments
      */
     static checkSalesforceEntryEvents(ca: any): void;
+    /**
+     *
+     * @param {object[]} conditions -
+     * @param {string[]} errors list of errors
+     * @param {'primaryObjectFilterCriteria'|'relatedObjectFilterCriteria'} context used to improve error logs
+     */
+    static checkSfFilterFieldsExist(conditions: object[], errors: string[], context: "primaryObjectFilterCriteria" | "relatedObjectFilterCriteria"): void;
     static requiredConfigurationArguments: string[];
     /**
      *

package/@types/lib/metadataTypes/Event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Event.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/Event.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Event.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/Event.js"],"names":[],"mappings":";uBAUa,OAAO,wBAAwB,EAAE,QAAQ;0BACzC,OAAO,wBAAwB,EAAE,WAAW;8BAC5C,OAAO,wBAAwB,EAAE,eAAe;+BAChD,OAAO,wBAAwB,EAAE,gBAAgB;mCACjD,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;8BACpD,OAAO,wBAAwB,EAAE,eAAe;iCAChD,OAAO,wBAAwB,EAAE,kBAAkB;gCACnD,OAAO,wBAAwB,EAAE,iBAAiB;0BAClD,OAAO,wBAAwB,EAAE,WAAW;8BAE5C,OAAO,wBAAwB,EAAE,eAAe;4BAChD,OAAO,wBAAwB,EAAE,aAAa;AAb3D;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH;IACI,oCAAkC;IAElC;;;;;;;;;;OAUG;IACH,6BANW,MAAM,MACN,IAAI,GAAG,MAAM,EAAE,OACf,IAAI,GAAG,MAAM,EAAE,QACf,MAAM,GACJ,OAAO,CAAE,kBAAkB,CAAC,CAwBxC;IAED;;;;OAIG;IACH,2BAFa,OAAO,CAAE,kBAAkB,CAAC,CAIxC;IAED;;;;;;;OAOG;IACH,uCALW,MAAM,QACN,MAAM,qBACN,WAAW,GACT,OAAO,CAAE,mBAAmB,CAAC,CAiDzC;IA8BD;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAK1B;IAED;;;;;OAKG;IACH,6BAHW,gBAAgB,gBAU1B;IAED;;;;;OAKG;IACH,gCAHW,gBAAgB,GACd,OAAO,CAAE,gBAAgB,CAAC,CAmCtC;IAyLD;;;;;OAKG;IACH,mCAHW,gBAAgB,GACd,OAAO,CAAE,gBAAgB,CAAC,CA2CtC;IACD;QACI,uBAAuB;yBAAZ,MAAM,EAAE;QAEnB,2EAA2E;2BAAhE;gBAAQ,MAAM,GAAE,eAAe,EAAE;SAAC;QAE7C,oGAAoG;sBAAzF;gBAAQ,MAAM,GAAE;oBAAQ,MAAM,GAAE,aAAa;aAAC;SAAC;MAE5D;IAEF;;;;OAIG;IACH,2CAFW,MAAM,iBAsJhB;IAED,yCAYE;IAEF;;;OAGG;IACH,sCAFW,GAAG,QAuLb;IAED;;;;;OAKG;IACH,4CAJW,MAAM,EAAE,UACR,MAAM,EAAE,WACR,6BAA6B,GAAC,6BAA6B,QAerE;IAED,gDAYE;IACF;;;;;;;OAOG;IACH,4DANW,MAAM,MACN,GAAG,OACH,MAAM,SACN,MAAM,GACJ,OAAO,CAAE,IAAI,CAAC,CAoD1B;IAED;;;;;OAKG;IACH,yDAJW,MAAM,MACN,GAAG,GACD,OAAO,CAAE,IAAI,CAAC,CA0D1B;CACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAn9BwB,mBAAmB"}

package/@types/lib/metadataTypes/Journey.d.ts

@@ -108,10 +108,11 @@ declare class Journey extends MetadataType {
      *
      * @param {string} statusUrl URL to check the status of the publish request
      * @param {string} key key or id for log messages
+     * @param {any} spinner key or id for log messages
      * @param {number} [tries] number of tries used to check the status
      * @returns {Promise.<string>} key of the item that was published successfully
      */
-    static _checkPublishStatus(statusUrl: string, key: string, tries?: number): Promise<string>;
+    static _checkPublishStatus(statusUrl: string, key: string, spinner: any, tries?: number): Promise<string>;
     /**
      * helper for {@link Journey._checkPublishStatus}
      *

package/@types/lib/metadataTypes/Journey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Journey.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/Journey.js"],"names":[],"mappings":";uBAaa,OAAO,wBAAwB,EAAE,QAAQ;0BACzC,OAAO,wBAAwB,EAAE,WAAW;8BAC5C,OAAO,wBAAwB,EAAE,eAAe;+BAChD,OAAO,wBAAwB,EAAE,gBAAgB;mCACjD,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;8BACpD,OAAO,wBAAwB,EAAE,eAAe;iCAChD,OAAO,wBAAwB,EAAE,kBAAkB;gCACnD,OAAO,wBAAwB,EAAE,iBAAiB;0BAClD,OAAO,wBAAwB,EAAE,WAAW;AAVzD;;;;;;;;;;;GAWG;AAEH;;;;;;;;GAQG;AACH;IACI;;;;;;;;OAQG;IACH,6BANW,MAAM,MACN,IAAI,GAAG,MAAM,EAAE,OACf,IAAI,GAAG,MAAM,EAAE,QACf,MAAM,GACJ,OAAO,CAAE,kBAAkB,CAAC,CA8JxC;IAmFD;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAS1B;IAED;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAK1B;IAmBD;;;;OAIG;IACH,2CAFW,eAAe,iBAmBzB;IAED;;;;;OAKG;IACH,mCAHW,gBAAgB,GACd,OAAO,CAAE,gBAAgB,CAAC,CAsMtC;IAED;;;;;OAKG;IACH,6CA2aC;IAED;;;;;;OAMG;IACH,gCAHW,gBAAgB,GACd,OAAO,CAAE,gBAAgB,CAAC,CA+ItC;IAED;;;;;OAKG;IACH,0CA6MC;IA4LD;;;;OAIG;IACH,sCAFW,eAAe,iBAWzB;IAED;;;;;OAKG;IACH,uBAHW,MAAM,EAAE,GACN,OAAO,CAAE,MAAM,EAAE,CAAC,CAkO9B;IAED;;;;;;;OAOG;IACH,sCALW,MAAM,OACN,MAAM,UACN,MAAM,GACJ,OAAO,CAAE,MAAM,CAAC,CAgC5B;IAED;;;;OAIG;IACH,2CAFW;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,QAAO;QAAC,QAAQ,QAAM;KAAC,QAgCvD;CA2FJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA55DwB,mBAAmB"}
+{"version":3,"file":"Journey.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/Journey.js"],"names":[],"mappings":";uBAca,OAAO,wBAAwB,EAAE,QAAQ;0BACzC,OAAO,wBAAwB,EAAE,WAAW;8BAC5C,OAAO,wBAAwB,EAAE,eAAe;+BAChD,OAAO,wBAAwB,EAAE,gBAAgB;mCACjD,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;8BACpD,OAAO,wBAAwB,EAAE,eAAe;iCAChD,OAAO,wBAAwB,EAAE,kBAAkB;gCACnD,OAAO,wBAAwB,EAAE,iBAAiB;0BAClD,OAAO,wBAAwB,EAAE,WAAW;AAVzD;;;;;;;;;;;GAWG;AAEH;;;;;;;;GAQG;AACH;IACI;;;;;;;;OAQG;IACH,6BANW,MAAM,MACN,IAAI,GAAG,MAAM,EAAE,OACf,IAAI,GAAG,MAAM,EAAE,QACf,MAAM,GACJ,OAAO,CAAE,kBAAkB,CAAC,CA8JxC;IAmFD;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAS1B;IAED;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAK1B;IAmBD;;;;OAIG;IACH,2CAFW,eAAe,iBAmBzB;IAED;;;;;OAKG;IACH,mCAHW,gBAAgB,GACd,OAAO,CAAE,gBAAgB,CAAC,CAsMtC;IAED;;;;;OAKG;IACH,6CA2aC;IAED;;;;;;OAMG;IACH,gCAHW,gBAAgB,GACd,OAAO,CAAE,gBAAgB,CAAC,CA+ItC;IAED;;;;;OAKG;IACH,0CA6MC;IA4LD;;;;OAIG;IACH,sCAFW,eAAe,iBAWzB;IAED;;;;;OAKG;IACH,uBAHW,MAAM,EAAE,GACN,OAAO,CAAE,MAAM,EAAE,CAAC,CAmP9B;IAED;;;;;;;;OAQG;IACH,sCANW,MAAM,OACN,MAAM,WACN,GAAG,UACH,MAAM,GACJ,OAAO,CAAE,MAAM,CAAC,CAkC5B;IAED;;;;OAIG;IACH,2CAFW;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,QAAO;QAAC,QAAQ,QAAM;KAAC,QAgCvD;CA2FJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAj7DwB,mBAAmB"}

package/@types/lib/metadataTypes/Role.d.ts

@@ -39,6 +39,13 @@ declare class Role extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Metadata store object
      */
     static retrieve(retrieveDir: string, _?: void | string[], ___?: void | string[], key?: string): Promise<MetadataTypeMapObj>;
+    /**
+     * adds default roles to the list of retrieved roles for proper caching (but not storing)
+     * also caches available timezones for retrieve-user
+     *
+     * @param {MetadataTypeMap} parsed list or previously retrieved items as reference
+     */
+    static cacheDefaultRolesAndTimezones(parsed: MetadataTypeMap): Promise<void>;
     /**
      * Gets executed before deploying metadata
      *

package/@types/lib/metadataTypes/Role.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Role.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/Role.js"],"names":[],"mappings":";uBAQa,OAAO,wBAAwB,EAAE,QAAQ;0BACzC,OAAO,wBAAwB,EAAE,WAAW;8BAC5C,OAAO,wBAAwB,EAAE,eAAe;+BAChD,OAAO,wBAAwB,EAAE,gBAAgB;mCACjD,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;8BACpD,OAAO,wBAAwB,EAAE,eAAe;iCAChD,OAAO,wBAAwB,EAAE,kBAAkB;gCACnD,OAAO,wBAAwB,EAAE,iBAAiB;kCAClD,OAAO,wBAAwB,EAAE,mBAAmB;0BACpD,OAAO,wBAAwB,EAAE,WAAW;AAXzD;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH;IACI;;;;;;;;OAQG;IACH,6BANW,MAAM,MACN,IAAI,GAAG,MAAM,EAAE,QACf,IAAI,GAAG,MAAM,EAAE,QACf,MAAM,GACJ,OAAO,CAAE,kBAAkB,CAAC,CAsFxC;IAED;;;;;OAKG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAS5B;IAED;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAK1B;IAED;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAK1B;IAED;;;;;OAKG;IACH,2BAHW,eAAe,GACb,OAAO,CAAE,IAAI,CAAC,CA4G1B;IAED;;;;;;;;;;OAUG;IACH,4BAPW,MAAM,WACN,MAAM,eACN,MAAM,cACN,MAAM,GAEJ,IAAI,CAyDhB;CACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAhVwB,mBAAmB"}
+{"version":3,"file":"Role.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/Role.js"],"names":[],"mappings":";uBAQa,OAAO,wBAAwB,EAAE,QAAQ;0BACzC,OAAO,wBAAwB,EAAE,WAAW;8BAC5C,OAAO,wBAAwB,EAAE,eAAe;+BAChD,OAAO,wBAAwB,EAAE,gBAAgB;mCACjD,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;8BACpD,OAAO,wBAAwB,EAAE,eAAe;iCAChD,OAAO,wBAAwB,EAAE,kBAAkB;gCACnD,OAAO,wBAAwB,EAAE,iBAAiB;kCAClD,OAAO,wBAAwB,EAAE,mBAAmB;0BACpD,OAAO,wBAAwB,EAAE,WAAW;AAXzD;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH;IACI;;;;;;;;OAQG;IACH,6BANW,MAAM,MACN,IAAI,GAAG,MAAM,EAAE,QACf,IAAI,GAAG,MAAM,EAAE,QACf,MAAM,GACJ,OAAO,CAAE,kBAAkB,CAAC,CAsDxC;IAED;;;;;OAKG;IACH,6CAFW,eAAe,iBAsCzB;IAED;;;;;OAKG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAS5B;IAED;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAK1B;IAED;;;;;OAKG;IACH,wBAHW,gBAAgB,gBAK1B;IAED;;;;;OAKG;IACH,2BAHW,eAAe,GACb,OAAO,CAAE,IAAI,CAAC,CA4G1B;IAED;;;;;;;;;;OAUG;IACH,4BAPW,MAAM,WACN,MAAM,eACN,MAAM,cACN,MAAM,GAEJ,IAAI,CAyDhB;CACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA5VwB,mBAAmB"}

package/boilerplate/files/.vscode/settings.json

@@ -37,7 +37,8 @@
     },
     "editor.formatOnSave": true,
     "files.associations": {
-        "*.ssjs": "javascript"
+        "*.ssjs": "javascript",
+        "*.html": "ampscript"
     },
     "files.eol": "\n",
     "files.exclude": {
@@ -48,7 +49,7 @@
         "editor.defaultFormatter": "esbenp.prettier-vscode"
     },
     "[html]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
+        "editor.defaultFormatter": "FiB.beautyAmp"
     },
     "[javascript]": {
         "editor.defaultFormatter": "esbenp.prettier-vscode"

package/boilerplate/forcedUpdates.json

@@ -1,4 +1,8 @@
 [
+    {
+        "version": "7.3.1",
+        "files": [".vscode/settings.json"]
+    },
     {
         "version": "7.3.0",
         "files": [".vscode/settings.json"]

package/lib/metadataTypes/Event.js

@@ -607,13 +607,12 @@ class Event extends MetadataType {
                     leadFieldNames.includes(item)
                 )) {
                     // copy the value from contact - while thats not perfectly correct it will hopefully be sufficient for what we need to check
-                    this.sfObjects.objectFields[contactLeadName][fieldName] =
-                        this.sfObjects.objectFields['Contact'][fieldName];
+                    this.sfObjects.objectFields[contactLeadName][fieldName] = structuredClone(
+                        this.sfObjects.objectFields['Contact'][fieldName]
+                    );
                     this.sfObjects.objectFields[contactLeadName][fieldName].objectname = 'Common';
 
-                    // delete the field from Contact obj and from Lead obj
-                    delete this.sfObjects.objectFields['Contact'][fieldName];
-                    delete this.sfObjects.objectFields['Lead'][fieldName];
+                    // do not delete fields from Contact or Lead because it depends on the environment where we have to look for those
                 }
                 // create duplicate to also reference this via "Common"
                 this.sfObjects.objectFields['Common'] =
@@ -647,6 +646,7 @@ class Event extends MetadataType {
         const dePrefixFields = {};
         const dePrefixRelationshipMap = {};
         const dePrefixReferenceObjectMap = {};
+        const checkCommon = ca.whoToInject === 'Contact ID/Lead ID (Contacts and Leads)';
         for (const object of edcObjects) {
             // create secondary object to quickly check eventDataSummary against
             dePrefixFields[object.dePrefix] = object.fields;
@@ -671,23 +671,23 @@ class Event extends MetadataType {
             } else {
                 // check if the fields selected in the eventDefinition are actually available
                 for (const fieldName of object.fields) {
-                    if (!this.sfObjects.objectFields[referencedObject][fieldName]) {
-                        if (
-                            (referencedObject === 'Contact' || referencedObject === 'Lead') &&
-                            this.sfObjects.objectFields['Contacts and Leads'][fieldName]
-                        ) {
-                            errors.push(
-                                `Salesforce object field ${referencedObject}.${fieldName} needs to be referenced as Common.${fieldName}`
-                            );
-                        } else {
-                            // TODO reactivate after switch to new API
-                            // errors.push(
-                            //     `Salesforce object field ${referencedObject}.${fieldName} not available on connected org.`
-                            // );
-                        }
+                    if (
+                        checkCommon &&
+                        (referencedObject === 'Contact' || referencedObject === 'Lead') &&
+                        this.sfObjects.objectFields['Common'][fieldName]
+                    ) {
+                        errors.push(
+                            `Salesforce object field ${referencedObject}.${fieldName} needs to be referenced as Common.${fieldName}`
+                        );
+                    } else if (!this.sfObjects.objectFields[referencedObject][fieldName]) {
+                        // TODO reactivate after switch to new API
+                        // errors.push(
+                        //     `Salesforce object field ${referencedObject}.${fieldName} not available on connected org.`
+                        // );
                     }
                     // 1.2 check if all fields in eventDataConfig are listed in the eventDataSummary
                     if (!ca.eventDataSummary.includes(object.dePrefix + fieldName)) {
+                        // TODO instead, remove in postRetrieve and re-add in preDeploy
                         errors.push(
                             `Field ${object.dePrefix + fieldName} is listed under eventDataConfig for referenceObject ${object.referenceObject} but not in eventDataSummary`
                         );
@@ -700,6 +700,7 @@ class Event extends MetadataType {
         // check if all fields in eventDataSummary are listed in the eventDataConfig
 
         for (let fieldName of ca.eventDataSummary) {
+            // TODO instead, remove in postRetrieve and re-add in preDeploy
             const fieldPath = fieldName.split(':');
             fieldName = fieldPath.pop();
             const dePrefix = fieldPath.join(':') + ':';
@@ -712,107 +713,107 @@ class Event extends MetadataType {
 
         // 3 check contactKey
         // check against referencedObjects
-        // const referencedContactObj = this.sfObjects.referencedObjects[ca.objectAPIName].find(
-        //     (el) =>
-        //         el.relationshipName ===
-        //         (ca.contactKey.relationshipName == ''
-        //             ? ca.contactKey.referenceObjectName
-        //             : ca.contactKey.relationshipName)
-        // );
-        // if (referencedContactObj) {
-        //     if (
-        //         ca.contactKey.isPolymorphic &&
-        //         referencedContactObj.isPolymorphic !== ca.contactKey.isPolymorphic
-        //     ) {
-        //         errors.push(
-        //             `configurationArguments.contactKey states an incorrect isPolimorphic value. Should be ${referencedContactObj.isPolymorphic}`
-        //         );
-        //     }
-        //     if (referencedContactObj.referenceObjectName !== ca.contactKey.referenceObjectName) {
-        //         errors.push(
-        //             `configurationArguments.contactKey states an incorrect referenceObjectName value. Should be ${referencedContactObj.referenceObjectName}`
-        //         );
-        //     }
-        //     if (
-        //         !this.sfObjects.objectFields[ca.contactKey.referenceObjectName]?.[
-        //             ca.contactKey.fieldName || ca.contactKey.relationshipIdName
-        //         ]
-        //     ) {
-        //         // * if contactKey uses "Common" then there is no fieldName attribute but instead relationshipIdName needs to be checked
-        //         if (
-        //             ca.contactKey.referenceObjectName === 'Contact' &&
-        //             this.sfObjects.objectFields['Common'][
-        //                 ca.contactKey.fieldName || ca.contactKey.relationshipIdName
-        //             ]
-        //         ) {
-        //             errors.push(
-        //                 `configurationArguments.contactKey should be referencing Common instead of Contact`
-        //             );
-        //         } else {
-        //             errors.push(
-        //                 `configurationArguments.contactKey states the invalid fieldName '${ca.contactKey.fieldName || ca.contactKey.relationshipIdName}' value that does not exist on ${ca.contactKey.referenceObjectName}`
-        //             );
-        //         }
-        //     }
-        // } else {
-        //     errors.push(
-        //         `configurationArguments.contactKey references ${
-        //             ca.contactKey.relationshipName == ''
-        //                 ? ca.contactKey.referenceObjectName
-        //                 : ca.contactKey.relationshipName
-        //         } which is not found in related salesforce objects`
-        //     );
-        // }
+        const referencedContactObj = this.sfObjects.referencedObjects[ca.objectAPIName].find(
+            (el) =>
+                el.relationshipName ===
+                (ca.contactKey.relationshipName == ''
+                    ? ca.contactKey.referenceObjectName
+                    : ca.contactKey.relationshipName)
+        );
+        if (referencedContactObj) {
+            if (
+                ca.contactKey.isPolymorphic &&
+                referencedContactObj.isPolymorphic !== ca.contactKey.isPolymorphic
+            ) {
+                errors.push(
+                    `configurationArguments.contactKey states an incorrect isPolimorphic value. Should be ${referencedContactObj.isPolymorphic}`
+                );
+            }
+            if (referencedContactObj.referenceObjectName !== ca.contactKey.referenceObjectName) {
+                errors.push(
+                    `configurationArguments.contactKey states an incorrect referenceObjectName value. Should be ${referencedContactObj.referenceObjectName}`
+                );
+            }
+            // * if contactKey uses "Common" then there is no fieldName attribute but instead relationshipIdName needs to be checked
+            if (
+                checkCommon &&
+                ca.contactKey.referenceObjectName === 'Contact' &&
+                this.sfObjects.objectFields['Common'][
+                    ca.contactKey.fieldName || ca.contactKey.relationshipIdName
+                ]
+            ) {
+                errors.push(
+                    `configurationArguments.contactKey should be referencing Common instead of Contact`
+                );
+            } else if (
+                !this.sfObjects.objectFields[ca.contactKey.referenceObjectName]?.[
+                    ca.contactKey.fieldName || ca.contactKey.relationshipIdName
+                ]
+            ) {
+                errors.push(
+                    `configurationArguments.contactKey states the invalid fieldName '${ca.contactKey.fieldName || ca.contactKey.relationshipIdName}' value that does not exist on ${ca.contactKey.referenceObjectName}`
+                );
+            }
+        } else {
+            errors.push(
+                `configurationArguments.contactKey references ${
+                    ca.contactKey.relationshipName == ''
+                        ? ca.contactKey.referenceObjectName
+                        : ca.contactKey.relationshipName
+                } which is not found in related salesforce objects`
+            );
+        }
 
         // 4 check passThroughArgument
-        // TODO check where Common vs Contact is really required
-        // const dePrefixCommon = ca.objectAPIName + ':Common';
-        // for (const key of Object.keys(ca.passThroughArgument.fields)) {
-        //     const fieldPath = ca.passThroughArgument.fields[key].split(':');
-        //     const fieldName = fieldPath.pop();
-        //     const dePrefix = fieldPath.join(':') + ':';
-        //     // it seems these fields do NOT need to be in the eventDataConfig
-        //     const relationshipName = dePrefixRelationshipMap[dePrefix];
-        //     let referenceObject = dePrefixReferenceObjectMap[dePrefix];
-        //     if (
-        //         relationshipName !== 'Contact' &&
-        //         referenceObject === 'Contact' &&
-        //         !this.sfObjects.objectFields[referenceObject][fieldName] &&
-        //         this.sfObjects.objectFields['Common']
-        //     ) {
-        //         // basically, when we link to Contact indirectly through other fields then the whole "common" thing does not apply but we still moved the fields to common
-        //         referenceObject = 'Common';
-        //     }
-        //     if (
-        //         !this.sfObjects.objectFields[referenceObject]?.[fieldName] &&
-        //         relationshipName !== 'Contact' &&
-        //         referenceObject === 'Contact' &&
-        //         !this.sfObjects.objectFields['Common']?.[fieldName]
-        //     ) {
-        //         if (
-        //             (relationshipName === 'Contact' || relationshipName === 'Lead') &&
-        //             this.sfObjects.objectFields['Common']?.[fieldName]
-        //         ) {
-        //             errors.push(
-        //                 `(${referenceObject})(${relationshipName}) Field ${dePrefix + fieldName} is listed under passThroughArgument.fields.${key} but needs to be referenced as ${dePrefixCommon}.${fieldName}`
-        //             );
-        //         } else {
-        //             errors.push(
-        //                 `(${referenceObject})(${relationshipName}) Field ${dePrefix + fieldName} is listed under passThroughArgument.fields.${key} but is not available on connected org.`
-        //             );
-        //         }
-        //     }
-        // }
-
-        // 5 check primaryObjectFilterCriteria
-        // TODO
+        const dePrefixCommon = ca.objectAPIName + ':Common';
+        for (const key of Object.keys(ca.passThroughArgument.fields)) {
+            const fieldPath = ca.passThroughArgument.fields[key].split(':');
+            const fieldName = fieldPath.pop();
+            const dePrefix = fieldPath.join(':') + ':';
+            // it seems these fields do NOT need to be in the eventDataConfig
+            const relationshipName = dePrefixRelationshipMap[dePrefix];
+            const referenceObject = dePrefixReferenceObjectMap[dePrefix];
+
+            if (!this.sfObjects.objectFields[referenceObject]?.[fieldName]) {
+                errors.push(
+                    `Field ${dePrefix + fieldName} is listed under passThroughArgument.fields.${key} but is not available on connected org.`
+                );
+            } else if (
+                checkCommon &&
+                (relationshipName === 'Contact' || relationshipName === 'Lead') &&
+                this.sfObjects.objectFields['Common']?.[fieldName]
+            ) {
+                errors.push(
+                    `Field ${dePrefix + fieldName} is listed under passThroughArgument.fields.${key} but needs to be referenced as ${dePrefixCommon}.${fieldName}`
+                );
+            }
+        }
+
+        // 5.a check primaryObjectFilterCriteria
+        this.checkSfFilterFieldsExist(
+            ca.primaryObjectFilterCriteria.conditions,
+            errors,
+            'primaryObjectFilterCriteria'
+        );
+
+        // 5.b check relatedObjectFilterCriteria
+        this.checkSfFilterFieldsExist(
+            ca.relatedObjectFilterCriteria.conditions,
+            errors,
+            'relatedObjectFilterCriteria'
+        );
 
-        // 6 remove primaryObjectFilterSummary (and auto-generate it again in preDeploy from primaryObjectFilterCriteria)
+        // 6.a remove primaryObjectFilterSummary (and auto-generate it again in preDeploy from primaryObjectFilterCriteria)
+        // TODO
+        // 6.b remove relatedObjectFilterSummary (and auto-generate it again in preDeploy from relatedObjectFilterCriteria)
         // TODO
 
         // 7 remove eventDataSummary (and auto-generate it again in preDeploy from eventDataConfig)
         // TODO
 
+        // 8 remove evaluationCriteriaSummary  (and auto-generate it again in preDeploy from salesforceTriggerCriteria)
+        // TODO
+
         // throw error if problems were found
         if (errors?.length) {
             // add a line break
@@ -821,6 +822,27 @@ class Event extends MetadataType {
         }
     }
 
+    /**
+     *
+     * @param {object[]} conditions -
+     * @param {string[]} errors list of errors
+     * @param {'primaryObjectFilterCriteria'|'relatedObjectFilterCriteria'} context used to improve error logs
+     */
+    static checkSfFilterFieldsExist(conditions, errors, context) {
+        for (const condition of conditions) {
+            if (
+                condition.fieldName & condition.referenceObjectName &&
+                !this.sfObjects.objectFields[condition.referenceObjectName]?.[condition.fieldName]
+            ) {
+                errors.push(
+                    `Field ${condition.referenceObjectName}.${condition.fieldName} is listed under ${context} but is not available on connected org.`
+                );
+            } else if (condition.conditions) {
+                this.checkSfFilterFieldsExist(condition.conditions, errors, context);
+            }
+        }
+    }
+
     static requiredConfigurationArguments = [
         'applicationExtensionKey',
         'contactKey',

package/lib/metadataTypes/Journey.js

@@ -9,6 +9,7 @@ import File from '../util/file.js';
 import ReplaceCbReference from '../util/replaceContentBlockReference.js';
 import Retriever from '../Retriever.js';
 import pLimit from 'p-limit';
+import yoctoSpinner from 'yocto-spinner';
 
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
@@ -1034,7 +1035,7 @@ class Journey extends MetadataType {
                             delete config.r__dataExtension_key;
                         }
                     }
-                    Event.preDeployTasks_SalesforceEntryEvents(
+                    await Event.preDeployTasks_SalesforceEntryEvents(
                         metadata.triggers[0].type,
                         metadata.triggers[0].configurationArguments
                     );
@@ -1557,7 +1558,6 @@ class Journey extends MetadataType {
      * @returns {Promise.<string[]>} Returns list of updated keys/ids that were published. Success could only be seen with a delay in the UI because the publish-endpoint is async
      */
     static async publish(keyArr) {
-        const resultsJourney = [];
         const resultsTransactional = [];
         // works only with objectId
         const statusUrls = [];
@@ -1646,7 +1646,7 @@ class Journey extends MetadataType {
                                     Util.logger.info(
                                         ` - published ${this.definition.type}: ${
                                             journey[this.definition.nameField]
-                                        } (${journey[this.definition.keyField]} by creating the matching transactionalEmail`
+                                        } (${journey[this.definition.keyField]}) by creating the matching transactionalEmail`
                                     );
                                     statusUrls.push({ key, statusUrl: response.statusUrl });
                                 }
@@ -1679,66 +1679,84 @@ class Journey extends MetadataType {
                     );
                     break;
                 }
-                case 'Multistep':
-                case 'Quicksend': {
-                    resultsJourney.push(
-                        (async () => {
-                            try {
-                                const response = await this.client.rest.post(
-                                    `/interaction/v1/interactions/publishAsync/${journey.id}?versionNumber=${version}`,
-                                    {}
-                                ); // payload is empty for this request
-                                if (response.statusUrl && response.statusId) {
-                                    Util.logger.info(
-                                        ` - queued for publishing ${this.definition.type}: ${key}`
-                                    );
-                                    statusUrls.push({ key, statusUrl: response.statusUrl });
-                                } else {
-                                    throw new Error(response);
-                                }
-                                return journey.key;
-                            } catch (ex) {
-                                if (
-                                    ex.message === 'Cannot publish interaction in Published status.'
-                                ) {
-                                    Util.logger.info(
-                                        ` - ${this.definition.type} ${key} is already published`
-                                    );
-                                } else if (
-                                    ex.message === 'Cannot publish interaction in Stopped status.'
-                                ) {
-                                    Util.logger.warn(
-                                        ` - ${this.definition.type} ${key} is already published but stopped. Please resume it manually.`
-                                    );
-                                } else {
-                                    Util.logger.error(
-                                        `Failed to publish ${this.definition.type} ${key}: ${ex.message}`
-                                    );
-                                }
+                case 'Multistep': {
+                    // SF Event, Api Event Journeys
+                    // ! for SF-triggered journeys this cannot be asynchronous or it will cause a race-condition (see #1627 for details); the requests are accepted but then processed sequentually anyways, eliminating potential speed gains.
+                    // It is unknown if the same would happen for API-event journeys but given that it's the same endpoint, lets not risk it and run this sequentially
+                    let statusUrl;
+                    try {
+                        const response = await this.client.rest.post(
+                            `/interaction/v1/interactions/publishAsync/${journey.id}?versionNumber=${version}`,
+                            {}
+                        ); // payload is empty for this request
+                        if (response.statusUrl && response.statusId) {
+                            Util.logger.info(
+                                ` - ${this.definition.type} queued for publishing : ${key}/${version}`
+                            );
+                            statusUrl = response.statusUrl;
+                        } else {
+                            throw new Error(response);
+                        }
+                        if (!Util.OPTIONS.skipStatusCheck && statusUrl) {
+                            const spinner = yoctoSpinner({
+                                text: `Publishing journey…`,
+                            }).start();
+
+                            await Util.sleep(1000);
+                            executedKeyArr.push(
+                                await this._checkPublishStatus(statusUrl, key, spinner)
+                            );
+                        } else {
+                            // no guarantees if the journey was actually published
+                            executedKeyArr.push(key);
+                        }
+                    } catch (ex) {
+                        switch (ex.message) {
+                            case 'Cannot publish interaction in Published status.': {
+                                Util.logger.info(
+                                    ` - ${this.definition.type} ${key}/${version} is already published.`
+                                );
+
+                                break;
                             }
-                        })()
+                            case 'Cannot publish interaction in Stopped status.': {
+                                Util.logger.warn(
+                                    ` - ${this.definition.type} ${key}/${version} is stopped. Please create a new version and publish that.`
+                                );
+
+                                break;
+                            }
+                            case 'Cannot publish interaction in Paused status.': {
+                                Util.logger.warn(
+                                    ` - ${this.definition.type} ${key}/${version} is already published but currently paused. Run 'mcdev resume' instead.`
+                                );
+
+                                break;
+                            }
+                            default: {
+                                Util.logger.error(
+                                    `Failed to publish ${this.definition.type} ${key}: ${ex.message}`
+                                );
+                            }
+                        }
+                    }
+                    break;
+                }
+                default: {
+                    throw new Error(
+                        `${this.definition.type} type ${journey.definitionType} not supported yet by publish method`
                     );
                 }
             }
         } // for loop
-        if (resultsJourney.length) {
-            Util.logger.info(`Found ${resultsJourney.length} journey results`);
-            executedKeyArr.push(...(await Promise.all(resultsJourney)).filter(Boolean));
 
-            if (!Util.OPTIONS.skipStatusCheck && statusUrls.length) {
-                Util.logger.info(
-                    `Checking status of ${statusUrls.length} published item${statusUrls.length === 1 ? '' : 's'}`
-                );
-                executedKeyArr.length = 0;
-                await Util.sleep(5000);
-                for (const item of statusUrls) {
-                    executedKeyArr.push(await this._checkPublishStatus(item.statusUrl, item.key));
-                }
-            }
-        }
+        // Transactional Send Journeys
         if (resultsTransactional.length) {
-            Util.logger.info(`Found ${resultsTransactional.length} journey results`);
+            const spinner = yoctoSpinner({
+                text: `Publishing ${resultsTransactional.length} transactional journey${resultsTransactional.length === 1 ? '' : 's'}…`,
+            }).start();
             const transactionalKeyArr = (await Promise.all(resultsTransactional)).filter(Boolean);
+            spinner.success('done.');
             executedKeyArr.push(...transactionalKeyArr);
 
             Util.logger.info('Retrieving relevant journeys');
@@ -1787,30 +1805,33 @@ class Journey extends MetadataType {
      *
      * @param {string} statusUrl URL to check the status of the publish request
      * @param {string} key key or id for log messages
+     * @param {any} spinner key or id for log messages
      * @param {number} [tries] number of tries used to check the status
      * @returns {Promise.<string>} key of the item that was published successfully
      */
-    static async _checkPublishStatus(statusUrl, key, tries = 1) {
+    static async _checkPublishStatus(statusUrl, key, spinner, tries = 1) {
         try {
             const response = await this.client.rest.get(statusUrl);
             switch (response.status) {
                 case 'PublishCompleted': {
+                    spinner.success('done.');
                     Util.logger.info(` - ${this.definition.type} ${key}: publishing succeeded`);
                     this._showPublishStatusDetails(response);
                     return key;
                 }
                 case 'PublishInProcess': {
-                    Util.logger.info(
+                    Util.logger.debug(
                         ` - ${this.definition.type} ${key}: publishing still in progress`
                     );
                     if (tries < 50) {
                         await (tries < 10 ? Util.sleep(2000) : Util.sleep(5000));
-                        return await this._checkPublishStatus(statusUrl, key, tries + 1);
+                        return await this._checkPublishStatus(statusUrl, key, spinner, tries + 1);
                     } else {
                         return;
                     }
                 }
                 case 'Error': {
+                    spinner.success('failed.');
                     Util.logger.error(` - ${this.definition.type} ${key}: publishing failed.`);
                     this._showPublishStatusDetails(response);
                     return;
@@ -1907,7 +1928,7 @@ class Journey extends MetadataType {
         return stoppedKeyArr;
     }
     /**
-     * pauses all journey versions
+     * pauses selected journey versions
      *
      * @param {string[]} keyArr customerkey of the metadata
      * @returns {Promise.<string[]>} Returns list of keys that were paused

package/lib/metadataTypes/Role.js

@@ -73,41 +73,6 @@ class Role extends MetadataType {
         const results = await this.client.soap.retrieve('Role', fields, requestParams);
 
         const parsed = this.parseResponseBody(results);
-        if (!retrieveDir) {
-            // retrieve "Marketing Cloud%" roles not returned by SOAP API
-            const { roles, timeZones } = await this.client.rest.get(
-                '/platform/v1/setup/quickflow/data'
-            );
-            // this endpoint does not provide keys
-            const roleNameKeyMap = {
-                'Marketing Cloud Administrator': 'SYS_DEF_IMHADMIN',
-                'Marketing Cloud Channel Manager': 'SYS_DEF_CHANNELMANAGER',
-                'Marketing Cloud Content Editor/Publisher': 'SYS_DEF_CONTENTEDIT',
-                'Marketing Cloud Security Administrator': 'SYS_DEF_SECURITYADMIN',
-                'Marketing Cloud Viewer': 'SYS_DEF_VIEWER',
-            };
-            for (const role of roles) {
-                if (roleNameKeyMap[role.roleName]) {
-                    parsed[roleNameKeyMap[role.roleName]] = {
-                        CustomerKey: roleNameKeyMap[role.roleName],
-                        Name: role.roleName,
-                        ObjectID: role.roleID,
-                        Desscription: role.description,
-                        CreatedDate: '2012-02-21T02:09:19.983',
-                        IsSystemDefined: true,
-                        c__notAssignable: true,
-                    };
-                }
-            }
-            // the languages object is incomplete. the actual list is much longer --> ignoring it here
-            // convert timeZones to object
-            const timeZonesObj = {};
-            for (const timeZone of timeZones) {
-                timeZonesObj[timeZone.id] = timeZone;
-            }
-            // cache timeZones to share it with other type-classes
-            cache.setMetadata('_timezone', timeZonesObj);
-        }
         if (retrieveDir) {
             const savedMetadata = await super.saveResults(parsed, retrieveDir, null);
             Util.logger.info(
@@ -117,9 +82,56 @@ class Role extends MetadataType {
 
             await this.runDocumentOnRetrieve(key, savedMetadata);
         }
+
+        await this.cacheDefaultRolesAndTimezones(parsed);
+
         return { metadata: parsed, type: this.definition.type };
     }
 
+    /**
+     * adds default roles to the list of retrieved roles for proper caching (but not storing)
+     * also caches available timezones for retrieve-user
+     *
+     * @param {MetadataTypeMap} parsed list or previously retrieved items as reference
+     */
+    static async cacheDefaultRolesAndTimezones(parsed) {
+        // retrieve "Marketing Cloud%" roles not returned by SOAP API for cache (required by retrieve-user)
+        // also cache available timezones for retrieve-user
+        Util.logger.info(Util.getGrayMsg(' - Caching default roles and timezones'));
+        const { roles, timeZones } = await this.client.rest.get(
+            '/platform/v1/setup/quickflow/data'
+        );
+        // this endpoint does not provide keys
+        const roleNameKeyMap = {
+            'Marketing Cloud Administrator': 'SYS_DEF_IMHADMIN',
+            'Marketing Cloud Channel Manager': 'SYS_DEF_CHANNELMANAGER',
+            'Marketing Cloud Content Editor/Publisher': 'SYS_DEF_CONTENTEDIT',
+            'Marketing Cloud Security Administrator': 'SYS_DEF_SECURITYADMIN',
+            'Marketing Cloud Viewer': 'SYS_DEF_VIEWER',
+        };
+        for (const role of roles) {
+            if (roleNameKeyMap[role.roleName]) {
+                parsed[roleNameKeyMap[role.roleName]] = {
+                    CustomerKey: roleNameKeyMap[role.roleName],
+                    Name: role.roleName,
+                    ObjectID: role.roleID,
+                    Desscription: role.description,
+                    CreatedDate: '2012-02-21T02:09:19.983',
+                    IsSystemDefined: true,
+                    c__notAssignable: true,
+                };
+            }
+        }
+        // the languages object is incomplete. the actual list is much longer --> ignoring it here
+        // convert timeZones to object
+        const timeZonesObj = {};
+        for (const timeZone of timeZones) {
+            timeZonesObj[timeZone.id] = timeZone;
+        }
+        // cache timeZones to share it with other type-classes
+        cache.setMetadata('_timezone', timeZonesObj);
+    }
+
     /**
      * Gets executed before deploying metadata
      *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mcdev",
-    "version": "7.3.0",
+    "version": "7.3.1",
     "description": "Accenture Salesforce Marketing Cloud DevTools",
     "author": "Accenture: joern.berkefeld, douglas.midgley, robert.zimmermann, maciej.barnas",
     "license": "MIT",
@@ -59,6 +59,10 @@
         "lint-and-test": "run-s lint test",
         "test": "mocha --reporter-option maxDiffSize=25000",
         "coverage": "c8 npm run test",
+        "prepare-release:audit-fix": "npm audit fix",
+        "prepare-release:git-stage": "git add .",
+        "prepare-release:git-commit": "git commit -n -m \"prepare-release changes\"",
+        "prepare-release": "run-s prepare-release:audit-fix lint-ts lint:fix prepare-release:git-stage prepare-release:git-commit",
         "version:major": "npm version --no-commit-hooks major",
         "version:minor": "npm version --no-commit-hooks minor",
         "version:patch": "npm version --no-commit-hooks patch"
@@ -83,7 +87,8 @@
         "toposort": "2.0.2",
         "update-notifier": "7.2.0",
         "winston": "3.14.2",
-        "yargs": "17.7.2"
+        "yargs": "17.7.2",
+        "yocto-spinner": "0.1.0"
     },
     "devDependencies": {
         "@eslint/js": "9.9.0",

package/test/general.test.js

@@ -2067,7 +2067,10 @@ describe('GENERAL', () => {
         describe('Publish --metadata ~~~', () => {
             it('Should publish the journey', async () => {
                 handler.setOptions({ skipStatusCheck: true });
-                const argvMetadata = ['journey:id:3c3f4112-9b43-43ca-8a89-aa0375b2c1a2/1'];
+                const argvMetadata = [
+                    'journey:testExisting_journey_Multistep',
+                    'journey:testExisting_temail_notPublished',
+                ];
                 const typeKeyCombo = handler.metadataToTypeKey(argvMetadata);
                 // WHEN
                 const publish = await handler.publish('testInstance/testBU', typeKeyCombo);
@@ -2075,7 +2078,7 @@ describe('GENERAL', () => {
                 assert.equal(process.exitCode, 0, 'publish should not have thrown an error');
                 assert.deepEqual(
                     publish['testInstance/testBU']?.journey,
-                    ['testExisting_journey_Quicksend'],
+                    ['testExisting_journey_Multistep', 'testExisting_temail_notPublished'],
                     'should have published the right journey'
                 );
                 return;

package/test/mockRoot/.mcdevrc.json

@@ -100,5 +100,5 @@
             "verification"
         ]
     },
-    "version": "7.3.0"
+    "version": "7.3.1"
 }

package/test/type.journey.test.js

@@ -593,14 +593,14 @@ describe('type: journey', () => {
             const publish = await handler.publish(
                 'testInstance/testBU',
                 ['journey'],
-                ['testExisting_journey_Quicksend']
+                ['testExisting_journey_Multistep']
             );
             // THEN
             assert.equal(process.exitCode, 0, 'publish should not have thrown an error');
             // retrieve result
             assert.deepEqual(
                 publish['testInstance/testBU']?.journey,
-                ['testExisting_journey_Quicksend'],
+                ['testExisting_journey_Multistep'],
                 'should have published the right journey'
             );
 
@@ -630,14 +630,14 @@ describe('type: journey', () => {
             const publish = await handler.publish(
                 'testInstance/testBU',
                 ['journey'],
-                ['id:3c3f4112-9b43-43ca-8a89-aa0375b2c1a2/1']
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f/1']
             );
             // THEN
             assert.equal(process.exitCode, 0, 'publish should not have thrown an error');
             // retrieve result
             assert.deepEqual(
                 publish['testInstance/testBU']?.journey,
-                ['testExisting_journey_Quicksend'],
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f/1'],
                 'should have published the right journey'
             );
 
@@ -666,14 +666,14 @@ describe('type: journey', () => {
             const publish = await handler.publish(
                 'testInstance/testBU',
                 ['journey'],
-                ['id:3c3f4112-9b43-43ca-8a89-aa0375b2c1a2']
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f']
             );
             // THEN
             assert.equal(process.exitCode, 0, 'publish should not have thrown an error');
             // retrieve result
             assert.deepEqual(
                 publish['testInstance/testBU']?.journey,
-                ['testExisting_journey_Quicksend'],
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f'],
                 'should have published the right journey'
             );
 
@@ -708,7 +708,7 @@ describe('type: journey', () => {
             const publish = await handler.publish(
                 'testInstance/testBU',
                 ['journey'],
-                ['id:3c3f4112-9b43-43ca-8a89-aa0375b2c1a2/1']
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f/1']
             );
             // THEN
             assert.equal(process.exitCode, 1, 'publish should have thrown an error');
@@ -750,14 +750,14 @@ describe('type: journey', () => {
             const publish = await handler.publish(
                 'testInstance/testBU',
                 ['journey'],
-                ['id:3c3f4112-9b43-43ca-8a89-aa0375b2c1a2/1']
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f/1']
             );
             // THEN
             assert.equal(process.exitCode, 0, 'publish should not have thrown an error');
             // retrieve result
             assert.deepEqual(
                 publish['testInstance/testBU']?.journey,
-                ['id:3c3f4112-9b43-43ca-8a89-aa0375b2c1a2/1'],
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f/1'],
                 'should have published the journey'
             );
 
@@ -792,14 +792,14 @@ describe('type: journey', () => {
             const publish = await handler.publish(
                 'testInstance/testBU',
                 ['journey'],
-                ['id:3c3f4112-9b43-43ca-8a89-aa0375b2c1a2/1']
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f/1']
             );
             // THEN
             assert.equal(process.exitCode, 0, 'publish should not have thrown an error');
             // retrieve result
             assert.deepEqual(
                 publish['testInstance/testBU']?.journey,
-                ['id:3c3f4112-9b43-43ca-8a89-aa0375b2c1a2/1'],
+                ['id:0175b971-71a3-4d8e-98ac-48121f3fbf4f/1'],
                 'should have published the journey'
             );