cidaas-javascript-sdk 3.1.3 → 3.1.5

package/dist/web-auth/LoginService.d.ts

@@ -0,0 +1,103 @@
+import { IUserEntity, LoginFormRequestEntity, PhysicalVerificationLoginRequest, LoginFormRequestAsyncEntity, IChangePasswordEntity } from "./Entities";
+export declare namespace LoginService {
+    /**
+   * login with username and password
+   * @param options
+   */
+    function loginWithCredentials(options: LoginFormRequestEntity): void;
+    /**
+   * login with username and password and return response
+   * @param options
+   * @returns
+   */
+    function loginWithCredentialsAsynFn(options: LoginFormRequestAsyncEntity): Promise<Response>;
+    /**
+     * login with social
+     * @param options
+     * @param queryParams
+     */
+    function loginWithSocial(options: {
+        provider: string;
+        requestId: string;
+    }, queryParams: {
+        dc: string;
+        device_fp: string;
+    }): void;
+    /**
+     *  with social
+     * @param options
+     * @param queryParams
+     */
+    function registerWithSocial(options: {
+        provider: string;
+        requestId: string;
+    }, queryParams: {
+        dc: string;
+        device_fp: string;
+    }): void;
+    /**
+    * passwordless login
+    * @param options
+    */
+    function passwordlessLogin(options: PhysicalVerificationLoginRequest): void;
+    /**
+     * scope consent continue after token pre check
+     * @param options
+     */
+    function scopeConsentContinue(options: {
+        track_id: string;
+    }): void;
+    /**
+     * claim consent continue login
+     * @param options
+     */
+    function claimConsentContinue(options: {
+        track_id: string;
+    }): void;
+    /**
+    * consent continue login
+    * @param options
+    */
+    function consentContinue(options: {
+        client_id: string;
+        consent_refs: string[];
+        sub: string;
+        scopes: string[];
+        matcher: any;
+        track_id: string;
+    }): void;
+    /**
+     * mfa continue login
+     * @param options
+     */
+    function mfaContinue(options: PhysicalVerificationLoginRequest & {
+        track_id: string;
+    }): void;
+    /**
+     * change password continue
+     * @param options
+     */
+    function firstTimeChangePassword(options: IChangePasswordEntity): void;
+    /**
+     * progressiveRegistration
+     * @param options
+     * @param headers
+     * @returns
+     */
+    function progressiveRegistration(options: IUserEntity, headers: {
+        requestId: string;
+        trackId: string;
+        acceptlanguage: string;
+    }): Promise<unknown>;
+    /**
+     * loginAfterRegister
+     * @param options
+     */
+    function loginAfterRegister(options: {
+        device_id?: string;
+        dc?: string;
+        rememberMe?: boolean;
+        trackId?: string;
+        device_fp?: string;
+    }): void;
+}

package/dist/web-auth/LoginService.js

