@marqeta/ux-toolkit-sdk-javascript 2.9.1 → 2.10.1

package/dist/index.js

@@ -1767,6 +1767,9 @@ __export(src_exports, {
     reactNativeSdkJsContainer: function() {
         return reactNativeContainer;
     },
+    refreshAccessToken: function() {
+        return refreshAccessToken;
+    },
     registerDeviceForPushNotifications: function() {
         return registerDeviceForPushNotifications;
     },
@@ -1842,6 +1845,9 @@ __export(src_exports, {
     verifyExternalAccount: function() {
         return verifyExternalAccount;
     },
+    verifyOTP: function() {
+        return verifyOTP;
+    },
     wlaReactNativeSdkJsContainer: function() {
         return wlaReactNativeContainer;
     }
@@ -5471,7 +5477,7 @@ function checkHttpStandizedError(httpIsOk, data) {
 function _checkHttpStandizedError() {
     _checkHttpStandizedError = // src/http-client/utils/checkHttpStandardizedError.ts
     _async_to_generator(function(httpIsOk, data) {
-        var error2, stdError;
+        var error2, stdError, oauthError;
         return _ts_generator(this, function(_state) {
             error2 = data === null || data === void 0 ? void 0 : data.error;
             if ((error2 === null || error2 === void 0 ? void 0 : error2.id) && (error2 === null || error2 === void 0 ? void 0 : error2.debug)) {
@@ -5481,6 +5487,10 @@ function _checkHttpStandizedError() {
                 });
                 throw stdError;
             }
+            oauthError = data;
+            if ((oauthError === null || oauthError === void 0 ? void 0 : oauthError.error) && (oauthError === null || oauthError === void 0 ? void 0 : oauthError.error_description) && !httpIsOk) {
+                throw oauthError;
+            }
             if (!httpIsOk) {
                 throw new MqSDKError("Received HTTP response not OK - Non-standard Error");
             }
@@ -17086,6 +17096,60 @@ function _loginWithIdAndPassword() {
     return _loginWithIdAndPassword.apply(this, arguments);
 }
 __name(loginWithIdAndPassword, "loginWithIdAndPassword");
+function refreshAccessToken(request) {
+    return _refreshAccessToken.apply(this, arguments);
+}
+function _refreshAccessToken() {
+    _refreshAccessToken = // src/idp/base/interactors/refreshAccessToken.ts
+    _async_to_generator(function(request) {
+        var container2, idpService;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    container2 = getActiveIocContainer();
+                    idpService = container2.get(ITF_IDP_SERVICE);
+                    return [
+                        4,
+                        idpService.refreshAccessToken(request)
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+            }
+        });
+    });
+    return _refreshAccessToken.apply(this, arguments);
+}
+__name(refreshAccessToken, "refreshAccessToken");
+function verifyOTP(request) {
+    return _verifyOTP.apply(this, arguments);
+}
+function _verifyOTP() {
+    _verifyOTP = // src/idp/base/interactors/verifyOTP.ts
+    _async_to_generator(function(request) {
+        var container2, idpService;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    container2 = getActiveIocContainer();
+                    idpService = container2.get(ITF_IDP_SERVICE);
+                    return [
+                        4,
+                        idpService.otpVerification(request)
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+            }
+        });
+    });
+    return _verifyOTP.apply(this, arguments);
+}
+__name(verifyOTP, "verifyOTP");
 // src/idp/base/services/iIdpService.ts
 var import_inversify113 = require("inversify");
 function _ts_decorate89(decorators, target, key, desc) {
@@ -17130,6 +17194,17 @@ var _MockIdpService = /*#__PURE__*/ function(iIdpService) {
             refreshToken: "mock-refresh-token",
             idToken: "mock-id-token"
         });
+        __publicField(_assert_this_initialized(_this), "mockRefreshResponse", {
+            accessToken: "mock-refreshed-access-token",
+            expiresIn: 3600,
+            refreshToken: "mock-new-refresh-token",
+            idToken: "mock-new-id-token"
+        });
+        __publicField(_assert_this_initialized(_this), "mockMfaRequiredResponse", {
+            error: "mfa_required",
+            error_description: "Mock MFA required response",
+            oob_code: "mock-oob-code"
+        });
         return _this;
     }
     _create_class(_MockIdpService, [
@@ -17161,6 +17236,48 @@ var _MockIdpService = /*#__PURE__*/ function(iIdpService) {
                 })();
             }
         },
+        {
+            key: "refreshAccessToken",
+            value: function refreshAccessToken(request) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            _this.mockRefreshResponse
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "handleMfaRequired",
+            value: function handleMfaRequired(request) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            _this.mockMfaRequiredResponse
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "otpVerification",
+            value: function otpVerification(request) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            _this.mockLoginResponse
+                        ];
+                    });
+                })();
+            }
+        },
         {
             key: "setMockOtpResponse",
             value: function setMockOtpResponse(response) {
@@ -17172,6 +17289,18 @@ var _MockIdpService = /*#__PURE__*/ function(iIdpService) {
             value: function setMockLoginResponse(response) {
                 this.mockLoginResponse = response;
             }
+        },
+        {
+            key: "setMockRefreshResponse",
+            value: function setMockRefreshResponse(response) {
+                this.mockRefreshResponse = response;
+            }
+        },
+        {
+            key: "setMockMfaRequiredResponse",
+            value: function setMockMfaRequiredResponse(response) {
+                this.mockMfaRequiredResponse = response;
+            }
         }
     ]);
     return _MockIdpService;
