supaapps-auth 1.0.5 → 1.1.0

package/README.md

@@ -0,0 +1,74 @@
+# TODO
+
+
+`npm i supaapps-auth`
+
+
+- Initialize
+```ts
+        new AuthManager(
+            'https://supaapps-auth-api.testing.sacl.io/',
+            'root',
+            'http://localhost:3001/exchange',
+            () => {
+                // redirect to login
+            }
+        );
+```
+
+
+- Require login
+
+```ts
+import {AuthManager} from "./AuthManager";
+
+const authManager = AuthManager.getInstance();
+authManager.mustBeLoggedIn().then((isLoggedIn) => {
+    if (isLoggedIn) {
+        // do something
+    }
+});
+
+// or 
+
+AuthManager.getInstance().mustBeLoggedIn();
+```
+
+
+- Get user info
+
+```ts
+authManager.mustBeLoggedIn().then(
+            (isLoggedIn) => {
+                isLoggedIn && authManager.getAccessToken().then(
+                    (token) => {
+                        const decodedToken = JSON.parse(atob(token.split('.')[1]));
+                        // access info for example 
+                        // decodedToken.first_name
+                    }
+                );
+            }
+        )
+```
+
+
+
+Get login uri
+
+```ts
+AuthManager.getInstance().getLoginWithGoogleUri()
+```
+
+- Validate access token
+
+```typescript
+import { AuthManager } from './AuthManager';
+
+const isValid = await AuthManager.validateToken(BEARER_HEADER_OR_ACCESS_TOKEN)
+// or
+AuthManager.validateToken(BEARER_OR_ACCESS_TOKEN).then((isValid) => {
+  if (isValid) {
+    // token is valid
+  }
+})
+```

package/dist/AuthManager.d.ts

@@ -8,9 +8,10 @@ export declare class AuthManager {
     static getInstance<T>(): AuthManager;
     private toBase64Url;
     private generatePKCEPair;
-    mustBeLoggedIn(): Promise<void>;
+    mustBeLoggedIn(): Promise<boolean>;
     getLoginWithGoogleUri(): string;
     isLoggedIn(): Promise<boolean>;
     getAccessToken(): Promise<string>;
     loginUsingPkce(code: any): Promise<void>;
+    static validateToken(authServer: string, bearerToken: string): Promise<boolean>;
 }

package/dist/AuthManager.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthManager = void 0;
+const axios_1 = require("axios");
 const crypto_1 = require("crypto");
 class AuthManager {
     constructor(authServer, realmName, redirectUri, loginCallback) {
@@ -49,9 +50,15 @@ class AuthManager {
     }
     mustBeLoggedIn() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!(yield this.isLoggedIn())) {
-                this.loginCallback();
-            }
+            return new Promise((resolve, reject) => {
+                this.isLoggedIn().then((isLoggedIn) => {
+                    if (!isLoggedIn) {
+                        this.loginCallback();
+                        return resolve(false);
+                    }
+                    return resolve(true);
+                });
+            });
         });
     }
     getLoginWithGoogleUri() {
@@ -165,6 +172,40 @@ class AuthManager {
             });
         });
     }
