Merge pull request #1191 from Accenture/bugfix/1189-blank-file-behavi…

…or-not-retrieved-for-importfile-activity Bugfix/1189 blank file behavior not retrieved for importfile activity
Accenture · Jan 26, 2024 · bc0261e · bc0261e
2 parents f309eff + 790bf7f
commit bc0261e
Show file tree

Hide file tree

Showing 22 changed files with 346 additions and 88 deletions.
diff --git a/docs/dist/documentation.md b/docs/dist/documentation.md
@@ -866,7 +866,7 @@ FileTransfer MetadataType
 
 * [Asset](#Asset) ⇐ [<code>MetadataType</code>](#MetadataType)
     * [.retrieve(retrieveDir, _, [subTypeArr], [key])](#Asset.retrieve) ⇒ <code>Promise.&lt;{metadata: TYPE.AssetMap, type: string}&gt;</code>
-    * [.retrieveForCache(_, [subTypeArr])](#Asset.retrieveForCache) ⇒ <code>Promise.&lt;{metadata: TYPE.AssetMap, type: string}&gt;</code>
+    * [.retrieveForCache([_], [subTypeArr])](#Asset.retrieveForCache) ⇒ <code>Promise.&lt;{metadata: TYPE.AssetMap, type: string}&gt;</code>
     * [.retrieveAsTemplate(templateDir, name, templateVariables, [selectedSubType])](#Asset.retrieveAsTemplate) ⇒ <code>Promise.&lt;{metadata: TYPE.AssetItem, type: string}&gt;</code>
     * [.create(metadata)](#Asset.create) ⇒ <code>Promise</code>
     * [.update(metadata)](#Asset.update) ⇒ <code>Promise</code>
@@ -909,15 +909,15 @@ Retrieves Metadata of Asset
 
 <a name="Asset.retrieveForCache"></a>
 
-### Asset.retrieveForCache(_, [subTypeArr]) ⇒ <code>Promise.&lt;{metadata: TYPE.AssetMap, type: string}&gt;</code>
+### Asset.retrieveForCache([_], [subTypeArr]) ⇒ <code>Promise.&lt;{metadata: TYPE.AssetMap, type: string}&gt;</code>
 Retrieves asset metadata for caching
 
 **Kind**: static method of [<code>Asset</code>](#Asset)  
 **Returns**: <code>Promise.&lt;{metadata: TYPE.AssetMap, type: string}&gt;</code> - Promise  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| _ | <code>void</code> | unused |
+| [_] | <code>void</code> | parameter not used |
 | [subTypeArr] | <code>Array.&lt;string&gt;</code> | optionally limit to a single subtype |
 
 <a name="Asset.retrieveAsTemplate"></a>
@@ -2877,7 +2877,7 @@ Folder MetadataType
 
 * [Folder](#Folder) ⇐ [<code>MetadataType</code>](#MetadataType)
     * [.retrieve(retrieveDir, [additionalFields], [subTypeArr], [key])](#Folder.retrieve) ⇒ <code>Promise</code>
-    * [.retrieveForCache(_, [subTypeArr])](#Folder.retrieveForCache) ⇒ <code>Promise</code>
+    * [.retrieveForCache([_], [subTypeArr])](#Folder.retrieveForCache) ⇒ <code>Promise</code>
     * [.upsert(metadata)](#Folder.upsert) ⇒ <code>Promise.&lt;object&gt;</code>
     * [.create(metadataEntry)](#Folder.create) ⇒ <code>Promise</code>
     * [.update(metadataEntry)](#Folder.update) ⇒ <code>Promise</code>
@@ -2904,15 +2904,15 @@ Retrieves metadata of metadata type into local filesystem. executes callback wit
 
 <a name="Folder.retrieveForCache"></a>
 
-### Folder.retrieveForCache(_, [subTypeArr]) ⇒ <code>Promise</code>
+### Folder.retrieveForCache([_], [subTypeArr]) ⇒ <code>Promise</code>
 Retrieves folder metadata for caching
 
 **Kind**: static method of [<code>Folder</code>](#Folder)  
 **Returns**: <code>Promise</code> - Promise  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| _ | <code>void</code> | unused |
+| [_] | <code>void</code> | parameter not used |
 | [subTypeArr] | <code>Array.&lt;string&gt;</code> | content type of folder |
 
 <a name="Folder.upsert"></a>
@@ -3028,13 +3028,14 @@ ImportFile MetadataType
 
 * [ImportFile](#ImportFile) ⇐ [<code>MetadataType</code>](#MetadataType)
     * [.retrieve(retrieveDir, [_], [__], [key])](#ImportFile.retrieve) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
-    * [.retrieveForCache()](#ImportFile.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+    * [.retrieveForCache([_], [__], [key])](#ImportFile.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
     * [.retrieveAsTemplate(templateDir, name, templateVariables)](#ImportFile.retrieveAsTemplate) ⇒ <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code>
     * [.postRetrieveTasks(importDef)](#ImportFile.postRetrieveTasks) ⇒ <code>TYPE.MetadataTypeItem</code>
     * [.create(importFile)](#ImportFile.create) ⇒ <code>Promise</code>
     * [.update(importFile)](#ImportFile.update) ⇒ <code>Promise</code>
     * [.preDeployTasks(metadata)](#ImportFile.preDeployTasks) ⇒ <code>Promise</code>
     * [.parseMetadata(metadata)](#ImportFile.parseMetadata) ⇒ <code>TYPE.MetadataTypeItem</code>
+    * [.deleteByKey(customerKey)](#ImportFile.deleteByKey) ⇒ <code>boolean</code>
 
 <a name="ImportFile.retrieve"></a>
 
@@ -3055,11 +3056,18 @@ Currently it is not needed to loop over Imports with endpoint /automation/v1/imp
 
 <a name="ImportFile.retrieveForCache"></a>
 
-### ImportFile.retrieveForCache() ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+### ImportFile.retrieveForCache([_], [__], [key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
 Retrieves import definition metadata for caching
 
 **Kind**: static method of [<code>ImportFile</code>](#ImportFile)  
 **Returns**: <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code> - Promise  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| [_] | <code>void</code> | parameter not used |
+| [__] | <code>void</code> | parameter not used |
+| [key] | <code>string</code> | customer key of single item to retrieve |
+
 <a name="ImportFile.retrieveAsTemplate"></a>
 
 ### ImportFile.retrieveAsTemplate(templateDir, name, templateVariables) ⇒ <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code>
@@ -3134,6 +3142,18 @@ parses retrieved Metadata before saving
 | --- | --- | --- |
 | metadata | <code>TYPE.MetadataTypeItem</code> | a single import definition |
 
+<a name="ImportFile.deleteByKey"></a>
+
+### ImportFile.deleteByKey(customerKey) ⇒ <code>boolean</code>
+Delete a metadata item from the specified business unit
+
+**Kind**: static method of [<code>ImportFile</code>](#ImportFile)  
+**Returns**: <code>boolean</code> - deletion success status  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| customerKey | <code>string</code> | Identifier of data extension |
+
 <a name="Journey"></a>
 
 ## Journey ⇐ [<code>MetadataType</code>](#MetadataType)
@@ -3390,7 +3410,7 @@ Provides default functionality that can be overwritten by child metadata type cl
     * [.setFolderId(metadata)](#MetadataType.setFolderId)
     * [.retrieve(retrieveDir, [additionalFields], [subTypeArr], [key])](#MetadataType.retrieve) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
     * [.retrieveChangelog([additionalFields], [subTypeArr])](#MetadataType.retrieveChangelog) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
-    * [.retrieveForCache([additionalFields], [subTypeArr])](#MetadataType.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+    * [.retrieveForCache([additionalFields], [subTypeArr], [key])](#MetadataType.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
     * [.retrieveAsTemplate(templateDir, name, templateVariables, [subType])](#MetadataType.retrieveAsTemplate) ⇒ <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code>
     * [.retrieveTemplateREST(templateDir, uri, templateVariables, name)](#MetadataType.retrieveTemplateREST) ⇒ <code>Promise.&lt;{metadata: TYPE.MetadataTypeItem, type: string}&gt;</code>
     * [.buildTemplate(retrieveDir, templateDir, key, templateVariables)](#MetadataType.buildTemplate) ⇒ <code>Promise.&lt;TYPE.MetadataTypeItemObj&gt;</code>
@@ -3616,7 +3636,7 @@ Gets metadata from Marketing Cloud
 
 <a name="MetadataType.retrieveForCache"></a>
 
-### MetadataType.retrieveForCache([additionalFields], [subTypeArr]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+### MetadataType.retrieveForCache([additionalFields], [subTypeArr], [key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
 Gets metadata cache with limited fields and does not store value to disk
 
 **Kind**: static method of [<code>MetadataType</code>](#MetadataType)  
@@ -3626,6 +3646,7 @@ Gets metadata cache with limited fields and does not store value to disk
 | --- | --- | --- |
 | [additionalFields] | <code>Array.&lt;string&gt;</code> | Returns specified fields even if their retrieve definition is not set to true |
 | [subTypeArr] | <code>Array.&lt;string&gt;</code> | optionally limit to a single subtype |
+| [key] | <code>string</code> | customer key of single item to retrieve |
 
 <a name="MetadataType.retrieveAsTemplate"></a>
 
@@ -4341,7 +4362,7 @@ MobileKeyword 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>
+    * [.retrieveForCache([_], [__], [key])](#MobileKeyword.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</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>
@@ -4405,16 +4426,16 @@ helper for [upsert](#MetadataType.upsert)
 
 <a name="MobileKeyword.retrieveForCache"></a>
 
-### MobileKeyword.retrieveForCache(_, __, [key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+### MobileKeyword.retrieveForCache([_], [__], [key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
 Retrieves event definition metadata for caching
 
 **Kind**: static method of [<code>MobileKeyword</code>](#MobileKeyword)  
 **Returns**: <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code> - Promise of metadata  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| _ | <code>void</code> | parameter not used |
-| __ | <code>void</code> | parameter not used |
+| [_] | <code>void</code> | parameter not used |
+| [__] | <code>void</code> | parameter not used |
 | [key] | <code>string</code> | customer key of single item to retrieve |
 
 <a name="MobileKeyword.retrieveAsTemplate"></a>
@@ -4632,7 +4653,7 @@ MobileMessage MetadataType
 
 * [MobileMessage](#MobileMessage) ⇐ [<code>MetadataType</code>](#MetadataType)
     * [.retrieve(retrieveDir, [_], [__], [key])](#MobileMessage.retrieve) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code> \| <code>void</code>
-    * [.retrieveForCache(_, __, [key])](#MobileMessage.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+    * [.retrieveForCache([_], [__], [key])](#MobileMessage.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
     * [.update(metadata)](#MobileMessage.update) ⇒ <code>Promise</code>
     * [.create(metadata)](#MobileMessage.create) ⇒ <code>Promise</code>
     * [._mergeCode(metadata, deployDir, [templateName])](#MobileMessage._mergeCode) ⇒ <code>Promise.&lt;string&gt;</code>
@@ -4664,16 +4685,16 @@ Retrieves Metadata of Mobile Keywords
 
 <a name="MobileMessage.retrieveForCache"></a>
 
-### MobileMessage.retrieveForCache(_, __, [key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+### MobileMessage.retrieveForCache([_], [__], [key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
 Retrieves event definition metadata for caching
 
 **Kind**: static method of [<code>MobileMessage</code>](#MobileMessage)  
 **Returns**: <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code> - Promise of metadata  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| _ | <code>void</code> | parameter not used |
-| __ | <code>void</code> | parameter not used |
+| [_] | <code>void</code> | parameter not used |
+| [__] | <code>void</code> | parameter not used |
 | [key] | <code>string</code> | customer key of single item to retrieve |
 
 <a name="MobileMessage.update"></a>
@@ -5516,7 +5537,7 @@ TransactionalMessage MetadataType
 
 * [TransactionalMessage](#TransactionalMessage) ⇐ [<code>MetadataType</code>](#MetadataType)
     * [.retrieve(retrieveDir, [_], [__], [key])](#TransactionalMessage.retrieve) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
-    * [.retrieveForCache([key])](#TransactionalMessage.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+    * [.retrieveForCache([_], [__], [key])](#TransactionalMessage.retrieveForCache) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
     * [.update(metadata)](#TransactionalMessage.update) ⇒ <code>Promise</code>
     * [.create(metadata)](#TransactionalMessage.create) ⇒ <code>Promise</code>
     * [.deleteByKey(key)](#TransactionalMessage.deleteByKey) ⇒ <code>Promise.&lt;boolean&gt;</code>
@@ -5538,14 +5559,16 @@ Retrieves Metadata
 
 <a name="TransactionalMessage.retrieveForCache"></a>
 
-### TransactionalMessage.retrieveForCache([key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
+### TransactionalMessage.retrieveForCache([_], [__], [key]) ⇒ <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code>
 Retrieves event definition metadata for caching
 
 **Kind**: static method of [<code>TransactionalMessage</code>](#TransactionalMessage)  
 **Returns**: <code>Promise.&lt;TYPE.MetadataTypeMapObj&gt;</code> - Promise of metadata  
 
 | Param | Type | Description |
 | --- | --- | --- |
+| [_] | <code>void</code> | parameter not used |
+| [__] | <code>void</code> | parameter not used |
 | [key] | <code>string</code> | customer key of single item to cache |
 
 <a name="TransactionalMessage.update"></a>

diff --git a/lib/metadataTypes/Asset.js b/lib/metadataTypes/Asset.js
@@ -49,7 +49,7 @@ class Asset extends MetadataType {
     /**
      * Retrieves asset metadata for caching
      *
-     * @param {void} _ unused
+     * @param {void} [_] parameter not used
      * @param {string[]} [subTypeArr] optionally limit to a single subtype
      * @returns {Promise.<{metadata: TYPE.AssetMap, type: string}>} Promise
      */

diff --git a/lib/metadataTypes/Folder.js b/lib/metadataTypes/Folder.js
@@ -150,7 +150,7 @@ class Folder extends MetadataType {
     /**
      * Retrieves folder metadata for caching
      *
-     * @param {void} _ unused
+     * @param {void} [_] parameter not used
      * @param {string[]} [subTypeArr] content type of folder
      * @returns {Promise} Promise
      */

diff --git a/lib/metadataTypes/ImportFile.js b/lib/metadataTypes/ImportFile.js
@@ -23,17 +23,38 @@ class ImportFile extends MetadataType {
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
-    static retrieve(retrieveDir, _, __, key) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/imports/', null, key);
+    static async retrieve(retrieveDir, _, __, key) {
+        let objectId = null;
+        if (key) {
+            // using '?$filter=customerKey%20eq%20' + encodeURIComponent(key) would also work but that just retrieves more data for no reason
+            objectId = await this._getObjectIdForSingleRetrieve(key);
+            if (!objectId) {
+                // avoid running the rest request below by returning early
+                Util.logger.info(
+                    `Downloaded: ${this.definition.type} (0)${Util.getKeysString(key)}`
+                );
+                return { metadata: {}, type: this.definition.type };
+            }
+        }
+
+        return super.retrieveREST(
+            retrieveDir,
+            '/automation/v1/imports/' + (objectId || ''),
+            null,
+            key
+        );
     }
 
     /**
      * Retrieves import definition metadata for caching
      *
+     * @param {void} [_] parameter not used
+     * @param {void} [__] parameter not used
+     * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
      */
-    static async retrieveForCache() {
-        return super.retrieveREST(null, '/automation/v1/imports/');
+    static retrieveForCache(_, __, key) {
+        return this.retrieve(null, null, null, key);
     }
 
     /**
@@ -45,12 +66,12 @@ class ImportFile extends MetadataType {
      * @returns {Promise.<TYPE.MetadataTypeItemObj>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
-        const res = await this.client.rest.get(
-            '/automation/v1/imports/?$filter=name%20eq%20' + encodeURIComponent(name)
-        );
-        if (Array.isArray(res?.items) && res?.items.length) {
+        // using '?$filter=name%20eq%20' + encodeURIComponent(name) would also work but that just retrieves more data for no reason
+        const cache = await this.retrieveForCache(null, null, 'name:' + name);
+        const metadataArr = Object.values(cache?.metadata);
+        if (Array.isArray(metadataArr) && metadataArr.length) {
             // eq-operator returns a similar, not exact match and hence might return more than 1 entry
-            const metadata = res.items.find((item) => item.name === name);
+            const metadata = metadataArr.find((item) => item.name === name);
             if (!metadata) {
                 Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
                 return;
@@ -72,16 +93,39 @@ class ImportFile extends MetadataType {
             );
             Util.logger.info(`- templated ${this.definition.type}: ${name}`);
             return { metadata: val, type: this.definition.type };
-        } else if (res?.items) {
+        } else if (metadataArr) {
             Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
         } else {
             throw new Error(
                 `Encountered unknown error when retrieveing ${
                     this.definition.typeName
-                } "${name}": ${JSON.stringify(res)}`
+                } "${name}": ${JSON.stringify(metadataArr)}`
             );
         }
     }
+    /**
+     * helper to allow us to select single metadata entries via REST
+     *
+     * @private
+     * @param {string} key customer key
+     * @returns {Promise.<string>} objectId or enpty string
+     */
+    static async _getObjectIdForSingleRetrieve(key) {
+        const response = await this.client.soap.retrieve('ImportDefinition', ['ObjectID'], {
+            filter: key.startsWith('name:')
+                ? {
+                      leftOperand: 'Name',
+                      operator: 'equals',
+                      rightOperand: key.slice(5),
+                  }
+                : {
+                      leftOperand: 'CustomerKey',
+                      operator: 'equals',
+                      rightOperand: key,
+                  },
+        });
+        return response?.Results?.length ? response.Results[0].ObjectID : null;
+    }
 
     /**
      * manages post retrieve steps
@@ -90,8 +134,7 @@ class ImportFile extends MetadataType {
      * @returns {TYPE.MetadataTypeItem} metadata
      */
     static postRetrieveTasks(importDef) {
-        const val = this.parseMetadata(importDef);
-        return val;
+        return this.parseMetadata(importDef);
     }
 
     /**
@@ -163,6 +206,11 @@ class ImportFile extends MetadataType {
                 } not fully supported. Deploy might fail.`
             );
         }
+        if (metadata.c__blankFileProcessing) {
+            // omit this if not set
+            metadata.blankFileProcessingType =
+                this.definition.blankFileProcessingTypeMapping[metadata.c__blankFileProcessing];
+        }
         // When the destinationObjectTypeId is 584 it refers to Mobile Connect which is not supported as an Import Type
         metadata.destinationObjectTypeId =
             this.definition.destinationObjectTypeMapping[metadata.c__destinationType];
@@ -216,6 +264,14 @@ class ImportFile extends MetadataType {
                 Util.logger.warn(` - ImportFile ${metadata.customerKey}: ${ex.message}`);
             }
         }
+        if (metadata.blankFileProcessingType) {
+            // omit this if not set
+            metadata.c__blankFileProcessing = Util.inverseGet(
+                this.definition.blankFileProcessingTypeMapping,
+                metadata.blankFileProcessingType
+            );
+            delete metadata.blankFileProcessingType;
+        }
 
         metadata.c__subscriberImportType = Util.inverseGet(
             this.definition.subscriberImportTypeMapping,