@rockcarver/frodo-lib 0.19.2 → 2.0.0-1

package/cjs/ops/JourneyOps.js

@@ -4,8 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createFileParamTreeExportResolver = createFileParamTreeExportResolver;
-exports.createMultiTreeExportTemplate = createMultiTreeExportTemplate;
-exports.createSingleTreeExportTemplate = createSingleTreeExportTemplate;
+exports.default = void 0;
 exports.deleteJourney = deleteJourney;
 exports.deleteJourneys = deleteJourneys;
 exports.disableJourney = disableJourney;
@@ -31,7 +30,6 @@ var _uuid = require("uuid");
 var _lodash = _interopRequireDefault(require("lodash"));
 var _ExportImportUtils = require("./utils/ExportImportUtils");
 var _OpsUtils = require("./utils/OpsUtils");
-var state = _interopRequireWildcard(require("../shared/State"));
 var _NodeApi = require("../api/NodeApi");
 var _NodeOps = require("./NodeOps");
 var _TreeApi = require("../api/TreeApi");
@@ -51,6 +49,328 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class JourneyOps {
+  constructor(state) {
+    /**
+     * Default tree export resolver used to resolve a tree id/name to a full export
+     * w/o dependencies of that tree from a platform instance.
+     * @param {string} treeId id/name of the tree to resolve
+     * @returns {TreeExportResolverInterface} tree export
+     */
+    _defineProperty(this, "onlineTreeExportResolver", onlineTreeExportResolver);
+    /**
+     * Tree export resolver used to resolve a tree id/name to a full export
+     * of that tree from individual `treename.journey.json` export files.
+     * @param {string} treeId id/name of the tree to resolve
+     * @returns {TreeExportResolverInterface} tree export
+     */
+    _defineProperty(this, "fileByIdTreeExportResolver", fileByIdTreeExportResolver);
+    this.state = state;
+  }
+
+  /**
+   * Create an empty single tree export template
+   * @returns {SingleTreeExportInterface} an empty single tree export template
+   */
+  createSingleTreeExportTemplate() {
+    return createSingleTreeExportTemplate({
+      state: this.state
+    });
+  }
+
+  /**
+   * Create an empty multi tree export template
+   * @returns {MultiTreeExportInterface} an empty multi tree export template
+   */
+  createMultiTreeExportTemplate() {
+    return createMultiTreeExportTemplate({
+      state: this.state
+    });
+  }
+
+  /**
+   * Create export data for a tree/journey with all its nodes and dependencies. The export data can be written to a file as is.
+   * @param {string} treeId tree id/name
+   * @param {TreeExportOptions} options export options
+   * @returns {Promise<SingleTreeExportInterface>} a promise that resolves to an object containing the tree and all its nodes and dependencies
+   */
+  exportJourney(treeId) {
+    var _arguments = arguments,
+      _this = this;
+    return _asyncToGenerator(function* () {
+      var options = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : {
+        useStringArrays: true,
+        deps: true
+      };
+      return exportJourney({
+        treeId,
+        options,
+        state: _this.state
+      });
+    })();
+  }
+
+  /**
+   * Get all the journeys/trees without all their nodes and dependencies.
+   * @returns {Promise<TreeSkeleton[]>} a promise that resolves to an array of journey objects
+   */
+  getJourneys() {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      return getJourneys({
+        state: _this2.state
+      });
+    })();
+  }
+
+  /**
+   * Get a journey/tree without all its nodes and dependencies.
+   * @param {string} journeyId journey id/name
+   * @returns {Promise<TreeSkeleton>} a promise that resolves to a journey object
+   */
+  getJourney(journeyId) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      return getJourney({
+        journeyId,
+        state: _this3.state
+      });
+    })();
+  }
+
+  /**
+   * Helper to import a tree with all dependencies from a `SingleTreeExportInterface` object (typically read from a file)
+   * @param {SingleTreeExportInterface} treeObject tree object containing tree and all its dependencies
+   * @param {TreeImportOptions} options import options
+   * @returns {Promise<boolean>} a promise that resolves to true if no errors occurred during import
+   */
+  importJourney(treeObject, options) {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      return importJourney({
+        treeObject,
+        options,
+        state: _this4.state
+      });
+    })();
+  }
+
+  /**
+   * Resolve journey dependencies
+   * @param {Map} installedJorneys Map of installed journeys
+   * @param {Map} journeyMap Map of journeys to resolve dependencies for
+   * @param {string[]} unresolvedJourneys Map to hold the names of unresolved journeys and their dependencies
+   * @param {string[]} resolvedJourneys Array to hold the names of resolved journeys
+   * @param {int} index Depth of recursion
+   */
+  resolveDependencies(installedJorneys, journeyMap, unresolvedJourneys, resolvedJourneys) {
+    var _arguments2 = arguments;
+    return _asyncToGenerator(function* () {
+      var index = _arguments2.length > 4 && _arguments2[4] !== undefined ? _arguments2[4] : -1;
+      return resolveDependencies(installedJorneys, journeyMap, unresolvedJourneys, resolvedJourneys, index);
+    })();
+  }
+
+  /**
+   * Helper to import multiple trees from a tree map
+   * @param {MultiTreeExportInterface} treesMap map of trees object
+   * @param {TreeImportOptions} options import options
+   */
+  importAllJourneys(treesMap, options) {
+    var _this5 = this;
+    return _asyncToGenerator(function* () {
+      return importAllJourneys({
+        treesMap,
+        options,
+        state: _this5.state
+      });
+    })();
+  }
+
+  /**
+   * Get the node reference obbject for a node object. Node reference objects
+   * are used in a tree flow definition and within page nodes to reference
+   * nodes. Among other things, node references contain all the non-configuration
+   * meta data that exists for readaility, like the x/y coordinates of the node
+   * and the display name chosen by the tree designer. The dislay name is the
+   * only intuitive link between the graphical representation of the tree and
+   * the node configurations that make up the tree.
+   * @param nodeObj node object to retrieve the node reference object for
+   * @param singleTreeExport tree export with or without dependencies
+   * @returns {NodeRefSkeletonInterface | InnerNodeRefSkeletonInterface} node reference object
+   */
+  getNodeRef(nodeObj, singleTreeExport) {
+    return getNodeRef(nodeObj, singleTreeExport);
+  }
+  /**
+   * Factory that creates a tree export resolver used to resolve a tree id
+   * to a full export of that tree from a multi-tree export file.
+   * @param {string} file multi-tree export file
+   * @returns {TreeExportResolverInterface} tree export resolver
+   */
+  createFileParamTreeExportResolver(file) {
+    return createFileParamTreeExportResolver(file, this.state);
+  }
+
+  /**
+   * Get tree dependencies (all descendent inner trees)
+   * @param {SingleTreeExportInterface} treeExport single tree export
+   * @param {string[]} resolvedTreeIds list of tree ids wich have already been resolved
+   * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
+   * @returns {Promise<TreeDependencyMapInterface>} a promise that resolves to a tree dependency map
+   */
+  getTreeDescendents(treeExport, resolveTreeExport) {
+    var _arguments3 = arguments,
+      _this6 = this;
+    return _asyncToGenerator(function* () {
+      var resolvedTreeIds = _arguments3.length > 2 && _arguments3[2] !== undefined ? _arguments3[2] : [];
+      return getTreeDescendents({
+        treeExport,
+        resolveTreeExport,
+        resolvedTreeIds,
+        state: _this6.state
+      });
+    })();
+  }
+
+  /**
+   * Find all node configuration objects that are no longer referenced by any tree
+   * @returns {Promise<unknown[]>} a promise that resolves to an array of orphaned nodes
+   */
+  findOrphanedNodes() {
+    var _this7 = this;
+    return _asyncToGenerator(function* () {
+      return findOrphanedNodes({
+        state: _this7.state
+      });
+    })();
+  }
+
+  /**
+   * Remove orphaned nodes
+   * @param {NodeSkeleton[]} orphanedNodes Pass in an array of orphaned node configuration objects to remove
+   * @returns {Promise<NodeSkeleton[]>} a promise that resolves to an array nodes that encountered errors deleting
+   */
+  removeOrphanedNodes(orphanedNodes) {
+    var _this8 = this;
+    return _asyncToGenerator(function* () {
+      return removeOrphanedNodes({
+        orphanedNodes,
+        state: _this8.state
+      });
+    })();
+  }
+
+  /**
+   * Analyze if a journey contains any custom nodes considering the detected or the overridden version.
+   * @param {SingleTreeExportInterface} journey Journey/tree configuration object
+   * @returns {boolean} True if the journey/tree contains any custom nodes, false otherwise.
+   */
+  isCustomJourney(journey) {
+    return isCustomJourney({
+      journey,
+      state: this.state
+    });
+  }
+
+  /**
+   * Analyze if a journey contains any premium nodes considering the detected or the overridden version.
+   * @param {SingleTreeExportInterface} journey Journey/tree configuration object
+   * @returns {boolean} True if the journey/tree contains any custom nodes, false otherwise.
+   */
+  isPremiumJourney(journey) {
+    return isPremiumJourney(journey);
+  }
+
+  /**
+   * Analyze if a journey contains any cloud-only nodes considering the detected or the overridden version.
+   * @param {SingleTreeExportInterface} journey Journey/tree configuration object
+   * @returns {boolean} True if the journey/tree contains any cloud-only nodes, false otherwise.
+   */
+  isCloudOnlyJourney(journey) {
+    return isCloudOnlyJourney(journey);
+  }
+
+  /**
+   * Get a journey's classifications, which can be one or multiple of:
+   * - standard: can run on any instance of a ForgeRock platform
+   * - cloud: utilize nodes, which are exclusively available in the ForgeRock Identity Cloud
+   * - premium: utilizes nodes, which come at a premium
+   * - custom: utilizes nodes not included in the ForgeRock platform release
+   * @param {SingleTreeExportInterface} journey journey export data
+   * @returns {JourneyClassification[]} an array of one or multiple classifications
+   */
+  getJourneyClassification(journey) {
+    return getJourneyClassification({
+      journey,
+      state: this.state
+    });
+  }
+
+  /**
+   * Delete a journey
+   * @param {string} journeyId journey id/name
+   * @param {Object} options deep=true also delete all the nodes and inner nodes, verbose=true print verbose info
+   */
+  deleteJourney(journeyId, options) {
+    var _this9 = this;
+    return _asyncToGenerator(function* () {
+      return deleteJourney({
+        journeyId,
+        options,
+        state: _this9.state
+      });
+    })();
+  }
+
+  /**
+   * Delete all journeys
+   * @param {Object} options deep=true also delete all the nodes and inner nodes, verbose=true print verbose info
+   */
+  deleteJourneys(options) {
+    var _this10 = this;
+    return _asyncToGenerator(function* () {
+      return deleteJourneys({
+        options,
+        state: _this10.state
+      });
+    })();
+  }
+
+  /**
+   * Enable a journey
+   * @param journeyId journey id/name
+   * @returns {Promise<boolean>} true if the operation was successful, false otherwise
+   */
+  enableJourney(journeyId) {
+    var _this11 = this;
+    return _asyncToGenerator(function* () {
+      return enableJourney({
+        journeyId,
+        state: _this11.state
+      });
+    })();
+  }
+
+  /**
+   * Disable a journey
+   * @param journeyId journey id/name
+   * @returns {Promise<boolean>} true if the operation was successful, false otherwise
+   */
+  disableJourney(journeyId) {
+    var _this12 = this;
+    return _asyncToGenerator(function* () {
+      return disableJourney({
+        journeyId,
+        state: _this12.state
+      });
+    })();
+  }
+}
+exports.default = JourneyOps;
 var containerNodes = ['PageNode', 'CustomPageNode'];
 var scriptedNodes = ['ConfigProviderNode', 'ScriptedDecisionNode', 'ClientScriptNode', 'SocialProviderHandlerNode', 'CustomScriptNode'];
 var emailTemplateNodes = ['EmailSuspendNode', 'EmailTemplateNode'];
