oro-sdk-apis 1.11.1 → 1.15.0

package/dist/oro-sdk-apis.esm.js

@@ -1,7 +1,17 @@
+import { sha256 } from 'hash.js';
+import { Buffer } from 'buffer/';
 import createAuthRefreshInterceptor from 'axios-auth-refresh';
 import axios from 'axios';
-import { Buffer } from 'buffer/';
-import { sha256 } from 'hash.js';
+
+/**
+ * This function return a base64 string representation of a hashed string
+ * @param value the string to hash
+ * @returns a base64 string representation of a hashed value
+ */
+
+function hashToBase64String(value) {
+  return Buffer.from(sha256().update(value).digest('hex'), 'hex').toString('base64');
+}
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -1032,11 +1042,19 @@ var AxiosService = /*#__PURE__*/function () {
 var APIService = /*#__PURE__*/function (_AxiosService) {
   _inheritsLoose(APIService, _AxiosService);
 
-  function APIService(config, tokenRefreshFailureCallback) {
+  /**
+   * The API Service lets you use an axios API and handles oro backend services authentification via JWT tokens
+   * @param useLocalStorage if set to true, tokens will be stored in localStorage
+   * @param config (optional) an axios config
+   * @param tokenRefreshFailureCallback (optional) callback to call when failing to refresh the auth token
+   */
+  function APIService(useLocalStorage, config, tokenRefreshFailureCallback) {
     var _this;
 
     _this = _AxiosService.call(this, config) || this;
+    _this.useLocalStorage = useLocalStorage;
     _this.tokenRefreshFailureCallback = tokenRefreshFailureCallback;
+    _this.tokens = {};
 
     var self = _assertThisInitialized(_this);
 
@@ -1110,23 +1128,142 @@ var APIService = /*#__PURE__*/function (_AxiosService) {
   };
 
   _proto.setTokens = function setTokens(tokens) {
-    localStorage.setItem('tokens', JSON.stringify(tokens));
+    if (this.useLocalStorage) {
+      localStorage.setItem('tokens', JSON.stringify(tokens));
+    }
+
+    this.tokens = tokens;
   };
 
   _proto.getTokens = function getTokens() {
-    var tokens = {};
-    var item = localStorage.getItem('tokens');
+    if (this.useLocalStorage) {
+      var tokens = {};
+      var item = localStorage.getItem('tokens');
 
-    if (item) {
-      tokens = JSON.parse(item);
-    }
+      if (item) {
+        tokens = JSON.parse(item);
+      }
 
-    return tokens;
+      return tokens;
+    } else {
+      return this.tokens;
+    }
   };
 
   return APIService;
 }(AxiosService);
 
+/**
+ * This service enables you to handle one authentication token per practice
+ */
+
+var ApisPracticeManager = /*#__PURE__*/function () {
+  /**
+   * The constructor
+   * @param serviceCollReq the services to initialize. Only filled urls will get corresponding service to be initialized.
+   * It will be used each time a new practices needs a `ServiceCollection`
+   * @param getAuthTokenCbk the callback function used to get a new JWT token
+   * @param useLocalStorage (default: false) if true store tokens into local storage (only for browsers)
+   */
+  function ApisPracticeManager(serviceCollReq, getAuthTokenCbk, useLocalStorage) {
+    if (useLocalStorage === void 0) {
+      useLocalStorage = false;
+    }
+
+    this.serviceCollReq = serviceCollReq;
+    this.getAuthTokenCbk = getAuthTokenCbk;
+    this.useLocalStorage = useLocalStorage;
+    this.practiceInstances = new Map();
+  }
+  /**
+   * This function is used to get a `ServiceCollection` associated to a practice. If missing, it will initialize a new `ServiceCollection`.
+   * @param practiceUuid the uuid of the practice
+   * @returns a promise holding a `ServiceCollection`
+   */
+
+
+  var _proto = ApisPracticeManager.prototype;
+
+  _proto.get =
+  /*#__PURE__*/
+  function () {
+    var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(practiceUuid) {
+      var _this = this;
+
+      var practiceInstance, newPracticeInstance, authTokenFunc;
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              practiceInstance = this.practiceInstances.get(practiceUuid);
+
+              if (!practiceInstance) {
+                _context2.next = 3;
+                break;
+              }
+
+              return _context2.abrupt("return", practiceInstance);
+
+            case 3:
+              newPracticeInstance = init(this.serviceCollReq, undefined, this.useLocalStorage); // Create one auth token callback per practice since the practice uuid needs to change
+
+              authTokenFunc = /*#__PURE__*/function () {
+                var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
+                  return runtime_1.wrap(function _callee$(_context) {
+                    while (1) {
+                      switch (_context.prev = _context.next) {
+                        case 0:
+                          if (!newPracticeInstance.guardService) {
+                            _context.next = 7;
+                            break;
+                          }
+
+                          console.log("\x1B[36m[Auth] Refresh auth called (practiceUuid: " + practiceUuid + ")\x1B[36m");
+                          _context.next = 4;
+                          return _this.getAuthTokenCbk(newPracticeInstance.guardService, practiceUuid);
+
+                        case 4:
+                          return _context.abrupt("return", _context.sent);
+
+                        case 7:
+                          throw Error('[Auth] Unable to refresh token guard service is undefined');
+
+                        case 8:
+                        case "end":
+                          return _context.stop();
+                      }
+                    }
+                  }, _callee);
+                }));
+
+                return function authTokenFunc() {
+                  return _ref.apply(this, arguments);
+                };
+              }(); // Set the refresh tokens callback
+
+
+              newPracticeInstance.apiService.setAuthRefreshFn(authTokenFunc);
+              this.practiceInstances.set(practiceUuid, newPracticeInstance);
+              return _context2.abrupt("return", newPracticeInstance);
+
+            case 8:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function get(_x) {
+      return _get.apply(this, arguments);
+    }
+
+    return get;
+  }();
+
+  return ApisPracticeManager;
+}();
+
 var AssistantType;
 
 (function (AssistantType) {
@@ -1795,7 +1932,8 @@ var GuardService = /*#__PURE__*/function () {
   function GuardService(api, baseURL) {
     this.api = api;
     this.baseURL = baseURL;
-    this.api.setAuthRefreshFn(this.authRefresh.bind(this));
+    this.api.setAuthRefreshFn(this.authRefresh.bind(this)); // This is the default behavior for User JWT tokens. If you want other kind of refresh you shall overwrite this call
+
     this.identityCache = {};
     this.whoAmICache = {};
   }
@@ -1818,18 +1956,17 @@ var GuardService = /*#__PURE__*/function () {
     this.api.setTokens(_extends({}, this.api.getTokens(), tokens));
   }
   /**
-   * Allow to retrieve an access token and a refresh token in order
-   * to do authenticated request afterward
+   * Allow to retrieve a M2M token for a service
    *
    * @param req The credentials required to get an access token
    * @returns AuthTokenResponse
    */
   ;
 
-  _proto.authToken =
+  _proto.m2mToken =
   /*#__PURE__*/
   function () {
-    var _authToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(req) {
+    var _m2mToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(req) {
       var resp, config, _e$response, code;
 
       return runtime_1.wrap(function _callee$(_context) {
@@ -1841,13 +1978,12 @@ var GuardService = /*#__PURE__*/function () {
                 skipAuthRefresh: true
               };
               _context.next = 4;
-              return this.api.post(this.baseURL + "/v1/auth/token", req, config);
+              return this.api.post(this.baseURL + "/v1/m2m/token", req, config);
 
             case 4:
               resp = _context.sent;
               this.api.setTokens({
-                accessToken: resp.accessToken,
-                refreshToken: resp.refreshToken
+                accessToken: resp.accessToken
               });
               _context.next = 20;
               break;
@@ -1855,6 +1991,7 @@ var GuardService = /*#__PURE__*/function () {
             case 8:
               _context.prev = 8;
               _context.t0 = _context["catch"](0);
+              console.error('Error while posting m2m token:', _context.t0);
 
               if (!_context.t0.isAxiosError) {
                 _context.next = 19;
@@ -1863,14 +2000,11 @@ var GuardService = /*#__PURE__*/function () {
 
               code = (_e$response = _context.t0.response) == null ? void 0 : _e$response.status;
               _context.t1 = code;
-              _context.next = _context.t1 === 400 ? 15 : _context.t1 === 424 ? 16 : _context.t1 === 500 ? 17 : _context.t1 === 401 ? 18 : 18;
+              _context.next = _context.t1 === 400 ? 16 : _context.t1 === 500 ? 17 : _context.t1 === 401 ? 18 : 18;
               break;
 
-            case 15:
-              throw new AuthenticationBadRequest();
-
             case 16:
-              throw new AuthenticationUnconfirmedEmail();
+              throw new AuthenticationBadRequest();
 
             case 17:
               throw new AuthenticationServerError();
@@ -1892,7 +2026,89 @@ var GuardService = /*#__PURE__*/function () {
       }, _callee, this, [[0, 8]]);
     }));
 
-    function authToken(_x) {
+    function m2mToken(_x) {
+      return _m2mToken.apply(this, arguments);
+    }
+
+    return m2mToken;
+  }()
+  /**
+   * Allow to retrieve an access token and a refresh token in order
+   * to do authenticated request afterward
+   *
+   * @param req The credentials required to get an access token
+   * @returns AuthTokenResponse
+   */
+  ;
+
+  _proto.authToken =
+  /*#__PURE__*/
+  function () {
+    var _authToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(req) {
+      var resp, config, _e$response2, code;
+
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              config = {
+                skipAuthRefresh: true
+              };
+              _context2.next = 4;
+              return this.api.post(this.baseURL + "/v1/auth/token", req, config);
+
+            case 4:
+              resp = _context2.sent;
+              this.api.setTokens({
+                accessToken: resp.accessToken,
+                refreshToken: resp.refreshToken
+              });
+              _context2.next = 21;
+              break;
+
+            case 8:
+              _context2.prev = 8;
+              _context2.t0 = _context2["catch"](0);
+              console.error('Error while posting auth token:', _context2.t0);
+
+              if (!_context2.t0.isAxiosError) {
+                _context2.next = 20;
+                break;
+              }
+
+              code = (_e$response2 = _context2.t0.response) == null ? void 0 : _e$response2.status;
+              _context2.t1 = code;
+              _context2.next = _context2.t1 === 400 ? 16 : _context2.t1 === 424 ? 17 : _context2.t1 === 500 ? 18 : _context2.t1 === 401 ? 19 : 19;
+              break;
+
+            case 16:
+              throw new AuthenticationBadRequest();
+
+            case 17:
+              throw new AuthenticationUnconfirmedEmail();
+
+            case 18:
+              throw new AuthenticationServerError();
+
+            case 19:
+              throw new AuthenticationFailed();
+
+            case 20:
+              throw new AuthenticationFailed();
+
+            case 21:
+              return _context2.abrupt("return", resp);
+
+            case 22:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this, [[0, 8]]);
+    }));
+
+    function authToken(_x2) {
       return _authToken.apply(this, arguments);
     }
 
@@ -1908,27 +2124,27 @@ var GuardService = /*#__PURE__*/function () {
   _proto.authRefresh =
   /*#__PURE__*/
   function () {
-    var _authRefresh = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(refreshToken) {
+    var _authRefresh = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(refreshToken) {
       var config;
-      return runtime_1.wrap(function _callee2$(_context2) {
+      return runtime_1.wrap(function _callee3$(_context3) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
               config = {
                 skipAuthRefresh: true,
                 useRefreshToken: true
               };
-              return _context2.abrupt("return", this.api.put(this.baseURL + "/v1/auth/token", null, config));
+              return _context3.abrupt("return", this.api.put(this.baseURL + "/v1/auth/token", null, config));
 
             case 2:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
         }
-      }, _callee2, this);
+      }, _callee3, this);
     }));
 
-    function authRefresh(_x2) {
+    function authRefresh(_x3) {
       return _authRefresh.apply(this, arguments);
     }
 
@@ -1944,19 +2160,19 @@ var GuardService = /*#__PURE__*/function () {
   _proto.authLogout =
   /*#__PURE__*/
   function () {
-    var _authLogout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3() {
-      return runtime_1.wrap(function _callee3$(_context3) {
+    var _authLogout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4() {
+      return runtime_1.wrap(function _callee4$(_context4) {
         while (1) {
-          switch (_context3.prev = _context3.next) {
+          switch (_context4.prev = _context4.next) {
             case 0:
-              return _context3.abrupt("return", this.api.get(this.baseURL + "/v1/auth/logout"));
+              return _context4.abrupt("return", this.api.get(this.baseURL + "/v1/auth/logout"));
 
             case 1:
             case "end":
-              return _context3.stop();
+              return _context4.stop();
           }
         }
-      }, _callee3, this);
+      }, _callee4, this);
     }));
 
     function authLogout() {
@@ -1976,22 +2192,22 @@ var GuardService = /*#__PURE__*/function () {
   _proto.authRecover =
   /*#__PURE__*/
   function () {
-    var _authRecover = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(req) {
-      return runtime_1.wrap(function _callee4$(_context4) {
+    var _authRecover = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(req) {
+      return runtime_1.wrap(function _callee5$(_context5) {
         while (1) {
-          switch (_context4.prev = _context4.next) {
+          switch (_context5.prev = _context5.next) {
             case 0:
-              return _context4.abrupt("return", this.api.post(this.baseURL + "/v1/auth/recover", req));
+              return _context5.abrupt("return", this.api.post(this.baseURL + "/v1/auth/recover", req));
 
             case 1:
             case "end":
-              return _context4.stop();
+              return _context5.stop();
           }
         }
-      }, _callee4, this);
+      }, _callee5, this);
     }));
 
-    function authRecover(_x3) {
+    function authRecover(_x4) {
       return _authRecover.apply(this, arguments);
     }
 
@@ -2009,37 +2225,37 @@ var GuardService = /*#__PURE__*/function () {
   _proto.identityCreate =
   /*#__PURE__*/
   function () {
-    var _identityCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(req) {
-      var resp, _e$response2, code;
+    var _identityCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(req) {
+      var resp, _e$response3, code;
 
-      return runtime_1.wrap(function _callee5$(_context5) {
+      return runtime_1.wrap(function _callee6$(_context6) {
         while (1) {
-          switch (_context5.prev = _context5.next) {
+          switch (_context6.prev = _context6.next) {
             case 0:
-              _context5.prev = 0;
-              _context5.next = 3;
+              _context6.prev = 0;
+              _context6.next = 3;
               return this.api.post(this.baseURL + "/v1/identities", req);
 
             case 3:
-              resp = _context5.sent;
+              resp = _context6.sent;
               this.api.setTokens({
                 refreshToken: resp.refreshToken
               });
-              _context5.next = 18;
+              _context6.next = 18;
               break;
 
             case 7:
-              _context5.prev = 7;
-              _context5.t0 = _context5["catch"](0);
+              _context6.prev = 7;
+              _context6.t0 = _context6["catch"](0);
 
-              if (!_context5.t0.isAxiosError) {
-                _context5.next = 17;
+              if (!_context6.t0.isAxiosError) {
+                _context6.next = 17;
                 break;
               }
 
-              code = (_e$response2 = _context5.t0.response) == null ? void 0 : _e$response2.status;
-              _context5.t1 = code;
-              _context5.next = _context5.t1 === 400 ? 14 : _context5.t1 === 409 ? 15 : _context5.t1 === 500 ? 16 : 16;
+              code = (_e$response3 = _context6.t0.response) == null ? void 0 : _e$response3.status;
+              _context6.t1 = code;
+              _context6.next = _context6.t1 === 400 ? 14 : _context6.t1 === 409 ? 15 : _context6.t1 === 500 ? 16 : 16;
               break;
 
             case 14:
@@ -2055,17 +2271,17 @@ var GuardService = /*#__PURE__*/function () {
               throw new IdentityCreationFailed();
 
             case 18:
-              return _context5.abrupt("return", resp);
+              return _context6.abrupt("return", resp);
 
             case 19:
             case "end":
-              return _context5.stop();
+              return _context6.stop();
           }
         }
-      }, _callee5, this, [[0, 7]]);
+      }, _callee6, this, [[0, 7]]);
     }));
 
-    function identityCreate(_x4) {
+    function identityCreate(_x5) {
       return _identityCreate.apply(this, arguments);
     }
 
@@ -2084,13 +2300,13 @@ var GuardService = /*#__PURE__*/function () {
   _proto.identityGet =
   /*#__PURE__*/
   function () {
-    var _identityGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(identityID, skipCache) {
+    var _identityGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(identityID, skipCache) {
       var _tokens$accessToken, _tokens$refreshToken;
 
       var tokens, cacheKey, identity;
-      return runtime_1.wrap(function _callee6$(_context6) {
+      return runtime_1.wrap(function _callee7$(_context7) {
         while (1) {
-          switch (_context6.prev = _context6.next) {
+          switch (_context7.prev = _context7.next) {
             case 0:
               if (skipCache === void 0) {
                 skipCache = false;
@@ -2100,38 +2316,38 @@ var GuardService = /*#__PURE__*/function () {
               cacheKey = ((_tokens$accessToken = tokens.accessToken) != null ? _tokens$accessToken : '') + ((_tokens$refreshToken = tokens.refreshToken) != null ? _tokens$refreshToken : '') + identityID;
 
               if (!(skipCache || !tokens.accessToken || !this.identityCache[cacheKey])) {
-                _context6.next = 10;
+                _context7.next = 10;
                 break;
               }
 
-              _context6.next = 6;
+              _context7.next = 6;
               return this.api.get(this.baseURL + "/v1/identities/" + identityID);
 
             case 6:
-              identity = _context6.sent;
+              identity = _context7.sent;
 
               if (!skipCache) {
-                _context6.next = 9;
+                _context7.next = 9;
                 break;
               }
 
-              return _context6.abrupt("return", identity);
+              return _context7.abrupt("return", identity);
 
             case 9:
               this.identityCache[cacheKey] = identity;
 
             case 10:
-              return _context6.abrupt("return", this.identityCache[cacheKey]);
+              return _context7.abrupt("return", this.identityCache[cacheKey]);
 
             case 11:
             case "end":
-              return _context6.stop();
+              return _context7.stop();
           }
         }
-      }, _callee6, this);
+      }, _callee7, this);
     }));
 
-    function identityGet(_x5, _x6) {
+    function identityGet(_x6, _x7) {
       return _identityGet.apply(this, arguments);
     }
 
@@ -2148,13 +2364,13 @@ var GuardService = /*#__PURE__*/function () {
   _proto.whoAmI =
   /*#__PURE__*/
   function () {
-    var _whoAmI = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(refreshCache) {
+    var _whoAmI = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(refreshCache) {
       var _this$api$getTokens$a;
 
       var cacheKey;
-      return runtime_1.wrap(function _callee7$(_context7) {
+      return runtime_1.wrap(function _callee8$(_context8) {
         while (1) {
-          switch (_context7.prev = _context7.next) {
+          switch (_context8.prev = _context8.next) {
             case 0:
               if (refreshCache === void 0) {
                 refreshCache = false;
@@ -2163,28 +2379,28 @@ var GuardService = /*#__PURE__*/function () {
               cacheKey = (_this$api$getTokens$a = this.api.getTokens().accessToken) != null ? _this$api$getTokens$a : '';
 
               if (!(!this.whoAmICache[cacheKey] || refreshCache)) {
-                _context7.next = 6;
+                _context8.next = 6;
                 break;
               }
 
-              _context7.next = 5;
+              _context8.next = 5;
               return this.api.get(this.baseURL + "/v1/auth/whoami");
 
             case 5:
-              this.whoAmICache[cacheKey] = _context7.sent;
+              this.whoAmICache[cacheKey] = _context8.sent;
 
             case 6:
-              return _context7.abrupt("return", this.whoAmICache[cacheKey]);
+              return _context8.abrupt("return", this.whoAmICache[cacheKey]);
 
             case 7:
             case "end":
-              return _context7.stop();
+              return _context8.stop();
           }
         }
-      }, _callee7, this);
+      }, _callee8, this);
     }));
 
-    function whoAmI(_x7) {
+    function whoAmI(_x8) {
       return _whoAmI.apply(this, arguments);
     }
 
@@ -2202,22 +2418,22 @@ var GuardService = /*#__PURE__*/function () {
   _proto.identityUpdate =
   /*#__PURE__*/
   function () {
-    var _identityUpdate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(identityID, req) {
-      return runtime_1.wrap(function _callee8$(_context8) {
+    var _identityUpdate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(identityID, req) {
+      return runtime_1.wrap(function _callee9$(_context9) {
         while (1) {
-          switch (_context8.prev = _context8.next) {
+          switch (_context9.prev = _context9.next) {
             case 0:
-              return _context8.abrupt("return", this.api.put(this.baseURL + "/v1/identities/" + identityID, req));
+              return _context9.abrupt("return", this.api.put(this.baseURL + "/v1/identities/" + identityID, req));
 
             case 1:
             case "end":
-              return _context8.stop();
+              return _context9.stop();
           }
         }
-      }, _callee8, this);
+      }, _callee9, this);
     }));
 
-    function identityUpdate(_x8, _x9) {
+    function identityUpdate(_x9, _x10) {
       return _identityUpdate.apply(this, arguments);
     }
 
@@ -2236,16 +2452,16 @@ var GuardService = /*#__PURE__*/function () {
   _proto.identityMFAQRCode =
   /*#__PURE__*/
   function () {
-    var _identityMFAQRCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(identityID, password) {
+    var _identityMFAQRCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(identityID, password) {
       var req;
-      return runtime_1.wrap(function _callee9$(_context9) {
+      return runtime_1.wrap(function _callee10$(_context10) {
         while (1) {
-          switch (_context9.prev = _context9.next) {
+          switch (_context10.prev = _context10.next) {
             case 0:
               req = {
                 password: password
               };
-              return _context9.abrupt("return", this.api.post(this.baseURL + "/v1/identities/" + identityID + "/mfa", req, {
+              return _context10.abrupt("return", this.api.post(this.baseURL + "/v1/identities/" + identityID + "/mfa", req, {
                 headers: {
                   Accept: 'application/json'
                 }
@@ -2253,13 +2469,13 @@ var GuardService = /*#__PURE__*/function () {
 
             case 2:
             case "end":
-              return _context9.stop();
+              return _context10.stop();
           }
         }
-      }, _callee9, this);
+      }, _callee10, this);
     }));
 
-    function identityMFAQRCode(_x10, _x11) {
+    function identityMFAQRCode(_x11, _x12) {
       return _identityMFAQRCode.apply(this, arguments);
     }
 
@@ -2276,26 +2492,90 @@ var GuardService = /*#__PURE__*/function () {
   _proto.identitySendConfirmEmail =
   /*#__PURE__*/
   function () {
-    var _identitySendConfirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(req) {
-      return runtime_1.wrap(function _callee10$(_context10) {
+    var _identitySendConfirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(req) {
+      return runtime_1.wrap(function _callee11$(_context11) {
         while (1) {
-          switch (_context10.prev = _context10.next) {
+          switch (_context11.prev = _context11.next) {
             case 0:
-              return _context10.abrupt("return", this.api.post(this.baseURL + "/v1/identity/confirm", req));
+              return _context11.abrupt("return", this.api.post(this.baseURL + "/v1/identity/confirm", req));
 
             case 1:
             case "end":
-              return _context10.stop();
+              return _context11.stop();
           }
         }
-      }, _callee10, this);
+      }, _callee11, this);
     }));
 
-    function identitySendConfirmEmail(_x12) {
+    function identitySendConfirmEmail(_x13) {
       return _identitySendConfirmEmail.apply(this, arguments);
     }
 
     return identitySendConfirmEmail;
+  }()
+  /**
+   *  Get an identity using a customer email (format: customer+[b64Hash]@orohealth.me)
+   *
+   * @param email the customer email
+   * @returns IdentityResponse
+   */
+  ;
+
+  _proto.identityGetByCustomerEmail =
+  /*#__PURE__*/
+  function () {
+    var _identityGetByCustomerEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(email) {
+      return runtime_1.wrap(function _callee12$(_context12) {
+        while (1) {
+          switch (_context12.prev = _context12.next) {
+            case 0:
+              return _context12.abrupt("return", this.identityGetByHash(email.substring(email.indexOf('+') + 1, email.indexOf('@'))));
+
+            case 1:
+            case "end":
+              return _context12.stop();
+          }
+        }
+      }, _callee12, this);
+    }));
+
+    function identityGetByCustomerEmail(_x14) {
+      return _identityGetByCustomerEmail.apply(this, arguments);
+    }
+
+    return identityGetByCustomerEmail;
+  }()
+  /**
+   * Get an identity using a base64 hash
+   *
+   * @param b64Hash base64 hash of the identity
+   * @returns IdentityResponse
+   */
+  ;
+
+  _proto.identityGetByHash =
+  /*#__PURE__*/
+  function () {
+    var _identityGetByHash = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee13(b64Hash) {
+      return runtime_1.wrap(function _callee13$(_context13) {
+        while (1) {
+          switch (_context13.prev = _context13.next) {
+            case 0:
+              return _context13.abrupt("return", this.identityGet(b64Hash.replace('+', '-').replace('/', '_')));
+
+            case 1:
+            case "end":
+              return _context13.stop();
+          }
+        }
+      }, _callee13, this);
+    }));
+
+    function identityGetByHash(_x15) {
+      return _identityGetByHash.apply(this, arguments);
+    }
+
+    return identityGetByHash;
   }();
 
   return GuardService;
@@ -2447,7 +2727,7 @@ var PracticeService = /*#__PURE__*/function () {
   ;
 
   _proto.getPaymentIntentHashedEmail = function getPaymentIntentHashedEmail(email) {
-    return Buffer.from(sha256().update(email.toLowerCase()).digest('hex'), 'hex').toString('base64');
+    return hashToBase64String(email.toLowerCase());
   }
   /**
    * Creates a PracticePaymentIntent
@@ -3105,11 +3385,16 @@ var WorkflowService = /*#__PURE__*/function () {
 /**
  * This function is used to initialize services with a provided url
  * @param services an object containing the url of the services to init
- * @param (optional) authenticationCallback the authentification callback
+ * @param authenticationCallback (optional) the authentification callback. Called when the token were not able to be refreshed.
+ * @param useLocalStorage (default: true) if true store tokens into local storage (only for browsers)
  * @returns an instance of each services with a provided url
  */
 
-var init = function init(services, authenticationCallback) {
+var init = function init(services, authenticationCallback, useLocalStorage) {
+  if (useLocalStorage === void 0) {
+    useLocalStorage = true;
+  }
+
   var tellerBaseURL = services.tellerBaseURL,
       practiceBaseURL = services.practiceBaseURL,
       consultBaseURL = services.consultBaseURL,
@@ -3117,8 +3402,9 @@ var init = function init(services, authenticationCallback) {
       guardBaseURL = services.guardBaseURL,
       workflowBaseURL = services.workflowBaseURL,
       diagnosisBaseURL = services.diagnosisBaseURL;
-  var apiService = new APIService(undefined, authenticationCallback);
+  var apiService = new APIService(useLocalStorage, undefined, authenticationCallback);
   return {
+    apiService: apiService,
     tellerService: tellerBaseURL ? new TellerService(apiService, tellerBaseURL) : undefined,
     practiceService: practiceBaseURL ? new PracticeService(apiService, practiceBaseURL) : undefined,
     consultService: consultBaseURL ? new ConsultService(apiService, consultBaseURL) : undefined,
@@ -3130,5 +3416,5 @@ var init = function init(services, authenticationCallback) {
 };
 
 export default init;
-export { APIService, AssignmentStatus, AssistantType, AuthenticationBadRequest, AuthenticationFailed, AuthenticationServerError, AuthenticationUnconfirmedEmail, AxiosService, ConsultService, DiagnosisService, DocumentType, DrugType, FeeStatus, GuardService, IdentityCreationBadRequest, IdentityCreationConflict, IdentityCreationFailed, IndexKey, LicenseStatus, MedicalStatus, MetadataCategory, OtherRoleType, PaymentStatus, PeriodType, PlanStatus, PlanType, PracticeConfigKind, PracticeEmailKind, PracticeService, PractitionerStatus, PractitionnerRoleType, RateDimension, StripePriceType, SyncStatus, TaskStatus, TellerService, TransmissionKind, TransmissionStatus, VaultService, VisibilityType, WorkflowService, WorkflowType };
+export { APIService, ApisPracticeManager, AssignmentStatus, AssistantType, AuthenticationBadRequest, AuthenticationFailed, AuthenticationServerError, AuthenticationUnconfirmedEmail, AxiosService, ConsultService, DiagnosisService, DocumentType, DrugType, FeeStatus, GuardService, IdentityCreationBadRequest, IdentityCreationConflict, IdentityCreationFailed, IndexKey, LicenseStatus, MedicalStatus, MetadataCategory, OtherRoleType, PaymentStatus, PeriodType, PlanStatus, PlanType, PracticeConfigKind, PracticeEmailKind, PracticeService, PractitionerStatus, PractitionnerRoleType, RateDimension, StripePriceType, SyncStatus, TaskStatus, TellerService, TransmissionKind, TransmissionStatus, VaultService, VisibilityType, WorkflowService, WorkflowType, hashToBase64String, init };
 //# sourceMappingURL=oro-sdk-apis.esm.js.map