supaapps-auth 1.0.0

package/.github/workflows/publish-to-npm.yml

@@ -0,0 +1,30 @@
+name: Publish to NPM
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+            node-version: lts/*
+            registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish to npm
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Notice:  While this software is open-source under the MIT License, the "Supaapps" name, branding, and logo are proprietary and copyrighted by Supaapps GmbH. Any use, reproduction, or distribution of the "Supaapps" brand assets without explicit permission is strictly prohibited.
+
+Copyright (c) 2023 Supaapps GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/AuthManager.d.ts

@@ -0,0 +1,14 @@
+export declare class AuthManager {
+    private static instance;
+    private readonly authServer;
+    private readonly realmName;
+    private readonly redirectUri;
+    private constructor();
+    static getInstance<T>(): AuthManager;
+    private toBase64Url;
+    private generatePKCEPair;
+    getLoginWithGoogleUri(): string;
+    isLoggedIn(): Promise<boolean>;
+    getAccessToken(): Promise<string>;
+    loginUsingPkce(code: any): Promise<void>;
+}

package/dist/AuthManager.js

@@ -0,0 +1,153 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthManager = void 0;
+const crypto_1 = require("crypto");
+class AuthManager {
+    constructor(authServer, realmName, redirectUri) {
+        this.authServer = null;
+        this.realmName = null;
+        this.redirectUri = null;
+        this.toBase64Url = (base64String) => {
+            return base64String
+                .replace(/\+/g, '-')
+                .replace(/\//g, '_')
+                .replace(/=+$/, '');
+        };
+        this.generatePKCEPair = () => {
+            const NUM_OF_BYTES = 32; // This will generate a verifier of sufficient length
+            const HASH_ALG = 'sha256';
+            // Generate code verifier
+            const codeVerifier = this.toBase64Url((0, crypto_1.randomBytes)(NUM_OF_BYTES).toString('base64'));
+            // Generate code challenge
+            const hash = (0, crypto_1.createHash)(HASH_ALG)
+                .update(codeVerifier)
+                .digest('base64');
+            const codeChallenge = this.toBase64Url(hash);
+            return { codeVerifier, codeChallenge };
+        };
+        this.authServer = authServer;
+        this.realmName = realmName;
+        this.redirectUri = redirectUri;
+    }
+    static getInstance() {
+        if (!AuthManager.instance) {
+            throw new Error('AuthManager not initialized');
+        }
+        return AuthManager.instance;
+    }
+    getLoginWithGoogleUri() {
+        const { codeVerifier, codeChallenge } = this.generatePKCEPair();
+        localStorage.setItem('codeVerifier', codeVerifier);
+        localStorage.setItem('codeChallenge', codeChallenge);
+        if (this.authServer && this.realmName && this.redirectUri) {
+            return `${this.authServer}auth/login_with_google?realm_name=${this.realmName}` +
+                `&redirect_uri=${encodeURIComponent(this.realmName)}&code_challenge=${codeChallenge}&code_challenge_method=S256`;
+        }
+    }
+    isLoggedIn() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // todo here: check if refresh token is expired and if so, try to refresh, then update token
+            return new Promise((resolve, reject) => {
+                try {
+                    const accessToken = localStorage.getItem('access_token');
+                    if (!accessToken) {
+                        return resolve(false);
+                    }
+                    // decode access token and check if it's expired
+                    const decodedToken = accessToken ? JSON.parse(atob(accessToken.split('.')[1])) : null;
+                    if (decodedToken) {
+                        const currentTime = Date.now() / 1000;
+                        if (decodedToken.exp < currentTime) {
+                            // add refresh check here instead and
+                            localStorage.removeItem('access_token');
+                            return resolve(false);
+                        }
+                    }
+                    return resolve(true);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // todo here: check if refresh token is expired and if so, try to refresh, then update token
+            // otherwise throw error
+            return new Promise((resolve, reject) => {
+                try {
+                    const accessToken = localStorage.getItem('access_token');
+                    if (!accessToken) {
+                        throw new Error('No access token found');
+                    }
+                    // decode access token and check if it's expired
+                    const decodedToken = accessToken ? JSON.parse(atob(accessToken.split('.')[1])) : null;
+                    if (decodedToken) {
+                        const currentTime = Date.now() / 1000;
+                        if (decodedToken.exp < currentTime) {
+                            // add refresh check here instead and
+                            localStorage.removeItem('access_token');
+                            throw new Error('Access token expired');
+                        }
+                    }
+                    return resolve(accessToken);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    loginUsingPkce(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    const codeVerifier = localStorage.getItem('codeVerifier');
+                    if (codeVerifier) {
+                        fetch(`${this.authServer}auth/pkce_exchange`, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                            body: JSON.stringify({
+                                realm_name: this.realmName,
+                                code: code,
+                                redirect_uri: this.redirectUri,
+                                code_verifier: codeVerifier,
+                            }),
+                        })
+                            .then((response) => {
+                            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) => {
+                            reject(error);
+                        });
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+}
+exports.AuthManager = AuthManager;
+AuthManager.instance = null;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { AuthManager } from './AuthManager';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthManager = void 0;
+var AuthManager_1 = require("./AuthManager");
+Object.defineProperty(exports, "AuthManager", { enumerable: true, get: function () { return AuthManager_1.AuthManager; } });

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "supaapps-auth",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.7",
+    "crypto": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.10",
+    "typescript": "^5.3.3"
+  }
+}

package/src/AuthManager.ts

@@ -0,0 +1,149 @@
+import axios from 'axios';
+import { createHash, randomBytes } from 'crypto';
+
+
+export class AuthManager {
+    private static instance: AuthManager | null = null;
+    private readonly authServer: string | null = null;
+
+    private readonly realmName: string | null = null;
+
+    private readonly redirectUri: string | null = null;
+    private constructor(authServer: string, realmName: string, redirectUri: string) {
+        this.authServer = authServer;
+        this.realmName = realmName;
+        this.redirectUri = redirectUri;
+    }
+
+    public static getInstance<T>(): AuthManager{
+        if (!AuthManager.instance) {
+            throw new Error('AuthManager not initialized');
+        }
+        return AuthManager.instance;
+    }
+
+    private  toBase64Url = (base64String: string) => {
+        return base64String
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    };
+    private  generatePKCEPair = () => {
+        const NUM_OF_BYTES = 32; // This will generate a verifier of sufficient length
+        const HASH_ALG = 'sha256';
+
+        // Generate code verifier
+        const codeVerifier = this.toBase64Url(
+            randomBytes(NUM_OF_BYTES).toString('base64'),
+        );
+
+        // Generate code challenge
+        const hash = createHash(HASH_ALG)
+            .update(codeVerifier)
+            .digest('base64');
+        const codeChallenge = this.toBase64Url(hash);
+
+        return { codeVerifier, codeChallenge };
+    };
+    public getLoginWithGoogleUri(): string {
+        const { codeVerifier, codeChallenge } = this.generatePKCEPair();
+        localStorage.setItem('codeVerifier', codeVerifier);
+        localStorage.setItem('codeChallenge', codeChallenge);
+
+        if (this.authServer && this.realmName && this.redirectUri) {
+            return  `${this.authServer}auth/login_with_google?realm_name=${this.realmName}` +
+                `&redirect_uri=${encodeURIComponent(this.realmName )}&code_challenge=${codeChallenge}&code_challenge_method=S256`
+        }
+    }
+    public async isLoggedIn(): Promise<boolean> {
+        // todo here: check if refresh token is expired and if so, try to refresh, then update token
+        return new Promise((resolve, reject) => {
+            try {
+                const accessToken: string | null = localStorage.getItem('access_token');
+                if (!accessToken) {
+                    return resolve(false);
+                }
+                // decode access token and check if it's expired
+                const decodedToken = accessToken ? JSON.parse(atob(accessToken.split('.')[1])) : null;
+                if (decodedToken) {
+                    const currentTime = Date.now() / 1000;
+                    if (decodedToken.exp < currentTime) {
+                        // add refresh check here instead and
+                        localStorage.removeItem('access_token');
+                        return resolve(false);
+                    }
+                }
+
+                return resolve(true);
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    public async getAccessToken(): Promise<string> {
+        // todo here: check if refresh token is expired and if so, try to refresh, then update token
+        // otherwise throw error
+        return new Promise((resolve, reject) => {
+            try {
+                const accessToken: string | null = localStorage.getItem('access_token');
+                if (!accessToken) {
+                    throw new Error('No access token found');
+                }
+                // decode access token and check if it's expired
+                const decodedToken = accessToken ? JSON.parse(atob(accessToken.split('.')[1])) : null;
+                if (decodedToken) {
+                    const currentTime = Date.now() / 1000;
+                    if (decodedToken.exp < currentTime) {
+                        // add refresh check here instead and
+                        localStorage.removeItem('access_token');
+                        throw new Error('Access token expired');
+                    }
+                }
+
+                return resolve(accessToken);
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    public async loginUsingPkce(code): Promise<void> {
+        return new Promise((resolve, reject) => {
+            try {
+                const codeVerifier = localStorage.getItem('codeVerifier');
+                if (codeVerifier) {
+                    fetch(`${this.authServer}auth/pkce_exchange`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({
+                            realm_name: this.realmName,
+                            code: code,
+                            redirect_uri: this.redirectUri,
+                            code_verifier: codeVerifier,
+                        }),
+                    })
+                        .then((response) => {
+                            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) => {
+                            reject(error);
+                        });
+                }
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { AuthManager } from './AuthManager';

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+      "outDir": "./dist",
+      "declaration": true,
+      "module": "commonjs",
+      "target": "ES6"
+  },
+  "include": ["src/**/*.ts"]
+}