supaapps-auth 2.0.0 → 3.0.0

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

@@ -1,30 +0,0 @@
-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/.prettierrc

@@ -1,7 +0,0 @@
-{
-    "semi": true,
-    "trailingComma": "all",
-    "singleQuote": true,
-    "printWidth": 70,
-    "tabWidth": 2
-}

package/dist/AuthManager.d.ts

@@ -1,47 +0,0 @@
-import { AuthManagerEvent, PlatformCheckResponse, UserTokenPayload } from './types';
-export declare class AuthManager {
-    private static instance;
-    private authServer;
-    private realmName;
-    private redirectUri;
-    private onStateChange;
-    private constructor();
-    static initialize(authServer: string, realmName: string, redirectUri: string, onStateChange: (event: AuthManagerEvent) => void): AuthManager;
-    static getInstance(): AuthManager;
-    private tokenToPayload;
-    private toBase64Url;
-    private generatePKCEPair;
-    refreshAccessToken(isInitialization?: boolean): Promise<string>;
-    checkAccessToken(isInitilization?: boolean): Promise<string>;
-    private isTokenExpired;
-    mustBeLoggedIn(): Promise<void>;
-    getLoginWithGoogleUri(): string;
-    isLoggedIn(): Promise<boolean>;
-    getAccessToken(mustBeLoggedIn?: boolean): Promise<string>;
-    platformCheck(email: string): Promise<PlatformCheckResponse>;
-    verifyEmail(email: string, token: string): Promise<boolean>;
-    doPassReset(email: string, token: string, newPassword: string): Promise<boolean>;
-    changeEmail(email: string): Promise<boolean>;
-    initPasswordReset(email: string): Promise<boolean>;
-    /**
-     * Updates user account fields. Only sends fields present in the update object.
-     * For password, expects: { old: string, new: string }
-     */
-    updateAccount(update: {
-        firstName?: string;
-        lastName?: string;
-        email?: string;
-        password?: {
-            old: string;
-            new: string;
-        };
-    }): Promise<boolean>;
-    changePassword(oldPassword: string, newPassword: string, email: string): Promise<boolean>;
-    registerUsingEmail(firstName: string, lastName: string, email: string, password: string): Promise<void>;
-    private saveTokens;
-    loginUsingEmail(email: string, password: string): Promise<void>;
-    loginUsingPkce(code: string): Promise<void>;
-    logout(): Promise<void>;
-    static validateToken(authServer: string, bearerToken: string): Promise<UserTokenPayload>;
-    static resetInstance(): void;
-}

package/dist/AuthManager.js

