@smess/networking 1.0.1

package/README.md

@@ -0,0 +1,104 @@
+# SMESS Networking Package
+
+## Features
+- Per-instance configuration (no global config)
+- RxJS-based HTTP services
+- Extensible provider/service architecture
+- TypeScript-first
+
+## Usage
+
+### 1. Define your config
+```typescript
+const configA = {
+  baseUrl: 'https://api-a',
+  isProd: false,
+  clientId: 'A',
+  apiKey: 'keyA',
+};
+const configB = {
+  baseUrl: 'https://api-b',
+  isProd: true,
+  clientId: 'B',
+  apiKey: 'keyB',
+};
+```
+
+### 2. Create providers/services with config
+```typescript
+import { ProductService } from './core/product.service';
+import { UserService } from './core/user.service';
+
+const productServiceA = new ProductService(configA);
+const productServiceB = new ProductService(configB);
+const userServiceA = new UserService(configA);
+```
+
+### 3. Use services independently
+```typescript
+productServiceA.fetchAllProducts().subscribe(...);
+productServiceB.createProduct({ name: 'X', price: 10 }).subscribe(...);
+userServiceA.fetchUserById(1).subscribe(...);
+```
+
+### 4. Example: Custom Provider
+```typescript
+import { BaseProvider } from './core/base.provider';
+import { SmessService } from './services/smess.service';
+
+const config = {
+  baseUrl: 'https://custom-api',
+  isProd: false,
+  clientId: 'custom-client',
+  apiKey: 'custom-key',
+};
+
+class ExampleProvider extends BaseProvider {
+  constructor(config, resourceId: string) {
+    super({
+      config,
+      path: `/resource/${resourceId}`,
+      method: 'GET',
+      headers: { 'Custom-Header': 'value' },
+      getPath: () => `/resource/${resourceId}`,
+    });
+  }
+}
+
+const provider = new ExampleProvider(config, '123');
+const service = new SmessService(provider);
+service.request().subscribe(result => {
+  // handle result
+});
+```
+
+### 4. Example: Custom CustomerProvider
+
+```typescript
+import { CustomerProvider, CustomerTarget } from './core/customer.provider';
+import { SmessService } from './services/smess.service';
+
+const config = {
+  baseUrl: 'https://api.example.com',
+  isProd: false,
+  clientId: 'customer-client',
+  apiKey: 'customer-key',
+};
+
+const provider = new CustomerProvider(config, 'get-profile');
+const service = new SmessService(provider);
+
+service.request().subscribe(result => {
+  // handle result
+});
+```
+
+---
+
+## Private Package Usage
+
+See [SETUP.md](./SETUP.md) for instructions on using this package as a private dependency (GitHub repo, GitHub Packages, npm private registry) with the correct package name: `@smess/networking`.
+
+---
+
+MIT License 

package/dist/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 = 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>;
+}
+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/core/axios.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Axios = void 0;
+const networking_import_1 = require("../utils/networking-import");
+const axios_observable_1 = require("./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 (0, axios_observable_1.createObservable)(networking_import_1.axios.request, [config]);
+    }
+    static get(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.get, [url, config]);
+    }
+    static post(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.post, [url, data, config]);
+    }
+    static put(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.put, [url, data, config]);
+    }
+    static patch(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.patch, [url, data, config]);
+    }
+    static delete(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.delete, [url, config]);
+    }
+    static head(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.head, [url, config]);
+    }
+    static create(config) {
+        return new Axios(networking_import_1.axios.create(config));
+    }
+    // ----- Instance Methods -----
+    request(config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.request, [config]);
+    }
+    get(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.get, [url, config]);
+    }
+    head(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.head, [url, config]);
+    }
+    post(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.post, [url, data, config]);
+    }
+    put(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.put, [url, data, config]);
+    }
+    patch(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.patch, [url, data, config]);
+    }
+    delete(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.delete, [url, config]);
+    }
+}
+exports.Axios = Axios;
+Axios.defaults = networking_import_1.axios.defaults;
+Axios.interceptors = networking_import_1.axios.interceptors;
+exports.default = Axios;

