@smess/networking 1.0.16 → 1.0.19

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export * from "./services/user.service";
 export * from "./services/product.service";
 export * from "./services/auth.service";
 export * from "./services/store.service";
+export * from "./services/store.cart.service";
+export * from "./services/store.product.service";
 export * from "./services/customer.service";
 export * from "./services/order.service";
 export * from "./services/cache.service";

package/dist/index.js

@@ -2,6 +2,8 @@ export * from "./services/user.service";
 export * from "./services/product.service";
 export * from "./services/auth.service";
 export * from "./services/store.service";
+export * from "./services/store.cart.service";
+export * from "./services/store.product.service";
 export * from "./services/customer.service";
 export * from "./services/order.service";
 export * from "./services/cache.service";

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

@@ -0,0 +1,139 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type StoreCartTarget = "cart-get" | "cart-update" | "cart-add-item" | "cart-update-item" | "cart-delete-item" | "cart-delete-all-items";
+export interface BillingInformation {
+    email?: string;
+    phone_number?: string;
+    street?: string;
+    city?: string;
+    postal_code?: string;
+    state?: string;
+    country?: string;
+    [key: string]: unknown;
+}
+export interface ShippingInformation {
+    email?: string;
+    phone_number?: string;
+    street?: string;
+    city?: string;
+    postal_code?: string;
+    state?: string;
+    country?: string;
+    [key: string]: unknown;
+}
+export interface CartItem {
+    [key: string]: unknown;
+}
+export interface StoreInfo {
+    [key: string]: unknown;
+}
+export interface Cart {
+    dateCreated: string;
+    dateModified: string;
+    discountTotal: number;
+    discountTax: number;
+    shippingTotal: number;
+    shippingTax: number;
+    cartTax: number;
+    total: number;
+    totalTax: number;
+    customerId: string | null;
+    billingInformation: BillingInformation | null;
+    shippingInformation: ShippingInformation | null;
+    paymentMethod: string;
+    deliveryType: string;
+    transactionId: string | null;
+    customerIpAddress: string;
+    customerUserAgent: string;
+    customerNote: string | null;
+    cartHash: string;
+    cartItems: CartItem[];
+    paymentUrl: string | null;
+    store: StoreInfo | null;
+    [key: string]: unknown;
+}
+export interface CartUpdateRequest {
+    status?: string;
+    customer_note?: string;
+    customer_id?: string;
+    payment_method?: string;
+    delivery_type?: string;
+    billing_information?: BillingInformation;
+    shipping_information?: ShippingInformation;
+    [key: string]: unknown;
+}
+export interface CartAddItemRequest {
+    product_id: string;
+    quantity: number;
+    [key: string]: unknown;
+}
+export interface CartUpdateItemQuantityRequest {
+    quantity: number;
+}
+export declare class StoreCartProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $cartHash;
+    private readonly $storeId;
+    constructor(config: NetworkingConfig, target: StoreCartTarget, $cartHash: BehaviorSubject<string | null>, $storeId: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface StoreCartServiceType {
+    getCart(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    updateCart(payload: CartUpdateRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    addItem(payload: CartAddItemRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    updateItemQuantity(itemId: string, payload: CartUpdateItemQuantityRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    deleteItem(itemId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    deleteAllItems(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}
+export declare class StoreCartService implements StoreCartServiceType {
+    private readonly config;
+    private readonly $cartHash;
+    private readonly $storeId;
+    constructor(config: NetworkingConfig, $storeId?: BehaviorSubject<string | null>);
+    get currentCartHash(): string | null;
+    get cartHash$(): BehaviorSubject<string | null>;
+    get currentStoreId(): string | null;
+    get storeId$(): BehaviorSubject<string | null>;
+    setStoreId(storeId: string | null): void;
+    provider(target: StoreCartTarget): SmessService<StoreCartProvider>;
+    /**
+     * Update the cart hash from cart response
+     */
+    private updateCartHash;
+    /**
+     * Get the current cart
+     * GET api/v1/store/cart
+     */
+    getCart(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Update cart (e.g., add notes, apply coupon)
+     * PUT api/v1/store/cart
+     */
+    updateCart(payload: CartUpdateRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Add item to cart
+     * POST api/v1/store/cart/items
+     */
+    addItem(payload: CartAddItemRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Update item quantity in cart
+     * PUT api/v1/store/cart/items/{id}
+     */
+    updateItemQuantity(itemId: string, payload: CartUpdateItemQuantityRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Delete item from cart
+     * DELETE api/v1/store/cart/items/{id}
+     */
+    deleteItem(itemId: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Delete all items from cart
+     * DELETE api/v1/store/cart/items
+     */
+    deleteAllItems(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

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

@@ -0,0 +1,166 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { BehaviorSubject } from "rxjs";
+import { tap } from "rxjs/operators";
+export class StoreCartProvider {
+    constructor(config, target, $cartHash, $storeId) {
+        this.config = config;
+        this.target = target;
+        this.$cartHash = $cartHash;
+        this.$storeId = $storeId;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "cart-get":
+                return "/store/cart";
+            case "cart-update":
+                return "/store/cart";
+            case "cart-add-item":
+                return "/store/cart/items";
+            case "cart-update-item":
+                return "/store/cart/items/\${id}";
+            case "cart-delete-item":
+                return "/store/cart/items/\${id}";
+            case "cart-delete-all-items":
+                return "/store/cart/items";
+            default:
+                return "/store/cart";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "cart-get":
+                return "GET";
+            case "cart-update":
+                return "PUT";
+            case "cart-add-item":
+                return "POST";
+            case "cart-update-item":
+                return "PUT";
+            case "cart-delete-item":
+                return "DELETE";
+            case "cart-delete-all-items":
+                return "DELETE";
+            default:
+                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;
+        }
+        const filteredHeaders = SmessService.filterHeaders(headers);
+        // Add X-Nonce-Token header if cartHash is available
+        if (this.$cartHash.value) {
+            filteredHeaders["X-Nonce-Token"] = this.$cartHash.value;
+        }
+        // Add X-Store-Id header if storeId is available
+        if (this.$storeId.value) {
+            filteredHeaders["X-Store-Id"] = this.$storeId.value;
+        }
+        return filteredHeaders;
+    }
+    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 StoreCartService {
+    constructor(config, $storeId) {
+        this.config = config;
+        this.$cartHash = new BehaviorSubject(null);
+        // Use the provided BehaviorSubject or create a new one
+        this.$storeId = $storeId || new BehaviorSubject(null);
+    }
+    // Getter to access the current cart hash
+    get currentCartHash() {
+        return this.$cartHash.value;
+    }
+    // Getter to access the cart hash as observable
+    get cartHash$() {
+        return this.$cartHash;
+    }
+    // Getter to access the current store ID
+    get currentStoreId() {
+        return this.$storeId.value;
+    }
+    // Getter to access the store ID as observable
+    get storeId$() {
+        return this.$storeId;
+    }
+    // Method to update the store ID
+    setStoreId(storeId) {
+        this.$storeId.next(storeId);
+    }
+    provider(target) {
+        const targetWrapper = new StoreCartProvider(this.config, target, this.$cartHash, this.$storeId);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * Update the cart hash from cart response
+     */
+    updateCartHash(result) {
+        if (result.hasSuccess && result.response) {
+            const response = result.response;
+            // Try to extract cartHash from different possible structures
+            const cartHash = response.data?.cartHash || response.cartHash;
+            if (cartHash) {
+                this.$cartHash.next(cartHash);
+            }
+        }
+    }
+    /**
+     * Get the current cart
+     * GET api/v1/store/cart
+     */
+    getCart() {
+        return this.provider("cart-get").request().pipe(tap((result) => this.updateCartHash(result)));
+    }
+    /**
+     * Update cart (e.g., add notes, apply coupon)
+     * PUT api/v1/store/cart
+     */
+    updateCart(payload) {
+        return this.provider("cart-update").request(payload).pipe(tap((result) => this.updateCartHash(result)));
+    }
+    /**
+     * Add item to cart
+     * POST api/v1/store/cart/items
+     */
+    addItem(payload) {
+        return this.provider("cart-add-item").request(payload).pipe(tap((result) => this.updateCartHash(result)));
+    }
+    /**
+     * Update item quantity in cart
+     * PUT api/v1/store/cart/items/{id}
+     */
+    updateItemQuantity(itemId, payload) {
+        return this.provider("cart-update-item").request(payload, undefined, itemId).pipe(tap((result) => this.updateCartHash(result)));
+    }
+    /**
+     * Delete item from cart
+     * DELETE api/v1/store/cart/items/{id}
+     */
+    deleteItem(itemId) {
+        return this.provider("cart-delete-item").request(undefined, undefined, itemId);
+    }
+    /**
+     * Delete all items from cart
+     * DELETE api/v1/store/cart/items
+     */
+    deleteAllItems() {
+        return this.provider("cart-delete-all-items").request();
+    }
+}

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

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

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

@@ -0,0 +1,335 @@
+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("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);
+        });
+    });
+});