cidaas-javascript-sdk 4.3.3 → 5.0.0

package/dist/authentication-service/AuthenticationService.js

@@ -0,0 +1,210 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationService = void 0;
+const Helper_1 = require("../common/Helper");
+class AuthenticationService {
+    constructor(configUserProvider) {
+        if (!configUserProvider || !configUserProvider.getConfig()) {
+            throw new Helper_1.CustomException("Settings or Authentication instance in OIDC cannot be empty", 417);
+        }
+        this.config = configUserProvider.getConfig();
+        this.userManager = configUserProvider.getUserManager();
+        this.userManager.events.addSilentRenewError(function () {
+            throw new Helper_1.CustomException("Error while renewing silent login", 500);
+        });
+        this.configUserProvider = configUserProvider;
+    }
+    /**
+     * To register through cidaas sdk, call **registerWithBrowser()**. This will generate and redirect the app to authz url in same window for register view.
+     * Afterwards you will be redirected to the hosted registration page.
+     * @example
+     * ```js
+     * cidaasAuthenticationService.registerWithBrowser();
+     * ```
+     * @param {LoginRedirectOptions} options to over-ride the client config for redirect login
+     */
+    registerWithBrowser(options) {
+        return loginOrRegisterWithBrowser(this.configUserProvider, 'register', options);
+    }
+    /**
+     * To login through cidaas sdk, call **loginWithBrowser()**. This will generate and redirect the app to authz url in same window for logging in. Afterwards you will be redirected to the hosted login page.
+     * Once login successful, it will automatically redirects you to the redirect url, which is configured in cidaas config.
+     * @example
+     * ```js
+     * cidaasAuthenticationService.loginWithBrowser();
+     * ```
+     * @param {LoginRedirectOptions} options to over-ride the client config for redirect login
+     */
+    loginWithBrowser(options) {
+        return loginOrRegisterWithBrowser(this.configUserProvider, 'login', options);
+    }
+    /**
+     * To open the hosted login page in pop up window, call **popupSignIn()**. This will generate and open authz url in a popup window.
+     * On successful sign in, authenticated user is returned.
+     * @example
+     * ```js
+     * cidaasAuthenticationService.popupSignIn().then(function (response) {
+     *   // the response will give you user details after finishing loginCallback().
+     * }).catch(function(ex) {
+     *  // your failure code here
+     * });
+     * ```
+     * @param {PopupSignInOptions} options optional options to over-ride the client config for popup sign in
+     */
+    popupSignIn(options) {
+        return this.userManager.signinPopup(options);
+    }
+    /**
+     * Once login successful, it will automatically redirects you to the redirect url, which is configured in cidaas config.
+     * To complete the login process, call **loginCallback()**. This will parses needed informations such as tokens in the redirect url.
+     *
+     * @example
+     * ```js
+     * cidaasAuthenticationService.loginCallback().then(function (response: User) {
+     *   // the response will give you login details.
+     * }).catch(function(ex) {
+     *  // your failure code here
+     * });
+     * ```
+     * @param {string} url optional url to read sign in state from
+     */
+    loginCallback(url) {
+        return this.userManager.signinCallback(url);
+    }
+    /**
+     * To end user session, call **logout()**. You need set the redirect url, if not it will automatically redirect to the login page
+     * @example
+     * ```js
+     * cidaasAuthenticationService.logout();
+     * ```
+     * @param {LogoutRedirectOptions} options optional logout options to override cidaas configuration
+     */
+    logout(options) {
+        return this.userManager.signoutRedirect(options);
+    }
+    /**
+     * To open the hosted logout page in pop up window, call **popupSignOut()**.
+     * @example
+     * ```js
+     * cidaasAuthenticationService.popupSignOut().then(function() {
+     *   // success callback in main application window after finishing popupSignOutCallback().
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
+     *
+     * @param {PopupSignOutOptions} options optional logout options to override cidaas configuration
+     */
+    popupSignOut(options) {
+        return this.userManager.signoutPopup(options);
+    }
+    /**
+     * **logoutCallback()** will parses the details of userState after logout.
+     * Get the logout call state from the url provided, if none is provided current window url is used.
+     * @example
+     * ```js
+     * cidaasAuthenticationService.logoutCallback().then(function (response: LogoutResponse) {
+     *   // the response will give you userState details.
+     * }).catch(function(ex) {
+     *  // your failure code here
+     * });
+     * ```
+     * @param {string} url optional url to read signout state from,
+     * @param {boolean} keepopen optional boolean to keep the popup window open after logout, in case of popupSignOut()
+     */
+    logoutCallback(url, keepopen) {
+        return this.userManager.signoutCallback(url, keepopen);
+    }
+    /**
+     * **renewToken()** will update user information in user storage with a new token, based on refresh token that is stored in the storage.
+     * On successful token renewal, authenticated user is returned
+     *
+     * @example
+     * ```js
+     * cidaasAuthenticationService.renewToken().then(function (response) {
+     *   // the response will give you user details.
+     * }).catch(function(ex) {
+     *  // your failure code here
+     * });
+     * ```
+     * @param {RenewTokenOptions} options options to over-ride the client config for renewing token.
+     * @returns {Promise<User>} Authenticated user
+     */
+    renewToken(options) {
+        return this.userManager.signinSilent(Object.assign({ silentRequestTimeoutInSeconds: 60 }, (options && Object.assign({}, options) || {})));
+    }
+    /**
+     * To get the generated login url, call **getLoginURL()**. This will call authz service and generate login url to be used.
+     * @example
+     * ```js
+     * cidaasAuthenticationService.getLoginURL().then(function (response) {
+     *   // the response will give you login url.
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
+     * @param {LoginRequestOptions} options login options to override config settings provided
+     * @return {Promise<string>} authz url for login
+     */
+    getLoginURL(options) {
+        return new Promise((resolve, reject) => {
+            this.userManager.getClient().createSigninRequest(Object.assign(Object.assign({}, this.config), (options && { options } || {}))).then((signinRequest) => {
+                resolve(signinRequest.url);
+            }).catch((e) => {
+                reject(e);
+            });
+        });
+    }
+    /**
+     * To get the user informations from defined UserStorage, call **getUserInfoFromStorage()**.
+     * This will fetch informations about the authenticated user such as tokens & user profiles, which has been stored in predefined user storage based on cidaas configuration. (default is session storage)
+     *
+     * @example
+     * ```js
+     * cidaasAuthenticationService.getUserInfoFromStorage().then(function (response) {
+     *   // the response will give you profile details.
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
+     * @return {Promise<User|null>} returns authenticated user if present, else null
+     */
+    getUserInfoFromStorage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.userManager) {
+                return Promise.reject(new Helper_1.CustomException("UserManager cannot be empty", 417));
+            }
+            return yield this.userManager.getUser();
+        });
+    }
+}
+exports.AuthenticationService = AuthenticationService;
+/**
+ * This function will be called internally by loginWithBrowser() & registerWithBrowser function, to either authenticate existing user or register a new one.
+ *
+ * @param {ConfigUserProvider} configUserProvider contains cidaas configuration and user manager
+ * @param {string} view_type either 'login' or 'register'
+ * @param {LoginRedirectOptions} options optional login options to override the webauth configuration
+ */
+function loginOrRegisterWithBrowser(configUserProvider, view_type, options) {
+    var _a;
+    const config = configUserProvider.getConfig();
+    if (!config.extraQueryParams) {
+        config.extraQueryParams = {};
+    }
+    config.extraQueryParams.view_type = view_type;
+    if (config.response_type.indexOf("id_token") == -1 && ((_a = config.scope) === null || _a === void 0 ? void 0 : _a.indexOf("openid")) != -1 && !config.extraQueryParams.nonce) {
+        config.extraQueryParams.nonce = new Date().getTime().toString();
+    }
+    const userManager = configUserProvider.getUserManager();
+    return userManager.signinRedirect(Object.assign({ extraQueryParams: config.extraQueryParams, redirect_uri: config.redirect_uri }, (options && Object.assign({}, options) || {})));
+}

