supaapps-auth 2.0.0-rc.1 → 2.0.0-rc.10

package/dist/AuthManager.d.ts

@@ -1,4 +1,4 @@
-import { AuthManagerEvent } from './types';
+import { AuthManagerEvent, Platforms, UserTokenPayload } from './types';
 export declare class AuthManager {
     private static instance;
     private authServer;
@@ -11,16 +11,24 @@ export declare class AuthManager {
     private tokenToPayload;
     private toBase64Url;
     private generatePKCEPair;
-    refreshAccessToken(): Promise<string>;
-    checkAccessToken(): Promise<string>;
+    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<Array<Platforms>>;
+    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>;
+    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<boolean>;
+    static validateToken(authServer: string, bearerToken: string): Promise<UserTokenPayload>;
     static resetInstance(): void;
 }

package/dist/AuthManager.js

@@ -25,18 +25,18 @@ class AuthManager {
     static initialize(authServer, realmName, redirectUri, onStateChange) {
         if (!AuthManager.instance) {
             AuthManager.instance = new AuthManager(authServer, realmName, redirectUri, onStateChange);
-        }
-        AuthManager.instance
-            .checkAccessToken()
-            .then((token) => {
-            onStateChange({
-                type: types_1.AuthEventType.INITALIZED_IN,
-                user: AuthManager.instance.tokenToPayload(token),
+            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 });
             });
-        })
-            .catch(() => {
-            onStateChange({ type: types_1.AuthEventType.INITALIZED_OUT });
-        });
+        }
         return AuthManager.instance;
     }
     static getInstance() {
@@ -63,7 +63,7 @@ class AuthManager {
         return { verifier, challenge };
     }
     refreshAccessToken() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (isInitialization = false) {
             try {
                 const refreshToken = localStorage.getItem('refresh_token');
                 if (!refreshToken) {
@@ -79,16 +79,19 @@ class AuthManager {
                 console.error(`Refresh token error, logging out: ${error}`);
                 localStorage.removeItem('access_token');
                 localStorage.removeItem('refresh_token');
-                this.onStateChange({ type: types_1.AuthEventType.REFRESH_FAILED });
+                if (!isInitialization) {
+                    // throw refresh fail only if not initialization
+                    this.onStateChange({ type: types_1.AuthEventType.REFRESH_FAILED });
+                }
                 throw error;
             }
         });
     }
     checkAccessToken() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (isInitilization = false) {
             const accessToken = localStorage.getItem('access_token');
-            if (accessToken || this.isTokenExpired(accessToken)) {
-                return this.refreshAccessToken();
+            if (accessToken && this.isTokenExpired(accessToken)) {
+                return this.refreshAccessToken(isInitilization);
             }
             return accessToken;
         });
@@ -136,6 +139,113 @@ class AuthManager {
             }
         });
     }
