cidaas-javascript-sdk 2.4.3 → 2.5.1

package/types/authentication/index.d.ts

@@ -0,0 +1,55 @@
+import { UserManager, UserManagerSettings } from "oidc-client-ts";
+export declare class Authentication {
+    webAuthSettings: UserManagerSettings;
+    userManager: UserManager;
+    constructor(webAuthSettings: UserManagerSettings, userManager: UserManager);
+    /**
+     * redirect sign in
+     * @param view_type
+     */
+    redirectSignIn(view_type: string): void;
+    /**
+     * redirect sign in callback
+     * @returns
+     */
+    redirectSignInCallback(): Promise<unknown>;
+    /**
+     * redirect sign out
+     * @returns
+     */
+    redirectSignOut(): Promise<unknown>;
+    /**
+     * redirect sign out callback
+     * @returns
+     */
+    redirectSignOutCallback(): Promise<unknown>;
+    /**
+     * pop up sign in
+     */
+    popupSignIn(): void;
+    /**
+     * pop up sign in callback
+     */
+    popupSignInCallback(): void;
+    /**
+     * pop up sign out
+     */
+    popupSignOut(): void;
+    /**
+     * silent sign in
+     */
+    silentSignIn(): void;
+    /**
+     * silent sign in callback
+     */
+    silentSignInCallback(): void;
+    /**
+     * silent sign in callback v2
+     * @returns
+     */
+    silentSignInCallbackV2(): Promise<unknown>;
+    /**
+     * silent sign out callback
+     */
+    popupSignOutCallback(): void;
+}

package/types/authentication/index.js

