@smess/networking 1.0.2 → 1.0.4

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,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmessService = exports.Accept = exports.ContentType = exports.SMESSHeader = void 0;
+const types_1 = require("../types/types");
+const rxjs_import_1 = require("../utils/rxjs-import");
+const rx_http_service_1 = __importDefault(require("../core/rx.http.service"));
+const logger_service_1 = require("../services/logger.service");
+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 || (exports.SMESSHeader = SMESSHeader = {}));
+var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["FormURLEncoded"] = "application/x-www-form-urlencoded";
+})(ContentType || (exports.ContentType = ContentType = {}));
+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 || (exports.Accept = Accept = {}));
+class SmessService {
+    constructor(target) {
+        this.target = target;
+        // Set default headers
+        logger_service_1.$logger.info('SmessService initialized', {
+            target: this.target,
+            baseURL: this.target.baseURL,
+            method: this.target.method,
+            headers: this.target.headers,
+        }, 'SmessService');
+        this.httpService = rx_http_service_1.default.create({
+            baseURL: this.target.baseURL,
+            headers: this.target.headers,
+            method: this.target.method,
+        });
+        this.httpService.interceptors.response.use((response) => response, async (error) => {
+            var _a;
+            const originalRequest = error.config;
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 && !originalRequest._retry) {
+                originalRequest._retry = true;
+                logger_service_1.$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'] = 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 !== null && options !== void 0 ? 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((0, rxjs_import_1.catchError)((error) => this.transformAxiosError(error, mockResponse)), (0, rxjs_import_1.mergeMap)((data) => this.transformAxiosResponse(data)), (0, rxjs_import_1.startWith)(types_1.NetworkingUIEventWrapped.waiting()));
+    }
+    // MARK: - Private
+    transformAxiosError(error, mockResponse) {
+        logger_service_1.$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 === null || response === void 0 ? void 0 : response.statusText;
+        const alertModel = new types_1.AlertModel(message, httpErrorCode, true, title, response === null || response === void 0 ? void 0 : response.data, [types_1.AlertButtonModel.buttonYes()]);
+        if (mockResponse) {
+            return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
+        }
+        return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.failed(alertModel));
+    }
+    transformAxiosResponse(response) {
+        logger_service_1.$logger.info('transformAxiosResponse', response, 'SmessService');
+        if (response instanceof types_1.NetworkingUIEventWrapped) {
+            return (0, rxjs_import_1.of)(response);
+        }
+        return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response.data));
+    }
+}
+exports.SmessService = SmessService;

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

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

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for test mocks */
+const smess_service_1 = require("./smess.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("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 smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.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 = Object.assign(Object.assign({}, provider), { method: 'POST' });
+        const service = new smess_service_1.SmessService(postProvider);
+        service['httpService'] = {
+            get: jest.fn(),
+            post: jest.fn(() => (0, rxjs_1.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 smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.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 => {
+            var _a;
+            if (result.hasFailed) {
+                expect(result).toBeInstanceOf(types_1.NetworkingUIEventWrapped);
+                expect(result.hasFailed).toBe(true);
+                expect(result.alertModel).toBeTruthy();
+                expect((_a = result.alertModel) === null || _a === void 0 ? void 0 : _a.message).toBe('Test error');
+                done();
+            }
+        });
+    });
+    it('should return mock response if provided', done => {
+        const service = new smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error'))),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn((payload, mockResponse) => {
+                if (payload === 'error') {
+                    return (0, rxjs_1.throwError)(() => new Error('Test error'));
+                }
+                if (mockResponse !== undefined) {
+                    return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
+                }
+                return (0, rxjs_1.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.service.d.ts

@@ -0,0 +1,39 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types';
+import { SmessService } from './smess.service';
+import { BehaviorSubject, Observable } from 'rxjs';
+export type StoreTarget = 'store-get' | 'store-list' | 'store-product-category-list' | 'store-product-collection' | 'store-featured-product-list';
+export interface ProductCollectionRequest {
+    page?: number;
+    per_page?: number;
+    search?: string;
+    sort_by?: string;
+    category?: string;
+    min_price?: number;
+    max_price?: number;
+    only_discounted?: boolean;
+    unit?: string;
+    supplier?: string;
+    has_offer?: boolean;
+}
+export declare class StoreProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: StoreTarget, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export declare class StoreService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: StoreTarget): SmessService<StoreProvider>;
+    get(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    list(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    productCategoryList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    productCollection(id: string, payload: ProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    featuredProductList(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreService = exports.StoreProvider = void 0;
+const smess_service_1 = require("./smess.service");
+class StoreProvider {
+    constructor(config, target, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version ? `${this.config.baseUrl}/${this.config.version}` : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case 'store-get':
+                return '/store/${id}/information';
+            case 'store-list':
+                return '/store/list';
+            case 'store-product-category-list':
+                return '/store/product-category-list';
+            case 'store-product-collection':
+                return '/store/${id}/product-collection';
+            case 'store-featured-product-list':
+                return '/store/${id}/featured-product-list';
+            default:
+                return '/store/${id}';
+        }
+    }
+    get method() {
+        return 'GET';
+    }
+    get headers() {
+        let headers = smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1, this.$authToken.value);
+        if (this.config.clientId) {
+            headers[smess_service_1.SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            headers[smess_service_1.SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        return smess_service_1.SmessService.filterHeaders(headers);
+    }
+    getPath(...queryParams) {
+        let definedPath = this.path;
+        const params = definedPath.match(/\$\{(.+?)\}/g);
+        params === null || params === void 0 ? void 0 : params.forEach((value, index) => {
+            definedPath = definedPath.replace(value, String(queryParams[index]));
+        });
+        return definedPath;
+    }
+}
+exports.StoreProvider = StoreProvider;
+class StoreService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new StoreProvider(this.config, target, this.$authToken);
+        return new smess_service_1.SmessService(targetWrapper);
+    }
+    get(id) {
+        return this.provider('store-get').request(null, undefined, id);
+    }
+    list() {
+        return this.provider('store-list').request();
+    }
+    productCategoryList() {
+        return this.provider('store-product-category-list').request();
+    }
+    productCollection(id, payload) {
+        return this.provider('store-product-collection').request(payload, undefined, id);
+    }
+    featuredProductList(id) {
+        return this.provider('store-featured-product-list').request(null, undefined, id);
+    }
+}
+exports.StoreService = StoreService;

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

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

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const store_service_1 = require("./store.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+describe('StoreService', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client-id',
+        apiKey: 'test-api-key',
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new rxjs_1.BehaviorSubject(null);
+        service = new store_service_1.StoreService(config, $authToken);
+    });
+    it('get success', async () => {
+        const response = { data: { id: '1', name: 'Store' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.get('1').toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('get error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.get('1').toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+    it('list success', async () => {
+        const response = { data: [{ id: '1', name: 'Store' }] };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.list().toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('list error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.list().toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+    it('productCategoryList success', async () => {
+        const response = { data: [{ id: 'cat1', name: 'Category' }] };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.productCategoryList().toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('productCategoryList error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.productCategoryList().toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+    it('productCollection success', async () => {
+        const response = { data: [{ id: 'prod1', name: 'Product' }] };
+        const payload = { page: 1, per_page: 10 };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (payload, _mockResponse, id) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.productCollection('1', payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('productCollection error', async () => {
+        const payload = { page: 1, per_page: 10 };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (payload, _mockResponse, id) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.productCollection('1', payload).toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+    it('featuredProductList success', async () => {
+        const response = { data: [{ id: 'feat1', name: 'Featured' }] };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, storeId) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.featuredProductList('1').toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.response).toEqual(response);
+    });
+    it('featuredProductList error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, storeId) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.featuredProductList('1').toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasFailed).toBe(true);
+        expect(result === null || result === void 0 ? void 0 : result.alertModel).toBeInstanceOf(types_1.AlertModel);
+    });
+});

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

@@ -0,0 +1,16 @@
+import { BaseProvider } from '../core/base.provider';
+import { BaseServiceWrapper } from '../core/base.service.wrapper';
+import { NetworkingConfig } from '../types/types';
+export interface User {
+    id: number;
+    name: string;
+    email: string;
+}
+export declare class UserProvider extends BaseProvider {
+    constructor(config: NetworkingConfig, userId?: number);
+}
+export declare class UserService extends BaseServiceWrapper<UserProvider> {
+    constructor(config: NetworkingConfig, userId?: number);
+    fetchUserById(id: number): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<User>>;
+    fetchAllUsers(): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<User[]>>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserService = exports.UserProvider = void 0;
+const base_provider_1 = require("../core/base.provider");
+const base_service_wrapper_1 = require("../core/base.service.wrapper");
+// UserProvider implements ProviderType for user endpoints
+class UserProvider extends base_provider_1.BaseProvider {
+    constructor(config, userId) {
+        super({
+            config,
+            path: userId ? `/users/${userId}` : '/users',
+            method: 'GET',
+            headers: {},
+            getPath: () => (userId ? `/users/${userId}` : '/users'),
+        });
+    }
+}
+exports.UserProvider = UserProvider;
+// UserService provides high-level methods for user API
+class UserService extends base_service_wrapper_1.BaseServiceWrapper {
+    constructor(config, userId) {
+        super(new UserProvider(config, userId));
+    }
+    // Fetch a user by ID
+    fetchUserById(id) {
+        this.provider = new UserProvider({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false }, id);
+        return this.request();
+    }
+    // Fetch all users
+    fetchAllUsers() {
+        this.provider = new UserProvider({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false });
+        return this.request();
+    }
+}
+exports.UserService = UserService;
+// Example usage:
+// setNetworkingConfig({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false });
+// const userService = new UserService();
+// userService.fetchUserById(1).subscribe(result => console.log(result)); 

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

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

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const user_service_1 = require("./user.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+const base_service_wrapper_1 = require("../core/base.service.wrapper");
+describe('UserService', () => {
+    const config = {
+        baseUrl: 'https://jsonplaceholder.typicode.com',
+        isProd: false,
+        clientId: 'test-client',
+        apiKey: 'test-key',
+    };
+    const user = { id: 1, name: 'Test', email: 'test@example.com' };
+    let requestSpy;
+    beforeEach(() => {
+        requestSpy = jest.spyOn(base_service_wrapper_1.BaseServiceWrapper.prototype, 'request').mockImplementation(() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(user)));
+    });
+    afterEach(() => {
+        requestSpy.mockRestore();
+    });
+    it('fetchUserById should return user (success)', done => {
+        const service = new user_service_1.UserService(config);
+        service.fetchUserById(1).subscribe(result => {
+            expect(result.response).toEqual(user);
+            done();
+        });
+    });
+    it('fetchAllUsers should return users (success)', done => {
+        const service = new user_service_1.UserService(config);
+        service.fetchAllUsers().subscribe(result => {
+            expect(result.response).toEqual(user);
+            done();
+        });
+    });
+    it('request should handle error', done => {
+        requestSpy.mockImplementationOnce(() => (0, rxjs_1.throwError)(() => new Error('Test error')));
+        const service = new user_service_1.UserService(config);
+        service.request('error').subscribe({
+            error: err => {
+                expect(err).toBeInstanceOf(Error);
+                expect(err.message).toBe('Test error');
+                done();
+            },
+        });
+    });
+});

package/dist/src/types/types.d.ts

@@ -63,9 +63,6 @@ export interface ProviderType {
     headers: Record<string, string | undefined>;
     getPath(...queryParams: unknown[]): string;
 }
-export interface ProviderTypeMockable {
-    shouldUseMockData: boolean;
-}
 export interface HeaderType {
     shouldAddEncryptionHeader?: boolean;
     shouldAddClientIdHeader?: boolean;
@@ -88,6 +85,7 @@ export interface ServerErrorResponse {
 }
 export interface NetworkingConfig {
     baseUrl: string;
+    version?: string;
     isProd: boolean;
     clientId?: string;
     apiKey?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smess/networking",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Networking utilities and services for SMESS platform.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",