+    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;
+        });
+    }
+    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);
@@ -146,6 +256,19 @@ class AuthManager {
         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 {
@@ -189,23 +312,34 @@ class AuthManager {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             // @todo tests missing for this static validation
-            try {
-                const decodedToken = (_a = (0, jsonwebtoken_1.decode)(bearerToken, {
-                    complete: true,
-                })) === null || _a === void 0 ? void 0 : _a.payload;
-                if (!decodedToken) {
-                    return false;
-                }
-                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`);
-                // eslint-disable-next-line @typescript-eslint/dot-notation
-                return !revokedIds.includes(decodedToken['id']);
+            // @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');
             }
-            catch (error) {
-                return false;
+            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,
+            };
+            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() {

package/dist/types.d.ts

@@ -10,7 +10,7 @@ export declare enum AuthEventType {
 export interface UserTokenPayload {
     id: number;
     iss: string;
-    sub: number;
+    sub: number | string;
     first_name: string;
     last_name: string;
     email: string;
@@ -18,8 +18,19 @@ export interface UserTokenPayload {
     iat: number;
     exp: number;
     scopes: string;
+    realm: string;
 }
 export interface AuthManagerEvent {
     type: AuthEventType;
     user?: UserTokenPayload;
 }
+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,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthEventType = void 0;
+exports.Platforms = exports.AuthEventType = void 0;
 var AuthEventType;
 (function (AuthEventType) {
     AuthEventType["INITALIZED_IN"] = "initialized-logged-in";
@@ -11,3 +11,14 @@ var AuthEventType;
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supaapps-auth",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.10",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,7 +25,7 @@
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
     "axios-mock-adapter": "^1.22.0",
-    "eslint": "^8.57.0",
+    "eslint": "^8.57.1",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-airbnb-typescript": "^17.1.0",
     "eslint-config-next": "^13.5.6",

package/src/AuthManager.ts

@@ -4,7 +4,7 @@ import {
   decode as jwtDecode,
   verify as jwtVerify,
 } from 'jsonwebtoken'; // Ensure jsonwebtoken is correctly imported
-import { AuthEventType, AuthManagerEvent, UserTokenPayload } from './types';
+import {AuthEventType, AuthManagerEvent, Platforms, UserTokenPayload} from './types';
 
 export class AuthManager {
   private static instance: AuthManager | null = null;
@@ -43,9 +43,8 @@ export class AuthManager {
         redirectUri,
         onStateChange,
       );
-    }
-    AuthManager.instance
-      .checkAccessToken()
+      AuthManager.instance
+      .checkAccessToken(true)
       .then((token) => {
         onStateChange({
           type: AuthEventType.INITALIZED_IN,
@@ -55,6 +54,7 @@ export class AuthManager {
       .catch(() => {
         onStateChange({ type: AuthEventType.INITALIZED_OUT });
       });
+    }
     return AuthManager.instance;
   }
 
@@ -95,7 +95,7 @@ export class AuthManager {
     return { verifier, challenge };
   }
 
-  public async refreshAccessToken(): Promise<string> {
+  public async refreshAccessToken(isInitialization: boolean = false): Promise<string> {
     try {
       const refreshToken = localStorage.getItem('refresh_token');
       if (!refreshToken) {
@@ -114,15 +114,18 @@ export class AuthManager {
       console.error(`Refresh token error, logging out: ${error}`);
       localStorage.removeItem('access_token');
       localStorage.removeItem('refresh_token');
-      this.onStateChange({ type: AuthEventType.REFRESH_FAILED });
+      if (!isInitialization) {
+        // throw refresh fail only if not initialization
+        this.onStateChange({ type: AuthEventType.REFRESH_FAILED });
+      }
       throw error;
     }
   }
 
-  public async checkAccessToken(): Promise<string> {
+  public async checkAccessToken(isInitilization: boolean = false): Promise<string> {
     const accessToken = localStorage.getItem('access_token');
-    if (accessToken || this.isTokenExpired(accessToken)) {
-      return this.refreshAccessToken();
+    if (accessToken && this.isTokenExpired(accessToken)) {
+      return this.refreshAccessToken(isInitilization);
     }
     return accessToken;
   }
@@ -167,6 +170,143 @@ export class AuthManager {
     }
   }
 
+
+  public async platformCheck(email: string): Promise<Array<Platforms>> {
+    const response = await axios.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': []};
+  }
+
+  public async verifyEmail(email: string, token: string): Promise<boolean> {
+    const response = await axios.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;
+  }
+
+  public async doPassReset(email: string, token: string, newPassword: string): Promise<boolean> {
+    const response = await axios.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;
+  }
+
+  public async changeEmail(email: string): Promise<boolean> {
+    const accessToken = localStorage.getItem('access_token');
+    if (!accessToken) {
+      throw new Error('Access token not found');
+    }
+    const response = await axios.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;
+  }
+
+  public async initPasswordReset(email: string): Promise<boolean> {
+    const response = await axios.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;
+  }
+
+  public async changePassword(oldPassword: string, newPassword: string, email: string): Promise<boolean> {
+    const accessToken = localStorage.getItem('access_token');
+    if (!accessToken) {
+      throw new Error('Access token not found');
+    }
+    const response = await axios.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;
+  }
+
+  public async registerUsingEmail(
+      firstName: string,
+      lastName: string,
+      email: string,
+      password: string
+  ): Promise<void> {
+    const response = await axios.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);
+  }
+
   private saveTokens(response: AxiosResponse, byRefresh: boolean): void {
     localStorage.setItem('access_token', response.data.access_token);
     localStorage.setItem(
@@ -181,6 +321,21 @@ export class AuthManager {
     localStorage.setItem('user', JSON.stringify(user));
   }
 
+  public async loginUsingEmail(email: string, password: string): Promise<void> {
+    const response = await axios.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);
+  }
+
   public async loginUsingPkce(code: string): Promise<void> {
     try {
       const codeVerifier = localStorage.getItem('codeVerifier');
@@ -227,34 +382,47 @@ export class AuthManager {
   public static async validateToken(
     authServer: string,
     bearerToken: string,
-  ): Promise<boolean> {
+  ): Promise<UserTokenPayload> {
     // @todo tests missing for this static validation
-    try {
-      const decodedToken = jwtDecode(bearerToken, {
-        complete: true,
-      })?.payload;
+    // @todo add caching for public key and algo
+    const decodedToken = jwtDecode(bearerToken, {
+      complete: true,
+    })?.payload as unknown as UserTokenPayload;
 
-      if (!decodedToken) {
-        return false;
-      }
+    if (!decodedToken) {
+      throw new Error('Not a valid jwt token');
+    }
 
-      const { data: publicKey } = await axios.get(
-        `${authServer}public/public_key`,
-      );
-      const { data: algo } = await axios.get(
-        `${authServer}public/algo`,
-      );
+    const userToken: UserTokenPayload = {
+        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,
+    }
 
-      jwtVerify(bearerToken, publicKey, { algorithms: [algo] });
+    const { data: publicKey } = await axios.get(
+      `${authServer}public/public_key`,
+    );
+    const { data: algo } = await axios.get(
+      `${authServer}public/algo`,
+    );
 
-      const { data: revokedIds } = await axios.get(
-        `${authServer}public/revoked_ids`,
-      );
-      // eslint-disable-next-line @typescript-eslint/dot-notation
-      return !revokedIds.includes(decodedToken['id']);
-    } catch (error) {
-      return false;
+    jwtVerify(bearerToken, publicKey, { algorithms: [algo] });
+
+    const { data: revokedIds } = await axios.get(
+      `${authServer}public/revoked_ids`,
+    );
+    if(revokedIds.includes(decodedToken.id)){
+      throw new Error('Token is revoked');
     }
+    return userToken;
   }
 
   public static resetInstance(): void {

package/src/types.ts

@@ -12,7 +12,7 @@ export enum AuthEventType {
 export interface UserTokenPayload {
     id: number;
     iss: string;
-    sub: number;
+    sub: number | string;
     first_name: string;
     last_name: string;
     email: string;
@@ -20,9 +20,21 @@ export interface UserTokenPayload {
     iat: number;
     exp: number;
     scopes: string;
+    realm: string;
 }
 
 export interface AuthManagerEvent {
     type:  AuthEventType;
     user?: UserTokenPayload;
 }
+
+export enum Platforms {
+    PASSWORD = 'password',
+    GOOGLE = 'google',
+    FACEBOOK = 'facebook',
+    TWITTER = 'twitter',
+    GITHUB = 'github',
+    APPLE = 'apple',
+    LINKEDIN = 'linkedin',
+    MICROSOFT = 'microsoft',
+}

package/tests/AuthManager.test.ts

@@ -12,7 +12,12 @@ const tokenThatWontExpire2 = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxM
 const tokenThatExpired = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwiZmlyc3RfbmFtZSI6IkpvaG4gRG9lIiwibGFzdF9uYW1lIjoiRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJzY29wZXMiOiIvcm9vdC8qIiwiZXhwIjo1MDAsImlkIjoyLCJpc3MiOjEyMywiYXVkIjoidGVzdGluZyJ9.ungpbhHfCM5ZP5oiZ1RnMkJ-NKJI8s3_IPJptjyKHR4';
 
 
+
+
 describe('AuthManager Tests', () => {
+    beforeAll(() => {
+      jest.spyOn(localStorage, 'getItem');
+    });
 
     beforeEach(() => {
         localStorage.clear();  // Clear localStorage before each test
@@ -72,6 +77,26 @@ describe('AuthManager Tests', () => {
     });
   
 
+    describe('AuthManager Tests isolated ', () => {
+      it('doesn\'t refresh access token when its not expired', async () => {
+        const stateChange = jest.fn();
+        
+
+        // check that we set localstorage correct
+        localStorage.setItem('access_token', tokenThatWontExpire1);
+        localStorage.setItem('refresh_token', 'mockRefreshToken');
+    
+        const manager = AuthManager.initialize('http://auth-server.com/', 'example-realm', 'http://myapp.com/callback', stateChange);
+
+        const currentCallCount = (localStorage.getItem as jest.Mock).mock.calls.length;
+
+        const token = await manager.getAccessToken();
+    
+        expect(localStorage.getItem).toHaveBeenCalledTimes(currentCallCount + 1);
+    
+      });
+    });
+    
     it('throws an error when no refresh token is found', async () => {
       localStorage.removeItem('refresh_token');
 
@@ -125,4 +150,4 @@ describe('AuthManager Tests', () => {
 
   
   
-});
+});