@@ -60,9 +380,14 @@ var emptyScriptPlaceholder = '[Empty]';
  * Create an empty single tree export template
  * @returns {SingleTreeExportInterface} an empty single tree export template
  */
-function createSingleTreeExportTemplate() {
+function createSingleTreeExportTemplate(_ref) {
+  var {
+    state
+  } = _ref;
   return {
-    meta: (0, _ExportImportUtils.getMetadata)(),
+    meta: (0, _ExportImportUtils.getMetadata)({
+      state
+    }),
     innerNodes: {},
     nodes: {},
     scripts: {},
@@ -79,9 +404,14 @@ function createSingleTreeExportTemplate() {
  * Create an empty multi tree export template
  * @returns {MultiTreeExportInterface} an empty multi tree export template
  */
-function createMultiTreeExportTemplate() {
+function createMultiTreeExportTemplate(_ref2) {
+  var {
+    state
+  } = _ref2;
   return {
-    meta: (0, _ExportImportUtils.getMetadata)(),
+    meta: (0, _ExportImportUtils.getMetadata)({
+      state
+    }),
     trees: {}
   };
 }
@@ -93,7 +423,7 @@ function createMultiTreeExportTemplate() {
  * @param {[Object]} allCirclesOfTrust array of all circle of trust objects
  * @returns {Promise} a promise that resolves to an object containing a saml2 dependencies
  */
-function getSaml2NodeDependencies(_x, _x2, _x3) {
+function getSaml2NodeDependencies(_x, _x2, _x3, _x4) {
   return _getSaml2NodeDependencies.apply(this, arguments);
 }
 /**
@@ -103,7 +433,7 @@ function getSaml2NodeDependencies(_x, _x2, _x3) {
  * @returns {Promise<SingleTreeExportInterface>} a promise that resolves to an object containing the tree and all its nodes and dependencies
  */
 function _getSaml2NodeDependencies() {
-  _getSaml2NodeDependencies = _asyncToGenerator(function* (nodeObject, allProviders, allCirclesOfTrust) {
+  _getSaml2NodeDependencies = _asyncToGenerator(function* (nodeObject, allProviders, allCirclesOfTrust, state) {
     var samlProperties = ['metaAlias', 'idpEntityId'];
     var saml2EntityPromises = [];
     for (var samlProperty of samlProperties) {
@@ -114,7 +444,11 @@ function _getSaml2NodeDependencies() {
       });
       if (entity) {
         try {
-          var providerResponse = yield (0, _Saml2Api.getProviderByLocationAndId)(entity.location, entity._id);
+          var providerResponse = yield (0, _Saml2Api.getProviderByLocationAndId)({
+            location: entity.location,
+            entityId64: entity._id,
+            state
+          });
           /**
            * Adding entityLocation here to the entityResponse because the import tool
            * needs to know whether the saml2 entity is remote or not (this will be removed
@@ -124,7 +458,10 @@ function _getSaml2NodeDependencies() {
           providerResponse.entityLocation = entity.location;
           if (entity.location === 'remote') {
             // get the xml representation of this entity and add it to the entityResponse;
-            var metaDataResponse = yield (0, _Saml2Api.getProviderMetadata)(providerResponse.entityId);
+            var metaDataResponse = yield (0, _Saml2Api.getProviderMetadata)({
+              entityId: providerResponse.entityId,
+              state
+            });
             providerResponse.base64EntityXML = (0, _Base.encodeBase64Url)(metaDataResponse);
           }
           saml2EntityPromises.push(providerResponse);
@@ -167,7 +504,7 @@ function _getSaml2NodeDependencies() {
   });
   return _getSaml2NodeDependencies.apply(this, arguments);
 }
-function exportJourney(_x4) {
+function exportJourney(_x5) {
   return _exportJourney.apply(this, arguments);
 }
 /**
@@ -175,14 +512,23 @@ function exportJourney(_x4) {
  * @returns {Promise<TreeSkeleton[]>} a promise that resolves to an array of journey objects
  */
 function _exportJourney() {
-  _exportJourney = _asyncToGenerator(function* (treeId) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      useStringArrays: true,
-      deps: true
-    };
-    var exportData = createSingleTreeExportTemplate();
+  _exportJourney = _asyncToGenerator(function* (_ref3) {
+    var {
+      treeId,
+      options = {
+        useStringArrays: true,
+        deps: true
+      },
+      state
+    } = _ref3;
+    var exportData = createSingleTreeExportTemplate({
+      state
+    });
     try {
-      var treeObject = yield (0, _TreeApi.getTree)(treeId);
+      var treeObject = yield (0, _TreeApi.getTree)({
+        id: treeId,
+        state
+      });
       var {
         useStringArrays,
         deps
@@ -204,7 +550,9 @@ function _exportJourney() {
       var themePromise = null;
       if (deps && state.getDeploymentType() !== globalConfig.CLASSIC_DEPLOYMENT_TYPE_KEY) {
         try {
-          themePromise = (0, _ThemeOps.getThemes)();
+          themePromise = (0, _ThemeOps.getThemes)({
+            state
+          });
         } catch (error) {
           (0, _Console.printMessage)(error, 'error');
         }
@@ -216,7 +564,11 @@ function _exportJourney() {
 
       // get all the nodes
       for (var [nodeId, nodeInfo] of Object.entries(treeObject.nodes)) {
-        nodePromises.push((0, _NodeApi.getNode)(nodeId, nodeInfo['nodeType']));
+        nodePromises.push((0, _NodeApi.getNode)({
+          nodeId,
+          nodeType: nodeInfo['nodeType'],
+          state
+        }));
       }
       if (verbose && nodePromises.length > 0) (0, _Console.printMessage)('  - Nodes:');
       var nodeObjects = yield Promise.all(nodePromises);
@@ -230,14 +582,20 @@ function _exportJourney() {
 
         // handle script node types
         if (deps && scriptedNodes.includes(nodeType) && nodeObject.script !== emptyScriptPlaceholder) {
-          scriptPromises.push((0, _ScriptApi.getScript)(nodeObject.script));
+          scriptPromises.push((0, _ScriptApi.getScript)({
+            scriptId: nodeObject.script,
+            state
+          }));
         }
 
         // frodo supports email templates in platform deployments
         if (deps && state.getDeploymentType() === globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY || state.getDeploymentType() === globalConfig.FORGEOPS_DEPLOYMENT_TYPE_KEY) {
           if (emailTemplateNodes.includes(nodeType)) {
             try {
-              var emailTemplate = yield (0, _EmailTemplateOps.getEmailTemplate)(nodeObject.emailTemplateName);
+              var emailTemplate = yield (0, _EmailTemplateOps.getEmailTemplate)({
+                templateId: nodeObject.emailTemplateName,
+                state
+              });
               emailTemplatePromises.push(emailTemplate);
             } catch (error) {
               var message = "".concat(error);
@@ -253,18 +611,24 @@ function _exportJourney() {
         if (deps && nodeType === 'product-Saml2Node') {
           if (!allSaml2Providers) {
             // eslint-disable-next-line no-await-in-loop
-            allSaml2Providers = (yield (0, _Saml2Api.getProviders)()).result;
+            allSaml2Providers = (yield (0, _Saml2Api.getProviders)({
+              state
+            })).result;
           }
           if (!allCirclesOfTrust) {
             // eslint-disable-next-line no-await-in-loop
-            allCirclesOfTrust = (yield (0, _CirclesOfTrustApi.getCirclesOfTrust)()).result;
+            allCirclesOfTrust = (yield (0, _CirclesOfTrustApi.getCirclesOfTrust)({
+              state
+            })).result;
           }
-          saml2ConfigPromises.push(getSaml2NodeDependencies(nodeObject, allSaml2Providers, allCirclesOfTrust));
+          saml2ConfigPromises.push(getSaml2NodeDependencies(nodeObject, allSaml2Providers, allCirclesOfTrust, state));
         }
 
         // If this is a SocialProviderHandlerNode get each enabled social identity provider.
         if (deps && !socialProviderPromise && nodeType === 'SocialProviderHandlerNode') {
-          socialProviderPromise = (0, _SocialIdentityProvidersApi.getSocialIdentityProviders)();
+          socialProviderPromise = (0, _SocialIdentityProvidersApi.getSocialIdentityProviders)({
+            state
+          });
         }
 
         // If this is a SelectIdPNode and filteredProviters is not already set to empty array set filteredSocialProviers.
@@ -280,7 +644,11 @@ function _exportJourney() {
         // get inner nodes (nodes inside container nodes)
         if (containerNodes.includes(nodeType)) {
           for (var innerNode of nodeObject.nodes) {
-            innerNodePromises.push((0, _NodeApi.getNode)(innerNode._id, innerNode.nodeType));
+            innerNodePromises.push((0, _NodeApi.getNode)({
+              nodeId: innerNode._id,
+              nodeType: innerNode.nodeType,
+              state
+            }));
           }
           // frodo supports themes in platform deployments
           if (deps && state.getDeploymentType() === globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY || state.getDeploymentType() === globalConfig.FORGEOPS_DEPLOYMENT_TYPE_KEY) {
@@ -316,14 +684,20 @@ function _exportJourney() {
 
         // handle script node types
         if (deps && scriptedNodes.includes(innerNodeType)) {
-          scriptPromises.push((0, _ScriptApi.getScript)(innerNodeObject.script));
+          scriptPromises.push((0, _ScriptApi.getScript)({
+            scriptId: innerNodeObject.script,
+            state
+          }));
         }
 
         // frodo supports email templates in platform deployments
         if (deps && state.getDeploymentType() === globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY || state.getDeploymentType() === globalConfig.FORGEOPS_DEPLOYMENT_TYPE_KEY) {
           if (emailTemplateNodes.includes(innerNodeType)) {
             try {
-              var _emailTemplate = yield (0, _EmailTemplateOps.getEmailTemplate)(innerNodeObject.emailTemplateName);
+              var _emailTemplate = yield (0, _EmailTemplateOps.getEmailTemplate)({
+                templateId: innerNodeObject.emailTemplateName,
+                state
+              });
               emailTemplatePromises.push(_emailTemplate);
             } catch (error) {
               var _message = "".concat(error);
@@ -340,18 +714,24 @@ function _exportJourney() {
           (0, _Console.printMessage)('SAML2 inner node', 'error');
           if (!allSaml2Providers) {
             // eslint-disable-next-line no-await-in-loop
-            allSaml2Providers = (yield (0, _Saml2Api.getProviders)()).result;
+            allSaml2Providers = (yield (0, _Saml2Api.getProviders)({
+              state
+            })).result;
           }
           if (!allCirclesOfTrust) {
             // eslint-disable-next-line no-await-in-loop
-            allCirclesOfTrust = (yield (0, _CirclesOfTrustApi.getCirclesOfTrust)()).result;
+            allCirclesOfTrust = (yield (0, _CirclesOfTrustApi.getCirclesOfTrust)({
+              state
+            })).result;
           }
-          saml2ConfigPromises.push(getSaml2NodeDependencies(innerNodeObject, allSaml2Providers, allCirclesOfTrust));
+          saml2ConfigPromises.push(getSaml2NodeDependencies(innerNodeObject, allSaml2Providers, allCirclesOfTrust, state));
         }
 
         // If this is a SocialProviderHandlerNode get each enabled social identity provider.
         if (deps && !socialProviderPromise && innerNodeType === 'SocialProviderHandlerNode') {
-          socialProviderPromise = (0, _SocialIdentityProvidersApi.getSocialIdentityProviders)();
+          socialProviderPromise = (0, _SocialIdentityProvidersApi.getSocialIdentityProviders)({
+            state
+          });
         }
 
         // If this is a SelectIdPNode and filteredProviters is not already set to empty array set filteredSocialProviers.
@@ -401,7 +781,10 @@ function _exportJourney() {
           // filteredProviders property of a SelectIdPNode do it here.
           if (socialProvider && (!filteredSocialProviders || filteredSocialProviders.length === 0 || filteredSocialProviders.includes(socialProvider._id))) {
             if (verbose) (0, _Console.printMessage)("    - ".concat(socialProvider._id), 'info');
-            scriptPromises.push((0, _ScriptApi.getScript)(socialProvider.transform));
+            scriptPromises.push((0, _ScriptApi.getScript)({
+              scriptId: socialProvider.transform,
+              state
+            }));
             exportData.socialIdentityProviders[socialProvider._id] = socialProvider;
           }
         }
@@ -446,7 +829,7 @@ function _exportJourney() {
   });
   return _exportJourney.apply(this, arguments);
 }
-function getJourneys() {
+function getJourneys(_x6) {
   return _getJourneys.apply(this, arguments);
 }
 /**
@@ -455,16 +838,21 @@ function getJourneys() {
  * @returns {Promise<TreeSkeleton>} a promise that resolves to a journey object
  */
 function _getJourneys() {
-  _getJourneys = _asyncToGenerator(function* () {
+  _getJourneys = _asyncToGenerator(function* (_ref4) {
+    var {
+      state
+    } = _ref4;
     var {
       result
-    } = yield (0, _TreeApi.getTrees)();
+    } = yield (0, _TreeApi.getTrees)({
+      state
+    });
     result.sort((a, b) => a._id.localeCompare(b._id));
     return result;
   });
   return _getJourneys.apply(this, arguments);
 }
-function getJourney(_x5) {
+function getJourney(_x7) {
   return _getJourney.apply(this, arguments);
 }
 /**
@@ -474,13 +862,20 @@ function getJourney(_x5) {
  * @returns {Promise<boolean>} a promise that resolves to true if no errors occurred during import
  */
 function _getJourney() {
-  _getJourney = _asyncToGenerator(function* (journeyId) {
-    var response = yield (0, _TreeApi.getTree)(journeyId);
+  _getJourney = _asyncToGenerator(function* (_ref5) {
+    var {
+      journeyId,
+      state
+    } = _ref5;
+    var response = yield (0, _TreeApi.getTree)({
+      id: journeyId,
+      state
+    });
     return response;
   });
   return _getJourney.apply(this, arguments);
 }
-function importJourney(_x6, _x7) {
+function importJourney(_x8) {
   return _importJourney.apply(this, arguments);
 }
 /**
@@ -492,7 +887,12 @@ function importJourney(_x6, _x7) {
  * @param {int} index Depth of recursion
  */
 function _importJourney() {
-  _importJourney = _asyncToGenerator(function* (treeObject, options) {
+  _importJourney = _asyncToGenerator(function* (_ref6) {
+    var {
+      treeObject,
+      options,
+      state
+    } = _ref6;
     var {
       reUuid,
       deps
@@ -515,7 +915,11 @@ function _importJourney() {
           scriptObject['script'] = (0, _Base.encode)(JSON.parse(scriptObject['script']));
         }
         try {
-          yield (0, _ScriptOps.putScript)(scriptId, scriptObject);
+          yield (0, _ScriptOps.putScript)({
+            scriptId,
+            scriptData: scriptObject,
+            state
+          });
         } catch (error) {
           throw new Error("Error importing script ".concat(scriptObject['name'], " (").concat(scriptId, ") in journey ").concat(treeId, ": ").concat(error.message));
         }
@@ -529,7 +933,11 @@ function _importJourney() {
       for (var [templateId, templateData] of Object.entries(treeObject.emailTemplates)) {
         if (verbose) (0, _Console.printMessage)("    - ".concat(templateId), 'info', false);
         try {
-          yield (0, _EmailTemplateOps.putEmailTemplate)(templateId, templateData);
+          yield (0, _EmailTemplateOps.putEmailTemplate)({
+            templateId,
+            templateData,
+            state
+          });
         } catch (error) {
           (0, _Console.printMessage)(error.response.data, 'error');
           throw new Error("Error importing email templates: ".concat(error.message));
@@ -547,7 +955,10 @@ function _importJourney() {
         themes[theme['_id']] = theme;
       }
       try {
-        yield (0, _ThemeOps.putThemes)(themes);
+        yield (0, _ThemeOps.putThemes)({
+          themeMap: themes,
+          state
+        });
       } catch (error) {
         throw new Error("Error importing themes: ".concat(error.message));
       }
@@ -559,13 +970,23 @@ function _importJourney() {
       for (var [providerId, providerData] of Object.entries(treeObject.socialIdentityProviders)) {
         if (verbose) (0, _Console.printMessage)("    - ".concat(providerId), 'info');
         try {
-          yield (0, _SocialIdentityProvidersApi.putProviderByTypeAndId)(providerData['_type']['_id'], providerId, providerData);
+          yield (0, _SocialIdentityProvidersApi.putProviderByTypeAndId)({
+            type: providerData['_type']['_id'],
+            id: providerId,
+            providerData,
+            state
+          });
         } catch (importError) {
           var _importError$response, _importError$response2, _importError$response3;
           if (((_importError$response = importError.response) === null || _importError$response === void 0 ? void 0 : _importError$response.status) === 500 && ((_importError$response2 = importError.response) === null || _importError$response2 === void 0 ? void 0 : (_importError$response3 = _importError$response2.data) === null || _importError$response3 === void 0 ? void 0 : _importError$response3.message) === 'Unable to update SMS config: Data validation failed for the attribute, Redirect after form post URL') {
             providerData['redirectAfterFormPostURI'] = '';
             try {
-              yield (0, _SocialIdentityProvidersApi.putProviderByTypeAndId)(providerData['_type']['_id'], providerId, providerData);
+              yield (0, _SocialIdentityProvidersApi.putProviderByTypeAndId)({
+                type: providerData['_type']['_id'],
+                id: providerId,
+                providerData,
+                state
+              });
             } catch (importError2) {
               var _importError$response4;
               (0, _Console.printMessage)(((_importError$response4 = importError.response) === null || _importError$response4 === void 0 ? void 0 : _importError$response4.data) || importError, 'error');
@@ -599,14 +1020,27 @@ function _importJourney() {
         delete _providerData['entityLocation'];
         delete _providerData['base64EntityXML'];
         // create the provider if it doesn't already exist, or just update it
-        if ((yield (0, _Saml2Api.findProviders)("entityId eq '".concat(entityId, "'"), ['location'])).resultCount === 0) {
-          yield (0, _Saml2Api.createProvider)(entityLocation, _providerData, metaData).catch(createProviderErr => {
+        if ((yield (0, _Saml2Api.findProviders)({
+          filter: "entityId eq '".concat(entityId, "'"),
+          fields: ['location'],
+          state
+        })).resultCount === 0) {
+          yield (0, _Saml2Api.createProvider)({
+            location: entityLocation,
+            providerData: _providerData,
+            metaData,
+            state
+          }).catch(createProviderErr => {
             var _createProviderErr$re;
             (0, _Console.printMessage)(((_createProviderErr$re = createProviderErr.response) === null || _createProviderErr$re === void 0 ? void 0 : _createProviderErr$re.data) || createProviderErr, 'error');
             throw new Error("Error creating provider ".concat(entityId));
           });
         } else {
-          yield (0, _Saml2Api.updateProvider)(entityLocation, _providerData).catch(updateProviderErr => {
+          yield (0, _Saml2Api.updateProvider)({
+            location: entityLocation,
+            providerData: _providerData,
+            state
+          }).catch(updateProviderErr => {
             var _updateProviderErr$re;
             (0, _Console.printMessage)(((_updateProviderErr$re = updateProviderErr.response) === null || _updateProviderErr$re === void 0 ? void 0 : _updateProviderErr$re.data) || updateProviderErr, 'error');
             throw new Error("Error updating provider ".concat(entityId));
@@ -625,12 +1059,19 @@ function _importJourney() {
         delete cotData['_rev'];
         if (verbose) (0, _Console.printMessage)("    - ".concat(cotId), 'info');
         try {
-          yield (0, _CirclesOfTrustApi.createCircleOfTrust)(cotData);
+          yield (0, _CirclesOfTrustApi.createCircleOfTrust)({
+            cotData,
+            state
+          });
         } catch (createCotErr) {
           var _createCotErr$respons, _createCotErr$respons2;
           if (((_createCotErr$respons = createCotErr.response) === null || _createCotErr$respons === void 0 ? void 0 : _createCotErr$respons.status) === 409 || ((_createCotErr$respons2 = createCotErr.response) === null || _createCotErr$respons2 === void 0 ? void 0 : _createCotErr$respons2.status) === 500) {
             try {
-              yield (0, _CirclesOfTrustApi.updateCircleOfTrust)(cotId, cotData);
+              yield (0, _CirclesOfTrustApi.updateCircleOfTrust)({
+                cotId,
+                cotData,
+                state
+              });
             } catch (updateCotErr) {
               var _createCotErr$respons3, _updateCotErr$respons;
               (0, _Console.printMessage)(((_createCotErr$respons3 = createCotErr.response) === null || _createCotErr$respons3 === void 0 ? void 0 : _createCotErr$respons3.data) || createCotErr, 'error');
@@ -674,11 +1115,18 @@ function _importJourney() {
         // and the node's identityResource is the same as the tree's identityResource
         // change it to the current realm managed user identityResource otherwise leave it alone.
         if (innerNodeData['identityResource'] && innerNodeData['identityResource'].endsWith('user') && innerNodeData['identityResource'] === treeObject.tree.identityResource) {
-          innerNodeData['identityResource'] = "managed/".concat((0, _OpsUtils.getRealmManagedUser)());
+          innerNodeData['identityResource'] = "managed/".concat((0, _OpsUtils.getRealmManagedUser)({
+            state
+          }));
           if (verbose) (0, _Console.printMessage)("\n      - identityResource: ".concat(innerNodeData['identityResource']), 'info', false);
         }
         try {
-          yield (0, _NodeApi.putNode)(newUuid, nodeType, innerNodeData);
+          yield (0, _NodeApi.putNode)({
+            nodeId: newUuid,
+            nodeType,
+            nodeData: innerNodeData,
+            state
+          });
         } catch (nodeImportError) {
           var _nodeImportError$resp, _nodeImportError$resp2, _nodeImportError$resp3;
           if (nodeImportError.response.status === 400 && nodeImportError.response.data.message === 'Data validation failed for the attribute, Script') {
@@ -695,7 +1143,12 @@ function _importJourney() {
               }
             }
             try {
-              yield (0, _NodeApi.putNode)(newUuid, nodeType, innerNodeData);
+              yield (0, _NodeApi.putNode)({
+                nodeId: newUuid,
+                nodeType,
+                nodeData: innerNodeData,
+                state
+              });
             } catch (nodeImportError2) {
               (0, _Console.printMessage)(nodeImportError2.response.data, 'error');
               throw new Error("Error importing node ".concat(innerNodeId).concat(innerNodeId === newUuid ? '' : " [".concat(newUuid, "]"), " in journey ").concat(treeId));
@@ -736,11 +1189,18 @@ function _importJourney() {
         // and the node's identityResource is the same as the tree's identityResource
         // change it to the current realm managed user identityResource otherwise leave it alone.
         if (nodeData.identityResource && nodeData.identityResource.endsWith('user') && nodeData.identityResource === treeObject.tree.identityResource) {
-          nodeData['identityResource'] = "managed/".concat((0, _OpsUtils.getRealmManagedUser)());
+          nodeData['identityResource'] = "managed/".concat((0, _OpsUtils.getRealmManagedUser)({
+            state
+          }));
           if (verbose) (0, _Console.printMessage)("\n      - identityResource: ".concat(nodeData['identityResource']), 'info', false);
         }
         try {
-          yield (0, _NodeApi.putNode)(newUuid, _nodeType, nodeData);
+          yield (0, _NodeApi.putNode)({
+            nodeId: newUuid,
+            nodeType: _nodeType,
+            nodeData,
+            state
+          });
         } catch (nodeImportError) {
           var _nodeImportError$resp4, _nodeImportError$resp5, _nodeImportError$resp6;
           if (nodeImportError.response.status === 400 && nodeImportError.response.data.message === 'Data validation failed for the attribute, Script') {
@@ -757,7 +1217,12 @@ function _importJourney() {
               }
             }
             try {
-              yield (0, _NodeApi.putNode)(newUuid, _nodeType, nodeData);
+              yield (0, _NodeApi.putNode)({
+                nodeId: newUuid,
+                nodeType: _nodeType,
+                nodeData,
+                state
+              });
             } catch (nodeImportError2) {
               (0, _Console.printMessage)(nodeImportError2.response.data, 'error');
               throw new Error("Error importing node ".concat(nodeId).concat(nodeId === newUuid ? '' : " [".concat(newUuid, "]"), " in journey ").concat(treeId));
@@ -785,12 +1250,18 @@ function _importJourney() {
     // and the identityResource ends in 'user'
     // Set the identityResource for the tree to the selected resource.
     if (treeObject.tree.identityResource && treeObject.tree['identityResource'].endsWith('user') || state.getDeploymentType() === globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY || state.getDeploymentType() === globalConfig.FORGEOPS_DEPLOYMENT_TYPE_KEY) {
-      treeObject.tree.identityResource = "managed/".concat((0, _OpsUtils.getRealmManagedUser)());
+      treeObject.tree.identityResource = "managed/".concat((0, _OpsUtils.getRealmManagedUser)({
+        state
+      }));
       if (verbose) (0, _Console.printMessage)("    - identityResource: ".concat(treeObject.tree.identityResource), 'info', false);
     }
     delete treeObject.tree._rev;
     try {
-      yield (0, _TreeApi.putTree)(treeObject.tree._id, treeObject.tree);
+      yield (0, _TreeApi.putTree)({
+        treeId: treeObject.tree._id,
+        treeData: treeObject.tree,
+        state
+      });
       if (verbose) (0, _Console.printMessage)("\n    - Done", 'info', true);
     } catch (importError) {
       var _importError$response6, _importError$response7, _importError$response8;
@@ -806,7 +1277,11 @@ function _importJourney() {
           }
         }
         try {
-          yield (0, _TreeApi.putTree)(treeObject.tree._id, treeObject.tree);
+          yield (0, _TreeApi.putTree)({
+            treeId: treeObject.tree._id,
+            treeData: treeObject.tree,
+            state
+          });
           if (verbose) (0, _Console.printMessage)("\n    - Done", 'info', true);
         } catch (importError2) {
           (0, _Console.printMessage)(importError2.response.data, 'error');
@@ -823,7 +1298,7 @@ function _importJourney() {
   });
   return _importJourney.apply(this, arguments);
 }
-function resolveDependencies(_x8, _x9, _x10, _x11) {
+function resolveDependencies(_x9, _x10, _x11, _x12) {
   return _resolveDependencies.apply(this, arguments);
 }
 /**
@@ -883,7 +1358,7 @@ function _resolveDependencies() {
   });
   return _resolveDependencies.apply(this, arguments);
 }
-function importAllJourneys(_x12, _x13) {
+function importAllJourneys(_x13) {
   return _importAllJourneys.apply(this, arguments);
 }
 /**
@@ -899,8 +1374,15 @@ function importAllJourneys(_x12, _x13) {
  * @returns {NodeRefSkeletonInterface | InnerNodeRefSkeletonInterface} node reference object
  */
 function _importAllJourneys() {
-  _importAllJourneys = _asyncToGenerator(function* (treesMap, options) {
-    var installedJourneys = (yield (0, _TreeApi.getTrees)()).result.map(x => x._id);
+  _importAllJourneys = _asyncToGenerator(function* (_ref7) {
+    var {
+      treesMap,
+      options,
+      state
+    } = _ref7;
+    var installedJourneys = (yield (0, _TreeApi.getTrees)({
+      state
+    })).result.map(x => x._id);
     var unresolvedJourneys = {};
     var resolvedJourneys = [];
     (0, _Console.createProgressIndicator)(undefined, 'Resolving dependencies', 'indeterminate');
@@ -917,7 +1399,11 @@ function _importAllJourneys() {
     for (var tree of resolvedJourneys) {
       try {
         // eslint-disable-next-line no-await-in-loop
-        yield importJourney(treesMap[tree], options);
+        yield importJourney({
+          treeObject: treesMap[tree],
+          options,
+          state
+        });
         (0, _Console.updateProgressIndicator)("".concat(tree));
       } catch (error) {
         (0, _Console.printMessage)("\n".concat(error.message), 'error');
@@ -951,15 +1437,19 @@ function getNodeRef(nodeObj, singleTreeExport) {
  * @returns {TreeExportResolverInterface} tree export
  */
 var onlineTreeExportResolver = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(function* (treeId) {
+  var _ref8 = _asyncToGenerator(function* (treeId, state) {
     (0, _Console.debugMessage)("onlineTreeExportResolver(".concat(treeId, ")"));
-    return yield exportJourney(treeId, {
-      deps: false,
-      useStringArrays: false
+    return yield exportJourney({
+      treeId,
+      options: {
+        deps: false,
+        useStringArrays: false
+      },
+      state
     });
   });
-  return function onlineTreeExportResolver(_x14) {
-    return _ref.apply(this, arguments);
+  return function onlineTreeExportResolver(_x14, _x15) {
+    return _ref8.apply(this, arguments);
   };
 }();
 
@@ -971,9 +1461,11 @@ var onlineTreeExportResolver = /*#__PURE__*/function () {
  */
 exports.onlineTreeExportResolver = onlineTreeExportResolver;
 var fileByIdTreeExportResolver = /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator(function* (treeId) {
+  var _ref9 = _asyncToGenerator(function* (treeId, state) {
     (0, _Console.debugMessage)("fileByIdTreeExportResolver(".concat(treeId, ")"));
-    var treeExport = createSingleTreeExportTemplate();
+    var treeExport = createSingleTreeExportTemplate({
+      state
+    });
     var files = (0, _ExportImportUtils.findFilesByName)((0, _ExportImportUtils.getTypedFilename)("".concat(treeId), 'journey'));
     try {
       var _jsonData$tree;
@@ -993,8 +1485,8 @@ var fileByIdTreeExportResolver = /*#__PURE__*/function () {
     }
     return treeExport;
   });
-  return function fileByIdTreeExportResolver(_x15) {
-    return _ref2.apply(this, arguments);
+  return function fileByIdTreeExportResolver(_x16, _x17) {
+    return _ref9.apply(this, arguments);
   };
 }();
 
@@ -1005,11 +1497,13 @@ var fileByIdTreeExportResolver = /*#__PURE__*/function () {
  * @returns {TreeExportResolverInterface} tree export resolver
  */
 exports.fileByIdTreeExportResolver = fileByIdTreeExportResolver;
-function createFileParamTreeExportResolver(file) {
+function createFileParamTreeExportResolver(file, state) {
   var fileParamTreeExportResolver = /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator(function* (treeId) {
+    var _ref10 = _asyncToGenerator(function* (treeId) {
       (0, _Console.debugMessage)("fileParamTreeExportResolver(".concat(treeId, ")"));
-      var treeExport = createSingleTreeExportTemplate();
+      var treeExport = createSingleTreeExportTemplate({
+        state
+      });
       try {
         var _jsonData$tree2;
         var jsonData = JSON.parse(_fs.default.readFileSync(file, 'utf8'));
@@ -1023,15 +1517,15 @@ function createFileParamTreeExportResolver(file) {
         }
         // fall back to fileByIdTreeExportResolver
         else {
-          treeExport = yield fileByIdTreeExportResolver(treeId);
+          treeExport = yield fileByIdTreeExportResolver(treeId, state);
         }
       } catch (error) {
         //
       }
       return treeExport;
     });
-    return function fileParamTreeExportResolver(_x16) {
-      return _ref3.apply(this, arguments);
+    return function fileParamTreeExportResolver(_x18) {
+      return _ref10.apply(this, arguments);
     };
   }();
   (0, _Console.debugMessage)("fileParamTreeExportResolver: file=".concat(file));
@@ -1045,7 +1539,7 @@ function createFileParamTreeExportResolver(file) {
  * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
  * @returns {Promise<TreeDependencyMapInterface>} a promise that resolves to a tree dependency map
  */
-function getTreeDescendents(_x17) {
+function getTreeDescendents(_x19) {
   return _getTreeDescendents.apply(this, arguments);
 }
 /**
@@ -1053,9 +1547,13 @@ function getTreeDescendents(_x17) {
  * @returns {Promise<unknown[]>} a promise that resolves to an array of orphaned nodes
  */
 function _getTreeDescendents() {
-  _getTreeDescendents = _asyncToGenerator(function* (treeExport) {
-    var resolveTreeExport = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : onlineTreeExportResolver;
-    var resolvedTreeIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  _getTreeDescendents = _asyncToGenerator(function* (_ref11) {
+    var {
+      treeExport,
+      resolveTreeExport = onlineTreeExportResolver,
+      resolvedTreeIds = [],
+      state
+    } = _ref11;
     (0, _Console.debugMessage)("getTreeDependencies(".concat(treeExport.tree._id, ", [").concat(resolvedTreeIds.join(', '), "])"));
     if (!resolvedTreeIds.includes(treeExport.tree._id)) {
       resolvedTreeIds.push(treeExport.tree._id);
@@ -1067,10 +1565,15 @@ function _getTreeDescendents() {
     for (var [nodeId, node] of Object.entries(treeExport.tree.nodes)) {
       var innerTreeId = treeExport.nodes[nodeId].tree;
       if (node.nodeType === 'InnerTreeEvaluatorNode' && !resolvedTreeIds.includes(innerTreeId)) {
-        var innerTreeExport = yield resolveTreeExport(innerTreeId);
+        var innerTreeExport = yield resolveTreeExport(innerTreeId, state);
         (0, _Console.debugMessage)("resolved inner tree: ".concat(innerTreeExport.tree._id));
         // resolvedTreeIds.push(innerTreeId);
-        dependencies.push(yield getTreeDescendents(innerTreeExport, resolveTreeExport, resolvedTreeIds));
+        dependencies.push(yield getTreeDescendents({
+          treeExport: innerTreeExport,
+          resolveTreeExport,
+          resolvedTreeIds,
+          state
+        }));
       }
     }
     treeDependencyMap[treeExport.tree._id] = dependencies;
@@ -1078,25 +1581,32 @@ function _getTreeDescendents() {
   });
   return _getTreeDescendents.apply(this, arguments);
 }
-function findOrphanedNodes() {
+function findOrphanedNodes(_x20) {
   return _findOrphanedNodes.apply(this, arguments);
 }
 /**
  * Remove orphaned nodes
- * @param {[Object]} orphanedNodes Pass in an array of orphaned node configuration objects to remove
- * @returns {Promise<unknown[]>} a promise that resolves to an array nodes that encountered errors deleting
+ * @param {NodeSkeleton[]} orphanedNodes Pass in an array of orphaned node configuration objects to remove
+ * @returns {Promise<NodeSkeleton[]>} a promise that resolves to an array nodes that encountered errors deleting
  */
 function _findOrphanedNodes() {
-  _findOrphanedNodes = _asyncToGenerator(function* () {
+  _findOrphanedNodes = _asyncToGenerator(function* (_ref12) {
+    var {
+      state
+    } = _ref12;
     var allNodes = [];
     var orphanedNodes = [];
     var types = [];
-    var allJourneys = (yield (0, _TreeApi.getTrees)()).result;
+    var allJourneys = (yield (0, _TreeApi.getTrees)({
+      state
+    })).result;
     var errorMessage = '';
     var errorTypes = [];
     (0, _Console.createProgressIndicator)(undefined, "Counting total nodes...", 'indeterminate');
     try {
-      types = (yield (0, _NodeApi.getNodeTypes)()).result;
+      types = (yield (0, _NodeApi.getNodeTypes)({
+        state
+      })).result;
     } catch (error) {
       (0, _Console.printMessage)('Error retrieving all available node types:', 'error');
       (0, _Console.printMessage)(error.response.data, 'error');
@@ -1105,7 +1615,10 @@ function _findOrphanedNodes() {
     for (var type of types) {
       try {
         // eslint-disable-next-line no-await-in-loop, no-loop-func
-        var nodes = (yield (0, _NodeApi.getNodesByType)(type._id)).result;
+        var nodes = (yield (0, _NodeApi.getNodesByType)({
+          nodeType: type._id,
+          state
+        })).result;
         for (var node of nodes) {
           allNodes.push(node);
           (0, _Console.updateProgressIndicator)("".concat(allNodes.length, " total nodes").concat(errorMessage));
@@ -1130,7 +1643,11 @@ function _findOrphanedNodes() {
           (0, _Console.updateProgressIndicator)("".concat(activeNodes.length, " active nodes"));
           var _node = journey.nodes[nodeId];
           if (containerNodes.includes(_node.nodeType)) {
-            var containerNode = yield (0, _NodeApi.getNode)(nodeId, _node.nodeType);
+            var containerNode = yield (0, _NodeApi.getNode)({
+              nodeId,
+              nodeType: _node.nodeType,
+              state
+            });
             for (var innerNode of containerNode.nodes) {
               activeNodes.push(innerNode._id);
               (0, _Console.updateProgressIndicator)("".concat(activeNodes.length, " active nodes"));
@@ -1150,7 +1667,7 @@ function _findOrphanedNodes() {
   });
   return _findOrphanedNodes.apply(this, arguments);
 }
-function removeOrphanedNodes(_x18) {
+function removeOrphanedNodes(_x21) {
   return _removeOrphanedNodes.apply(this, arguments);
 }
 /**
@@ -1159,14 +1676,22 @@ function removeOrphanedNodes(_x18) {
  * @returns {boolean} True if the journey/tree contains any custom nodes, false otherwise.
  */
 function _removeOrphanedNodes() {
-  _removeOrphanedNodes = _asyncToGenerator(function* (orphanedNodes) {
+  _removeOrphanedNodes = _asyncToGenerator(function* (_ref13) {
+    var {
+      orphanedNodes,
+      state
+    } = _ref13;
     var errorNodes = [];
     (0, _Console.createProgressIndicator)(orphanedNodes.length, 'Removing orphaned nodes...');
     for (var node of orphanedNodes) {
       (0, _Console.updateProgressIndicator)("Removing ".concat(node['_id'], "..."));
       try {
         // eslint-disable-next-line no-await-in-loop
-        yield (0, _NodeApi.deleteNode)(node['_id'], node['_type']['_id']);
+        yield (0, _NodeApi.deleteNode)({
+          nodeId: node['_id'],
+          nodeType: node['_type']['_id'],
+          state
+        });
       } catch (deleteError) {
         errorNodes.push(node);
         (0, _Console.printMessage)(" ".concat(deleteError), 'error');
@@ -1177,10 +1702,17 @@ function _removeOrphanedNodes() {
   });
   return _removeOrphanedNodes.apply(this, arguments);
 }
-function isCustomJourney(journey) {
+function isCustomJourney(_ref14) {
+  var {
+    journey,
+    state
+  } = _ref14;
   var nodeList = Object.values(journey.nodes).concat(Object.values(journey.innerNodes));
   for (var node of nodeList) {
-    if ((0, _NodeOps.isCustomNode)(node['_type']['_id'])) {
+    if ((0, _NodeOps.isCustomNode)({
+      nodeType: node['_type']['_id'],
+      state
+    })) {
       return true;
     }
   }
@@ -1226,10 +1758,17 @@ function isCloudOnlyJourney(journey) {
  * @param {SingleTreeExportInterface} journey journey export data
  * @returns {JourneyClassification[]} an array of one or multiple classifications
  */
-function getJourneyClassification(journey) {
+function getJourneyClassification(_ref15) {
+  var {
+    journey,
+    state
+  } = _ref15;
   var classifications = [];
   var premium = isPremiumJourney(journey);
-  var custom = isCustomJourney(journey);
+  var custom = isCustomJourney({
+    journey,
+    state
+  });
   var cloud = isCloudOnlyJourney(journey);
   if (custom) {
     classifications.push(_OpsTypes.JourneyClassification.CUSTOM);
@@ -1247,7 +1786,7 @@ function getJourneyClassification(journey) {
  * @param {string} journeyId journey id/name
  * @param {Object} options deep=true also delete all the nodes and inner nodes, verbose=true print verbose info
  */
-function deleteJourney(_x19, _x20) {
+function deleteJourney(_x22) {
   return _deleteJourney.apply(this, arguments);
 }
 /**
@@ -1255,7 +1794,12 @@ function deleteJourney(_x19, _x20) {
  * @param {Object} options deep=true also delete all the nodes and inner nodes, verbose=true print verbose info
  */
 function _deleteJourney() {
-  _deleteJourney = _asyncToGenerator(function* (journeyId, options) {
+  _deleteJourney = _asyncToGenerator(function* (_ref16) {
+    var {
+      journeyId,
+      options,
+      state
+    } = _ref16;
     var {
       deep,
       verbose
@@ -1266,8 +1810,11 @@ function _deleteJourney() {
     };
     if (progress) (0, _Console.createProgressIndicator)(undefined, "Deleting ".concat(journeyId, "..."), 'indeterminate');
     if (progress && verbose) (0, _Console.stopProgressIndicator)();
-    return (0, _TreeApi.deleteTree)(journeyId).then( /*#__PURE__*/function () {
-      var _ref4 = _asyncToGenerator(function* (deleteTreeResponse) {
+    return (0, _TreeApi.deleteTree)({
+      treeId: journeyId,
+      state
+    }).then( /*#__PURE__*/function () {
+      var _ref20 = _asyncToGenerator(function* (deleteTreeResponse) {
         status['status'] = 'success';
         var nodePromises = [];
         if (verbose) (0, _Console.printMessage)("Deleted ".concat(journeyId, " (tree)"), 'info');
@@ -1277,10 +1824,18 @@ function _deleteJourney() {
             if (containerNodes.includes(nodeObject['nodeType'])) {
               try {
                 // eslint-disable-next-line no-await-in-loop
-                var containerNode = yield (0, _NodeApi.getNode)(nodeId, nodeObject['nodeType']);
+                var containerNode = yield (0, _NodeApi.getNode)({
+                  nodeId,
+                  nodeType: nodeObject['nodeType'],
+                  state
+                });
                 if (verbose) (0, _Console.printMessage)("Read ".concat(nodeId, " (").concat(nodeObject['nodeType'], ") from ").concat(journeyId), 'info');
                 var _loop3 = function* _loop3(innerNodeObject) {
-                  nodePromises.push((0, _NodeApi.deleteNode)(innerNodeObject._id, innerNodeObject.nodeType).then(response2 => {
+                  nodePromises.push((0, _NodeApi.deleteNode)({
+                    nodeId: innerNodeObject._id,
+                    nodeType: innerNodeObject.nodeType,
+                    state
+                  }).then(response2 => {
                     status.nodes[innerNodeObject._id] = {
                       status: 'success'
                     };
@@ -1298,7 +1853,11 @@ function _deleteJourney() {
                   yield* _loop3(innerNodeObject);
                 }
                 // finally delete the container node
-                nodePromises.push((0, _NodeApi.deleteNode)(containerNode._id, containerNode['_type']['_id']).then(response2 => {
+                nodePromises.push((0, _NodeApi.deleteNode)({
+                  nodeId: containerNode._id,
+                  nodeType: containerNode['_type']['_id'],
+                  state
+                }).then(response2 => {
                   status.nodes[containerNode._id] = {
                     status: 'success'
                   };
@@ -1324,7 +1883,11 @@ function _deleteJourney() {
               }
             } else {
               // delete the node
-              nodePromises.push((0, _NodeApi.deleteNode)(nodeId, nodeObject['nodeType']).then(response => {
+              nodePromises.push((0, _NodeApi.deleteNode)({
+                nodeId,
+                nodeType: nodeObject['nodeType'],
+                state
+              }).then(response => {
                 status.nodes[nodeId] = {
                   status: 'success'
                 };
@@ -1362,8 +1925,8 @@ function _deleteJourney() {
         }
         return status;
       });
-      return function (_x24) {
-        return _ref4.apply(this, arguments);
+      return function (_x26) {
+        return _ref20.apply(this, arguments);
       };
     }()).catch(error => {
       status['status'] = 'error';
@@ -1375,7 +1938,7 @@ function _deleteJourney() {
   });
   return _deleteJourney.apply(this, arguments);
 }
-function deleteJourneys(_x21) {
+function deleteJourneys(_x23) {
   return _deleteJourneys.apply(this, arguments);
 }
 /**
@@ -1384,17 +1947,27 @@ function deleteJourneys(_x21) {
  * @returns {Promise<boolean>} true if the operation was successful, false otherwise
  */
 function _deleteJourneys() {
-  _deleteJourneys = _asyncToGenerator(function* (options) {
+  _deleteJourneys = _asyncToGenerator(function* (_ref17) {
+    var {
+      options,
+      state
+    } = _ref17;
     var {
       verbose
     } = options;
     var status = {};
-    var trees = (yield (0, _TreeApi.getTrees)()).result;
+    var trees = (yield (0, _TreeApi.getTrees)({
+      state
+    })).result;
     (0, _Console.createProgressIndicator)(trees.length, 'Deleting journeys...');
     for (var tree of trees) {
       if (verbose) (0, _Console.printMessage)('');
       options['progress'] = false;
-      status[tree._id] = yield deleteJourney(tree._id, options);
+      status[tree._id] = yield deleteJourney({
+        journeyId: tree._id,
+        options,
+        state
+      });
       (0, _Console.updateProgressIndicator)("".concat(tree._id));
       // introduce a 100ms wait to allow the progress bar to update before the next verbose message prints from the async function
       if (verbose)
@@ -1420,7 +1993,7 @@ function _deleteJourneys() {
   });
   return _deleteJourneys.apply(this, arguments);
 }
-function enableJourney(_x22) {
+function enableJourney(_x24) {
   return _enableJourney.apply(this, arguments);
 }
 /**
@@ -1429,12 +2002,23 @@ function enableJourney(_x22) {
  * @returns {Promise<boolean>} true if the operation was successful, false otherwise
  */
 function _enableJourney() {
-  _enableJourney = _asyncToGenerator(function* (journeyId) {
+  _enableJourney = _asyncToGenerator(function* (_ref18) {
+    var {
+      journeyId,
+      state
+    } = _ref18;
     try {
-      var treeObject = yield (0, _TreeApi.getTree)(journeyId);
+      var treeObject = yield (0, _TreeApi.getTree)({
+        id: journeyId,
+        state
+      });
       treeObject['enabled'] = true;
       delete treeObject._rev;
-      var newTreeObject = yield (0, _TreeApi.putTree)(journeyId, treeObject);
+      var newTreeObject = yield (0, _TreeApi.putTree)({
+        treeId: journeyId,
+        treeData: treeObject,
+        state
+      });
       return newTreeObject['enabled'] === true;
     } catch (error) {
       (0, _Console.printMessage)(error.response.data, 'error');
@@ -1443,16 +2027,27 @@ function _enableJourney() {
   });
   return _enableJourney.apply(this, arguments);
 }
-function disableJourney(_x23) {
+function disableJourney(_x25) {
   return _disableJourney.apply(this, arguments);
 }
 function _disableJourney() {
-  _disableJourney = _asyncToGenerator(function* (journeyId) {
+  _disableJourney = _asyncToGenerator(function* (_ref19) {
+    var {
+      journeyId,
+      state
+    } = _ref19;
     try {
-      var treeObject = yield (0, _TreeApi.getTree)(journeyId);
+      var treeObject = yield (0, _TreeApi.getTree)({
+        id: journeyId,
+        state
+      });
       treeObject['enabled'] = false;
       delete treeObject._rev;
-      var newTreeObject = yield (0, _TreeApi.putTree)(journeyId, treeObject);
+      var newTreeObject = yield (0, _TreeApi.putTree)({
+        treeId: journeyId,
+        treeData: treeObject,
+        state
+      });
       return newTreeObject['enabled'] === false;
     } catch (error) {
       (0, _Console.printMessage)(error.response.data, 'error');