@smess/networking 1.0.23 → 1.0.25

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

@@ -0,0 +1,394 @@
+import { StoreCartService, StoreCartProvider, } from "./store.cart.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { BehaviorSubject, of } from "rxjs";
+describe("StoreCartService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    beforeEach(() => {
+        service = new StoreCartService(config);
+    });
+    it("should initialize with null cartHash and storeId", () => {
+        expect(service.currentCartHash).toBe(null);
+        expect(service.cartHash$.value).toBe(null);
+        expect(service.currentStoreId).toBe(null);
+        expect(service.storeId$.value).toBe(null);
+    });
+    it("should initialize with provided storeId BehaviorSubject", () => {
+        const storeId = "store-123";
+        const $storeId = new BehaviorSubject(storeId);
+        const serviceWithStore = new StoreCartService(config, $storeId);
+        expect(serviceWithStore.currentStoreId).toBe(storeId);
+        expect(serviceWithStore.storeId$.value).toBe(storeId);
+    });
+    it("should update storeId dynamically", () => {
+        expect(service.currentStoreId).toBe(null);
+        service.setStoreId("store-456");
+        expect(service.currentStoreId).toBe("store-456");
+        expect(service.storeId$.value).toBe("store-456");
+    });
+    describe("getCart", () => {
+        it("should get cart successfully and update cartHash", async () => {
+            const cart = {
+                dateCreated: "2025-10-14 12:56:31",
+                dateModified: "2025-10-14 12:56:31",
+                discountTotal: 0,
+                discountTax: 0,
+                shippingTotal: 0,
+                shippingTax: 0,
+                cartTax: 0,
+                total: 20.0,
+                totalTax: 0,
+                customerId: "cust-123",
+                billingInformation: null,
+                shippingInformation: null,
+                paymentMethod: "cash",
+                deliveryType: "pickup",
+                transactionId: null,
+                customerIpAddress: "172.18.0.1",
+                customerUserAgent: "Test Agent",
+                customerNote: null,
+                cartHash: "test-hash-123",
+                cartItems: [
+                    {
+                        id: "item-1",
+                        productId: "prod-1",
+                        name: "Test Product",
+                        quantity: 2,
+                        price: 10.0,
+                        total: 20.0,
+                    },
+                ],
+                paymentUrl: null,
+                store: null,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
+            });
+            const result = await service.getCart().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(cart);
+            expect(service.currentCartHash).toBe("test-hash-123");
+        });
+        it("should handle getCart error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.getCart().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("updateCart", () => {
+        it("should update cart successfully", async () => {
+            const payload = {
+                status: "submitted",
+                customer_note: "Customer Note Example",
+                customer_id: "f1df6e9a-0160-11f0-82c2-6cac1a7e2953",
+                payment_method: "bank_transfer",
+                delivery_type: "delivery",
+                billing_information: {
+                    email: "billing@example.com",
+                    phone_number: "+1-555-111-2222",
+                    street: "456 Market Street",
+                    city: "san_francisco",
+                    postal_code: "94103",
+                    state: "ca",
+                    country: "us",
+                },
+                shipping_information: {
+                    email: "john.doe@example.com",
+                    phone_number: "+1-555-123-4567",
+                    street: "123 Main Street",
+                    city: "san_francisco",
+                    postal_code: "94105",
+                    state: "ca",
+                    country: "us",
+                },
+            };
+            const cart = {
+                dateCreated: "2025-10-14 12:56:31",
+                dateModified: "2025-10-14 12:56:31",
+                discountTotal: 0,
+                discountTax: 0,
+                shippingTotal: 0,
+                shippingTax: 0,
+                cartTax: 0,
+                total: 0,
+                totalTax: 0,
+                customerId: null,
+                billingInformation: null,
+                shippingInformation: null,
+                paymentMethod: "cash",
+                deliveryType: "pickup",
+                transactionId: null,
+                customerIpAddress: "172.18.0.1",
+                customerUserAgent: "Test Agent",
+                customerNote: "Please deliver in the evening",
+                cartHash: "test-hash",
+                cartItems: [],
+                paymentUrl: null,
+                store: null,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
+            });
+            const result = await service.updateCart(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(cart);
+        });
+        it("should handle updateCart error", async () => {
+            const payload = {
+                status: "invalid_status",
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.updateCart(payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("addItem", () => {
+        it("should add item to cart successfully", async () => {
+            const payload = {
+                product_id: "prod-123",
+                quantity: 3,
+            };
+            const cart = {
+                dateCreated: "2025-10-14 12:56:31",
+                dateModified: "2025-10-14 12:56:31",
+                discountTotal: 0,
+                discountTax: 0,
+                shippingTotal: 0,
+                shippingTax: 0,
+                cartTax: 0,
+                total: 45.0,
+                totalTax: 0,
+                customerId: null,
+                billingInformation: null,
+                shippingInformation: null,
+                paymentMethod: "cash",
+                deliveryType: "pickup",
+                transactionId: null,
+                customerIpAddress: "172.18.0.1",
+                customerUserAgent: "Test Agent",
+                customerNote: null,
+                cartHash: "test-hash",
+                cartItems: [
+                    {
+                        id: "item-1",
+                        productId: "prod-123",
+                        quantity: 3,
+                        price: 15.0,
+                        total: 45.0,
+                    },
+                ],
+                paymentUrl: null,
+                store: null,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
+            });
+            const result = await service.addItem(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(cart);
+        });
+        it("should handle addItem error", async () => {
+            const payload = {
+                product_id: "prod-999",
+                quantity: 1,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.addItem(payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("batchItems", () => {
+        it("should batch create/update items successfully and update cartHash", async () => {
+            const payload = {
+                create: [
+                    { product_id: "prod-111", quantity: 2 },
+                    { product_id: "prod-222", quantity: 1 },
+                ],
+                update: [
+                    { product_id: "prod-333", quantity: 5 },
+                ],
+            };
+            const cart = {
+                dateCreated: "2025-10-14 12:56:31",
+                dateModified: "2025-10-14 12:56:31",
+                discountTotal: 0,
+                discountTax: 0,
+                shippingTotal: 0,
+                shippingTax: 0,
+                cartTax: 0,
+                total: 100.0,
+                totalTax: 0,
+                customerId: null,
+                billingInformation: null,
+                shippingInformation: null,
+                paymentMethod: "cash",
+                deliveryType: "pickup",
+                transactionId: null,
+                customerIpAddress: "172.18.0.1",
+                customerUserAgent: "Test Agent",
+                customerNote: null,
+                cartHash: "hash-batch-123",
+                cartItems: [
+                    { id: "item-1", productId: "prod-111", quantity: 2, price: 10, total: 20 },
+                    { id: "item-2", productId: "prod-222", quantity: 1, price: 30, total: 30 },
+                    { id: "item-3", productId: "prod-333", quantity: 5, price: 10, total: 50 },
+                ],
+                paymentUrl: null,
+                store: null,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
+            });
+            const result = await service.batchItems(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(cart);
+            expect(service.currentCartHash).toBe("hash-batch-123");
+        });
+        it("should handle batchItems error", async () => {
+            const payload = {
+                create: [{ product_id: "invalid", quantity: 0 }],
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.batchItems(payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("updateItemQuantity", () => {
+        it("should update item quantity successfully", async () => {
+            const itemId = "item-123";
+            const payload = {
+                quantity: 5,
+            };
+            const cart = {
+                dateCreated: "2025-10-14 12:56:31",
+                dateModified: "2025-10-14 12:56:31",
+                discountTotal: 0,
+                discountTax: 0,
+                shippingTotal: 0,
+                shippingTax: 0,
+                cartTax: 0,
+                total: 75.0,
+                totalTax: 0,
+                customerId: null,
+                billingInformation: null,
+                shippingInformation: null,
+                paymentMethod: "cash",
+                deliveryType: "pickup",
+                transactionId: null,
+                customerIpAddress: "172.18.0.1",
+                customerUserAgent: "Test Agent",
+                customerNote: null,
+                cartHash: "test-hash",
+                cartItems: [
+                    {
+                        id: itemId,
+                        productId: "prod-123",
+                        quantity: 5,
+                        price: 15.0,
+                        total: 75.0,
+                    },
+                ],
+                paymentUrl: null,
+                store: null,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(cart)),
+            });
+            const result = await service.updateItemQuantity(itemId, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(cart);
+        });
+        it("should handle updateItemQuantity error", async () => {
+            const itemId = "item-999";
+            const payload = {
+                quantity: 5,
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.updateItemQuantity(itemId, payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("deleteItem", () => {
+        it("should delete item from cart successfully", async () => {
+            const itemId = "item-123";
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(undefined)),
+            });
+            const result = await service.deleteItem(itemId).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+        });
+        it("should handle deleteItem error", async () => {
+            const itemId = "item-999";
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.deleteItem(itemId).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("deleteAllItems", () => {
+        it("should delete all items from cart successfully", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(undefined)),
+            });
+            const result = await service.deleteAllItems().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+        });
+        it("should handle deleteAllItems error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.deleteAllItems().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("headers", () => {
+        it("should include X-Store-Id header when storeId is set", () => {
+            const storeId = "store-123";
+            const cartHash = "cart-hash-456";
+            const $cartHashSubject = new BehaviorSubject(cartHash);
+            const $storeIdSubject = new BehaviorSubject(storeId);
+            const provider = new StoreCartProvider(config, "cart-get", $cartHashSubject, $storeIdSubject);
+            const headers = provider.headers;
+            expect(headers["X-Store-Id"]).toBe(storeId);
+            expect(headers["X-Nonce-Token"]).toBe(cartHash);
+        });
+        it("should not include X-Store-Id header when storeId is null", () => {
+            const $cartHashSubject = new BehaviorSubject(null);
+            const $storeIdSubject = new BehaviorSubject(null);
+            const provider = new StoreCartProvider(config, "cart-get", $cartHashSubject, $storeIdSubject);
+            const headers = provider.headers;
+            expect(headers["X-Store-Id"]).toBeUndefined();
+        });
+        it("should include X-Nonce-Token header when cartHash is set", () => {
+            const cartHash = "cart-hash-789";
+            const $cartHashSubject = new BehaviorSubject(cartHash);
+            const $storeIdSubject = new BehaviorSubject(null);
+            const provider = new StoreCartProvider(config, "cart-get", $cartHashSubject, $storeIdSubject);
+            const headers = provider.headers;
+            expect(headers["X-Nonce-Token"]).toBe(cartHash);
+        });
+    });
+});

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

@@ -0,0 +1,123 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { Observable } from "rxjs";
+export type StoreProductTarget = "featured-product-list" | "featured-product-list-by-store" | "product-category-list" | "product-get-by-id" | "product-collection" | "product-collection-by-store";
+export interface StoreProductCollectionRequest {
+    page?: number;
+    per_page?: number;
+    search?: string;
+    sort_by?: string;
+    category?: string;
+    group?: string;
+    min_price?: number;
+    max_price?: number;
+    only_discounted?: boolean;
+    unit?: string;
+    supplier?: string;
+    has_offer?: boolean;
+    [key: string]: unknown;
+}
+export interface PaginationLinks {
+    first: string;
+    last: string;
+    next?: string;
+    prev?: string;
+}
+export interface StoreProduct {
+    id: string;
+    barcode: string;
+    expiryDate: string | null;
+    name: string;
+    category: string;
+    subCategory: string | null;
+    vatInPercent: number;
+    unit: string;
+    volume: number | null;
+    quantity: number;
+    unitWeight: number | null;
+    articleWeight: number | null;
+    tareWeight: number | null;
+    supplier: string | null;
+    supplierCode: string | null;
+    supplierItemName: string | null;
+    picture: string;
+    slug: string;
+    internalCode: string;
+    htmlDescription: string | null;
+    inventory: boolean;
+    quantityInStock: number;
+    minimumStockQuantity: number;
+    pricePurchase: number;
+    priceToSell: number;
+    discountInPercent: number;
+    priceAfterDiscount: number;
+    [key: string]: unknown;
+}
+export interface StoreProductCollectionResponse {
+    links: PaginationLinks;
+    items: StoreProduct[];
+    count: number;
+    total: number;
+    page: number;
+    totalPage: number;
+    perPage: number;
+    metadata: unknown[];
+}
+export interface ProductCategory {
+    name: string;
+    numberOfProducts: number;
+    image: string | null;
+}
+export declare class StoreProductProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    constructor(config: NetworkingConfig, target: StoreProductTarget);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface StoreProductServiceType {
+    getFeaturedProductList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getFeaturedProductListByStore(storeId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getProductCategoryList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getProductById(productId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getProductCollection(payload?: StoreProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getProductCollectionByStore(storeId: string, payload?: StoreProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}
+export declare class StoreProductService implements StoreProductServiceType {
+    private readonly config;
+    constructor(config: NetworkingConfig);
+    provider(target: StoreProductTarget): SmessService<StoreProductProvider>;
+    /**
+     * Get featured product list
+     * GET /api/v1/store/featured-product-list
+     */
+    getFeaturedProductList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get featured product list by store
+     * GET /api/v1/store/{id}/featured-product-list
+     */
+    getFeaturedProductListByStore(storeId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get product category list
+     * GET /api/v1/store/product-category/list
+     */
+    getProductCategoryList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get product by ID
+     * GET /api/v1/store/product/{id}
+     */
+    getProductById(productId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get product collection
+     * GET /api/v1/store/product-collection
+     */
+    getProductCollection(payload?: StoreProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get product collection by store
+     * GET /api/v1/store/{id}/product-collection
+     */
+    getProductCollectionByStore(storeId: string, payload?: StoreProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

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

@@ -0,0 +1,102 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+export class StoreProductProvider {
+    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 "featured-product-list":
+                return "/store/featured-product-list";
+            case "featured-product-list-by-store":
+                return "/store/${id}/featured-product-list";
+            case "product-category-list":
+                return "/store/product-category/list";
+            case "product-get-by-id":
+                return "/store/product/${id}";
+            case "product-collection":
+                return "/store/product-collection";
+            case "product-collection-by-store":
+                return "/store/${id}/product-collection";
+            default:
+                return "/store";
+        }
+    }
+    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 StoreProductService {
+    constructor(config) {
+        this.config = config;
+    }
+    provider(target) {
+        const targetWrapper = new StoreProductProvider(this.config, target);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * Get featured product list
+     * GET /api/v1/store/featured-product-list
+     */
+    getFeaturedProductList() {
+        return this.provider("featured-product-list").request();
+    }
+    /**
+     * Get featured product list by store
+     * GET /api/v1/store/{id}/featured-product-list
+     */
+    getFeaturedProductListByStore(storeId) {
+        return this.provider("featured-product-list-by-store").request(undefined, undefined, storeId);
+    }
+    /**
+     * Get product category list
+     * GET /api/v1/store/product-category/list
+     */
+    getProductCategoryList() {
+        return this.provider("product-category-list").request();
+    }
+    /**
+     * Get product by ID
+     * GET /api/v1/store/product/{id}
+     */
+    getProductById(productId) {
+        return this.provider("product-get-by-id").request(undefined, undefined, productId);
+    }
+    /**
+     * Get product collection
+     * GET /api/v1/store/product-collection
+     */
+    getProductCollection(payload) {
+        return this.provider("product-collection").request(payload, undefined, undefined);
+    }
+    /**
+     * Get product collection by store
+     * GET /api/v1/store/{id}/product-collection
+     */
+    getProductCollectionByStore(storeId, payload) {
+        return this.provider("product-collection-by-store").request(payload, undefined, storeId);
+    }
+}

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

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