@smess/networking 1.2.0 → 2.1.0

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

@@ -1,91 +0,0 @@
-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

@@ -1,225 +0,0 @@
-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

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

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

@@ -1,271 +0,0 @@
-import { StorefrontCustomerMetadataService, StorefrontCustomerMetadataProvider, } from "./storefront.customer.metadata.service";
-import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
-import { of, BehaviorSubject } from "rxjs";
-describe("StorefrontCustomerMetadataService", () => {
-    const config = {
-        baseUrl: "https://api.example.com",
-        version: "api/v1",
-        isProd: false,
-        clientId: "test-client-id",
-        apiKey: "test-api-key",
-    };
-    let service;
-    let $authToken;
-    beforeEach(() => {
-        $authToken = new BehaviorSubject(null);
-        service = new StorefrontCustomerMetadataService(config, $authToken);
-    });
-    describe("StorefrontCustomerMetadataProvider", () => {
-        it("should generate correct path for metadata-get", () => {
-            const provider = new StorefrontCustomerMetadataProvider(config, "metadata-get", $authToken);
-            expect(provider.path).toBe("/storefront/customer/metadata");
-            expect(provider.method).toBe("GET");
-        });
-        it("should generate correct path for favorites-add", () => {
-            const provider = new StorefrontCustomerMetadataProvider(config, "favorites-add", $authToken);
-            expect(provider.path).toBe("/storefront/customer/favorites");
-            expect(provider.method).toBe("POST");
-        });
-        it("should generate correct path for favorites-update-category", () => {
-            const provider = new StorefrontCustomerMetadataProvider(config, "favorites-update-category", $authToken);
-            expect(provider.path).toBe("/storefront/customer/favorites/${productId}/category");
-            expect(provider.method).toBe("PUT");
-            expect(provider.getPath(123)).toBe("/storefront/customer/favorites/123/category");
-        });
-        it("should include auth token in headers", () => {
-            $authToken.next("test-auth-token");
-            const provider = new StorefrontCustomerMetadataProvider(config, "metadata-get", $authToken);
-            const headers = provider.headers;
-            expect(headers["Authorization"]).toBe("Bearer test-auth-token");
-        });
-    });
-    describe("getMetadata", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const result = await service.getMetadata(1).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should get metadata successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { customerId: "123", preferences: {} },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.getMetadata(1).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-    describe("addFavorite", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const payload = { productId: 123 };
-            const result = await service.addFavorite(1, payload).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should add favorite successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const payload = { productId: 123 };
-            const response = {
-                data: { id: 1, productId: 123 },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.addFavorite(1, payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-    describe("listFavorites", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const result = await service.listFavorites(1).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should list favorites successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { favorites: [] },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.listFavorites(1).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-        it("should list favorites with category filter", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { favorites: [] },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service
-                .listFavorites(1, "Electronics")
-                .toPromise();
-            expect(result?.hasSuccess).toBe(true);
-        });
-    });
-    describe("updateFavoriteCategory", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const payload = { category: "Books" };
-            const result = await service
-                .updateFavoriteCategory(123, 1, payload)
-                .toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should update favorite category successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const payload = { category: "Books" };
-            const response = {
-                data: { id: 1, category: "Books" },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: (_payload, _mockResponse, productId) => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service
-                .updateFavoriteCategory(123, 1, payload)
-                .toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-    describe("removeFavorite", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const result = await service.removeFavorite(123, 1).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should remove favorite successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { message: "Favorite removed" },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: (_payload, _mockResponse, productId) => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.removeFavorite(123, 1).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-    describe("listFavoriteCategories", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const result = await service.listFavoriteCategories(1).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should list favorite categories successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { categories: ["Books", "Electronics"] },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.listFavoriteCategories(1).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-    describe("updatePreferences", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const payload = { preferences: {} };
-            const result = await service.updatePreferences(1, payload).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should update preferences successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const payload = {
-                preferences: { theme: "dark" },
-            };
-            const response = {
-                data: { preferences: { theme: "dark" } },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.updatePreferences(1, payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-    describe("recordProductView", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const payload = { productId: 123 };
-            const result = await service.recordProductView(1, payload).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should record product view successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const payload = { productId: 123 };
-            const response = {
-                data: { message: "Product view recorded" },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.recordProductView(1, payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-    describe("getRecentSearches", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const result = await service.getRecentSearches(1).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should get recent searches successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { searches: ["laptop", "phone"] },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.getRecentSearches(1).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-    describe("getRecentlyViewed", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const result = await service.getRecentlyViewed(1).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-        });
-        it("should get recently viewed successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { products: [] },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.getRecentlyViewed(1).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-        it("should get recently viewed with limit", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { products: [] },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.getRecentlyViewed(1, 10).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-        });
-    });
-});

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

@@ -1,45 +0,0 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
-import { SmessService } from "./smess.service";
-import { BehaviorSubject, Observable } from "rxjs";
-export type StorefrontOrderTarget = "order-list" | "order-detail" | "order-track";
-export interface OrderListRequest {
-    page?: number;
-    limit?: number;
-    status?: string;
-}
-export interface TrackOrderRequest {
-    orderNumber: string;
-    email: string;
-}
-export declare class StorefrontOrderProvider implements ProviderType {
-    private readonly config;
-    private readonly target;
-    private readonly $authToken;
-    constructor(config: NetworkingConfig, target: StorefrontOrderTarget, $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 StorefrontOrderService {
-    private readonly config;
-    private readonly $authToken;
-    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
-    provider(target: StorefrontOrderTarget): SmessService<StorefrontOrderProvider>;
-    /**
-     * List customer orders (requires authentication)
-     * GET /storefront/orders
-     */
-    listOrders(params?: OrderListRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get order details (requires authentication)
-     * GET /storefront/orders/{id}
-     */
-    getOrderDetail(id: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Track guest order (no authentication required)
-     * POST /storefront/orders/track
-     */
-    trackOrder(payload: TrackOrderRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-}