@smess/networking 1.0.29 → 1.0.30

package/dist/services/storefront.checkout.service.test.js

@@ -0,0 +1,158 @@
+import { StorefrontCheckoutService, StorefrontCheckoutProvider, } from "./storefront.checkout.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("StorefrontCheckoutService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        version: "api/v1",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    let $authToken;
+    let $sessionToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        $sessionToken = new BehaviorSubject(null);
+        service = new StorefrontCheckoutService(config, $authToken, $sessionToken);
+    });
+    describe("StorefrontCheckoutProvider", () => {
+        it("should generate correct path for checkout-validate", () => {
+            const provider = new StorefrontCheckoutProvider(config, "checkout-validate", $sessionToken, $authToken);
+            expect(provider.path).toBe("/storefront/checkout/validate");
+            expect(provider.method).toBe("POST");
+        });
+        it("should generate correct path for checkout-process", () => {
+            const provider = new StorefrontCheckoutProvider(config, "checkout-process", $sessionToken, $authToken);
+            expect(provider.path).toBe("/storefront/checkout/process");
+            expect(provider.method).toBe("POST");
+        });
+        it("should include session token in headers when not authenticated", () => {
+            $sessionToken.next("test-session");
+            const provider = new StorefrontCheckoutProvider(config, "checkout-validate", $sessionToken, $authToken);
+            const headers = provider.headers;
+            expect(headers["X-Session-Token"]).toBe("test-session");
+        });
+        it("should include auth token in headers when authenticated", () => {
+            $authToken.next("test-auth-token");
+            $sessionToken.next("test-session");
+            const provider = new StorefrontCheckoutProvider(config, "checkout-validate", $sessionToken, $authToken);
+            const headers = provider.headers;
+            expect(headers["Authorization"]).toBe("Bearer test-auth-token");
+            expect(headers["X-Session-Token"]).toBeUndefined();
+        });
+    });
+    describe("validateCheckout", () => {
+        it("should validate checkout successfully", async () => {
+            const response = {
+                data: { isValid: true, errors: [], warnings: [] },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.validateCheckout().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle validate checkout error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.validateCheckout().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("processCheckout", () => {
+        it("should process checkout successfully", async () => {
+            const payload = {
+                billingInformation: {
+                    email: "test@example.com",
+                    street: "123 Main St",
+                    city: "Test City",
+                    postal_code: "12345",
+                },
+                shippingInformation: {
+                    email: "test@example.com",
+                    street: "123 Main St",
+                    city: "Test City",
+                    postal_code: "12345",
+                },
+                paymentMethod: "card",
+                deliveryType: "delivery",
+            };
+            const response = {
+                data: { orderId: 123, status: "completed" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.processCheckout(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle process checkout error", async () => {
+            const payload = {
+                billingInformation: {
+                    email: "test@example.com",
+                },
+                shippingInformation: {
+                    email: "test@example.com",
+                },
+                paymentMethod: "cash",
+                deliveryType: "pickup",
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.processCheckout(payload).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+        it("should process checkout with guest session token", async () => {
+            $sessionToken.next("guest-session-token");
+            const payload = {
+                billingInformation: {
+                    email: "guest@example.com",
+                },
+                shippingInformation: {
+                    email: "guest@example.com",
+                },
+                paymentMethod: "card",
+                deliveryType: "delivery",
+            };
+            const response = {
+                data: { orderId: 456, status: "completed" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.processCheckout(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should process checkout with authenticated user", async () => {
+            $authToken.next("auth-token");
+            const payload = {
+                billingInformation: {
+                    email: "user@example.com",
+                },
+                shippingInformation: {
+                    email: "user@example.com",
+                },
+                paymentMethod: "bank_transfer",
+                deliveryType: "pickup",
+            };
+            const response = {
+                data: { orderId: 789, status: "completed" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.processCheckout(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+});

package/dist/services/storefront.customer.metadata.service.d.ts

@@ -0,0 +1,91 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type StorefrontCustomerMetadataTarget = "metadata-get" | "favorites-add" | "favorites-list" | "favorites-update-category" | "favorites-remove" | "favorites-categories" | "preferences-update" | "product-view-record" | "recent-searches" | "recently-viewed";
+export interface AddFavoriteRequest {
+    productId: number;
+}
+export interface UpdateFavoriteCategoryRequest {
+    category: string;
+}
+export interface UpdatePreferencesRequest {
+    preferences: Record<string, unknown>;
+}
+export interface RecordProductViewRequest {
+    productId: number;
+}
+export declare class StorefrontCustomerMetadataProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: StorefrontCustomerMetadataTarget, $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 StorefrontCustomerMetadataService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: StorefrontCustomerMetadataTarget): SmessService<StorefrontCustomerMetadataProvider>;
+    /**
+     * Check if user is authenticated
+     */
+    private checkAuthentication;
+    /**
+     * Create authentication required error
+     */
+    private createAuthRequiredError;
+    /**
+     * Get customer metadata
+     * GET /storefront/customer/metadata?store_id={storeId}
+     */
+    getMetadata(storeId: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Add favorite product
+     * POST /storefront/customer/favorites?store_id={storeId}
+     */
+    addFavorite(storeId: number, payload: AddFavoriteRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * List favorite products
+     * GET /storefront/customer/favorites?store_id={storeId}&category={category}
+     */
+    listFavorites(storeId: number, category?: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Update favorite product category
+     * PUT /storefront/customer/favorites/{productId}/category?store_id={storeId}
+     */
+    updateFavoriteCategory(productId: number, storeId: number, payload: UpdateFavoriteCategoryRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Remove favorite product
+     * DELETE /storefront/customer/favorites/{productId}?store_id={storeId}
+     */
+    removeFavorite(productId: number, storeId: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * List favorite categories
+     * GET /storefront/customer/favorites/categories?store_id={storeId}
+     */
+    listFavoriteCategories(storeId: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Update customer preferences
+     * PUT /storefront/customer/preferences?store_id={storeId}
+     */
+    updatePreferences(storeId: number, payload: UpdatePreferencesRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Record product view
+     * POST /storefront/customer/product-view?store_id={storeId}
+     */
+    recordProductView(storeId: number, payload: RecordProductViewRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get recent searches
+     * GET /storefront/customer/recent-searches?store_id={storeId}
+     */
+    getRecentSearches(storeId: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    /**
+     * Get recently viewed products
+     * GET /storefront/customer/recently-viewed?store_id={storeId}&limit={limit}
+     */
+    getRecentlyViewed(storeId: number, limit?: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

package/dist/services/storefront.customer.metadata.service.js

@@ -0,0 +1,225 @@
+import { NetworkingUIEventWrapped, AlertModel, AlertButtonModel, } from "../types/types";
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { of } from "rxjs";
+export class StorefrontCustomerMetadataProvider {
+    constructor(config, target, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "metadata-get":
+                return "/storefront/customer/metadata";
+            case "favorites-add":
+                return "/storefront/customer/favorites";
+            case "favorites-list":
+                return "/storefront/customer/favorites";
+            case "favorites-update-category":
+                return "/storefront/customer/favorites/${productId}/category";
+            case "favorites-remove":
+                return "/storefront/customer/favorites/${productId}";
+            case "favorites-categories":
+                return "/storefront/customer/favorites/categories";
+            case "preferences-update":
+                return "/storefront/customer/preferences";
+            case "product-view-record":
+                return "/storefront/customer/product-view";
+            case "recent-searches":
+                return "/storefront/customer/recent-searches";
+            case "recently-viewed":
+                return "/storefront/customer/recently-viewed";
+            default:
+                return "/storefront/customer/metadata";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "metadata-get":
+            case "favorites-list":
+            case "favorites-categories":
+            case "recent-searches":
+            case "recently-viewed":
+                return "GET";
+            case "favorites-add":
+            case "product-view-record":
+                return "POST";
+            case "favorites-update-category":
+            case "preferences-update":
+                return "PUT";
+            case "favorites-remove":
+                return "DELETE";
+            default:
+                return "GET";
+        }
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        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 StorefrontCustomerMetadataService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new StorefrontCustomerMetadataProvider(this.config, target, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * Check if user is authenticated
+     */
+    checkAuthentication() {
+        return this.$authToken.value !== null && this.$authToken.value !== "";
+    }
+    /**
+     * Create authentication required error
+     */
+    createAuthRequiredError() {
+        const alertModel = new AlertModel("Authentication required to access customer metadata", 401, true, "Authentication Required", null, [AlertButtonModel.buttonYes()]);
+        return of(NetworkingUIEventWrapped.failed(alertModel));
+    }
+    /**
+     * Get customer metadata
+     * GET /storefront/customer/metadata?store_id={storeId}
+     */
+    getMetadata(storeId) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        return this.provider("metadata-get").request({
+            store_id: storeId,
+        });
+    }
+    /**
+     * Add favorite product
+     * POST /storefront/customer/favorites?store_id={storeId}
+     */
+    addFavorite(storeId, payload) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        return this.provider("favorites-add").request({
+            ...payload,
+            store_id: storeId,
+        });
+    }
+    /**
+     * List favorite products
+     * GET /storefront/customer/favorites?store_id={storeId}&category={category}
+     */
+    listFavorites(storeId, category) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        const params = { store_id: storeId };
+        if (category) {
+            params.category = category;
+        }
+        return this.provider("favorites-list").request(params);
+    }
+    /**
+     * Update favorite product category
+     * PUT /storefront/customer/favorites/{productId}/category?store_id={storeId}
+     */
+    updateFavoriteCategory(productId, storeId, payload) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        return this.provider("favorites-update-category").request({ ...payload, store_id: storeId }, undefined, productId);
+    }
+    /**
+     * Remove favorite product
+     * DELETE /storefront/customer/favorites/{productId}?store_id={storeId}
+     */
+    removeFavorite(productId, storeId) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        return this.provider("favorites-remove").request({ store_id: storeId }, undefined, productId);
+    }
+    /**
+     * List favorite categories
+     * GET /storefront/customer/favorites/categories?store_id={storeId}
+     */
+    listFavoriteCategories(storeId) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        return this.provider("favorites-categories").request({
+            store_id: storeId,
+        });
+    }
+    /**
+     * Update customer preferences
+     * PUT /storefront/customer/preferences?store_id={storeId}
+     */
+    updatePreferences(storeId, payload) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        return this.provider("preferences-update").request({
+            ...payload,
+            store_id: storeId,
+        });
+    }
+    /**
+     * Record product view
+     * POST /storefront/customer/product-view?store_id={storeId}
+     */
+    recordProductView(storeId, payload) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        return this.provider("product-view-record").request({
+            ...payload,
+            store_id: storeId,
+        });
+    }
+    /**
+     * Get recent searches
+     * GET /storefront/customer/recent-searches?store_id={storeId}
+     */
+    getRecentSearches(storeId) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        return this.provider("recent-searches").request({
+            store_id: storeId,
+        });
+    }
+    /**
+     * Get recently viewed products
+     * GET /storefront/customer/recently-viewed?store_id={storeId}&limit={limit}
+     */
+    getRecentlyViewed(storeId, limit) {
+        if (!this.checkAuthentication()) {
+            return this.createAuthRequiredError();
+        }
+        const params = { store_id: storeId };
+        if (limit !== undefined) {
+            params.limit = limit;
+        }
+        return this.provider("recently-viewed").request(params);
+    }
+}

package/dist/services/storefront.customer.metadata.service.test.d.ts

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