package/dist/{authentication/Authentication.model.d.ts → authentication-service/AuthenticationService.model.d.ts}

@@ -1,24 +1,30 @@
-import { SigninPopupArgs, SigninRedirectArgs, SigninSilentArgs, SignoutPopupArgs, SignoutRedirectArgs, UserManagerSettings, UserManager, OidcClient, CreateSigninRequestArgs, User as OidcUser, SignoutResponse } from 'oidc-client-ts';
+import { SigninPopupArgs, SigninRedirectArgs, SigninSilentArgs, SignoutPopupArgs, SignoutRedirectArgs, UserManagerSettings, UserManager, OidcClient, CreateSigninRequestArgs, User as OidcUser, SignoutResponse, SigninRequest } from 'oidc-client-ts';
 /**
  * @augments UserManagerSettings
- * **/
+ */
 export interface OidcSettings extends UserManagerSettings {
 }
 /**
  * @augments UserManager
- * */
+ */
 export declare class OidcManager extends UserManager {
     constructor(settings: OidcSettings);
     getClient(): OidcClient;
 }
-/***
+/**
  * Login request to generate authz url.
+ * @augments SigninRequest
+ */
+export interface LoginRequest extends SigninRequest {
+}
+/**
+ * options for Login request to generate authz url.
  * It's based of the parameters in OIDC specs
  * @augments CreateSigninRequestArgs
  */
 export interface LoginRequestOptions extends CreateSigninRequestArgs {
 }
