cidaas-javascript-sdk 2.4.3 → 2.5.1

package/types/web-auth/Helper.js

@@ -0,0 +1,89 @@
+"use strict";
+exports.__esModule = true;
+exports.CustomException = exports.Helper = void 0;
+var Helper = /** @class */ (function () {
+    function Helper() {
+    }
+    /**
+   * create form
+   * @param form
+   * @param options
+   * @returns
+   */
+    Helper.createForm = function (url, options, method) {
+        if (method === void 0) { method = 'POST'; }
+        var form = document.createElement('form');
+        form.action = url;
+        form.method = method;
+        for (var key in options) {
+            if (options.hasOwnProperty(key)) {
+                var hiddenField = document.createElement("input");
+                hiddenField.setAttribute("type", "hidden");
+                hiddenField.setAttribute("name", key);
+                hiddenField.setAttribute("value", options[key]);
+                form.appendChild(hiddenField);
+            }
+        }
+        return form;
+    };
+    /**
+    * utility function to create and make post request
+    * @param options
+    * @param serviceurl
+    * @param errorResolver
+    * @param access_token
+    * @param headers
+    * @returns
+    */
+    Helper.createPostPromise = function (options, serviceurl, errorResolver, access_token, headers) {
+        return new Promise(function (resolve, reject) {
+            try {
+                var http = new XMLHttpRequest();
+                http.onreadystatechange = function () {
+                    if (http.readyState == 4) {
+                        if (http.responseText) {
+                            resolve(JSON.parse(http.responseText));
+                        }
+                        else {
+                            resolve(errorResolver);
+                        }
+                    }
+                };
+                http.open("POST", serviceurl, true);
+                http.setRequestHeader("Content-type", "application/json");
+                if (headers) {
+                    for (var key in headers) {
+                        if (headers.hasOwnProperty(key)) {
+                            http.setRequestHeader(key, headers[key]);
+                        }
+                    }
+                }
+                if (access_token) {
+                    http.setRequestHeader("Authorization", "Bearer ".concat(access_token));
+                }
+                if (window.localeSettings) {
+                    http.setRequestHeader("accept-language", window.localeSettings);
+                }
+                if (options) {
+                    http.send(JSON.stringify(options));
+                }
+                else {
+                    http.send();
+                }
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    };
+    return Helper;
+}());
+exports.Helper = Helper;
+var CustomException = /** @class */ (function () {
+    function CustomException(errorMessage, statusCode) {
+        this.errorMessage = errorMessage;
+        this.statusCode = statusCode;
+    }
+    return CustomException;
+}());
+exports.CustomException = CustomException;

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

@@ -0,0 +1,102 @@
+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;
+    /**
+     * register 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;
+    }): void;
+}

package/types/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;
+    ;
+    /**
+     * register 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/types/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/types/web-auth/TokenService.js

@@ -0,0 +1,210 @@
+"use strict";
+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) {
+        return new Promise(function (resolve, reject) {
+            try {
+                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 http = new XMLHttpRequest();
+                var _serviceURL = window.webAuthSettings.authority + "/token-srv/token";
+                http.onreadystatechange = function () {
+                    if (http.readyState == 4) {
+                        resolve(JSON.parse(http.responseText));
+                    }
+                };
+                http.open("POST", _serviceURL, true);
+                http.setRequestHeader("Content-type", "application/json");
+                if (window.localeSettings) {
+                    http.setRequestHeader("accept-language", window.localeSettings);
+                }
+                http.send(JSON.stringify(options));
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    }
+    TokenService.renewToken = renewToken;
+    ;
+    /**
+     * get access token from code
+     * @param options
+     * @returns
+     */
+    function getAccessToken(options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                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.code_verifier = _this.code_verifier;
+                options.grant_type = "authorization_code";
+                var http = new XMLHttpRequest();
+                var _serviceURL = window.webAuthSettings.authority + "/token-srv/token";
+                http.onreadystatechange = function () {
+                    if (http.readyState == 4) {
+                        resolve(JSON.parse(http.responseText));
+                    }
+                };
+                http.open("POST", _serviceURL, true);
+                http.setRequestHeader("Content-type", "application/json");
+                if (window.localeSettings) {
+                    http.setRequestHeader("accept-language", window.localeSettings);
+                }
+                http.send(JSON.stringify(options));
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    }
+    TokenService.getAccessToken = getAccessToken;
+    ;
+    /**
+     * validate access token
+     * @param options
+     * @returns
+     */
+    function validateAccessToken(options) {
+        return new Promise(function (resolve, reject) {
+            try {
+                if (!options.token || !options.token_type_hint) {
+                    throw new Helper_1.CustomException("token or token_type_hint cannot be empty", 417);
+                }
+                var http = new XMLHttpRequest();
+                var _serviceURL = window.webAuthSettings.authority + "/token-srv/introspect";
+                http.onreadystatechange = function () {
+                    if (http.readyState == 4) {
+                        resolve(JSON.parse(http.responseText));
+                    }
+                };
+                http.open("POST", _serviceURL, true);
+                http.setRequestHeader("Content-type", "application/json");
+                if (window.localeSettings) {
+                    http.setRequestHeader("accept-language", window.localeSettings);
+                }
+                http.send(JSON.stringify(options));
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    }
+    TokenService.validateAccessToken = validateAccessToken;
+    ;
+    /**
+     * get scope consent details
+     * @param options
+     * @returns
+     */
+    function getScopeConsentDetails(options) {
+        return new Promise(function (resolve, reject) {
+            try {
+                var http = new XMLHttpRequest();
+                var _serviceURL = window.webAuthSettings.authority + "/token-srv/prelogin/metadata/" + options.track_id + "?acceptLanguage=" + options.locale;
+                http.onreadystatechange = function () {
+                    if (http.readyState == 4) {
+                        if (http.responseText) {
+                            resolve(JSON.parse(http.responseText));
+                        }
+                        else {
+                            resolve(false);
+                        }
+                    }
+                };
+                http.open("GET", _serviceURL, true);
+                http.setRequestHeader("Content-type", "application/json");
+                if (window.localeSettings) {
+                    http.setRequestHeader("accept-language", window.localeSettings);
+                }
+                http.send();
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    }
+    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);
+    }
+    TokenService.updateSuggestMFA = updateSuggestMFA;
+    ;
+    /**
+     * getMissingFieldsLogin
+     * @param trackId
+     * @returns
+     */
+    function getMissingFieldsLogin(trackId) {
+        return new Promise(function (resolve, reject) {
+            try {
+                var http = new XMLHttpRequest();
+                var _serviceURL = window.webAuthSettings.authority + "/token-srv/prelogin/metadata/" + trackId;
+                http.onreadystatechange = function () {
+                    if (http.readyState == 4) {
+                        if (http.responseText) {
+                            resolve(JSON.parse(http.responseText));
+                        }
+                        else {
+                            resolve(undefined);
+                        }
+                    }
+                };
+                http.open("GET", _serviceURL, true);
+                http.setRequestHeader("Content-type", "application/json");
+                if (window.localeSettings) {
+                    http.setRequestHeader("accept-language", window.localeSettings);
+                }
+                http.send();
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    }
+    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 = {}));