cidaas-javascript-sdk 3.1.2 → 3.1.4

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-## [3.1.2](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/compare/v3.1.1...v3.1.2) (2023-09-05)
+## [3.1.4](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/compare/v3.1.3...v3.1.4) (2023-09-06)
 
 
 ### Bug Fixes
 
-* semantic release format ([e73ccc3](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/commit/e73ccc377ad14bdf7de3e89c91dca0b3d1c0c1d1))
+* update ci ([6bb80e0](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/commit/6bb80e01aed3cd92a18303d0bf4ea74d29e8d9f6))

package/README.md

@@ -2613,4 +2613,3 @@ The SDK will throws Custom Exception if something went wrong during the operatio
 |----------------- | ----------------------- |
 |  500 | during creation of WebAuth instance |
 |  417 | if there are any other failure |
- 

package/dist/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/{src/main/authentication/index.ts → dist/authentication/index.js}

@@ -1,14 +1,16 @@
-import { UserManager, UserManagerSettings } from "oidc-client-ts";
-
-export class Authentication {
-
-    constructor(public webAuthSettings: UserManagerSettings, public userManager: UserManager) { }
-
+"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 
+     * @param view_type
      */
-    redirectSignIn(view_type: string) {
+    Authentication.prototype.redirectSignIn = function (view_type) {
         try {
             if (this.userManager) {
                 if (this.webAuthSettings) {
@@ -28,196 +30,233 @@ export class Authentication {
                 }).then(function () {
                     console.log("Redirect logged in using cidaas sdk");
                 });
-            } else {
+            }
+            else {
                 throw "user manager is null";
             }
-        } catch (ex) {
+        }
+        catch (ex) {
             console.log("user manager instance is empty : " + ex);
         }
     };
-
+    ;
     /**
      * redirect sign in callback
-     * @returns 
+     * @returns
      */
-    redirectSignInCallback() {
-        return new Promise((resolve, reject) => {
+    Authentication.prototype.redirectSignInCallback = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
             try {
-                if (this.userManager) {
-                    this.userManager.signinRedirectCallback()
-                        .then(function (user: any) {
-                            if (user) {
-                                resolve(user);
-                                return;
-                            }
-                            resolve(undefined);
-                        });
-                } else {
+                if (_this.userManager) {
+                    _this.userManager.signinRedirectCallback()
+                        .then(function (user) {
+                        if (user) {
+                            resolve(user);
+                            return;
+                        }
+                        resolve(undefined);
+                    });
+                }
+                else {
                     throw "user manager is null";
                 }
-            } catch (ex) {
+            }
+            catch (ex) {
                 reject(ex);
             }
         });
-    }
-
+    };
     /**
      * redirect sign out
-     * @returns 
+     * @returns
      */
-    redirectSignOut() {
-        return new Promise((resolve, reject) => {
+    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: any) {
+                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: any) {
+                        window.authentication.redirectSignOutCallback().then(function (resp) {
                             resolve(resp);
                         });
                     });
-                } else {
+                }
+                else {
                     throw "user manager or settings is null";
                 }
-            } catch (ex) {
+            }
+            catch (ex) {
                 reject(ex);
             }
         });
     };
-
+    ;
     /**
      * redirect sign out callback
-     * @returns 
+     * @returns
      */
