mcdev 7.0.3 → 7.1.0

package/lib/util/replaceContentBlockReference.js

@@ -2,6 +2,7 @@
 
 import auth from './auth.js';
 import cache from './cache.js';
+import File from './file.js';
 import { Util } from '../util/util.js';
 
 import Folder from '../metadataTypes/Folder.js';
@@ -29,6 +30,8 @@ import Asset from '../metadataTypes/Asset.js';
  * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
  * @typedef {import('../../types/mcdev.d.js').TypeKeyCombo} TypeKeyCombo
  * @typedef {import('../../types/mcdev.d.js').SDKError} SDKError
+ *
+ * @typedef {import('../../types/mcdev.d.js').AssetMap} AssetMap
  * @typedef {import('../../types/mcdev.d.js').AssetItemSimple} AssetItemSimple
  * @typedef {import('../../types/mcdev.d.js').AssetItemSimpleMap} AssetItemSimpleMap
  * @typedef {import('../../types/mcdev.d.js').AssetItemIdSimpleMap} AssetItemIdSimpleMap
@@ -86,18 +89,20 @@ export default class ReplaceContentBlockReference {
      *
      * @param {string} str full code string
      * @param {string} parentName name of the object that was passed in; used in error message only
-     * @param {ContentBlockConversionTypes[]} [fromList] what to replace
-     * @param {ContentBlockConversionTypes} [to] what to replace with
+     * @param {Set.<string>} [findAssetKeys] list of keys that were found referenced via ContentBlockByX; if set, method only gets keys and runs no updates
      * @returns {string} replaced string
      */
-    static replaceReference(str, parentName, fromList, to) {
+    static replaceReference(str, parentName, findAssetKeys) {
         if (!str) {
             const ex = new Error('No string provided');
+            // @ts-expect-error custom error object
             ex.code = 200;
             throw ex;
         }
-        fromList ||= Util.OPTIONS.referenceFrom;
-        to ||= Util.OPTIONS.referenceTo;
+        /** @type {ContentBlockConversionTypes[]} */
+        const fromList = Util.OPTIONS.referenceFrom;
+        /** @type {ContentBlockConversionTypes} */
+        const to = Util.OPTIONS.referenceTo;
         let result = str;
         let changes = 0;
         const languages = [
@@ -117,7 +122,12 @@ export default class ReplaceContentBlockReference {
                         if (referencedAsset && referencedAsset[to]) {
                             // make sure we not only found the asset but also have a replacement for it (folder issue could block swap to ContentBlockByName)
                             changes++;
-                            return this.#replaceWith(referencedAsset, to, lang.isSsjs);
+                            if (findAssetKeys) {
+                                findAssetKeys.add(referencedAsset.key);
+                                return;
+                            } else {
+                                return this.#replaceWith(referencedAsset, to, lang.isSsjs);
+                            }
                         } else {
                             if (referencedAsset && !referencedAsset[to]) {
                                 // this is expected to only happen if to=="name"
@@ -133,6 +143,7 @@ export default class ReplaceContentBlockReference {
         }
         if (!changes) {
             const ex = new Error('No changes made to the code.');
+            // @ts-expect-error custom error object
             ex.code = 200;
             throw ex;
         }
@@ -158,7 +169,7 @@ export default class ReplaceContentBlockReference {
                 break;
             }
             case 'name': {
-                if (isSsjs) {
+                if (isSsjs && typeof identifier === 'string') {
                     identifier = identifier.replaceAll('\\\\', '\\');
                 }
                 reference = ReplaceContentBlockReference.assetCacheMap.name[identifier];
@@ -193,40 +204,34 @@ export default class ReplaceContentBlockReference {
     }
 
     /**
+     * ensures we cache the right things from disk and if required from server
      *
      * @param {Mcdevrc} properties properties for auth
 saved
      * @param {BuObject} buObject properties for auth
+     * @param {boolean} [retrieveSharedOnly] for --dependencies only, do not have to re-retrieve local assets
+     * @returns {Promise.<void>} -
      */
-    static async createCacheMap(properties, buObject) {
-        const client = auth.getSDK(buObject);
-
-        if (!cache.getCache()) {
-            cache.initCache(buObject);
-        }
-        Util.logger.info('Caching folders');
-        Folder.buObject = buObject;
-        Folder.properties = properties;
-        Folder.client = client;
-        const resultFolder = await Folder.retrieveForCache(null, ['asset', 'asset-shared']);
-        cache.setMetadata('folder', resultFolder.metadata);
+    static async createCacheMap(properties, buObject, retrieveSharedOnly = false) {
+        const { localAssets, sharedAssets } = await ReplaceContentBlockReference._retrieveCache(
+            buObject,
+            properties,
+            retrieveSharedOnly
+        );
 
-        Util.logger.info('Caching assets');
-        Asset.buObject = buObject;
-        Asset.properties = properties;
-        Asset.client = client;
-        const resultAsset = await Asset.retrieveForCache(undefined, [
-            'asset',
-            'code',
-            'textfile',
-            'block',
-            'other',
-        ]);
-        for (const element of Object.values(resultAsset.metadata)) {
-            // ensure we got the folder-path in our cache
-            Asset.setFolderPath(element);
+        ReplaceContentBlockReference._createCacheMap(localAssets);
+        ReplaceContentBlockReference._createCacheMap(sharedAssets);
+    }
 
+    /**
+     * helper for {@link this.createCacheMap} that converts AssetMap into Asset
+     *
+     * @param {AssetMap} metadataMap list of local or shared assets
+     */
+    static _createCacheMap(metadataMap) {
+        for (const element of Object.values(metadataMap)) {
             // create actual cache map
+            /** @type {AssetItemSimple} */
             const simpleAsset = {
                 id: element.id,
                 key: element.customerKey,
@@ -235,44 +240,88 @@ saved
                     : null,
             };
             // ! note that ContentBlockByName expects backslashes between folders and file name, not forward slashes
-            ReplaceContentBlockReference.assetCacheMap.id[simpleAsset.id] = simpleAsset;
-            ReplaceContentBlockReference.assetCacheMap.key[simpleAsset.key] = simpleAsset;
+            this.assetCacheMap.id[simpleAsset.id] = simpleAsset;
+            this.assetCacheMap.key[simpleAsset.key] = simpleAsset;
             if (simpleAsset.name) {
                 // while asset without path could still be found via search, it would no longer referencable via ContentBlockByName
-                ReplaceContentBlockReference.assetCacheMap.name[simpleAsset.name] = simpleAsset;
+                this.assetCacheMap.name[simpleAsset.name] = simpleAsset;
             }
         }
+    }
 
-        cache.setMetadata('asset', resultAsset.metadata);
+    /**
+     * helper for {@link this.createCacheMap}
+     *
+     * @param {BuObject} buObject references credentials
+     * @param {Mcdevrc} properties central properties object
+     * @param {boolean} [retrieveSharedOnly] for --dependencies only, do not have to re-retrieve local assets
+     * @returns {Promise.<{localAssets: AssetMap, sharedAssets: AssetMap}>} -
+     */
+    static async _retrieveCache(buObject, properties, retrieveSharedOnly = false) {
+        const client = auth.getSDK(buObject);
 
-        Util.logger.info('Caching shared assets');
-        const resultAssetShared = await Asset.retrieveForCache(
-            undefined,
-            ['asset', 'code', 'textfile', 'block', 'other'],
-            undefined,
-            true
-        );
-        for (const element of Object.values(resultAssetShared.metadata)) {
-            // ensure we got the folder-path in our cache
-            Asset.setFolderPath(element);
+        if (!cache.getCache()) {
+            cache.initCache(buObject);
+        }
+        Util.logger.info(' - Caching folders');
+        Folder.buObject = buObject;
+        Folder.properties = properties;
+        Folder.client = client;
+        const resultFolder = await Folder.retrieveForCache(null, ['asset', 'asset-shared']);
+        cache.setMetadata('folder', resultFolder.metadata);
 
-            // create actual cache map
-            const simpleAsset = {
-                id: element.id,
-                key: element.customerKey,
-                name: element.r__folder_Path
-                    ? element.r__folder_Path.replaceAll('/', '\\') + '\\' + element.name
-                    : null,
-            };
-            // ! note that ContentBlockByName expects backslashes between folders and file name, not forward slashes
-            ReplaceContentBlockReference.assetCacheMap.id[simpleAsset.id] = simpleAsset;
-            ReplaceContentBlockReference.assetCacheMap.key[simpleAsset.key] = simpleAsset;
-            if (simpleAsset.name) {
-                // while asset without path could still be found via search, it would no longer referencable via ContentBlockByName
-                ReplaceContentBlockReference.assetCacheMap.name[simpleAsset.name] = simpleAsset;
+        let localAssets;
+        if (retrieveSharedOnly) {
+            Util.logger.debug(' - Caching assets locally');
+            if (!Asset.getJsonFromFSCache) {
+                // avoid re-reading the same files in every recursive iteration
+                Asset.getJsonFromFSCache = await Asset.getJsonFromFS(
+                    File.normalizePath([
+                        properties.directories.retrieve,
+                        buObject.credential,
+                        buObject.businessUnit,
+                        Asset.definition.type,
+                    ])
+                );
+            }
+            localAssets = Asset.getJsonFromFSCache;
+            cache.setMetadata('asset', Asset.getJsonFromFSCache);
+        } else {
+            Util.logger.info(' - Caching assets from server');
+            Asset.buObject = buObject;
+            Asset.properties = properties;
+            Asset.client = client;
+            const resultAsset = await Asset.retrieveForCache(
+                undefined,
+                Asset.definition.crosslinkedSubTypes
+            );
+            for (const element of Object.values(resultAsset.metadata)) {
+                // ensure we got the folder-path in our cache
+                Asset.setFolderPath(element);
             }
+            localAssets = resultAsset.metadata;
+            cache.setMetadata('asset', resultAsset.metadata);
         }
 
+        // get shared assets
+        Util.logger.info(' - Caching shared assets from server (not stored on disk)');
+        Asset.buObject = buObject;
+        Asset.properties = properties;
+        Asset.client = client;
+        const sharedAssets = (
+            await Asset.retrieveForCache(
+                undefined,
+                Asset.definition.crosslinkedSubTypes,
+                undefined,
+                true
+            )
+        )?.metadata;
         // lets not put the shared assets into our cache to avoid confusing the system...
+
+        for (const element of Object.values(sharedAssets)) {
+            // ensure we got the folder-path in our cache
+            Asset.setFolderPath(element);
+        }
+        return { localAssets, sharedAssets };
     }
 }

package/lib/util/util.js

@@ -103,7 +103,7 @@ export const Util = {
             return true;
         } else {
             Util.logger.error(`Could not find the market '${market}' in your configuration file.`);
-            const marketArr = Object.values(properties.markets);
+            const marketArr = Object.keys(properties.markets);
 
             if (marketArr.length) {
                 Util.logger.info('Available markets are: ' + marketArr.join(', '));
@@ -797,13 +797,14 @@ export const Util = {
      * helper to print the subtypes we filtered by
      *
      * @param {string[]} subTypeArr list of subtypes to be printed
+     * @param {string} [indent] optional prefix of spaces to be added to the log message
      * @returns {void}
      */
-    logSubtypes(subTypeArr) {
+    logSubtypes(subTypeArr, indent = '') {
         if (subTypeArr && subTypeArr.length > 0) {
             Util.logger.info(
                 Util.getGrayMsg(
-                    ` - Subtype${subTypeArr.length > 1 ? 's' : ''}: ${subTypeArr.join(', ')}`
+                    `${indent} - Subtype${subTypeArr.length > 1 ? 's' : ''}: ${[...subTypeArr].sort().join(', ')}`
                 )
             );
         }
@@ -837,6 +838,10 @@ export const Util = {
      * @returns {Promise.<void>} - promise to wait for
      */
     async sleep(ms) {
+        if (Util.OPTIONS._runningTest) {
+            Util.logger.debug('Skipping sleep in test mode');
+            return;
+        }
         return new Promise((resolve) => {
             setTimeout(resolve, ms);
         });
@@ -956,7 +961,7 @@ export const Util = {
     /**
      * helper for Retriever and Deployer class
      *
-     * @param {string[]} typeArr -
+     * @param {string | string[]} typeArr -
      * @param {string[]} keyArr -
      * @param {boolean} [returnEmpty] returns array with null element if false/not set; Retriever needs this to be false; Deployer needs it to be true
      * @returns {TypeKeyCombo} -
@@ -968,6 +973,9 @@ export const Util = {
         }
         /** @type {TypeKeyCombo} */
         const typeKeyMap = {};
+        if ('string' === typeof typeArr) {
+            typeArr = [typeArr];
+        }
         // no keys or array of keys was provided (likely called via CLI or to retrieve all)
         // transform into TypeKeyCombo to iterate over it
         for (const type of typeArr) {
@@ -975,6 +983,73 @@ export const Util = {
         }
         return typeKeyMap;
     },
+    /**
+     * helper that converts TypeKeyCombo objects into a string with all relevant -m parameters
+     *
+     * @param {TypeKeyCombo} [selectedTypes] selected metadata types & key
+     * @returns {string} object converted into --metadata parameters
+     */
+    convertTypeKeyToCli(selectedTypes) {
+        return selectedTypes
+            ? Object.keys(selectedTypes)
+                  .reduce((previousValue, type) => {
+                      previousValue.push(
+                          ...selectedTypes[type].map((key) =>
+                              key === null ? `-m ${type}` : `-m "${type}:${key}"`
+                          )
+                      );
+                      return previousValue;
+                  }, [])
+                  .join(' ')
+            : '';
+    },
+    /**
+     * helper that converts TypeKeyCombo objects into a string with all relevant -m parameters
+     *
+     * @param {TypeKeyCombo} [selectedTypes] selected metadata types & key
+     * @returns {string} object converted into --metadata parameters
+     */
+    convertTypeKeyToString(selectedTypes) {
+        return selectedTypes
+            ? Object.keys(selectedTypes)
+                  .reduce((previousValue, type) => {
+                      previousValue.push(
+                          selectedTypes[type]
+                              .map((key, index) => {
+                                  let response = '';
+                                  if (index === 0) {
+                                      response += `${type}`;
+                                  }
+                                  if (key !== null && index === 0) {
+                                      response += ' (';
+                                  }
+                                  response += key === null ? `` : `"${key}"`;
+                                  if (key !== null && index === selectedTypes[type].length - 1) {
+                                      response += ')';
+                                  }
+                                  return response;
+                              })
+                              .join(', ')
+                      );
+                      return previousValue;
+                  }, [])
+                  .join(', ')
+            : '';
+    },
+    /**
+     * helper that checks how many keys are defined in TypeKeyCombo object
+     *
+     * @param {TypeKeyCombo} [selectedTypes] selected metadata types & key
+     * @returns {number} amount of keys across all types
+     */
+    getTypeKeyCount(selectedTypes) {
+        return Object.keys(selectedTypes).reduce(
+            (previousValue, type) =>
+                previousValue + (selectedTypes[type] ? selectedTypes[type].length : 0),
+            0
+        );
+    },
+
     /**
      * async version of Array.find()
      * returns the first element in the provided array that satisfies the provided testin function
@@ -990,6 +1065,17 @@ export const Util = {
             }
         }
     },
+    /**
+     *
+     * @param {Array} array array to be chunked
+     * @param {number} chunk_size integer > 0
+     * @returns {Array[]} array of arrays with max chunk_size members per element, last element might have less
+     */
+    chunk(array, chunk_size) {
+        return array.length == 0
+            ? []
+            : [array.splice(0, chunk_size)].concat(this.chunk(array, chunk_size));
+    },
 };
 
 Util.startLogger(false, true);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mcdev",
-    "version": "7.0.3",
+    "version": "7.1.0",
     "description": "Accenture Salesforce Marketing Cloud DevTools",
     "author": "Accenture: joern.berkefeld, douglas.midgley, robert.zimmermann, maciej.barnas",
     "license": "MIT",
@@ -54,7 +54,7 @@
         "debug": "node --nolazy --inspect-brk=9229 lib/cli.js",
         "lint:fix": "eslint --fix lib/**/*.js types/*.js test/**/*.js",
         "lint": "eslint lib/**/*.js types/*.js test/**/*.js",
-        "lint-ts": "tsc -p jsconfig.json --maxNodeModuleJsDepth 1 --noEmit",
+        "lint-ts": "tsc -p tsconfig.npmScripts.json",
         "prepare": "husky || true",
         "lint-and-test": "run-s lint test",
         "test": "mocha --reporter-option maxDiffSize=25000",
@@ -71,45 +71,48 @@
         "console.table": "0.10.0",
         "deep-equal": "2.2.3",
         "fs-extra": "11.2.0",
-        "inquirer": "9.2.6",
+        "inquirer": "10.0.1",
         "json-to-table": "4.2.1",
         "mustache": "4.2.0",
-        "p-limit": "5.0.0",
-        "prettier": "3.3.2",
-        "prettier-plugin-sql": "0.18.0",
-        "semver": "7.6.0",
-        "sfmc-sdk": "2.0.1",
+        "p-limit": "6.1.0",
+        "prettier": "3.3.3",
+        "prettier-plugin-sql": "0.18.1",
+        "semver": "7.6.3",
+        "sfmc-sdk": "2.1.1",
         "simple-git": "3.25.0",
         "toposort": "2.0.2",
         "update-notifier": "7.0.0",
-        "winston": "3.13.0",
+        "winston": "3.13.1",
         "yargs": "17.7.2"
     },
     "devDependencies": {
-        "@eslint/js": "9.6.0",
-        "@types/mocha": "10.0.6",
-        "@types/node": "20.14.9",
+        "@eslint/js": "9.7.0",
+        "@types/fs-extra": "11.0.4",
+        "@types/inquirer": "9.0.7",
+        "@types/mocha": "10.0.7",
+        "@types/node": "20.14.10",
+        "@types/yargs": "17.0.32",
         "assert": "2.1.0",
         "axios-mock-adapter": "1.22.0",
         "c8": "10.0.0",
         "chai": "5.1.1",
         "chai-files": "1.4.0",
-        "eslint": "9.6.0",
+        "eslint": "9.7.0",
         "eslint-config-prettier": "9.1.0",
         "eslint-config-ssjs": "2.0.0",
-        "eslint-plugin-jsdoc": "48.2.7",
+        "eslint-plugin-jsdoc": "48.8.3",
         "eslint-plugin-mocha": "10.4.3",
-        "eslint-plugin-prettier": "5.1.2",
-        "eslint-plugin-unicorn": "53.0.0",
+        "eslint-plugin-prettier": "5.2.1",
+        "eslint-plugin-unicorn": "54.0.0",
         "fast-xml-parser": "4.4.0",
-        "globals": "15.6.0",
+        "globals": "15.8.0",
         "husky": "9.0.11",
         "lint-staged": "15.2.7",
-        "mocha": "10.4.0",
+        "mocha": "10.7.0",
         "mock-fs": "5.2.0",
         "npm-run-all": "4.1.5",
         "prettier-eslint": "16.3.0",
-        "typescript": "5.4.5"
+        "typescript": "5.5.3"
     },
     "optionalDependencies": {
         "fsevents": "*"