mcdev 3.1.1 → 4.0.0

package/lib/metadataTypes/Role.js

@@ -1,29 +1,32 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
 const File = require('../util/file');
 
 /**
  * ImportFile MetadataType
+ *
  * @augments MetadataType
  */
 class Role extends MetadataType {
     /**
      * Gets metadata from Marketing Cloud
-     * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {String[]} _ Returns specified fields even if their retrieve definition is not set to true
-     * @param {Object} buObject properties for auth
-     * @returns {Promise<Object>} Metadata store object
+     *
+     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
+     * @param {string[]} _ Returns specified fields even if their retrieve definition is not set to true
+     * @param {TYPE.BuObject} buObject properties for auth
+     * @param {void} [___] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Metadata store object
      */
-    static async retrieve(retrieveDir, _, buObject) {
-        if (retrieveDir) {
+    static async retrieve(retrieveDir, _, buObject, ___, key) {
+        if (retrieveDir && buObject.eid !== buObject.mid) {
             // don't run for BUs other than Parent BU
             // this check does not work during caching
-            if (buObject.eid !== buObject.mid) {
-                Util.logger.info('Skipping Role retrieval on non-parent BU');
-                return;
-            }
+            Util.logger.info(' - Skipping Role retrieval on non-parent BU');
+            return;
         }
 
         const fields = Object.keys(this.definition.fields).reduce((accumulator, currentValue) => {
@@ -32,7 +35,10 @@ class Role extends MetadataType {
             }
             return accumulator;
         }, []);
-        const options = {
+        // manually add ObjectID for retrieves as it is no longer automatically returned, and is needed for updates
+        fields.push('ObjectID');
+        /** @type {TYPE.SoapRequestParams} */
+        let requestParams = {
             // filter individual roles
             filter: {
                 leftOperand: 'IsPrivate',
@@ -40,18 +46,26 @@ class Role extends MetadataType {
                 rightOperand: false,
             },
         };
-        const results = await new Promise((resolve) => {
-            this.client.SoapClient.retrieve('Role', fields, options, (error, response) => {
-                if (error) {
-                    throw new Error(error);
-                } else {
-                    resolve(response.body);
-                }
-            });
-        });
+        if (key) {
+            // move original filter down one level into rightOperand and add key filter into leftOperand
+            requestParams = {
+                filter: {
+                    leftOperand: {
+                        leftOperand: 'CustomerKey',
+                        operator: 'equals',
+                        rightOperand: key,
+                    },
+                    operator: 'AND',
+                    rightOperand: requestParams.filter,
+                },
+            };
+        }
+
+        const results = await this.client.soap.retrieve('Role', fields, requestParams);
+
         const parsed = this.parseResponseBody(results);
         if (retrieveDir) {
-            const savedMetadata = await this.saveResults(parsed, retrieveDir, null);
+            const savedMetadata = await super.saveResults(parsed, retrieveDir, null);
             Util.logger.info(
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
             );
@@ -63,10 +77,11 @@ class Role extends MetadataType {
     }
     /**
      * Gets executed before deploying metadata
-     * @param {Object} metadata a single metadata item
-     * @returns {Promise<Object>} Promise of a single metadata item
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single metadata item
+     * @returns {TYPE.MetadataTypeItem} Promise of a single metadata item
      */
-    static async preDeployTasks(metadata) {
+    static preDeployTasks(metadata) {
         if (this.definition.deployBlacklist.includes(metadata.CustomerKey)) {
             throw new Error(
                 `Skipped ${metadata.Name} (${metadata.CustomerKey}) because its CustomerKey is reserved for a default system role.`
@@ -77,7 +92,8 @@ class Role extends MetadataType {
 
     /**
      * Create a single Role.
-     * @param {Object} metadata single metadata entry
+     *
+     * @param {TYPE.MetadataTypeItem} metadata single metadata entry
      * @returns {Promise} Promise
      */
     static create(metadata) {
@@ -86,7 +102,8 @@ class Role extends MetadataType {
 
     /**
      * Updates a single Role.
-     * @param {Object} metadata single metadata entry
+     *
+     * @param {TYPE.MetadataTypeItem} metadata single metadata entry
      * @returns {Promise} Promise
      */
     static update(metadata) {
@@ -95,9 +112,10 @@ class Role extends MetadataType {
 
     /**
      * Creates markdown documentation of all roles
-     * @param {Object} buObject properties for auth
-     * @param {Object} [metadata] role definitions
-     * @returns {Promise<void>} -
+     *
+     * @param {TYPE.BuObject} buObject properties for auth
+     * @param {TYPE.MetadataTypeMap} [metadata] role definitions
+     * @returns {Promise.<void>} -
      */
     static async document(buObject, metadata) {
         if (buObject.eid !== buObject.mid) {
@@ -121,15 +139,24 @@ class Role extends MetadataType {
                 return;
             }
         }
-        const directory = this.properties.directories.roles;
+        const directory = File.normalizePath([this.properties.directories.docs, 'role']);
 
         // initialize permission object
         this.allPermissions = {};
         // traverse all permissions recursively and write them into allPermissions object once it has reached the end
         for (const role in metadata) {
-            metadata[role].PermissionSets.PermissionSet.forEach((element) => {
-                this._traverseRoles(role, element);
-            });
+            // filter standard rules
+            if (
+                this.properties.options?.documentStandardRoles === false &&
+                'string' === typeof metadata[role]?.CustomerKey && // key could be numeric
+                metadata[role].CustomerKey.startsWith('SYS_DEF')
+            ) {
+                delete metadata[role];
+            } else {
+                for (const element of metadata[role].PermissionSets.PermissionSet) {
+                    this._traverseRoles(role, element);
+                }
+            }
         }
         // Create output markdown
         let output = `# Permission Overview - ${buObject.credential}\n\n`;
@@ -143,7 +170,7 @@ class Role extends MetadataType {
 >
 > **+** = _Allow_: User has access to the application or functionality
 >
-> **•** = _Not Set_: User permission for this app or functionality is not explicitely granted nor denied, but defaults to Deny
+> ** •** = _Not Set_: User permission for this app or functionality is not explicitely granted nor denied, but defaults to Deny
 >
 > **-** = _Deny_: User does not have access to the app or functionality
 >
@@ -156,7 +183,7 @@ class Role extends MetadataType {
             let separator = '| --- |';
             for (const role in metadata) {
                 output +=
-                    metadata[role].IsSystemDefined === 'true'
+                    metadata[role].IsSystemDefined === true
                         ? ` [${metadata[role].Name}] |`
                         : ` ${metadata[role].Name} |`;
                 separator += ' --- |';
@@ -167,14 +194,14 @@ class Role extends MetadataType {
             for (const permission in this.allPermissions[permGroup]) {
                 output += '| ' + permission + ' |';
                 for (const role in this.allPermissions[permGroup][permission]) {
-                    if (this.allPermissions[permGroup][permission][role] === 'true') {
+                    if (this.allPermissions[permGroup][permission][role] === true) {
                         output += ' + |';
-                    } else if (this.allPermissions[permGroup][permission][role] === 'false') {
+                    } else if (this.allPermissions[permGroup][permission][role] === false) {
                         output += ' - |';
                     } else if (
                         'undefined' === typeof this.allPermissions[permGroup][permission][role]
                     ) {
-                        output += ' • |';
+                        output += '  • |';
                     } else {
                         output += ' ' + this.allPermissions[permGroup][permission][role] + ' |';
                     }
@@ -185,15 +212,11 @@ class Role extends MetadataType {
         }
         try {
             const filename = buObject.credential;
-            // ensure docs/roles folder is existing (depends on setup in .mcdevrc.json)
-            if (!File.existsSync(directory)) {
-                File.mkdirpSync(directory);
-            }
             // write to disk
             await File.writeToFile(directory, filename + '.roles', 'md', output);
-            Util.logger.info(`Created ${directory}${filename}.roles.md`);
+            Util.logger.info(`Created ${File.normalizePath([directory, filename])}.roles.md`);
             if (['html', 'both'].includes(this.properties.options.documentType)) {
-                Util.logger.warn('HTML-based documentation of roles currently not supported.');
+                Util.logger.warn(' - HTML-based documentation of roles currently not supported.');
             }
         } catch (ex) {
             Util.logger.error(`Roles.document():: error | `, ex.message);
@@ -212,12 +235,7 @@ class Role extends MetadataType {
      * @returns {void}
      */
     static _traverseRoles(role, element, permission, isAllowed) {
-        let _permission;
-        if (permission) {
-            _permission = permission + ' > ' + element.Name;
-        } else {
-            _permission = element.Name;
-        }
+        const _permission = permission ? permission + ' > ' + element.Name : element.Name;
         // Reached end: write permission into this.allPermissions
         if (element.Operation) {
             const permSplit = _permission.split(' > ');
@@ -229,15 +247,14 @@ class Role extends MetadataType {
             if (!this.allPermissions[basePermission][permissionName]) {
                 this.allPermissions[basePermission][permissionName] = {};
             }
-            this.allPermissions[basePermission][permissionName][role] = element.IsAllowed
-                ? element.IsAllowed
-                : isAllowed;
+            this.allPermissions[basePermission][permissionName][role] =
+                element.IsAllowed || isAllowed;
             // Not at end: Traverse more
         } else if (element.PermissionSets) {
             if (Array.isArray(element.PermissionSets.PermissionSet)) {
-                element.PermissionSets.PermissionSet.forEach((nextElement) => {
+                for (const nextElement of element.PermissionSets.PermissionSet) {
                     this._traverseRoles(role, nextElement, _permission);
-                });
+                }
             } else {
                 this._traverseRoles(
                     role,
@@ -250,20 +267,20 @@ class Role extends MetadataType {
             // Not at end: Traverse more
         } else if (element.Permissions) {
             if (Array.isArray(element.Permissions.Permission)) {
-                element.Permissions.Permission.forEach((nextElement) => {
+                for (const nextElement of element.Permissions.Permission) {
                     this._traverseRoles(
                         role,
                         nextElement,
                         _permission,
-                        element.IsAllowed ? element.IsAllowed : isAllowed
+                        element.IsAllowed || isAllowed
                     );
-                });
+                }
             } else {
                 this._traverseRoles(
                     role,
                     element.Permissions.Permission,
                     _permission,
-                    element.IsAllowed ? element.IsAllowed : isAllowed
+                    element.IsAllowed || isAllowed
                 );
             }
         }
@@ -272,7 +289,5 @@ class Role extends MetadataType {
 
 // Assign definition to static attributes
 Role.definition = require('../MetadataTypeDefinitions').role;
-Role.cache = {};
-Role.client = undefined;
 
 module.exports = Role;

package/lib/metadataTypes/Script.js

@@ -1,64 +1,54 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
 const File = require('../util/file');
-const Mustache = require('mustache');
-
-/**
- * @typedef {Object} ScriptItem
- * @property {string} name name
- * @property {string} key key
- * @property {string} description -
- * @property {string} createdDate e.g. "2020-09-14T01:42:03.017"
- * @property {string} modifiedDate e.g. "2020-09-14T01:42:03.017"
- * @property {string} [script] contains script with line breaks converted to '\n'. The content is extracted during retrieval and written into a separate *.ssjs file
- * @property {string} [categoryId] holds folder ID, replaced with r__folder_Path during retrieve
- * @property {string} r__folder_Path folder path in which this DE is saved
- *
- * @typedef {Object.<string, ScriptItem>} ScriptMap
- *
- * @typedef {Object} CodeExtractItem
- * @property {ScriptItem} 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');
 
 /**
  * Script MetadataType
+ *
  * @augments MetadataType
  */
 class Script extends MetadataType {
     /**
      * Retrieves Metadata of Script
      * Endpoint /automation/v1/scripts/ return all Scripts with all details.
+     *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @returns {Promise<{metadata:ScriptMap,type:string}>} Promise
+     * @param {void} [_] unused parameter
+     * @param {void} [__] unused parameter
+     * @param {void} [___] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<{metadata: TYPE.ScriptMap, type: string}>} Promise
      */
-    static async retrieve(retrieveDir) {
+    static async retrieve(retrieveDir, _, __, ___, key) {
         await File.initPrettier('ssjs');
-        return super.retrieveREST(retrieveDir, '/automation/v1/scripts/', null);
+        return super.retrieveREST(retrieveDir, '/automation/v1/scripts/', null, null, key);
     }
     /**
      * Retrieves script metadata for caching
-     * @returns {Promise<{metadata:ScriptMap,type:string}>} Promise
+     *
+     * @returns {Promise.<{metadata: TYPE.ScriptMap, type: string}>} Promise
      */
     static async retrieveForCache() {
-        return super.retrieveREST(null, '/automation/v1/scripts/', null);
+        return super.retrieveREST(null, '/automation/v1/scripts/');
     }
 
     /**
      * Retrieve a specific Script by Name
+     *
      * @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
-     * @returns {Promise<{metadata:ScriptMap,type:string}>} Promise
+     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<{metadata: TYPE.Script, type: string}>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
         await File.initPrettier('ssjs');
         return super.retrieveREST(
             templateDir,
-            '/automation/v1/scripts/?$filter=name%20eq%20' + name.split(' ').join('%20'),
+            '/automation/v1/scripts/?$filter=name%20eq%20' + encodeURIComponent(name),
             null,
             templateVariables
         );
@@ -66,24 +56,18 @@ class Script extends MetadataType {
 
     /**
      * manages post retrieve steps
-     * @param {ScriptItem} metadata a single script
-     * @param {string} [_] unused
-     * @param {boolean} [isTemplating] signals that we are retrieving templates
-     * @returns {CodeExtractItem} Array with one metadata object and one ssjs string
+     *
+     * @param {TYPE.ScriptItem} metadata a single script
+     * @returns {TYPE.CodeExtractItem} Array with one metadata object and one ssjs string
      */
-    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 Automations using this script are updated with the new script-key before deployment.';
-            this.overrideKeyWithName(metadata, warningMsg);
-        }
+    static postRetrieveTasks(metadata) {
         return this.parseMetadata(metadata);
     }
 
     /**
      * Updates a single Script
-     * @param {Object} script a single Script
+     *
+     * @param {TYPE.MetadataTypeItem} script a single Script
      * @returns {Promise} Promise
      */
     static update(script) {
@@ -92,7 +76,8 @@ class Script extends MetadataType {
 
     /**
      * Creates a single Script
-     * @param {Object} script a single Script
+     *
+     * @param {TYPE.MetadataTypeItem} script a single Script
      * @returns {Promise} Promise
      */
     static create(script) {
@@ -101,10 +86,11 @@ class Script extends MetadataType {
 
     /**
      * helper for this.preDeployTasks() that loads extracted code content back into JSON
-     * @param {ScriptItem} metadata a single asset definition
+     *
+     * @param {TYPE.ScriptItem} metadata a single asset definition
      * @param {string} deployDir directory of deploy files
      * @param {string} [templateName] name of the template used to built defintion (prior applying templating)
-     * @returns {Promise<String>} content for metadata.script
+     * @returns {Promise.<string>} content for metadata.script
      */
     static async _mergeCode(metadata, deployDir, templateName) {
         templateName = templateName || metadata.key;
@@ -115,15 +101,15 @@ class Script extends MetadataType {
             templateName + '.' + this.definition.type + '-meta',
         ]);
 
-        if (File.existsSync(codePath + '.ssjs')) {
-            code = await File.readFile(
+        if (await File.pathExists(codePath + '.ssjs')) {
+            code = await File.readFilteredFilename(
                 [deployDir, this.definition.type],
                 templateName + '.' + this.definition.type + '-meta',
                 'ssjs'
             );
             code = `<script runat="server">\n${code}</script>`;
-        } else if (File.existsSync(codePath + '.html')) {
-            code = await File.readFile(
+        } else if (await File.pathExists(codePath + '.html')) {
+            code = await File.readFilteredFilename(
                 [deployDir, this.definition.type],
                 templateName + '.' + this.definition.type + '-meta',
                 'html'
@@ -135,55 +121,108 @@ class Script extends MetadataType {
     }
     /**
      * prepares a Script for deployment
-     * @param {ScriptItem} metadata a single script activity definition
+     *
+     * @param {TYPE.ScriptItem} metadata a single script activity definition
      * @param {string} dir directory of deploy files
-     * @returns {ScriptItem} Promise
+     * @returns {TYPE.ScriptItem} Promise
      */
     static async preDeployTasks(metadata, dir) {
         // folder
-        try {
-            metadata.categoryId = Util.getFromCache(
-                this.cache,
-                'folder',
-                metadata.r__folder_Path,
-                'Path',
-                'ID'
-            );
-            delete metadata.r__folder_Path;
-        } catch (ex) {
-            Util.logger.error(`Script '${metadata.key}': ${ex.message}`);
-        }
+        metadata.categoryId = cache.searchForField('folder', metadata.r__folder_Path, 'Path', 'ID');
+        delete metadata.r__folder_Path;
 
         // code
         metadata.script = await this._mergeCode(metadata, dir);
 
         return metadata;
     }
-
     /**
      * helper for buildDefinition
      * handles extracted code if any are found for complex types
+     *
      * @param {string} templateDir Directory where metadata templates are stored
      * @param {string|string[]} targetDir (List of) Directory where built definitions will be saved
-     * @param {ScriptItem} metadata main JSON file that was read from file system
-     * @param {Util.TemplateMap} variables variables to be replaced in the metadata
+     * @param {TYPE.ScriptItem} 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} Promise
+     * @returns {Promise.<string[][]>} list of extracted files with path-parts provided as an array
      */
-    static async buildDefinitionForExtracts(
+    static buildDefinitionForNested(
         templateDir,
         targetDir,
         metadata,
-        variables,
+        templateVariables,
         templateName
     ) {
-        // get SSJS from filesystem
-        let code = this._mergeCode(metadata, templateDir, templateName);
+        return this._buildForNested(
+            templateDir,
+            targetDir,
+            metadata,
+            templateVariables,
+            templateName,
+            'definition'
+        );
+    }
+    /**
+     * helper for buildTemplate
+     * handles extracted code if any are found for complex types
+     *
+     * @example scripts are saved as 1 json and 1 ssjs 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.ScriptItem} 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.<string[][]>} list of extracted files with path-parts provided as an array
+     */
+    static buildTemplateForNested(
+        templateDir,
+        targetDir,
+        metadata,
+        templateVariables,
+        templateName
+    ) {
+        return this._buildForNested(
+            templateDir,
+            targetDir,
+            metadata,
+            templateVariables,
+            templateName,
+            'template'
+        );
+    }
 
-        // replace template variables with their values
+    /**
+     * helper for buildTemplateForNested / buildDefinitionForNested
+     * handles extracted code if any are found for complex types
+     *
+     * @param {string} templateDir Directory where metadata templates are stored
+     * @param {string|string[]} targetDir (List of) Directory where built definitions will be saved
+     * @param {TYPE.ScriptItem} 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.<string[][]>} list of extracted files with path-parts provided as an array
+     */
+    static async _buildForNested(
+        templateDir,
+        targetDir,
+        metadata,
+        templateVariables,
+        templateName,
+        mode
+    ) {
+        // get SSJS from filesystem
+        let code = await this._mergeCode(metadata, templateDir, templateName);
         try {
-            code = Mustache.render(code, variables);
-        } catch (ex) {
+            if (mode === 'definition') {
+                // replace template variables with their values
+                code = this.applyTemplateValues(code, templateVariables);
+            } else if (mode === 'template') {
+                // replace template values with corresponding variable names
+                code = this.applyTemplateNames(code, templateVariables);
+            }
+        } catch {
             throw new Error(
                 `${this.definition.type}:: Error applying template variables on ${
                     metadata[this.definition.keyField] + '.' + this.definition.type
@@ -193,6 +232,7 @@ class Script extends MetadataType {
 
         // write to file
         const targetDirArr = Array.isArray(targetDir) ? targetDir : [targetDir];
+        const nestedFilePaths = [];
 
         for (const targetDir of targetDirArr) {
             File.writeToFile(
@@ -201,19 +241,25 @@ class Script extends MetadataType {
                 'ssjs',
                 code
             );
+            nestedFilePaths.push([
+                targetDir,
+                this.definition.type,
+                metadata[this.definition.keyField] + '.' + this.definition.type + '-meta.ssjs',
+            ]);
         }
+        return nestedFilePaths;
     }
 
     /**
      * Splits the script metadata into two parts and parses in a standard manner
-     * @param {ScriptItem} metadata a single script activity definition
-     * @returns {CodeExtractItem} a single item with code parts extracted
+     *
+     * @param {TYPE.ScriptItem} metadata a single script activity definition
+     * @returns {TYPE.CodeExtractItem} a single item with code parts extracted
      */
     static parseMetadata(metadata) {
         // folder
         try {
-            metadata.r__folder_Path = Util.getFromCache(
-                this.cache,
+            metadata.r__folder_Path = cache.searchForField(
                 'folder',
                 metadata.categoryId,
                 'ID',
@@ -221,7 +267,7 @@ class Script extends MetadataType {
             );
             delete metadata.categoryId;
         } catch (ex) {
-            Util.logger.warn(`Script '${metadata.key}': ${ex.message}`);
+            Util.logger.warn(` - Script '${metadata.key}': ${ex.message}`);
         }
 
         // extract SSJS
@@ -231,15 +277,14 @@ class Script extends MetadataType {
         let ssjs;
         let fileExt;
         const regexMatches = regex.exec(metadata.script);
-        if (regexMatches && regexMatches.length > 1) {
+        if (regexMatches?.length > 1) {
             ssjs = regexMatches[1];
             fileExt = 'ssjs';
         } else {
             ssjs = metadata.script;
             fileExt = 'html';
             Util.logger.warn(
-                'Script.parseMetadata:: Could not find script tags, saving whole text in SSJS: ' +
-                    metadata.name
+                ' - Could not find script tags, saving whole text in SSJS: ' + metadata.name
             );
         }
         delete metadata.script;
@@ -252,11 +297,30 @@ class Script extends MetadataType {
 
         return { json: metadata, codeArr: codeArr, subFolder: null };
     }
+    /**
+     * 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 getFilesToCommit(keyArr) {
+        const path = File.normalizePath([
+            this.properties.directories.retrieve,
+            this.buObject.credential,
+            this.buObject.businessUnit,
+            this.definition.type,
+        ]);
+
+        const fileList = keyArr.flatMap((key) => [
+            File.normalizePath([path, `${key}.${this.definition.type}-meta.json`]),
+            File.normalizePath([path, `${key}.${this.definition.type}-meta.ssjs`]),
+        ]);
+        return fileList;
+    }
 }
 
 // Assign definition & cache to static attributes
 Script.definition = require('../MetadataTypeDefinitions').script;
-Script.cache = {};
-Script.client = undefined;
 
 module.exports = Script;