cidaas-javascript-sdk 3.1.5 → 4.0.1

package/dist/web-auth/TokenService.js

@@ -38,12 +38,26 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 exports.__esModule = true;
 exports.TokenService = void 0;
 var Helper_1 = require("./Helper");
+var JwtHelper_1 = require("./JwtHelper");
 var TokenService;
 (function (TokenService) {
     /**
-     * renew token using refresh token
-     * @param options
-     * @returns
+     * To get a new token with the grant type refresh_token, call **renewToken()**.
+     * The refresh token to create a new token. The refresh token is received while creating an access token using the token endpoint and later can be used to fetch a new token without using credentials
+     * @example
+     * ```js
+     * const options = {
+     *   refresh_token: "your refresh token",
+     * }
+     *
+     * cidaas.renewToken(options)
+     *   .then(function (response) {
+     *     // type your code here
+     *   })
+     *   .catch(function (ex) {
+     *     // your failure code here
+     *   });
+     * ```
      */
     function renewToken(options) {
         if (!options.refresh_token) {
@@ -52,14 +66,27 @@ var TokenService;
         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");
+        return Helper_1.Helper.createHttpPromise(options, _serviceURL, undefined, "POST");
     }
     TokenService.renewToken = renewToken;
     ;
     /**
-     * get access token from code
-     * @param options
-     * @returns
+     * To get a new token with the grant type authorization_code, call **getAccessToken()** with code to create a new token.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/4ff850f48629a-generate-token for more details.
+     * @example
+     * ```js
+     * const options = {
+     *   code: "your code to be exchanged with access token",
+     * }
+     *
+     * cidaas.getAccessToken(options)
+     *   .then(function (response) {
+     *     // type your code here
+     *   })
+     *   .catch(function (ex) {
+     *     // your failure code here
+     *   });
+     * ```
      */
     function getAccessToken(options) {
         var _a;
@@ -82,7 +109,7 @@ var TokenService;
                         _b.label = 2;
                     case 2:
                         _serviceURL = window.webAuthSettings.authority + "/token-srv/token";
-                        return [2 /*return*/, Helper_1.Helper.createPostPromise(options, _serviceURL, undefined, "POST")];
+                        return [2 /*return*/, Helper_1.Helper.createHttpPromise(options, _serviceURL, undefined, "POST")];
                 }
             });
         });
@@ -90,56 +117,113 @@ var TokenService;
     TokenService.getAccessToken = getAccessToken;
     ;
     /**
-     * validate access token
-     * @param options
-     * @returns
+     * To validate an access token, call **validateAccessToken()**.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/26ff31e2937f1-introspect-with-bearer-token for more details.
+     * @example
+     * ```js
+     * const options = {
+     *   token: "your access token",
+     *   token_type_hint: "accepted token type hints are access_token, id_token, refresh_token, sso",
+     * }
+     *
+     * cidaas.validateAccessToken(options)
+     * .then(function (response) {
+     *   // type your code here
+     * })
+     * .catch(function (ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     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");
+        return Helper_1.Helper.createHttpPromise(options, _serviceURL, false, "POST", options.token);
     }
     TokenService.validateAccessToken = validateAccessToken;
     ;
     /**
-     * get scope consent details
-     * @param options
-     * @returns
+     * To get precheck result after login, call **loginPrecheck()**. If there is missing information, user will be redirected to either accepting consent, changing password, continuing MFA process, or do progressive registration
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/aappczju1t3uh-precheck-information for more details.
+     * @example
+     * ```js
+     * const options = {
+     *   trackId: "your track id from login",
+     *   locale: "your preferred locale",
+     * }
+     *
+     * cidaas.loginPrecheck(options)
+     * .then(function (response) {
+     *   // type your code here
+     * })
+     * .catch(function (ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
-    function getScopeConsentDetails(options) {
+    function loginPrecheck(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");
+        return Helper_1.Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
     }
-    TokenService.getScopeConsentDetails = getScopeConsentDetails;
+    TokenService.loginPrecheck = loginPrecheck;
     ;
     /**
-     * updateSuggestMFA
-     * @param track_id
-     * @param options
-     * @returns
+     * To get the missing fields after login, call **getMissingFields()**.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/aappczju1t3uh-precheck-information for more details.
+     * @example
+     * ```js
+     * const trackId = "your track id from login";
+     * cidaas.getMissingFields(trackId)
+     *   .then(function (response) {
+     *     // type your code here
+     * })
+     *   .catch(function (ex) {
+     *     // your failure code here
+     * });
+     * ```
      */
