@smess/networking 1.0.3 → 1.0.5

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

@@ -1,27 +1,21 @@
-"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;
+import { NetworkingUIEventWrapped, AlertModel, AlertButtonModel } from '../types/types.js';
+import { of, catchError, mergeMap, startWith } from '../utils/rxjs-import.js';
+import HttpService from '../core/rx.http.service.js';
+import { $logger } from '../services/logger.service.js';
+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 || (exports.SMESSHeader = SMESSHeader = {}));
-var ContentType;
+})(SMESSHeader || (SMESSHeader = {}));
+export var ContentType;
 (function (ContentType) {
     ContentType["Json"] = "application/json";
     ContentType["FormURLEncoded"] = "application/x-www-form-urlencoded";
-})(ContentType || (exports.ContentType = ContentType = {}));
-var Accept;
+})(ContentType || (ContentType = {}));
+export var Accept;
 (function (Accept) {
     Accept["V1"] = "application/json";
     Accept["V2"] = "application/vnd.smess.v2+json";
@@ -33,28 +27,27 @@ var Accept;
     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 {
+})(Accept || (Accept = {}));
+export class SmessService {
     constructor(target) {
         this.target = target;
         // Set default headers
-        logger_service_1.$logger.info('SmessService initialized', {
+        $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({
+        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) => {
-            var _a;
             const originalRequest = error.config;
-            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 && !originalRequest._retry) {
+            if (error.response?.status === 401 && !originalRequest._retry) {
                 originalRequest._retry = true;
-                logger_service_1.$logger.info('SmessService constructor - 401 retry', originalRequest, 'SmessService');
+                $logger.info('SmessService constructor - 401 retry', originalRequest, 'SmessService');
                 // Implement token refresh logic here
                 // Then retry the original request
                 // return httpService.request(originalRequest);
@@ -69,8 +62,12 @@ class SmessService {
         }
         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 { shouldAddClientIdHeader = true, } = options ?? {};
         const headers = {
             Accept: version,
             Authorization: '',
@@ -81,9 +78,6 @@ class SmessService {
     }
     // MARK: - Public
     request(request, mockResponse, ...queryParams) {
-        if (mockResponse !== undefined) {
-            return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
-        }
         const url = queryParams.length
             ? this.target.getPath(...queryParams)
             : this.target.path;
@@ -94,11 +88,9 @@ class SmessService {
                 config.data = request;
                 config.params = request;
             }
-            // Note: HttpService.get expects (url, config)
             observable = this.httpService.get(url, config);
         }
         else if (this.target.method === 'POST') {
-            // HttpService.post expects (url, data, config)
             observable = this.httpService.post(url, request, config);
         }
         else if (this.target.method === 'PATCH') {
@@ -110,28 +102,27 @@ class SmessService {
         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()));
+        return observable.pipe(catchError((error) => this.transformAxiosError(error, mockResponse)), mergeMap((data) => this.transformAxiosResponse(data)), startWith(NetworkingUIEventWrapped.waiting()));
     }
     // MARK: - Private
     transformAxiosError(error, mockResponse) {
-        logger_service_1.$logger.error('transformAxiosError', error, 'SmessService');
+        $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()]);
+        const title = response?.statusText;
+        const alertModel = new AlertModel(message, httpErrorCode, true, title, response?.data, [AlertButtonModel.buttonYes()]);
         if (mockResponse) {
-            return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
+            return of(NetworkingUIEventWrapped.succeeded(mockResponse));
         }
-        return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.failed(alertModel));
+        return of(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);
+        $logger.info('transformAxiosResponse', response, 'SmessService');
+        if (response instanceof NetworkingUIEventWrapped) {
+            return of(response);
         }
-        return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response.data));
+        return of(NetworkingUIEventWrapped.succeeded(response.data));
     }
 }
-exports.SmessService = SmessService;

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

@@ -1,9 +1,7 @@
-"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");
+import { SmessService } from './smess.service.js';
+import { NetworkingUIEventWrapped } from '../types/types.js';
+import { of, throwError } from 'rxjs';
 describe('SmessService', () => {
     const config = {
         baseUrl: 'https://api.example.com',
@@ -19,88 +17,83 @@ describe('SmessService', () => {
         getPath: () => '/resource',
     };
     it('should return succeeded for GET', done => {
-        const service = new smess_service_1.SmessService(provider);
+        const service = new SmessService(provider);
         service['httpService'] = {
-            get: jest.fn(() => (0, rxjs_1.of)({ data: { foo: 'bar' } })),
+            get: jest.fn(() => of({ data: { foo: 'bar' } })),
             post: jest.fn(),
             patch: jest.fn(),
             put: jest.fn(),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for test compatibility
-            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({ foo: 'bar' }));
-            }),
+            request: jest.fn(),
             interceptors: { response: { use: jest.fn() } },
         };
-        service.request().subscribe(result => {
-            expect(result).toBeInstanceOf(types_1.NetworkingUIEventWrapped);
-            expect(result.response).toEqual({ foo: 'bar' });
-            done();
+        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);
+        const postProvider = { ...provider, method: 'POST' };
+        const service = new SmessService(postProvider);
         service['httpService'] = {
             get: jest.fn(),
-            post: jest.fn((payload) => {
-                if (payload === 'error') {
-                    return (0, rxjs_1.throwError)(() => new Error('Test error'));
-                }
-                return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 'baz' }));
-            }),
+            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 => {
-            expect(result.response).toEqual({ foo: 'baz' });
-            done();
+        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);
+        const service = new SmessService(provider);
         service['httpService'] = {
-            get: jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error'))),
+            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 => {
-            var _a;
-            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();
+        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 smess_service_1.SmessService(provider);
+        const service = new SmessService(provider);
         service['httpService'] = {
-            get: jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error'))),
+            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 (0, rxjs_1.throwError)(() => new Error('Test error'));
+                    return throwError(() => new Error('Test error'));
                 }
                 if (mockResponse !== undefined) {
-                    return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
+                    return of(NetworkingUIEventWrapped.succeeded(mockResponse));
                 }
-                return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 'mock' }));
+                return of({ data: { foo: 'mock' } });
             }),
             interceptors: { response: { use: jest.fn() } },
         };
