@smess/networking 1.2.0 → 2.1.0

package/dist/services/storefront.order.service.js

@@ -1,99 +0,0 @@
-import { NetworkingUIEventWrapped, AlertModel, AlertButtonModel, } from "../types/types";
-import { Accept, SMESSHeader, SmessService } from "./smess.service";
-import { of } from "rxjs";
-export class StorefrontOrderProvider {
-    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 "order-list":
-                return "/storefront/orders";
-            case "order-detail":
-                return "/storefront/orders/${id}";
-            case "order-track":
-                return "/storefront/orders/track";
-            default:
-                return "/storefront/orders";
-        }
-    }
-    get method() {
-        switch (this.target) {
-            case "order-list":
-            case "order-detail":
-                return "GET";
-            case "order-track":
-                return "POST";
-            default:
-                return "GET";
-        }
-    }
-    get headers() {
-        // For order-track, don't include auth token (public endpoint)
-        const authToken = this.target === "order-track" ? null : this.$authToken.value;
-        let headers = SmessService.getHeaders(Accept.V1, authToken);
-        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 StorefrontOrderService {
-    constructor(config, $authToken) {
-        this.config = config;
-        this.$authToken = $authToken;
-    }
-    provider(target) {
-        const targetWrapper = new StorefrontOrderProvider(this.config, target, this.$authToken);
-        return new SmessService(targetWrapper);
-    }
-    /**
-     * List customer orders (requires authentication)
-     * GET /storefront/orders
-     */
-    listOrders(params) {
-        // Check authentication
-        if (!this.$authToken.value) {
-            const alertModel = new AlertModel("Authentication required to list orders", 401, true, "Authentication Required", null, [AlertButtonModel.buttonYes()]);
-            return of(NetworkingUIEventWrapped.failed(alertModel));
-        }
-        return this.provider("order-list").request(params);
-    }
-    /**
-     * Get order details (requires authentication)
-     * GET /storefront/orders/{id}
-     */
-    getOrderDetail(id) {
-        // Check authentication
-        if (!this.$authToken.value) {
-            const alertModel = new AlertModel("Authentication required to view order details", 401, true, "Authentication Required", null, [AlertButtonModel.buttonYes()]);
-            return of(NetworkingUIEventWrapped.failed(alertModel));
-        }
-        return this.provider("order-detail").request(null, undefined, id);
-    }
-    /**
-     * Track guest order (no authentication required)
-     * POST /storefront/orders/track
-     */
-    trackOrder(payload) {
-        return this.provider("order-track").request(payload);
-    }
-}

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

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

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

@@ -1,158 +0,0 @@
-import { StorefrontOrderService, StorefrontOrderProvider, } from "./storefront.order.service";
-import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
-import { of, BehaviorSubject } from "rxjs";
-describe("StorefrontOrderService", () => {
-    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 StorefrontOrderService(config, $authToken);
-    });
-    describe("StorefrontOrderProvider", () => {
-        it("should generate correct path for order-list", () => {
-            const provider = new StorefrontOrderProvider(config, "order-list", $authToken);
-            expect(provider.path).toBe("/storefront/orders");
-            expect(provider.method).toBe("GET");
-        });
-        it("should generate correct path for order-detail", () => {
-            const provider = new StorefrontOrderProvider(config, "order-detail", $authToken);
-            expect(provider.path).toBe("/storefront/orders/${id}");
-            expect(provider.method).toBe("GET");
-            expect(provider.getPath(123)).toBe("/storefront/orders/123");
-        });
-        it("should generate correct path for order-track", () => {
-            const provider = new StorefrontOrderProvider(config, "order-track", $authToken);
-            expect(provider.path).toBe("/storefront/orders/track");
-            expect(provider.method).toBe("POST");
-        });
-        it("should include auth token in headers for authenticated endpoints", () => {
-            $authToken.next("test-auth-token");
-            const provider = new StorefrontOrderProvider(config, "order-list", $authToken);
-            const headers = provider.headers;
-            expect(headers["Authorization"]).toBe("Bearer test-auth-token");
-        });
-        it("should not include auth token for order-track", () => {
-            $authToken.next("test-auth-token");
-            const provider = new StorefrontOrderProvider(config, "order-track", $authToken);
-            const headers = provider.headers;
-            expect(headers["Authorization"]).toBeUndefined();
-        });
-    });
-    describe("listOrders", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const result = await service.listOrders().toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-            expect(result?.alertModel?.message).toContain("Authentication required");
-        });
-        it("should list orders successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const params = {
-                page: 1,
-                limit: 20,
-                status: "completed",
-            };
-            const response = {
-                data: { orders: [], total: 0 },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.listOrders(params).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-        it("should handle list orders error when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.listOrders().toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("getOrderDetail", () => {
-        it("should return authentication error when not authenticated", async () => {
-            const result = await service.getOrderDetail(123).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-            expect(result?.alertModel?.httpErrorCode).toBe(401);
-            expect(result?.alertModel?.message).toContain("Authentication required");
-        });
-        it("should get order detail successfully when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const response = {
-                data: { id: 123, status: "completed" },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.getOrderDetail(123).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-        it("should handle get order detail error when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.getOrderDetail(123).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("trackOrder", () => {
-        it("should track order successfully without authentication", async () => {
-            const payload = {
-                orderNumber: "ORD-12345",
-                email: "customer@example.com",
-            };
-            const response = {
-                data: { id: 123, status: "shipped" },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.trackOrder(payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-        it("should handle track order error", async () => {
-            const payload = {
-                orderNumber: "ORD-12345",
-                email: "customer@example.com",
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.trackOrder(payload).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-        it("should track order even when authenticated", async () => {
-            $authToken.next("test-auth-token");
-            const payload = {
-                orderNumber: "ORD-67890",
-                email: "user@example.com",
-            };
-            const response = {
-                data: { id: 456, status: "delivered" },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.trackOrder(payload).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-    });
-});

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

@@ -1,52 +0,0 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
-import { SmessService } from "./smess.service";
-import { Observable } from "rxjs";
-export type StorefrontProductTarget = "product-list" | "product-collection" | "product-detail";
-export interface ProductListRequest {
-    page?: number;
-    limit?: number;
-    store_id?: number;
-    category?: string;
-    sub_category?: string;
-    min_price?: number;
-    max_price?: number;
-    in_stock?: boolean;
-    search?: string;
-}
-export interface StorefrontProductCollectionRequest extends ProductListRequest {
-    per_page?: number;
-    only_promoted?: boolean;
-    only_discounted?: boolean;
-    include_hidden?: boolean;
-    only_featured?: boolean;
-}
-export declare class StorefrontProductProvider implements ProviderType {
-    private readonly config;
-    private readonly target;
-    constructor(config: NetworkingConfig, target: StorefrontProductTarget);
-    get baseURL(): string;
-    get path(): string;
-    get method(): string;
-    get headers(): Record<string, string>;
-    getPath(...queryParams: unknown[]): string;
-}
-export declare class StorefrontProductService {
-    private readonly config;
-    constructor(config: NetworkingConfig);
-    provider(target: StorefrontProductTarget): SmessService<StorefrontProductProvider>;
-    /**
-     * List products with pagination and filtering
-     * GET /storefront/products
-     */
-    listProducts(params?: ProductListRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get product collection with per_page pagination style
-     * GET /storefront/products/collection
-     */
-    getProductCollection(params?: StorefrontProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get product details by ID
-     * GET /storefront/products/{id}
-     */
-    getProductDetail(id: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-}

package/dist/services/storefront.product.service.js

@@ -1,75 +0,0 @@
-import { Accept, SMESSHeader, SmessService } from "./smess.service";
-export class StorefrontProductProvider {
-    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 "product-list":
-                return "/storefront/products";
-            case "product-collection":
-                return "/storefront/products/collection";
-            case "product-detail":
-                return "/storefront/products/${id}";
-            default:
-                return "/storefront/products";
-        }
-    }
-    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 StorefrontProductService {
-    constructor(config) {
-        this.config = config;
-    }
-    provider(target) {
-        const targetWrapper = new StorefrontProductProvider(this.config, target);
-        return new SmessService(targetWrapper);
-    }
-    /**
-     * List products with pagination and filtering
-     * GET /storefront/products
-     */
-    listProducts(params) {
-        return this.provider("product-list").request(params);
-    }
-    /**
-     * Get product collection with per_page pagination style
-     * GET /storefront/products/collection
-     */
-    getProductCollection(params) {
-        return this.provider("product-collection").request(params);
-    }
-    /**
-     * Get product details by ID
-     * GET /storefront/products/{id}
-     */
-    getProductDetail(id) {
-        return this.provider("product-detail").request(null, undefined, id);
-    }
-}

package/dist/services/storefront.product.service.test.d.ts

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

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

@@ -1,120 +0,0 @@
-import { StorefrontProductService, StorefrontProductProvider, } from "./storefront.product.service";
-import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
-import { of } from "rxjs";
-describe("StorefrontProductService", () => {
-    const config = {
-        baseUrl: "https://api.example.com",
-        version: "api/v1",
-        isProd: false,
-        clientId: "test-client-id",
-        apiKey: "test-api-key",
-    };
-    let service;
-    beforeEach(() => {
-        service = new StorefrontProductService(config);
-    });
-    describe("StorefrontProductProvider", () => {
-        it("should generate correct path for product-list", () => {
-            const provider = new StorefrontProductProvider(config, "product-list");
-            expect(provider.path).toBe("/storefront/products");
-            expect(provider.method).toBe("GET");
-        });
-        it("should generate correct path for product-collection", () => {
-            const provider = new StorefrontProductProvider(config, "product-collection");
-            expect(provider.path).toBe("/storefront/products/collection");
-            expect(provider.method).toBe("GET");
-        });
-        it("should generate correct path for product-detail", () => {
-            const provider = new StorefrontProductProvider(config, "product-detail");
-            expect(provider.path).toBe("/storefront/products/${id}");
-            expect(provider.method).toBe("GET");
-            expect(provider.getPath(123)).toBe("/storefront/products/123");
-        });
-        it("should include correct headers", () => {
-            const provider = new StorefrontProductProvider(config, "product-list");
-            const headers = provider.headers;
-            expect(headers["X-Client-Id"]).toBe("test-client-id");
-            expect(headers["X-Api-Key"]).toBe("test-api-key");
-            expect(headers["Accept"]).toBe("application/json");
-        });
-        it("should generate correct baseURL with version", () => {
-            const provider = new StorefrontProductProvider(config, "product-list");
-            expect(provider.baseURL).toBe("https://api.example.com/api/v1");
-        });
-    });
-    describe("listProducts", () => {
-        it("should list products successfully", async () => {
-            const params = {
-                page: 1,
-                limit: 20,
-                store_id: 1,
-                category: "Electronics",
-            };
-            const response = {
-                data: { products: [], total: 0 },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.listProducts(params).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-        it("should handle list products error", async () => {
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.listProducts().toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("getProductCollection", () => {
-        it("should get product collection successfully", async () => {
-            const params = {
-                page: 1,
-                per_page: 20,
-                only_promoted: true,
-                only_discounted: false,
-            };
-            const response = {
-                data: { products: [], total: 0 },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.getProductCollection(params).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-        it("should handle get product collection error", async () => {
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.getProductCollection().toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-    describe("getProductDetail", () => {
-        it("should get product detail successfully", async () => {
-            const response = {
-                data: { id: 123, name: "Test Product" },
-            };
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
-            });
-            const result = await service.getProductDetail(123).toPromise();
-            expect(result?.hasSuccess).toBe(true);
-            expect(result?.response).toEqual(response);
-        });
-        it("should handle get product detail error", async () => {
-            jest.spyOn(service, "provider").mockReturnValue({
-                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
-            });
-            const result = await service.getProductDetail(123).toPromise();
-            expect(result?.hasFailed).toBe(true);
-            expect(result?.alertModel).toBeInstanceOf(AlertModel);
-        });
-    });
-});

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

@@ -1,54 +0,0 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse, CacheOptions } from "../types/types";
-import { SmessService } from "./smess.service";
-import { Observable } from "rxjs";
-export type StorefrontStoreTarget = "store-list" | "store-information";
-export interface StorefrontStoreData {
-    id: number;
-    data: HttpResponse;
-    timestamp: number;
-}
-export interface StorefrontStoreListData {
-    data: HttpResponse;
-    timestamp: number;
-}
-export declare class StorefrontStoreProvider implements ProviderType {
-    private readonly config;
-    private readonly target;
-    constructor(config: NetworkingConfig, target: StorefrontStoreTarget);
-    get baseURL(): string;
-    get path(): string;
-    get method(): string;
-    get headers(): Record<string, string>;
-    getPath(...queryParams: unknown[]): string;
-}
-export declare class StorefrontStoreService {
-    private readonly config;
-    private readonly cacheService;
-    private readonly storeListCache;
-    private readonly cacheOptions;
-    private readonly cacheDuration;
-    constructor(config: NetworkingConfig, cacheOptions?: CacheOptions);
-    provider(target: StorefrontStoreTarget): SmessService<StorefrontStoreProvider>;
-    /**
-     * List all accessible stores with shipping rules
-     * GET /storefront/stores/list
-     */
-    listStores(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Get detailed store information by ID including shipping rules
-     * GET /storefront/stores/{id}/information
-     */
-    getStoreInformation(id: number): Observable<NetworkingUIEventWrapped<HttpResponse>>;
-    /**
-     * Clear all cache
-     */
-    clearCache(): Promise<void>;
-    /**
-     * Clear cache for a specific store
-     */
-    clearStoreCache(id: number): Promise<void>;
-    /**
-     * Check if cache is still valid
-     */
-    private isCacheValid;
-}