-    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");
+    function getMissingFields(trackId) {
+        var _serviceURL = window.webAuthSettings.authority + "/token-srv/prelogin/metadata/" + trackId;
+        return Helper_1.Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
     }
-    TokenService.updateSuggestMFA = updateSuggestMFA;
+    TokenService.getMissingFields = getMissingFields;
     ;
     /**
-     * getMissingFieldsLogin
-     * @param trackId
-     * @returns
+     * To initiate device code, call **initiateDeviceCode()**.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/b6d284f55be5e-authorization-request for more details.
+     * @example
+     * ```js
+     * const clientId = "your client id";
+     * cidaas.initiateDeviceCode(clientId)
+     *   .then(function (response) {
+     *     // type your code here
+     * })
+     *   .catch(function (ex) {
+     *     // your failure code here
+     * });
+     * ```
      */
-    function getMissingFieldsLogin(trackId) {
-        var _serviceURL = window.webAuthSettings.authority + "/token-srv/prelogin/metadata/" + trackId;
-        return Helper_1.Helper.createPostPromise(undefined, _serviceURL, false, "GET");
+    function initiateDeviceCode(clientId) {
+        var clientid = clientId !== null && clientId !== void 0 ? clientId : window.webAuthSettings.client_id;
+        var _serviceURL = "".concat(window.webAuthSettings.authority, "/authz-srv/device/authz?client_id=").concat(clientid);
+        return Helper_1.Helper.createHttpPromise(undefined, _serviceURL, false, "GET");
     }
-    TokenService.getMissingFieldsLogin = getMissingFieldsLogin;
-    ;
+    TokenService.initiateDeviceCode = initiateDeviceCode;
     /**
-     * device code flow - verify
-     * @param code
+     * To verify device code, call **deviceCodeVerify()**.
+     * @example
+     * ```js
+     * const code = "your code which has been send after initiateDeviceCode()";
+     * cidaas.deviceCodeVerify(code)
+     *   .then(function (response) {
+     *     // type your code here
+     * })
+     *   .catch(function (ex) {
+     *     // your failure code here
+     * });
+     * ```
      */
     function deviceCodeVerify(code) {
         var params = "user_code=".concat(encodeURI(code));
@@ -157,4 +241,45 @@ var TokenService;
         }
     }
     TokenService.deviceCodeVerify = deviceCodeVerify;
+    /**
+     * To check access token without having to call cidaas api, call **offlineTokenCheck()**. THe function will return true if the token is valid & false if the token is invalid.
+     * @example
+     * ```js
+     * cidaas.offlineTokenCheck('your access token');
+     * ```
+     */
+    function offlineTokenCheck(accessToken) {
+        var _a, _b;
+        var result = {
+            isExpiryDateValid: false,
+            isScopesValid: false,
+            isIssuerValid: false
+        };
+        var accessTokenHeaderAsJson = JwtHelper_1.JwtHelper.decodeTokenHeader(accessToken);
+        var accessTokenAsJson = JwtHelper_1.JwtHelper.decodeToken(accessToken);
+        if (!accessTokenAsJson || !accessTokenHeaderAsJson) {
+            return result;
+        }
+        else {
+            if (accessTokenAsJson.exp) {
+                var expirationDate = new Date(0);
+                expirationDate.setUTCSeconds(accessTokenAsJson.exp);
+                result.isExpiryDateValid = expirationDate.valueOf() > new Date().valueOf();
+            }
+            var accessTokenScopes_1 = accessTokenAsJson.scopes;
+            var webAuthSettingScopes = (_b = (_a = window.webAuthSettings) === null || _a === void 0 ? void 0 : _a.scope) === null || _b === void 0 ? void 0 : _b.split(' ');
+            if ((accessTokenScopes_1 === null || accessTokenScopes_1 === void 0 ? void 0 : accessTokenScopes_1.length) === (webAuthSettingScopes === null || webAuthSettingScopes === void 0 ? void 0 : webAuthSettingScopes.length)) {
+                webAuthSettingScopes.forEach(function (webAuthSettingScope) {
+                    var i = accessTokenScopes_1.indexOf(webAuthSettingScope);
+                    if (i > -1) {
+                        accessTokenScopes_1.splice(i, 1);
+                    }
+                });
+                result.isScopesValid = accessTokenScopes_1.length === 0;
+            }
+            result.isIssuerValid = accessTokenAsJson.iss === window.webAuthSettings.authority;
+        }
+        return result;
+    }
+    TokenService.offlineTokenCheck = offlineTokenCheck;
 })(TokenService = exports.TokenService || (exports.TokenService = {}));

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