@@ -1,408 +0,0 @@
-"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 axios_1 = require("axios");
-const crypto_1 = require("crypto");
-const jsonwebtoken_1 = require("jsonwebtoken"); // Ensure jsonwebtoken is correctly imported
-const types_1 = require("./types");
-class AuthManager {
-    constructor(authServer, realmName, redirectUri, onStateChange) {
-        this.authServer = authServer;
-        this.realmName = realmName;
-        this.redirectUri = redirectUri;
-        this.onStateChange = onStateChange;
-        AuthManager.instance = this;
-    }
-    static initialize(authServer, realmName, redirectUri, onStateChange) {
-        if (!AuthManager.instance) {
-            AuthManager.instance = new AuthManager(authServer, realmName, redirectUri, onStateChange);
-            AuthManager.instance
-                .checkAccessToken(true)
-                .then((token) => {
-                onStateChange({
-                    type: types_1.AuthEventType.INITALIZED_IN,
-                    user: AuthManager.instance.tokenToPayload(token),
-                });
-            })
-                .catch(() => {
-                onStateChange({ type: types_1.AuthEventType.INITALIZED_OUT });
-            });
-        }
-        return AuthManager.instance;
-    }
-    static getInstance() {
-        if (!AuthManager.instance) {
-            throw new Error('AuthManager not initialized');
-        }
-        return AuthManager.instance;
-    }
-    tokenToPayload(token) {
-        return JSON.parse(atob(token.split('.')[1]));
-    }
-    toBase64Url(base64String) {
-        return base64String
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=+$/, '');
-    }
-    generatePKCEPair() {
-        var _a, _b;
-        const verifier = (_a = localStorage.getItem('codeVerifier')) !== null && _a !== void 0 ? _a : this.toBase64Url((0, crypto_1.randomBytes)(32).toString('base64'));
-        const challenge = (_b = localStorage.getItem('codeChallenge')) !== null && _b !== void 0 ? _b : this.toBase64Url((0, crypto_1.createHash)('sha256').update(verifier).digest('base64'));
-        localStorage.setItem('codeVerifier', verifier);
-        localStorage.setItem('codeChallenge', challenge);
-        return { verifier, challenge };
-    }
-    refreshAccessToken() {
-        return __awaiter(this, arguments, void 0, function* (isInitialization = false) {
-            try {
-                const refreshToken = localStorage.getItem('refresh_token');
-                if (!refreshToken) {
-                    throw new Error('No refresh token found');
-                }
-                const response = yield axios_1.default.post(`${this.authServer}auth/refresh`, {
-                    refresh_token: refreshToken,
-                });
-                this.saveTokens(response, true);
-                return response.data.access_token;
-            }
-            catch (error) {
-                console.error(`Refresh token error, logging out: ${error}`);
-                localStorage.removeItem('access_token');
-                localStorage.removeItem('refresh_token');
-                if (!isInitialization) {
-                    // throw refresh fail only if not initialization
-                    this.onStateChange({ type: types_1.AuthEventType.REFRESH_FAILED });
-                }
-                throw error;
-            }
-        });
-    }
-    checkAccessToken() {
-        return __awaiter(this, arguments, void 0, function* (isInitilization = false) {
-            const accessToken = localStorage.getItem('access_token');
-            if (accessToken && this.isTokenExpired(accessToken)) {
-                return this.refreshAccessToken(isInitilization);
-            }
-            return accessToken;
-        });
-    }
-    isTokenExpired(token) {
-        const decoded = this.tokenToPayload(token);
-        return decoded.exp < Date.now() / 1000;
-    }
-    mustBeLoggedIn() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(yield this.isLoggedIn())) {
-                this.onStateChange({
-                    type: types_1.AuthEventType.FAILED_MUST_LOGIN_CHECK,
-                });
-            }
-        });
-    }
-    getLoginWithGoogleUri() {
-        const { challenge } = this.generatePKCEPair();
-        return `${this.authServer}auth/login_with_google?realm_name=${this.realmName}&redirect_uri=${encodeURIComponent(this.redirectUri)}&code_challenge=${challenge}&code_challenge_method=S256`;
-    }
-    isLoggedIn() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.checkAccessToken();
-                return true;
-            }
-            catch (error) {
-                return false;
-            }
-        });
-    }
-    getAccessToken() {
-        return __awaiter(this, arguments, void 0, function* (mustBeLoggedIn = false) {
-            try {
-                return yield this.checkAccessToken();
-            }
-            catch (error) {
-                if (mustBeLoggedIn) {
-                    this.onStateChange({
-                        type: types_1.AuthEventType.FAILED_MUST_LOGIN_CHECK,
-                    });
-                }
-                return '';
-            }
-        });
-    }
-    platformCheck(email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.post(`${this.authServer}auth/email/platform_check`, {
-                realm_name: this.realmName,
-                email,
-            });
-            if (response.data.error || response.data.errors) {
-                throw new Error(response.data.error || response.data.message);
-            }
-            return response.status === 200
-                ? response.data
-                : { platforms: [] };
-        });
-    }
-    verifyEmail(email, token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.post(`${this.authServer}auth/email/verify`, {
-                realm_name: this.realmName,
-                email,
-                token,
-            });
-            if (response.data.error || response.data.errors) {
-                throw new Error(response.data.error || response.data.message);
-            }
-            return response.status === 200;
-        });
-    }
-    doPassReset(email, token, newPassword) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.post(`${this.authServer}auth/email/do_pass_reset`, {
-                realm_name: this.realmName,
-                email,
-                token,
-                new_password: newPassword,
-            });
-            if (response.data.error || response.data.errors) {
-                throw new Error(response.data.error || response.data.message);
-            }
-            return response.status === 200;
-        });
-    }
-    changeEmail(email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accessToken = localStorage.getItem('access_token');
-            if (!accessToken) {
-                throw new Error('Access token not found');
-            }
-            const response = yield axios_1.default.post(`${this.authServer}auth/email/change_email`, {
-                realm_name: this.realmName,
-                email,
-            }, {
-                headers: { Authorization: `Bearer ${accessToken}` },
-            });
-            if (response.data.error || response.data.errors) {
-                throw new Error(response.data.error || response.data.message);
-            }
-            return response.status === 200;
-        });
-    }
-    initPasswordReset(email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.post(`${this.authServer}auth/email/init_pass_reset`, {
-                realm_name: this.realmName,
-                email,
-            });
-            if (response.data.error || response.data.errors) {
-                throw new Error(response.data.error || response.data.message);
-            }
-            return response.status === 200 || response.status === 201;
-        });
-    }
-    /**
-     * Updates user account fields. Only sends fields present in the update object.
-     * For password, expects: { old: string, new: string }
-     */
-    updateAccount(update) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accessToken = localStorage.getItem('access_token');
-            if (!accessToken) {
-                throw new Error('Access token not found');
-            }
-            // Update name
-            if (update.firstName || update.lastName) {
-                const response = yield axios_1.default.post(`${this.authServer}auth/email/update_profile`, Object.assign(Object.assign({ realm_name: this.realmName }, (update.firstName && { first_name: update.firstName })), (update.lastName && { last_name: update.lastName })), {
-                    headers: { Authorization: `Bearer ${accessToken}` },
-                });
-                if (response.data.error || response.data.errors) {
-                    throw new Error(response.data.error || response.data.message);
-                }
-            }
-            // Update email
-            if (update.email) {
-                const response = yield axios_1.default.post(`${this.authServer}auth/email/change_email`, {
-                    realm_name: this.realmName,
-                    email: update.email,
-                }, {
-                    headers: { Authorization: `Bearer ${accessToken}` },
-                });
-                if (response.data.error || response.data.errors) {
-                    throw new Error(response.data.error || response.data.message);
-                }
-            }
-            // Update password
-            if (update.password && update.email) {
-                const response = yield axios_1.default.post(`${this.authServer}auth/email/change_pass`, {
-                    realm_name: this.realmName,
-                    email: update.email,
-                    old_password: update.password.old,
-                    new_password: update.password.new,
-                }, {
-                    headers: { Authorization: `Bearer ${accessToken}` },
-                });
-                if (response.data.error || response.data.errors) {
-                    throw new Error(response.data.error || response.data.message);
-                }
-            }
-            else if (update.password && !update.email) {
-                throw new Error('Email is required to change password');
-            }
-            return true;
-        });
-    }
-    changePassword(oldPassword, newPassword, email) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accessToken = localStorage.getItem('access_token');
-            if (!accessToken) {
-                throw new Error('Access token not found');
-            }
-            const response = yield axios_1.default.post(`${this.authServer}auth/email/change_pass`, {
-                realm_name: this.realmName,
-                email,
-                old_password: oldPassword,
-                new_password: newPassword,
-            }, {
-                headers: { Authorization: `Bearer ${accessToken}` },
-            });
-            if (response.data.error || response.data.errors) {
-                throw new Error(response.data.error || response.data.message);
-            }
-            return response.status === 200;
-        });
-    }
-    registerUsingEmail(firstName, lastName, email, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.post(`${this.authServer}auth/email/register`, {
-                realm_name: this.realmName,
-                first_name: firstName,
-                last_name: lastName,
-                email,
-                password,
-            });
-            if (response.data.message || response.data.error) {
-                throw new Error(response.data.message || response.data.error);
-            }
-            if (!response.data.access_token) {
-                throw new Error('Something went wrong');
-            }
-            this.saveTokens(response, false);
-        });
-    }
-    saveTokens(response, byRefresh) {
-        localStorage.setItem('access_token', response.data.access_token);
-        localStorage.setItem('refresh_token', response.data.refresh_token);
-        this.onStateChange({
-            type: byRefresh
-                ? types_1.AuthEventType.USER_UPDATED
-                : types_1.AuthEventType.USER_LOGGED_IN,
-            user: this.tokenToPayload(response.data.access_token),
-        });
-        const user = this.tokenToPayload(response.data.access_token);
-        localStorage.setItem('user', JSON.stringify(user));
-    }
-    loginUsingEmail(email, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.post(`${this.authServer}auth/email/login`, {
-                realm_name: this.realmName,
-                email,
-                password,
-            });
-            if (response.data.message || response.data.error) {
-                throw new Error(response.data.message || response.data.error);
-            }
-            this.saveTokens(response, false);
-        });
-    }
-    loginUsingPkce(code) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const codeVerifier = localStorage.getItem('codeVerifier');
-                if (!codeVerifier) {
-                    throw new Error('Code verifier not found');
-                }
-                const response = yield axios_1.default.post(`${this.authServer}auth/pkce_exchange`, {
-                    realm_name: this.realmName,
-                    code,
-                    redirect_uri: this.redirectUri,
-                    code_verifier: codeVerifier,
-                });
-                this.saveTokens(response, false);
-            }
-            finally {
-                localStorage.removeItem('codeVerifier');
-                localStorage.removeItem('codeChallenge');
-            }
-        });
-    }
-    logout() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const accessToken = localStorage.getItem('access_token');
-                if (!accessToken) {
-                    throw new Error('Access token not found');
-                }
-                yield axios_1.default.post(`${this.authServer}auth/logout`, {}, {
-                    headers: { Authorization: `Bearer ${accessToken}` },
-                });
-            }
-            finally {
-                localStorage.removeItem('access_token');
-                localStorage.removeItem('refresh_token');
-                this.onStateChange({ type: types_1.AuthEventType.USER_LOGGED_OUT });
-            }
-        });
-    }
-    static validateToken(authServer, bearerToken) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // @todo tests missing for this static validation
-            // @todo add caching for public key and algo
-            const decodedToken = (_a = (0, jsonwebtoken_1.decode)(bearerToken, {
-                complete: true,
-            })) === null || _a === void 0 ? void 0 : _a.payload;
-            if (!decodedToken) {
-                throw new Error('Not a valid jwt token');
-            }
-            const userToken = {
-                id: decodedToken.id,
-                iss: decodedToken.iss,
-                sub: typeof decodedToken.sub === 'string'
-                    ? parseInt(decodedToken.sub)
-                    : decodedToken.sub,
-                first_name: decodedToken.first_name,
-                last_name: decodedToken.last_name,
-                email: decodedToken.email,
-                aud: decodedToken.aud,
-                iat: decodedToken.iat,
-                exp: decodedToken.exp,
-                scopes: decodedToken.scopes,
-                realm: decodedToken.realm,
-                provider: decodedToken.provider,
-            };
-            const { data: publicKey } = yield axios_1.default.get(`${authServer}public/public_key`);
-            const { data: algo } = yield axios_1.default.get(`${authServer}public/algo`);
-            (0, jsonwebtoken_1.verify)(bearerToken, publicKey, { algorithms: [algo] });
-            const { data: revokedIds } = yield axios_1.default.get(`${authServer}public/revoked_ids`);
-            if (revokedIds.includes(decodedToken.id)) {
-                throw new Error('Token is revoked');
-            }
-            return userToken;
-        });
-    }
-    static resetInstance() {
-        AuthManager.instance = null;
-    }
-}
-exports.AuthManager = AuthManager;
-AuthManager.instance = null;