-/***
+/**
  * Options to override options during redirect login
  * @augments SigninRedirectArgs
  */
@@ -27,36 +33,36 @@ export interface LoginRedirectOptions extends SigninRedirectArgs {
 /**
  * Response state holding sign out errors if any
  * @augments SignoutResponse
- * **/
+ */
 export interface LogoutResponse extends SignoutResponse {
 }
-/***
+/**
  * Options to override options during redirect logout
  * @augments SignoutRedirectArgs
  */
 export interface LogoutRedirectOptions extends SignoutRedirectArgs {
 }
-/***
+/**
  * Options to override options during popup sign in
  * @augments SigninPopupArgs
  */
 export interface PopupSignInOptions extends SigninPopupArgs {
 }
-/***
+/**
  * Options to override options during popup sign out
  * @augments SignoutPopupArgs
  */
 export interface PopupSignOutOptions extends SignoutPopupArgs {
 }
-/***
+/**
  * Options to override options during silent sign in
  * @augments SigninSilentArgs
  */
-export interface SilentSignInOptions extends SigninSilentArgs {
+export interface RenewTokenOptions extends SigninSilentArgs {
 }
 /**
  * Authenticated user information including token, id_token and claims
  * @augments OidcUser
- * **/
+ */
 export declare class User extends OidcUser {
 }

package/dist/{authentication/Authentication.model.js → authentication-service/AuthenticationService.model.js}

@@ -4,7 +4,7 @@ exports.User = exports.OidcManager = void 0;
 const oidc_client_ts_1 = require("oidc-client-ts");
 /**
  * @augments UserManager
- * */
+ */
 class OidcManager extends oidc_client_ts_1.UserManager {
     constructor(settings) {
         super(settings);
@@ -17,7 +17,7 @@ exports.OidcManager = OidcManager;
 /**
  * Authenticated user information including token, id_token and claims
  * @augments OidcUser
- * **/
+ */
 class User extends oidc_client_ts_1.User {
 }
 exports.User = User;

package/dist/common/Common.model.d.ts

@@ -4,29 +4,25 @@ export interface LoginPrecheckRequest {
 }
 /** Type of verification to be used to authenticate user */
 export declare enum VerificationType {
-    'PASSWORD' = 0,
-    'TOUCHID' = 1,
-    'FIDO2' = 2,
-    'SECURITY_QUESTION' = 3,
-    'SMS' = 4,
-    'IVR' = 5,
-    'FACE' = 6,
-    'TOTP' = 7,
-    'EMAIL' = 8,
-    'BACKUPCODE' = 9,
-    'PATTERN' = 10,
-    'PUSH' = 11,
-    'VOICE' = 12
+    Password = "PASSWORD",
+    TouchId = "TOUCHID",
+    Fido2 = "FIDO2",
+    SecurityQuestion = "SECURITY_QUESTION",
+    Sms = "SMS",
+    Ivr = "IVR",
+    Face = "FACE",
+    Totp = "TOTP",
+    Email = "EMAIL",
+    BackupCode = "BACKUPCODE",
+    Pattern = "PATTERN",
+    Push = "PUSH",
+    Voice = "VOICE"
 }
 export interface HTTPRequestHeader {
     /** Request id returned from the authorization call */
     requestId: string;
-    /** DEPRECATED: Captcha string for captcha check */
-    captcha?: string;
     /** Response language, which is configured in cidaas admin ui */
     acceptlanguage?: string;
-    /** DEPRECATED: Needed in case bot captcha check is activated */
-    bot_captcha_response?: string;
     /** Identifier generated after successful authentication but unfulfilled prechecks */
     trackId?: string;
     /** Latitude is the string location parameter sent in the headers */
@@ -36,6 +32,6 @@ export interface HTTPRequestHeader {
 }
 /** defines whether the the process will be done via email link or whether the user needs to enter a code to complete the process. */
 export declare enum ProcessingType {
-    'CODE' = 0,
-    'LINK' = 1
+    Code = "CODE",
+    Link = "LINK"
 }

package/dist/common/Common.model.js

@@ -4,23 +4,23 @@ exports.ProcessingType = exports.VerificationType = void 0;
 /** Type of verification to be used to authenticate user */
 var VerificationType;
 (function (VerificationType) {
-    VerificationType[VerificationType["PASSWORD"] = 0] = "PASSWORD";
-    VerificationType[VerificationType["TOUCHID"] = 1] = "TOUCHID";
-    VerificationType[VerificationType["FIDO2"] = 2] = "FIDO2";
-    VerificationType[VerificationType["SECURITY_QUESTION"] = 3] = "SECURITY_QUESTION";
-    VerificationType[VerificationType["SMS"] = 4] = "SMS";
-    VerificationType[VerificationType["IVR"] = 5] = "IVR";
-    VerificationType[VerificationType["FACE"] = 6] = "FACE";
-    VerificationType[VerificationType["TOTP"] = 7] = "TOTP";
-    VerificationType[VerificationType["EMAIL"] = 8] = "EMAIL";
-    VerificationType[VerificationType["BACKUPCODE"] = 9] = "BACKUPCODE";
-    VerificationType[VerificationType["PATTERN"] = 10] = "PATTERN";
-    VerificationType[VerificationType["PUSH"] = 11] = "PUSH";
-    VerificationType[VerificationType["VOICE"] = 12] = "VOICE";
-})(VerificationType = exports.VerificationType || (exports.VerificationType = {}));
+    VerificationType["Password"] = "PASSWORD";
+    VerificationType["TouchId"] = "TOUCHID";
+    VerificationType["Fido2"] = "FIDO2";
+    VerificationType["SecurityQuestion"] = "SECURITY_QUESTION";
+    VerificationType["Sms"] = "SMS";
+    VerificationType["Ivr"] = "IVR";
+    VerificationType["Face"] = "FACE";
+    VerificationType["Totp"] = "TOTP";
+    VerificationType["Email"] = "EMAIL";
+    VerificationType["BackupCode"] = "BACKUPCODE";
+    VerificationType["Pattern"] = "PATTERN";
+    VerificationType["Push"] = "PUSH";
+    VerificationType["Voice"] = "VOICE";
+})(VerificationType || (exports.VerificationType = VerificationType = {}));
 /** defines whether the the process will be done via email link or whether the user needs to enter a code to complete the process. */
 var ProcessingType;
 (function (ProcessingType) {
-    ProcessingType[ProcessingType["CODE"] = 0] = "CODE";
-    ProcessingType[ProcessingType["LINK"] = 1] = "LINK";
-})(ProcessingType = exports.ProcessingType || (exports.ProcessingType = {}));
+    ProcessingType["Code"] = "CODE";
+    ProcessingType["Link"] = "LINK";
+})(ProcessingType || (exports.ProcessingType = ProcessingType = {}));

package/dist/common/ConfigUserProvider.d.ts

@@ -0,0 +1,10 @@
+import { OidcManager, OidcSettings } from "../authentication-service/AuthenticationService.model";
+declare class ConfigUserProvider {
+    private config;
+    private userManager;
+    constructor(config: OidcSettings);
+    setConfig(config: OidcSettings): void;
+    getConfig(): OidcSettings;
+    getUserManager(): OidcManager;
+}
+export default ConfigUserProvider;

package/dist/common/ConfigUserProvider.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AuthenticationService_model_1 = require("../authentication-service/AuthenticationService.model");
+class ConfigUserProvider {
+    constructor(config) {
+        if (!config.response_type) {
+            config.response_type = "code";
+        }
+        if (!config.scope) {
+            config.scope = "email openid profile mobile";
+        }
+        if (config.authority && config.authority.charAt(config.authority.length - 1) === '/') {
+            config.authority = config.authority.slice(0, config.authority.length - 1);
+        }
+        this.config = config;
+        this.userManager = new AuthenticationService_model_1.OidcManager(this.config);
+    }
+    setConfig(config) {
+        this.config = Object.assign(Object.assign({}, this.config), config);
+    }
+    getConfig() {
+        return this.config;
+    }
+    getUserManager() {
+        return this.userManager;
+    }
+}
+exports.default = ConfigUserProvider;

package/dist/common/Helper.d.ts

@@ -1,3 +1,4 @@
+import { OidcManager } from "../authentication-service/AuthenticationService.model";
 export declare class Helper {
     /**
      * create form
@@ -16,6 +17,12 @@ export declare class Helper {
     * @returns
     */
     static createHttpPromise(options: any, serviceurl: string, errorResolver: boolean, method: string, access_token?: string, headers?: any, formPayload?: FormData): Promise<any>;
+    static getAccessTokenFromUserStorage(userManager: OidcManager): Promise<string>;
+    /**
+     * To set accept language
+     * @param acceptLanguage
+     */
+    static setAcceptLanguageHeader(acceptLanguage: string): void;
 }
 export declare class CustomException {
     errorMessage: string;

package/dist/common/Helper.js

@@ -88,6 +88,25 @@ class Helper {
             }
         });
     }
+    static getAccessTokenFromUserStorage(userManager) {
+        return new Promise((resolve, reject) => {
+            try {
+                userManager.getUser().then((user) => {
+                    resolve(user === null || user === void 0 ? void 0 : user.access_token);
+                });
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    }
+    /**
+     * To set accept language
+     * @param acceptLanguage
+     */
+    static setAcceptLanguageHeader(acceptLanguage) {
+        window.localeSettings = acceptLanguage;
+    }
 }
 exports.Helper = Helper;
 class CustomException {

package/dist/common/User.model.d.ts

@@ -1,8 +1,6 @@
 export interface CidaasUser {
     /** Status of User */
     userStatus?: string;
-    /** DEPRECATED: use userStatus variable instead */
-    user_status?: string;
     /** Reason for user status */
     user_status_reason?: string;
     /** Username of the user */
@@ -79,8 +77,6 @@ export interface CidaasUser {
     roles?: string[];
     /** List of groups of a user */
     groups?: UserGroupMap[];
-    /** DEPRECATED: use groups instead */
-    userGroups?: UserGroupMap[];
     /** Identifier generated after successful authentication but unfulfilled prechecks */
     trackId?: string;
     /** User information Json Object in String format */