@smess/networking 1.0.29 → 1.1.0

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

@@ -0,0 +1,42 @@
+import { BaseProvider } from "../core/base.provider";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+// ProductProvider implements ProviderType for product endpoints
+export class ProductProvider extends BaseProvider {
+    constructor(config, { productId, method } = {}) {
+        super({
+            config,
+            path: productId ? `/products/${productId}` : "/products",
+            method: method || "GET",
+            headers: { "Content-Type": "application/json" },
+            getPath: () => (productId ? `/products/${productId}` : "/products"),
+        });
+    }
+}
+// ProductService provides high-level methods for product API
+export class ProductService extends BaseServiceWrapper {
+    constructor(config, productId, method) {
+        super(new ProductProvider(config, { productId, method }));
+        this.config = config;
+    }
+    // Fetch a product by ID
+    fetchProductById(id) {
+        this.provider = new ProductProvider(this.config, { productId: id });
+        return this.request();
+    }
+    // Fetch all products
+    fetchAllProducts() {
+        this.provider = new ProductProvider(this.config);
+        return this.request();
+    }
+    // Create a new product (POST)
+    createProduct(product) {
+        this.provider = new ProductProvider(this.config, { method: "POST" });
+        return this.request(product);
+    }
+}
+// Example usage:
+// setNetworkingConfig({ baseUrl: 'https://fakestoreapi.com', isProd: false });
+// const productService = new ProductService();
+// productService.fetchProductById(1).subscribe(result => console.log(result));
+// productService.fetchAllProducts().subscribe(result => console.log(result));
+// productService.createProduct({ name: 'New Product', price: 99.99 }).subscribe(result => console.log(result));

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

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

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

@@ -0,0 +1,61 @@
+import { ProductService } from "./product.service";
+import { NetworkingUIEventWrapped } from "../types/types";
+import { of, throwError } from "rxjs";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+describe("ProductService", () => {
+    const config = {
+        baseUrl: "https://jsonplaceholder.typicode.com",
+        isProd: false,
+        clientId: "test-client",
+        apiKey: "test-key",
+    };
+    const product = { id: 1, name: "Product", price: 10 };
+    let requestSpy;
+    beforeEach(() => {
+        requestSpy = jest
+            .spyOn(BaseServiceWrapper.prototype, "request")
+            .mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(product)));
+    });
+    afterEach(() => {
+        requestSpy.mockRestore();
+    });
+    it("should fetch product by id", (done) => {
+        const service = new ProductService(config, 1);
+        service
+            .fetchProductById(1)
+            .subscribe((result) => {
+            expect(result.response).toEqual(product);
+            done();
+        });
+    });
+    it("should fetch all products", (done) => {
+        const service = new ProductService(config);
+        service
+            .fetchAllProducts()
+            .subscribe((result) => {
+            expect(result.response).toEqual(product);
+            done();
+        });
+    });
+    it("should create a product", (done) => {
+        const service = new ProductService(config);
+        service
+            .createProduct({ name: "New Product", price: 99.99 })
+            .subscribe((result) => {
+            expect(result.response).toEqual(product);
+            done();
+        });
+    });
+    it("request should handle error", (done) => {
+        requestSpy.mockImplementationOnce(() => throwError(() => new Error("Test error")));
+        const service = new ProductService(config);
+        // Simulate error by calling a method that uses request
+        service.fetchProductById(1).subscribe({
+            error: (err) => {
+                expect(err).toBeInstanceOf(Error);
+                expect(err.message).toBe("Test error");
+                done();
+            },
+        });
+    });
+});

package/dist/src/services/smess.service.d.ts

@@ -0,0 +1,36 @@
+import { HeaderType, NetworkingUIEventWrapped, ProviderType } from "../types/types";
+import { Observable } from "../utils/rxjs-import";
+export declare enum SMESSHeader {
+    ContentType = "Content-Type",
+    Authorization = "Authorization",
+    Accept = "Accept",
+    ApiKey = "X-Api-Key",
+    ClientId = "X-Client-Id"
+}
+export declare enum ContentType {
+    Json = "application/json",
+    FormURLEncoded = "application/x-www-form-urlencoded"
+}
+export declare enum Accept {
+    V1 = "application/json",
+    V2 = "application/vnd.smess.v2+json",
+    V3 = "application/vnd.smess.v3+json",
+    V4 = "application/vnd.smess.v4+json",
+    V5 = "application/vnd.smess.v5+json",
+    V6 = "application/vnd.smess.v6+json",
+    V7 = "application/vnd.smess.v7+json",
+    V8 = "application/vnd.smess.v8+json",
+    V9 = "application/vnd.smess.v9+json",
+    V10 = "application/vnd.smess.v10+json"
+}
+export declare class SmessService<T extends ProviderType> {
+    private httpService;
+    private target;
+    constructor(target: T);
+    static getHeaders(version: Accept, authorization?: string | null, options?: HeaderType): Partial<Record<SMESSHeader, string | undefined>>;
+    static filterHeaders(headers: Partial<Record<SMESSHeader, string | undefined>>): Record<string, string>;
+    private static commonHeaders;
+    request<R = unknown>(request?: unknown, mockResponse?: R, ...queryParams: unknown[]): Observable<NetworkingUIEventWrapped<R>>;
+    private transformAxiosError;
+    private transformAxiosResponse;
+}