@@ -17194,21 +17323,17 @@ function _ts_metadata50(k, v) {
     if ((typeof Reflect === "undefined" ? "undefined" : _type_of(Reflect)) === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata50, "_ts_metadata");
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-__name(_ts_param, "_ts_param");
 var _RestIdpService = /*#__PURE__*/ function(iIdpService) {
     _inherits(_RestIdpService, iIdpService);
     var _super = _create_super(_RestIdpService);
-    function _RestIdpService(httpClient) {
+    function _RestIdpService() {
         _class_call_check(this, _RestIdpService);
         var _this;
-        _this = _super.call(this);
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments)));
         __publicField(_assert_this_initialized(_this), "httpClient");
-        _this.httpClient = httpClient;
+        __publicField(_assert_this_initialized(_this), "getEnvConfigValueByName");
         return _this;
     }
     _create_class(_RestIdpService, [
@@ -17254,11 +17379,18 @@ var _RestIdpService = /*#__PURE__*/ function(iIdpService) {
             value: function loginWithPassword(request) {
                 var _this = this;
                 return _async_to_generator(function() {
-                    var url, response;
+                    var url, audience, response, error2, mfaResponse, error3;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    9
+                                ]);
                                 url = "".concat(request.oauthBaseUrl, "/oauth/token");
+                                audience = _this.getEnvConfigValueByName.execute("CUI_API_BASE_URL");
                                 return [
                                     4,
                                     _this.httpClient.post(url, {
@@ -17271,7 +17403,102 @@ var _RestIdpService = /*#__PURE__*/ function(iIdpService) {
                                             username: request.identifier,
                                             password: request.password,
                                             client_id: request.clientId,
-                                            scope: "openid,profile,offline_access,cardholder:all"
+                                            scope: "openid email profile offline_access cardholder:all",
+                                            audience: audience
+                                        })
+                                    })
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        accessToken: response.access_token,
+                                        expiresIn: response.expires_in,
+                                        refreshToken: response.refresh_token,
+                                        idToken: response.id_token
+                                    }
+                                ];
+                            case 2:
+                                error2 = _state.sent();
+                                if (!(error2.error === "mfa_required" && error2.mfa_token)) return [
+                                    3,
+                                    7
+                                ];
+                                _state.label = 3;
+                            case 3:
+                                _state.trys.push([
+                                    3,
+                                    5,
+                                    ,
+                                    6
+                                ]);
+                                return [
+                                    4,
+                                    _this.handleMfaRequired({
+                                        oauthBaseUrl: request.oauthBaseUrl,
+                                        mfa_token: error2.mfa_token,
+                                        identifier: request.identifier,
+                                        clientId: request.clientId
+                                    })
+                                ];
+                            case 4:
+                                mfaResponse = _state.sent();
+                                throw {
+                                    accessToken: "",
+                                    expiresIn: 0,
+                                    refreshToken: "",
+                                    idToken: "",
+                                    error: error2.error,
+                                    error_description: mfaResponse.error_description,
+                                    mfa_token: error2.mfa_token,
+                                    oob_code: mfaResponse.oob_code
+                                };
+                            case 5:
+                                error3 = _state.sent();
+                                throw error3;
+                            case 6:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                throw new Error(error2.error_description || error2.error);
+                            case 8:
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 9:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "refreshAccessToken",
+            value: function refreshAccessToken(request) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var url, response;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = "".concat(request.oauthBaseUrl, "/oauth/token");
+                                return [
+                                    4,
+                                    _this.httpClient.post(url, {
+                                        method: "POST",
+                                        headers: {
+                                            "Content-Type": "application/json"
+                                        },
+                                        body: JSON.stringify({
+                                            grant_type: "refresh_token",
+                                            refresh_token: request.refreshToken,
+                                            client_id: request.clientId
                                         })
                                     })
                                 ];
@@ -17290,19 +17517,128 @@ var _RestIdpService = /*#__PURE__*/ function(iIdpService) {
                     });
                 })();
             }
