mcdev 7.6.3 → 7.7.1

package/lib/metadataTypes/Asset.js

@@ -188,13 +188,13 @@ class Asset extends MetadataType {
     }
 
     /**
-     * Returns Order in which metadata needs to be retrieved/deployed
+     * Returns Order in which metadata needs to be retrieved/deployed and skips components with missing components
      *
-     * @param {AssetMap} metadataMap metadata mapped by their keyField
+     * @param {AssetMap} metadataMap metadata thats about to be deployed
      * @param {string} deployDir directory where deploy metadata are saved
      * @returns {Promise.<AssetMap>} keyField => metadata map but sorted to ensure dependencies are deployed in correct order
      */
-    static async _getUpsertOrder(metadataMap, deployDir) {
+    static async _getUpsertOrderAndSkipMissing(metadataMap, deployDir) {
         /**
          * one entry for each dependency with the first item being the key thats required by the second item
          *
@@ -207,29 +207,44 @@ class Asset extends MetadataType {
         Util.OPTIONS.referenceTo = 'key';
         // loop through all metadata types which are being retrieved/deployed
         for (const key in metadataMap) {
+            const errors = [];
             const findAssetKeys = new Set();
+            // find asset references in metadata
+            const findAssetKeyMeta = Util.findLeafVals(metadataMap[key], 'r__asset_key');
+            for (const metaKey of findAssetKeyMeta) {
+                if (metadataMap[key] || cache.getByKey(this.definition.type, metaKey)) {
+                    findAssetKeys.add(metaKey);
+                } else {
+                    errors.push(
+                        `content block ${metaKey} that is referenced via r__asset_key was not found on BU nor in deployment package`
+                    );
+                }
+            }
             try {
                 // find asset references in code
                 await this.replaceCbReference(metadataMap[key], deployDir, findAssetKeys);
-                // find asset references in metadata
-                const findAssetKeyMeta = Util.findLeafVals(metadataMap[key], 'r__asset_key');
-                for (const metaKey of findAssetKeyMeta) {
-                    findAssetKeys.add(metaKey);
+            } catch (ex) {
+                if (ex.code === 200) {
+                    // no dependent keys found
+                    // good from this perspective
+                } else {
+                    errors.push(
+                        `content block ${ex.message} that is referenced via ContentBlockByX was not found on BU nor in deployment package`
+                    );
                 }
-
+            }
+            if (errors.length) {
+                Util.logger.error(
+                    ` ☇ skipping ${this.definition.type} ${key}:${errors.length > 1 ? '\n        ·' : ''} ${errors.join('\n        · ')}`
+                );
+            } else {
                 const dependentKeys = [...findAssetKeys];
                 if (dependentKeys.length > 0) {
                     dependencies.push(...dependentKeys.map((depKey) => [depKey, key]));
                 } else {
-                    Util.logger.debug('Asset._getUpsertOrder: this case should not happen');
+                    Util.logger.debug('Asset._getUpsertOrder: no dependent keys found for ' + key);
                     dependencies.push([undefined, key]);
                 }
-            } catch (ex) {
-                if (ex.code !== 200) {
-                    Util.logger.errorStack(ex, 'Cannot find related code blocks for ' + key);
-                }
-                // no dependent keys found
-                dependencies.push([undefined, key]);
             }
         }
 
@@ -240,7 +255,9 @@ class Asset extends MetadataType {
         const metadataTypeMapSorted = {};
         // group subtypes per type
         for (const key of flatList) {
-            metadataTypeMapSorted[key] = metadataMap[key];
+            if (metadataMap[key]) {
+                metadataTypeMapSorted[key] = metadataMap[key];
+            }
         }
         return metadataTypeMapSorted;
     }
@@ -253,12 +270,13 @@ class Asset extends MetadataType {
      * @returns {Promise.<AssetMap>} keyField => metadata map
      */
     static async upsert(metadataMap, deployDir) {
-        if (Object.keys(metadataMap).length > 1) {
-            // fill the cache map with our deployment package to ensure we can find
-            ReplaceCbReference.createCacheForMap(metadataMap);
-            // assets can link to other assets (via template, content block reference and SSJS/AMPscript) and deployment would fail if we did not sort this here
-            metadataMap = await this._getUpsertOrder(metadataMap, deployDir);
-        }
+        // add already existing, cached items to our cache map to ensure we can find them
+        ReplaceCbReference.createCacheForMap(cache.getCache().asset);
+        // await ReplaceCbReference.createCache(this.properties, this.buObject, true);
+        // fill the cache map with our deployment package to ensure we can find
+        ReplaceCbReference.createCacheForMap(metadataMap);
+        // assets can link to other assets (via template, content block reference and SSJS/AMPscript) and deployment would fail if we did not sort this here
+        metadataMap = await this._getUpsertOrderAndSkipMissing(metadataMap, deployDir);
         return super.upsert(metadataMap, deployDir, true);
     }
 
@@ -274,6 +292,32 @@ class Asset extends MetadataType {
         return super.createREST(metadata, uri);
     }
 
+    /**
+     * helper for {@link MetadataType.createREST}
+     *
+     * @param {MetadataTypeItem} metadataEntry a single metadata Entry
+     * @param {object} apiResponse varies depending on the API call
+     * @returns {Promise.<object>} apiResponse, potentially modified
+     */
+    static async postCreateTasks(metadataEntry, apiResponse) {
+        if (apiResponse[this.definition.idField]) {
+            // this also happens inside of MetadataType.upsert but we need it for createCacheMap()
+            // ensure we have the ID in the cache
+            metadataEntry[this.definition.idField] = apiResponse[this.definition.idField];
+        }
+        if (apiResponse.objectID) {
+            // ensure we have the asset objectId in the cache
+            metadataEntry.objectID = apiResponse.objectID;
+        }
+
+        // make this newly created item available in cache for other itmes that might reference it
+        /** @type {MetadataTypeMap} */
+        const newObject = {};
+        newObject[metadataEntry[this.definition.keyField]] = metadataEntry;
+        ReplaceCbReference.createCacheForMap(newObject);
+        return apiResponse;
+    }
+
     /**
      * Updates a single asset
      *
@@ -799,6 +843,16 @@ class Asset extends MetadataType {
         // folder
         this.setFolderId(metadata);
 
+        if (
+            metadata.assetType.name === 'webpage' &&
+            !cache.getByKey(this.definition.type, metadata[this.definition.keyField])
+        ) {
+            // we are attempting to CREATE a cloudpage asset which needs to be prevented.
+            throw new Error(
+                'CloudPages cannot be created via mcdev. Please create it via the UI first, then change its key to the value required by you, and finally, re-run this deployment.'
+            );
+        }
+
         // template-based emails
         if (
             metadata.assetType.name === 'templatebasedemail' &&

package/lib/metadataTypes/DataExtension.js

@@ -53,7 +53,15 @@ class DataExtension extends MetadataType {
         let filteredByPreDeploy = 0;
         for (const metadataKey in metadataMap) {
             try {
-                await this.validation('deploy', metadataMap[metadataKey], deployDir);
+                metadataMap[metadataKey] = await this.validation(
+                    'deploy',
+                    metadataMap[metadataKey],
+                    deployDir
+                );
+                if (!metadataMap[metadataKey]) {
+                    filteredByPreDeploy++;
+                    continue;
+                }
                 metadataMap[metadataKey] = await this.preDeployTasks(metadataMap[metadataKey]);
 
                 await this.createOrUpdate(
@@ -394,7 +402,7 @@ class DataExtension extends MetadataType {
         }
 
         // find all shared data extensions
-        if (!this.deployedSharedKeys.length) {
+        if (!this.deployedSharedKeys?.length) {
             Util.logger.debug(
                 `Skipping fixShared logic because no Shared Data Extensions were updated`
             );

package/lib/metadataTypes/DomainVerification.js

@@ -0,0 +1,246 @@
+'use strict';
+
+import MetadataType from './MetadataType.js';
+import { Util } from '../util/util.js';
+import cache from '../util/cache.js';
+
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ * @typedef {import('../../types/mcdev.d.js').DomainVerificationItem} DomainVerificationItem
+ */
+
+/**
+ * DomainVerification MetadataType
+ *
+ * @augments MetadataType
+ */
+class DomainVerification extends MetadataType {
+    /**
+     * Retrieves Metadata ofDomainVerification.
+     * Endpoint /automation/v1/dataextracts/ returns all items
+     *
+     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
+     */
+    static async retrieve(retrieveDir, _, __, key) {
+        return super.retrieveREST(retrieveDir, '/messaging/v1/domainverification/', null, key);
+    }
+
+    /**
+     * Retrieves Metadata of DomainVerification for caching
+     *
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
+     */
+    static async retrieveForCache() {
+        return super.retrieveREST(null, '/messaging/v1/domainverification/');
+    }
+
+    /**
+     * Creates a single item
+     *
+     * @param {DomainVerificationItem} metadataItem a single item
+     * @returns {Promise} Promise
+     */
+    static create(metadataItem) {
+        return super.createREST(metadataItem, '/messaging/v1/domainverification/');
+    }
+
+    /**
+     * helper for {@link MetadataType.createREST}
+     *
+     * @param {DomainVerificationItem} metadataEntry a single metadata Entry
+     * @param {object} apiResponse varies depending on the API call
+     * @returns {Promise.<DomainVerificationItem>} apiResponse
+     */
+    static async postCreateTasks(metadataEntry, apiResponse) {
+        if (apiResponse && apiResponse === `${metadataEntry.domain} successfully added.`) {
+            return metadataEntry;
+        } else {
+            throw new Error(apiResponse);
+        }
+    }
+
+    /**
+     * helper for {@link update}
+     *
+     * @param {DomainVerificationItem} metadataEntry a single metadata Entry
+     * @param {object} apiResponse varies depending on the API call
+     * @returns {Promise.<DomainVerificationItem>} apiResponse, potentially modified
+     */
+    static async postUpdateTasks(metadataEntry, apiResponse) {
+        if (apiResponse && apiResponse === `1 records successfully updated!`) {
+            metadataEntry.domain = metadataEntry.emailAddress;
+            return metadataEntry;
+        } else {
+            throw new Error(apiResponse);
+        }
+    }
+
+    /**
+     * Updates a single item; replaces super.updateREST because we need to send metadataItem as an array for some reason and also get an array back
+     *
+     * @param {DomainVerificationItem} metadataItem a single item
+     * @returns {Promise.<DomainVerificationItem>} Promise
+     */
+    static async update(metadataItem) {
+        const uri = '/messaging/v1/domainverification/update';
+
+        this.removeNotUpdateableFields(metadataItem);
+        try {
+            // set to empty object in case API returned nothing to be able to update it in helper classes
+            let response = (await this.client.rest.post(uri, [metadataItem])) || {};
+            this.getErrorsREST(response);
+            response = await this.postUpdateTasks(metadataItem, response);
+            // some times, e.g. automation dont return a key in their update response and hence we need to fall back to name
+            Util.logger.info(` - updated ${Util.getTypeKeyName(this.definition, metadataItem)}`);
+            return metadataItem;
+        } catch (ex) {
+            const parsedErrors = this.getErrorsREST(ex);
+            Util.logger.error(
+                ` ☇ error updating ${Util.getTypeKeyName(this.definition, metadataItem)}:`
+            );
+            for (const msg of parsedErrors) {
+                Util.logger.error('   • ' + msg);
+            }
+            return null;
+        }
+    }
+    /**
+     * manages post retrieve steps
+     *
+     * @param {DomainVerificationItem} metadataItem a single item
+     * @returns {DomainVerificationItem} metadata
+     */
+    static postRetrieveTasks(metadataItem) {
+        if (metadataItem.status !== 'Verified') {
+            Util.logger.warn(
+                Util.getMsgPrefix(this.definition, metadataItem) +
+                    ` is not verified. Current status: ${metadataItem.status}`
+            );
+        }
+        if (!metadataItem.isSendable) {
+            Util.logger.warn(
+                Util.getMsgPrefix(this.definition, metadataItem) + ` is not sendable.`
+            );
+        }
+        return metadataItem;
+    }
+
+    /**
+     * Gets executed after deployment of metadata type
+     *
+     * @param {MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
+     * @returns {Promise.<void>} -
+     */
+    static async postDeployTasks(upsertResults) {
+        // re-retrieve all upserted items to ensure we have all fields (createdDate and modifiedDate are otherwise not present)
+        Util.logger.debug(
+            `Caching all ${this.definition.type} post-deploy to ensure we have all fields`
+        );
+        const typeCache = await this.retrieveForCache();
+        // update values in upsertResults with retrieved values before saving to disk
+        for (const key of Object.keys(upsertResults)) {
+            if (typeCache.metadata[key]) {
+                upsertResults[key] = typeCache.metadata[key];
+            }
+        }
+    }
+
+    /**
+     * prepares a single item for deployment
+     *
+     * @param {DomainVerificationItem} metadata a single item
+     * @returns {Promise.<DomainVerificationItem>} Promise
+     */
+    static async preDeployTasks(metadata) {
+        if (metadata.domainType && metadata.domainType !== 'UserDomain') {
+            throw new Error(
+                `Can only delete entries of type 'UserDomain'. Found: ${metadata.domainType}`
+            );
+        }
+        // prep for update which uses emailAddress instead of domain
+        metadata.emailAddress = metadata.domain;
+
+        return metadata;
+    }
+
+    /**
+     * Gets executed before deleting a list of keys for the current type
+     *
+     * @returns {Promise.<void>} -
+     */
+    static async preDeleteTasks() {
+        if (!cache.getCache()) {
+            cache.initCache(this.buObject);
+        }
+        if (!cache.getCache()?.[this.definition.type]) {
+            const cached = await this.retrieveForCache();
+            if (cached) {
+                cache.setMetadata(this.definition.type, cached?.metadata);
+            }
+        }
+    }
+
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {string} key Identifier of data extension
+     * @returns {Promise.<boolean>} deletion success flag
+     */
+    static async deleteByKey(key) {
+        const metadataItem = cache.getByKey(this.definition.type, key);
+        if (!metadataItem) {
+            Util.logger.error(` - ${this.definition.type} ${key} not found`);
+            return false;
+        }
+        if (metadataItem.domainType !== 'UserDomain') {
+            Util.logger.error(
+                ` - ${this.definition.type} ${key}: Can only delete entries of type UserDomain. Found: ${metadataItem.domainType}`
+            );
+            return false;
+        }
+        try {
+            const response = await this.client.rest.post(
+                '/messaging/v1/domainverification/delete',
+                [
+                    {
+                        emailAddress: metadataItem.domain,
+                        domainType: metadataItem.domainType,
+                    },
+                ]
+            );
+            if (response === '1 records successfully updated!') {
+                Util.logger.info(` - deleted ${this.definition.type}: ${key}`);
+                this.postDeleteTasks(key);
+                return true;
+            } else {
+                Util.logger.error(
+                    ` - Deleting ${this.definition.type} '${key}' failed: ` + response
+                );
+                return false;
+            }
+        } catch (ex) {
+            Util.logger.errorStack(ex, ` - Deleting ${this.definition.type} '${key}' failed`);
+
+            return false;
+        }
+    }
+}
+
+// Assign definition to static attributes
+import MetadataTypeDefinitions from '../MetadataTypeDefinitions.js';
+DomainVerification.definition = MetadataTypeDefinitions.domainVerification;
+
+export default DomainVerification;

package/lib/metadataTypes/Event.js

@@ -46,7 +46,6 @@ class Event extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static async retrieve(retrieveDir, _, __, key) {
-        Util.logBeta(this.definition.type);
         try {
             return await super.retrieveREST(
                 retrieveDir,
@@ -87,7 +86,6 @@ class Event extends MetadataType {
      * @returns {Promise.<MetadataTypeItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
-        Util.logBeta(this.definition.type);
         const res = await this.client.rest.get(
             '/interaction/v1/eventDefinitions?name=' + encodeURIComponent(name)
         );
@@ -141,13 +139,27 @@ class Event extends MetadataType {
      * @param {string} key Identifier of item
      * @returns {Promise.<boolean>} deletion success status
      */
-    static deleteByKey(key) {
-        Util.logBeta(this.definition.type);
-        return super.deleteByKeyREST(
-            '/interaction/v1/eventDefinitions/key:' + encodeURIComponent(key),
-            key,
-            false
-        );
+    static async deleteByKey(key) {
+        let response = false;
+        try {
+            response = await super.deleteByKeyREST(
+                '/interaction/v1/eventDefinitions/key:' + encodeURIComponent(key),
+                key,
+                true
+            );
+            Util.logger.info(` - deleted ${this.definition.type}: ${key}`);
+        } catch (ex) {
+            if (ex.code === 30000) {
+                Util.logger.warn(
+                    ` ☇ skipping deletion of ${this.definition.type} ${key}: not found on server`
+                );
+            } else {
+                Util.logger.errorStack(ex, ` - Deleting ${this.definition.type} '${key}' failed`);
+            }
+
+            return false;
+        }
+        return response;
     }
 
     /**