@smess/networking 1.0.29 → 1.0.30

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

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

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

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

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

@@ -0,0 +1,52 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } 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;
+    constructor(config: NetworkingConfig);
+    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 (24 hours)
+     */
+    private isCacheValid;
+}

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

@@ -0,0 +1,140 @@
+import { NetworkingUIEventWrapped, } from "../types/types";
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { from, of } from "rxjs";
+import { map, switchMap, catchError } from "rxjs/operators";
+import { GenericIndexedDBService } from "./cache.service";
+export class StorefrontStoreProvider {
+    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 "store-list":
+                return "/storefront/stores/list";
+            case "store-information":
+                return "/storefront/stores/${id}/information";
+            default:
+                return "/storefront/stores/list";
+        }
+    }
+    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 StorefrontStoreService {
+    constructor(config) {
+        this.config = config;
+        // Initialize cache services for different data types
+        this.cacheService = new GenericIndexedDBService("StorefrontStoreCache", "id, timestamp", (data) => data, (data) => data);
+        this.storeListCache = new GenericIndexedDBService("StorefrontStoreListCache", "timestamp", (data) => data, (data) => data);
+    }
+    provider(target) {
+        const targetWrapper = new StorefrontStoreProvider(this.config, target);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * List all accessible stores with shipping rules
+     * GET /storefront/stores/list
+     */
+    listStores() {
+        return from(this.storeListCache.getAll("storefront-store-list")).pipe(switchMap((cachedData) => {
+            if (cachedData &&
+                cachedData.length > 0 &&
+                this.isCacheValid(cachedData[0].timestamp)) {
+                return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
+            }
+            return this.provider("store-list")
+                .request()
+                .pipe(map((response) => {
+                if (response.response) {
+                    this.storeListCache.saveAll([
+                        {
+                            data: response.response,
+                            timestamp: Date.now(),
+                        },
+                    ], "storefront-store-list");
+                }
+                return response;
+            }), catchError((error) => {
+                if (cachedData && cachedData.length > 0) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData[0].data));
+                }
+                throw error;
+            }));
+        }));
+    }
+    /**
+     * Get detailed store information by ID including shipping rules
+     * GET /storefront/stores/{id}/information
+     */
+    getStoreInformation(id) {
+        return from(this.cacheService.getOne(String(id))).pipe(switchMap((cachedData) => {
+            if (cachedData && this.isCacheValid(cachedData.timestamp)) {
+                return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+            }
+            return this.provider("store-information")
+                .request(null, undefined, id)
+                .pipe(map((response) => {
+                if (response.response) {
+                    this.cacheService.saveOne({
+                        id,
+                        data: response.response,
+                        timestamp: Date.now(),
+                    });
+                }
+                return response;
+            }), catchError((error) => {
+                if (cachedData) {
+                    return of(NetworkingUIEventWrapped.succeeded(cachedData.data));
+                }
+                throw error;
+            }));
+        }));
+    }
+    /**
+     * Clear all cache
+     */
+    clearCache() {
+        return Promise.all([
+            this.cacheService.clearAll(),
+            this.storeListCache.clearAll(),
+        ]).then(() => { });
+    }
+    /**
+     * Clear cache for a specific store
+     */
+    clearStoreCache(id) {
+        return this.cacheService.delete(String(id));
+    }
+    /**
+     * Check if cache is still valid (24 hours)
+     */
+    isCacheValid(timestamp) {
+        const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours
+        return Date.now() - timestamp < CACHE_DURATION;
+    }
+}

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

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

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