@@ -1,18 +1,51 @@
 import { UserEntity, ResetPasswordEntity, FindUserEntity, IUserLinkEntity, ChangePasswordEntity, ValidateResetPasswordEntity, AcceptResetPasswordEntity } from "./Entities";
 export declare namespace UserService {
     /**
-     * get user info
-     * @param options
-     * @returns
+     * To get the user profile information by using cidaas internal api, call **getUserProfile()**.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/2zfvjx3vtq6g6-get-user-info for more details.
+     * @example
+     * ```js
+     * const options = {
+     *   access_token: 'your access token'
+     * }
+     * cidaas.getUserProfile(options)
+     * .then(function () {
+     *   // the response will give you user profile information.
+     * }).catch(function (ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function getUserProfile(options: {
         access_token: string;
     }): Promise<unknown>;
     /**
-     * register user
-     * @param options
-     * @param headers
-     * @returns
+     * To register user, call **register()**. This method will create a new user.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/427632e587203-register-a-new-user for more details.
+     * Note: Only requestId in the headers is required.
+     * @example
+     * ```js
+     * const headers = {
+     *   requestId: 'your_received_requestId',
+     *   captcha: 'captcha',
+     *   acceptlanguage: 'acceptlanguage',
+     *   bot_captcha_response: 'bot_captcha_response'
+     * };
+     *
+     * cidaas.register({
+     *   email: 'xxx123@xxx.com',
+     *   given_name: 'xxxxx',
+     *   family_name: 'yyyyy',
+     *   password: '123456',
+     *   password_echo: '123456',
+     *   provider: 'your provider', // FACEBOOK, GOOGLE, SELF
+     *   acceptlanguage: 'your locale' // optional example: de-de, en-US
+     * }, headers).then(function (response) {
+     *   // the response will give you client registration details.
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     *```
      */
     function register(options: UserEntity, headers: {
         requestId: string;
@@ -22,49 +55,121 @@ export declare namespace UserService {
         trackId?: string;
     }): Promise<unknown>;
     /**
-     * get invite info
-     * @param options
-     * @returns
+     * to get information about invitation details, call **getInviteUserDetails()**
+     * @example
+     * ```js
+     * const options = {
+     *   invite_id: 'id of user invitation'
+     * }
+     * cidaas.getInviteUserDetails(options)
+     * .then(function () {
+     *   // the response will give you information about the invitation.
+     * }).catch(function (ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function getInviteUserDetails(options: {
         invite_id: string;
     }): Promise<unknown>;
     /**
-     * get Communication status
-     * @param options
-     * @returns
+     * Once registration successful, verify the account based on the flow. To get the details, call **getCommunicationStatus()**.
+     * @example
+     * ```js
+     * cidaas.getCommunicationStatus({
+     *   sub: 'your sub', // which you will get on the registration response
+     * }).then(function (response) {
+     *   // the response will give you account details once its verified.
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function getCommunicationStatus(options: {
         sub: string;
+    }, headers?: {
         requestId: string;
     }): Promise<unknown>;
     /**
-     * initiate reset password
-     * @param options
-     * @returns
+     * To initiate the password resetting, call **initiateResetPassword()**. This will send verification code to your email or mobile based on the resetMedium you mentioned.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/6b29bac6002f4-initiate-password-reset for more details.
+     * @example
+     * ```js
+     * cidaas.initiateResetPassword({
+     *   email: 'xxxxxx@xxx.com',
+     *   processingType: 'CODE',
+     *   requestId: 'your requestId',
+     *   resetMedium: 'email'
+     * }).then(function (response) {
+     *   // the response will give you password reset details.
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function initiateResetPassword(options: ResetPasswordEntity): Promise<unknown>;
     /**
-     * handle reset password
-     * @param options
+     * To handle the reset password by entering the verification code you received, call **handleResetPassword()**. This will check if your verification code was valid or not, and allows you to proceed to the next step.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/3t8ztokeb7cfz-handle-reset-password for more details.
+     * @example
+     * ```js
+     * const handleResponseAsJson = 'true if the response need to be handled the old way (as json). In the current handling, the response information will be given as query parameter in redirect url.';
+     * cidaas.handleResetPassword({
+     *   code: 'your code in email or sms or ivr',
+     *   resetRequestId: 'your resetRequestId' // which you will get on initiate reset password response
+     * }, handleResponseAsJson).then(function (response) {
+     *   // the response will give you valid verification code.
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
-    function handleResetPassword(options: ValidateResetPasswordEntity): Promise<unknown>;
+    function handleResetPassword(options: ValidateResetPasswordEntity, handleResponseAsJson?: boolean): Promise<unknown>;
     /**
-    * reset password
-    * @param options
-    */
-    function resetPassword(options: AcceptResetPasswordEntity): Promise<unknown>;
+     * To finish reseting the password, call **resetPassword()**. This will allow you to change your password.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/qa9ny0gkzlf6y-accept-reset-password for more details.
+     * @example
+     * ```js
+     * const handleResponseAsJson = 'true if the response need to be handled the old way (as json). In the current handling, user will be redirected to success page after successful reset password.';
+     * cidaas.resetPassword({
+     *   password: '123456',
+     *   confirmPassword: '123456',
+     *   exchangeId: 'your exchangeId', // which you will get on handle reset password response
+     *   resetRequestId: 'your resetRequestId' // which you will get on handle reset password response
+     * }).then(function (response) {
+     *   // the response will give you reset password details.
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
+     */
+    function resetPassword(options: AcceptResetPasswordEntity, handleResponseAsJson?: boolean): Promise<unknown>;
     /**
-     * get Deduplication details
-     * @param options
-     * @returns
+     * To get the list of existing users in deduplication, call **getDeduplicationDetails()**.
+     * @example
+     * ```js
+     * this.cidaas.getDeduplicationDetails({
+     *   track_id: 'your track id'
+     * }).then((response) => {
+     *   // the response will give you deduplication details of users.
+     * }).catch((err) => {
+     *   // your failure code here
+     * });
+     * ```
      */
     function getDeduplicationDetails(options: {
         trackId: string;
     }): Promise<unknown>;
     /**
-     * deduplication login
-     * @param options
+     * To use the existing users in deduplication, you need to call **deduplicationLogin()**.
+     * @example
+     * ```js
+     * this.cidaas.deduplicationLogin({
+     *   sub: 'your sub',
+     *   requestId: 'request id from deduplication initialisation after register',
+     *   trackId: 'track id from deduplication initialisation after register'
+     * })
+     * ```
      */
     function deduplicationLogin(options: {
         trackId: string;
@@ -72,72 +177,165 @@ export declare namespace UserService {
         sub: string;
     }): void;
     /**
-     * register Deduplication
-     * @param options
-     * @returns
+     * To register new user in deduplication, call **registerDeduplication()**.
+     * @example
+     * ```js
+     * this.cidaas.registerDeduplication({
+     *   track_id: 'track id from deduplication initialisation after register',
+     * }).then((response) => {
+     *   // the response will give you new registered deduplication user.
+     * }).catch((err) => {
+     *   // your failure code here
+     * });
+     * ```
      */
     function registerDeduplication(options: {
         trackId: string;
     }): Promise<unknown>;
     /**
-     * change password
-     * @param options
-     * @param access_token
-     * @returns
+     * To change the password, call **changePassword()**. This will allow you to change your password.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/8221883241464-change-password for more details.
+     * @example
+     * ```js
+     * cidaas.changePassword({
+     *   old_password: 'your old password',
+     *   new_password: 'your new password',
+     *   confirm_password: 'your new password',
+     *   sub: 'your sub',
+     * }, 'your access token')
+     * .then(function () {
+     *   // your success code
+     * }).catch(function (ex) {
+     *   // your failure code
+     * });
+     * ```
      */
     function changePassword(options: ChangePasswordEntity, access_token: string): Promise<unknown>;
     /**
-     * update profile
-     * @param options
-     * @param access_token
-     * @param sub
-     * @returns
+     * To update the user profile information, call **updateProfile()**.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/i3uqnxcpxr19r-update-user-profile for more details.
+     * @example
+     * ```js
+     * cidaas.updateProfile({
+     *   family_name: 'Doe',
+     *   given_name: 'John',
+     *   provider: 'self',
+     *   acceptlanguage: 'your locale' // optional example: de-de, en-US
+     * }, 'your access token', 'your sub').then(function () {
+     *   // the response will give you updated user profile info.
+     * }).catch(function (ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function updateProfile(options: UserEntity, access_token: string, sub: string): Promise<unknown>;
     /**
-     * initiate link accoount
-     * @param options
-     * @param access_token
-     * @returns
+     * To initiate account linking, call **initiateLinkAccount()**.
+     * @example
+     * ```js
+     * const options = {
+     *   master_sub: 'sub of the user who initiates the user link',
+     *   user_name_to_link: 'username of the user which should get linked',
+     *   user_name_type: 'type of user name to link. E.g. email'
+     * }
+     * const access_token = 'your access token'
+     * this.cidaas.initiateLinkAccount(options, access_token).then((response) => {
+     *   // your success code
+     * }).catch((err) => {
+     *   // your failure code here
+     * });
+     * ```
      */
     function initiateLinkAccount(options: IUserLinkEntity, access_token: string): Promise<unknown>;
     /**
-     * complete link accoount
-     * @param options
-     * @param access_token
-     * @returns
+     * To complete account linking, call **completeLinkAccount()**.
+     * @example
+     * ```js
+     * const options = {
+     *   code: 'code which is sent to account to be linked',
+     *   link_request_id: 'comes from initiateLinkAccount'
+     * }
+     * const access_token = 'your access token'
+     * this.cidaas.completeLinkAccount(options, access_token).then((response) => {
+     *   // your success code
+     * }).catch((err) => {
+     *   // your failure code here
+     * });
+     * ```
      */
     function completeLinkAccount(options: {
         code?: string;
         link_request_id?: string;
     }, access_token: string): Promise<unknown>;
     /**
-     * get linked users
-     * @param access_token
-     * @param sub
-     * @returns
+     * To get all the linked accounts, call **getLinkedUsers()**.
+     * @example
+     * ```js
+     * const acccess_token= 'your access token';
+     * const sub = 'your sub';
+     *
+     * cidaas.getLinkedUsers(access_token, sub)
+     * .then(function (response) {
+     *   // type your code here
+     * })
+     * .catch(function (ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function getLinkedUsers(access_token: string, sub: string): Promise<unknown>;
     /**
-     * unlink accoount
-     * @param access_token
-     * @param identityId
-     * @returns
+     * To unlink an account for a user, call **unlinkAccount()**.
+     * @example
+     * ```js
+     * const acccess_token= "your access token";
+     * const identityId = "comes from getLinkedUsers";
+     *
+     * cidaas.unlinkAccount(access_token, identityId)
+     * .then(function (response) {
+     *   // type your code here
+     * })
+     * .catch(function (ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function unlinkAccount(access_token: string, identityId: string): Promise<unknown>;
     /**
-     * deleteUserAccount
-     * @param options
-     * @returns
+     * To delete the user account directly in the application, call **deleteUserAccount()**.
+     * Please refer to the api document https://docs.cidaas.com/docs/cidaas-iam/x133xdifl1sx9-schedule-user-deletion for more details.
+     * @example
+     * ```js
+     * options = {
+     *   access_token: "your access token",
+     *   sub: "your sub"
+     * }
+     *
+     * cidaas.deleteUserAccount(options).then(function (response) {
+     *   // your success code
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function deleteUserAccount(options: {
         access_token: string;
         sub: string;
     }): Promise<unknown>;
     /**
-     * check if an user exists from users-actions-srv
-     * @param options
-     * @returns
+     * To check if user exists, call **userCheckExists()**.
+     * @example
+     * options = {
+     *   requestId: "your request id",
+     *   email: "your email"
+     * }
+     *
+     * cidaas.userCheckExists(options).then(function (response) {
+     *   // your success code
+     * }).catch(function(ex) {
+     *   // your failure code here
+     * });
+     * ```
      */
     function userCheckExists(options: FindUserEntity): Promise<unknown>;
 }