mcdev 3.0.0 → 3.1.0

package/lib/metadataTypes/Asset.js

@@ -7,6 +7,19 @@ const bluebird = require('bluebird');
 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
+ */
+
 /**
  * FileTransfer MetadataType
  * @augments MetadataType
@@ -14,11 +27,11 @@ const Mustache = require('mustache');
 class Asset extends MetadataType {
     /**
      * Retrieves Metadata of Asset
-     * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
+     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} _ -
      * @param {void} __ -
-     * @param {String} [selectedSubType] optionally limit to a single subtype
-     * @returns {Promise} Promise
+     * @param {AssetSubType} [selectedSubType] optionally limit to a single subtype
+     * @returns {Promise<{metadata:AssetMap,type:string}>} Promise
      */
     static async retrieve(retrieveDir, _, __, selectedSubType) {
         const items = [];
@@ -48,8 +61,8 @@ class Asset extends MetadataType {
     /**
      * Retrieves asset metadata for caching
      * @param {void} _ -
-     * @param {String} [selectedSubType] optionally limit to a single subtype
-     * @returns {Promise} Promise
+     * @param {string} [selectedSubType] optionally limit to a single subtype
+     * @returns {Promise<{metadata:AssetMap,type:string}>} Promise
      */
     static retrieveForCache(_, selectedSubType) {
         return this.retrieve(null, null, null, selectedSubType);
@@ -57,13 +70,13 @@ class Asset extends MetadataType {
 
     /**
      * Retrieves asset metadata for caching
-     * @param {String} templateDir Directory where retrieved metadata directory will be saved
-     * @param {String} templateName name of the metadata file
-     * @param {Object} templateVariables variables to be replaced in the metadata
-     * @param {String} [selectedSubType] optionally limit to a single subtype
-     * @returns {Promise} Promise
+     * @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
      */
-    static async retrieveAsTemplate(templateDir, templateName, templateVariables, selectedSubType) {
+    static async retrieveAsTemplate(templateDir, name, templateVariables, selectedSubType) {
         const items = [];
         const subTypes = selectedSubType ? [selectedSubType] : this._getSubTypes();
         await File.initPrettier();
@@ -76,12 +89,15 @@ class Asset extends MetadataType {
                     subType,
                     this.definition.extendedSubTypes[subType],
                     templateDir,
-                    templateName,
+                    name,
                     templateVariables
                 ))
             );
         }
         const metadata = this.parseResponseBody({ items: items });
+        if (!Object.keys(metadata).length) {
+            Util.logger.error(`${this.definition.type} '${name}' not found on server.`);
+        }
         Util.logger.info(`Downloaded: ${this.definition.type} (${Object.keys(metadata).length})`);
 
         return { metadata: metadata, type: this.definition.type };
@@ -89,22 +105,26 @@ class Asset extends MetadataType {
     /**
      * helper for retrieve + retrieveAsTemplate
      * @private
-     * @returns {String[]} subtype array
+     * @returns {AssetSubType[]} subtype array
      */
     static _getSubTypes() {
-        if (this.properties.metaDataTypes.retrieve.includes('asset')) {
+        const selectedSubTypeArr = this.properties.metaDataTypes.retrieve.filter((type) =>
+            type.startsWith('asset-')
+        );
+        if (
+            this.properties.metaDataTypes.retrieve.includes('asset') ||
+            !selectedSubTypeArr.length
+        ) {
             // if "asset" is found in config assume to download the default subtypes only
             return this.definition.typeRetrieveByDefault;
         } else {
-            return this.properties.metaDataTypes.retrieve
-                .filter((type) => type.startsWith('asset-'))
-                .map((type) => type.replace('asset-', ''));
+            return selectedSubTypeArr.map((type) => type.replace('asset-', ''));
         }
     }
 
     /**
      * Creates a single asset
-     * @param {Object} metadata a single asset
+     * @param {AssetItem} metadata a single asset
      * @returns {Promise} Promise
      */
     static create(metadata) {
@@ -114,7 +134,7 @@ class Asset extends MetadataType {
 
     /**
      * Updates a single asset
-     * @param {Object} metadata a single asset
+     * @param {AssetItem} metadata a single asset
      * @returns {Promise} Promise
      */
     static update(metadata) {
@@ -123,11 +143,11 @@ class Asset extends MetadataType {
     }
     /**
      * Retrieves Metadata of a specific asset type
-     * @param {String} subType group of similar assets to put in a folder (ie. images)
-     * @param {Array} 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 {Object} [templateVariables] variables to be replaced in the metadata
+     * @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 {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
      * @returns {Promise} Promise
      */
     static async requestSubType(
@@ -142,6 +162,7 @@ class Asset extends MetadataType {
         } else {
             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',
@@ -158,9 +179,9 @@ class Asset extends MetadataType {
         if (templateName) {
             options.json.query = {
                 leftOperand: {
-                    property: 'assetType.name',
+                    property: 'assetType.id',
                     simpleOperator: 'in',
-                    value: subTypeArray,
+                    value: subtypeIds,
                 },
                 logicalOperator: 'AND',
                 rightOperand: {
@@ -171,9 +192,9 @@ class Asset extends MetadataType {
             };
         } else {
             options.json.query = {
-                property: 'assetType.name',
+                property: 'assetType.id',
                 simpleOperator: 'in',
-                value: subTypeArray,
+                value: subtypeIds,
             };
             options.json.sort = [{ property: 'id', direction: 'ASC' }];
         }
@@ -197,7 +218,10 @@ class Asset extends MetadataType {
         let items = [];
         do {
             options.json.page.page = lastPage + 1;
-            const response = await this.client.RestClient.post(options);
+            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) {
                 // sometimes the api will return a payload without items
                 // --> ensure we only add proper items-arrays here
@@ -209,9 +233,9 @@ class Asset extends MetadataType {
                 // Since we sort by ID, we can get the last ID then run new requests from there
                 options.json.query = {
                     leftOperand: {
-                        property: 'assetType.name',
+                        property: 'assetType.id',
                         simpleOperator: 'in',
-                        value: subTypeArray,
+                        value: subtypeIds,
                     },
                     logicalOperator: 'AND',
                     rightOperand: {
@@ -239,9 +263,9 @@ class Asset extends MetadataType {
     /**
      * Retrieves extended metadata (files or extended content) of asset
      * @param {Array} items array of items to retrieve
-     * @param {String} subType group of similar assets to put in a folder (ie. images)
-     * @param {String} retrieveDir target directory for saving assets
-     * @param {Object} [templateVariables] variables to be replaced in the metadata
+     * @param {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
      * @returns {Promise} Promise
      */
     static async requestAndSaveExtended(items, subType, retrieveDir, templateVariables) {
@@ -274,7 +298,7 @@ class Asset extends MetadataType {
                                 ) {
                                     metadata[item.customerKey] = item;
                                     if (templateVariables) {
-                                        // do this here already because otherwise the extended file could be saved with wrong filename
+                                        // 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);
@@ -320,9 +344,9 @@ class Asset extends MetadataType {
     /**
      * 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 {Object} metadata a single asset
-     * @param {String} subType group of similar assets to put in a folder (ie. images)
-     * @param {String} retrieveDir target directory for saving assets
+     * @param {AssetItem} metadata a single asset
+     * @param {AssetSubType} subType group of similar assets to put in a folder (ie. images)
+     * @param {string} retrieveDir target directory for saving assets
      * @returns {Promise<void>} -
      */
     static async _retrieveExtendedFile(metadata, subType, retrieveDir) {
@@ -330,14 +354,14 @@ class Asset extends MetadataType {
             uri: '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
+        // 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 fileExt = metadata.fileProperties.extension.split(' ')[0];
 
         File.writeToFile(
             [retrieveDir, this.definition.type, subType],
             metadata.customerKey,
-            fileext,
+            fileExt,
             file.body,
             'base64'
         );
@@ -346,31 +370,31 @@ 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 {Object} metadata a single asset
-     * @param {String} subType group of similar assets to put in a folder (ie. images)
-     * @param {String} deployDir directory of deploy files
+     * @param {AssetItem} metadata a single asset
+     * @param {AssetSubType} subType group of similar assets to put in a folder (ie. images)
+     * @param {string} deployDir directory of deploy files
      * @returns {Promise<void>} -
      */
     static async _readExtendedFileFromFS(metadata, subType, deployDir) {
         if (metadata.fileProperties && metadata.fileProperties.extension) {
-            // to handle uploaded files that bear the same name, SFMC engineers decided to add a number after the filename
+            // 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 fileExt = metadata.fileProperties.extension.split(' ')[0];
 
             metadata.file = await File.readFile(
                 [deployDir, this.definition.type, subType],
                 metadata.customerKey,
-                fileext,
+                fileExt,
                 'base64'
             );
         }
     }
     /**
      * manages post retrieve steps
-     * @param {Object} metadata a single asset
-     * @param {String} [_] unused
+     * @param {AssetItem} metadata a single asset
+     * @param {string} [_] unused
      * @param {Boolean} isTemplating signals that we are retrieving templates
-     * @returns {Object[]} metadata
+     * @returns {CodeExtractItem} metadata
      */
     static postRetrieveTasks(metadata, _, isTemplating) {
         // if retrieving template, replace the name with customer key if that wasn't already the case
@@ -384,9 +408,9 @@ class Asset extends MetadataType {
 
     /**
      * prepares an asset definition for deployment
-     * @param {Object} metadata a single asset
-     * @param {String} deployDir directory of deploy files
-     * @returns {Promise} Promise
+     * @param {AssetItem} metadata a single asset
+     * @param {string} deployDir directory of deploy files
+     * @returns {Promise<AssetItem>} Promise
      */
     static async preDeployTasks(metadata, deployDir) {
         // additonalattributes fail where the value is "" so we need to remove them from deploy
@@ -418,14 +442,14 @@ class Asset extends MetadataType {
         await this._mergeCode(metadata, deployDir, subType);
 
         // #2 get file from local disk and insert as base64
-        await this._readExtendedFileFromFS(metadata, deployDir, subType);
+        await this._readExtendedFileFromFS(metadata, subType, deployDir);
 
         return metadata;
     }
     /**
      * determines the subtype of the current asset
-     * @param {Object} metadata a single asset
-     * @returns {String} subtype
+     * @param {AssetItem} metadata a single asset
+     * @returns {AssetSubType} subtype
      */
     static getSubtype(metadata) {
         for (const sub in this.definition.extendedSubTypes) {
@@ -438,12 +462,12 @@ class Asset extends MetadataType {
     /**
      * 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 {Object} metadata main JSON file that was read from file system
-     * @param {Object} variables variables to be replaced in the metadata
-     * @param {String} templateName name of the template to be built
-     * @returns {Promise} Promise
+     * @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 {string} templateName name of the template to be built
+     * @returns {Promise<void>} Promise
      */
     static async buildDefinitionForExtracts(
         templateDir,
@@ -468,27 +492,27 @@ class Asset extends MetadataType {
                 throw new Error(
                     `${this.definition.type}:: Error applying template variables on ${
                         metadata[this.definition.keyField]
-                    }: ${extractedFile.filename}.${extractedFile.fileext}.`
+                    }: ${extractedFile.fileName}.${extractedFile.fileExt}.`
                 );
             }
         }
 
         // #2 binary extracts
         if (metadata.fileProperties && metadata.fileProperties.extension) {
-            // to handle uploaded files that bear the same name, SFMC engineers decided to add a number after the filename
+            // 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 fileExt = metadata.fileProperties.extension.split(' ')[0];
 
             const filecontent = await File.readFile(
                 [templateDir, this.definition.type, subType],
                 metadata.customerKey,
-                fileext,
+                fileExt,
                 'base64'
             );
             fileList.push({
-                pathArr: [this.definition.type, subType],
-                filename: metadata.customerKey,
-                fileext: fileext,
+                subFolder: [this.definition.type, subType],
+                fileName: metadata.customerKey,
+                fileExt: fileExt,
                 content: filecontent,
                 encoding: 'base64',
             });
@@ -499,9 +523,9 @@ class Asset extends MetadataType {
         for (const targetDir of targetDirArr) {
             for (const extractedFile of fileList) {
                 File.writeToFile(
-                    [targetDir, ...extractedFile.pathArr],
-                    extractedFile.filename,
-                    extractedFile.fileext,
+                    [targetDir, ...extractedFile.subFolder],
+                    extractedFile.fileName,
+                    extractedFile.fileExt,
                     extractedFile.content,
                     extractedFile.encoding || null
                 );
@@ -511,8 +535,8 @@ class Asset extends MetadataType {
 
     /**
      * parses retrieved Metadata before saving
-     * @param {Object} metadata a single asset definition
-     * @returns {Object} parsed metadata definition
+     * @param {AssetItem} metadata a single asset definition
+     * @returns {CodeExtractItem} parsed metadata definition
      */
     static parseMetadata(metadata) {
         // folder
@@ -538,11 +562,11 @@ class Asset extends MetadataType {
     }
     /**
      * helper for this.preDeployTasks() that loads extracted code content back into JSON
-     * @param {Object} metadata a single asset definition
-     * @param {String} deployDir directory of deploy files
-     * @param {String} subType asset-subtype name
-     * @param {String} [templateName] name of the template used to built defintion (prior applying templating)
-     * @returns {Promise<Object[]>} fileList for templating (disregarded during deployment)
+     * @param {AssetItem} metadata a single asset definition
+     * @param {string} deployDir directory of deploy files
+     * @param {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)
      */
     static async _mergeCode(metadata, deployDir, subType, templateName) {
         const subtypeExtension = `.${this.definition.type}-${subType}-meta`;
@@ -578,9 +602,9 @@ class Asset extends MetadataType {
                     if (templateName) {
                         // to use this method in templating, store a copy of the info in fileList
                         fileList.push({
-                            pathArr: [...subDirArr, metadata.customerKey],
-                            filename: 'index' + subtypeExtension,
-                            fileext: 'html',
+                            subFolder: [...subDirArr, metadata.customerKey],
+                            fileName: 'index' + subtypeExtension,
+                            fileExt: 'html',
                             content: metadata.views.html.content,
                         });
                     }
@@ -623,9 +647,9 @@ class Asset extends MetadataType {
                     if (templateName) {
                         // to use this method in templating, store a copy of the info in fileList
                         fileList.push({
-                            pathArr: subDirArr,
-                            filename: metadata.customerKey + subtypeExtension,
-                            fileext: 'html',
+                            subFolder: subDirArr,
+                            fileName: metadata.customerKey + subtypeExtension,
+                            fileExt: 'html',
                             content: metadata.views.text.content,
                         });
                     }
@@ -658,9 +682,9 @@ class Asset extends MetadataType {
                     if (templateName) {
                         // to use this method in templating, store a copy of the info in fileList
                         fileList.push({
-                            pathArr: subDirArr,
-                            filename: metadata.customerKey + subtypeExtension,
-                            fileext: 'html',
+                            subFolder: subDirArr,
+                            fileName: metadata.customerKey + subtypeExtension,
+                            fileExt: 'html',
                             content: metadata.content,
                         });
                     }
@@ -672,12 +696,12 @@ class Asset extends MetadataType {
     /**
      * 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[]} 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 {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 {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)
+     * @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>} -
      */
     static async _mergeCode_slots(
@@ -696,13 +720,13 @@ 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 = `${slot}-${block}${subtypeExtension}`;
                             if (
                                 File.existsSync(
                                     File.normalizePath([
                                         ...readDirArr,
                                         'blocks',
-                                        `${filename}.html`,
+                                        `${fileName}.html`,
                                     ])
                                 )
                             ) {
@@ -710,15 +734,15 @@ class Asset extends MetadataType {
                                 // if an extracted block was found, save it back into JSON
                                 slotObj.blocks[block].content = await File.readFile(
                                     [...readDirArr, 'blocks'],
-                                    filename,
+                                    fileName,
                                     'html'
                                 );
                                 if (templateName) {
                                     // to use this method in templating, store a copy of the info in fileList
                                     fileList.push({
-                                        pathArr: [...subDirArr, customerKey, 'blocks'],
-                                        filename: filename,
-                                        fileext: 'html',
+                                        subFolder: [...subDirArr, customerKey, 'blocks'],
+                                        fileName: fileName,
+                                        fileExt: 'html',
                                         content: slotObj.blocks[block].content,
                                     });
                                 }
@@ -744,8 +768,8 @@ 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 {Object} metadata a single asset definition
-     * @returns {Object} { json: metadata, codeArr: object[], subFolder: string[] }
+     * @param {AssetItem} metadata a single asset definition
+     * @returns {CodeExtractItem} { json: metadata, codeArr: object[], subFolder: string[] }
      */
     static _extractCode(metadata) {
         const codeArr = [];
@@ -835,8 +859,8 @@ 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 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
      */
     static getJsonFromFS(dir) {
@@ -850,7 +874,7 @@ class Asset extends MetadataType {
                     files.forEach((dirent) => {
                         try {
                             let thisDir = currentdir;
-                            let filename = dirent.name;
+                            let fileName = dirent.name;
                             if (dirent.isDirectory()) {
                                 // complex types with more than one extracted piece of code are saved in their
                                 // own subfolder (with folder name = CustomerKey)
@@ -860,20 +884,20 @@ class Asset extends MetadataType {
                                 );
                                 subfolderFiles.forEach((subFileName) => {
                                     if (subFileName.endsWith('-meta.json')) {
-                                        filename = subFileName;
+                                        fileName = subFileName;
                                         thisDir = File.normalizePath([currentdir, dirent.name]);
                                     }
                                 });
                             }
-                            if (filename.endsWith('-meta.json')) {
+                            if (fileName.endsWith('-meta.json')) {
                                 const fileContent = File.readJSONFile(
                                     thisDir,
-                                    filename,
+                                    fileName,
                                     true,
                                     false
                                 );
                                 // subtype will change the metadata suffix length
-                                const fileNameWithoutEnding = filename.slice(
+                                const fileNameWithoutEnding = fileName.slice(
                                     0,
                                     -17 - subtype.length
                                 );
@@ -895,9 +919,9 @@ 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 {string} subtype name
+     * @param {string} templateDir Directory where metadata templates are stored
+     * @param {string} templateName name of the metadata file
+     * @returns {AssetSubType} subtype name
      */
     static findSubType(templateDir, templateName) {
         const typeDirArr = [this.definition.type];
@@ -928,11 +952,11 @@ 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 {Object} metadata
+     * @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
      */
     static async readSecondaryFolder(templateDir, typeDirArr, templateName, fileName) {
         // handles subtypes that create 1 folder per asset -> currently causes the below File.ReadFile to error out