sfmc-sdk 0.1.1 → 0.2.0

package/.eslintrc.json

@@ -4,44 +4,22 @@
         "node": true,
         "mocha": true
     },
-    "extends": ["eslint:recommended", "prettier", "ssjs"],
-    "plugins": ["mocha", "prettier"],
+    "extends": [
+        "eslint:recommended",
+        "plugin:mocha/recommended",
+        "plugin:jsdoc/recommended",
+        "plugin:prettier/recommended"
+    ],
+    "plugins": [
+        "mocha",
+        "jsdoc"
+    ],
     "globals": {
         "Atomics": "readonly",
         "SharedArrayBuffer": "readonly"
     },
     "parserOptions": {
-        "ecmaVersion": 2018,
+        "ecmaVersion": 2020,
         "sourceType": "module"
-    },
-    "rules": {
-        "arrow-body-style": ["error", "as-needed"],
-        "curly": "error",
-        "mocha/no-exclusive-tests": "error",
-        "no-console": "off",
-        "require-jsdoc": [
-            "warn",
-            {
-                "require": {
-                    "FunctionDeclaration": true,
-                    "MethodDefinition": true,
-                    "ClassDeclaration": true,
-                    "ArrowFunctionExpression": false,
-                    "FunctionExpression": true
-                }
-            }
-        ],
-        "valid-jsdoc": "error",
-        "spaced-comment": ["warn", "always", { "block": { "exceptions": ["*"], "balanced": true } }]
-    },
-    "overrides": [
-        {
-            "files": ["*.js"],
-            "rules": {
-                "no-var": "error",
-                "prefer-const": "error",
-                "prettier/prettier": "warn"
-            }
-        }
-    ]
-}
+    }
+}

package/.github/workflows/prvalidation.yml

@@ -21,4 +21,6 @@ jobs:
         with:
           node-version: 16
           registry-url: https://registry.npmjs.org/
+      - run: npm install
+      - run: npm run lint
       - run: npm run test

package/.github/workflows/release.yml

@@ -34,7 +34,7 @@ jobs:
           git add package.json
           git add package-lock.json
           git commit -m "Release ${{ steps.create_release.outputs.tag_name }}"
-          git push origin master
+          git push origin main
       - uses: eregon/publish-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "editor.formatOnSave": true
+}

package/README.md

@@ -36,7 +36,12 @@ const sfmc = new SDK(
         auth_url: 'https://ZZZZZZZ.auth.marketingcloudapis.com/',
         account_id: 7281698,
     },
