mcdev 3.1.3 → 4.0.0

package/lib/metadataTypes/DataExtensionField.js

@@ -1,55 +1,41 @@
 'use strict';
 
-const Util = require('../util/util');
-
-/**
- * @typedef {Object} DataExtensionFieldItem
- * @property {string} [ObjectID] id
- * @property {string} [CustomerKey] key in format [DEkey].[FieldName]
- * @property {Object} [DataExtension] -
- * @property {string} DataExtension.CustomerKey key of DE
- * @property {string} Name name of field
- * @property {string} [Name_new] custom attribute that is only used when trying to rename a field from Name to Name_new
- * @property {string} DefaultValue empty string for not set
- * @property {'true'|'false'} IsRequired -
- * @property {'true'|'false'} IsPrimaryKey -
- * @property {string} Ordinal 1, 2, 3, ...
- * @property {'Text'|'Number'|'Date'|'Boolean'|'Decimal'|'EmailAddress'|'Phone'|'Locale'} FieldType can only be set on create
- * @property {string} Scale the number of places after the decimal that the field can hold; example: "0","1", ...
- *
- * @typedef {Object.<string, DataExtensionFieldItem>} DataExtensionFieldMap
- */
-
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
+const Util = require('../util/util');
 
 /**
  * DataExtensionField MetadataType
+ *
  * @augments MetadataType
  */
 class DataExtensionField extends MetadataType {
     /**
      * Retrieves all records and saves it to disk
+     *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
-     * @param {Object} buObject properties for auth
-     * @returns {Promise<{metadata:DataExtensionFieldMap,type:string}>} Promise of items
+     * @param {TYPE.BuObject} buObject properties for auth
+     * @returns {Promise.<{metadata: TYPE.DataExtensionFieldMap, type: string}>} Promise of items
      */
     static async retrieve(retrieveDir, additionalFields, buObject) {
-        return super.retrieveSOAPgeneric(retrieveDir, buObject, null, additionalFields);
+        return super.retrieveSOAP(retrieveDir, buObject, null, additionalFields);
     }
     /**
      * Retrieves all records for caching
-     * @param {Object} [options] required for the specific request (filter for example)
+     *
+     * @param {TYPE.SoapRequestParams} [requestParams] required for the specific request (filter for example)
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
-     * @returns {Promise<{metadata:DataExtensionFieldMap,type:string}>} Promise of items
+     * @returns {Promise.<{metadata: TYPE.DataExtensionFieldMap, type: string}>} Promise of items
      */
-    static async retrieveForCache(options, additionalFields) {
-        return super.retrieveSOAPgeneric(null, null, options, additionalFields);
+    static async retrieveForCache(requestParams, additionalFields) {
+        return super.retrieveSOAP(null, null, requestParams, additionalFields);
     }
     /**
      * helper for DataExtension.js that sorts the fields into an array
-     * @param {DataExtensionFieldMap} fieldsObj customerKey-based list of fields for one dataExtension
-     * @returns {DataExtensionFieldItem[]} sorted array of field objects
+     *
+     * @param {TYPE.DataExtensionFieldMap} fieldsObj customerKey-based list of fields for one dataExtension
+     * @returns {TYPE.DataExtensionFieldItem[]} sorted array of field objects
      */
     static convertToSortedArray(fieldsObj) {
         return (
@@ -62,8 +48,9 @@ class DataExtensionField extends MetadataType {
 
     /**
      * sorting method to ensure `Ordinal` is respected
-     * @param {DataExtensionFieldItem} a -
-     * @param {DataExtensionFieldItem} b -
+     *
+     * @param {TYPE.DataExtensionFieldItem} a -
+     * @param {TYPE.DataExtensionFieldItem} b -
      * @returns {boolean} sorting based on Ordinal
      */
     static sortDeFields(a, b) {
@@ -71,9 +58,10 @@ class DataExtensionField extends MetadataType {
     }
     /**
      * manages post retrieve steps
-     * @param {DataExtensionFieldItem} metadata a single item
+     *
+     * @param {TYPE.DataExtensionFieldItem} metadata a single item
      * @param {boolean} forDataExtension when used by DataExtension class we remove more fields
-     * @returns {DataExtensionFieldItem} metadata
+     * @returns {TYPE.DataExtensionFieldItem} metadata
      */
     static postRetrieveTasks(metadata, forDataExtension) {
         return this._parseMetadata(metadata, forDataExtension);
@@ -81,10 +69,11 @@ class DataExtensionField extends MetadataType {
 
     /**
      * parses retrieved Metadata before saving
+     *
      * @private
-     * @param {DataExtensionFieldItem} metadata a single record
+     * @param {TYPE.DataExtensionFieldItem} metadata a single record
      * @param {boolean} forDataExtension when used by DataExtension class we remove more fields
-     * @returns {DataExtensionFieldItem} parsed metadata definition
+     * @returns {TYPE.DataExtensionFieldItem} parsed metadata definition
      */
     static _parseMetadata(metadata, forDataExtension) {
         if (forDataExtension) {
@@ -106,9 +95,9 @@ class DataExtensionField extends MetadataType {
      * Mofifies passed deployColumns for update by mapping ObjectID to their target column's values.
      * Removes FieldType field if its the same in deploy and target column, because it results in an error even if its of the same type
      *
-     * @param {DataExtensionFieldItem[]} deployColumns Columns of data extension that will be deployed
+     * @param {TYPE.DataExtensionFieldItem[]} deployColumns Columns of data extension that will be deployed
      * @param {string} deKey external/customer key of Data Extension
-     * @returns {Object<string,DataExtensionFieldItem>} existing fields by their original name to allow re-adding FieldType after update
+     * @returns {Object.<string, TYPE.DataExtensionFieldItem>} existing fields by their original name to allow re-adding FieldType after update
      */
     static async prepareDeployColumnsOnUpdate(deployColumns, deKey) {
         // retrieve existing fields to enable updating them
@@ -126,12 +115,12 @@ class DataExtensionField extends MetadataType {
         const fieldsObj = response.metadata;
 
         // ensure fields can be updated properly by their adding ObjectId based on Name-matching
-        /** @type {Object<string,DataExtensionFieldItem>} */
+        /** @type {Object.<string, TYPE.DataExtensionFieldItem>} */
         const existingFieldByName = {};
 
-        Object.keys(fieldsObj).forEach((key) => {
+        for (const key of Object.keys(fieldsObj)) {
             existingFieldByName[fieldsObj[key].Name] = fieldsObj[key];
-        });
+        }
         for (let i = deployColumns.length - 1; i >= 0; i--) {
             const item = deployColumns[i];
             const itemOld = existingFieldByName[item.Name];
@@ -141,7 +130,7 @@ class DataExtensionField extends MetadataType {
                 // Updating to a new FieldType will result in an error; warn & afterwards remove it
                 if (itemOld.FieldType !== item.FieldType) {
                     Util.logger.warn(
-                        `- The Field Type of an existing field cannot be changed. Keeping the original value for [${deKey}].[${item.Name}]: '${itemOld.FieldType}'`
+                        ` - The Field Type of an existing field cannot be changed. Keeping the original value for [${deKey}].[${item.Name}]: '${itemOld.FieldType}'`
                     );
                     item.FieldType = itemOld.FieldType;
                 }
@@ -153,13 +142,13 @@ class DataExtensionField extends MetadataType {
 
                 if (itemOld.MaxLength > item.MaxLength) {
                     Util.logger.warn(
-                        `- The length of an existing field cannot be decreased. Keeping the original value for [${deKey}].[${item.Name}]: '${itemOld.MaxLength}'`
+                        ` - The length of an existing field cannot be decreased. Keeping the original value for [${deKey}].[${item.Name}]: '${itemOld.MaxLength}'`
                     );
                     item.MaxLength = itemOld.MaxLength;
                 }
                 if (Util.isFalse(itemOld.IsRequired) && Util.isTrue(item.IsRequired)) {
                     Util.logger.warn(
-                        `- A field cannot be changed to be required on update after it was created to allow nulls: [${deKey}].[${item.Name}]`
+                        ` - A field cannot be changed to be required on update after it was created to allow nulls: [${deKey}].[${item.Name}]`
                     );
                     item.IsRequired = itemOld.IsRequired;
                 }
@@ -169,17 +158,17 @@ class DataExtensionField extends MetadataType {
                     item.Name = item.Name_new;
                     delete item.Name_new;
                     Util.logger.warn(
-                        `Found 'Name_new' value '${item.Name_new}' for ${deKey}.${item.Name} - trying to rename.`
+                        ` - Found 'Name_new' value '${item.Name_new}' for ${deKey}.${item.Name} - trying to rename.`
                     );
                 }
 
                 // check if any changes were found
                 let changeFound = false;
-                Object.keys(item).forEach((key) => {
+                for (const key of Object.keys(item)) {
                     if (item[key] !== itemOld[key]) {
                         changeFound = true;
                     }
-                });
+                }
                 if (!changeFound) {
                     deployColumns.splice(i, 1);
                     Util.logger.verbose(`no change - removed field [${deKey}].[${item.Name}]`);
@@ -192,13 +181,13 @@ class DataExtensionField extends MetadataType {
                 // field is getting added ---
                 if (Util.isTrue(item.IsRequired) && item.DefaultValue === '') {
                     Util.logger.warn(
-                        `- Adding new fields to an existing table requires that these fields are either not-required (nullable) or have a default value set. Changing [${deKey}].[${item.Name}] to be not-required`
+                        ` - Adding new fields to an existing table requires that these fields are either not-required (nullable) or have a default value set. Changing [${deKey}].[${item.Name}] to be not-required`
                     );
-                    item.IsRequired = 'false';
+                    item.IsRequired = false;
                 }
                 if (item.Name_new) {
                     Util.logger.warn(
-                        `Found 'Name_new' value '${item.Name_new}' for ${deKey}.${item.Name} but could not find a corresponding DE field on the server - adding new field instead of updating.`
+                        ` - Found 'Name_new' value '${item.Name_new}' for ${deKey}.${item.Name} but could not find a corresponding DE field on the server - adding new field instead of updating.`
                     );
                     delete item.Name_new;
                 }
@@ -219,16 +208,104 @@ class DataExtensionField extends MetadataType {
             }
         }
         Util.logger.debug(
-            `${deployColumns.length} Fields added/updated for [${deKey}]: ` +
-                deployColumns.map((item) => item.Name).join(', ')
+            `${deployColumns.length} Fields added/updated for [${deKey}]${
+                deployColumns.length ? ': ' : ''
+            }` + deployColumns.map((item) => item.Name).join(', ')
+        );
+        return existingFieldByName;
+    }
+
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {TYPE.BuObject} buObject references credentials
+     * @param {string} customerKey Identifier of data extension
+     * @returns {Promise.<boolean>} deletion success status
+     */
+    static deleteByKey(buObject, customerKey) {
+        return this.deleteByKeySOAP(buObject, customerKey, false);
+    }
+
+    /**
+     * Delete a data extension from the specified business unit
+     *
+     * @param {TYPE.BuObject} buObject references credentials
+     * @param {string} customerKey Identifier of metadata
+     * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
+     * @returns {boolean} deletion success flag
+     */
+    static async deleteByKeySOAP(buObject, customerKey, handleOutside) {
+        const [deKey, fieldKey] = customerKey.split('.');
+        customerKey = `[${deKey}].[${fieldKey}]`;
+
+        // get the object id
+        const response = await this.retrieveForCache(
+            {
+                filter: {
+                    leftOperand: 'CustomerKey',
+                    operator: 'equals',
+                    rightOperand: customerKey,
+                },
+            },
+            ['Name', 'ObjectID']
+        );
+        const fieldObjectID = response.metadata[customerKey].ObjectID;
+        if (!fieldObjectID) {
+            Util.logger.error(`Could not find ${customerKey} on your BU`);
+            return false;
+        }
+
+        // normal code
+        const keyObj = {
+            CustomerKey: deKey,
+            Fields: {
+                Field: {
+                    ObjectID: fieldObjectID,
+                },
+            },
+        };
+        try {
+            this.client.soap.delete(
+                'DataExtension', // yes, not DataExtensionField
+                keyObj,
+                null
+            );
+
+            if (!handleOutside) {
+                Util.logger.info(`- deleted ${this.definition.type}: ${customerKey}`);
+            }
+            this.postDeleteTasks(buObject, customerKey);
+            return true;
+        } catch (ex) {
+            if (!handleOutside) {
+                const errorMsg = ex.results?.length
+                    ? `${ex.results[0].StatusMessage} (Code ${ex.results[0].ErrorCode})`
+                    : ex.message;
+                Util.logger.error(
+                    `- error deleting ${this.definition.type} '${customerKey}': ${errorMsg}`
+                );
+            } else {
+                throw ex;
+            }
+
+            return false;
+        }
+    }
+    /**
+     * clean up after deleting a metadata item
+     *
+     * @param {string} customerKey Identifier of metadata item
+     * @returns {void}
+     */
+    static async postDeleteTasks(customerKey) {
+        // TODO actually clean up local dataextension json
+        Util.logger.warn(
+            ` - The dataExtension for ${customerKey} wasn't updated locally yet after removing this field.`
         );
-        return deployColumns.length ? existingFieldByName : null;
     }
 }
 
 // Assign definition to static attributes
 DataExtensionField.definition = require('../MetadataTypeDefinitions').dataExtensionField;
-DataExtensionField.cache = {};
-DataExtensionField.client = undefined;
 
 module.exports = DataExtensionField;

package/lib/metadataTypes/DataExtensionTemplate.js

@@ -1,19 +1,37 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 
 /**
  * DataExtensionTemplate MetadataType
+ *
  * @augments MetadataType
  */
 class DataExtensionTemplate extends MetadataType {
     /**
      * Retrieves SOAP based metadata of metadata type into local filesystem. executes callback with retrieved metadata
-     * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
+     * @param {void} [_] unused parameter
+     * @param {void} [__] unused parameter
+     * @param {void} [___] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static retrieve(retrieveDir) {
-        return super.retrieveSOAPgeneric(retrieveDir);
+    static retrieve(retrieveDir, _, __, ___, key) {
+        /** @type {TYPE.SoapRequestParams} */
+        let requestParams = null;
+        if (key) {
+            requestParams = {
+                filter: {
+                    leftOperand: 'CustomerKey',
+                    operator: 'equals',
+                    rightOperand: key,
+                },
+            };
+        }
+        return super.retrieveSOAP(retrieveDir, null, requestParams);
     }
 }
 

package/lib/metadataTypes/DataExtract.js

@@ -1,90 +1,97 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 const Util = require('../util/util');
 const File = require('../util/file');
+const cache = require('../util/cache');
 
 /**
  * DataExtract MetadataType
+ *
  * @augments MetadataType
  */
 class DataExtract extends MetadataType {
     /**
      * Retrieves Metadata of Data Extract Activity.
      * Endpoint /automation/v1/dataextracts/ returns all Data Extracts
-     * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
+     * @param {void} [_] unused parameter
+     * @param {void} [__] unused parameter
+     * @param {void} [___] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static async retrieve(retrieveDir) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/dataextracts/', null);
+    static async retrieve(retrieveDir, _, __, ___, key) {
+        return super.retrieveREST(retrieveDir, '/automation/v1/dataextracts/', null, null, key);
     }
     /**
      * Retrieves Metadata of  Data Extract Activity for caching
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
     static async retrieveForCache() {
-        return super.retrieveREST(null, '/automation/v1/dataextracts/', null);
+        return super.retrieveREST(null, '/automation/v1/dataextracts/');
     }
 
     /**
      * Retrieve a specific dataExtract Definition by Name
-     * @param {String} templateDir Directory where retrieved metadata directory will be saved
-     * @param {String} name name of the metadata file
-     * @param {Object} templateVariables variables to be replaced in the metadata
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @param {string} templateDir Directory where retrieved metadata directory will be saved
+     * @param {string} name name of the metadata file
+     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<TYPE.MetadataTypeItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
-        const options = {
-            uri: '/automation/v1/dataextracts/?$filter=name%20eq%20' + name.split(' ').join('%20'),
-        };
-
-        const res = await this.client.RestClient.get(options);
-        if (res.body && Array.isArray(res.body.items) && res.body.items.length) {
+        const res = await this.client.rest.get(
+            '/automation/v1/dataextracts/?$filter=name%20eq%20' + encodeURIComponent(name)
+        );
+        if (Array.isArray(res.items) && res.items.length) {
             // eq-operator returns a similar, not exact match and hence might return more than 1 entry
-            const [metadata] = res.body.items.filter((item) => item.name === name);
+            const metadata = res.items.find((item) => item.name === name);
             if (!metadata) {
                 Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
                 return;
             }
 
             // get full definition
-            const extended = await this.client.RestClient.get({
-                uri: '/automation/v1/dataextracts/' + metadata.id,
-            });
-            const originalKey = extended.body[this.definition.keyField];
+            const extended = await this.client.rest.get(
+                '/automation/v1/dataextracts/' + metadata[this.definition.idField]
+            );
+            const originalKey = extended[this.definition.keyField];
             const val = JSON.parse(
                 Util.replaceByObject(
-                    JSON.stringify(this.parseMetadata(extended.body)),
+                    JSON.stringify(this.parseMetadata(extended)),
                     templateVariables
                 )
             );
 
             // remove all fields listed in Definition for templating
             this.keepTemplateFields(val);
-            File.writeJSONToFile(
+            await File.writeJSONToFile(
                 [templateDir, this.definition.type].join('/'),
                 originalKey + '.' + this.definition.type + '-meta',
                 JSON.parse(Util.replaceByObject(JSON.stringify(val), templateVariables))
             );
-            Util.logger.info(
-                `Dataextracts.retrieveAsTemplate:: Written Metadata to filesystem (${name})`
-            );
+            Util.logger.info(`- templated ${this.definition.type}: ${name}`);
             return { metadata: val, type: this.definition.type };
-        } else if (res.body && res.body.items) {
+        } else if (res?.items) {
             Util.logger.error(`No ${this.definition.typeName} found with name "${name}"`);
         } else {
             throw new Error(
                 `Encountered unknown error when retrieveing ${
                     this.definition.typeName
-                } "${name}": ${JSON.stringify(res.body)}`
+                } "${name}": ${JSON.stringify(res)}`
             );
         }
     }
 
     /**
      * manages post retrieve steps
-     * @param {Object} fileTransfer a single fileTransfer
-     * @returns {Object[]} metadata
+     *
+     * @param {TYPE.MetadataTypeItem} fileTransfer a single fileTransfer
+     * @returns {TYPE.MetadataTypeItem} metadata
      */
     static postRetrieveTasks(fileTransfer) {
         return this.parseMetadata(fileTransfer);
@@ -92,7 +99,8 @@ class DataExtract extends MetadataType {
 
     /**
      * Creates a single Data Extract
-     * @param {Object} dataExtract a single Data Extract
+     *
+     * @param {TYPE.MetadataTypeItem} dataExtract a single Data Extract
      * @returns {Promise} Promise
      */
     static create(dataExtract) {
@@ -101,7 +109,8 @@ class DataExtract extends MetadataType {
 
     /**
      * Updates a single Data Extract
-     * @param {Object} dataExtract a single Data Extract
+     *
+     * @param {TYPE.MetadataTypeItem} dataExtract a single Data Extract
      * @returns {Promise} Promise
      */
     static update(dataExtract) {
@@ -113,12 +122,12 @@ class DataExtract extends MetadataType {
 
     /**
      * prepares a dataExtract for deployment
-     * @param {Object} metadata a single dataExtract activity definition
-     * @returns {Object} metadata object
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single dataExtract activity definition
+     * @returns {TYPE.MetadataTypeItem} metadata object
      */
     static preDeployTasks(metadata) {
-        metadata.dataExtractTypeId = Util.getFromCache(
-            this.cache,
+        metadata.dataExtractTypeId = cache.searchForField(
             'dataExtractType',
             metadata.r__dataExtractType_name,
             'name',
@@ -129,25 +138,29 @@ class DataExtract extends MetadataType {
     }
     /**
      * parses retrieved Metadata before saving
-     * @param {Object} metadata a single dataExtract activity definition
-     * @returns {Array} Array with one metadata object and one sql string
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single dataExtract activity definition
+     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one sql string
      */
     static parseMetadata(metadata) {
-        metadata.r__dataExtractType_name = Util.getFromCache(
-            this.cache,
-            'dataExtractType',
-            metadata.dataExtractTypeId,
-            'extractId',
-            'name'
-        );
-        delete metadata.dataExtractTypeId;
+        try {
+            metadata.r__dataExtractType_name = cache.searchForField(
+                'dataExtractType',
+                metadata.dataExtractTypeId,
+                'extractId',
+                'name'
+            );
+            delete metadata.dataExtractTypeId;
+        } catch (ex) {
+            Util.logger.warn(
+                ` - ${this.definition.type} ${metadata[this.definition.keyField]}: ${ex.message}`
+            );
+        }
         return JSON.parse(JSON.stringify(metadata));
     }
 }
 
 // Assign definition to static attributes
 DataExtract.definition = require('../MetadataTypeDefinitions').dataExtract;
-DataExtract.cache = {};
-DataExtract.client = undefined;
 
 module.exports = DataExtract;

package/lib/metadataTypes/DataExtractType.js

@@ -1,34 +1,40 @@
 'use strict';
 
+const TYPE = require('../../types/mcdev.d');
 const MetadataType = require('./MetadataType');
 
 /**
  * DataExtractType MetadataType
  * Only for Caching No retrieve/upsert is required
  * as this is a configuration in the EID
+ *
  * @augments MetadataType
  */
 class DataExtractType extends MetadataType {
     /**
      * Retrieves Metadata of  Data Extract Type.
-     * @param {String} retrieveDir Directory where retrieved metadata directory will be saved
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
+     * @param {void} [_] unused parameter
+     * @param {void} [__] unused parameter
+     * @param {void} [___] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static retrieve(retrieveDir) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/dataextracttypes/', null);
+    static retrieve(retrieveDir, _, __, ___, key) {
+        return super.retrieveREST(retrieveDir, '/automation/v1/dataextracttypes/', null, null, key);
     }
     /**
      * Retrieves Metadata of  Data Extract Type for caching.
-     * @returns {Promise<Object>} Promise of metadata
+     *
+     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
     static retrieveForCache() {
-        return super.retrieveREST(null, '/automation/v1/dataextracttypes/', null);
+        return super.retrieveREST(null, '/automation/v1/dataextracttypes/');
     }
 }
 
 // Assign definition to static attributes
 DataExtractType.definition = require('../MetadataTypeDefinitions').dataExtractType;
-DataExtractType.cache = {};
-DataExtractType.client = undefined;
 
 module.exports = DataExtractType;