@smess/networking 1.1.5 → 2.0.0

package/dist/services/auth.service.js

@@ -1,197 +0,0 @@
-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;
-        this.target = target;
-        this.$authToken = $authToken;
-    }
-    get baseURL() {
-        return this.config.version
-            ? `${this.config.baseUrl}/${this.config.version}`
-            : this.config.baseUrl;
-    }
-    get path() {
-        switch (this.target) {
-            case "login":
-                return "/authentication/login_check";
-            case "password-forgot":
-                return "/authentication/forgot-password";
-            case "reset-password":
-                return "/authentication/reset-password";
-            case "verify-reset-password-token":
-                return "/authentication/verify-reset-password-token";
-            case "logout":
-                return "/authentication/logout";
-            case "change-password":
-                return "/authentication/change-password";
-            default:
-                return "/authentication";
-        }
-    }
-    get method() {
-        switch (this.target) {
-            default:
-                return "POST";
-        }
-    }
-    get headers() {
-        let authHeaders = {};
-        switch (this.target) {
-            case "login":
-            case "password-forgot":
-            case "reset-password":
-            case "verify-reset-password-token":
-                authHeaders = SmessService.getHeaders(Accept.V1);
-                break;
-            default:
-                authHeaders = SmessService.getHeaders(Accept.V1, this.$authToken.value);
-        }
-        if (this.config.clientId) {
-            authHeaders[SMESSHeader.ClientId] = this.config.clientId;
-        }
-        if (this.config.apiKey) {
-            authHeaders[SMESSHeader.ApiKey] = this.config.apiKey;
-        }
-        return SmessService.filterHeaders(authHeaders);
-    }
-    getPath(...queryParams) {
-        let definedPath = this.path;
-        const params = definedPath.match(/\$\{(.+?)\}/g);
-        params?.forEach((value, index) => {
-            definedPath = definedPath.replace(value, String(queryParams[index]));
-        });
-        return definedPath;
-    }
-}
-export class AuthService {
-    constructor(config) {
-        this.config = config;
-        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.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);
-        return new SmessService(targetWrapper);
-    }
-    login(payload) {
-        return this.provider("login")
-            .request(payload)
-            .pipe(tap((result) => {
-            if (result.hasSuccess && result.response?.token) {
-                // Set the auth token when login is successful
-                this.$_authToken.next(String(result.response.token));
-                // Save to localStorage if rememberMe is true
-                if (payload.rememberMe && result.response) {
-                    this.saveAuthToStorage(result.response);
-                }
-            }
-        }));
-    }
-    logout() {
-        return this.provider("logout")
-            .request()
-            .pipe(tap((result) => {
-            if (result.hasSuccess) {
-                // Clear from localStorage (this will also clear memory)
-                this.clearAuthFromStorage();
-            }
-        }));
-    }
-    forgotPassword(payload) {
-        return this.provider("password-forgot").request(payload);
-    }
-    changePassword(payload) {
-        return this.provider("change-password").request(payload);
-    }
-    resetPassword(payload) {
-        return this.provider("reset-password").request(payload);
-    }
-    verifyResetPasswordToken(payload) {
-        return this.provider("verify-reset-password-token").request(payload);
-    }
-}

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,340 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import { AuthService, } from "./auth.service";
-import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
-import { of } from "rxjs";
-describe("AuthService", () => {
-    const config = {
-        baseUrl: "https://api.example.com",
-        isProd: false,
-        clientId: "test-client-id",
-        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 () => {
-        const payload = { identifier: "user", password: "pass" };
-        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");
-    });
-    it("login error", async () => {
-        const payload = { identifier: "user", password: "wrong" };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.login(payload).toPromise();
-        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");
-        expect(service.currentAuthToken).toBe("test-token");
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(undefined)),
-        });
-        const result = await service.logout().toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        // 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" };
-        const response = { data: "ok" };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.forgotPassword(payload).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("changePassword success", async () => {
-        const payload = {
-            old_password: "old",
-            password: "new",
-        };
-        const response = { data: "changed" };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.changePassword(payload).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("resetPassword success", async () => {
-        const payload = {
-            token: "token",
-            password: "newpass",
-        };
-        const response = { data: "reset" };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-        });
-        const result = await service.resetPassword(payload).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("verifyResetPasswordToken success", async () => {
-        const token = "token";
-        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.verifyResetPasswordToken({
-            token,
-            new_password: 'newpass',
-        }).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("forgotPassword error", async () => {
-        const payload = { identifier: "user" };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.forgotPassword(payload).toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("changePassword error", async () => {
-        const payload = {
-            old_password: "old",
-            password: "bad",
-        };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.changePassword(payload).toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("resetPassword error", async () => {
-        const payload = { token: "bad", password: "bad" };
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.resetPassword(payload).toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("verifyResetPasswordToken error", async () => {
-        const token = "bad";
-        jest.spyOn(service, "provider").mockReturnValue({
-            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-        });
-        const result = await service.verifyResetPasswordToken({
-            token,
-            new_password: 'newpass',
-        }).toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-});

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

@@ -1,31 +0,0 @@
-import { Dexie, Table } from "../utils/cache-import";
-export interface CacheMetadata {
-    key: string;
-    cachedAt: number;
-    expiresAt: number;
-    version: string;
-}
-export declare class GenericDB<T> extends Dexie {
-    data: Table<T>;
-    cache: Table<CacheMetadata>;
-    constructor(name: string, dataStoreSchema: string);
-}
-export declare class GenericIndexedDBService<T, TCached> {
-    private toCached;
-    private fromCached;
-    private readonly CACHE_DURATION;
-    readonly db: GenericDB<TCached>;
-    constructor(dbName: string, storeSchema: string, toCached: (raw: T) => TCached, fromCached: (cached: TCached) => T);
-    saveAll(items: T[], cacheKey: string): Promise<void>;
-    getAll(cacheKey: string): Promise<T[] | null>;
-    saveOne(item: T): Promise<void>;
-    getOne(id: string): Promise<T | null>;
-    delete(id: string): Promise<void>;
-    clearAll(): Promise<void>;
-    getCacheInfo(key: string): Promise<{
-        count: number;
-        lastUpdated?: Date;
-    }>;
-    setStats(key: string, stats: unknown): Promise<void>;
-    getStats(key: string): Promise<unknown | null>;
-}

package/dist/services/cache.service.js

@@ -1,77 +0,0 @@
-import { Dexie } from "../utils/cache-import";
-export class GenericDB extends Dexie {
-    constructor(name, dataStoreSchema) {
-        super(name);
-        this.version(1).stores({
-            data: dataStoreSchema,
-            cache: "key, cachedAt, expiresAt",
-        });
-    }
-}
-export class GenericIndexedDBService {
-    constructor(dbName, storeSchema, toCached, fromCached) {
-        this.toCached = toCached;
-        this.fromCached = fromCached;
-        this.CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours
-        this.db = new GenericDB(dbName, storeSchema);
-    }
-    async saveAll(items, cacheKey) {
-        const cachedItems = items.map(this.toCached);
-        await this.db.transaction("rw", this.db.data, this.db.cache, async () => {
-            await this.db.data.clear();
-            await this.db.data.bulkAdd(cachedItems);
-            await this.db.cache.put({
-                key: cacheKey,
-                cachedAt: Date.now(),
-                expiresAt: Date.now() + this.CACHE_DURATION,
-                version: "1.0",
-            });
-        });
-    }
-    async getAll(cacheKey) {
-        const cacheInfo = await this.db.cache.get(cacheKey);
-        if (!cacheInfo || Date.now() > cacheInfo.expiresAt)
-            return null;
-        const cachedItems = await this.db.data.toArray();
-        return cachedItems.map(this.fromCached);
-    }
-    async saveOne(item) {
-        const cached = this.toCached(item);
-        await this.db.data.put(cached);
-    }
-    async getOne(id) {
-        const cached = await this.db.data.get(id);
-        return cached ? this.fromCached(cached) : null;
-    }
-    async delete(id) {
-        await this.db.data.delete(id);
-    }
-    async clearAll() {
-        await this.db.transaction("rw", this.db.data, this.db.cache, async () => {
-            await this.db.data.clear();
-            await this.db.cache.clear();
-        });
-    }
-    async getCacheInfo(key) {
-        const count = await this.db.data.count();
-        const cacheInfo = await this.db.cache.get(key);
-        return {
-            count,
-            lastUpdated: cacheInfo ? new Date(cacheInfo.cachedAt) : undefined,
-        };
-    }
-    async setStats(key, stats) {
-        await this.db.cache.put({
-            key,
-            cachedAt: Date.now(),
-            expiresAt: Date.now() + this.CACHE_DURATION,
-            version: JSON.stringify(stats),
-        });
-    }
-    async getStats(key) {
-        const cacheInfo = await this.db.cache.get(key);
-        if (!cacheInfo || Date.now() > cacheInfo.expiresAt)
-            return null;
-        return JSON.parse(cacheInfo.version);
-    }
-}

package/dist/services/cache.service.test.d.ts

@@ -1 +0,0 @@
-import "fake-indexeddb/auto";