-    true
+    {
+        onLoop: (type, accumulator) => console.log("Looping", type, accumlator.length),
+        onRefresh: (options) => console.log("RefreshingToken.", Options),
+        logRequest: (req) => console.log(req),
+        logResponse: (res) => console.log(res)
+    }
 );
 ```
 
@@ -46,19 +51,25 @@ SOAP currently only supports all the standard SOAP action types. Some examples b
 
 ```javascript
 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 soapRetrieveBulk = await sfmc.soap.retrieveBulk('DataExtension', ['ObjectID'], {
+    filter: {
+        leftOperand: 'CustomerKey',
+        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"
@@ -90,7 +101,6 @@ Please make sure to update tests as appropriate.
 
 ## To Do
 
--   No tests are in place
 -   Look at persisting access tokens across sessions as an option
 -   Validation improvement
 -   Support Scopes in API Requests

package/lib/auth.js

@@ -4,60 +4,52 @@ const axios = require('axios');
 module.exports = class Auth {
     /**
      * Creates an instance of Auth.
-     * @param {Object} options Auth Payload
+     *
+     * @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 {Object} eventHandlers collection of handler functions (for examplef or logging)
+     * @param {object} eventHandlers collection of handler functions (for examplef or logging)
      */
     constructor(options, eventHandlers) {
-        if (options) {
-            if (!options.client_id) {
-                throw new Error('clientId or clientSecret is missing or invalid');
-            }
-            if (typeof options.client_id !== 'string') {
-                throw new Error('client_id or client_secret must be strings');
-            }
-            if (!options.client_secret) {
-                throw new Error('client_id or client_secret is missing or invalid');
-            }
-            if (typeof options.client_secret !== 'string') {
-                throw new Error('client_id or client_secret must be strings');
-            }
-            if (!options.account_id) {
-                throw new Error('account_id is missing or invalid');
-            }
-            if (!Number.isInteger(options.account_id)) {
-                throw new Error('account_id must be an integer');
-            }
-            if (!options.auth_url) {
-                throw new Error('auth_url is missing or invalid');
-            }
-            if (typeof options.auth_url !== 'string') {
-                throw new Error('auth_url must be a string');
-            }
-            if (
-                !/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/'
-                );
-            }
-            // TODO add check for scope
-        } else {
+        if (!options) {
             throw new Error('options are required. see readme.');
+        } else if (!options.client_id) {
+            throw new Error('client_id or client_secret is missing or invalid');
+        } else if (typeof options.client_id !== 'string') {
+            throw new Error('client_id or client_secret must be strings');
+        } else if (!options.client_secret) {
+            throw new Error('client_id or client_secret is missing or invalid');
+        } else if (typeof options.client_secret !== 'string') {
+            throw new Error('client_id or client_secret must be strings');
+        } else if (!options.account_id) {
+            throw new Error('account_id is missing or invalid');
+        } else if (!Number.isInteger(Number.parseInt(options.account_id))) {
+            throw new Error(
+                'account_id must be an Integer (Integers in String format are accepted)'
+            );
+        } else if (!options.auth_url) {
+            throw new Error('auth_url is missing or invalid');
+        } else if (typeof options.auth_url !== 'string') {
+            throw new Error('auth_url must be a string');
+        } else if (
+            !/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/'
+            );
         }
-
+        // TODO add check for scope
         this.options = Object.assign(this.options || {}, options);
         this.eventHandlers = eventHandlers;
     }
     /**
      *
      *
-     * @param {Boolean} forceRefresh used to enforce a refresh of token
-     * @return {Promise<Object>} current session information
+     * @param {boolean} forceRefresh used to enforce a refresh of token
+     * @returns {Promise<object>} current session information
      */
     async getAccessToken(forceRefresh) {
         if (Boolean(forceRefresh) || _isExpired(this.options)) {
@@ -70,8 +62,8 @@ module.exports = class Auth {
     }
 };
 /**
- * @param {Object} options Auth object
- * @return {Boolean} true if token is expired
+ * @param {object} options Auth object
+ * @returns {boolean} true if token is expired
  */
 function _isExpired(options) {
     let expired = false;
@@ -88,8 +80,8 @@ function _isExpired(options) {
 /**
  *
  *
- * @param {Object} options Auth Object for api calls
- * @return {Promise<Object>} updated Auth Object
+ * @param {object} options Auth Object for api calls
+ * @returns {Promise<object>} updated Auth Object
  */
 async function _requestToken(options) {
     // TODO retry logic

package/lib/index.js

@@ -5,8 +5,9 @@ const Soap = require('./soap');
 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 examplef or logging)
+     *
+     * @param {object} options Auth Object for making requests
+     * @param {object} eventHandlers collection of handler functions (for examplef or logging)
      */
     constructor(options, eventHandlers) {
         this.auth = new Auth(options, eventHandlers);

package/lib/rest.js

@@ -7,9 +7,10 @@ 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)
+     *
+     * @function Object() { [native code] }
+     * @param {object} auth Auth object used for initializing
+     * @param {object} eventHandlers collection of handler functions (for examplef or logging)
      */
     constructor(auth, eventHandlers) {
         this.auth = auth;
@@ -18,8 +19,9 @@ module.exports = class Rest {
 
     /**
      * Method that makes the GET API request
+     *
      * @param {string} url of the resource to retrieve
-     * @returns {Promise<Object>} API response
+     * @returns {Promise<object>} API response
      */
     get(url) {
         return _apiRequest(
@@ -33,19 +35,20 @@ module.exports = class Rest {
     }
     /**
      * 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
+     * @param {number} pageSize of the response, defaults to 50
+     * @returns {Promise<object>} API response combined items
      */
-    async getBulk(url) {
+    async getBulk(url, pageSize) {
         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());
+        let shouldPaginate = false;
+        queryParams.set('$pageSize', Number(pageSize || 50).toString());
         do {
             queryParams.set('$page', Number(page).toString());
-
             const temp = await _apiRequest(
                 this.auth,
                 {
@@ -60,22 +63,25 @@ module.exports = class Rest {
                 collector = temp;
             }
             if (Array.isArray(collector.items) && collector.items.length >= temp.count) {
-                shouldContinue = false;
+                shouldPaginate = false;
             } else {
                 page++;
-                shouldContinue = true;
+                shouldPaginate = true;
             }
-        } while (shouldContinue);
+        } while (shouldPaginate);
         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 {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) {
+    async getCollection(urlArray, concurrentLimit) {
         const limit = pLimit(concurrentLimit || 5);
+        // run auth before to avoid parallel requests
+        await this.auth.getAccessToken();
         return Promise.all(
             urlArray.map((url) =>
                 limit(() =>
@@ -93,9 +99,10 @@ module.exports = class Rest {
     }
     /**
      * Method that makes the POST api request
+     *
      * @param {string} url of the resource to create
-     * @param {Object} payload for the POST request body
-     * @returns {Promise<Object>} API response
+     * @param {object} payload for the POST request body
+     * @returns {Promise<object>} API response
      */
     post(url, payload) {
         const options = {
@@ -108,9 +115,10 @@ module.exports = class Rest {
     }
     /**
      * Method that makes the PUT api request
+     *
      * @param {string} url of the resource to replace
-     * @param {Object} payload for the PUT request body
-     * @returns {Promise<Object>} API response
+     * @param {object} payload for the PUT request body
+     * @returns {Promise<object>} API response
      */
     put(url, payload) {
         const options = {
@@ -123,9 +131,10 @@ module.exports = class Rest {
     }
     /**
      * Method that makes the PATCH api request
+     *
      * @param {string} url of the resource to update
-     * @param {Object} payload for the PATCH request body
-     * @returns {Promise<Object>} API response
+     * @param {object} payload for the PATCH request body
+     * @returns {Promise<object>} API response
      */
     patch(url, payload) {
         const options = {
@@ -138,8 +147,9 @@ module.exports = class Rest {
     }
     /**
      * Method that makes the DELETE api request
+     *
      * @param {string} url of the resource to delete
-     * @returns {Promise<Object>} API response
+     * @returns {Promise<object>} API response
      */
     delete(url) {
         return _apiRequest(
@@ -155,24 +165,25 @@ module.exports = class Rest {
 };
 /**
  * method to check if the payload is plausible and throw error if not
- * @param {Object} options API request opptions
- * @returns {Void} throws error if issue
+ *
+ * @param {object} options API request opptions
  */
 function _checkPayload(options) {
     if (!isObject(options.data)) {
-        throw new TypeError(`${options.method} requests require a payload in options.data`);
+        throw new Error(`${options.method} requests require a payload in options.data`);
     }
 }
 /**
  * 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 {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
+ * @returns {Promise<object>} Results from the Rest request in Object format
  */
 async function _apiRequest(auth, options, remainingAttempts) {
     if (!isObject(options)) {
-        throw new TypeError('options argument is required');
+        throw new Error('options argument is required');
     }
     try {
         await auth.getAccessToken();
@@ -185,14 +196,14 @@ async function _apiRequest(auth, options, remainingAttempts) {
         if (options.method.includes('POST', 'PATCH', 'PUT')) {
             requestOptions.data = options.data;
         }
-
         const res = await axios(requestOptions);
         return res.data;
     } catch (ex) {
-        if (ex.response && ex.response.status === 404 && remainingAttempts) {
+        if (ex.response && ex.response.status === 401 && remainingAttempts) {
             // force refresh due to url related issue
             await auth.getAccessToken(true);
-            return _apiRequest(auth, options, remainingAttempts--);
+            remainingAttempts--;
+            return _apiRequest(auth, options, remainingAttempts);
         } else {
             throw ex;
         }