@smess/networking 1.0.6 → 1.0.8

package/dist/index.js

@@ -1,12 +1,15 @@
-export * from './src/services/user.service.js';
-export * from './src/services/product.service.js';
-export * from './src/services/auth.service.js';
-export * from './src/services/smess.service.js';
-export * from './src/core/base.provider.js';
-export * from './src/core/base.service.wrapper.js';
-export * from './src/core/axios.observable.js';
-export * from './src/types/types.js';
-export { $logger } from './src/services/logger.service.js';
+export * from './services/user.service';
+export * from './services/product.service';
+export * from './services/auth.service';
+export * from './services/store.service';
+export * from './services/customer.service';
+export * from './services/product.service';
+export * from './services/smess.service';
+export * from './core/base.provider';
+export * from './core/base.service.wrapper';
+export * from './core/axios.observable';
+export * from './types/types';
+export { $logger } from './services/logger.service';
 export const baseURL = () => {
     return '';
 };

package/dist/{src/services → services}/auth.service.d.ts

@@ -1,5 +1,5 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types.js';
-import { SmessService } from './smess.service.js';
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types';
+import { SmessService } from './smess.service';
 import { BehaviorSubject, Observable } from "rxjs";
 export interface AuthLoginRequest {
     identifier: string;

package/dist/{src/services → services}/auth.service.js

@@ -1,4 +1,4 @@
-import { Accept, SMESSHeader, SmessService } from './smess.service.js';
+import { Accept, SMESSHeader, SmessService } from './smess.service';
 export class AuthProvider {
     constructor(config, target, $authToken) {
         this.config = config;

package/dist/{src/services → services}/auth.service.test.js

@@ -1,5 +1,5 @@
-import { AuthService } from './auth.service.js';
-import { NetworkingUIEventWrapped, AlertModel } from '../types/types.js';
+import { AuthService } from './auth.service';
+import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
 import { of, BehaviorSubject } from 'rxjs';
 describe('AuthService', () => {
     const config = {

package/dist/{src/services → services}/customer.service.d.ts

@@ -1,5 +1,5 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types.js';
-import { SmessService } from './smess.service.js';
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types';
+import { SmessService } from './smess.service';
 import { BehaviorSubject, Observable } from 'rxjs';
 export type CustomerTarget = 'register' | 'get-profile' | 'update-profile';
 export interface CustomerRegisterRequest {

package/dist/{src/services → services}/customer.service.js

@@ -1,4 +1,4 @@
-import { Accept, SMESSHeader, SmessService } from './smess.service.js';
+import { Accept, SMESSHeader, SmessService } from './smess.service';
 export class CustomerProvider {
     constructor(config, target, $authToken) {
         this.config = config;

package/dist/{src/services → services}/customer.service.test.js

@@ -1,5 +1,5 @@
-import { CustomerService } from './customer.service.js';
-import { NetworkingUIEventWrapped, AlertModel } from '../types/types.js';
+import { CustomerService } from './customer.service';
+import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
 import { of, BehaviorSubject } from 'rxjs';
 describe('CustomerService', () => {
     const config = {

package/dist/services/logger.service.d.ts

@@ -8,7 +8,7 @@ export declare enum LogLevel {
 export interface LogEntry {
     level: LogLevel;
     message: string;
-    data?: any;
+    data?: unknown;
     timestamp: number;
     context?: string;
 }
@@ -21,10 +21,10 @@ export declare class LoggerService {
     private formatMessage;
     private getEmojiForLevel;
     private log;
-    debug(message: string, data?: any, context?: string): void;
-    info(message: string, data?: any, context?: string): void;
-    warn(message: string, data?: any, context?: string): void;
-    error(message: string, data?: any, context?: string): void;
+    debug(message: string, data?: unknown, context?: string): void;
+    info(message: string, data?: unknown, context?: string): void;
+    warn(message: string, data?: unknown, context?: string): void;
+    error(message: string, data?: unknown, context?: string): void;
     getLogs(): LogEntry[];
     clearLogs(): void;
 }

package/dist/services/logger.service.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$logger = exports.LoggerService = exports.LogLevel = void 0;
-var LogLevel;
+export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
     LogLevel[LogLevel["INFO"] = 1] = "INFO";
     LogLevel[LogLevel["WARN"] = 2] = "WARN";
     LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
     LogLevel[LogLevel["NONE"] = 4] = "NONE";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-class LoggerService {
+})(LogLevel || (LogLevel = {}));
+export class LoggerService {
     constructor() {
         this.currentLevel = LogLevel.DEBUG;
         this.logs = [];
@@ -92,6 +89,5 @@ class LoggerService {
         this.logs = [];
     }
 }
-exports.LoggerService = LoggerService;
 // Export singleton instance
-exports.$logger = new LoggerService();
+export const $logger = new LoggerService();

package/dist/services/logger.service.test.js

@@ -1,33 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_service_1 = require("./logger.service");
+import { $logger, LogLevel } from './logger.service';
 describe('LoggerService', () => {
     beforeEach(() => {
-        logger_service_1.$logger.clearLogs();
-        logger_service_1.$logger.setLogLevel(logger_service_1.LogLevel.DEBUG);
+        $logger.clearLogs();
+        $logger.setLogLevel(LogLevel.DEBUG);
     });
     it('should log info', () => {
-        logger_service_1.$logger.info('info message', { foo: 1 }, 'test');
-        const logs = logger_service_1.$logger.getLogs();
-        expect(logs[0].level).toBe(logger_service_1.LogLevel.INFO);
+        $logger.info('info message', { foo: 1 }, 'test');
+        const logs = $logger.getLogs();
+        expect(logs[0].level).toBe(LogLevel.INFO);
         expect(logs[0].message).toBe('info message');
         expect(logs[0].data).toEqual({ foo: 1 });
         expect(logs[0].context).toBe('test');
     });
     it('should log warn and error', () => {
-        logger_service_1.$logger.warn('warn message');
-        logger_service_1.$logger.error('error message', { bar: 2 });
-        const logs = logger_service_1.$logger.getLogs();
-        expect(logs[0].level).toBe(logger_service_1.LogLevel.WARN);
-        expect(logs[1].level).toBe(logger_service_1.LogLevel.ERROR);
+        $logger.warn('warn message');
+        $logger.error('error message', { bar: 2 });
+        const logs = $logger.getLogs();
+        expect(logs[0].level).toBe(LogLevel.WARN);
+        expect(logs[1].level).toBe(LogLevel.ERROR);
         expect(logs[1].data).toEqual({ bar: 2 });
     });
     it('should respect log level', () => {
-        logger_service_1.$logger.setLogLevel(logger_service_1.LogLevel.ERROR);
-        logger_service_1.$logger.info('should not log');
-        logger_service_1.$logger.error('should log');
-        const logs = logger_service_1.$logger.getLogs();
+        $logger.setLogLevel(LogLevel.ERROR);
+        $logger.info('should not log');
+        $logger.error('should log');
+        const logs = $logger.getLogs();
         expect(logs.length).toBe(1);
-        expect(logs[0].level).toBe(logger_service_1.LogLevel.ERROR);
+        expect(logs[0].level).toBe(LogLevel.ERROR);
     });
 });

package/dist/{src/services → services}/order.service.d.ts

@@ -1,5 +1,5 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types.js';
-import { SmessService } from './smess.service.js';
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types';
+import { SmessService } from './smess.service';
 import { BehaviorSubject, Observable } from 'rxjs';
 export type OrderTarget = 'order-list' | 'order-create' | 'order-delete' | 'order-get-draft' | 'order-update' | 'order-get';
 export interface CreateOrderRequest extends UpdateOrderRequest {

package/dist/{src/services → services}/order.service.js

@@ -1,4 +1,4 @@
-import { Accept, SMESSHeader, SmessService } from './smess.service.js';
+import { Accept, SMESSHeader, SmessService } from './smess.service';
 export class OrderProvider {
     constructor(config, target, $authToken) {
         this.config = config;

package/dist/{src/services → services}/order.service.test.js

@@ -1,5 +1,5 @@
-import { OrderService } from './order.service.js';
-import { NetworkingUIEventWrapped, AlertModel } from '../types/types.js';
+import { OrderService } from './order.service';
+import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
 import { of, BehaviorSubject } from 'rxjs';
 describe('OrderService', () => {
     const config = {

package/dist/{src/services → services}/product.service.js

@@ -1,5 +1,5 @@
-import { BaseProvider } from '../core/base.provider.js';
-import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
+import { BaseProvider } from '../core/base.provider';
+import { BaseServiceWrapper } from '../core/base.service.wrapper';
 // ProductProvider implements ProviderType for product endpoints
 export class ProductProvider extends BaseProvider {
     constructor(config, { productId, method } = {}) {

package/dist/{src/services → services}/product.service.test.js

@@ -1,7 +1,7 @@
-import { ProductService } from './product.service.js';
-import { NetworkingUIEventWrapped } from '../types/types.js';
+import { ProductService } from './product.service';
+import { NetworkingUIEventWrapped } from '../types/types';
 import { of, throwError } from 'rxjs';
-import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
+import { BaseServiceWrapper } from '../core/base.service.wrapper';
 describe('ProductService', () => {
     const config = {
         baseUrl: 'https://jsonplaceholder.typicode.com',

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

@@ -15,15 +15,22 @@ 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"
+    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): Record<SMESSHeader, any>;
+    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 = any>(request?: any, mockResponse?: R, ...queryParams: any[]): Observable<NetworkingUIEventWrapped<R>>;
+    request<R = unknown>(request?: unknown, mockResponse?: R, ...queryParams: unknown[]): Observable<NetworkingUIEventWrapped<R>>;
     private transformAxiosError;
     private transformAxiosResponse;
 }

package/dist/services/smess.service.js

@@ -1,56 +1,53 @@
-"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("./logger.service");
-// import { LOG_SERVICES_CONTEXT } from '@/services';
-var SMESSHeader;
+import { AlertButtonModel, AlertModel, NetworkingUIEventWrapped, } from '../types/types';
+import { catchError, mergeMap, of, startWith, } from '../utils/rxjs-import';
+import HttpService from '../core/rx.http.service';
+import { $logger } from '../services/logger.service';
+export var SMESSHeader;
 (function (SMESSHeader) {
     SMESSHeader["ContentType"] = "Content-Type";
     SMESSHeader["Authorization"] = "Authorization";
     SMESSHeader["Accept"] = "Accept";
     SMESSHeader["ApiKey"] = "X-Api-Key";
     SMESSHeader["ClientId"] = "X-Client-Id";
-})(SMESSHeader || (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";
     Accept["V3"] = "application/vnd.smess.v3+json";
     Accept["V4"] = "application/vnd.smess.v4+json";
-})(Accept || (exports.Accept = Accept = {}));
-const isProduction = typeof process !== 'undefined' && process.env.NODE_ENV === 'production';
-class SmessService {
+    Accept["V5"] = "application/vnd.smess.v5+json";
+    Accept["V6"] = "application/vnd.smess.v6+json";
+    Accept["V7"] = "application/vnd.smess.v7+json";
+    Accept["V8"] = "application/vnd.smess.v8+json";
+    Accept["V9"] = "application/vnd.smess.v9+json";
+    Accept["V10"] = "application/vnd.smess.v10+json";
+})(Accept || (Accept = {}));
+export class SmessService {
     constructor(target) {
         this.target = target;
         // Set default headers
-        logger_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);
@@ -65,27 +62,24 @@ 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: '',
             'Content-Type': ContentType.Json,
-            'X-Api-Key': '',
-            'X-Client-Id': '',
+            'X-Api-Key': ''
         };
-        if (shouldAddClientIdHeader) {
-            // headers[SMESSHeader.ClientId] = clientId; // Removed clientId usage
-        }
         return headers;
     }
     // 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.getPath(...queryParams)
             : this.target.path;
         const config = { url };
         let observable;
@@ -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,27 +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');
-        const message = error.message;
+        $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/services/smess.service.test.js

@@ -1,80 +1,99 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const smess_service_1 = require("./smess.service");
-const types_1 = require("../types/types");
-const rxjs_1 = require("rxjs");
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for test mocks */
+import { SmessService } from './smess.service';
+import { NetworkingUIEventWrapped } from '../types/types';
+import { of, throwError } from 'rxjs';
 describe('SmessService', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client',
+        apiKey: 'test-key',
+    };
     const provider = {
-        baseURL: 'https://api.example.com',
+        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);
+        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(),
             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(() => (0, rxjs_1.of)({ data: { 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(),
+            request: jest.fn((payload, mockResponse) => {
+                if (payload === 'error') {
+                    return throwError(() => new Error('Test error'));
+                }
+                if (mockResponse !== undefined) {
+                    return of(NetworkingUIEventWrapped.succeeded(mockResponse));
+                }
+                return of({ data: { foo: 'mock' } });
+            }),
             interceptors: { response: { use: jest.fn() } },
         };
-        service.request(undefined, { foo: 'mock' }).subscribe(result => {
-            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 → services}/store.service.d.ts

@@ -1,5 +1,5 @@
-import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types.js';
-import { SmessService } from './smess.service.js';
+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 {

package/dist/{src/services → services}/store.service.js

@@ -1,4 +1,4 @@
-import { Accept, SMESSHeader, SmessService } from './smess.service.js';
+import { Accept, SMESSHeader, SmessService } from './smess.service';
 export class StoreProvider {
     constructor(config, target, $authToken) {
         this.config = config;

package/dist/{src/services → services}/store.service.test.js

@@ -1,5 +1,5 @@
-import { StoreService } from './store.service.js';
-import { NetworkingUIEventWrapped, AlertModel } from '../types/types.js';
+import { StoreService } from './store.service';
+import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
 import { of, BehaviorSubject } from 'rxjs';
 describe('StoreService', () => {
     const config = {

package/dist/{src/services → services}/user.service.js

@@ -1,5 +1,5 @@
-import { BaseProvider } from '../core/base.provider.js';
-import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
+import { BaseProvider } from '../core/base.provider';
+import { BaseServiceWrapper } from '../core/base.service.wrapper';
 // UserProvider implements ProviderType for user endpoints
 export class UserProvider extends BaseProvider {
     constructor(config, userId) {

package/dist/{src/services → services}/user.service.test.js

@@ -1,7 +1,7 @@
-import { UserService } from './user.service.js';
-import { NetworkingUIEventWrapped } from '../types/types.js';
+import { UserService } from './user.service';
+import { NetworkingUIEventWrapped } from '../types/types';
 import { of, throwError } from 'rxjs';
-import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
+import { BaseServiceWrapper } from '../core/base.service.wrapper';
 describe('UserService', () => {
     const config = {
         baseUrl: 'https://jsonplaceholder.typicode.com',