-    redirectSignOutCallback() {
-        return new Promise((resolve, reject) => {
+    Authentication.prototype.redirectSignOutCallback = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
             try {
-                if (this.userManager) {
-                    this.userManager.signoutRedirectCallback().then(function (resp: any) {
+                if (_this.userManager) {
+                    _this.userManager.signoutRedirectCallback().then(function (resp) {
                         console.log("Signed out");
                         resolve(resp);
                     });
-                } else {
+                }
+                else {
                     resolve(undefined);
                     throw "user manager is null";
                 }
-            } catch (ex) {
+            }
+            catch (ex) {
                 reject(ex);
             }
         });
     };
-
+    ;
     /**
      * pop up sign in
      */
-    popupSignIn() {
+    Authentication.prototype.popupSignIn = function () {
         try {
             if (this.userManager && this.webAuthSettings) {
                 this.userManager.signinPopup().then(function () {
                     console.log("signed in");
                 });
-            } else {
+            }
+            else {
                 throw "user manager or settings is null";
             }
-        } catch (ex) { console.error(ex) }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
     };
-
+    ;
     /**
      * pop up sign in callback
      */
-    popupSignInCallback() {
+    Authentication.prototype.popupSignInCallback = function () {
         try {
             if (this.userManager) {
                 this.userManager.signinPopupCallback();
             }
-        } catch (ex) { console.error(ex) }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
     };
-
+    ;
     /**
      * pop up sign out
      */
-    popupSignOut() {
+    Authentication.prototype.popupSignOut = function () {
         try {
             if (this.userManager && this.webAuthSettings) {
                 this.userManager.signoutPopup({
                     state: this.webAuthSettings
-                }).then(function (resp: any) {
+                }).then(function (resp) {
                     console.log('signed out', resp);
                 });
-            } else {
+            }
+            else {
                 throw "user manager or settings is null";
             }
-        } catch (ex) { console.error(ex) }
-
+        }
+        catch (ex) {
+            console.error(ex);
+        }
     };
-
+    ;
     /**
      * silent sign in
      */
-    silentSignIn() {
+    Authentication.prototype.silentSignIn = function () {
         try {
             if (this.userManager && this.webAuthSettings) {
                 this.userManager.signinSilent({
                     state: this.webAuthSettings
-                }).then(function (user: any) {
+                }).then(function (user) {
                     console.log("signed in : " + user.access_token);
                 });
-            } else {
+            }
+            else {
                 throw "user manager is null";
             }
-        } catch (ex) { console.error(ex) }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
     };
-
+    ;
     /**
      * silent sign in callback
      */
-    silentSignInCallback() {
+    Authentication.prototype.silentSignInCallback = function () {
         try {
             if (this.userManager) {
                 this.userManager.signinSilentCallback();
-            } else {
+            }
+            else {
                 throw "user manager is null";
             }
-        } catch (ex) { console.error(ex) }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
     };
-
+    ;
     /**
      * silent sign in callback v2
-     * @returns 
+     * @returns
      */
-    silentSignInCallbackV2() {
-        return new Promise((resolve, reject) => {
+    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: any) {
-                            if (user) {
-                                resolve(user);
-                                return;
-                            }
-                            resolve(undefined);
-                        });
-                } else {
+                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) {
+            }
+            catch (ex) {
                 reject(ex);
             }
         });
-
     };
-
+    ;
     /**
      * silent sign out callback
      */
-    popupSignOutCallback() {
+    Authentication.prototype.popupSignOutCallback = function () {
         try {
             if (this.userManager) {
                 this.userManager.signoutPopupCallback(this.webAuthSettings.post_logout_redirect_uri, true);
-            } else {
+            }
+            else {
                 throw "user manager is null";
             }
-        } catch (ex) { console.error(ex) }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
     };
-}
+    ;
+    return Authentication;
+}());
+exports.Authentication = Authentication;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { Authentication } from "./authentication";
+import { WebAuth } from "./web-auth/WebAuth";
+export { WebAuth, Authentication };

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+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;

package/dist/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/dist/web-auth/ConsentService.js

@@ -0,0 +1,73 @@
+"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, "POST");
+    }
+    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, "POST");
+    }
+    ConsentService.acceptConsentV2 = acceptConsentV2;
+    ;
+    /**
+     * get scope consent version details
+     * @param options
+     * @returns
+     */
+    function getScopeConsentVersionDetailsV2(options) {
+        var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/v2/consent/versions/details/" + options.scopeid + "?locale=" + options.locale;
+        return Helper_1.Helper.createPostPromise(undefined, _serviceURL, false, "GET", options.access_token);
+    }
+    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, "POST");
+    }
+    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, "POST");
+    }
+    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, "POST");
+    }
+    ConsentService.revokeClaimConsent = revokeClaimConsent;
+    ;
+})(ConsentService = exports.ConsentService || (exports.ConsentService = {}));