sfmc-sdk 0.0.2 → 0.0.6

package/.github/workflows/publish.yml

@@ -20,16 +20,3 @@ jobs:
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}
-
-  publish-gpr:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: 12
-          registry-url: https://npm.pkg.github.com/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.GH_PACKAGEREGISTRY}}

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## SFMC SDK follows [semantic versioning](https://semver.org/).
 
+## 0.0.6 - 2021-12-23
+
+- Bump dependency versions
+- Extended SOAP action support to other types
+- Added SOAP Retreive Bulk
+- Added REST Get Collection & GetBulk features
+
 ## 0.0.2 - 2021-04-10
 
 NPM Publishing

package/PULL_REQUEST_TEMPLATE.md

@@ -4,10 +4,7 @@
 
 - [ ] Documentation update
 - [ ] Bug fix
-- [ ] New metadata support
-- [ ] Enhanced metadata
-- [ ] Add a CLI option
-- [ ] Add something to the core
+- [ ] Extend features
 - [ ] Other, please explain:
 
 ## What changes did you make? (Give an overview)

package/README.md

@@ -16,30 +16,57 @@ This library attempts to overcomes some of the complexity/shortcomings of the or
 -   Is opinionated about how Auth should be managed (only accepts a standard Auth method)
 -   Only uses Promises/Async-Await, no callbacks
 -   Maintainers of the semi-official lib from Salesforce are not responsive
+-   Allows for using a persisting credentials in an external app, then passing
+-   We expect parsing of SOAP to
 
 ## Usage
 
 ### Initialization
 
 Initializes the Auth Object in the SDK.
-The SDK will automatically request a new token if none is valid
+The SDK will automatically request a new token if none is valid.
+the second parameter in the constructor is to allow for specific events to execute a function. Currently onRefresh and onLoop are supported. This reduces the number of requests for token therefore increasing speed between executions (when testing was 2.5 seconds down to 1.5 seconds for one rest and one soap request)
 
 ```javascript
 const SDK = require('sfmc-sdk');
-const sfmc = new SDK({
-    client_id: 'XXXXX',
-    client_secret: 'YYYYYY',
-    auth_url: 'https://ZZZZZZZ.auth.marketingcloudapis.com/',
-    account_id: 7281698,
-});
+const sfmc = new SDK(
+    {
+        client_id: 'XXXXX',
+        client_secret: 'YYYYYY',
+        auth_url: 'https://ZZZZZZZ.auth.marketingcloudapis.com/',
+        account_id: 7281698,
+    },
+    true
+);
 ```
 
 ### SOAP
 
-SOAP currently only supports retrieve, will be updating soon for other types.
+SOAP currently only supports all the standard SOAP action types. Some examples below
 
 ```javascript
-const soapResponse = await sfmc.soap.retrieve('DataExtension', ['ObjectID'], {});
+const soapRetrieve = await sfmc.soap.retrieve('DataExtension', ['ObjectID'], {});
+const soapRetrieveBulk = await sfmc.soap.retrieveBulk('DataExtension', ['ObjectID'], filter: {
+                leftOperand: 'ExternalKey',
+                operator: 'equals',
+                rightOperand: 'SOMEKEYHERE',
+            }); // when you want to auto paginate
+const soapCreate = await sfmc.soap.create('Subscriber', {
+    "SubscriberKey": "12345123",
+    "EmailAddress": "example@example.com"
+    }, {
+        "options": {
+            "SaveOptions": { "SaveAction" : "UpdateAdd" }
+        }
+    }});
+const soapUpdate = await sfmc.soap.update('Role', {
+    "CustomerKey": "12345123",
+    "Name": "UpdatedName"
+    }, {});
+const soapExecute = await sfmc.soap.execute('LogUnsubEvent', [{
+    "SubscriberKey": "12345123",
+    "EmailAddress": "example@example.com"
+    }], {});
 ```
 
 ### REST
