@smess/networking 1.0.22 → 1.0.24

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

@@ -0,0 +1,334 @@
+/**
+ * @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/src/services/cache.service.d.ts

@@ -0,0 +1,31 @@
+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/src/services/cache.service.js

@@ -0,0 +1,77 @@
+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/src/services/cache.service.test.d.ts

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

package/dist/src/services/cache.service.test.js

@@ -0,0 +1,88 @@
+import "fake-indexeddb/auto";
+import { GenericIndexedDBService } from "./cache.service";
+const toCached = (entity) => ({
+    id: entity.id,
+    name: entity.name,
+    createdAt: entity.createdAt.toISOString(),
+    cachedAt: Date.now(),
+});
+const fromCached = (cached) => ({
+    id: cached.id,
+    name: cached.name,
+    createdAt: new Date(cached.createdAt),
+});
+describe("GenericIndexedDBService", () => {
+    let service;
+    beforeEach(() => {
+        service = new GenericIndexedDBService("TestDB", "id, name", toCached, fromCached);
+    });
+    afterEach(async () => {
+        await service.db.delete();
+    });
+    it("should save and retrieve one item", async () => {
+        const item = {
+            id: "1",
+            name: "Test Item",
+            createdAt: new Date(),
+        };
+        await service.saveOne(item);
+        const result = await service.getOne("1");
+        expect(result).not.toBeNull();
+        expect(result?.id).toBe("1");
+    });
+    it("should save and retrieve all items", async () => {
+        const now = new Date();
+        const items = [
+            { id: "1", name: "One", createdAt: now },
+            { id: "2", name: "Two", createdAt: now },
+        ];
+        await service.saveAll(items, "all");
+        const results = await service.getAll("all");
+        expect(results).not.toBeNull();
+        expect(results.length).toBe(2);
+    });
+    it("should return null when cache is expired", async () => {
+        const cacheTable = service.db.cache;
+        await cacheTable.put({
+            key: "expired",
+            cachedAt: Date.now() - 10000,
+            expiresAt: Date.now() - 5000,
+            version: "1.0",
+        });
+        const result = await service.getAll("expired");
+        expect(result).toBeNull();
+    });
+    it("should delete one item", async () => {
+        const item = {
+            id: "1",
+            name: "Delete Me",
+            createdAt: new Date(),
+        };
+        await service.saveOne(item);
+        await service.delete("1");
+        const result = await service.getOne("1");
+        expect(result).toBeNull();
+    });
+    it("should set and retrieve stats", async () => {
+        const stats = { total: 99 };
+        await service.setStats("mystats", stats);
+        const result = await service.getStats("mystats");
+        expect(result).toEqual(stats);
+    });
+    it("should get cache info", async () => {
+        await service.saveOne({
+            id: "123",
+            name: "Info Item",
+            createdAt: new Date(),
+        });
+        await service.db.cache.put({
+            key: "info",
+            cachedAt: Date.now(),
+            expiresAt: Date.now() + 10000,
+            version: "1.0",
+        });
+        const info = await service.getCacheInfo("info");
+        expect(info.count).toBeGreaterThanOrEqual(1);
+        expect(info.lastUpdated).toBeInstanceOf(Date);
+    });
+});

package/dist/src/services/customer.service.d.ts

@@ -0,0 +1,71 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type CustomerTarget = "register" | "get-profile" | "update-profile" | "cart-collection" | "customer-product-collection" | "customer-product-create" | "customer-product-remove" | "customer-product-update-notes";
+export interface CustomerRegisterRequest {
+    client_id?: string;
+    email: string;
+    password: string;
+    phone_number?: string;
+    name?: string;
+    address?: string;
+    tax_identification_number?: string | null;
+}
+export interface CustomerUpdateRequest {
+    name: string;
+    address: string;
+    postal_code: string;
+    city: string;
+    state: string | null;
+    country: string | null;
+    contact_email: string | null;
+    phone_number: string | null;
+}
+export interface CustomerCartCollectionQuery {
+    page?: number;
+    per_page?: number;
+    status?: string;
+    search?: string;
+    sort_by?: string;
+    sort_order?: "asc" | "desc";
+}
+export interface CustomerProductCollectionQuery {
+    page?: number;
+    per_page?: number;
+}
+export interface CustomerProductCreateRequest {
+    product_id: string;
+    notes?: string;
+}
+export interface CustomerProductRemoveRequest {
+    product_id: string;
+}
+export interface CustomerProductUpdateNotesRequest {
+    product_id: string;
+    notes: string;
+}
+export declare class CustomerProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: CustomerTarget, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export declare class CustomerService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: CustomerTarget): SmessService<CustomerProvider>;
+    register(payload: CustomerRegisterRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getProfile(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    updateProfile(payload: CustomerUpdateRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getCartCollection(query?: CustomerCartCollectionQuery): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getCustomerProductCollection(query?: CustomerProductCollectionQuery): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    createCustomerProduct(payload: CustomerProductCreateRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    removeCustomerProduct(payload: CustomerProductRemoveRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    updateCustomerProductNotes(payload: CustomerProductUpdateNotesRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}