@smess/networking 1.0.23 → 1.0.24

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>>;
+}

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

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

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

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