@@ -51,6 +78,8 @@ const restResponse = await sfmc.rest.get('/interaction/v1/interactions');
 const restResponse = await sfmc.rest.post('/interaction/v1/interactions', jsonPayload);
 const restResponse = await sfmc.rest.patch('/interaction/v1/interactions/IDHERE', jsonPayload); // PUT ALSO
 const restResponse = await sfmc.rest.delete('/interaction/v1/interactions/IDHERE');
+const restResponse = await sfmc.rest.getBulk('/interaction/v1/interactions'); // auto-paginate based on $pageSize
+const restResponse = await sfmc.rest.getCollection(['/interaction/v1/interactions/213', '/interaction/v1/interactions/123'], 3); // parallel requests
 ```
 
 ## Contributing
@@ -62,7 +91,6 @@ Please make sure to update tests as appropriate.
 ## To Do
 
 -   No tests are in place
--   Improve handling for other SOAP Actions than Retrieve
 -   Look at persisting access tokens across sessions as an option
 -   Validation improvement
 -   Support Scopes in API Requests

package/lib/auth.js

@@ -1,24 +1,18 @@
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * Licensed under the BSD 3-Clause license.
- * For full license text, see LICENSE.txt file in the repo root  or https://opensource.org/licenses/BSD-3-Clause
- */
 'use strict';
 
 const axios = require('axios');
-
 module.exports = class Auth {
     /**
      * Creates an instance of Auth.
      * @param {Object} options Auth Payload
-     * @param {String} options.client_id Client Id from SFMC config
-     * @param {String} options.client_secret Client Secret from SFMC config
-     * @param {Number} options.account_id MID of Business Unit used for API Calls
-     * @param {String} options.auth_url Auth URL from SFMC config
-     * @param {String} [options.scope] Scope used for requests
+     * @param {string} options.client_id Client Id from SFMC config
+     * @param {string} options.client_secret Client Secret from SFMC config
+     * @param {number} options.account_id MID of Business Unit used for API Calls
+     * @param {string} options.auth_url Auth URL from SFMC config
+     * @param {string} [options.scope] Scope used for requests
+     * @param {Object} eventHandlers collection of handler functions (for examplef or logging)
      */
-    constructor(options) {
+    constructor(options, eventHandlers) {
         if (options) {
             if (!options.client_id) {
                 throw new Error('clientId or clientSecret is missing or invalid');
@@ -45,7 +39,7 @@ module.exports = class Auth {
                 throw new Error('auth_url must be a string');
             }
             if (
-                !/https:\/\/[a-z0-9]{28}\.auth\.marketingcloudapis\.com\//gm.test(options.auth_url)
+                !/https:\/\/[a-z0-9\-]{28}\.auth\.marketingcloudapis\.com\//gm.test(options.auth_url)
             ) {
                 throw new Error(
                     'auth_url must be in format https://mcXXXXXXXXXXXXXXXXXXXXXXXXXX.auth.marketingcloudapis.com/'
@@ -57,17 +51,22 @@ module.exports = class Auth {
         }
 
         this.options = Object.assign(this.options || {}, options);
+        this.eventHandlers = eventHandlers;
     }
     /**
      *
      *
      * @param {Boolean} forceRefresh used to enforce a refresh of token
-     * @return {void}
+     * @return {Promise<Object>} current session information
      */
     async getAccessToken(forceRefresh) {
         if (Boolean(forceRefresh) || _isExpired(this.options)) {
             this.options = await _requestToken(this.options);
+            if (this.eventHandlers && this.eventHandlers.onRefresh) {
+                this.eventHandlers.onRefresh(this.options);
+            }
         }
+        return this.options;
     }
 };
 /**
@@ -103,19 +102,13 @@ async function _requestToken(options) {
     if (options.scope) {
         payload.scope = options.scope;
     }
-    try {
-        const res = await axios({
-            method: 'post',
-            baseURL: options.auth_url,
-            url: '/v2/token',
-            data: payload,
-        });
-        const newAuth = Object.assign(options, res.data);
-        newAuth.expiration = process.hrtime()[0] + res.data.expires_in;
-        return newAuth;
-    } catch (ex) {
-        console.log(ex.response.status, ex.response.statusCode);
-        console.log(ex.response.data);
-        console.log(payload);
-    }
+    const res = await axios({
+        method: 'post',
+        baseURL: options.auth_url,
+        url: '/v2/token',
+        data: payload,
+    });
+    const newAuth = Object.assign(options, res.data);
+    newAuth.expiration = process.hrtime()[0] + res.data.expires_in;
+    return newAuth;
 }

package/lib/index.js

@@ -6,10 +6,11 @@ module.exports = class SDK {
     /**
      * Creates an instance of SDK.
      * @param {Object} options Auth Object for making requests
+     * @param {Object} eventHandlers collection of handler functions (for example for logging)
      */
-    constructor(options) {
-        const auth = new Auth(options);
-        this.rest = new Rest(auth);
-        this.soap = new Soap(auth);
+    constructor(options, eventHandlers) {
+        this.auth = new Auth(options, eventHandlers);
+        this.rest = new Rest(this.auth, eventHandlers);
+        this.soap = new Soap(this.auth, eventHandlers);
     }
 };

package/lib/rest.js

@@ -2,88 +2,155 @@
 
 const axios = require('axios');
 const { isObject } = require('./util');
+const pLimit = require('p-limit');
 
 module.exports = class Rest {
     /**
      * Constuctor of Rest object
      * @constructor
      * @param {Object} auth Auth object used for initializing
+     * @param {Object} eventHandlers collection of handler functions (for examplef or logging)
      */
-    constructor(auth) {
+    constructor(auth, eventHandlers) {
         this.auth = auth;
+        this.eventHandlers = eventHandlers;
     }
 
     /**
-     * Method that makes the GET api request
-     * @param {String} url of the resource to retrieve
+     * Method that makes the GET API request
+     * @param {string} url of the resource to retrieve
      * @returns {Promise<Object>} API response
      */
     get(url) {
-        return _apiRequest(this.auth, {
-            method: 'GET',
-            retry: true,
-            url: url,
-        });
+        return _apiRequest(
+            this.auth,
+            {
+                method: 'GET',
+                url: url,
+            },
+            1
+        );
+    }
+    /**
+     * Method that makes paginated GET API Requests using $pageSize and $page parameters
+     * @param {string} url of the resource to retrieve
+     * @returns {Promise<Object>} API response combined items
+     */
+    async getBulk(url) {
+        let page = 1;
+        const baseUrl = url.split('?')[0];
+        const queryParams = new URLSearchParams(url.split('?')[1]);
+        let collector;
+        let shouldContinue = false;
+        queryParams.set('$pageSize', Number(2).toString());
+        do {
+            queryParams.set('$page', Number(page).toString());
+
+            const temp = await _apiRequest(
+                this.auth,
+                {
+                    method: 'GET',
+                    url: baseUrl + '?' + decodeURIComponent(queryParams.toString()),
+                },
+                1
+            );
+            if (collector && Array.isArray(temp.items)) {
+                collector.items.push(...temp.items);
+            } else if (collector == null) {
+                collector = temp;
+            }
+            if (Array.isArray(collector.items) && collector.items.length >= temp.count) {
+                shouldContinue = false;
+            } else {
+                page++;
+                shouldContinue = true;
+            }
+        } while (shouldContinue);
+        return collector;
+    }
+    /**
+     * Method that makes a GET API request for each URL (including rate limiting)
+     * @param {Array<String>} urlArray of the resource to retrieve
+     * @param {number} [concurrentLimit=5] number of requests to execute at once
+     * @returns {Promise<Array>} API response
+     */
+    getCollection(urlArray, concurrentLimit) {
+        const limit = pLimit(concurrentLimit || 5);
+        return Promise.all(
+            urlArray.map((url) =>
+                limit(() =>
+                    _apiRequest(
+                        this.auth,
+                        {
+                            method: 'GET',
+                            url: url,
+                        },
+                        1
+                    )
+                )
+            )
+        );
     }
     /**
      * Method that makes the POST api request
-     * @param {String} url of the resource to create
+     * @param {string} url of the resource to create
      * @param {Object} payload for the POST request body
      * @returns {Promise<Object>} API response
      */
     post(url, payload) {
         const options = {
             method: 'POST',
-            retry: true,
             url: url,
             data: payload,
         };
         _checkPayload(options);
-        return _apiRequest(this.auth, options);
+        return _apiRequest(this.auth, options, 1);
     }
     /**
      * Method that makes the PUT api request
-     * @param {String} url of the resource to replace
+     * @param {string} url of the resource to replace
      * @param {Object} payload for the PUT request body
      * @returns {Promise<Object>} API response
      */
     put(url, payload) {
         const options = {
             method: 'PUT',
-            retry: true,
             url: url,
             data: payload,
         };
         _checkPayload(options);
-        return _apiRequest(this.auth, options);
+        return _apiRequest(this.auth, options, 1);
     }
     /**
      * Method that makes the PATCH api request
-     * @param {String} url of the resource to update
+     * @param {string} url of the resource to update
      * @param {Object} payload for the PATCH request body
      * @returns {Promise<Object>} API response
      */
     patch(url, payload) {
         const options = {
             method: 'PATCH',
-            retry: true,
             url: url,
             data: payload,
         };
         _checkPayload(options);
-        return _apiRequest(this.auth, options);
+        return _apiRequest(this.auth, options, 1);
     }
     /**
      * Method that makes the DELETE api request
-     * @param {String} url of the resource to delete
+     * @param {string} url of the resource to delete
      * @returns {Promise<Object>} API response
      */
     delete(url) {
-        return _apiRequest(this.auth, {
-            method: 'DELETE',
-            retry: true,
-            url: url,
-        });
+        return _apiRequest(
+            this.auth,
+            {
+                method: 'DELETE',
+
+                url: url,
+            },
+            1
+        );
     }
 };
 /**
@@ -100,9 +167,10 @@ function _checkPayload(options) {
  * Method that makes the api request
  * @param {Object} auth - Auth Object used to make request
  * @param {Object} options configuration for the request including body
+ * @param {number} remainingAttempts number of times this request should be reattempted in case of error
  * @returns {Promise<Object>} Results from the Rest request in Object format
  */
-async function _apiRequest(auth, options) {
+async function _apiRequest(auth, options, remainingAttempts) {
     if (!isObject(options)) {
         throw new TypeError('options argument is required');
     }
@@ -115,12 +183,18 @@ async function _apiRequest(auth, options) {
             headers: { Authorization: `Bearer ` + auth.options.access_token },
         };
         if (options.method.includes('POST', 'PATCH', 'PUT')) {
-            requestOptions.data = options.payload;
+            requestOptions.data = options.data;
         }
+
         const res = await axios(requestOptions);
         return res.data;
     } catch (ex) {
-        console.error(ex.message, ex.response);
-        console.error(options);
+        if (ex.response && ex.response.status === 404 && remainingAttempts) {
+            // force refresh due to url related issue
+            await auth.getAccessToken(true);
+            return _apiRequest(auth, options, remainingAttempts--);
+        } else {
+            throw ex;
+        }
     }
 }

package/lib/soap.js

@@ -1,6 +1,7 @@
 'use strict';
 const axios = require('axios');
-const xml2js = require('xml2js');
+const xmlToJson = require('fast-xml-parser');
+const JsonToXml = require('fast-xml-parser').j2xParser;
 const { isObject } = require('./util');
 
 module.exports = class Soap {
@@ -8,77 +9,313 @@ module.exports = class Soap {
      * Constuctor of Soap object
      * @constructor
      * @param {Object} auth Auth object used for initializing
+     * @param {Object} eventHandlers collection of handler functions (for examplef or logging)
      */
-    constructor(auth) {
+    constructor(auth, eventHandlers) {
         this.auth = auth;
+        this.eventHandlers = eventHandlers;
     }
 
     /**
      * Method used to retrieve data via SOAP API
-     * @param {String} type -SOAP Object type
+     * @param {string} type -SOAP Object type
      * @param {Array<String>} props - Properties which should be retrieved
-     * @param {Object} options - configuration of the request
-     * @param {Array<Number>} [clientIDs] - MIDs which should be added to the request payload
+     * @param {Object} [requestParams] - additional RetrieveRequest parameters, for example filter or options
      * @returns {Promise<Object>} SOAP object converted from XML
      */
-    retrieve(type, props, options, clientIDs) {
-        // const defaults = {
-        //     paginate: false,
-        // };
+    retrieve(type, props, requestParams) {
         const body = {
             RetrieveRequestMsg: {
-                $: {
-                    xmlns: 'http://exacttarget.com/wsdl/partnerAPI',
-                },
+                '@_xmlns': 'http://exacttarget.com/wsdl/partnerAPI',
                 RetrieveRequest: {
                     ObjectType: type,
                     Properties: props,
                 },
             },
         };
-        if (clientIDs) {
-            body.RetrieveRequestMsg.RetrieveRequest.ClientIDs = clientIDs;
-        }
-        // filter can be simple or complex and has three properties leftOperand, rightOperand, and operator
-        if (options.filter) {
-            body.RetrieveRequestMsg.RetrieveRequest.Filter = _parseFilter(options.filter);
+
+        if (requestParams) {
+            validateOptions(requestParams.options, [
+                'BatchSize',
+                'IncludeObjects',
+                'OnlyIncludeBase',
+            ]);
+            if (requestParams.options) {
+                body.RetrieveRequestMsg.RetrieveRequest.Options = requestParams.options;
+            }
+            if (requestParams.ClientIDs) {
+                body.RetrieveRequestMsg.RetrieveRequest.ClientIDs = requestParams.clientIDs;
+            }
+            // filter can be simple or complex and has three properties leftOperand, rightOperand, and operator
+            if (requestParams.filter) {
+                body.RetrieveRequestMsg.RetrieveRequest.Filter = _parseFilter(requestParams.filter);
+            }
+            if (requestParams.QueryAllAccounts) {
+                body.RetrieveRequestMsg.RetrieveRequest.QueryAllAccounts = true;
+            }
+            if (requestParams.continueRequest) {
+                body.RetrieveRequestMsg.RetrieveRequest.ContinueRequest =
+                    requestParams.continueRequest;
+            }
         }
 
-        if (options.queryAllAccounts) {
-            body.RetrieveRequestMsg.RetrieveRequest.QuertAllAccounts = true;
+        return _apiRequest(
+            this.auth,
+            {
+                action: 'Retrieve',
+                req: body,
+                key: 'RetrieveResponseMsg',
+            },
+            1
+        );
+    }
+    /**
+     * Method used to retrieve all data via SOAP API
+     * @param {string} type -SOAP Object type
+     * @param {Array<String>} props - Properties which should be retrieved
+     * @param {Object} [requestParams] - additional RetrieveRequest parameters, for example filter or options
+     * @returns {Promise<Object>} SOAP object converted from XML
+     */
+    async retrieveBulk(type, props, requestParams) {
+        let status;
+        let resultsBulk;
+        do {
+            const resultsBatch = await this.retrieve(type, props, requestParams);
+            if (resultsBulk) {
+                // once first batch is done, the follow just add to result payload
+                resultsBulk.Results.push(...resultsBatch.Results);
+            } else {
+                resultsBulk = resultsBatch;
+            }
+            status = resultsBatch.OverallStatus;
+            if (status === 'MoreDataAvailable') {
+                requestParams.continueRequest = resultsBatch.RequestID;
+                if (this.eventHandlers && this.eventHandlers.onLoop) {
+                    this.eventHandlers.onLoop(type, resultsBulk);
+                }
+            }
+        } while (status === 'MoreDataAvailable');
+        return resultsBulk;
+    }
+    /**
+     * Method used to create data via SOAP API
+     * @param {string} type -SOAP Object type
+     * @param {Array<String>} props - Properties which should be created
+     * @param {Object} options - configuration of the request
+     * @returns {Promise<Object>} SOAP object converted from XML
+     */
+    create(type, props, options) {
+        const body = {
+            CreateRequest: {
+                '@_xmlns': 'http://exacttarget.com/wsdl/partnerAPI',
+                Options: options,
+                Objects: props,
+            },
+        };
+        body.CreateRequest.Objects['@_xsi:type'] = type;
+        validateOptions(options);
+        return _apiRequest(
+            this.auth,
+            {
+                action: 'Create',
+                req: body,
+                key: 'CreateResponse',
+            },
+            1
+        );
+    }
+    /**
+     * Method used to update data via SOAP API
+     * @param {string} type -SOAP Object type
+     * @param {Array<String>} props - Properties which should be updated
+     * @param {Object} options - configuration of the request
+     * @returns {Promise<Object>} SOAP object converted from XML
+     */
+    update(type, props, options) {
+        const body = {
+            UpdateRequest: {
+                '@_xmlns': 'http://exacttarget.com/wsdl/partnerAPI',
+                Options: options,
+                Objects: props,
+            },
+        };
+        body.UpdateRequest.Objects['@_xsi:type'] = type;
+        validateOptions(options);
+        return _apiRequest(
+            this.auth,
+            {
+                action: 'Update',
+                req: body,
+                key: 'UpdateResponse',
+            },
+            1
+        );
+    }
+    /**
+     * Method used to delete data via SOAP API
+     * @param {string} type -SOAP Object type
+     * @param {Array<String>} props - Properties which should be retrieved
+     * @param {Object} options - configuration of the request
+     * @returns {Promise<Object>} SOAP object converted from XML
+     */
+    delete(type, props, options) {
+        const body = {
+            DeleteRequest: {
+                '@_xmlns': 'http://exacttarget.com/wsdl/partnerAPI',
+                Options: options,
+                Objects: props,
+            },
+        };
+        body.DeleteRequest.Objects['@_xsi:type'] = type;
+        validateOptions(options);
+        return _apiRequest(
+            this.auth,
+            {
+                action: 'Delete',
+                req: body,
+                key: 'DeleteResponse',
+            },
+            1
+        );
+    }
+    /**
+     * Method used to schedule data via SOAP API
+     * @param {string} type -SOAP Object type
+     * @param {Object} schedule -object for what the schedule should be
+     * @param {Array|Object} interactions - Object or array of interactions
+     * @param {string} action - type of schedul
+     * @param {Object} options - configuration of the request
+     * @returns {Promise<Object>} SOAP object converted from XML
+     */
+    schedule(type, schedule, interactions, action, options) {
+        const body = {
+            ScheduleRequestMsg: {
+                '@_xmlns': 'http://exacttarget.com/wsdl/partnerAPI',
+                Action: action,
+                Options: options,
+                Schedule: schedule,
+                Interactions: interactions,
+            },
+        };
+        if (Array.isArray(body.ScheduleRequestMsg.Interactions)) {
+            body.ScheduleRequestMsg.Interactions = body.ScheduleRequestMsg.Interactions.map((i) => {
+                i.Interaction['@_xsi:type'] = type;
+                return i;
+            });
+        } else if (isObject(body.ScheduleRequestMsg.Interactions)) {
+            body.ScheduleRequestMsg.Interactions.Interaction['@_xsi:type'] = type;
+        } else {
+            throw new TypeError('Interactions must be of Array or Object Type');
         }
-        // TODO continueRequest + Pagination
-        return _apiRequest(this.auth, {
-            action: 'Retrieve',
-            req: body,
-            key: 'RetrieveResponseMsg',
-            retry: true,
-        });
+        validateOptions(options);
+        return _apiRequest(
+            this.auth,
+            {
+                action: 'Schedule',
+                req: body,
+                key: 'ScheduleResponse',
+            },
+            1
+        );
+    }
+    /**
+     * Method used to describe metadata via SOAP API
+     * @param {string} type -SOAP Object type
+     * @returns {Promise<Object>} SOAP object converted from XML
+     */
+    describe(type) {
+        return _apiRequest(
+            this.auth,
+            {
+                action: 'Describe',
+                req: {
+                    DefinitionRequestMsg: {
+                        '@_xmlns': 'http://exacttarget.com/wsdl/partnerAPI',
+                        DescribeRequests: {
+                            ObjectDefinitionRequest: {
+                                ObjectType: type,
+                            },
+                        },
+                    },
+                },
+                key: 'DefinitionResponseMsg',
+            },
+            1
+        );
+    }
+    /**
+     * Method used to execute data via SOAP API
+     * @param {string} type -SOAP Object type
+     * @param {Array<String>} props - Properties which should be retrieved
+     * @returns {Promise<Object>} SOAP object converted from XML
+     */
+    execute(type, props) {
+        return _apiRequest(
+            this.auth,
+            {
+                action: 'Execute',
+                req: {
+                    ExecuteRequestMsg: {
+                        '@_xmlns': 'http://exacttarget.com/wsdl/partnerAPI',
+                        Requests: {
+                            Name: type,
+                            Parameters: props,
+                        },
+                    },
+                },
+                key: 'ExecuteResponseMsg',
+            },
+            1
+        );
+    }
+    /**
+     * Method used to execute data via SOAP API
+     * @param {string} type -SOAP Object type
+     * @param {Array<String>} props - Properties which should be retrieved
+     * @returns {Promise<Object>} SOAP object converted from XML
+     */
+    perform(type) {
+        return _apiRequest(
+            this.auth,
+            {
+                action: 'perform',
+                req: {
+                    PerformRequestMsg: {
+                        '@_xmlns': 'http://exacttarget.com/wsdl/partnerAPI',
+                        Action: 'start',
+                        Definitions: [
+                            {
+                                Definition: {
+                                    '@_xsi:type': type,
+                                },
+                            },
+                        ],
+                    },
+                },
+                key: 'PerformResponseMsg',
+            },
+            1
+        );
     }
 };
 /**
  * Method to build the payload then conver to XML
  * @param {Object} request Object form of the payload
- * @param {String} token access token for authentication
+ * @param {string} token access token for authentication
  * @return {Promise<String>} XML string payload
  */
 function _buildEnvelope(request, token) {
-    const builder = new xml2js.Builder({
-        rootName: 'Envelope',
-        headless: true,
-    });
-    return builder.buildObject({
-        Body: request,
-        $: {
-            xmlns: 'http://schemas.xmlsoap.org/soap/envelope/',
-            'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
-        },
-        Header: {
-            fueloauth: {
-                $: {
-                    xmlns: 'http://exacttarget.com',
+    const jsonToXml = new JsonToXml({ ignoreAttributes: false });
+    return jsonToXml.parse({
+        Envelope: {
+            Body: request,
+            '@_xmlns': 'http://schemas.xmlsoap.org/soap/envelope/',
+            '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+            Header: {
+                fueloauth: {
+                    '@_xmlns': 'http://exacttarget.com',
+                    '#text': token,
                 },
-                _: token,
             },
         },
     });
@@ -110,25 +347,18 @@ function _parseFilter(filter) {
             break;
     }
 
-    obj.$ = { 'xsi:type': filterType + 'FilterPart' };
+    obj['@_xsi:type'] = filterType + 'FilterPart';
 
     return obj;
 }
 /**
  * Method to parse the XML response
- * @param {String} body payload in XML format
- * @param {String} key key of the expected response body
+ * @param {string} body payload in XML format
+ * @param {string} key key of the expected response body
  * @return {Promise<Object|Error>} Result of request in Object format
  */
 async function _parseResponse(body, key) {
-    const parser = new xml2js.Parser({
-        trim: true,
-        normalize: true,
-        explicitArray: false,
-        ignoreAttrs: true,
-    });
-
-    const payload = await parser.parseStringPromise(body);
+    const payload = xmlToJson.parse(body);
     const soapBody = payload['soap:Envelope']['soap:Body'];
     // checks errors in Body Fault
     if (soapBody['soap:Fault']) {
@@ -151,8 +381,13 @@ async function _parseResponse(body, key) {
         soapError.errorPropagatedFrom = key;
         throw soapError;
     }
+    // These should always be run no matter the execution
+    // Results should always be an array
+    if (isObject(soapBody[key].Results)) {
+        soapBody[key].Results = [soapBody[key].Results];
+    }
     // retrieve parse
-    if (key === 'RetrieveResponseMsg') {
+    if (['CreateResponse', 'RetrieveResponseMsg', 'UpdateResponse'].includes(key)) {
         if (
             soapBody[key].OverallStatus === 'OK' ||
             soapBody[key].OverallStatus === 'MoreDataAvailable'
@@ -160,9 +395,12 @@ async function _parseResponse(body, key) {
             return soapBody[key];
         } else {
             // This is an error
-            const soapError = new Error(soapBody[key].OverallStatus.split(':')[1].trim());
+            const errorType = soapBody[key].OverallStatus.includes(':')
+                ? soapBody[key].OverallStatus.split(':')[1].trim()
+                : soapBody[key].OverallStatus;
+            const soapError = new Error(errorType);
             soapError.requestId = soapBody[key].RequestID;
-            soapError.errorPropagatedFrom = 'Retrieve Response';
+            soapError.errorPropagatedFrom = key;
             throw soapError;
         }
     }
@@ -174,9 +412,10 @@ async function _parseResponse(body, key) {
  * Method that makes the api request
  * @param {Object} auth - Auth Object used to make request
  * @param {Object} options configuration for the request including body
+ * @param {number} remainingAttempts number of times this request should be reattempted in case of error
  * @returns {Promise<Object>} Results from the SOAP request in Object format
  */
-async function _apiRequest(auth, options) {
+async function _apiRequest(auth, options, remainingAttempts) {
     if (!isObject(options)) {
         throw new TypeError('options argument is required');
     }
@@ -192,10 +431,40 @@ async function _apiRequest(auth, options) {
             },
             data: _buildEnvelope(options.req, auth.options.access_token),
         };
+
         const res = await axios(requestOptions);
         return _parseResponse(res.data, options.key);
     } catch (ex) {
-        console.error(ex.message, ex.response);
-        console.error(options);
+        if (ex.response && [404, 596].includes(Number(ex.response.status)) && remainingAttempts) {
+            // force refresh due to url related issue
+            await auth.getAccessToken(true);
+            return _apiRequest(auth, options, remainingAttempts--);
+        }
+        throw ex;
+    }
+}
+/**
+ * Method checks options object for validity
+ * @param {Object} options configuration for the request including body
+ * @param {Array<String>} additional - additional keys which are acceptable
+ * @returns {Void} throws error if not supported
+ */
+function validateOptions(options, additional) {
+    additional = additional || [];
+    const defaultOptions = [
+        'CallsInConversation',
+        'Client',
+        'ConversationID',
+        'Priority',
+        'RequestType',
+        'SaveOptions',
+        'ScheduledTime',
+        'SendResponseTo',
+        'SequenceCode',
+    ];
+    for (const key in options) {
+        if (!defaultOptions.concat(additional).includes(key)) {
+            throw new Error(`${key} is not a supported Option`);
+        }
     }
 }

package/package.json

@@ -1,16 +1,21 @@
 {
     "name": "sfmc-sdk",
-    "version": "0.0.2",
+    "version": "0.0.6",
     "description": "Libarary to simplify SFMC requests with updated dependencies and less overhead",
     "main": "./lib/index.js",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1"
     },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DougMidgley/SFMC-SDK.git"
+    },
     "author": "Doug Midgley <douglasmidgley@gmail.com>",
     "license": "BSD-3-Clause",
     "dependencies": {
-        "axios": "^0.21.1",
-        "xml2js": "^0.4.23"
+        "axios": "^0.24.0",
+        "fast-xml-parser": "3.21.1",
+        "p-limit": "4.0.0"
     },
     "keywords": [
         "fuel",