@smess/networking 1.0.22 → 1.0.24

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

@@ -0,0 +1,319 @@
+import { StoreProductService, } from "./store.product.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of } from "rxjs";
+describe("StoreProductService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    beforeEach(() => {
+        service = new StoreProductService(config);
+    });
+    describe("getFeaturedProductList", () => {
+        it("should get featured product list successfully", async () => {
+            const response = {
+                data: [
+                    {
+                        id: "1",
+                        name: "Product 1",
+                        barcode: "123",
+                        category: "CONGELE",
+                        vatInPercent: 5.5,
+                        unit: "piece",
+                        quantity: 1,
+                        picture: "image.png",
+                        slug: "product-1",
+                        internalCode: "001",
+                        inventory: true,
+                        quantityInStock: 10,
+                        minimumStockQuantity: 5,
+                        pricePurchase: 10,
+                        priceToSell: 15,
+                        discountInPercent: 0,
+                        priceAfterDiscount: 0,
+                        expiryDate: null,
+                        subCategory: null,
+                        volume: null,
+                        unitWeight: null,
+                        articleWeight: null,
+                        tareWeight: null,
+                        supplier: null,
+                        supplierCode: null,
+                        supplierItemName: null,
+                        htmlDescription: null,
+                    },
+                ],
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getFeaturedProductList().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.getFeaturedProductList().toPromise();
+            expect(result?.hasFailed).toBe(true);
+        });
+    });
+    describe("getFeaturedProductListByStore", () => {
+        it("should get featured product list by store successfully", async () => {
+            const storeId = "store-123";
+            const response = {
+                data: [
+                    {
+                        id: "1",
+                        name: "Product 1",
+                        barcode: "123",
+                        category: "CONGELE",
+                        vatInPercent: 5.5,
+                        unit: "piece",
+                        quantity: 1,
+                        picture: "image.png",
+                        slug: "product-1",
+                        internalCode: "001",
+                        inventory: true,
+                        quantityInStock: 10,
+                        minimumStockQuantity: 5,
+                        pricePurchase: 10,
+                        priceToSell: 15,
+                        discountInPercent: 0,
+                        priceAfterDiscount: 0,
+                        expiryDate: null,
+                        subCategory: null,
+                        volume: null,
+                        unitWeight: null,
+                        articleWeight: null,
+                        tareWeight: null,
+                        supplier: null,
+                        supplierCode: null,
+                        supplierItemName: null,
+                        htmlDescription: null,
+                    },
+                ],
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getFeaturedProductListByStore(storeId).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getProductCategoryList", () => {
+        it("should get product category list successfully", async () => {
+            const response = {
+                data: [
+                    {
+                        name: "BOISSON",
+                        numberOfProducts: 443,
+                        image: null,
+                    },
+                    {
+                        name: "CONGELE",
+                        numberOfProducts: 324,
+                        image: null,
+                    },
+                ],
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductCategoryList().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getProductById", () => {
+        it("should get product by id successfully", async () => {
+            const productId = "product-123";
+            const response = {
+                data: {
+                    id: productId,
+                    name: "Product 1",
+                    barcode: "123",
+                    category: "CONGELE",
+                    vatInPercent: 5.5,
+                    unit: "piece",
+                    quantity: 1,
+                    picture: "image.png",
+                    slug: "product-1",
+                    internalCode: "001",
+                    inventory: true,
+                    quantityInStock: 10,
+                    minimumStockQuantity: 5,
+                    pricePurchase: 10,
+                    priceToSell: 15,
+                    discountInPercent: 0,
+                    priceAfterDiscount: 0,
+                    expiryDate: null,
+                    subCategory: null,
+                    volume: null,
+                    unitWeight: null,
+                    articleWeight: null,
+                    tareWeight: null,
+                    supplier: null,
+                    supplierCode: null,
+                    supplierItemName: null,
+                    htmlDescription: null,
+                },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductById(productId).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getProductCollection", () => {
+        it("should get product collection successfully", async () => {
+            const payload = {
+                page: 1,
+                per_page: 10,
+                search: "test",
+            };
+            const response = {
+                data: {
+                    links: {
+                        first: "/api/v1/store/product-collection?per_page=10&page=1",
+                        last: "/api/v1/store/product-collection?per_page=10&page=5",
+                        next: "/api/v1/store/product-collection?per_page=10&page=2",
+                    },
+                    items: [
+                        {
+                            id: "1",
+                            name: "Product 1",
+                            barcode: "123",
+                            category: "CONGELE",
+                            vatInPercent: 5.5,
+                            unit: "piece",
+                            quantity: 1,
+                            picture: "image.png",
+                            slug: "product-1",
+                            internalCode: "001",
+                            inventory: true,
+                            quantityInStock: 10,
+                            minimumStockQuantity: 5,
+                            pricePurchase: 10,
+                            priceToSell: 15,
+                            discountInPercent: 0,
+                            priceAfterDiscount: 0,
+                            expiryDate: null,
+                            subCategory: null,
+                            volume: null,
+                            unitWeight: null,
+                            articleWeight: null,
+                            tareWeight: null,
+                            supplier: null,
+                            supplierCode: null,
+                            supplierItemName: null,
+                            htmlDescription: null,
+                        },
+                    ],
+                    count: 10,
+                    total: 50,
+                    page: 1,
+                    totalPage: 5,
+                    perPage: 10,
+                    metadata: [],
+                },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductCollection(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should get product collection without payload", async () => {
+            const response = {
+                data: {
+                    links: {
+                        first: "/api/v1/store/product-collection?per_page=24&page=1",
+                        last: "/api/v1/store/product-collection?per_page=24&page=1",
+                    },
+                    items: [],
+                    count: 0,
+                    total: 0,
+                    page: 1,
+                    totalPage: 1,
+                    perPage: 24,
+                    metadata: [],
+                },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductCollection().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getProductCollectionByStore", () => {
+        it("should get product collection by store successfully", async () => {
+            const storeId = "store-123";
+            const payload = {
+                page: 1,
+                per_page: 10,
+            };
+            const response = {
+                data: {
+                    links: {
+                        first: "/api/v1/store/product-collection?per_page=10&page=1",
+                        last: "/api/v1/store/product-collection?per_page=10&page=1",
+                    },
+                    items: [
+                        {
+                            id: "1",
+                            name: "Product 1",
+                            barcode: "123",
+                            category: "CONGELE",
+                            vatInPercent: 5.5,
+                            unit: "piece",
+                            quantity: 1,
+                            picture: "image.png",
+                            slug: "product-1",
+                            internalCode: "001",
+                            inventory: true,
+                            quantityInStock: 10,
+                            minimumStockQuantity: 5,
+                            pricePurchase: 10,
+                            priceToSell: 15,
+                            discountInPercent: 0,
+                            priceAfterDiscount: 0,
+                            expiryDate: null,
+                            subCategory: null,
+                            volume: null,
+                            unitWeight: null,
+                            articleWeight: null,
+                            tareWeight: null,
+                            supplier: null,
+                            supplierCode: null,
+                            supplierItemName: null,
+                            htmlDescription: null,
+                        },
+                    ],
+                    count: 1,
+                    total: 1,
+                    page: 1,
+                    totalPage: 1,
+                    perPage: 10,
+                    metadata: [],
+                },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductCollectionByStore(storeId, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+});

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

@@ -0,0 +1,79 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type StoreTarget = "store-get" | "store-list" | "store-product-category-list" | "store-product-collection" | "store-featured-product-list";
+export interface ProductCollectionRequest {
+    page?: number;
+    per_page?: number;
+    search?: string;
+    sort_by?: string;
+    category?: string;
+    min_price?: number;
+    max_price?: number;
+    only_discounted?: boolean;
+    unit?: string;
+    supplier?: string;
+    has_offer?: boolean;
+}
+export declare class StoreProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    constructor(config: NetworkingConfig, target: StoreTarget);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface StoreData {
+    id: string;
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface StoreListData {
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface ProductCollectionData {
+    storeId: string;
+    request: ProductCollectionRequest;
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface ProductCategoryData {
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface FeaturedProductData {
+    storeId: string;
+    data: HttpResponse;
+    timestamp: number;
+}
+export declare class StoreService {
+    private readonly config;
+    readonly $selectedStoreId: BehaviorSubject<string | null>;
+    private readonly cacheService;
+    private readonly storeListCache;
+    private readonly productCollectionCache;
+    private readonly productCategoryCache;
+    private readonly featuredProductCache;
+    constructor(config: NetworkingConfig);
+    provider(target: StoreTarget): SmessService<StoreProvider>;
+    /**
+     * Set the selected store ID
+     */
+    setSelectedStoreId(storeId: string | null): void;
+    /**
+     * Get the current selected store ID
+     */
+    get currentSelectedStoreId(): string | null;
+    get(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    list(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    productCategoryList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    productCollection(id: string, payload: ProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    featuredProductList(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    clearCache(): Promise<void>;
+    clearStoreCache(id: string): Promise<void>;
+    clearProductCollectionCache(id: string): Promise<void>;
+    private isCacheValid;
+}

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

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

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