@smess/networking 1.2.0 → 2.1.0

package/dist/services/store.service.js

@@ -1,235 +0,0 @@
-import { NetworkingUIEventWrapped, } from "../types/types";
-import { Accept, SMESSHeader, SmessService } from "./smess.service";
-import { BehaviorSubject, from, of } from "rxjs";
-import { map, switchMap, catchError } from "rxjs/operators";
-import { GenericIndexedDBService } from "./cache.service";
-export class StoreProvider {
-    constructor(config, target) {
-        this.config = config;
-        this.target = target;
-    }
-    get baseURL() {
-        return this.config.version
-            ? `${this.config.baseUrl}/${this.config.version}`
-            : this.config.baseUrl;
-    }
-    get path() {
-        switch (this.target) {
-            case "store-get":
-                return "/store/${id}/information";
-            case "store-list":
-                return "/store/list";
-            case "store-product-category-list":
-                return "/store/product-category-list";
-            case "store-product-collection":
-                return "/store/${id}/product-collection";
-            case "store-featured-product-list":
-                return "/store/${id}/featured-product-list";
-            default:
-                return "/store/${id}";
-        }
-    }
-    get method() {
-        return "GET";
-    }
-    get headers() {
-        let headers = SmessService.getHeaders(Accept.V1, null);
-        if (this.config.clientId) {
-            headers[SMESSHeader.ClientId] = this.config.clientId;
-        }
-        if (this.config.apiKey) {
-            headers[SMESSHeader.ApiKey] = this.config.apiKey;
-        }
-        return SmessService.filterHeaders(headers);
-    }
-    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 StoreService {
-    constructor(config) {
-        this.config = config;
-        this.$selectedStoreId = new BehaviorSubject(null);
-        // Initialize cache services for different data types
-        this.cacheService = new GenericIndexedDBService("StoreCache", "id, timestamp", (data) => data, (data) => data);
-        this.storeListCache = new GenericIndexedDBService("StoreListCache", "timestamp", (data) => data, (data) => data);
-        this.productCollectionCache = new GenericIndexedDBService("ProductCollectionCache", "storeId, timestamp", (data) => data, (data) => data);
-        this.productCategoryCache = new GenericIndexedDBService("ProductCategoryCache", "timestamp", (data) => data, (data) => data);
-        this.featuredProductCache = new GenericIndexedDBService("FeaturedProductCache", "storeId, timestamp", (data) => data, (data) => data);
-    }
-    provider(target) {
-        const targetWrapper = new StoreProvider(this.config, target);
-        return new SmessService(targetWrapper);
-    }
-    /**
-     * Set the selected store ID
-     */
-    setSelectedStoreId(storeId) {
-        this.$selectedStoreId.next(storeId);
-    }
-    /**
-     * Get the current selected store ID
-     */
-    get currentSelectedStoreId() {
-        return this.$selectedStoreId.value;
-    }
-    get(id) {
-        return from(this.cacheService.getOne(id)).pipe(switchMap((cachedData) => {
-            if (cachedData && this.isCacheValid(cachedData.timestamp)) {
-                // Return cached data if valid
-                return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
-            }
-            // Fetch from network if no cache or expired
-            return this.provider("store-get")
-                .request(null, undefined, id)
-                .pipe(map((response) => {
-                // Cache the successful response
-                if (response.response) {
-                    this.cacheService.saveOne({
-                        id,
-                        data: response.response,
-                        timestamp: Date.now(),
-                    });
-                }
-                return response;
-            }), catchError((error) => {
-                // If network fails and we have stale cache, return it
-                if (cachedData) {
-                    return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
-                }
-                throw error;
-            }));
-        }));
-    }
-    list() {
-        return from(this.storeListCache.getAll("store-list")).pipe(switchMap((cachedData) => {
-            if (cachedData &&
-                cachedData.length > 0 &&
-                this.isCacheValid(cachedData[0].timestamp)) {
-                return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
-            }
-            return this.provider("store-list")
-                .request()
-                .pipe(map((response) => {
-                if (response.response) {
-                    this.storeListCache.saveAll([
-                        {
-                            data: response.response,
-                            timestamp: Date.now(),
-                        },
-                    ], "store-list");
-                }
-                return response;
-            }), catchError((error) => {
-                if (cachedData && cachedData.length > 0) {
-                    return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
-                }
-                throw error;
-            }));
-        }));
-    }
-    productCategoryList() {
-        return from(this.productCategoryCache.getAll("product-category-list")).pipe(switchMap((cachedData) => {
-            if (cachedData &&
-                cachedData.length > 0 &&
-                this.isCacheValid(cachedData[0].timestamp)) {
-                return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
-            }
-            return this.provider("store-product-category-list")
-                .request()
-                .pipe(map((response) => {
-                if (response.response) {
-                    this.productCategoryCache.saveAll([
-                        {
-                            data: response.response,
-                            timestamp: Date.now(),
-                        },
-                    ], "product-category-list");
-                }
-                return response;
-            }), catchError((error) => {
-                if (cachedData && cachedData.length > 0) {
-                    return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
-                }
-                throw error;
-            }));
-        }));
-    }
-    productCollection(id, payload) {
-        const cacheKey = `${id}-${JSON.stringify(payload)}`;
-        return from(this.productCollectionCache.getOne(cacheKey)).pipe(switchMap((cachedData) => {
-            if (cachedData && this.isCacheValid(cachedData.timestamp)) {
-                return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
-            }
-            return this.provider("store-product-collection")
-                .request(payload, undefined, id)
-                .pipe(map((response) => {
-                if (response.response) {
-                    this.productCollectionCache.saveOne({
-                        storeId: cacheKey,
-                        request: payload,
-                        data: response.response,
-                        timestamp: Date.now(),
-                    });
-                }
-                return response;
-            }), catchError((error) => {
-                if (cachedData) {
-                    return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
-                }
-                throw error;
-            }));
-        }));
-    }
-    featuredProductList(id) {
-        return from(this.featuredProductCache.getOne(id)).pipe(switchMap((cachedData) => {
-            if (cachedData && this.isCacheValid(cachedData.timestamp)) {
-                return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
-            }
-            return this.provider("store-featured-product-list")
-                .request(null, undefined, id)
-                .pipe(map((response) => {
-                if (response.response) {
-                    this.featuredProductCache.saveOne({
-                        storeId: id,
-                        data: response.response,
-                        timestamp: Date.now(),
-                    });
-                }
-                return response;
-            }), catchError((error) => {
-                if (cachedData) {
-                    return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
-                }
-                throw error;
-            }));
-        }));
-    }
-    // Cache management methods
-    clearCache() {
-        return Promise.all([
-            this.cacheService.clearAll(),
-            this.storeListCache.clearAll(),
-            this.productCollectionCache.clearAll(),
-            this.productCategoryCache.clearAll(),
-            this.featuredProductCache.clearAll(),
-        ]).then(() => { });
-    }
-    clearStoreCache(id) {
-        return this.cacheService.delete(id);
-    }
-    clearProductCollectionCache(id) {
-        // This would need to be implemented with a more sophisticated approach
-        // to clear all product collection cache entries for a specific store
-        return Promise.resolve();
-    }
-    isCacheValid(timestamp) {
-        const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours for testing
-        return Date.now() - timestamp < CACHE_DURATION;
-    }
-}

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

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

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

@@ -1,274 +0,0 @@
-import "fake-indexeddb/auto";
-import { StoreService, } from "./store.service";
-import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
-import { of } from "rxjs";
-describe("StoreService", () => {
-    const config = {
-        baseUrl: "https://api.example.com",
-        isProd: false,
-        clientId: "test-client-id",
-        apiKey: "test-api-key",
-    };
-    let service;
-    beforeEach(() => {
-        service = new StoreService(config);
-    });
-    afterEach(async () => {
-        await service.clearCache();
-    });
-    it("should create service instance", () => {
-        expect(service).toBeDefined();
-    });
-    it("should get store from network when no cache", async () => {
-        const response = { data: { id: "1", name: "Store" } };
-        const mockProvider = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider);
-        const result = await service.get("1").toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get store from cache when available", async () => {
-        const response = { data: { id: "1", name: "Store" } };
-        // First call to populate cache
-        const mockProvider1 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider1);
-        await service.get("1").toPromise();
-        // Second call should use cache (even if network fails)
-        const mockProvider2 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider2);
-        const result = await service.get("1").toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should handle network error when no cache", async () => {
-        const mockProvider = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider);
-        const result = await service.get("1").toPromise();
-        expect(result?.hasFailed).toBe(true);
-        expect(result?.alertModel).toBeInstanceOf(AlertModel);
-    });
-    it("should get store list from network when no cache", async () => {
-        const response = { data: [{ id: "1", name: "Store" }] };
-        const mockProvider = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider);
-        const result = await service.list().toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get store list from cache when available", async () => {
-        const response = { data: [{ id: "1", name: "Store" }] };
-        // First call to populate cache
-        const mockProvider1 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider1);
-        await service.list().toPromise();
-        // Second call should use cache
-        const mockProvider2 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider2);
-        const result = await service.list().toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get product category list from network when no cache", async () => {
-        const response = { data: [{ id: "cat1", name: "Category" }] };
-        const mockProvider = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider);
-        const result = await service.productCategoryList().toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get product category list from cache when available", async () => {
-        const response = { data: [{ id: "cat1", name: "Category" }] };
-        // First call to populate cache
-        const mockProvider1 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider1);
-        await service.productCategoryList().toPromise();
-        // Second call should use cache
-        const mockProvider2 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider2);
-        const result = await service.productCategoryList().toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get product collection from network when no cache", async () => {
-        const response = { data: [{ id: "prod1", name: "Product" }] };
-        const payload = { page: 1, per_page: 10 };
-        const mockProvider = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider);
-        const result = await service.productCollection("1", payload).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get product collection from cache when available", async () => {
-        const response = { data: [{ id: "prod1", name: "Product" }] };
-        const payload = { page: 1, per_page: 10 };
-        // First call to populate cache
-        const mockProvider1 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider1);
-        await service.productCollection("1", payload).toPromise();
-        // Second call should use cache
-        const mockProvider2 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider2);
-        const result = await service.productCollection("1", payload).toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get featured product list from network when no cache", async () => {
-        const response = {
-            data: [{ id: "feat1", name: "Featured" }],
-        };
-        const mockProvider = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider);
-        const result = await service.featuredProductList("1").toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should get featured product list from cache when available", async () => {
-        const response = {
-            data: [{ id: "feat1", name: "Featured" }],
-        };
-        // First call to populate cache
-        const mockProvider1 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider1);
-        await service.featuredProductList("1").toPromise();
-        // Second call should use cache
-        const mockProvider2 = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider2);
-        const result = await service.featuredProductList("1").toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(result?.response).toEqual(response);
-    });
-    it("should clear cache successfully", async () => {
-        const response = { data: { id: "1", name: "Store" } };
-        const mockProvider = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider);
-        // Populate cache
-        await service.get("1").toPromise();
-        // Clear cache
-        await service.clearCache();
-        // Should call network again after cache clear
-        const result = await service.get("1").toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(mockProvider.request).toHaveBeenCalledTimes(2); // Once before clear, once after
-    });
-    it("should clear specific store cache", async () => {
-        const response = { data: { id: "1", name: "Store" } };
-        const mockProvider = {
-            request: jest
-                .fn()
-                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
-        };
-        jest
-            .spyOn(service, "provider")
-            .mockReturnValue(mockProvider);
-        // Populate cache for store '1'
-        await service.get("1").toPromise();
-        // Clear specific store cache
-        await service.clearStoreCache("1");
-        // Should call network again after cache clear
-        const result = await service.get("1").toPromise();
-        expect(result?.hasSuccess).toBe(true);
-        expect(mockProvider.request).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/services/storefront.cart.service.d.ts

@@ -1,73 +0,0 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
-import { SmessService } from "./smess.service";
-import { BehaviorSubject, Observable } from "rxjs";
-export type StorefrontCartTarget = "cart-add-item" | "cart-get" | "cart-update-item" | "cart-remove-item" | "cart-calculate-shipping";
-export type DeliveryType = "pickup" | "delivery";
-export interface AddToCartRequest {
-    productId: number;
-    quantity: number;
-    sessionToken?: string;
-}
-export interface UpdateCartItemRequest {
-    quantity: number;
-}
-export interface CalculateShippingRequest {
-    postalCode: string;
-    deliveryType: DeliveryType;
-}
-export declare class StorefrontCartProvider implements ProviderType {
-    private readonly config;
-    private readonly target;
-    private readonly $sessionToken;
-    private readonly $authToken;
-    constructor(config: NetworkingConfig, target: StorefrontCartTarget, $sessionToken: BehaviorSubject<string | null>, $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 StorefrontCartService {
-    private readonly config;
-    private readonly $authToken;
-    readonly $sessionToken: BehaviorSubject<string | null>;
-    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
-    provider(target: StorefrontCartTarget): SmessService<StorefrontCartProvider>;
-    /**
-     * Add item to cart
-     * POST /storefront/cart/items
-     */
-    addToCart(payload: AddToCartRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get current cart
-     * GET /storefront/cart
-     */
-    getCart(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Update cart item quantity
-     * PUT /storefront/cart/items/{cartItemId}
-     */
-    updateCartItem(cartItemId: number, payload: UpdateCartItemRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Remove cart item
-     * DELETE /storefront/cart/items/{cartItemId}
-     */
-    removeCartItem(cartItemId: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Calculate shipping costs
-     * POST /storefront/cart/calculate-shipping
-     */
-    calculateShipping(payload: CalculateShippingRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Set the session token
-     */
-    setSessionToken(token: string | null): void;
-    /**
-     * Get the current session token
-     */
-    get currentSessionToken(): string | null;
-    /**
-     * Extract and store session token from cart responses
-     */
-    private extractAndStoreSessionToken;
-}