package/dist/types.d.ts

@@ -1,40 +0,0 @@
-export declare enum AuthEventType {
-    INITALIZED_IN = "initialized-logged-in",
-    INITALIZED_OUT = "initialized-logged-out",
-    USER_LOGGED_IN = "user-logged-in",
-    USER_LOGGED_OUT = "user-logged-out",
-    USER_UPDATED = "user-updated",
-    FAILED_MUST_LOGIN_CHECK = "failed-must-login",
-    REFRESH_FAILED = "refresh-failed"
-}
-export interface UserTokenPayload {
-    id: number;
-    iss: string;
-    sub: number | string;
-    first_name: string;
-    last_name: string;
-    email: string;
-    aud: string;
-    iat: number;
-    exp: number;
-    scopes: string;
-    realm: string;
-    provider: Platforms;
-}
-export interface AuthManagerEvent {
-    type: AuthEventType;
-    user?: UserTokenPayload;
-}
-export interface PlatformCheckResponse {
-    platform: Platforms[];
-}
-export declare enum Platforms {
-    PASSWORD = "password",
-    GOOGLE = "google",
-    FACEBOOK = "facebook",
-    TWITTER = "twitter",
-    GITHUB = "github",
-    APPLE = "apple",
-    LINKEDIN = "linkedin",
-    MICROSOFT = "microsoft"
-}

