@smess/networking 1.2.0 → 2.1.0

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

@@ -1,65 +0,0 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
-import { SmessService } from "./smess.service";
-import { BehaviorSubject, Observable } from "rxjs";
-export interface AuthLoginRequest {
-    identifier: string;
-    password: string;
-    rememberMe?: boolean;
-}
-export interface ForgotPasswordRequest {
-    identifier: string;
-}
-export interface AuthChangePasswordRequest {
-    old_password: string;
-    password: string;
-}
-export interface ResetPasswordRequest {
-    token: string;
-    password: string;
-}
-export type AuthLoginResponse = {
-    token_type: unknown;
-    expires_in: unknown;
-    token: unknown;
-    refresh_token: unknown;
-};
-export type AuthTarget = "login" | "logout" | "change-password" | "password-forgot" | "reset-password" | "verify-reset-password-token";
-export declare class AuthProvider implements ProviderType {
-    private readonly config;
-    private readonly target;
-    private readonly $authToken;
-    constructor(config: NetworkingConfig, target: AuthTarget, $authToken: BehaviorSubject<string | null>);
-    get baseURL(): string;
-    get path(): string;
-    get method(): string;
-    get headers(): Record<string, string>;
-    getPath(...queryParams: unknown[]): string;
-}
-export interface AuthServiceType {
-    provider(target: AuthTarget): SmessService<AuthProvider>;
-    login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
-    logout(): Observable<NetworkingUIEventWrapped<void>>;
-    forgotPassword(payload: ForgotPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    changePassword(payload: AuthChangePasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    resetPassword(payload: ResetPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
-}
-export declare class AuthService implements AuthServiceType {
-    private readonly config;
-    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>>;
-    forgotPassword(payload: ForgotPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    changePassword(payload: AuthChangePasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    resetPassword(payload: ResetPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
-}

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(token) {
-        return this.provider("verify-reset-password-token").request({ token });
-    }
-}

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

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

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

@@ -1,334 +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).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).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>;
-}