+        },
+        {
+            key: "handleMfaRequired",
+            value: function handleMfaRequired(request) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var otpRequest, error2;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                if (!request.mfa_token) {
+                                    throw new Error("MFA token is required for handling MFA");
+                                }
+                                return [
+                                    4,
+                                    _this.requestOtpCode({
+                                        mfaToken: request.mfa_token,
+                                        oauthBaseUrl: request.oauthBaseUrl,
+                                        clientId: request.clientId
+                                    })
+                                ];
+                            case 1:
+                                otpRequest = _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        error: "mfa_required",
+                                        error_description: "Multi-factor authentication is required.",
+                                        oob_code: otpRequest.oobCode
+                                    }
+                                ];
+                            case 2:
+                                error2 = _state.sent();
+                                throw new Error("Error handling MFA requirement: " + error2.message);
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "otpVerification",
+            value: function otpVerification(request) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var url, response, error2;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                url = "".concat(request.oauthBaseUrl, "/oauth/token");
+                                return [
+                                    4,
+                                    _this.httpClient.post(url, {
+                                        method: "POST",
+                                        headers: {
+                                            "Content-Type": "application/json"
+                                        },
+                                        body: JSON.stringify({
+                                            // Auth0's token endpoint specifically looks for the exact string http://auth0.com/oauth/grant-type/mfa-oob to identify MFA OOB requests.
+                                            grant_type: "http://auth0.com/oauth/grant-type/mfa-oob",
+                                            client_id: request.clientId,
+                                            mfa_token: request.mfaToken,
+                                            oob_code: request.oobCode,
+                                            binding_code: request.bindingCode
+                                        })
+                                    })
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        accessToken: response.access_token,
+                                        expiresIn: response.expires_in,
+                                        refreshToken: response.refresh_token,
+                                        idToken: response.id_token,
+                                        tokenType: response.token_type,
+                                        scope: response.scope
+                                    }
+                                ];
+                            case 2:
+                                error2 = _state.sent();
+                                throw new Error("Error verifying OTP: " + error2.message);
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
         }
     ]);
     return _RestIdpService;
 }(iIdpService);
 __name(_RestIdpService, "RestIdpService");
 var RestIdpService = _RestIdpService;
+_ts_decorate91([
+    (0, import_inversify115.inject)(ITF_HTTP_CLIENT),
+    _ts_metadata50("design:type", typeof iHttpClient === "undefined" ? Object : iHttpClient)
+], RestIdpService.prototype, "httpClient", void 0);
+_ts_decorate91([
+    (0, import_inversify115.inject)(INTR_GET_ENV_CONFIG_VALUE_BY_NAME),
+    _ts_metadata50("design:type", typeof GetEnvConfigValueByName === "undefined" ? Object : GetEnvConfigValueByName)
+], RestIdpService.prototype, "getEnvConfigValueByName", void 0);
 RestIdpService = _ts_decorate91([
-    (0, import_inversify115.injectable)(),
-    _ts_param(0, (0, import_inversify115.inject)(ITF_HTTP_CLIENT)),
-    _ts_metadata50("design:type", Function),
-    _ts_metadata50("design:paramtypes", [
-        typeof iHttpClient === "undefined" ? Object : iHttpClient
-    ])
+    (0, import_inversify115.injectable)()
 ], RestIdpService);
 // src/idp/ioc/idpIOCModule.ts
 var import_inversify116 = require("inversify");
@@ -23289,6 +23625,7 @@ setActiveIocContainer(container);
     reactNativeCommonIOCModule: reactNativeCommonIOCModule,
     reactNativeFeatureFlagsIOCModule: reactNativeFeatureFlagsIOCModule,
     reactNativeSdkJsContainer: reactNativeSdkJsContainer,
+    refreshAccessToken: refreshAccessToken,
     registerDeviceForPushNotifications: registerDeviceForPushNotifications,
     replaceWlaCard: replaceWlaCard,
     requestOtpCode: requestOtpCode,
@@ -23314,6 +23651,7 @@ setActiveIocContainer(container);
     updateExternalAccount: updateExternalAccount,
     usersIOCModule: usersIOCModule,
     verifyExternalAccount: verifyExternalAccount,
+    verifyOTP: verifyOTP,
     wlaReactNativeSdkJsContainer: wlaReactNativeSdkJsContainer
 }); /*! Bundled license information: