mcdev 5.0.1 → 5.0.2

package/.eslintrc.json

@@ -84,6 +84,7 @@
                 }
             }
         ],
+        "jsdoc/tag-lines": ["warn", "any", { "startLines": 1 }],
         "spaced-comment": ["warn", "always", { "block": { "exceptions": ["*"], "balanced": true } }]
     },
     "overrides": [

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:
+              - 5.0.2
               - 5.0.1
               - 5.0.0
               - 4.3.4

package/.husky/commit-msg

@@ -2,7 +2,7 @@
 . "$(dirname "$0")/_/husky.sh"
 INPUT_FILE=$1
 START_LINE=`head -n1 $INPUT_FILE`
-PATTERN="^(#[[:digit:]]|Merge)"
+PATTERN="^(#[[:digit:]]|Merge|Revert)"
 
 if ! [[ "$START_LINE" =~ $PATTERN ]] ; then
   echo "Bad commit message, see example: \"#431 commit message\", you provided: \"$START_LINE\""

package/.husky/post-checkout

@@ -1,5 +1,36 @@
 #!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+# ### git commit message template ###
 git config commit.template .git/templatemessage
-TICKETID=`git rev-parse --abbrev-ref HEAD | LC_ALL=en_US.utf8 grep -oP '((feature|bug|bugfix|fix|hotfix|task|chore)\/)\K\d{1,7}'`
-echo "[POST_CHECKOUT] Setting template commit to $TICKETID"
-echo "#$TICKETID: " > ".git/templatemessage"
+TICKETID=`git rev-parse --abbrev-ref HEAD | LC_ALL=en_US.utf8 grep -oP '^((feature|bug|bugfix|fix|hotfix|task|chore)\/)?\K\d{1,7}' || true`
+if [ -z "$TICKETID" ]
+then
+  TICKETID="0"
+fi
+TEMPLATE="#$TICKETID: "
+echo "[POST_CHECKOUT] Setting template commit to '$TEMPLATE'"
+echo $TEMPLATE > ".git/templatemessage"
+
+
+# ### run npm install ###
+echo "[POST-CHECKOUT] 📦 Checking for changes to dependencies"
+# define how to split strings into array elements
+IFS=$'\n'
+# $1 is the new HEAD pointer
+NEWHEAD=$1
+# $2 is the previous HEAD pointer
+OLDHEAD=$2
+# extract all paths to package-lock.json files 
+PACKAGE_LOCK_REGEX="(^package-lock\.json)"
+PACKAGES=$(git diff --name-only $NEWHEAD $OLDHEAD | grep -E $PACKAGE_LOCK_REGEX || true)
+
+if [[ ${PACKAGES[@]} ]]; then
+  for package in $PACKAGES; do
+    echo "📦 $package was changed."
+  done
+  echo "📦 Running npm install to update your dependencies..."
+  npm install
+else
+  echo "📦 All packages up-to-date. No need to run npm install."
+fi

package/.husky/post-merge

@@ -0,0 +1,21 @@
+#!/bin/sh
+# ### run npm install ###
+. "$(dirname "$0")/_/husky.sh"
+
+
+echo "[POST-MERGE] 📦 Checking for changes to dependencies"
+
+IFS=$'\n'
+# extract all paths to package-lock.json files 
+PACKAGE_LOCK_REGEX="(^package-lock\.json)"
+PACKAGES=$(git diff --name-only HEAD^1 HEAD | grep -E $PACKAGE_LOCK_REGEX || true)
+
+if [[ ${PACKAGES[@]} ]]; then
+  for package in $PACKAGES; do
+    echo "📦 $package was changed."
+  done
+  echo "📦 Running npm install to update your dependencies..."
+  npm install
+else
+  echo "📦 All packages up-to-date. No need to run npm install."
+fi

package/.husky/pre-commit

@@ -1,5 +1,6 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
+
 npm run docs
 git update-index --add docs/dist/documentation.md
 npx --no lint-staged

package/docs/dist/documentation.md

@@ -1212,7 +1212,7 @@ Automation MetadataType
     * [.update(metadata, metadataBefore)](#Automation.update) ⇒ <code>Promise</code>
     * [.preDeployTasks(metadata)](#Automation.preDeployTasks) ⇒ <code>Promise.&lt;TYPE.AutomationItem&gt;</code>
     * [.validateDeployMetadata(metadata)](#Automation.validateDeployMetadata) ⇒ <code>boolean</code>
-    * [.postDeployTasks(metadata, originalMetadata)](#Automation.postDeployTasks) ⇒ <code>Promise.&lt;void&gt;</code>
+    * [.postDeployTasks(metadataMap, originalMetadataMap)](#Automation.postDeployTasks) ⇒ <code>Promise.&lt;void&gt;</code>
     * [.setFolderPath(metadata)](#Automation.setFolderPath)
     * [.setFolderId(metadata)](#Automation.setFolderId)
     * [.parseMetadata(metadata)](#Automation.parseMetadata) ⇒ <code>TYPE.AutomationItem</code> \| <code>void</code>
@@ -1345,7 +1345,7 @@ Whitelisted Activites are deployed but require configuration
 
 <a name="Automation.postDeployTasks"></a>
 
-### Automation.postDeployTasks(metadata, originalMetadata) ⇒ <code>Promise.&lt;void&gt;</code>
+### Automation.postDeployTasks(metadataMap, originalMetadataMap) ⇒ <code>Promise.&lt;void&gt;</code>
 Gets executed after deployment of metadata type
 
 **Kind**: static method of [<code>Automation</code>](#Automation)  
@@ -1353,8 +1353,8 @@ Gets executed after deployment of metadata type
 
 | Param | Type | Description |
 | --- | --- | --- |
-| metadata | <code>TYPE.AutomationMap</code> | metadata mapped by their keyField |
-| originalMetadata | <code>TYPE.AutomationMap</code> | metadata to be updated (contains additioanl fields) |
+| metadataMap | <code>TYPE.AutomationMap</code> | metadata mapped by their keyField |
+| originalMetadataMap | <code>TYPE.AutomationMap</code> | metadata to be updated (contains additioanl fields) |
 
 <a name="Automation.setFolderPath"></a>
 
@@ -3167,6 +3167,7 @@ Provides default functionality that can be overwritten by child metadata type cl
     * [.getSOAPErrorMsg(ex)](#MetadataType.getSOAPErrorMsg) ⇒ <code>string</code>
     * [.retrieveSOAP(retrieveDir, [requestParams], [singleRetrieve], [additionalFields])](#MetadataType.retrieveSOAP) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
     * [.retrieveREST(retrieveDir, uri, [templateVariables], [singleRetrieve])](#MetadataType.retrieveREST) ⇒ <code>Promise.&lt;{metadata: (TYPE.MetadataTypeMap\|TYPE.MetadataTypeItem), type: string}&gt;</code>
+    * [.runDocumentOnRetrieve([singleRetrieve], metadataMap)](#MetadataType.runDocumentOnRetrieve) ⇒ <code>Promise.&lt;void&gt;</code>
     * [.parseResponseBody(body, [singleRetrieve])](#MetadataType.parseResponseBody) ⇒ <code>TYPE.MetadataTypeMap</code>
     * [.deleteFieldByDefinition(metadataEntry, fieldPath, definitionProperty, origin)](#MetadataType.deleteFieldByDefinition) ⇒ <code>void</code>
     * [.removeNotCreateableFields(metadataEntry)](#MetadataType.removeNotCreateableFields) ⇒ <code>void</code>
@@ -3632,6 +3633,19 @@ Retrieves Metadata for Rest Types
 | [templateVariables] | <code>TYPE.TemplateMap</code> | variables to be replaced in the metadata |
 | [singleRetrieve] | <code>string</code> \| <code>number</code> | key of single item to filter by |
 
+<a name="MetadataType.runDocumentOnRetrieve"></a>
+
+### MetadataType.runDocumentOnRetrieve([singleRetrieve], metadataMap) ⇒ <code>Promise.&lt;void&gt;</code>
+helper for [retrieveREST](retrieveREST) and [retrieveSOAP](retrieveSOAP)
+
+**Kind**: static method of [<code>MetadataType</code>](#MetadataType)  
+**Returns**: <code>Promise.&lt;void&gt;</code> - -  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| [singleRetrieve] | <code>string</code> \| <code>number</code> | key of single item to filter by |
+| metadataMap | <code>TYPE.MetadataTypeMap</code> | saved metadata |
+
 <a name="MetadataType.parseResponseBody"></a>
 
 ### MetadataType.parseResponseBody(body, [singleRetrieve]) ⇒ <code>TYPE.MetadataTypeMap</code>
@@ -4006,11 +4020,13 @@ MobileKeyword MetadataType
 
 * [MobileKeyword](#MobileKeyword) ⇐ [<code>MetadataType</code>](#MetadataType)
     * [.retrieve(retrieveDir, [_], [__], [key])](#MobileKeyword.retrieve) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code> \| <code>void</code>
+    * [.parseResponseBody(body, [singleRetrieve])](#MobileKeyword.parseResponseBody) ⇒ <code>TYPE.MetadataTypeMap</code>
+    * [.createOrUpdate(metadataMap, metadataKey, hasError, metadataToUpdate, metadataToCreate)](#MobileKeyword.createOrUpdate) ⇒ <code>&#x27;create&#x27;</code> \| <code>&#x27;update&#x27;</code> \| <code>&#x27;skip&#x27;</code>
     * [.retrieveForCache(_, __, [key])](#MobileKeyword.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
-    * [.retrieveAsTemplate(templateDir, name, templateVariables)](#MobileKeyword.retrieveAsTemplate) ⇒ <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code>
-    * [.create(MobileKeyword)](#MobileKeyword.create) ⇒ <code>Promise</code>
+    * [.retrieveAsTemplate(templateDir, key, templateVariables)](#MobileKeyword.retrieveAsTemplate) ⇒ <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code>
+    * [.create(metadata)](#MobileKeyword.create) ⇒ <code>Promise</code>
     * [.update(metadata)](#MobileKeyword.update) ⇒ <code>Promise</code>
-    * [.postRetrieveTasks(metadata)](#MobileKeyword.postRetrieveTasks) ⇒ <code>TYPE.CodeExtractItem</code> \| <code>TYPE.MetadataTypeItem</code>
+    * [.postRetrieveTasks(metadata)](#MobileKeyword.postRetrieveTasks) ⇒ <code>TYPE.CodeExtractItem</code> \| <code>TYPE.MetadataTypeItem</code> \| <code>void</code>
     * [.prepExtractedCode(metadataScript)](#MobileKeyword.prepExtractedCode) ⇒ <code>Object</code>
     * [.buildDefinitionForNested(templateDir, targetDir, metadata, templateVariables, templateName)](#MobileKeyword.buildDefinitionForNested) ⇒ <code>Promise.&lt;Array.&lt;Array.&lt;string&gt;&gt;&gt;</code>
     * [.buildTemplateForNested(templateDir, targetDir, metadata, templateVariables, templateName)](#MobileKeyword.buildTemplateForNested) ⇒ <code>Promise.&lt;Array.&lt;Array.&lt;string&gt;&gt;&gt;</code>
@@ -4039,6 +4055,35 @@ Endpoint /legacy/v1/beta/mobile/keyword/ return all Mobile Keywords with all det
 | [__] | <code>void</code> | unused parameter |
 | [key] | <code>string</code> | customer key of single item to retrieve |
 
+<a name="MobileKeyword.parseResponseBody"></a>
+
+### MobileKeyword.parseResponseBody(body, [singleRetrieve]) ⇒ <code>TYPE.MetadataTypeMap</code>
+Builds map of metadata entries mapped to their keyfields
+
+**Kind**: static method of [<code>MobileKeyword</code>](#MobileKeyword)  
+**Returns**: <code>TYPE.MetadataTypeMap</code> - keyField => metadata map  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| body | <code>object</code> | json of response body |
+| [singleRetrieve] | <code>string</code> \| <code>number</code> | key of single item to filter by |
+
+<a name="MobileKeyword.createOrUpdate"></a>
+
+### MobileKeyword.createOrUpdate(metadataMap, metadataKey, hasError, metadataToUpdate, metadataToCreate) ⇒ <code>&#x27;create&#x27;</code> \| <code>&#x27;update&#x27;</code> \| <code>&#x27;skip&#x27;</code>
+helper for [upsert](#MetadataType.upsert)
+
+**Kind**: static method of [<code>MobileKeyword</code>](#MobileKeyword)  
+**Returns**: <code>&#x27;create&#x27;</code> \| <code>&#x27;update&#x27;</code> \| <code>&#x27;skip&#x27;</code> - action to take  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| metadataMap | <code>TYPE.MetadataTypeMap</code> | list of metadata |
+| metadataKey | <code>string</code> | key of item we are looking at |
+| hasError | <code>boolean</code> | error flag from previous code |
+| metadataToUpdate | <code>Array.&lt;TYPE.MetadataTypeItemDiff&gt;</code> | list of items to update |
+| metadataToCreate | <code>Array.&lt;TYPE.MetadataTypeItem&gt;</code> | list of items to create |
+
 <a name="MobileKeyword.retrieveForCache"></a>
 
 ### MobileKeyword.retrieveForCache(_, __, [key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
@@ -4055,8 +4100,8 @@ Retrieves event definition metadata for caching
 
 <a name="MobileKeyword.retrieveAsTemplate"></a>
 
-### MobileKeyword.retrieveAsTemplate(templateDir, name, templateVariables) ⇒ <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code>
-Retrieve a specific keyword
+### MobileKeyword.retrieveAsTemplate(templateDir, key, templateVariables) ⇒ <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code>
+retrieve an item and create a template from it
 
 **Kind**: static method of [<code>MobileKeyword</code>](#MobileKeyword)  
 **Returns**: <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code> - Promise of metadata  
@@ -4064,20 +4109,20 @@ Retrieve a specific keyword
 | Param | Type | Description |
 | --- | --- | --- |
 | templateDir | <code>string</code> | Directory where retrieved metadata directory will be saved |
-| name | <code>string</code> | name of the metadata file |
+| key | <code>string</code> | name of the metadata file |
 | templateVariables | <code>TYPE.TemplateMap</code> | variables to be replaced in the metadata |
 
 <a name="MobileKeyword.create"></a>
 
-### MobileKeyword.create(MobileKeyword) ⇒ <code>Promise</code>
-Creates a single Event Definition
+### MobileKeyword.create(metadata) ⇒ <code>Promise</code>
+Creates a single item
 
 **Kind**: static method of [<code>MobileKeyword</code>](#MobileKeyword)  
 **Returns**: <code>Promise</code> - Promise  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| MobileKeyword | <code>TYPE.MetadataTypeItem</code> | a single Event Definition |
+| metadata | <code>TYPE.MetadataTypeItem</code> | a single item |
 
 <a name="MobileKeyword.update"></a>
 
@@ -4093,11 +4138,11 @@ Updates a single item
 
 <a name="MobileKeyword.postRetrieveTasks"></a>
 
-### MobileKeyword.postRetrieveTasks(metadata) ⇒ <code>TYPE.CodeExtractItem</code> \| <code>TYPE.MetadataTypeItem</code>
+### MobileKeyword.postRetrieveTasks(metadata) ⇒ <code>TYPE.CodeExtractItem</code> \| <code>TYPE.MetadataTypeItem</code> \| <code>void</code>
 manages post retrieve steps
 
 **Kind**: static method of [<code>MobileKeyword</code>](#MobileKeyword)  
-**Returns**: <code>TYPE.CodeExtractItem</code> \| <code>TYPE.MetadataTypeItem</code> - Array with one metadata object and one ssjs string  
+**Returns**: <code>TYPE.CodeExtractItem</code> \| <code>TYPE.MetadataTypeItem</code> \| <code>void</code> - Array with one metadata object and one ssjs string; or single metadata object; nothing if filtered  
 
 | Param | Type | Description |
 | --- | --- | --- |

package/lib/Deployer.js

@@ -18,7 +18,6 @@ class Deployer {
     /**
      * Creates a Deployer, uses v2 auth if v2AuthOptions are passed.
      *
-     *
      * @param {TYPE.Mcdevrc} properties General configuration to be used in retrieve
      * @param {TYPE.BuObject} buObject properties for auth
      */

package/lib/cli.js

@@ -240,7 +240,7 @@ yargs
         },
     })
     .command({
-        command: 'buildDefinition <BU> <TYPE> <NAME> <MARKET>',
+        command: 'buildDefinition <BU> <TYPE> <FILENAME> <MARKET>',
         aliases: ['bd'],
         desc: 'builds metadata definition based on template',
         builder: (yargs) => {
@@ -253,9 +253,9 @@ yargs
                     type: 'string',
                     describe: 'metadata type',
                 })
-                .positional('NAME', {
+                .positional('FILENAME', {
                     type: 'string',
-                    describe: 'name of the metadata component',
+                    describe: 'File name of the metadata template without the extension',
                 })
                 .positional('MARKET', {
                     type: 'string',
@@ -264,11 +264,11 @@ yargs
         },
         handler: (argv) => {
             Mcdev.setOptions(argv);
-            Mcdev.buildDefinition(argv.BU, argv.TYPE, argv.NAME, argv.MARKET);
+            Mcdev.buildDefinition(argv.BU, argv.TYPE, argv.FILENAME, argv.MARKET);
         },
     })
     .command({
-        command: 'buildDefinitionBulk <LISTNAME> <TYPE> <NAME>',
+        command: 'buildDefinitionBulk <LISTNAME> <TYPE> <FILENAME>',
         aliases: ['bdb'],
         desc: 'builds metadata definition based on template en bulk',
         builder: (yargs) => {
@@ -281,14 +281,14 @@ yargs
                     type: 'string',
                     describe: 'metadata type',
                 })
-                .positional('NAME', {
+                .positional('FILENAME', {
                     type: 'string',
-                    describe: 'name of the metadata component',
+                    describe: 'File name of the metadata template without the extension',
                 });
         },
         handler: (argv) => {
             Mcdev.setOptions(argv);
-            Mcdev.buildDefinitionBulk(argv.LISTNAME, argv.TYPE, argv.NAME);
+            Mcdev.buildDefinitionBulk(argv.LISTNAME, argv.TYPE, argv.FILENAME);
         },
     })
     .command({

package/lib/index.js

@@ -256,11 +256,12 @@ class Mcdev {
             cred = buObject.credential;
             bu = buObject.businessUnit;
             // clean up old folders after types were renamed
-            // TODO: Remove this with version 5.0.0
+            // TODO: Remove renamedTypes-logic 6 months after version 5 release
             const renamedTypes = {
                 emailSend: 'emailSendDefinition',
                 event: 'eventDefinition',
                 fileLocation: 'ftpLocation',
+                journey: 'interaction',
                 triggeredSend: 'triggeredSendDefinition',
                 user: 'accountUser',
             };

package/lib/metadataTypes/Asset.js

@@ -26,7 +26,9 @@ class Asset extends MetadataType {
     static async retrieve(retrieveDir, _, subTypeArr, key) {
         const items = [];
         subTypeArr ||= this._getSubTypes();
-        await File.initPrettier();
+        if (retrieveDir) {
+            await File.initPrettier();
+        }
         // loop through subtypes and return results of each subType for caching (saving is handled per subtype)
         for (const subType of subTypeArr) {
             // each subtype contains multiple different specific types (images contains jpg and png for example)
@@ -235,7 +237,7 @@ class Asset extends MetadataType {
                     rightOperand: {
                         property: 'id',
                         simpleOperator: 'greaterThan',
-                        value: items[items.length - 1].id,
+                        value: items.at(-1).id,
                     },
                 };
                 lastPage = 0;

package/lib/metadataTypes/Automation.js

@@ -70,18 +70,18 @@ class Automation extends MetadataType {
                   })
               )
             : [];
-        const parsed = this.parseResponseBody({ items: details });
+        let metadataMap = this.parseResponseBody({ items: details });
+        // * retrieveDir can be empty when we use it in the context of postDeployTasks
+        if (retrieveDir) {
+            metadataMap = await this.saveResults(metadataMap, retrieveDir, null, null);
+            Util.logger.info(
+                `Downloaded: ${this.definition.type} (${Object.keys(metadataMap).length})` +
+                    Util.getKeysString(key)
+            );
 
-        // * retrieveDir is mandatory in this method as it is not used for caching (there is a seperate method for that)
-        const savedMetadata = await this.saveResults(parsed, retrieveDir, null, null);
-        Util.logger.info(
-            `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
-                Util.getKeysString(key)
-        );
-        if (this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)) {
-            await this.document(savedMetadata);
+            await this.runDocumentOnRetrieve(key, metadataMap);
         }
-        return { metadata: savedMetadata, type: this.definition.type };
+        return { metadata: metadataMap, type: this.definition.type };
     }
     /**
      * Retrieves Metadata of Automation
@@ -397,23 +397,23 @@ class Automation extends MetadataType {
     /**
      * Gets executed after deployment of metadata type
      *
-     * @param {TYPE.AutomationMap} metadata metadata mapped by their keyField
-     * @param {TYPE.AutomationMap} originalMetadata metadata to be updated (contains additioanl fields)
+     * @param {TYPE.AutomationMap} metadataMap metadata mapped by their keyField
+     * @param {TYPE.AutomationMap} originalMetadataMap metadata to be updated (contains additioanl fields)
      * @returns {Promise.<void>} -
      */
-    static async postDeployTasks(metadata, originalMetadata) {
-        for (const key in metadata) {
+    static async postDeployTasks(metadataMap, originalMetadataMap) {
+        for (const key in metadataMap) {
             // need to put schedule on here if status is scheduled
 
-            if (originalMetadata[key]?.type === 'scheduled') {
+            if (originalMetadataMap[key]?.type === 'scheduled') {
                 // Starting Source == 'Schedule': Try starting the automation
-                if (originalMetadata[key].status === 'Scheduled') {
+                if (originalMetadataMap[key].status === 'Scheduled') {
                     let schedule = null;
                     try {
-                        schedule = this._buildSchedule(originalMetadata[key].schedule);
+                        schedule = this._buildSchedule(originalMetadataMap[key].schedule);
                     } catch (ex) {
                         Util.logger.error(
-                            `- Could not create schedule for automation ${originalMetadata[key].name} to start it: ${ex.message}`
+                            `- Could not create schedule for automation ${originalMetadataMap[key].name} to start it: ${ex.message}`
                         );
                     }
                     if (schedule !== null) {
@@ -431,7 +431,7 @@ class Automation extends MetadataType {
                                 schedule,
                                 {
                                     Interaction: {
-                                        ObjectID: metadata[key].id,
+                                        ObjectID: metadataMap[key].id,
                                     },
                                 },
                                 'start',
@@ -445,31 +445,42 @@ class Automation extends MetadataType {
                                       (schedule_interval > 1 ? 's' : ''));
                             Util.logger.warn(
                                 ` - scheduled automation '${
-                                    originalMetadata[key].name
+                                    originalMetadataMap[key].name
                                 }' deployed Active: runs every ${intervalString} starting ${
                                     schedule_StartDateTime.split('T').join(' ').split('.')[0]
                                 } ${schedule_timezoneString}`
                             );
                         } catch (ex) {
                             Util.logger.error(
-                                `- Could not start scheduled automation '${originalMetadata[key].name}': ${ex.message}`
+                                `- Could not start scheduled automation '${originalMetadataMap[key].name}': ${ex.message}`
                             );
                         }
                     }
                 } else {
                     Util.logger.warn(
-                        ` - scheduled automation '${originalMetadata[key].name}' deployed Paused`
+                        ` - scheduled automation '${originalMetadataMap[key].name}' deployed Paused`
                     );
                 }
             }
-            if (metadata[key].startSource) {
-                metadata[key].schedule = metadata[key].startSource.schedule;
+            if (metadataMap[key].startSource) {
+                metadataMap[key].schedule = metadataMap[key].startSource.schedule;
 
-                delete metadata[key].startSource;
+                delete metadataMap[key].startSource;
             }
-            if (metadata[key].schedule) {
-                metadata[key].schedule.typeId = metadata[key].schedule.scheduleTypeId;
-                delete metadata[key].schedule.scheduleTypeId;
+            if (metadataMap[key].schedule) {
+                metadataMap[key].schedule.typeId = metadataMap[key].schedule.scheduleTypeId;
+                delete metadataMap[key].schedule.scheduleTypeId;
+            }
+
+            // re-retrieve deployed items because the API does not return any info for them except the new id (api key)
+            try {
+                const { metadata } = await this.retrieve(null, null, null, key);
+                metadataMap[key] = Object.values(metadata)[0];
+                // postRetrieveTasks will be run automatically on this via super.saveResult
+            } catch (ex) {
+                throw new Error(
+                    `Could not get details for new ${this.definition.type} ${key} from server (${ex.message})`
+                );
             }
         }
     }

package/lib/metadataTypes/DataExtension.js

@@ -464,9 +464,7 @@ class DataExtension extends MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
                     Util.getKeysString(key)
             );
-            if (this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)) {
-                await this.document(savedMetadata);
-            }
+            await this.runDocumentOnRetrieve(key, savedMetadata);
         }
         return { metadata: metadata, type: 'dataExtension' };
     }

package/lib/metadataTypes/DataExtensionField.js

@@ -170,11 +170,11 @@ class DataExtensionField extends MetadataType {
 
                 // enable renaming
                 if (item.Name_new) {
+                    Util.logger.info(
+                        ` - Found Name_new='${item.Name_new}' for field ${deKey}.${item.Name} - trying to rename.`
+                    );
                     item.Name = item.Name_new;
                     delete item.Name_new;
-                    Util.logger.warn(
-                        ` - Found 'Name_new' value '${item.Name_new}' for ${deKey}.${item.Name} - trying to rename.`
-                    );
                 }
 
                 // check if any changes were found
@@ -210,8 +210,8 @@ class DataExtensionField extends MetadataType {
                     }
                 }
                 if (item.Name_new) {
-                    Util.logger.warn(
-                        ` - Found 'Name_new' value '${item.Name_new}' for ${deKey}.${item.Name} but could not find a corresponding DE field on the server - adding new field instead of updating.`
+                    Util.logger.info(
+                        ` - Found Name_new='${item.Name_new}' for field ${deKey}.${item.Name} but could not find a corresponding DE field on the server - adding new field instead of updating.`
                     );
                     delete item.Name_new;
                 }

package/lib/metadataTypes/Journey.js

@@ -542,12 +542,13 @@ class Journey extends MetadataType {
                     try {
                         // mobileKeyword
                         if (activity.configurationArguments?.keywordId) {
-                            activity.configurationArguments.c__mobileKeyword = cache.searchForField(
-                                'mobileKeyword',
-                                activity.configurationArguments.keywordId,
-                                'id',
-                                'keyword'
-                            );
+                            activity.configurationArguments.r__mobileKeyword_codeKeyword =
+                                cache.searchForField(
+                                    'mobileKeyword',
+                                    activity.configurationArguments.keywordId,
+                                    'id',
+                                    'c__codeKeyword'
+                                );
                             delete activity.configurationArguments.keywordId;
                         }
                     } catch (ex) {
@@ -833,14 +834,14 @@ class Journey extends MetadataType {
                         delete activity.configurationArguments.c__mobileMessage_id;
                     }
                     // mobileKeyword
-                    if (activity.configurationArguments?.c__mobileKeyword) {
+                    if (activity.configurationArguments?.r__mobileKeyword_codeKeyword) {
                         activity.configurationArguments.keywordId = cache.searchForField(
                             'mobileKeyword',
-                            activity.c__mobileKeyword,
-                            'keyword',
+                            activity.r__mobileKeyword_codeKeyword,
+                            'c__codeKeyword',
                             'id'
                         );
-                        delete activity.configurationArguments.c__mobileKeyword;
+                        delete activity.configurationArguments.r__mobileKeyword_codeKeyword;
                     }
                     if (activity.configurationArguments?.c__next_mobileKeyword) {
                         activity.configurationArguments.nextKeywordId = cache.searchForField(

package/lib/metadataTypes/MetadataType.js

@@ -1016,12 +1016,7 @@ class MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
                     Util.getKeysString(singleRetrieve)
             );
-            if (
-                this.buObject &&
-                this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)
-            ) {
-                await this.document(savedMetadata);
-            }
+            await this.runDocumentOnRetrieve(singleRetrieve, savedMetadata);
         }
         return { metadata: metadata, type: this.definition.type };
     }
@@ -1063,6 +1058,7 @@ class MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
                     Util.getKeysString(singleRetrieve)
             );
+            await this.runDocumentOnRetrieve(singleRetrieve, savedMetadata);
         }
 
         return {
@@ -1071,6 +1067,34 @@ class MetadataType {
         };
     }
 
+    /**
+     * helper for {@link retrieveREST} and {@link retrieveSOAP}
+     *
+     * @param {string|number} [singleRetrieve] key of single item to filter by
+     * @param {TYPE.MetadataTypeMap} metadataMap saved metadata
+     * @returns {Promise.<void>} -
+     */
+    static async runDocumentOnRetrieve(singleRetrieve, metadataMap) {
+        if (
+            this.buObject &&
+            this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)
+        ) {
+            if (!singleRetrieve || (singleRetrieve && !this.definition.documentInOneFile)) {
+                const count = Object.keys(metadataMap).length;
+                Util.logger.debug(
+                    ` - Running document for ${count} record${count === 1 ? '' : 's'}`
+                );
+                await this.document(metadataMap);
+            } else {
+                Util.logger.info(
+                    Util.getGrayMsg(
+                        ` - Skipped running document because you supplied keys and ${this.definition.type} is documented in a single file for all.`
+                    )
+                );
+            }
+        }
+    }
+
     /**
      * Builds map of metadata entries mapped to their keyfields
      *
@@ -1528,7 +1552,10 @@ class MetadataType {
                 // so its in retrieve but not in save. Here we put into the clone so that the original
                 // object used for caching doesnt have the Id removed.
                 const saveClone = JSON.parse(JSON.stringify(results[originalKey]));
-                if (!this.definition.keepId) {
+                if (
+                    !this.definition.keepId &&
+                    this.definition.idField !== this.definition.keyField
+                ) {
                     delete saveClone[this.definition.idField];
                 }