@smess/networking 1.0.25 → 1.0.28

package/dist/src/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/src/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/src/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/src/services/cache.service.test.d.ts

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

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

@@ -1,88 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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>>;
-}