mcdev 9.0.2 → 10.0.0

package/lib/metadataTypes/AttributeGroup.js

@@ -25,12 +25,7 @@ class AttributeGroup extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static async retrieve(retrieveDir, _, __, key) {
-        return super.retrieveREST(
-            retrieveDir,
-            '/hub/v1/contacts/schema/attributeGroups',
-            null,
-            key
-        );
+        return super.retrieveREST(retrieveDir, '/hub/v1/contacts/schema/attributeGroups', key);
     }
 
     /**

package/lib/metadataTypes/AttributeSet.js

@@ -38,7 +38,7 @@ class AttributeSet extends MetadataType {
             const result = await AttributeGroup.retrieveForCache();
             cache.setMetadata('attributeGroup', result.metadata);
         }
-        return super.retrieveREST(retrieveDir, '/hub/v1/contacts/schema/setDefinitions', null, key);
+        return super.retrieveREST(retrieveDir, '/hub/v1/contacts/schema/setDefinitions', key);
     }
 
     /**

package/lib/metadataTypes/Automation.js

@@ -107,7 +107,7 @@ class Automation extends MetadataType {
         // * retrieveDir can be empty when we use it in the context of postDeployTasks
         if (retrieveDir) {
             this.retrieveDir = retrieveDir;
-            const savedMetadataMap = await this.saveResults(metadataMap, retrieveDir, null, null);
+            const savedMetadataMap = await this.saveResults(metadataMap, retrieveDir);
             Util.logger.info(
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadataMap).length})` +
                     Util.getKeysString(key)
@@ -127,7 +127,7 @@ class Automation extends MetadataType {
      * @param {SDKError} ex exception
      * @param {string} key id or key of item
      * @param {string} url url to call for retry
-     * @returns {Promise.<any>} can return retry-result
+     * @returns {Promise.<object|null>} retry result or null when the request cannot be recovered
      */
     static async handleRESTErrors(ex, key, url) {
         try {
@@ -138,7 +138,7 @@ class Automation extends MetadataType {
                     ${
                         ex.endpoint
                             ? Util.getGrayMsg(
-                                  ' - ' + ex.endpoint.split('rest.marketingcloudapis.com')[1]
+                                  ' - ' + ex.endpoint.split('rest.marketingcloudapis.com', 2)[1]
                               )
                             : ''
                     }`
@@ -243,20 +243,21 @@ class Automation extends MetadataType {
                                 }
                                 for (const activity of step.workers) {
                                     // activties
-                                    if (
-                                        activity.objectTypeId === 467 &&
-                                        activity.serializedObject
-                                    ) {
-                                        // wait activities
-                                        const waitObj = JSON.parse(activity.serializedObject);
-                                        if (waitObj.timeZone) {
-                                            // add timezone to the wait activity
-                                            item.steps[step.sequence].activities[
-                                                activity.sequence
-                                            ].timeZone = waitObj.timeZone;
-                                        }
-                                        // * wait activities are not supported in the new API
+                                    if (!(
+                                        activity.objectTypeId === 467 && activity.serializedObject
+                                    )) {
+                                        continue;
                                     }
+
+                                    // wait activities
+                                    const waitObj = JSON.parse(activity.serializedObject);
+                                    if (waitObj.timeZone) {
+                                        // add timezone to the wait activity
+                                        item.steps[step.sequence].activities[
+                                            activity.sequence
+                                        ].timeZone = waitObj.timeZone;
+                                    }
+                                    // * wait activities are not supported in the new API
                                 }
                             }
                         }
@@ -357,9 +358,9 @@ class Automation extends MetadataType {
             : []) {
             details.push(...item.Results);
         }
-        details.map((item) => {
+        for (const item of details) {
             item.key = item.CustomerKey;
-        });
+        }
 
         const parsed = this.parseResponseBody({ items: details });
 
@@ -414,78 +415,6 @@ class Automation extends MetadataType {
         return { metadata: resultsConverted, type: this.definition.type };
     }
 
-    /**
-     * Retrieve a specific Automation Definition by Name
-     *
-     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
-     * @param {string} templateDir Directory where retrieved metadata directory will be saved
-     * @param {string} name name of the metadata file
-     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
-     * @returns {Promise.<AutomationItemObj>} Promise of metadata
-     */
-    static async retrieveAsTemplate(templateDir, name, templateVariables) {
-        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
-        const results = await this.client.soap.retrieve('Program', ['ObjectID', 'Name'], {
-            filter: {
-                leftOperand: 'Name',
-                operator: 'equals',
-                rightOperand: name,
-            },
-        });
-        if (Array.isArray(results?.Results)) {
-            // eq-operator returns a similar, not exact match and hence might return more than 1 entry
-            const metadata = results.Results.find((item) => item.Name === name);
-            if (!metadata) {
-                Util.logger.error(`${this.definition.type} '${name}' not found on server.`);
-                return;
-            }
-            let details = await this.client.rest.get(
-                '/automation/v1/automations/' + metadata.ObjectID
-            );
-            const metadataMap = this.parseResponseBody({ items: [details] });
-            if (Object.keys(metadataMap).length) {
-                // attach notification and wait timezone information to each automation that has any
-                await this.#getAutomationLegacyREST(metadataMap);
-                details = Object.values(metadataMap)[0];
-            }
-
-            let val = null;
-            let originalKey;
-            // if parsing fails, we should just save what we get
-            try {
-                const parsedDetails = this.postRetrieveTasks(details);
-                originalKey = parsedDetails[this.definition.keyField];
-                if (parsedDetails !== null) {
-                    val = JSON.parse(
-                        Util.replaceByObject(JSON.stringify(parsedDetails), templateVariables)
-                    );
-                }
-            } catch {
-                val = structuredClone(details);
-            }
-            if (val === null) {
-                throw new Error(
-                    `Automations '${name}' was skipped and hence cannot be used for templating.`
-                );
-            }
-            // remove all fields not listed in Definition for templating
-            this.keepTemplateFields(val);
-            await File.writeJSONToFile(
-                [templateDir, this.definition.type].join('/'),
-                originalKey + '.' + this.definition.type + '-meta',
-                val
-            );
-            Util.logger.info(`- templated ${this.definition.type}: ${name}`);
-            return { metadata: val, type: this.definition.type };
-        } else if (results) {
-            Util.logger.error(`${this.definition.type} '${name}' not found on server.`);
-            Util.logger.info(`Downloaded: automation (0)`);
-            return { metadata: {}, type: this.definition.type };
-        } else {
-            throw new Error(JSON.stringify(results));
-        }
-    }
-
     /**
      * helper for {@link Automation.postRetrieveTasks} and {@link Automation.execute}
      *
@@ -609,12 +538,12 @@ class Automation extends MetadataType {
                             if (activity.r__type === 'wait') {
                                 // convert 12 to 24 hrs system
                                 let waitTime24;
-                                const [waitDuration, waitUnit] = activity.name.split(' ');
+                                const [waitDuration, waitUnit] = activity.name.split(' ', 2);
                                 if (waitUnit === 'AM' || waitUnit === 'PM') {
                                     waitTime24 = waitDuration;
                                     if (waitUnit === 'PM') {
                                         waitTime24 =
-                                            (Number(waitTime24.split(':')[0]) + 12).toString() +
+                                            (Number(waitTime24.split(':', 1)[0]) + 12).toString() +
                                             ':00';
                                     }
                                     activity.name = waitTime24;
@@ -907,9 +836,10 @@ class Automation extends MetadataType {
         const errors = super.getErrorsREST(ex);
         if (errors?.length > 0) {
             return errors.map((msg) =>
-                msg
-                    .split('403 Forbidden')
-                    .join('403 Forbidden: Please check if the automation is currently running.')
+                msg.replaceAll(
+                    '403 Forbidden',
+                    '403 Forbidden: Please check if the automation is currently running.'
+                )
             );
         }
         return errors;
@@ -1066,7 +996,7 @@ class Automation extends MetadataType {
                             );
                         }
                         if (activity.r__type === 'wait') {
-                            const [waitDuration, waitUnit] = activity.name.split(' ');
+                            const [waitDuration, waitUnit] = activity.name.split(' ', 2);
                             const waitDurationNumber = Number(waitDuration);
                             const allowedWaitUnits = [
                                 'Minutes',
@@ -1284,42 +1214,44 @@ class Automation extends MetadataType {
      * @returns {Promise.<void>} -
      */
     static async #updateNotificationInfoREST(metadataMap, key) {
-        if (this.notificationUpdates[key]) {
-            // create & update automation calls return programId as 'legacyId'; retrieve does not return it
-            const programId = metadataMap[key]?.legacyId;
-            if (programId) {
-                const notificationBody = {
+        if (!this.notificationUpdates[key]) {
+            return;
+        }
+
+        // create & update automation calls return programId as 'legacyId'; retrieve does not return it
+        const programId = metadataMap[key]?.legacyId;
+        if (programId) {
+            const notificationBody = {
+                programId,
+                workers: this.notificationUpdates[key].map((notification) => ({
                     programId,
-                    workers: this.notificationUpdates[key].map((notification) => ({
-                        programId,
-                        notificationType: notification.type,
-                        definition: Array.isArray(notification.email)
-                            ? notification.email.join(',')
-                            : notification.email,
-                        body: notification.message,
-                        channelType: 'Account',
-                    })),
-                };
-                try {
-                    const result = await this.client.rest.post(
-                        '/legacy/v1/beta/automations/notifications/' + programId,
-                        notificationBody
-                    );
-                    if (result) {
-                        // should be empty if all OK
-                        throw new Error(result);
-                    }
-                } catch (ex) {
-                    Util.logger.error(
-                        `Error updating notifications for automation '${metadataMap[key].name}': ${ex.message} (${ex.code}))`
-                    );
+                    notificationType: notification.type,
+                    definition: Array.isArray(notification.email)
+                        ? notification.email.join(',')
+                        : notification.email,
+                    body: notification.message,
+                    channelType: 'Account',
+                })),
+            };
+            try {
+                const result = await this.client.rest.post(
+                    '/legacy/v1/beta/automations/notifications/' + programId,
+                    notificationBody
+                );
+                if (result) {
+                    // should be empty if all OK
+                    throw new Error(result);
                 }
-                Util.logger.info(
-                    Util.getGrayMsg(
-                        ` - updated notifications for automation '${metadataMap[key].name}'`
-                    )
+            } catch (ex) {
+                Util.logger.error(
+                    `Error updating notifications for automation '${metadataMap[key].name}': ${ex.message} (${ex.code}))`
                 );
             }
+            Util.logger.info(
+                Util.getGrayMsg(
+                    ` - updated notifications for automation '${metadataMap[key].name}'`
+                )
+            );
         }
     }
 
@@ -1425,7 +1357,7 @@ class Automation extends MetadataType {
         const dateServer = new Date(utc + 3600000 * offsetServer);
 
         // return time as a string without trailing "Z" and without miliseconds (separated by .)
-        return dateServer.toISOString().slice(0, -1).split('.')[0];
+        return dateServer.toISOString().slice(0, -1).split('.', 1)[0];
     }
 
     /**
@@ -1461,8 +1393,8 @@ class Automation extends MetadataType {
 
             if (json.schedule?.icalRecur) {
                 output += `**Schedule:**\n\n`;
-                output += `* Start: ${json.schedule.startDate.split('T').join(' ')} ${tz}\n`;
-                output += `* End: ${json.schedule.endDate.split('T').join(' ')} ${tz}\n`;
+                output += `* Start: ${json.schedule.startDate.replaceAll('T', ' ')} ${tz}\n`;
+                output += `* End: ${json.schedule.endDate.replaceAll('T', ' ')} ${tz}\n`;
                 output += `* Timezone: ${json.schedule.timezoneName}\n`;
 
                 const ical = {};
@@ -1592,9 +1524,8 @@ class Automation extends MetadataType {
                 );
             }
         }
-        let output;
         if (mode === 'md') {
-            output = this._generateDocMd(json, tabled);
+            const output = this._generateDocMd(json, tabled);
             try {
                 // write to disk
                 await File.writeToFile(directory, filename + '.automation-doc', mode, output);
@@ -1611,37 +1542,39 @@ class Automation extends MetadataType {
      * @returns {Promise.<void>} -
      */
     static async document(metadata) {
-        if (['md', 'both'].includes(this.properties.options.documentType)) {
-            if (!metadata) {
-                metadata = (
-                    await this.readBUMetadataForType(
-                        File.normalizePath([
-                            this.properties.directories.retrieve,
-                            this.buObject.credential,
-                            this.buObject.businessUnit,
-                        ]),
-                        true
-                    )
-                ).automation;
-            }
-            const docPath = File.normalizePath([
-                this.properties.directories.retrieve,
-                this.buObject.credential,
-                this.buObject.businessUnit,
-                this.definition.type,
-            ]);
-            if (!metadata || !Object.keys(metadata).length) {
-                // as part of retrieve & manual execution we could face an empty folder
-                return;
-            }
+        if (!['md', 'both'].includes(this.properties.options.documentType)) {
+            return;
+        }
 
-            const docLimit = pLimit(100);
-            await Promise.all(
-                Object.keys(metadata).map((key) =>
-                    docLimit(() => this._writeDoc(docPath + '/', key, metadata[key], 'md'))
+        if (!metadata) {
+            metadata = (
+                await this.readBUMetadataForType(
+                    File.normalizePath([
+                        this.properties.directories.retrieve,
+                        this.buObject.credential,
+                        this.buObject.businessUnit,
+                    ]),
+                    true
                 )
-            );
+            ).automation;
+        }
+        const docPath = File.normalizePath([
+            this.properties.directories.retrieve,
+            this.buObject.credential,
+            this.buObject.businessUnit,
+            this.definition.type,
+        ]);
+        if (!metadata || !Object.keys(metadata).length) {
+            // as part of retrieve & manual execution we could face an empty folder
+            return;
         }
+
+        const docLimit = pLimit(100);
+        await Promise.all(
+            Object.keys(metadata).map((key) =>
+                docLimit(() => this._writeDoc(docPath + '/', key, metadata[key], 'md'))
+            )
+        );
     }
 
     /**
@@ -1720,7 +1653,7 @@ class Automation extends MetadataType {
     /**
      * helper for {@link MetadataType.getNestedValue} - adjusted for automation activities
      *
-     * @param {any} obj the metadataItem to search in (or the result)
+     * @param {ReturnType<JSON['parse']>} obj the metadataItem to search in (or the result)
      * @param {string[]} nestedKeyParts key in dot-notation split into parts
      * @param {string} dependentType used for types that need custom handling
      * @returns {(string) | (string)[]} result

package/lib/metadataTypes/Campaign.js

@@ -33,12 +33,7 @@ class Campaign extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static async retrieve(retrieveDir, _, __, key) {
-        const res = await super.retrieveREST(
-            retrieveDir,
-            '/legacy/v1/beta2/data/campaign/',
-            null,
-            key
-        );
+        const res = await super.retrieveREST(retrieveDir, '/legacy/v1/beta2/data/campaign/', key);
         // get assignments
         Util.logger.info(`Retrieving: campaignAsset`);
         const campaignAssets = await Promise.all(