package/dist/src/services/smess.service.js

@@ -0,0 +1,128 @@
+import { AlertButtonModel, AlertModel, NetworkingUIEventWrapped, } from "../types/types";
+import { catchError, mergeMap, of, startWith, } from "../utils/rxjs-import";
+import HttpService from "../core/rx.http.service";
+import { $logger } from "../services/logger.service";
+export var SMESSHeader;
+(function (SMESSHeader) {
+    SMESSHeader["ContentType"] = "Content-Type";
+    SMESSHeader["Authorization"] = "Authorization";
+    SMESSHeader["Accept"] = "Accept";
+    SMESSHeader["ApiKey"] = "X-Api-Key";
+    SMESSHeader["ClientId"] = "X-Client-Id";
+})(SMESSHeader || (SMESSHeader = {}));
+export var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["FormURLEncoded"] = "application/x-www-form-urlencoded";
+})(ContentType || (ContentType = {}));
+export var Accept;
+(function (Accept) {
+    Accept["V1"] = "application/json";
+    Accept["V2"] = "application/vnd.smess.v2+json";
+    Accept["V3"] = "application/vnd.smess.v3+json";
+    Accept["V4"] = "application/vnd.smess.v4+json";
+    Accept["V5"] = "application/vnd.smess.v5+json";
+    Accept["V6"] = "application/vnd.smess.v6+json";
+    Accept["V7"] = "application/vnd.smess.v7+json";
+    Accept["V8"] = "application/vnd.smess.v8+json";
+    Accept["V9"] = "application/vnd.smess.v9+json";
+    Accept["V10"] = "application/vnd.smess.v10+json";
+})(Accept || (Accept = {}));
+export class SmessService {
+    constructor(target) {
+        this.target = target;
+        // Set default headers
+        $logger.info("SmessService initialized", {
+            target: this.target,
+            baseURL: this.target.baseURL,
+            method: this.target.method,
+            headers: this.target.headers,
+        }, "SmessService");
+        this.httpService = HttpService.create({
+            baseURL: this.target.baseURL,
+            headers: this.target.headers,
+            method: this.target.method,
+        });
+        this.httpService.interceptors.response.use((response) => response, async (error) => {
+            const originalRequest = error.config;
+            if (error.response?.status === 401 && !originalRequest._retry) {
+                originalRequest._retry = true;
+                $logger.info("SmessService constructor - 401 retry", originalRequest, "SmessService");
+                // Implement token refresh logic here
+                // Then retry the original request
+                // return httpService.request(originalRequest);
+            }
+            return Promise.reject(error);
+        });
+    }
+    static getHeaders(version, authorization = null, options) {
+        const headers = this.commonHeaders(version, options);
+        if (authorization) {
+            headers["Authorization"] = 'Bearer ' + authorization;
+        }
+        return headers;
+    }
+    static filterHeaders(headers) {
+        const filteredHeaders = Object.fromEntries(Object.entries(headers).filter(([_, value]) => value !== undefined && value !== null && value !== ""));
+        return filteredHeaders;
+    }
+    static commonHeaders(version, options) {
+        const { shouldAddClientIdHeader = true } = options ?? {};
+        const headers = {
+            Accept: version,
+            Authorization: "",
+            "Content-Type": ContentType.Json,
+            "X-Api-Key": "",
+        };
+        return headers;
+    }
+    // MARK: - Public
+    request(request, mockResponse, ...queryParams) {
+        const url = queryParams.length
+            ? this.target.getPath(...queryParams)
+            : this.target.path;
+        const config = { url };
+        let observable;
+        if (this.target.method === "GET") {
+            if (request) {
+                config.data = request;
+                config.params = request;
+            }
+            observable = this.httpService.get(url, config);
+        }
+        else if (this.target.method === "POST") {
+            observable = this.httpService.post(url, request, config);
+        }
+        else if (this.target.method === "PATCH") {
+            observable = this.httpService.patch(url, request, config);
+        }
+        else if (this.target.method === "PUT") {
+            observable = this.httpService.put(url, request, config);
+        }
+        else {
+            observable = this.httpService.request(config);
+        }
+        return observable.pipe(catchError((error) => this.transformAxiosError(error, mockResponse)), mergeMap((data) => this.transformAxiosResponse(data)), startWith(NetworkingUIEventWrapped.waiting()));
+    }
+    // MARK: - Private
+    transformAxiosError(error, mockResponse) {
+        $logger.error("transformAxiosError", error, "SmessService");
+        const message = error instanceof Error ? error.message : String(error);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for axios compatibility
+        const response = error.response;
+        const httpErrorCode = response ? response.status : 0;
+        const title = response?.statusText;
+        const alertModel = new AlertModel(message, httpErrorCode, true, title, response?.data, [AlertButtonModel.buttonYes()]);
+        if (mockResponse) {
+            return of(NetworkingUIEventWrapped.succeeded(mockResponse));
+        }
+        return of(NetworkingUIEventWrapped.failed(alertModel));
+    }
+    transformAxiosResponse(response) {
+        $logger.info("transformAxiosResponse", response, "SmessService");
+        if (response instanceof NetworkingUIEventWrapped) {
+            return of(response);
+        }
+        return of(NetworkingUIEventWrapped.succeeded(response.data));
+    }
+}