-        service.request(undefined, { foo: 'mock' }).subscribe(result => {
-            expect(result.response).toEqual({ foo: 'mock' });
-            done();
+        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.js';
+import { SmessService } from './smess.service.js';
+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,73 @@
+import { Accept, SMESSHeader, SmessService } from './smess.service.js';
+export 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 = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        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 StoreService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new StoreProvider(this.config, target, this.$authToken);
+        return new 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);
+    }
+}

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

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

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

@@ -0,0 +1,104 @@
+import { StoreService } from './store.service.js';
+import { NetworkingUIEventWrapped, AlertModel } from '../types/types.js';
+import { of, BehaviorSubject } from '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 BehaviorSubject(null);
+        service = new StoreService(config, $authToken);
+    });
+    it('get success', async () => {
+        const response = { data: { id: '1', name: 'Store' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.get('1').toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('get error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.get('1').toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('list success', async () => {
+        const response = { data: [{ id: '1', name: 'Store' }] };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.list().toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('list error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.list().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('productCategoryList success', async () => {
+        const response = { data: [{ id: 'cat1', name: 'Category' }] };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.productCategoryList().toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('productCategoryList error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.productCategoryList().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(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) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.productCollection('1', payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('productCollection error', async () => {
+        const payload = { page: 1, per_page: 10 };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.productCollection('1', payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('featuredProductList success', async () => {
+        const response = { data: [{ id: 'feat1', name: 'Featured' }] };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, storeId) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.featuredProductList('1').toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('featuredProductList error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, storeId) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.featuredProductList('1').toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+});

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

@@ -1,6 +1,6 @@
-import { BaseProvider } from '../core/base.provider';
-import { BaseServiceWrapper } from '../core/base.service.wrapper';
-import { NetworkingConfig } from '../types/types';
+import { BaseProvider } from '../core/base.provider.js';
+import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
+import { NetworkingConfig } from '../types/types.js';
 export interface User {
     id: number;
     name: string;
@@ -11,6 +11,6 @@ export declare class UserProvider extends BaseProvider {
 }
 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[]>>;
+    fetchUserById(id: number): import("rxjs").Observable<import("../types/types.js").NetworkingUIEventWrapped<User>>;
+    fetchAllUsers(): import("rxjs").Observable<import("../types/types.js").NetworkingUIEventWrapped<User[]>>;
 }

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

@@ -1,10 +1,7 @@
-"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");
+import { BaseProvider } from '../core/base.provider.js';
+import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
 // UserProvider implements ProviderType for user endpoints
-class UserProvider extends base_provider_1.BaseProvider {
+export class UserProvider extends BaseProvider {
     constructor(config, userId) {
         super({
             config,
@@ -15,9 +12,8 @@ class UserProvider extends base_provider_1.BaseProvider {
         });
     }
 }
-exports.UserProvider = UserProvider;
 // UserService provides high-level methods for user API
-class UserService extends base_service_wrapper_1.BaseServiceWrapper {
+export class UserService extends BaseServiceWrapper {
     constructor(config, userId) {
         super(new UserProvider(config, userId));
     }
@@ -32,7 +28,6 @@ class UserService extends base_service_wrapper_1.BaseServiceWrapper {
         return this.request();
     }
 }
-exports.UserService = UserService;
 // Example usage:
 // setNetworkingConfig({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false });
 // const userService = new UserService();

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

@@ -1,9 +1,7 @@
-"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");
+import { UserService } from './user.service.js';
+import { NetworkingUIEventWrapped } from '../types/types.js';
+import { of, throwError } from 'rxjs';
+import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
 describe('UserService', () => {
     const config = {
         baseUrl: 'https://jsonplaceholder.typicode.com',
@@ -14,30 +12,31 @@ describe('UserService', () => {
     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)));
+        requestSpy = jest.spyOn(BaseServiceWrapper.prototype, 'request').mockImplementation(() => of(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 => {
+    it('fetchUserById should return user (success)', (done) => {
+        const service = new 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 => {
+    it('fetchAllUsers should return users (success)', (done) => {
+        const service = new 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 => {
+    it('request should handle error', (done) => {
+        requestSpy.mockImplementationOnce(() => throwError(() => new Error('Test error')));
+        const service = new UserService(config);
+        // Simulate error by calling a method that uses request
+        service.fetchUserById(1).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;