@@ -0,0 +1,90 @@
+import { StorefrontStoreService, StorefrontStoreProvider, } from "./storefront.store.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of } from "rxjs";
+describe("StorefrontStoreService", () => {
+    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 StorefrontStoreService(config);
+    });
+    describe("StorefrontStoreProvider", () => {
+        it("should generate correct path for store-list", () => {
+            const provider = new StorefrontStoreProvider(config, "store-list");
+            expect(provider.path).toBe("/storefront/stores/list");
+            expect(provider.method).toBe("GET");
+        });
+        it("should generate correct path for store-information", () => {
+            const provider = new StorefrontStoreProvider(config, "store-information");
+            expect(provider.path).toBe("/storefront/stores/${id}/information");
+            expect(provider.method).toBe("GET");
+            expect(provider.getPath(1)).toBe("/storefront/stores/1/information");
+        });
+        it("should include correct headers", () => {
+            const provider = new StorefrontStoreProvider(config, "store-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 StorefrontStoreProvider(config, "store-list");
+            expect(provider.baseURL).toBe("https://api.example.com/api/v1");
+        });
+    });
+    describe("listStores", () => {
+        it("should list stores successfully", async () => {
+            const response = {
+                data: { stores: [], total: 0 },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.listStores().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle list stores error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.listStores().toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("getStoreInformation", () => {
+        it("should get store information successfully", async () => {
+            const response = {
+                data: { id: 1, name: "Test Store" },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getStoreInformation(1).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle get store information error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.getStoreInformation(1).toPromise();
+            expect(result?.hasFailed).toBe(true);
+            expect(result?.alertModel).toBeInstanceOf(AlertModel);
+        });
+    });
+    describe("cache management", () => {
+        it("should clear all cache", async () => {
+            await expect(service.clearCache()).resolves.toBeUndefined();
+        });
+        it("should clear specific store cache", async () => {
+            await expect(service.clearStoreCache(1)).resolves.toBeUndefined();
+        });
+    });
+});

package/dist/src/core/axios.d.ts

@@ -0,0 +1,51 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "../utils/networking-import";
+import type { AxiosInterceptorManager } from "axios";
+import { AxiosObservable } from "./axios.observable";
+export interface Axiosable {
+    request<T = unknown>(config: AxiosRequestConfig): AxiosObservable<T>;
+    get<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    head<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    patch<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    delete<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+}
+declare class Axios implements Axiosable {
+    private axiosInstance;
+    static defaults: Omit<import("axios").AxiosDefaults<any>, "headers"> & {
+        headers: import("axios").HeadersDefaults & {
+            [key: string]: import("axios").AxiosHeaderValue;
+        };
+    };
+    static interceptors: {
+        request: AxiosInterceptorManager<import("axios").InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+    constructor(axiosInstance: AxiosInstance);
+    get defaults(): Omit<import("axios").AxiosDefaults<any>, "headers"> & {
+        headers: import("axios").HeadersDefaults & {
+            [key: string]: import("axios").AxiosHeaderValue;
+        };
+    };
+    get interceptors(): {
+        request: AxiosInterceptorManager<import("axios").InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+    static request<T = any>(config: AxiosRequestConfig): AxiosObservable<T>;
+    static get<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static delete<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static head<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static create(config: AxiosRequestConfig): Axios;
+    request<T = any>(config: AxiosRequestConfig): AxiosObservable<T>;
+    get<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    head<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+}
+export default Axios;
+export { Axios };

package/dist/src/core/axios.js

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for axios compatibility */
+import { axios, } from "../utils/networking-import";
+import { createObservable } from "./axios.observable";
+class Axios {
+    constructor(axiosInstance) {
+        this.axiosInstance = axiosInstance;
+    }
+    get defaults() {
+        return this.axiosInstance.defaults;
+    }
+    get interceptors() {
+        return this.axiosInstance.interceptors;
+    }
+    // ----- Static Methods -----
+    static request(config) {
+        return createObservable(axios.request, [config]);
+    }
+    static get(url, config) {
+        return createObservable(axios.get, [url, config]);
+    }
+    static post(url, data, config) {
+        return createObservable(axios.post, [url, data, config]);
+    }
+    static put(url, data, config) {
+        return createObservable(axios.put, [url, data, config]);
+    }
+    static patch(url, data, config) {
+        return createObservable(axios.patch, [url, data, config]);
+    }
+    static delete(url, config) {
+        return createObservable(axios.delete, [url, config]);
+    }
+    static head(url, config) {
+        return createObservable(axios.head, [url, config]);
+    }
+    static create(config) {
+        return new Axios(axios.create(config));
+    }
+    // ----- Instance Methods -----
+    request(config) {
+        return createObservable(this.axiosInstance.request, [config]);
+    }
+    get(url, config) {
+        return createObservable(this.axiosInstance.get, [url, config]);
+    }
+    head(url, config) {
+        return createObservable(this.axiosInstance.head, [url, config]);
+    }
+    post(url, data, config) {
+        return createObservable(this.axiosInstance.post, [url, data, config]);
+    }
+    put(url, data, config) {
+        return createObservable(this.axiosInstance.put, [url, data, config]);
+    }
+    patch(url, data, config) {
+        return createObservable(this.axiosInstance.patch, [url, data, config]);
+    }
+    delete(url, config) {
+        return createObservable(this.axiosInstance.delete, [url, config]);
+    }
+}
+Axios.defaults = axios.defaults;
+Axios.interceptors = axios.interceptors;
+export default Axios;
+export { Axios };

package/dist/src/core/axios.observable.d.ts

@@ -0,0 +1,11 @@
+import { AxiosResponse } from "../utils/networking-import";
+import type { AxiosPromise } from "axios";
+import { Observable } from "../utils/rxjs-import";
+export type AxiosObservable<T> = Observable<AxiosResponse<T>>;
+interface ObservableOptions {
+    retry?: number;
+    timeoutMs?: number;
+    cache?: boolean;
+}
+export declare function createObservable<T>(promiseFactory: (...args: any[]) => AxiosPromise<T>, args: any[], options?: ObservableOptions): AxiosObservable<T>;
+export {};

package/dist/src/core/axios.observable.js

@@ -0,0 +1,58 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for axios compatibility */
+import { axios, } from "../utils/networking-import";
+import { Observable, timeout as rxTimeout, retry as rxRetry, shareReplay, catchError, throwError, } from "../utils/rxjs-import";
+import { $logger } from "../services/logger.service";
+export function createObservable(promiseFactory, args, options = {}) {
+    let config = args[args.length - 1];
+    if (config && typeof config === "object" && !Array.isArray(config)) {
+        config = { ...config };
+    }
+    else {
+        config = {};
+        args.push(config);
+    }
+    let cancelSource = null;
+    const hasCancelToken = !!config.cancelToken;
+    if (!hasCancelToken) {
+        $logger.warn("[Networking] You can omit cancelToken — unsubscribing cancels the request automatically.", undefined, "axios.observable");
+    }
+    let source$ = new Observable((subscriber) => {
+        if (!hasCancelToken) {
+            cancelSource = axios.CancelToken.source();
+            config.cancelToken = cancelSource.token;
+        }
+        promiseFactory(...args)
+            .then((response) => {
+            subscriber.next(response);
+            subscriber.complete();
+        })
+            .catch((error) => {
+            if (!subscriber.closed) {
+                subscriber.error(error);
+            }
+        });
+        return () => {
+            if (cancelSource) {
+                cancelSource.cancel("Request canceled via unsubscribe.");
+            }
+        };
+    });
+    // Add timeout if specified
+    if (options.timeoutMs) {
+        source$ = source$.pipe(rxTimeout(options.timeoutMs));
+    }
+    // Add retry logic
+    if (options.retry) {
+        source$ = source$.pipe(rxRetry(options.retry));
+    }
+    // Cache the response if needed
+    if (options.cache) {
+        source$ = source$.pipe(shareReplay({ bufferSize: 1, refCount: false }));
+    }
+    // Optional: Log or catch errors globally
+    source$ = source$.pipe(catchError((err) => {
+        $logger.error("[createObservable error]:", err, "axios.observable");
+        return throwError(() => err);
+    }));
+    return source$;
+}

package/dist/src/core/base.provider.advanced.test.d.ts

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