+    static validateToken(authServer, bearerToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accessToken = bearerToken.includes('Bearer ') ? bearerToken.replace('Bearer ', '') : bearerToken;
+                    const decodedToken = accessToken ? JSON.parse(atob(accessToken.split('.')[1])) : null;
+                    if (!decodedToken) {
+                        return resolve(false);
+                    }
+                    const currentTime = Date.now() / 1000;
+                    if (decodedToken.exp < currentTime) {
+                        return resolve(false);
+                    }
+                    const { data: publicKey } = yield axios_1.default.get(`${authServer}public/public_key`);
+                    const { data: algo } = yield axios_1.default.get(`${authServer}public/algo`);
+                    const jwt = require('jsonwebtoken');
+                    jwt.verify(accessToken, publicKey, { algorithms: [algo] }, (error, payload) => {
+                        if (error) {
+                            return resolve(false);
+                        }
+                        axios_1.default.get(`${authServer}public/revoked_ids`).then(({ data: revokedIds }) => {
+                            if (revokedIds && revokedIds.includes(decodedToken['id'])) {
+                                return resolve(false);
+                            }
+                            return resolve(true);
+                        });
+                    });
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }));
+        });
+    }
 }
 exports.AuthManager = AuthManager;
 AuthManager.instance = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supaapps-auth",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,8 @@
   "license": "MIT",
   "dependencies": {
     "axios": "^1.6.7",
-    "crypto": "^1.0.1"
+    "crypto": "^1.0.1",
+    "jsonwebtoken": "^9.0.2"
   },
   "devDependencies": {
     "@types/node": "^20.11.10",

package/src/AuthManager.ts

@@ -28,9 +28,9 @@ export class AuthManager {
 
     private  toBase64Url = (base64String: string) => {
         return base64String
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=+$/, '');
+          .replace(/\+/g, '-')
+          .replace(/\//g, '_')
+          .replace(/=+$/, '');
     };
     private  generatePKCEPair = () => {
         const NUM_OF_BYTES = 32; // This will generate a verifier of sufficient length
@@ -38,23 +38,30 @@ export class AuthManager {
 
         // Generate code verifier
         const newCodeVerifier = this.toBase64Url(
-            randomBytes(NUM_OF_BYTES).toString('base64'),
+          randomBytes(NUM_OF_BYTES).toString('base64'),
         );
 
         // Generate code challenge
         const hash = createHash(HASH_ALG)
-            .update(newCodeVerifier)
-            .digest('base64');
+          .update(newCodeVerifier)
+          .digest('base64');
         const newCodeChallenge = this.toBase64Url(hash);
 
         return { newCodeVerifier, newCodeChallenge };
     };
 
-    public async mustBeLoggedIn(): Promise<void> {
-        if (!await this.isLoggedIn()) {
-            this.loginCallback();
-        }
+    public async mustBeLoggedIn(): Promise<boolean> {
+        return new Promise((resolve, reject) => {
+            this.isLoggedIn().then((isLoggedIn) => {
+                if (!isLoggedIn) {
+                    this.loginCallback();
+                    return resolve(false);
+                }
+                return resolve(true);
+            });
+        });
     }
+
     public getLoginWithGoogleUri(): string {
         // get or create codeVerifier and codeChallenge from localstorage
         const { newCodeVerifier, newCodeChallenge } = this.generatePKCEPair();
@@ -65,7 +72,7 @@ export class AuthManager {
 
         if (this.authServer && this.realmName && this.redirectUri) {
             return  `${this.authServer}auth/login_with_google?realm_name=${this.realmName}` +
-                `&redirect_uri=${encodeURIComponent(this.redirectUri)}&code_challenge=${codeChallenge}&code_challenge_method=S256`
+              `&redirect_uri=${encodeURIComponent(this.redirectUri)}&code_challenge=${codeChallenge}&code_challenge_method=S256`
         }
     }
     public async isLoggedIn(): Promise<boolean> {
@@ -138,24 +145,24 @@ export class AuthManager {
                             code_verifier: codeVerifier,
                         }),
                     })
-                        .then((response) => {
-                            localStorage.removeItem('codeVerifier');
-                            localStorage.removeItem('codeChallenge');
-                            if (response.status !== 200) {
-                                throw new Error('Failed to exchange code for token');
-                            }
-                            return response.json();
-                        })
-                        .then((exchangeJson) => {
-                            localStorage.setItem('access_token', exchangeJson.access_token);
-                            localStorage.setItem('refresh_token', exchangeJson.refresh_token);
-                            resolve();
-                        })
-                        .catch((error) => {
-                            localStorage.removeItem('codeVerifier');
-                            localStorage.removeItem('codeChallenge');
-                            reject(error);
-                        });
+                      .then((response) => {
+                          localStorage.removeItem('codeVerifier');
+                          localStorage.removeItem('codeChallenge');
+                          if (response.status !== 200) {
+                              throw new Error('Failed to exchange code for token');
+                          }
+                          return response.json();
+                      })
+                      .then((exchangeJson) => {
+                          localStorage.setItem('access_token', exchangeJson.access_token);
+                          localStorage.setItem('refresh_token', exchangeJson.refresh_token);
+                          resolve();
+                      })
+                      .catch((error) => {
+                          localStorage.removeItem('codeVerifier');
+                          localStorage.removeItem('codeChallenge');
+                          reject(error);
+                      });
                 }
             } catch (error) {
                 reject(error);
@@ -163,4 +170,38 @@ export class AuthManager {
         });
     }
 
+    public static async validateToken(authServer: string, bearerToken: string): Promise<boolean> {
+        return new Promise<boolean>(async (resolve, reject) => {
+            try {
+                const accessToken = bearerToken.includes('Bearer ') ? bearerToken.replace('Bearer ', '') : bearerToken;
+                const decodedToken = accessToken ? JSON.parse(atob(accessToken.split('.')[1])) : null;
+
+                if (!decodedToken) {
+                    return resolve(false);
+                }
+
+                const currentTime = Date.now() / 1000;
+                if (decodedToken.exp < currentTime) {
+                    return resolve(false);
+                }
+
+                const { data: publicKey } = await axios.get(`${authServer}public/public_key`);
+                const { data: algo } = await axios.get(`${authServer}public/algo`);
+                const jwt = require('jsonwebtoken');
+                jwt.verify(accessToken, publicKey, { algorithms: [algo] }, (error, payload) => {
+                    if (error) {
+                        return resolve(false);
+                    }
+                    axios.get(`${authServer}public/revoked_ids`).then(({ data: revokedIds }) => {
+                        if (revokedIds && (revokedIds as number[]).includes(decodedToken['id'])) {
+                            return resolve(false);
+                        }
+                        return resolve(true);
+                    });
+                });
+            } catch (error) {
+                reject(error);
+            }
+        })
+    }
 }