package/dist/src/services/smess.service.test.d.ts

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

package/dist/src/services/smess.service.test.js

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for test mocks */
+import { SmessService } from "./smess.service";
+import { NetworkingUIEventWrapped, } from "../types/types";
+import { of, throwError } from "rxjs";
+describe("SmessService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        isProd: false,
+        clientId: "test-client",
+        apiKey: "test-key",
+    };
+    const provider = {
+        baseURL: config.baseUrl,
+        path: "/resource",
+        method: "GET",
+        headers: {},
+        getPath: () => "/resource",
+    };
+    it("should return succeeded for GET", (done) => {
+        const service = new SmessService(provider);
+        service["httpService"] = {
+            get: jest.fn(() => of({ data: { foo: "bar" } })),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn(),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request().subscribe((result) => {
+            if (result.hasSuccess) {
+                expect(result.response).toEqual({ foo: "bar" });
+                done();
+            }
+        });
+    });
+    it("should return succeeded for POST", (done) => {
+        const postProvider = { ...provider, method: "POST" };
+        const service = new SmessService(postProvider);
+        service["httpService"] = {
+            get: jest.fn(),
+            post: jest.fn(() => of({ data: { foo: "baz" } })),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn(),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service
+            .request({ some: "data" })
+            .subscribe((result) => {
+            if (result.hasSuccess) {
+                expect(result.response).toEqual({ foo: "baz" });
+                done();
+            }
+        });
+    });
+    it("should handle error", (done) => {
+        const service = new SmessService(provider);
+        service["httpService"] = {
+            get: jest.fn(() => throwError(() => new Error("Test error"))),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn(),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request().subscribe((result) => {
+            if (result.hasFailed) {
+                expect(result).toBeInstanceOf(NetworkingUIEventWrapped);
+                expect(result.hasFailed).toBe(true);
+                expect(result.alertModel).toBeTruthy();
+                expect(result.alertModel?.message).toBe("Test error");
+                done();
+            }
+        });
+    });
+    it("should return mock response if provided", (done) => {
+        const service = new SmessService(provider);
+        service["httpService"] = {
+            get: jest.fn(() => throwError(() => new Error("Test error"))),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn((payload, mockResponse) => {
+                if (payload === "error") {
+                    return throwError(() => new Error("Test error"));
+                }
+                if (mockResponse !== undefined) {
+                    return of(NetworkingUIEventWrapped.succeeded(mockResponse));
+                }
+                return of({ data: { foo: "mock" } });
+            }),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service
+            .request(undefined, { foo: "mock" })
+            .subscribe((result) => {
+            if (result.hasSuccess) {
+                expect(result.response).toEqual({ foo: "mock" });
+                done();
+            }
+        });
+    });
+});

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

@@ -0,0 +1,158 @@
+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" | "cart-batch-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 interface CartBatchItemsRequest {
+    create?: Array<{
+        product_id: string;
+        quantity: number;
+        [key: string]: unknown;
+    }>;
+    update?: Array<{
+        product_id: string;
+        quantity: number;
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+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>>;
+    batchItems(payload: CartBatchItemsRequest): 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>>;
+    /**
+     * Batch create/update items in cart
+     * POST api/v1/store/cart/items/batch
+     */
+    batchItems(payload: CartBatchItemsRequest): 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>>;
+}