@@ -0,0 +1,262 @@
+"use strict";
+exports.__esModule = true;
+exports.Authentication = void 0;
+var Authentication = /** @class */ (function () {
+    function Authentication(webAuthSettings, userManager) {
+        this.webAuthSettings = webAuthSettings;
+        this.userManager = userManager;
+    }
+    /**
+     * redirect sign in
+     * @param view_type
+     */
+    Authentication.prototype.redirectSignIn = function (view_type) {
+        try {
+            if (this.userManager) {
+                if (this.webAuthSettings) {
+                    if (!this.webAuthSettings.extraQueryParams) {
+                        this.webAuthSettings.extraQueryParams = {};
+                    }
+                    this.webAuthSettings.extraQueryParams.view_type = view_type;
+                    if (this.webAuthSettings.scope) {
+                        if (this.webAuthSettings.response_type.indexOf("id_token") == -1 && this.webAuthSettings.scope.indexOf("openid") != -1 && !this.webAuthSettings.extraQueryParams.nonce) {
+                            this.webAuthSettings.extraQueryParams.nonce = new Date().getTime().toString();
+                        }
+                    }
+                }
+                this.userManager.signinRedirect({
+                    extraQueryParams: this.webAuthSettings.extraQueryParams,
+                    redirect_uri: this.webAuthSettings.redirect_uri
+                }).then(function () {
+                    console.log("Redirect logged in using cidaas sdk");
+                });
+            }
+            else {
+                throw "user manager is null";
+            }
+        }
+        catch (ex) {
+            console.log("user manager instance is empty : " + ex);
+        }
+    };
+    ;
+    /**
+     * redirect sign in callback
+     * @returns
+     */
+    Authentication.prototype.redirectSignInCallback = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                if (_this.userManager) {
+                    _this.userManager.signinRedirectCallback(_this.webAuthSettings.redirect_uri)
+                        .then(function (user) {
+                        if (user) {
+                            resolve(user);
+                            return;
+                        }
+                        resolve(undefined);
+                    });
+                }
+                else {
+                    throw "user manager is null";
+                }
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    };
+    /**
+     * redirect sign out
+     * @returns
+     */
+    Authentication.prototype.redirectSignOut = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                if (_this.userManager && _this.webAuthSettings) {
+                    _this.userManager.signoutRedirect({
+                        state: _this.webAuthSettings
+                    }).then(function (resp) {
+                        console.log('signed out', resp);
+                        window.authentication.redirectSignOutCallback().then(function (resp) {
+                            resolve(resp);
+                        });
+                    });
+                }
+                else {
+                    throw "user manager or settings is null";
+                }
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    };
+    ;
+    /**
+     * redirect sign out callback
+     * @returns
+     */
+    Authentication.prototype.redirectSignOutCallback = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                if (_this.userManager) {
+                    _this.userManager.signoutRedirectCallback().then(function (resp) {
+                        console.log("Signed out");
+                        resolve(resp);
+                    });
+                }
+                else {
+                    resolve(undefined);
+                    throw "user manager is null";
+                }
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    };
+    ;
+    /**
+     * pop up sign in
+     */
+    Authentication.prototype.popupSignIn = function () {
+        try {
+            if (this.userManager && this.webAuthSettings) {
+                this.userManager.signinPopup().then(function () {
+                    console.log("signed in");
+                });
+            }
+            else {
+                throw "user manager or settings is null";
+            }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
+    };
+    ;
+    /**
+     * pop up sign in callback
+     */
+    Authentication.prototype.popupSignInCallback = function () {
+        try {
+            if (this.userManager) {
+                this.userManager.signinPopupCallback();
+            }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
+    };
+    ;
+    /**
+     * pop up sign out
+     */
+    Authentication.prototype.popupSignOut = function () {
+        try {
+            if (this.userManager && this.webAuthSettings) {
+                this.userManager.signoutPopup({
+                    state: this.webAuthSettings
+                }).then(function (resp) {
+                    console.log('signed out', resp);
+                });
+            }
+            else {
+                throw "user manager or settings is null";
+            }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
+    };
+    ;
+    /**
+     * silent sign in
+     */
+    Authentication.prototype.silentSignIn = function () {
+        try {
+            if (this.userManager && this.webAuthSettings) {
+                this.userManager.signinSilent({
+                    state: this.webAuthSettings
+                }).then(function (user) {
+                    console.log("signed in : " + user.access_token);
+                });
+            }
+            else {
+                throw "user manager is null";
+            }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
+    };
+    ;
+    /**
+     * silent sign in callback
+     */
+    Authentication.prototype.silentSignInCallback = function () {
+        try {
+            if (this.userManager) {
+                this.userManager.signinSilentCallback();
+            }
+            else {
+                throw "user manager is null";
+            }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
+    };
+    ;
+    /**
+     * silent sign in callback v2
+     * @returns
+     */
+    Authentication.prototype.silentSignInCallbackV2 = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                if (_this.userManager) {
+                    _this.userManager.signinSilentCallback(_this.webAuthSettings.silent_redirect_uri)
+                        .then(function (user) {
+                        if (user) {
+                            resolve(user);
+                            return;
+                        }
+                        resolve(undefined);
+                    });
+                }
+                else {
+                    throw "user manager is null";
+                }
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    };
+    ;
+    /**
+     * silent sign out callback
+     */
+    Authentication.prototype.popupSignOutCallback = function () {
+        try {
+            if (this.userManager) {
+                this.userManager.signoutPopupCallback(this.webAuthSettings.post_logout_redirect_uri, true);
+            }
+            else {
+                throw "user manager is null";
+            }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
+    };
+    ;
+    return Authentication;
+}());
+exports.Authentication = Authentication;

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import { Authentication } from "./authentication";
+import { WebAuth } from "./web-auth/WebAuth";
+declare const Version: any;
+export { WebAuth, Authentication, Version };

package/types/index.js

@@ -0,0 +1,9 @@
+"use strict";
+exports.__esModule = true;
+exports.Version = exports.Authentication = exports.WebAuth = void 0;
+var authentication_1 = require("./authentication");
+exports.Authentication = authentication_1.Authentication;
+var WebAuth_1 = require("./web-auth/WebAuth");
+exports.WebAuth = WebAuth_1.WebAuth;
+var Version = require('../../package.json').version;
+exports.Version = Version;

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

@@ -0,0 +1,59 @@
+import { IConsentAcceptEntity } from "./Entities";
+export declare namespace ConsentService {
+    /**
+    * get user consent details
+    * @param options
+    * @returns
+    */
+    function getConsentDetailsV2(options: {
+        consent_id: string;
+        consent_version_id: string;
+        sub: string;
+    }): Promise<unknown>;
+    /**
+     * accept constn v2
+     * @param options
+     * @returns
+     */
+    function acceptConsentV2(options: IConsentAcceptEntity): Promise<unknown>;
+    /**
+     * get scope consent version details
+     * @param options
+     * @returns
+     */
+    function getScopeConsentVersionDetailsV2(options: {
+        scopeid: string;
+        locale: string;
+        access_token: string;
+    }): Promise<unknown>;
+    /**
+     * accept scope Consent
+     * @param options
+     * @returns
+     */
+    function acceptScopeConsent(options: {
+        client_id: string;
+        sub: string;
+        scopes: string[];
+    }): Promise<unknown>;
+    /**
+     * accept claim Consent
+     * @param options
+     * @returns
+     */
+    function acceptClaimConsent(options: {
+        client_id: string;
+        sub: string;
+        accepted_claims: string[];
+    }): Promise<unknown>;
+    /**
+     * revoke claim Consent
+     * @param options
+     * @returns
+     */
+    function revokeClaimConsent(options: {
+        client_id: string;
+        sub: string;
+        revoked_claims: string[];
+    }): Promise<unknown>;
+}

package/types/web-auth/ConsentService.js

@@ -0,0 +1,97 @@
+"use strict";
+exports.__esModule = true;
+exports.ConsentService = void 0;
+var Helper_1 = require("./Helper");
+var ConsentService;
+(function (ConsentService) {
+    /**
+    * get user consent details
+    * @param options
+    * @returns
+    */
+    function getConsentDetailsV2(options) {
+        var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/v2/consent/usage/public/info";
+        return Helper_1.Helper.createPostPromise(options, _serviceURL, false);
+    }
+    ConsentService.getConsentDetailsV2 = getConsentDetailsV2;
+    ;
+    /**
+     * accept constn v2
+     * @param options
+     * @returns
+     */
+    function acceptConsentV2(options) {
+        var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/v2/consent/usage/accept";
+        return Helper_1.Helper.createPostPromise(options, _serviceURL, false);
+    }
+    ConsentService.acceptConsentV2 = acceptConsentV2;
+    ;
+    /**
+     * get scope consent version details
+     * @param options
+     * @returns
+     */
+    function getScopeConsentVersionDetailsV2(options) {
+        return new Promise(function (resolve, reject) {
+            try {
+                var http = new XMLHttpRequest();
+                var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/v2/consent/versions/details/" + options.scopeid + "?locale=" + 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");
+                http.setRequestHeader("Authorization", "Bearer ".concat(options.access_token));
+                if (window.localeSettings) {
+                    http.setRequestHeader("accept-language", window.localeSettings);
+                }
+                http.send();
+            }
+            catch (ex) {
+                reject(ex);
+            }
+        });
+    }
+    ConsentService.getScopeConsentVersionDetailsV2 = getScopeConsentVersionDetailsV2;
+    ;
+    /**
+     * accept scope Consent
+     * @param options
+     * @returns
+     */
+    function acceptScopeConsent(options) {
+        var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/consent/scope/accept";
+        return Helper_1.Helper.createPostPromise(options, _serviceURL, false);
+    }
+    ConsentService.acceptScopeConsent = acceptScopeConsent;
+    ;
+    /**
+     * accept claim Consent
+     * @param options
+     * @returns
+     */
+    function acceptClaimConsent(options) {
+        var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/consent/claim/accept";
+        return Helper_1.Helper.createPostPromise(options, _serviceURL, false);
+    }
+    ConsentService.acceptClaimConsent = acceptClaimConsent;
+    ;
+    /**
+     * revoke claim Consent
+     * @param options
+     * @returns
+     */
+    function revokeClaimConsent(options) {
+        var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/consent/claim/revoke";
+        return Helper_1.Helper.createPostPromise(options, _serviceURL, false);
+    }
+    ConsentService.revokeClaimConsent = revokeClaimConsent;
+    ;
+})(ConsentService = exports.ConsentService || (exports.ConsentService = {}));