cidaas-javascript-sdk 2.4.2 → 2.5.0

package/CHANGELOG.md

@@ -1,6 +1,8 @@
-## [2.4.2](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/compare/v2.4.1...v2.4.2) (2023-04-04)
+# [2.5.0](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/compare/v2.4.3...v2.5.0) (2023-05-03)
 
 
-### Bug Fixes
+### Features
 
-* read tag after release ([e66a657](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/commit/e66a65704f738e0105a6047958f130756cbf99b5))
+* js to ts migration with version update in readme ([2e8ae77](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/commit/2e8ae77f8c521c796f45ba87aadc17c19f2ebca8))
+* typescript migration ([79d875d](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/commit/79d875d5983a35500bc70ee4e7e6f189468966e4))
+* typescript migration ([d84074d](https://gitlab.widas.de/cidaas-public-devkits/cidaas-public-sdks/cidaas-javascript-sdk/commit/d84074def880a2b321dd3a8a1541b1ecec203d16))

package/README.md

@@ -22,9 +22,8 @@ Make sure you have installed all of the following prerequisites on your developm
 From CDN
 
 ```html
-<!-- Release version 2.0.9 -->
-<!-- Minified version -->
-<script src="https://cdn.cidaas.de/javascript/oidc/2.4.2/cidaas-javascript-sdk.min.js"></script>
+<!-- Replace the required <version> in the script tag, example: 3.0.0. All the released tag can be found https://www.npmjs.com/package/cidaas-javascript-sdk?activeTab=versions -->
+<script src="https://cdn.cidaas.de/javascript/oidc/<version>/cidaas-javascript-sdk.min.js"></script>
 ```
 
 From npm

package/package.json

@@ -1,20 +1,19 @@
 {
   "name": "cidaas-javascript-sdk",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "author": "cidaas by Widas ID GmbH",
   "description": "Cidaas native javascript sdk",
   "license": "MIT",
-  "main": "src/main/index.js",
+  "main": "types/main/index.js",
   "types": "types/main/index.d.ts",
   "engine": {
     "node": ">=8.9.10"
   },
   "scripts": {
-    "dev": "webpack --config webpack.dev.js",
-    "build": "npm run build-types && webpack --config webpack.prod.js",
-    "test": "jest --coverage",
-    "test:coverage": "jest --coverage",
-    "build-types": "npx -p typescript tsc src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDir types"
+    "dev": "tsc && webpack --config webpack.dev.js",
+    "build": "tsc && webpack --config webpack.prod.js",
+    "test": "echo 'test'",
+    "test:coverage": "echo 'test coverage'"
   },
   "files": [
     "src",
@@ -28,16 +27,15 @@
   },
   "dependencies": {
     "@fingerprintjs/fingerprintjs": "^3.4.0",
-    "@types/node": "^18.11.18",
+    "@types/crypto-js": "^4.1.1",
     "crypto-js": "^4.1.1",
-    "oidc-client": "^1.11.5"
+    "oidc-client-ts": "^2.2.1"
   },
   "devDependencies": {
-    "compression-webpack-plugin": "^9.0.0",
-    "jest": "27.3.1",
     "terser-webpack-plugin": "^5.2.4",
+    "ts-loader": "^9.4.2",
     "typescript": "^4.5.4",
-    "webpack": "^5.76.2",
+    "webpack": "^5.59.1",
     "webpack-cli": "^4.9.1",
     "webpack-dev-server": "^4.3.1",
     "webpack-hot-middleware": "^2.25.1",

package/src/main/authentication/index.ts

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

package/src/main/global.d.ts

@@ -0,0 +1,10 @@
+/**
+ * all the global variables are declared in this file
+ */
+
+interface Window {
+  webAuthSettings: any;
+  usermanager: any;
+  localeSettings: string;
+  authentication: any;
+}

package/src/main/index.ts

@@ -0,0 +1,6 @@
+import { Authentication } from "./authentication";
+import { WebAuth } from "./web-auth/WebAuth";
+
+const { version: Version } = require('../../package.json');
+
+export { WebAuth, Authentication, Version };

package/src/main/web-auth/ConsentService.ts

@@ -0,0 +1,98 @@
+import { IConsentAcceptEntity } from "./Entities"
+import { Helper } from "./Helper";
+
+export namespace ConsentService {
+  /**
+  * get user consent details
+  * @param options 
+  * @returns 
+  */
+  export function getConsentDetailsV2(options: {
+    consent_id: string;
+    consent_version_id: string;
+    sub: string;
+  }) {
+    var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/v2/consent/usage/public/info";
+    return Helper.createPostPromise(options, _serviceURL, false);
+  };
+
+  /**
+   * accept constn v2
+   * @param options 
+   * @returns 
+   */
+  export function acceptConsentV2(options: IConsentAcceptEntity) {
+    var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/v2/consent/usage/accept";
+    return Helper.createPostPromise(options, _serviceURL, false);
+  };
+
+  /**
+   * get scope consent version details
+   * @param options 
+   * @returns 
+   */
+  export function getScopeConsentVersionDetailsV2(options: {
+    scopeid: string;
+    locale: string;
+    access_token: string;
+  }) {
+    return new Promise((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 ${options.access_token}`);
+        if (window.localeSettings) {
+          http.setRequestHeader("accept-language", window.localeSettings);
+        }
+        http.send();
+      } catch (ex) {
+        reject(ex);
+      }
+    });
+  };
+
+  /**
+   * accept scope Consent
+   * @param options 
+   * @returns 
+   */
+  export function acceptScopeConsent(options: {
+    client_id: string;
+    sub: string;
+    scopes: string[];
+  }) {
+    var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/consent/scope/accept";
+    return Helper.createPostPromise(options, _serviceURL, false);
+  };
+
+  /**
+   * accept claim Consent
+   * @param options 
+   * @returns 
+   */
+  export function acceptClaimConsent(options: { client_id: string; sub: string; accepted_claims: string[]; }) {
+    var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/consent/claim/accept";
+    return Helper.createPostPromise(options, _serviceURL, false);
+  };
+
+  /**
+   * revoke claim Consent
+   * @param options 
+   * @returns 
+   */
+  export function revokeClaimConsent(options: { client_id: string; sub: string; revoked_claims: string[]; }) {
+    var _serviceURL = window.webAuthSettings.authority + "/consent-management-srv/consent/claim/revoke";
+    return Helper.createPostPromise(options, _serviceURL, false);
+  };
+}