package/dist/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/core/axios.observable.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createObservable = createObservable;
+const networking_import_1 = require("../utils/networking-import");
+const rxjs_import_1 = require("../utils/rxjs-import");
+const logger_service_1 = require("../services/logger.service");
+function createObservable(promiseFactory, args, options = {}) {
+    let config = args[args.length - 1];
+    if (config && typeof config === 'object' && !Array.isArray(config)) {
+        config = Object.assign({}, config);
+    }
+    else {
+        config = {};
+        args.push(config);
+    }
+    let cancelSource = null;
+    const hasCancelToken = !!config.cancelToken;
+    if (!hasCancelToken) {
+        logger_service_1.$logger.warn('[Networking] You can omit cancelToken — unsubscribing cancels the request automatically.', undefined, 'axios.observable');
+    }
+    let source$ = new rxjs_import_1.Observable((subscriber) => {
+        if (!hasCancelToken) {
+            cancelSource = networking_import_1.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((0, rxjs_import_1.timeout)(options.timeoutMs));
+    }
+    // Add retry logic
+    if (options.retry) {
+        source$ = source$.pipe((0, rxjs_import_1.retry)(options.retry));
+    }
+    // Cache the response if needed
+    if (options.cache) {
+        source$ = source$.pipe((0, rxjs_import_1.shareReplay)({ bufferSize: 1, refCount: false }));
+    }
+    // Optional: Log or catch errors globally
+    source$ = source$.pipe((0, rxjs_import_1.catchError)((err) => {
+        logger_service_1.$logger.error('[createObservable error]:', err, 'axios.observable');
+        return (0, rxjs_import_1.throwError)(() => err);
+    }));
+    return source$;
+}

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

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

package/dist/core/base.provider.advanced.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_provider_1 = require("./base.provider");
+describe('BaseProvider Advanced', () => {
+    it('should support dynamic getPath for multiple params', () => {
+        const provider = new base_provider_1.BaseProvider({
+            baseURL: 'https://api.example.com',
+            path: '/resource/:id/:action',
+            method: 'GET',
+            headers: {},
+            getPath: (id, action) => `/resource/${id}/${action}`,
+        });
+        expect(provider.getPath('42', 'edit')).toBe('/resource/42/edit');
+    });
+    it('should allow dynamic headers and method', () => {
+        const provider = new base_provider_1.BaseProvider({
+            baseURL: 'https://api.example.com',
+            path: '/resource',
+            method: 'PATCH',
+            headers: { Authorization: 'Bearer token' },
+        });
+        expect(provider.method).toBe('PATCH');
+        expect(provider.headers.Authorization).toBe('Bearer token');
+    });
+});

package/dist/core/base.provider.d.ts

@@ -0,0 +1,15 @@
+import { ProviderType } from '../types/types';
+export declare class BaseProvider implements ProviderType {
+    baseURL: string;
+    path: string;
+    method: string;
+    headers: any;
+    getPath: (...queryParams: any[]) => string;
+    constructor({ baseURL, path, method, headers, getPath, }: {
+        baseURL: string;
+        path: string;
+        method: string;
+        headers: any;
+        getPath?: (...queryParams: any[]) => string;
+    });
+}

package/dist/core/base.provider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProvider = void 0;
+class BaseProvider {
+    constructor({ baseURL, path, method, headers, getPath, }) {
+        this.baseURL = baseURL;
+        this.path = path;
+        this.method = method;
+        this.headers = headers;
+        this.getPath = getPath || (() => path);
+    }
+}
+exports.BaseProvider = BaseProvider;

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

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

package/dist/core/base.provider.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_provider_1 = require("./base.provider");
+describe('BaseProvider', () => {
+    it('should construct with required fields', () => {
+        const provider = new base_provider_1.BaseProvider({
+            baseURL: 'https://api.example.com',
+            path: '/resource',
+            method: 'GET',
+            headers: { foo: 'bar' },
+        });
+        expect(provider.baseURL).toBe('https://api.example.com');
+        expect(provider.path).toBe('/resource');
+        expect(provider.method).toBe('GET');
+        expect(provider.headers).toEqual({ foo: 'bar' });
+        expect(provider.getPath()).toBe('/resource');
+    });
+    it('should use custom getPath if provided', () => {
+        const provider = new base_provider_1.BaseProvider({
+            baseURL: 'https://api.example.com',
+            path: '/resource/:id',
+            method: 'GET',
+            headers: {},
+            getPath: (id) => `/resource/${id}`,
+        });
+        expect(provider.getPath('123')).toBe('/resource/123');
+    });
+});

package/dist/core/base.service.wrapper.advanced.test.d.ts

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

package/dist/core/base.service.wrapper.advanced.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_service_wrapper_1 = require("./base.service.wrapper");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+describe('BaseServiceWrapper Advanced', () => {
+    const mockProvider = {
+        baseURL: 'https://api.example.com',
+        path: '/resource',
+        method: 'GET',
+        headers: {},
+        getPath: () => '/resource',
+    };
+    it('should allow use of RxJS operators', done => {
+        const wrapper = new base_service_wrapper_1.BaseServiceWrapper(mockProvider);
+        wrapper.request = (() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 1 })));
+        wrapper.request().pipe((0, operators_1.map)(r => r.response)).subscribe(val => {
+            expect(val).toEqual({ foo: 1 });
+            done();
+        });
+    });
+    it('should handle multiple concurrent requests', done => {
+        const wrapper = new base_service_wrapper_1.BaseServiceWrapper(mockProvider);
+        wrapper.request = ((payload) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: payload })));
+        const results = [];
+        wrapper.request(1).subscribe(r => {
+            results.push(r.response);
+            if (results.length === 2) {
+                expect(results).toContainEqual({ foo: 1 });
+                expect(results).toContainEqual({ foo: 2 });
+                done();
+            }
+        });
+        wrapper.request(2).subscribe(r => {
+            results.push(r.response);
+            if (results.length === 2) {
+                expect(results).toContainEqual({ foo: 1 });
+                expect(results).toContainEqual({ foo: 2 });
+                done();
+            }
+        });
+    });
+});

