mcdev 3.1.3 → 4.0.1

package/lib/metadataTypes/Asset.js

@@ -1,39 +1,30 @@
 'use strict';
 
 const MetadataType = require('./MetadataType');
+const TYPE = require('../../types/mcdev.d');
 const Util = require('../util/util');
 const File = require('../util/file');
-const bluebird = require('bluebird');
+const pLimit = require('p-limit');
 const cliProgress = require('cli-progress');
-const Mustache = require('mustache');
-
-/**
- * @typedef {Object.<string, any>} AssetItem
- *
- * @typedef {Object.<string, AssetItem>} AssetMap
- *
- * @typedef {'archive'|'asset'|'audio'|'block'|'code'|'document'|'image'|'message'|'other'|'rawimage'|'template'|'textfile'|'video'} AssetSubType
- *
- * @typedef {Object} CodeExtractItem
- * @property {AssetItem} json metadata of one item w/o code
- * @property {MetadataType.CodeExtract[]} codeArr list of code snippets in this item
- * @property {string[]} subFolder mostly set to null, otherwise list of subfolders
- */
+const cache = require('../util/cache');
 
 /**
  * FileTransfer MetadataType
+ *
  * @augments MetadataType
  */
 class Asset extends MetadataType {
     /**
      * Retrieves Metadata of Asset
+     *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} _ -
      * @param {void} __ -
-     * @param {AssetSubType} [selectedSubType] optionally limit to a single subtype
-     * @returns {Promise<{metadata:AssetMap,type:string}>} Promise
+     * @param {TYPE.AssetSubType} [selectedSubType] optionally limit to a single subtype
+     * @param {string} [key] customer key
+     * @returns {Promise.<{metadata: TYPE.AssetMap, type: string}>} Promise
      */
-    static async retrieve(retrieveDir, _, __, selectedSubType) {
+    static async retrieve(retrieveDir, _, __, selectedSubType, key) {
         const items = [];
         const subTypes = selectedSubType ? [selectedSubType] : this._getSubTypes();
         await File.initPrettier();
@@ -45,7 +36,10 @@ class Asset extends MetadataType {
                 ...(await this.requestSubType(
                     subType,
                     this.definition.extendedSubTypes[subType],
-                    retrieveDir
+                    retrieveDir,
+                    null,
+                    null,
+                    key
                 ))
             );
         }
@@ -60,21 +54,23 @@ class Asset extends MetadataType {
 
     /**
      * Retrieves asset metadata for caching
+     *
      * @param {void} _ -
      * @param {string} [selectedSubType] optionally limit to a single subtype
-     * @returns {Promise<{metadata:AssetMap,type:string}>} Promise
+     * @returns {Promise.<{metadata: TYPE.AssetMap, type: string}>} Promise
      */
     static retrieveForCache(_, selectedSubType) {
         return this.retrieve(null, null, null, selectedSubType);
     }
 
     /**
-     * Retrieves asset metadata for caching
+     * Retrieves asset metadata for templating
+     *
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
-     * @param {Util.TemplateMap} templateVariables variables to be replaced in the metadata
-     * @param {AssetSubType} [selectedSubType] optionally limit to a single subtype
-     * @returns {Promise<{metadata:AssetMap,type:string}>} Promise
+     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @param {TYPE.AssetSubType} [selectedSubType] optionally limit to a single subtype
+     * @returns {Promise.<{metadata: TYPE.AssetItem, type: string}>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables, selectedSubType) {
         const items = [];
@@ -100,17 +96,19 @@ class Asset extends MetadataType {
         }
         Util.logger.info(`Downloaded: ${this.definition.type} (${Object.keys(metadata).length})`);
 
-        return { metadata: metadata, type: this.definition.type };
+        return { metadata: Object.values(metadata)[0], type: this.definition.type };
     }
     /**
      * helper for retrieve + retrieveAsTemplate
+     *
      * @private
-     * @returns {AssetSubType[]} subtype array
+     * @returns {TYPE.AssetSubType[]} subtype array
      */
     static _getSubTypes() {
         const selectedSubTypeArr = this.properties.metaDataTypes.retrieve.filter((type) =>
             type.startsWith('asset-')
         );
+        /* eslint-disable unicorn/prefer-ternary */
         if (
             this.properties.metaDataTypes.retrieve.includes('asset') ||
             !selectedSubTypeArr.length
@@ -120,11 +118,13 @@ class Asset extends MetadataType {
         } else {
             return selectedSubTypeArr.map((type) => type.replace('asset-', ''));
         }
+        /* eslint-enable unicorn/prefer-ternary */
     }
 
     /**
      * Creates a single asset
-     * @param {AssetItem} metadata a single asset
+     *
+     * @param {TYPE.AssetItem} metadata a single asset
      * @returns {Promise} Promise
      */
     static create(metadata) {
@@ -134,7 +134,8 @@ class Asset extends MetadataType {
 
     /**
      * Updates a single asset
-     * @param {AssetItem} metadata a single asset
+     *
+     * @param {TYPE.AssetItem} metadata a single asset
      * @returns {Promise} Promise
      */
     static update(metadata) {
@@ -143,11 +144,13 @@ class Asset extends MetadataType {
     }
     /**
      * Retrieves Metadata of a specific asset type
-     * @param {AssetSubType} subType group of similar assets to put in a folder (ie. images)
-     * @param {AssetSubType[]} subTypeArray list of all asset types within this subtype
+     *
+     * @param {TYPE.AssetSubType} subType group of similar assets to put in a folder (ie. images)
+     * @param {TYPE.AssetSubType[]} subTypeArray list of all asset types within this subtype
      * @param {string} [retrieveDir] target directory for saving assets
      * @param {string} [templateName] name of the metadata file
-     * @param {Util.TemplateMap} [templateVariables] variables to be replaced in the metadata
+     * @param {TYPE.TemplateMap} [templateVariables] variables to be replaced in the metadata
+     * @param {string} key customer key to filter by
      * @returns {Promise} Promise
      */
     static async requestSubType(
@@ -155,29 +158,29 @@ class Asset extends MetadataType {
         subTypeArray,
         retrieveDir,
         templateName,
-        templateVariables
+        templateVariables,
+        key
     ) {
         if (retrieveDir) {
             Util.logger.info(`- Retrieving Subtype: ${subType}`);
         } else {
-            Util.logger.info(`- Caching Subtype: ${subType}`);
+            Util.logger.info(` - Caching Subtype: ${subType}`);
         }
-        const subtypeIds = subTypeArray?.map(subTypeItemName => Asset.definition.typeMapping[subTypeItemName]);
-        const uri = 'asset/v1/content/assets/';
-        const options = {
-            uri: uri + 'query',
-            headers: {},
-            json: {
-                page: {
-                    page: 1,
-                    pageSize: 50,
-                },
-                query: null,
-                fields: [],
+        const subtypeIds = subTypeArray?.map(
+            (subTypeItemName) => Asset.definition.typeMapping[subTypeItemName]
+        );
+        const uri = 'asset/v1/content/assets/query';
+        const payload = {
+            page: {
+                page: 1,
+                pageSize: 50,
             },
+            query: null,
+            fields: ['category', 'createdDate', 'createdBy', 'modifiedDate', 'modifiedBy'], // get folder to allow duplicate name check against cache
         };
+
         if (templateName) {
-            options.json.query = {
+            payload.query = {
                 leftOperand: {
                     property: 'assetType.id',
                     simpleOperator: 'in',
@@ -185,22 +188,36 @@ class Asset extends MetadataType {
                 },
                 logicalOperator: 'AND',
                 rightOperand: {
-                    property: 'name',
+                    property: this.definition.nameField,
                     simpleOperator: 'equal',
                     value: templateName,
                 },
             };
+        } else if (key) {
+            payload.query = {
+                leftOperand: {
+                    property: 'assetType.id',
+                    simpleOperator: 'in',
+                    value: subtypeIds,
+                },
+                logicalOperator: 'AND',
+                rightOperand: {
+                    property: this.definition.keyField,
+                    simpleOperator: 'equal',
+                    value: key,
+                },
+            };
         } else {
-            options.json.query = {
+            payload.query = {
                 property: 'assetType.id',
                 simpleOperator: 'in',
                 value: subtypeIds,
             };
-            options.json.sort = [{ property: 'id', direction: 'ASC' }];
+            payload.sort = [{ property: 'id', direction: 'ASC' }];
         }
         // for caching we do not need these fields
         if (retrieveDir) {
-            options.json.fields = [
+            payload.fields = [
                 'fileProperties',
                 'status',
                 'category',
@@ -217,21 +234,18 @@ class Asset extends MetadataType {
         let lastPage = 0;
         let items = [];
         do {
-            options.json.page.page = lastPage + 1;
-            let response;
-            await Util.retryOnError(`Retrying Subtype: ${subType}`, async () => {
-                response = await this.client.RestClient.post(options);
-            });
-            if (response && response.body && response.body.items && response.body.items.length) {
+            payload.page.page = lastPage + 1;
+            const response = await this.client.rest.post(uri, payload);
+            if (response?.items?.length) {
                 // sometimes the api will return a payload without items
                 // --> ensure we only add proper items-arrays here
-                items = items.concat(response.body.items);
+                items = items.concat(response.items);
             }
             // check if any more records
-            if (response.body.message && response.body.message.includes('all shards failed')) {
+            if (response?.message?.includes('all shards failed')) {
                 // When running certain filters, there is a limit of 10k on ElastiCache.
                 // Since we sort by ID, we can get the last ID then run new requests from there
-                options.json.query = {
+                payload.query = {
                     leftOperand: {
                         property: 'assetType.id',
                         simpleOperator: 'in',
@@ -246,94 +260,100 @@ class Asset extends MetadataType {
                 };
                 lastPage = 0;
                 moreResults = true;
-            } else if (response.body.page * response.body.pageSize < response.body.count) {
+            } else if (response.page * response.pageSize < response.count) {
                 moreResults = true;
-                lastPage = Number(response.body.page);
+                lastPage = Number(response.page);
             } else {
                 moreResults = false;
             }
         } while (moreResults);
+
         // only when we save results do we need the complete metadata or files. caching can skip these
         if (retrieveDir && items.length > 0) {
             // we have to wait on execution or it potentially causes memory reference issues when changing between BUs
             await this.requestAndSaveExtended(items, subType, retrieveDir, templateVariables);
+            Util.logger.debug(`Downloaded asset-${subType}: ${items.length}`);
+        } else if (retrieveDir && !items.length) {
+            Util.logger.info(`  Downloaded asset-${subType}: ${items.length}`);
         }
         return items;
     }
     /**
      * Retrieves extended metadata (files or extended content) of asset
+     *
      * @param {Array} items array of items to retrieve
-     * @param {AssetSubType} subType group of similar assets to put in a folder (ie. images)
+     * @param {TYPE.AssetSubType} subType group of similar assets to put in a folder (ie. images)
      * @param {string} retrieveDir target directory for saving assets
-     * @param {Util.TemplateMap} [templateVariables] variables to be replaced in the metadata
+     * @param {TYPE.TemplateMap} [templateVariables] variables to be replaced in the metadata
      * @returns {Promise} Promise
      */
     static async requestAndSaveExtended(items, subType, retrieveDir, templateVariables) {
+        // disable CLI logs other than error while retrieving subtype
+        const loggerLevelBak = Util.logger.level;
+        if (loggerLevelBak !== 'error') {
+            // disable logging to cli other than Errors
+            Util.setLoggingLevel({ silent: true });
+        }
         const extendedBar = new cliProgress.SingleBar(
-            { format: 'Processing [{bar}] {percentage}% | {value}/{total}' },
+            {
+                format:
+                    '                 Downloaded [{bar}] {percentage}% | {value}/{total} | asset-' +
+                    subType,
+            },
             cliProgress.Presets.shades_classic
         );
 
         const completed = [];
+        const failed = [];
         // put in do loop to manage issues with connection timeout
         do {
             // use promise execution limiting to avoid rate limits on api, but speed up execution
             // start the progress bar with a total value of 200 and start value of 0
             extendedBar.start(items.length - completed.length, 0);
             try {
-                const promiseMap = await bluebird.map(
-                    items,
-                    async (item) => {
-                        await Util.retryOnError(
-                            `Retrying asset-${subType} ${item[this.definition.nameField]} (${
-                                item[this.definition.keyField]
-                            })`,
-                            async () => {
-                                const metadata = {};
-                                // this is a file so extended is at another endpoint
-                                if (
-                                    item.fileProperties &&
-                                    item.fileProperties.extension &&
-                                    !completed.includes(item.id)
-                                ) {
-                                    metadata[item.customerKey] = item;
-                                    if (templateVariables) {
-                                        // do this here already because otherwise the extended file could be saved with wrong fileName
-                                        const warningMsg =
-                                            'Ensure that Code that might be loading this via ContentBlockByKey is updated with the new key before deployment.';
-                                        this.overrideKeyWithName(item, warningMsg);
-                                    }
+                const rateLimit = pLimit(5);
+
+                const promiseMap = await Promise.all(
+                    items.map((item) =>
+                        rateLimit(async () => {
+                            const metadata = {};
+                            // this is a file so extended is at another endpoint
+                            if (item?.fileProperties?.extension && !completed.includes(item.id)) {
+                                try {
                                     // retrieving the extended file does not need to be awaited
                                     await this._retrieveExtendedFile(item, subType, retrieveDir);
+                                } catch (ex) {
+                                    failed.push({ item: item, error: ex });
                                 }
-                                // this is a complex type which stores data in the asset itself
-                                else if (!completed.includes(item.id)) {
-                                    const extendedItem = await this.client.RestClient.get({
-                                        uri: 'asset/v1/content/assets/' + item.id,
-                                    });
-                                    metadata[item.customerKey] = extendedItem.body;
-                                }
-                                completed.push(item.id);
-                                await this.saveResults(
-                                    metadata,
-                                    retrieveDir,
-                                    'asset-' + subType,
-                                    templateVariables
+                                metadata[item.customerKey] = item;
+                            }
+                            // this is a complex type which stores data in the asset itself
+                            else if (!completed.includes(item.id)) {
+                                const extendedItem = await this.client.rest.get(
+                                    'asset/v1/content/assets/' + item.id
                                 );
-                                // update the current value in your application..
-                                extendedBar.increment();
-                            },
-                            true
-                        );
-                    },
-                    { concurrency: 5 }
+                                metadata[item.customerKey] = extendedItem;
+                            }
+                            completed.push(item.id);
+                            await this.saveResults(
+                                metadata,
+                                retrieveDir,
+                                'asset-' + subType,
+                                templateVariables
+                            );
+                            // update the current value in your application..
+                            extendedBar.increment();
+                        })
+                    )
                 );
 
                 // stop the progress bar
                 extendedBar.stop();
+                Asset._resetLogLevel(loggerLevelBak, failed);
                 return promiseMap;
             } catch (ex) {
                 extendedBar.stop();
+                Asset._resetLogLevel(loggerLevelBak, failed);
                 // timeouts should be retried, others can be retried
                 if (ex.code !== 'ETIMEDOUT') {
                     throw ex;
@@ -341,18 +361,70 @@ class Asset extends MetadataType {
             }
         } while (completed.length === items.length);
     }
+
+    /**
+     * helper that reset the log level and prints errors
+     *
+     * @private
+     * @param {'info'|'verbose'|'debug'|'error'} loggerLevelBak original logger level
+     * @param {object[]} failed array of failed items
+     */
+    static _resetLogLevel(loggerLevelBak, failed) {
+        // re-enable CLI logs
+        if (loggerLevelBak !== 'error') {
+            // reset logging level
+            let obj;
+            switch (loggerLevelBak) {
+                case 'info': {
+                    obj = {};
+                    break;
+                }
+                case 'verbose': {
+                    obj = { verbose: true };
+                    break;
+                }
+                case 'debug': {
+                    obj = { debug: true };
+                    break;
+                }
+                case 'error': {
+                    obj = { silent: true };
+                }
+            }
+            Util.setLoggingLevel(obj);
+        }
+
+        if (failed.length) {
+            Util.logger.warn(
+                ` - Failed to download ${failed.length} extended file${
+                    failed.length > 1 ? 's' : ''
+                }:`
+            );
+            for (const fail of failed) {
+                Util.logger.warn(
+                    `   -  "${fail.item.name}" (${fail.item.customerKey}) in ${fail.item.r__folder_Path}: ${fail.error.message}`
+                );
+                Util.logger.debug(`-- Error: ${fail.error.message}`);
+                Util.logger.debug(`-- AssetType: ${fail.item.assetType.name}`);
+                Util.logger.debug(`-- fileProperties: ${JSON.stringify(fail.item.fileProperties)}`);
+            }
+            Util.logger.info(
+                ' - You will still find a JSON file for each of these in the download directory.'
+            );
+        }
+    }
+
     /**
      * Some metadata types store their actual content as a separate file, e.g. images
      * This method retrieves these and saves them alongside the metadata json
-     * @param {AssetItem} metadata a single asset
-     * @param {AssetSubType} subType group of similar assets to put in a folder (ie. images)
+     *
+     * @param {TYPE.AssetItem} metadata a single asset
+     * @param {TYPE.AssetSubType} subType group of similar assets to put in a folder (ie. images)
      * @param {string} retrieveDir target directory for saving assets
-     * @returns {Promise<void>} -
+     * @returns {Promise.<void>} -
      */
     static async _retrieveExtendedFile(metadata, subType, retrieveDir) {
-        const file = await this.client.RestClient.get({
-            uri: 'asset/v1/content/assets/' + metadata.id + '/file',
-        });
+        const file = await this.client.rest.get('asset/v1/content/assets/' + metadata.id + '/file');
 
         // to handle uploaded files that bear the same name, SFMC engineers decided to add a number after the fileName
         // however, their solution was not following standards: fileName="header.png (4) " and then extension="png (4) "
@@ -362,7 +434,7 @@ class Asset extends MetadataType {
             [retrieveDir, this.definition.type, subType],
             metadata.customerKey,
             fileExt,
-            file.body,
+            file,
             'base64'
         );
     }
@@ -370,10 +442,11 @@ class Asset extends MetadataType {
      * helper for this.preDeployTasks()
      * Some metadata types store their actual content as a separate file, e.g. images
      * This method reads these from the local FS stores them in the metadata object allowing to deploy it
-     * @param {AssetItem} metadata a single asset
-     * @param {AssetSubType} subType group of similar assets to put in a folder (ie. images)
+     *
+     * @param {TYPE.AssetItem} metadata a single asset
+     * @param {TYPE.AssetSubType} subType group of similar assets to put in a folder (ie. images)
      * @param {string} deployDir directory of deploy files
-     * @returns {Promise<void>} -
+     * @returns {Promise.<void>} -
      */
     static async _readExtendedFileFromFS(metadata, subType, deployDir) {
         if (metadata.fileProperties && metadata.fileProperties.extension) {
@@ -381,7 +454,7 @@ class Asset extends MetadataType {
             // however, their solution was not following standards: fileName="header.png (4) " and then extension="png (4) "
             const fileExt = metadata.fileProperties.extension.split(' ')[0];
 
-            metadata.file = await File.readFile(
+            metadata.file = await File.readFilteredFilename(
                 [deployDir, this.definition.type, subType],
                 metadata.customerKey,
                 fileExt,
@@ -391,36 +464,25 @@ class Asset extends MetadataType {
     }
     /**
      * manages post retrieve steps
-     * @param {AssetItem} metadata a single asset
-     * @param {string} [_] unused
-     * @param {Boolean} isTemplating signals that we are retrieving templates
-     * @returns {CodeExtractItem} metadata
+     *
+     * @param {TYPE.AssetItem} metadata a single asset
+     * @returns {TYPE.CodeExtractItem} metadata
      */
-    static postRetrieveTasks(metadata, _, isTemplating) {
-        // if retrieving template, replace the name with customer key if that wasn't already the case
-        if (isTemplating) {
-            const warningMsg =
-                'Ensure that Code that might be loading this via ContentBlockByKey is updated with the new key before deployment.';
-            this.overrideKeyWithName(metadata, warningMsg);
-        }
+    static postRetrieveTasks(metadata) {
         return this.parseMetadata(metadata);
     }
 
     /**
      * prepares an asset definition for deployment
-     * @param {AssetItem} metadata a single asset
+     *
+     * @param {TYPE.AssetItem} metadata a single asset
      * @param {string} deployDir directory of deploy files
-     * @returns {Promise<AssetItem>} Promise
+     * @param {TYPE.BuObject} buObject buObject properties for auth
+     * @returns {Promise.<TYPE.AssetItem>} Promise
      */
-    static async preDeployTasks(metadata, deployDir) {
+    static async preDeployTasks(metadata, deployDir, buObject) {
         // additonalattributes fail where the value is "" so we need to remove them from deploy
-        if (
-            metadata.data &&
-            metadata.data.email &&
-            metadata.data.email &&
-            metadata.data.email.attributes &&
-            metadata.data.email.attributes.length > 0
-        ) {
+        if (metadata?.data?.email?.attributes?.length > 0) {
             metadata.data.email.attributes = metadata.data.email.attributes.filter(
                 (attr) => attr.value
             );
@@ -428,7 +490,7 @@ class Asset extends MetadataType {
 
         // folder
         metadata.category = {
-            id: Util.getFromCache(this.cache, 'folder', metadata.r__folder_Path, 'Path', 'ID'),
+            id: cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID'),
         };
         delete metadata.r__folder_Path;
 
@@ -436,7 +498,7 @@ class Asset extends MetadataType {
         metadata.assetType.id = this.definition.typeMapping[metadata.assetType.name];
 
         // define asset's subtype
-        const subType = this.getSubtype(metadata);
+        const subType = this._getSubtype(metadata);
 
         // #1 get text extracts back into the JSON
         await this._mergeCode(metadata, deployDir, subType);
@@ -444,51 +506,190 @@ class Asset extends MetadataType {
         // #2 get file from local disk and insert as base64
         await this._readExtendedFileFromFS(metadata, subType, deployDir);
 
+        // only execute #3 if we are deploying / copying from one BU to another, not while using mcdev as a developer tool
+        if (
+            buObject.mid &&
+            metadata.memberId !== buObject.mid &&
+            !metadata[this.definition.keyField].startsWith(buObject.mid)
+        ) {
+            // #3 make sure customer key is unique by prefixing it with target MID (unless we are deploying to the same MID)
+            // check if this prefixed with the source MID
+            const suffix = '-' + buObject.mid;
+            // for customer key max is 36 chars
+            metadata[this.definition.keyField] =
+                metadata[this.definition.keyField].slice(0, Math.max(0, 36 - suffix.length)) +
+                suffix;
+        }
+        // #4 make sure the name is unique
+        const assetCache = cache.getCache()[this.definition.type];
+        const namesInFolder = Object.keys(assetCache)
+            .filter((key) => assetCache[key].category.id === metadata.category.id)
+            .map((key) => ({
+                type: this._getMainSubtype(assetCache[key].assetType.name),
+                key: key,
+                name: assetCache[key].name,
+            }));
+        // if the name is already in the folder for a different key, add a number to the end
+        metadata[this.definition.nameField] = this._findUniqueName(
+            metadata[this.definition.keyField],
+            metadata[this.definition.nameField],
+            this._getMainSubtype(metadata.assetType.name),
+            namesInFolder
+        );
         return metadata;
     }
+    /**
+     * find the subType matching the extendedSubType
+     *
+     * @param {string} extendedSubType webpage, htmlblock, etc
+     * @returns {string} subType: block, message, other, etc
+     */
+    static _getMainSubtype(extendedSubType) {
+        return Object.keys(this.definition.extendedSubTypes).find((subType) =>
+            this.definition.extendedSubTypes[subType].includes(extendedSubType)
+        );
+    }
+    /**
+     * helper to find a new unique name during asset creation
+     *
+     * @private
+     * @param {string} key key of the asset
+     * @param {string} name name of the asset
+     * @param {string} type assetType-name
+     * @param {string[]} namesInFolder names of the assets in the same folder
+     * @returns {string} new name
+     */
+    static _findUniqueName(key, name, type, namesInFolder) {
+        let newName = name;
+        let suffix;
+        let i = 1;
+        while (
+            namesInFolder.find(
+                (item) => item.name === newName && item.type === type && item.key !== key
+            )
+        ) {
+            suffix = ' (' + i + ')';
+            // for customer key max is 100 chars
+            newName = name.slice(0, Math.max(0, 100 - suffix.length)) + suffix;
+            i++;
+        }
+        return newName;
+    }
     /**
      * determines the subtype of the current asset
-     * @param {AssetItem} metadata a single asset
-     * @returns {AssetSubType} subtype
+     *
+     * @private
+     * @param {TYPE.AssetItem} metadata a single asset
+     * @returns {TYPE.AssetSubType} subtype
      */
-    static getSubtype(metadata) {
+    static _getSubtype(metadata) {
         for (const sub in this.definition.extendedSubTypes) {
             if (this.definition.extendedSubTypes[sub].includes(metadata.assetType.name)) {
                 return sub;
             }
         }
     }
-
     /**
      * helper for buildDefinition
      * handles extracted code if any are found for complex types
+     *
      * @param {string} templateDir Directory where metadata templates are stored
      * @param {string} targetDir Directory where built definitions will be saved
-     * @param {AssetItem} metadata main JSON file that was read from file system
-     * @param {Util.TemplateMap} variables variables to be replaced in the metadata
+     * @param {TYPE.AssetItem} metadata main JSON file that was read from file system
+     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
      * @param {string} templateName name of the template to be built
-     * @returns {Promise<void>} Promise
+     * @returns {Promise.<void>} -
      */
-    static async buildDefinitionForExtracts(
+    static buildDefinitionForNested(
         templateDir,
         targetDir,
         metadata,
-        variables,
+        templateVariables,
         templateName
     ) {
-        // clone metadata to ensure the main file is not modified by what we do in here
+        return this._buildForNested(
+            templateDir,
+            targetDir,
+            metadata,
+            templateVariables,
+            templateName,
+            'definition'
+        );
+    }
+    /**
+     * helper for buildTemplate
+     * handles extracted code if any are found for complex types
+     *
+     * @example assets of type codesnippetblock will result in 1 json and 1 amp/html file. both files need to be run through templating
+     * @param {string} templateDir Directory where metadata templates are stored
+     * @param {string|string[]} targetDir (List of) Directory where built definitions will be saved
+     * @param {TYPE.AssetItem} metadata main JSON file that was read from file system
+     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @param {string} templateName name of the template to be built
+     * @returns {Promise.<void>} -
+     */
+    static buildTemplateForNested(
+        templateDir,
+        targetDir,
+        metadata,
+        templateVariables,
+        templateName
+    ) {
+        return this._buildForNested(
+            templateDir,
+            targetDir,
+            metadata,
+            templateVariables,
+            templateName,
+            'template'
+        );
+    }
+
+    /**
+     * helper for buildDefinition
+     * handles extracted code if any are found for complex types
+     *
+     * @param {string} templateDir Directory where metadata templates are stored
+     * @param {string} targetDir Directory where built definitions will be saved
+     * @param {TYPE.AssetItem} metadata main JSON file that was read from file system
+     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @param {string} templateName name of the template to be built
+     * @param {'definition'|'template'} mode defines what we use this helper for
+     * @returns {Promise.<void>} -
+     */
+    static async _buildForNested(
+        templateDir,
+        targetDir,
+        metadata,
+        templateVariables,
+        templateName,
+        mode
+    ) {
+        // * because asset's _mergeCode() is overwriting 'metadata', clone it to ensure the main file is not modified by what we do in here
         metadata = JSON.parse(JSON.stringify(metadata));
 
         // #1 text extracts
         // define asset's subtype
-        const subType = this.getSubtype(metadata);
+        const subType = this._getSubtype(metadata);
         // get HTML from filesystem
         const fileList = await this._mergeCode(metadata, templateDir, subType, templateName);
         // replace template variables with their values
         for (const extractedFile of fileList) {
             try {
-                extractedFile.content = Mustache.render(extractedFile.content, variables);
-            } catch (ex) {
+                if (mode === 'definition') {
+                    // replace template variables with their values
+                    extractedFile.content = this.applyTemplateValues(
+                        extractedFile.content,
+                        templateVariables
+                    );
+                } else if (mode === 'template') {
+                    // replace template values with corresponding variable names
+                    extractedFile.content = this.applyTemplateNames(
+                        extractedFile.content,
+                        templateVariables
+                    );
+                }
+            } catch {
                 throw new Error(
                     `${this.definition.type}:: Error applying template variables on ${
                         metadata[this.definition.keyField]
@@ -498,12 +699,12 @@ class Asset extends MetadataType {
         }
 
         // #2 binary extracts
-        if (metadata.fileProperties && metadata.fileProperties.extension) {
+        if (metadata?.fileProperties?.extension) {
             // to handle uploaded files that bear the same name, SFMC engineers decided to add a number after the fileName
             // however, their solution was not following standards: fileName="header.png (4) " and then extension="png (4) "
             const fileExt = metadata.fileProperties.extension.split(' ')[0];
 
-            const filecontent = await File.readFile(
+            const filecontent = await File.readFilteredFilename(
                 [templateDir, this.definition.type, subType],
                 metadata.customerKey,
                 fileExt,
@@ -511,7 +712,7 @@ class Asset extends MetadataType {
             );
             fileList.push({
                 subFolder: [this.definition.type, subType],
-                fileName: metadata.customerKey,
+                fileName: templateName,
                 fileExt: fileExt,
                 content: filecontent,
                 encoding: 'base64',
@@ -535,14 +736,14 @@ class Asset extends MetadataType {
 
     /**
      * parses retrieved Metadata before saving
-     * @param {AssetItem} metadata a single asset definition
-     * @returns {CodeExtractItem} parsed metadata definition
+     *
+     * @param {TYPE.AssetItem} metadata a single asset definition
+     * @returns {TYPE.CodeExtractItem} parsed metadata definition
      */
     static parseMetadata(metadata) {
         // folder
         try {
-            metadata.r__folder_Path = Util.getFromCache(
-                this.cache,
+            metadata.r__folder_Path = cache.searchForField(
                 'folder',
                 metadata.category.id,
                 'ID',
@@ -553,7 +754,7 @@ class Asset extends MetadataType {
             // ! if we don't catch this error here we end up saving the actual asset but not its corresponding JSON
             Util.logger.debug(ex.message);
             Util.logger.warn(
-                `Could not find folder with ID ${metadata.category.id} for '${metadata.name}' (${metadata.customerKey})`
+                ` - Could not find folder with ID ${metadata.category.id} for '${metadata.name}' (${metadata.customerKey})`
             );
         }
         // extract HTML for selected subtypes and convert payload for easier processing in MetadataType.saveResults()
@@ -562,42 +763,42 @@ class Asset extends MetadataType {
     }
     /**
      * helper for this.preDeployTasks() that loads extracted code content back into JSON
-     * @param {AssetItem} metadata a single asset definition
+     *
+     * @param {TYPE.AssetItem} metadata a single asset definition
      * @param {string} deployDir directory of deploy files
-     * @param {AssetSubType} subType asset-subtype name
+     * @param {TYPE.AssetSubType} subType asset-subtype name
      * @param {string} [templateName] name of the template used to built defintion (prior applying templating)
-     * @returns {Promise<MetadataType.CodeExtract[]>} fileList for templating (disregarded during deployment)
+     * @param {boolean} [fileListOnly] does not read file contents nor update metadata if true
+     * @returns {Promise.<TYPE.CodeExtract[]>} fileList for templating (disregarded during deployment)
      */
-    static async _mergeCode(metadata, deployDir, subType, templateName) {
+    static async _mergeCode(metadata, deployDir, subType, templateName, fileListOnly = false) {
         const subtypeExtension = `.${this.definition.type}-${subType}-meta`;
         const fileList = [];
         let subDirArr;
         let readDirArr;
-
         switch (metadata.assetType.name) {
-            case 'webpage': // asset
             case 'templatebasedemail': // message
-            case 'htmlemail': // message
+            case 'htmlemail': {
+                // message
                 // this complex type always creates its own subdir per asset
                 subDirArr = [this.definition.type, subType];
-                readDirArr = [
-                    deployDir,
-                    ...subDirArr,
-                    templateName ? templateName : metadata.customerKey,
-                ];
+                readDirArr = [deployDir, ...subDirArr, templateName || metadata.customerKey];
 
                 // metadata.views.html.content (mandatory)
+                // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
                 if (
-                    File.existsSync(
+                    (await File.pathExists(
                         File.normalizePath([...readDirArr, `index${subtypeExtension}.html`])
-                    )
+                    )) &&
+                    metadata.views.html
                 ) {
-                    // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
-                    metadata.views.html.content = await File.readFile(
-                        readDirArr,
-                        'index' + subtypeExtension,
-                        'html'
-                    );
+                    if (!fileListOnly) {
+                        metadata.views.html.content = await File.readFilteredFilename(
+                            readDirArr,
+                            'index' + subtypeExtension,
+                            'html'
+                        );
+                    }
 
                     if (templateName) {
                         // to use this method in templating, store a copy of the info in fileList
@@ -611,39 +812,44 @@ class Asset extends MetadataType {
                 }
 
                 // metadata.views.html.slots.<>.blocks.<>.content (optional)
-                if (metadata.views && metadata.views.html && metadata.views.html.slots) {
+                if (metadata?.views?.html?.slots) {
                     await this._mergeCode_slots(
+                        'views.html.slots',
                         metadata.views.html.slots,
                         readDirArr,
                         subtypeExtension,
                         subDirArr,
                         fileList,
                         metadata.customerKey,
-                        templateName
+                        templateName,
+                        fileListOnly
                     );
                 }
                 break;
-            case 'textonlyemail': // message
+            }
+            case 'textonlyemail': {
+                // message
                 // metadata.views.text.content
                 subDirArr = [this.definition.type, subType];
                 readDirArr = [deployDir, ...subDirArr];
                 if (
-                    File.existsSync(
+                    await File.pathExists(
                         File.normalizePath([
                             ...readDirArr,
                             `${
-                                templateName ? templateName : metadata.customerKey
+                                templateName || metadata.customerKey // TODO check why this could be templateName
                             }${subtypeExtension}.html`,
                         ])
                     )
                 ) {
                     // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
-                    metadata.views.text.content = await File.readFile(
-                        readDirArr,
-                        (templateName ? templateName : metadata.customerKey) + subtypeExtension,
-                        'html'
-                    );
-
+                    if (!fileListOnly) {
+                        metadata.views.text.content = await File.readFilteredFilename(
+                            readDirArr,
+                            (templateName || metadata.customerKey) + subtypeExtension,
+                            'html'
+                        );
+                    }
                     if (templateName) {
                         // to use this method in templating, store a copy of the info in fileList
                         fileList.push({
@@ -655,63 +861,162 @@ class Asset extends MetadataType {
                     }
                 }
                 break;
-            case 'freeformblock': // block
-            case 'htmlblock': // block
-            case 'textblock': // block
-            case 'smartcaptureblock': // other
-            case 'codesnippetblock': // other
-                // metadata.content
+            }
+            case 'webpage': {
+                // asset
+                // this complex type always creates its own subdir per asset
                 subDirArr = [this.definition.type, subType];
-                readDirArr = [deployDir, ...subDirArr];
+                readDirArr = [deployDir, ...subDirArr, templateName || metadata.customerKey];
+
+                // metadata.views.html.slots.<>.blocks.<>.content (optional) (pre & post 20222)
+                if (metadata?.views?.html?.slots) {
+                    await this._mergeCode_slots(
+                        'views.html.slots',
+                        metadata.views.html.slots,
+                        readDirArr,
+                        subtypeExtension,
+                        subDirArr,
+                        fileList,
+                        metadata.customerKey,
+                        templateName,
+                        fileListOnly
+                    );
+                }
+
+                // +++ old webpages / pre-2022 +++
+                // metadata.views.html.content (mandatory)
                 if (
-                    File.existsSync(
+                    (await File.pathExists(
                         File.normalizePath([
                             ...readDirArr,
-                            `${
-                                templateName ? templateName : metadata.customerKey
-                            }${subtypeExtension}.html`,
+                            `views.html.content${subtypeExtension}.html`,
                         ])
+                    )) && // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
+                    metadata.views?.html
+                ) {
+                    if (!fileListOnly) {
+                        metadata.views.html.content = await File.readFilteredFilename(
+                            readDirArr,
+                            'views.html.content' + subtypeExtension,
+                            'html'
+                        );
+                    }
+                    if (templateName) {
+                        // to use this method in templating, store a copy of the info in fileList
+                        fileList.push({
+                            subFolder: [...subDirArr, metadata.customerKey],
+                            fileName: 'views.html.content' + subtypeExtension,
+                            fileExt: 'html',
+                            content: metadata.views.html.content,
+                        });
+                    }
+                }
+
+                // +++ new webpages / 2022+ +++
+                // metadata.content
+                if (
+                    await File.pathExists(
+                        File.normalizePath([...readDirArr, `content${subtypeExtension}.html`])
                     )
                 ) {
                     // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
-                    metadata.content = await File.readFile(
-                        readDirArr,
-                        (templateName ? templateName : metadata.customerKey) + subtypeExtension,
-                        'html'
-                    );
+                    if (!fileListOnly) {
+                        metadata.content = await File.readFilteredFilename(
+                            readDirArr,
+                            'content' + subtypeExtension,
+                            'html'
+                        );
+                    }
                     if (templateName) {
                         // to use this method in templating, store a copy of the info in fileList
                         fileList.push({
-                            subFolder: subDirArr,
-                            fileName: metadata.customerKey + subtypeExtension,
+                            subFolder: [...subDirArr, metadata.customerKey],
+                            fileName: 'content' + subtypeExtension,
                             fileExt: 'html',
-                            content: metadata.content,
+                            content: metadata.views.html.content,
                         });
                     }
                 }
+
                 break;
+            }
+            case 'buttonblock': // block - Button Block
+            case 'freeformblock': // block
+            case 'htmlblock': // block
+            case 'icemailformblock': // block - Interactive Content Email Form
+            case 'imageblock': // block - Image Block
+            case 'textblock': // block
+            case 'smartcaptureblock': // other
+            case 'codesnippetblock': {
+                // other
+                // metadata.content
+                subDirArr = [this.definition.type, subType];
+                readDirArr = [deployDir, ...subDirArr];
+                const fileExtArr = ['html']; // eslint-disable-line no-case-declarations
+                if (metadata.assetType.name === 'codesnippetblock') {
+                    // extracted code snippets should end on the right extension
+                    // we are making a few assumptions during retrieve to pick the right one
+                    fileExtArr.push('amp', 'sjss');
+                }
+                for (const ext of fileExtArr) {
+                    if (
+                        await File.pathExists(
+                            File.normalizePath([
+                                ...readDirArr,
+                                `${templateName || metadata.customerKey}${subtypeExtension}.${ext}`,
+                            ])
+                        )
+                    ) {
+                        // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
+                        if (!fileListOnly) {
+                            metadata.content = await File.readFilteredFilename(
+                                readDirArr,
+                                (templateName || metadata.customerKey) + subtypeExtension,
+                                ext
+                            );
+                        }
+                        if (templateName) {
+                            // to use this method in templating, store a copy of the info in fileList
+                            fileList.push({
+                                subFolder: subDirArr,
+                                fileName: (templateName || metadata.customerKey) + subtypeExtension,
+                                fileExt: ext,
+                                content: metadata.content,
+                            });
+                        }
+                        // break loop when found
+                        break;
+                    }
+                }
+                break;
+            }
         }
         return fileList;
     }
     /**
      * helper for this.preDeployTasks() that loads extracted code content back into JSON
-     * @param {Object} metadataSlots metadata.views.html.slots or deeper slots.<>.blocks.<>.slots
+     *
+     * @param {string} prefix usually the customerkey
+     * @param {object} metadataSlots metadata.views.html.slots or deeper slots.<>.blocks.<>.slots
      * @param {string[]} readDirArr directory of deploy files
      * @param {string} subtypeExtension asset-subtype name ending on -meta
      * @param {string[]} subDirArr directory of files w/o leading deploy dir
-     * @param {Object[]} fileList directory of files w/o leading deploy dir
+     * @param {object[]} fileList directory of files w/o leading deploy dir
      * @param {string} customerKey external key of template (could have been changed if used during templating)
      * @param {string} [templateName] name of the template used to built defintion (prior applying templating)
-     * @returns {Promise<void>} -
+     * @param {boolean} [fileListOnly] does not read file contents nor update metadata if true
+     * @returns {Promise.<void>} -
      */
     static async _mergeCode_slots(
+        prefix,
         metadataSlots,
         readDirArr,
         subtypeExtension,
         subDirArr,
         fileList,
         customerKey,
-        templateName
+        templateName,
+        fileListOnly = false
     ) {
         for (const slot in metadataSlots) {
             if (Object.prototype.hasOwnProperty.call(metadataSlots, slot)) {
@@ -720,9 +1025,9 @@ class Asset extends MetadataType {
                 if (slotObj.blocks) {
                     for (const block in slotObj.blocks) {
                         if (Object.prototype.hasOwnProperty.call(slotObj.blocks, block)) {
-                            const fileName = `${slot}-${block}${subtypeExtension}`;
+                            const fileName = `${prefix}.[${slot}-${block}]${subtypeExtension}`;
                             if (
-                                File.existsSync(
+                                await File.pathExists(
                                     File.normalizePath([
                                         ...readDirArr,
                                         'blocks',
@@ -732,11 +1037,13 @@ class Asset extends MetadataType {
                             ) {
                                 // the main content can be empty (=not set up yet) hence check if we did extract sth or else readFile() will print error msgs
                                 // if an extracted block was found, save it back into JSON
-                                slotObj.blocks[block].content = await File.readFile(
-                                    [...readDirArr, 'blocks'],
-                                    fileName,
-                                    'html'
-                                );
+                                if (!fileListOnly) {
+                                    slotObj.blocks[block].content = await File.readFilteredFilename(
+                                        [...readDirArr, 'blocks'],
+                                        fileName,
+                                        'html'
+                                    );
+                                }
                                 if (templateName) {
                                     // to use this method in templating, store a copy of the info in fileList
                                     fileList.push({
@@ -750,6 +1057,7 @@ class Asset extends MetadataType {
                             if (slotObj.blocks[block].slots) {
                                 // * recursion: each block can have slots of its own
                                 await this._mergeCode_slots(
+                                    `${prefix}.[${slot}-${block}]`,
                                     slotObj.blocks[block].slots,
                                     readDirArr,
                                     subtypeExtension,
@@ -768,17 +1076,19 @@ class Asset extends MetadataType {
     /**
      * helper for this.parseMetadata() that finds code content in JSON and extracts it
      * to allow saving that separately and formatted
-     * @param {AssetItem} metadata a single asset definition
-     * @returns {CodeExtractItem} { json: metadata, codeArr: object[], subFolder: string[] }
+     *
+     * @param {TYPE.AssetItem} metadata a single asset definition
+     * @returns {TYPE.CodeExtractItem} { json: metadata, codeArr: object[], subFolder: string[] }
      */
     static _extractCode(metadata) {
         const codeArr = [];
+        let subType;
         switch (metadata.assetType.name) {
-            case 'webpage': // asset
             case 'templatebasedemail': // message
-            case 'htmlemail': // message
+            case 'htmlemail': {
+                // message
                 // metadata.views.html.content (mandatory)
-                if (metadata.views.html.content && metadata.views.html.content.length) {
+                if (metadata.views?.html?.content?.length) {
                     codeArr.push({
                         subFolder: null,
                         fileName: 'index',
@@ -789,14 +1099,16 @@ class Asset extends MetadataType {
                 }
 
                 // metadata.views.html.slots.<>.blocks.<>.content (optional)
-                if (metadata.views && metadata.views.html && metadata.views.html.slots) {
-                    this._extractCode_slots(metadata.views.html.slots, codeArr);
+                if (metadata.views?.html?.slots) {
+                    this._extractCode_slots('views.html.slots', metadata.views.html.slots, codeArr);
                 }
 
                 return { json: metadata, codeArr: codeArr, subFolder: [metadata.customerKey] };
-            case 'textonlyemail': // message
+            }
+            case 'textonlyemail': {
+                // message
                 // metadata.views.text.content
-                if (metadata.views.text.content && metadata.views.text.content.length) {
+                if (metadata.views?.text?.content?.length) {
                     codeArr.push({
                         subFolder: null,
                         fileName: metadata.customerKey,
@@ -806,32 +1118,86 @@ class Asset extends MetadataType {
                     delete metadata.views.text.content;
                 }
                 return { json: metadata, codeArr: codeArr, subFolder: null };
+            }
+            case 'webpage': {
+                // asset
+                // metadata.views.html.content (pre & post 20222)
+                if (metadata.views?.html?.content?.length) {
+                    codeArr.push({
+                        subFolder: null,
+                        fileName: 'views.html.content',
+                        fileExt: 'html',
+                        content: metadata.views.html.content,
+                    });
+                    delete metadata.views.html.content;
+                }
+
+                // +++ old webpages / pre-2022 +++
+                // metadata.views.html.slots.<>.blocks.<>.content (optional)
+                if (metadata.views?.html?.slots) {
+                    this._extractCode_slots('views.html.slots', metadata.views.html.slots, codeArr);
+                }
+
+                // +++ new webpages / 2022+ +++
+                // metadata.content
+                if (metadata?.content?.length) {
+                    codeArr.push({
+                        subFolder: null,
+                        fileName: 'content',
+                        fileExt: 'html',
+                        content: metadata.content,
+                    });
+                    delete metadata.content;
+                }
+                return { json: metadata, codeArr: codeArr, subFolder: [metadata.customerKey] };
+            }
+            case 'buttonblock': // block - Button Block
             case 'freeformblock': // block
             case 'htmlblock': // block
+            case 'icemailformblock': // block - Interactive Content Email Form
+            case 'imageblock': // block - Image Block
             case 'textblock': // block
             case 'smartcaptureblock': // other
-            case 'codesnippetblock': // other
+            case 'codesnippetblock': {
+                // other
                 // metadata.content
-                if (metadata.content && metadata.content.length) {
+                let fileExt = 'html'; // eslint-disable-line no-case-declarations
+                if (
+                    metadata.assetType.name === 'codesnippetblock' && // extracted code snippets should end on the right extension
+                    // we are making a few assumptions during retrieve to pick the right one
+                    metadata?.content?.includes('%%[')
+                ) {
+                    fileExt = 'amp';
+                }
+                if (metadata?.content?.length) {
                     codeArr.push({
                         subFolder: null,
                         fileName: metadata.customerKey,
-                        fileExt: 'html',
+                        fileExt: fileExt,
                         content: metadata.content,
                     });
                     delete metadata.content;
                 }
                 return { json: metadata, codeArr: codeArr, subFolder: null };
-            default:
+            }
+            default: {
+                subType = this._getSubtype(metadata);
+                if (!this.definition.binarySubtypes.includes(subType)) {
+                    Util.logger.debug(
+                        'not processed metadata.assetType.name: ' + metadata.assetType.name
+                    );
+                }
                 return { json: metadata, codeArr: codeArr, subFolder: null };
+            }
         }
     }
     /**
-     * @param {Object} metadataSlots metadata.views.html.slots or deeper slots.<>.blocks.<>.slots
-     * @param {Object[]} codeArr to be extended array for extracted code
+     * @param {string} prefix usually the customerkey
+     * @param {object} metadataSlots metadata.views.html.slots or deeper slots.<>.blocks.<>.slots
+     * @param {object[]} codeArr to be extended array for extracted code
      * @returns {void}
      */
-    static _extractCode_slots(metadataSlots, codeArr) {
+    static _extractCode_slots(prefix, metadataSlots, codeArr) {
         for (const slot in metadataSlots) {
             if (Object.prototype.hasOwnProperty.call(metadataSlots, slot)) {
                 const slotObj = metadataSlots[slot];
@@ -843,7 +1209,7 @@ class Asset extends MetadataType {
                             const code = slotObj.blocks[block].content;
                             codeArr.push({
                                 subFolder: ['blocks'],
-                                fileName: `${slot}-${block}`,
+                                fileName: `${prefix}.[${slot}-${block}]`,
                                 fileExt: 'html',
                                 content: code,
                             });
@@ -851,7 +1217,11 @@ class Asset extends MetadataType {
                         }
                         if (slotObj.blocks[block].slots) {
                             // * recursion: each block can have slots of its own
-                            this._extractCode_slots(slotObj.blocks[block].slots, codeArr);
+                            this._extractCode_slots(
+                                `${prefix}.[${slot}-${block}]`,
+                                slotObj.blocks[block].slots,
+                                codeArr
+                            );
                         }
                     }
                 }
@@ -860,18 +1230,28 @@ class Asset extends MetadataType {
     }
     /**
      * Returns file contents mapped to their fileName without '.json' ending
+     *
      * @param {string} dir directory that contains '.json' files to be read
-     * @returns {Object} fileName => fileContent map
+     * @param {void} [_] unused parameter
+     * @param {string[]} selectedSubType asset, message, ...
+     * @returns {TYPE.MetadataTypeMap} fileName => fileContent map
      */
-    static getJsonFromFS(dir) {
+    static getJsonFromFS(dir, _, selectedSubType) {
         const fileName2FileContent = {};
         try {
             for (const subtype of this.definition.subTypes) {
+                if (
+                    selectedSubType &&
+                    !selectedSubType.includes('asset-' + subtype) &&
+                    !selectedSubType.includes('asset')
+                ) {
+                    continue;
+                }
                 const currentdir = File.normalizePath([dir, subtype]);
-                if (File.existsSync(currentdir)) {
+                if (File.pathExistsSync(currentdir)) {
                     const files = File.readdirSync(currentdir, { withFileTypes: true });
 
-                    files.forEach((dirent) => {
+                    for (const dirent of files) {
                         try {
                             let thisDir = currentdir;
                             let fileName = dirent.name;
@@ -882,12 +1262,12 @@ class Asset extends MetadataType {
                                 const subfolderFiles = File.readdirSync(
                                     File.normalizePath([currentdir, dirent.name])
                                 );
-                                subfolderFiles.forEach((subFileName) => {
+                                for (const subFileName of subfolderFiles) {
                                     if (subFileName.endsWith('-meta.json')) {
                                         fileName = subFileName;
                                         thisDir = File.normalizePath([currentdir, dirent.name]);
                                     }
-                                });
+                                }
                             }
                             if (fileName.endsWith('-meta.json')) {
                                 const fileContent = File.readJSONFile(
@@ -907,7 +1287,7 @@ class Asset extends MetadataType {
                             // by catching this in the loop we gracefully handle the issue and move on to the next file
                             Util.metadataLogger('debug', this.definition.type, 'getJsonFromFS', ex);
                         }
-                    });
+                    }
                 }
             }
         } catch (ex) {
@@ -919,22 +1299,23 @@ class Asset extends MetadataType {
     }
     /**
      * check template directory for complex types that open subfolders for their subtypes
+     *
      * @param {string} templateDir Directory where metadata templates are stored
      * @param {string} templateName name of the metadata file
-     * @returns {AssetSubType} subtype name
+     * @returns {Promise.<TYPE.AssetSubType>} subtype name
      */
-    static findSubType(templateDir, templateName) {
+    static async findSubType(templateDir, templateName) {
         const typeDirArr = [this.definition.type];
         let subType;
         for (const st of this.definition.subTypes) {
             const fileNameFull = templateName + '.' + this.definition.type + `-${st}-meta.json`;
             if (
-                File.existsSync(
+                (await File.pathExists(
                     File.normalizePath([templateDir, ...typeDirArr, st, fileNameFull])
-                ) ||
-                File.existsSync(
+                )) ||
+                (await File.pathExists(
                     File.normalizePath([templateDir, ...typeDirArr, st, templateName, fileNameFull])
-                )
+                ))
             ) {
                 subType = st;
                 break;
@@ -952,19 +1333,88 @@ class Asset extends MetadataType {
     }
     /**
      * optional method used for some types to try a different folder structure
+     *
      * @param {string} templateDir Directory where metadata templates are stored
      * @param {string[]} typeDirArr current subdir for this type
      * @param {string} templateName name of the metadata template
      * @param {string} fileName name of the metadata template file w/o extension
-     * @returns {AssetItem} metadata
+     * @returns {TYPE.AssetItem} metadata
      */
     static async readSecondaryFolder(templateDir, typeDirArr, templateName, fileName) {
         // handles subtypes that create 1 folder per asset -> currently causes the below File.ReadFile to error out
         typeDirArr.push(templateName);
-        return await File.readFile([templateDir, ...typeDirArr], fileName, 'json');
+        return await File.readFilteredFilename([templateDir, ...typeDirArr], fileName, 'json');
+    }
+    /**
+     * should return only the json for all but asset, query and script that are saved as multiple files
+     * additionally, the documentation for dataExtension and automation should be returned
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @returns {string[]} list of all files that need to be committed in a flat array ['path/file1.ext', 'path/file2.ext']
+     */
+    static async getFilesToCommit(keyArr) {
+        const basePath = File.normalizePath([
+            this.properties.directories.retrieve,
+            this.buObject.credential,
+            this.buObject.businessUnit,
+        ]);
+
+        const fileList = (
+            await Promise.all(
+                keyArr.map(async (key) => {
+                    let subType;
+                    let filePath;
+                    let fileName;
+                    for (const st of this.definition.subTypes) {
+                        fileName = `${key}.${this.definition.type}-${st}-meta.json`;
+                        if (
+                            await File.pathExists(
+                                File.normalizePath([basePath, this.definition.type, st, fileName])
+                            )
+                        ) {
+                            subType = st;
+                            filePath = [basePath, this.definition.type, st];
+                            break;
+                        } else if (
+                            await File.pathExists(
+                                File.normalizePath([
+                                    basePath,
+                                    this.definition.type,
+                                    st,
+                                    key,
+                                    fileName,
+                                ])
+                            )
+                        ) {
+                            subType = st;
+                            filePath = [basePath, this.definition.type, st, key];
+                            break;
+                        }
+                    }
+                    if (await File.pathExists(File.normalizePath([...filePath, fileName]))) {
+                        const metadata = File.readJSONFile(filePath, fileName, true, false);
+                        const fileListNested = (
+                            await this._mergeCode(metadata, basePath, subType, metadata.customerKey)
+                        ).map((item) =>
+                            File.normalizePath([
+                                basePath,
+                                ...item.subFolder,
+                                `${item.fileName}.${item.fileExt}`,
+                            ])
+                        );
+
+                        return [File.normalizePath([...filePath, fileName]), ...fileListNested];
+                    } else {
+                        return [];
+                    }
+                })
+            )
+        ).flat();
+        return fileList;
     }
 }
 
 // Assign definition to static attributes
 Asset.definition = require('../MetadataTypeDefinitions').asset;
+
 module.exports = Asset;