package/dist/types.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Platforms = exports.AuthEventType = void 0;
-var AuthEventType;
-(function (AuthEventType) {
-    AuthEventType["INITALIZED_IN"] = "initialized-logged-in";
-    AuthEventType["INITALIZED_OUT"] = "initialized-logged-out";
-    AuthEventType["USER_LOGGED_IN"] = "user-logged-in";
-    AuthEventType["USER_LOGGED_OUT"] = "user-logged-out";
-    AuthEventType["USER_UPDATED"] = "user-updated";
-    AuthEventType["FAILED_MUST_LOGIN_CHECK"] = "failed-must-login";
-    AuthEventType["REFRESH_FAILED"] = "refresh-failed";
-})(AuthEventType || (exports.AuthEventType = AuthEventType = {}));
-var Platforms;
-(function (Platforms) {
-    Platforms["PASSWORD"] = "password";
-    Platforms["GOOGLE"] = "google";
-    Platforms["FACEBOOK"] = "facebook";
-    Platforms["TWITTER"] = "twitter";
-    Platforms["GITHUB"] = "github";
-    Platforms["APPLE"] = "apple";
-    Platforms["LINKEDIN"] = "linkedin";
-    Platforms["MICROSOFT"] = "microsoft";
-})(Platforms || (exports.Platforms = Platforms = {}));

package/jest.config.js

@@ -1,16 +0,0 @@
-module.exports = {
-    testEnvironment: 'jsdom',  // Use jsdom environment to run tests
-    roots: ['<rootDir>/tests'],
-    testMatch: ['**/*.test.ts'],  // Matches test files in the tests directory
-    transform: {
-      '^.+\\.tsx?$': 'ts-jest',  // Transform TypeScript files using ts-jest
-    },
-    setupFilesAfterEnv: ['jest-localstorage-mock'],  // Setup local storage mock for all tests
-    testEnvironment: 'node',  // Use node environment to run tests,
-    collectCoverage: true,
-    coverageReporters: [
-        "text",
-        "cobertura"
-    ]
-  };
-