package/dist/core/base.service.wrapper.d.ts

@@ -0,0 +1,7 @@
+import { ProviderType, NetworkingUIEventWrapped } from '../types/types';
+import { Observable } from 'rxjs';
+export declare class BaseServiceWrapper<T extends ProviderType> {
+    protected provider: T;
+    constructor(provider: T);
+    request<R = any>(payload?: any): Observable<NetworkingUIEventWrapped<R>>;
+}

package/dist/core/base.service.wrapper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseServiceWrapper = void 0;
+const smess_service_1 = require("../services/smess.service");
+class BaseServiceWrapper {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    request(payload) {
+        const service = new smess_service_1.SmessService(this.provider);
+        return service.request(payload);
+    }
+}
+exports.BaseServiceWrapper = BaseServiceWrapper;

package/dist/core/base.service.wrapper.test.d.ts

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

package/dist/core/base.service.wrapper.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_service_wrapper_1 = require("./base.service.wrapper");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+// Mock SmessService for testing
+jest.mock('../services/smess.service', () => ({
+    SmessService: jest.fn().mockImplementation(() => ({
+        request: jest.fn(() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 'bar' })))
+    }))
+}));
+describe('BaseServiceWrapper', () => {
+    const mockProvider = {
+        baseURL: 'https://api.example.com',
+        path: '/resource',
+        method: 'GET',
+        headers: {},
+        getPath: () => '/resource',
+    };
+    it('should delegate request to SmessService', done => {
+        const wrapper = new base_service_wrapper_1.BaseServiceWrapper(mockProvider);
+        wrapper.request().subscribe(result => {
+            expect(result.response).toEqual({ foo: 'bar' });
+            done();
+        });
+    });
+});

package/dist/core/product.service.d.ts