@@ -0,0 +1,248 @@
+"use strict";
+exports.__esModule = true;
+exports.LoginService = void 0;
+var Helper_1 = require("./Helper");
+var LoginService;
+(function (LoginService) {
+    /**
+   * login with username and password
+   * @param options
+   */
+    function loginWithCredentials(options) {
+        try {
+            var url = window.webAuthSettings.authority + "/login-srv/login";
+            var form = Helper_1.Helper.createForm(url, options);
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.loginWithCredentials = loginWithCredentials;
+    ;
+    /**
+   * login with username and password and return response
+   * @param options
+   * @returns
+   */
+    function loginWithCredentialsAsynFn(options) {
+        try {
+            var searchParams = new URLSearchParams(options);
+            var response = fetch(window.webAuthSettings.authority + "/login-srv/login", {
+                method: "POST",
+                redirect: "follow",
+                body: searchParams.toString(),
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded"
+                }
+            });
+            return response;
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.loginWithCredentialsAsynFn = loginWithCredentialsAsynFn;
+    ;
+    /**
+     * login with social
+     * @param options
+     * @param queryParams
+     */
+    function loginWithSocial(options, queryParams) {
+        try {
+            var _serviceURL = window.webAuthSettings.authority + "/login-srv/social/login/" + options.provider.toLowerCase() + "/" + options.requestId;
+            if (queryParams && queryParams.dc && queryParams.device_fp) {
+                _serviceURL = _serviceURL + "?dc=" + queryParams.dc + "&device_fp=" + queryParams.device_fp;
+            }
+            window.location.href = _serviceURL;
+        }
+        catch (ex) {
+            console.log(ex);
+        }
+    }
+    LoginService.loginWithSocial = loginWithSocial;
+    ;
+    /**
+     *  with social
+     * @param options
+     * @param queryParams
+     */
+    function registerWithSocial(options, queryParams) {
+        try {
+            var _serviceURL = window.webAuthSettings.authority + "/login-srv/social/register/" + options.provider.toLowerCase() + "/" + options.requestId;
+            if (queryParams && queryParams.dc && queryParams.device_fp) {
+                _serviceURL = _serviceURL + "?dc=" + queryParams.dc + "&device_fp=" + queryParams.device_fp;
+            }
+            window.location.href = _serviceURL;
+        }
+        catch (ex) {
+            console.log(ex);
+        }
+    }
+    LoginService.registerWithSocial = registerWithSocial;
+    ;
+    /**
+    * passwordless login
+    * @param options
+    */
+    function passwordlessLogin(options) {
+        try {
+            var url = window.webAuthSettings.authority + "/login-srv/verification/login";
+            var form = Helper_1.Helper.createForm(url, options);
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.passwordlessLogin = passwordlessLogin;
+    ;
+    /**
+     * scope consent continue after token pre check
+     * @param options
+     */
+    function scopeConsentContinue(options) {
+        try {
+            var form = document.createElement('form');
+            form.action = window.webAuthSettings.authority + "/login-srv/precheck/continue/" + options.track_id;
+            form.method = 'POST';
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.scopeConsentContinue = scopeConsentContinue;
+    ;
+    /**
+     * claim consent continue login
+     * @param options
+     */
+    function claimConsentContinue(options) {
+        try {
+            var form = document.createElement('form');
+            form.action = window.webAuthSettings.authority + "/login-srv/precheck/continue/" + options.track_id;
+            form.method = 'POST';
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.claimConsentContinue = claimConsentContinue;
+    ;
+    /**
+    * consent continue login
+    * @param options
+    */
+    function consentContinue(options) {
+        try {
+            var url = window.webAuthSettings.authority + "/login-srv/precheck/continue/" + options.track_id;
+            var form = Helper_1.Helper.createForm(url, options);
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.consentContinue = consentContinue;
+    ;
+    /**
+     * mfa continue login
+     * @param options
+     */
+    function mfaContinue(options) {
+        try {
+            var url = window.webAuthSettings.authority + "/login-srv/precheck/continue/" + options.track_id;
+            var form = Helper_1.Helper.createForm(url, options);
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.mfaContinue = mfaContinue;
+    ;
+    /**
+     * change password continue
+     * @param options
+     */
+    function firstTimeChangePassword(options) {
+        try {
+            var url = window.webAuthSettings.authority + "/login-srv/precheck/continue/" + options.loginSettingsId;
+            ;
+            var form = Helper_1.Helper.createForm(url, options);
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.firstTimeChangePassword = firstTimeChangePassword;
+    ;
+    /**
+     * progressiveRegistration
+     * @param options
+     * @param headers
+     * @returns
+     */
+    function progressiveRegistration(options, headers) {
+        return new Promise(function (resolve, reject) {
+            try {
+                var http = new XMLHttpRequest();
+                var _serviceURL = window.webAuthSettings.authority + "/login-srv/progressive/update/user";
+                http.onreadystatechange = function () {
+                    if (http.readyState == 4) {
+                        if (http.responseText) {
+                            resolve(JSON.parse(http.responseText));
+                        }
+                        else {
+                            resolve(undefined);
+                        }
+                    }
+                };
+                http.open("POST", _serviceURL, true);
+                http.setRequestHeader("Content-type", "application/json");
+                http.setRequestHeader("requestId", headers.requestId);
+                http.setRequestHeader("trackId", headers.trackId);
+                if (headers.acceptlanguage) {
+                    http.setRequestHeader("accept-language", headers.acceptlanguage);
+                }
+                else if (window.localeSettings) {
+                    http.setRequestHeader("accept-language", window.localeSettings);
+                }
+                http.send(JSON.stringify(options));
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    }
+    LoginService.progressiveRegistration = progressiveRegistration;
+    ;
+    /**
+     * loginAfterRegister
+     * @param options
+     */
+    function loginAfterRegister(options) {
+        try {
+            var url = window.webAuthSettings.authority + "/login-srv/login/handle/afterregister/" + options.trackId;
+            var form = Helper_1.Helper.createForm(url, options);
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Helper_1.CustomException(ex, 417);
+        }
+    }
+    LoginService.loginAfterRegister = loginAfterRegister;
+    ;
+})(LoginService = exports.LoginService || (exports.LoginService = {}));

package/dist/web-auth/TokenService.d.ts

@@ -0,0 +1,48 @@
+import { AccessTokenRequest, TokenIntrospectionEntity, ISuggestedMFAActionConfig } from "./Entities";
+export declare namespace TokenService {
+    /**
+     * renew token using refresh token
+     * @param options
+     * @returns
+     */
+    function renewToken(options: AccessTokenRequest): Promise<unknown>;
+    /**
+     * get access token from code
+     * @param options
+     * @returns
+     */
+    function getAccessToken(options: AccessTokenRequest): Promise<unknown>;
+    /**
+     * validate access token
+     * @param options
+     * @returns
+     */
+    function validateAccessToken(options: TokenIntrospectionEntity): Promise<unknown>;
+    /**
+     * get scope consent details
+     * @param options
+     * @returns
+     */
+    function getScopeConsentDetails(options: {
+        track_id: string;
+        locale: string;
+    }): Promise<unknown>;
+    /**
+     * updateSuggestMFA
+     * @param track_id
+     * @param options
+     * @returns
+     */
+    function updateSuggestMFA(track_id: string, options: ISuggestedMFAActionConfig): Promise<unknown>;
+    /**
+     * getMissingFieldsLogin
+     * @param trackId
+     * @returns
+     */
+    function getMissingFieldsLogin(trackId: string): Promise<unknown>;
+    /**
+     * device code flow - verify
+     * @param code
+     */
+    function deviceCodeVerify(code: string): void;
+}

package/dist/web-auth/TokenService.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.TokenService = void 0;
+var Helper_1 = require("./Helper");
+var TokenService;
+(function (TokenService) {
+    /**
+     * renew token using refresh token
+     * @param options
+     * @returns
+     */
+    function renewToken(options) {
+        if (!options.refresh_token) {
+            throw new Helper_1.CustomException("refresh_token cannot be empty", 417);
+        }
+        options.client_id = window.webAuthSettings.client_id;
+        options.grant_type = 'refresh_token';
+        var _serviceURL = window.webAuthSettings.authority + "/token-srv/token";
+        return Helper_1.Helper.createPostPromise(options, _serviceURL, undefined, "POST");
+    }
+    TokenService.renewToken = renewToken;
+    ;
+    /**
+     * get access token from code
+     * @param options
+     * @returns
+     */
+    function getAccessToken(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var signInRequest, _serviceURL;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!options.code) {
+                            throw new Helper_1.CustomException("code cannot be empty", 417);
+                        }
+                        options.client_id = window.webAuthSettings.client_id;
+                        options.redirect_uri = window.webAuthSettings.redirect_uri;
+                        options.grant_type = "authorization_code";
+                        if (!!window.webAuthSettings.disablePKCE) return [3 /*break*/, 2];
+                        return [4 /*yield*/, window.usermanager._client.createSigninRequest(window.webAuthSettings)];
+                    case 1:
+                        signInRequest = _b.sent();
+                        options.code_verifier = (_a = signInRequest.state) === null || _a === void 0 ? void 0 : _a.code_verifier;
+                        _b.label = 2;
+                    case 2:
+                        _serviceURL = window.webAuthSettings.authority + "/token-srv/token";
+                        return [2 /*return*/, Helper_1.Helper.createPostPromise(options, _serviceURL, undefined, "POST")];
+                }
+            });
+        });
+    }
+    TokenService.getAccessToken = getAccessToken;
+    ;
+    /**
+     * validate access token
+     * @param options
+     * @returns
+     */
+    function validateAccessToken(options) {
+        if (!options.token || !options.token_type_hint) {
+            throw new Helper_1.CustomException("token or token_type_hint cannot be empty", 417);
+        }
+        var _serviceURL = window.webAuthSettings.authority + "/token-srv/introspect";
+        return Helper_1.Helper.createPostPromise(options, _serviceURL, false, "POST");
+    }
+    TokenService.validateAccessToken = validateAccessToken;
+    ;
+    /**
+     * get scope consent details
+     * @param options
+     * @returns
+     */
+    function getScopeConsentDetails(options) {
+        var _serviceURL = window.webAuthSettings.authority + "/token-srv/prelogin/metadata/" + options.track_id + "?acceptLanguage=" + options.locale;
+        return Helper_1.Helper.createPostPromise(undefined, _serviceURL, false, "GET");
+    }
+    TokenService.getScopeConsentDetails = getScopeConsentDetails;
+    ;
+    /**
+     * updateSuggestMFA
+     * @param track_id
+     * @param options
+     * @returns
+     */
+    function updateSuggestMFA(track_id, options) {
+        var _serviceURL = window.webAuthSettings.authority + "/token-srv/prelogin/suggested/mfa/update/" + track_id;
+        return Helper_1.Helper.createPostPromise(options, _serviceURL, false, "POST");
+    }
+    TokenService.updateSuggestMFA = updateSuggestMFA;
+    ;
+    /**
+     * getMissingFieldsLogin
+     * @param trackId
+     * @returns
+     */
+    function getMissingFieldsLogin(trackId) {
+        var _serviceURL = window.webAuthSettings.authority + "/token-srv/prelogin/metadata/" + trackId;
+        return Helper_1.Helper.createPostPromise(undefined, _serviceURL, false, "GET");
+    }
+    TokenService.getMissingFieldsLogin = getMissingFieldsLogin;
+    ;
+    /**
+     * device code flow - verify
+     * @param code
+     */
+    function deviceCodeVerify(code) {
+        var params = "user_code=".concat(encodeURI(code));
+        var url = "".concat(window.webAuthSettings.authority, "/token-srv/device/verify?").concat(params);
+        try {
+            var options = {
+                user_code: encodeURI(code)
+            };
+            var form = Helper_1.Helper.createForm(url, options, 'GET');
+            document.body.appendChild(form);
+            form.submit();
+        }
+        catch (ex) {
+            throw new Error(ex);
+        }
+    }
+    TokenService.deviceCodeVerify = deviceCodeVerify;
+})(TokenService = exports.TokenService || (exports.TokenService = {}));

package/dist/web-auth/UserService.d.ts

@@ -0,0 +1,143 @@
+import { UserEntity, ResetPasswordEntity, FindUserEntity, IUserLinkEntity, ChangePasswordEntity, ValidateResetPasswordEntity, AcceptResetPasswordEntity } from "./Entities";
+export declare namespace UserService {
+    /**
+     * get user info
+     * @param options
+     * @returns
+     */
+    function getUserProfile(options: {
+        access_token: string;
+    }): Promise<unknown>;
+    /**
+     * register user
+     * @param options
+     * @param headers
+     * @returns
+     */
+    function register(options: UserEntity, headers: {
+        requestId: string;
+        captcha?: string;
+        acceptlanguage?: string;
+        bot_captcha_response?: string;
+        trackId?: string;
+    }): Promise<unknown>;
+    /**
+     * get invite info
+     * @param options
+     * @returns
+     */
+    function getInviteUserDetails(options: {
+        invite_id: string;
+    }): Promise<unknown>;
+    /**
+     * get Communication status
+     * @param options
+     * @returns
+     */
+    function getCommunicationStatus(options: {
+        sub: string;
+        requestId: string;
+    }): Promise<unknown>;
+    /**
+     * initiate reset password
+     * @param options
+     * @returns
+     */
+    function initiateResetPassword(options: ResetPasswordEntity): Promise<unknown>;
+    /**
+     * handle reset password
+     * @param options
+     */
+    function handleResetPassword(options: ValidateResetPasswordEntity): Promise<unknown>;
+    /**
+    * reset password
+    * @param options
+    */
+    function resetPassword(options: AcceptResetPasswordEntity): Promise<unknown>;
+    /**
+     * get Deduplication details
+     * @param options
+     * @returns
+     */
+    function getDeduplicationDetails(options: {
+        trackId: string;
+    }): Promise<unknown>;
+    /**
+     * deduplication login
+     * @param options
+     */
+    function deduplicationLogin(options: {
+        trackId: string;
+        requestId: string;
+        sub: string;
+    }): void;
+    /**
+     * register Deduplication
+     * @param options
+     * @returns
+     */
+    function registerDeduplication(options: {
+        trackId: string;
+    }): Promise<unknown>;
+    /**
+     * change password
+     * @param options
+     * @param access_token
+     * @returns
+     */
+    function changePassword(options: ChangePasswordEntity, access_token: string): Promise<unknown>;
+    /**
+     * update profile
+     * @param options
+     * @param access_token
+     * @param sub
+     * @returns
+     */
+    function updateProfile(options: UserEntity, access_token: string, sub: string): Promise<unknown>;
+    /**
+     * initiate link accoount
+     * @param options
+     * @param access_token
+     * @returns
+     */
+    function initiateLinkAccount(options: IUserLinkEntity, access_token: string): Promise<unknown>;
+    /**
+     * complete link accoount
+     * @param options
+     * @param access_token
+     * @returns
+     */
+    function completeLinkAccount(options: {
+        code?: string;
+        link_request_id?: string;
+    }, access_token: string): Promise<unknown>;
+    /**
+     * get linked users
+     * @param access_token
+     * @param sub
+     * @returns
+     */
+    function getLinkedUsers(access_token: string, sub: string): Promise<unknown>;
+    /**
+     * unlink accoount
+     * @param access_token
+     * @param identityId
+     * @returns
+     */
+    function unlinkAccount(access_token: string, identityId: string): Promise<unknown>;
+    /**
+     * deleteUserAccount
+     * @param options
+     * @returns
+     */
+    function deleteUserAccount(options: {
+        access_token: string;
+        sub: string;
+    }): Promise<unknown>;
+    /**
+     * check if an user exists from users-actions-srv
+     * @param options
+     * @returns
+     */
+    function userCheckExists(options: FindUserEntity): Promise<unknown>;
+}