@smess/networking 1.0.15 → 1.0.16

package/dist/services/auth.service.d.ts

@@ -4,6 +4,7 @@ import { BehaviorSubject, Observable } from "rxjs";
 export interface AuthLoginRequest {
     identifier: string;
     password: string;
+    rememberMe?: boolean;
 }
 export interface ForgotPasswordRequest {
     identifier: string;
@@ -45,9 +46,15 @@ export interface AuthServiceType {
 }
 export declare class AuthService implements AuthServiceType {
     private readonly config;
-    readonly $authToken: BehaviorSubject<string | null>;
+    private readonly $_authToken;
     constructor(config: NetworkingConfig);
+    get $authToken(): BehaviorSubject<string | null>;
     get currentAuthToken(): string | null;
+    private getValidToken;
+    private loadFromStorage;
+    private loadAuthFromStorage;
+    private saveAuthToStorage;
+    private clearAuthFromStorage;
     provider(target: AuthTarget): SmessService<AuthProvider>;
     login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
     logout(): Observable<NetworkingUIEventWrapped<void>>;

package/dist/services/auth.service.js

@@ -1,6 +1,9 @@
 import { Accept, SMESSHeader, SmessService } from "./smess.service";
 import { BehaviorSubject } from "rxjs";
 import { tap } from "rxjs/operators";
+// LocalStorage keys for auth persistence
+const AUTH_TOKEN_KEY = 'smess_auth_token';
+const AUTH_RESPONSE_KEY = 'smess_auth_response';
 export class AuthProvider {
     constructor(config, target, $authToken) {
         this.config = config;
@@ -68,11 +71,88 @@ export class AuthProvider {
 export class AuthService {
     constructor(config) {
         this.config = config;
-        this.$authToken = new BehaviorSubject(null);
+        this.$_authToken = new BehaviorSubject(null);
+        this.loadAuthFromStorage();
+    }
+    // Getter that returns BehaviorSubject with token validation
+    get $authToken() {
+        const currentToken = this.getValidToken();
+        if (currentToken !== this.$_authToken.value) {
+            this.$_authToken.next(currentToken);
+        }
+        return this.$_authToken;
     }
     // Get current auth token value
     get currentAuthToken() {
-        return this.$authToken.value;
+        return this.getValidToken();
+    }
+    // Get valid token from memory or localStorage
+    getValidToken() {
+        // If we have a token in memory, return it (assume it's valid)
+        if (this.$_authToken.value) {
+            return this.$_authToken.value;
+        }
+        // Otherwise, try to load from localStorage
+        return this.loadFromStorage();
+    }
+    // Load token from localStorage and check expiration
+    loadFromStorage() {
+        try {
+            const storedResponse = localStorage.getItem(AUTH_RESPONSE_KEY);
+            const storedAt = localStorage.getItem(`${AUTH_RESPONSE_KEY}_stored_at`);
+            if (storedResponse && storedAt) {
+                const authResponse = JSON.parse(storedResponse);
+                const storedTime = parseInt(storedAt, 10);
+                // Check if token is expired
+                if (authResponse.expires_in && typeof authResponse.expires_in === 'number') {
+                    const expirationTime = storedTime + (authResponse.expires_in * 1000);
+                    if (Date.now() >= expirationTime) {
+                        // Token expired, clear storage
+                        this.clearAuthFromStorage();
+                        return null;
+                    }
+                }
+                // Token is valid, store in memory and return
+                const token = String(authResponse.token);
+                this.$_authToken.next(token);
+                return token;
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load token from localStorage:', error);
+            this.clearAuthFromStorage();
+        }
+        return null;
+    }
+    // Load auth token from localStorage on initialization
+    loadAuthFromStorage() {
+        this.loadFromStorage();
+    }
+    // Save auth response to localStorage
+    saveAuthToStorage(authResponse) {
+        try {
+            localStorage.setItem(AUTH_TOKEN_KEY, String(authResponse.token));
+            localStorage.setItem(AUTH_RESPONSE_KEY, JSON.stringify(authResponse));
+            localStorage.setItem(`${AUTH_RESPONSE_KEY}_stored_at`, Date.now().toString());
+            // Update memory
+            this.$_authToken.next(String(authResponse.token));
+        }
+        catch (error) {
+            console.warn('Failed to save auth to localStorage:', error);
+        }
+    }
+    // Clear auth from localStorage
+    clearAuthFromStorage() {
+        try {
+            localStorage.removeItem(AUTH_TOKEN_KEY);
+            localStorage.removeItem(AUTH_RESPONSE_KEY);
+            localStorage.removeItem(`${AUTH_RESPONSE_KEY}_stored_at`);
+            // Clear memory
+            this.$_authToken.next(null);
+        }
+        catch (error) {
+            console.warn('Failed to clear auth from localStorage:', error);
+        }
     }
     provider(target) {
         const targetWrapper = new AuthProvider(this.config, target, this.$authToken);
@@ -84,7 +164,11 @@ export class AuthService {
             .pipe(tap((result) => {
             if (result.hasSuccess && result.response?.token) {
                 // Set the auth token when login is successful
-                this.$authToken.next(String(result.response.token));
+                this.$_authToken.next(String(result.response.token));
+                // Save to localStorage if rememberMe is true
+                if (payload.rememberMe && result.response) {
+                    this.saveAuthToStorage(result.response);
+                }
             }
         }));
     }
@@ -93,8 +177,8 @@ export class AuthService {
             .request()
             .pipe(tap((result) => {
             if (result.hasSuccess) {
-                // Clear the auth token when logout is successful
-                this.$authToken.next(null);
+                // Clear from localStorage (this will also clear memory)
+                this.clearAuthFromStorage();
             }
         }));
     }

package/dist/services/auth.service.test.js

@@ -1,3 +1,6 @@
+/**
+ * @jest-environment jsdom
+ */
 import { AuthService, } from "./auth.service";
 import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
 import { of } from "rxjs";
@@ -9,7 +12,18 @@ describe("AuthService", () => {
         apiKey: "test-api-key",
     };
     let service;
+    let mockLocalStorage;
     beforeEach(() => {
+        // Mock localStorage for all tests
+        mockLocalStorage = {
+            setItem: jest.fn(),
+            getItem: jest.fn(),
+            removeItem: jest.fn(),
+        };
+        Object.defineProperty(window, 'localStorage', {
+            value: mockLocalStorage,
+            writable: true,
+        });
         service = new AuthService(config);
     });
     it("login success", async () => {
@@ -39,6 +53,55 @@ describe("AuthService", () => {
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
+    it("login success with rememberMe", async () => {
+        const payload = {
+            identifier: "user",
+            password: "pass",
+            rememberMe: true
+        };
+        const response = {
+            token_type: "Bearer",
+            expires_in: 3600,
+            token: "token",
+            refresh_token: "refresh",
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.login(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+        // Verify that auth token is set after successful login
+        expect(service.currentAuthToken).toBe("token");
+        expect(service.$authToken.value).toBe("token");
+        // Verify that localStorage was called to save the auth data
+        expect(mockLocalStorage.setItem).toHaveBeenCalledWith('smess_auth_token', 'token');
+        expect(mockLocalStorage.setItem).toHaveBeenCalledWith('smess_auth_response', JSON.stringify(response));
+    });
+    it("login success without rememberMe", async () => {
+        const payload = {
+            identifier: "user",
+            password: "pass",
+            rememberMe: false
+        };
+        const response = {
+            token_type: "Bearer",
+            expires_in: 3600,
+            token: "token",
+            refresh_token: "refresh",
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.login(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+        // Verify that auth token is set after successful login
+        expect(service.currentAuthToken).toBe("token");
+        expect(service.$authToken.value).toBe("token");
+        // Verify that localStorage was NOT called to save the auth data
+        expect(mockLocalStorage.setItem).not.toHaveBeenCalled();
+    });
     it("logout success", async () => {
         // First set a token to test clearing it
         service.$authToken.next("test-token");
@@ -51,6 +114,132 @@ describe("AuthService", () => {
         // Verify that auth token is cleared after successful logout
         expect(service.currentAuthToken).toBe(null);
         expect(service.$authToken.value).toBe(null);
+        // Verify that localStorage was cleared
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_token');
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_response');
+    });
+    it("loads auth token from localStorage on initialization", () => {
+        // Mock localStorage to return a stored auth response
+        const storedResponse = {
+            token_type: "Bearer",
+            expires_in: 3600,
+            token: "stored-token",
+            refresh_token: "refresh",
+        };
+        const mockLocalStorage = {
+            setItem: jest.fn(),
+            getItem: jest.fn().mockImplementation((key) => {
+                if (key === 'smess_auth_response') {
+                    return JSON.stringify(storedResponse);
+                }
+                if (key === 'smess_auth_response_stored_at') {
+                    return Date.now().toString();
+                }
+                return null;
+            }),
+            removeItem: jest.fn(),
+        };
+        Object.defineProperty(window, 'localStorage', {
+            value: mockLocalStorage,
+            writable: true,
+        });
+        // Create a new service instance
+        const newService = new AuthService(config);
+        // Verify that the stored token was loaded
+        expect(newService.currentAuthToken).toBe('stored-token');
+        expect(newService.$authToken.value).toBe('stored-token');
+        expect(mockLocalStorage.getItem).toHaveBeenCalledWith('smess_auth_response');
+    });
+    it("handles localStorage errors gracefully", () => {
+        // Mock localStorage to throw an error
+        const mockLocalStorage = {
+            setItem: jest.fn().mockImplementation(() => {
+                throw new Error('localStorage error');
+            }),
+            getItem: jest.fn().mockImplementation(() => {
+                throw new Error('localStorage error');
+            }),
+            removeItem: jest.fn().mockImplementation(() => {
+                throw new Error('localStorage error');
+            }),
+        };
+        Object.defineProperty(window, 'localStorage', {
+            value: mockLocalStorage,
+            writable: true,
+        });
+        // Should not throw an error during initialization
+        expect(() => new AuthService(config)).not.toThrow();
+        // Should not throw an error during login with rememberMe
+        const service = new AuthService(config);
+        const payload = {
+            identifier: "user",
+            password: "pass",
+            rememberMe: true
+        };
+        const response = {
+            token_type: "Bearer",
+            expires_in: 3600,
+            token: "token",
+            refresh_token: "refresh",
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        expect(async () => {
+            await service.login(payload).toPromise();
+        }).not.toThrow();
+    });
+    it("handles expired token from localStorage", () => {
+        // Mock localStorage with expired token
+        const expiredResponse = {
+            token_type: "Bearer",
+            expires_in: 1, // 1 second
+            token: "expired-token",
+            refresh_token: "refresh",
+        };
+        mockLocalStorage.getItem.mockImplementation((key) => {
+            if (key === 'smess_auth_response') {
+                return JSON.stringify(expiredResponse);
+            }
+            if (key === 'smess_auth_response_stored_at') {
+                // Set stored time to 2 seconds ago (expired)
+                return (Date.now() - 2000).toString();
+            }
+            return null;
+        });
+        // Create a new service instance
+        const newService = new AuthService(config);
+        // Verify that expired token is not returned
+        expect(newService.currentAuthToken).toBe(null);
+        expect(newService.$authToken.value).toBe(null);
+        // Verify that localStorage was cleared
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_token');
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_response');
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('smess_auth_response_stored_at');
+    });
+    it("handles valid token from localStorage", () => {
+        // Mock localStorage with valid token
+        const validResponse = {
+            token_type: "Bearer",
+            expires_in: 3600, // 1 hour
+            token: "valid-token",
+            refresh_token: "refresh",
+        };
+        mockLocalStorage.getItem.mockImplementation((key) => {
+            if (key === 'smess_auth_response') {
+                return JSON.stringify(validResponse);
+            }
+            if (key === 'smess_auth_response_stored_at') {
+                // Set stored time to 30 minutes ago (still valid)
+                return (Date.now() - 1800000).toString();
+            }
+            return null;
+        });
+        // Create a new service instance
+        const newService = new AuthService(config);
+        // Verify that valid token is returned
+        expect(newService.currentAuthToken).toBe("valid-token");
+        expect(newService.$authToken.value).toBe("valid-token");
     });
     it("forgotPassword success", async () => {
         const payload = { identifier: "user" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smess/networking",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "Networking utilities and services for SMESS platform.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,6 +28,7 @@
     "eslint": "^9.31.0",
     "globals": "^16.3.0",
     "jest": "^30.0.4",
+    "jest-environment-jsdom": "^30.1.2",
     "ts-jest": "^29.4.0",
     "typescript": "^5.0.0",
     "typescript-eslint": "^8.37.0"