@@ -0,0 +1,19 @@
+import { BaseProvider } from './base.provider';
+import { BaseServiceWrapper } from './base.service.wrapper';
+export interface Product {
+    id: number;
+    name: string;
+    price: number;
+}
+export declare class ProductProvider extends BaseProvider {
+    constructor({ productId, method }?: {
+        productId?: number;
+        method?: string;
+    });
+}
+export declare class ProductService extends BaseServiceWrapper<ProductProvider> {
+    constructor(productId?: number, method?: string);
+    fetchProductById(id: number): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
+    fetchAllProducts(): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product[]>>;
+    createProduct(product: Omit<Product, 'id'>): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
+}

package/dist/core/product.service.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductService = exports.ProductProvider = void 0;
+const base_provider_1 = require("./base.provider");
+const base_service_wrapper_1 = require("./base.service.wrapper");
+// ProductProvider implements ProviderType for product endpoints
+class ProductProvider extends base_provider_1.BaseProvider {
+    constructor({ productId, method } = {}) {
+        super({
+            baseURL: 'https://fakestoreapi.com',
+            path: productId ? `/products/${productId}` : '/products',
+            method: method || 'GET',
+            headers: { 'Content-Type': 'application/json' },
+            getPath: () => (productId ? `/products/${productId}` : '/products'),
+        });
+    }
+}
+exports.ProductProvider = ProductProvider;
+// ProductService provides high-level methods for product API
+class ProductService extends base_service_wrapper_1.BaseServiceWrapper {
+    constructor(productId, method) {
+        super(new ProductProvider({ productId, method }));
+    }
+    // Fetch a product by ID
+    fetchProductById(id) {
+        this.provider = new ProductProvider({ productId: id });
+        return this.request();
+    }
+    // Fetch all products
+    fetchAllProducts() {
+        this.provider = new ProductProvider();
+        return this.request();
+    }
+    // Create a new product (POST)
+    createProduct(product) {
+        this.provider = new ProductProvider({ method: 'POST' });
+        return this.request(product);
+    }
+}
+exports.ProductService = ProductService;
+// 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/core/product.service.test.d.ts

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

package/dist/core/product.service.test.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const product_service_1 = require("./product.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+jest.mock('./base.service.wrapper', () => {
+    const actual = jest.requireActual('./base.service.wrapper');
+    return Object.assign(Object.assign({}, actual), { BaseServiceWrapper: class {
+            constructor() {
+                this.request = jest.fn((payload) => {
+                    if (payload === 'error') {
+                        return (0, rxjs_1.throwError)(() => new Error('Test error'));
+                    }
+                    return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ id: 1, name: 'Product', price: 10 }));
+                });
+            }
+        } });
+});
+describe('ProductService', () => {
+    it('fetchProductById should return product (success)', done => {
+        const service = new product_service_1.ProductService();
+        service.fetchProductById(1).subscribe(result => {
+            expect(result.response).toEqual({ id: 1, name: 'Product', price: 10 });
+            done();
+        });
+    });
+    it('fetchAllProducts should return products (success)', done => {
+        const service = new product_service_1.ProductService();
+        service.fetchAllProducts().subscribe(result => {
+            expect(result.response).toEqual({ id: 1, name: 'Product', price: 10 });
+            done();
+        });
+    });
+    it('createProduct should return product (success)', done => {
+        const service = new product_service_1.ProductService();
+        service.createProduct({ name: 'New', price: 99 }).subscribe(result => {
+            expect(result.response).toEqual({ id: 1, name: 'Product', price: 10 });
+            done();
+        });
+    });
+    it('request should handle error (fetchProductById)', done => {
+        const service = new product_service_1.ProductService();
+        service.request = jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error')));
+        service.request('error').subscribe({
+            error: err => {
+                expect(err).toBeInstanceOf(Error);
+                expect(err.message).toBe('Test error');
+                done();
+            },
+        });
+    });
+    it('request should handle error (createProduct)', done => {
+        const service = new product_service_1.ProductService();
+        service.request = jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error')));
+        service.request('error').subscribe({
+            error: err => {
+                expect(err).toBeInstanceOf(Error);
+                expect(err.message).toBe('Test error');
+                done();
+            },
+        });
+    });
+});