@smess/networking 1.0.3 → 1.0.4

package/dist/scripts/real-test.js

@@ -6,6 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const user_service_1 = require("../src/services/user.service");
 const rxjs_1 = require("rxjs");
 const axios_1 = __importDefault(require("axios"));
+const auth_service_1 = require("../src/services/auth.service");
+const customer_service_1 = require("../src/services/customer.service");
+const store_service_1 = require("../src/services/store.service");
+const logger_service_1 = require("../src/services/logger.service");
 function isNetworkingUIEventWrapped(val) {
     return (typeof val === 'object' &&
         val !== null &&
@@ -13,6 +17,53 @@ function isNetworkingUIEventWrapped(val) {
         'hasFailed' in val &&
         'response' in val);
 }
+async function testAuthService() {
+    const config = {
+        baseUrl: 'https://api.smeservices.cloud',
+        version: 'api/v1',
+        isProd: true,
+        clientId: '665e188a-cdb0-11ef-b5bd-470a5caf5cbc',
+    };
+    const $authToken = new rxjs_1.BehaviorSubject(null);
+    const authService = new auth_service_1.AuthService(config, $authToken);
+    let emitted = false;
+    try {
+        const obs$ = authService.login({ identifier: 'test@email.org', password: 'PassWord123' }).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
+            logger_service_1.$logger.error('❌ AuthService observable error', err, 'real-test');
+            return (0, rxjs_1.of)(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            obs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    logger_service_1.$logger.info('AuthService emission', val, 'real-test');
+                    if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
+                        logger_service_1.$logger.info('✅ AuthService real API test succeeded', val.response, 'real-test');
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        logger_service_1.$logger.error('❌ AuthService real API test failed', val.alertModel || val, 'real-test');
+                        reject(new Error('AuthService failed'));
+                    }
+                },
+                error: (err) => {
+                    logger_service_1.$logger.error('❌ AuthService observable error', err, 'real-test');
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        logger_service_1.$logger.error('❌ AuthService observable completed without emission', undefined, 'real-test');
+                        reject(new Error('No emission'));
+                    }
+                }
+            });
+        });
+    }
+    catch (err) {
+        logger_service_1.$logger.error('❌ AuthService test error', err, 'real-test');
+        process.exit(2);
+    }
+}
 async function testUserService() {
     const config = {
         baseUrl: 'https://jsonplaceholder.typicode.com',
@@ -22,30 +73,137 @@ async function testUserService() {
     let emitted = false;
     try {
         const obs$ = userService.fetchUserById(1).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
-            console.error('❌ UserService observable error:', err);
+            logger_service_1.$logger.error('❌ UserService observable error', err, 'real-test');
             return (0, rxjs_1.of)(undefined);
         }));
         await new Promise((resolve, reject) => {
             obs$.subscribe({
                 next: (val) => {
                     emitted = true;
-                    console.log('UserService emission:', val);
+                    logger_service_1.$logger.info('UserService emission', val, 'real-test');
                     if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
-                        console.log('✅ UserService real API test succeeded:', val.response);
+                        logger_service_1.$logger.info('✅ UserService real API test succeeded', val.response, 'real-test');
                         resolve(undefined);
                     }
                     else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
-                        console.error('❌ UserService real API test failed:', val.alertModel || val);
+                        logger_service_1.$logger.error('❌ UserService real API test failed', val.alertModel || val, 'real-test');
                         reject(new Error('UserService failed'));
                     }
                 },
                 error: (err) => {
-                    console.error('❌ UserService observable error:', err);
+                    logger_service_1.$logger.error('❌ UserService observable error', err, 'real-test');
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        logger_service_1.$logger.error('❌ UserService observable completed without emission', undefined, 'real-test');
+                        reject(new Error('No emission'));
+                    }
+                }
+            });
+        });
+    }
+    catch (err) {
+        logger_service_1.$logger.error('❌ UserService test error', err, 'real-test');
+        process.exit(2);
+    }
+}
+async function testCustomerRegister() {
+    const config = {
+        baseUrl: 'https://api.smeservices.cloud',
+        version: 'api/v1',
+        isProd: true,
+        clientId: '665e188a-cdb0-11ef-b5bd-470a5caf5cbc',
+    };
+    const $authToken = new rxjs_1.BehaviorSubject(null);
+    const customerService = new customer_service_1.CustomerService(config, $authToken);
+    const random = Math.floor(Math.random() * 1000000);
+    const payload = {
+        email: `realtest+${random}@email.org`,
+        password: `PassWord${random}`,
+        phone_number: `+83${random}`,
+        client_id: config.clientId,
+    };
+    let emitted = false;
+    try {
+        const obs$ = customerService.register(payload).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
+            logger_service_1.$logger.error('❌ CustomerService observable error', err, 'real-test');
+            return (0, rxjs_1.of)(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            obs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    logger_service_1.$logger.info('CustomerService emission', val, 'real-test');
+                    if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
+                        logger_service_1.$logger.info('✅ CustomerService real API test succeeded', val.response, 'real-test');
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        logger_service_1.$logger.error('❌ CustomerService real API test failed', val.alertModel || val, 'real-test');
+                        reject(new Error('CustomerService failed'));
+                    }
+                },
+                error: (err) => {
+                    logger_service_1.$logger.error('❌ CustomerService observable error', err, 'real-test');
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        logger_service_1.$logger.error('❌ CustomerService observable completed without emission', undefined, 'real-test');
+                        reject(new Error('No emission'));
+                    }
+                }
+            });
+        });
+    }
+    catch (err) {
+        logger_service_1.$logger.error('❌ CustomerService test error', err, 'real-test');
+        process.exit(2);
+    }
+}
+async function testStoreProductCollection() {
+    const config = {
+        baseUrl: 'https://api.smeservices.cloud',
+        version: 'api/v1',
+        isProd: true,
+        clientId: '665e188a-cdb0-11ef-b5bd-470a5caf5cbc',
+    };
+    const $authToken = new rxjs_1.BehaviorSubject(null);
+    const storeService = new store_service_1.StoreService(config, $authToken);
+    const storeId = 'f1df6e9a-0160-11f0-82c2-6cac1a7e2953'; // Use a real or test store id as appropriate
+    const payload = {
+        page: 1,
+        per_page: 10,
+        search: 'bia',
+    };
+    let emitted = false;
+    try {
+        const obs$ = storeService.productCollection(storeId, payload).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
+            logger_service_1.$logger.error('❌ StoreService.productCollection observable error', err, 'real-test');
+            return (0, rxjs_1.of)(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            obs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    logger_service_1.$logger.info('StoreService.productCollection emission', val, 'real-test');
+                    if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
+                        logger_service_1.$logger.info('✅ StoreService.productCollection real API test succeeded', val.response, 'real-test');
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        logger_service_1.$logger.error('❌ StoreService.productCollection real API test failed', val.alertModel || val, 'real-test');
+                        reject(new Error('StoreService.productCollection failed'));
+                    }
+                },
+                error: (err) => {
+                    logger_service_1.$logger.error('❌ StoreService.productCollection observable error', err, 'real-test');
                     reject(err);
                 },
                 complete: () => {
                     if (!emitted) {
-                        console.error('❌ UserService observable completed without emission');
+                        logger_service_1.$logger.error('❌ StoreService.productCollection observable completed without emission', undefined, 'real-test');
                         reject(new Error('No emission'));
                     }
                 }
@@ -53,7 +211,7 @@ async function testUserService() {
         });
     }
     catch (err) {
-        console.error('❌ UserService test error:', err);
+        logger_service_1.$logger.error('❌ StoreService.productCollection test error', err, 'real-test');
         process.exit(2);
     }
 }
@@ -61,21 +219,29 @@ async function testAxiosDirect() {
     try {
         const response = await axios_1.default.get('https://jsonplaceholder.typicode.com/users/1');
         if (response && response.data && response.data.id === 1) {
-            console.log('✅ Direct axios test succeeded:', response.data);
+            logger_service_1.$logger.info('✅ Direct axios test succeeded', response.data, 'real-test');
         }
         else {
-            console.error('❌ Direct axios test failed:', response.data);
+            logger_service_1.$logger.error('❌ Direct axios test failed', response.data, 'real-test');
             process.exit(3);
         }
     }
     catch (err) {
-        console.error('❌ Direct axios test error:', err);
+        logger_service_1.$logger.error('❌ Direct axios test error', err, 'real-test');
         process.exit(4);
     }
 }
 (async () => {
     await testAxiosDirect();
+    logger_service_1.$logger.info('✅ Direct axios test passed!', undefined, 'real-test');
+    await testAuthService();
+    logger_service_1.$logger.info('✅ AuthService real API tests passed!', undefined, 'real-test');
     await testUserService();
-    console.log('🎉 All real API tests passed!');
+    logger_service_1.$logger.info('✅ UserService real API tests passed!', undefined, 'real-test');
+    await testCustomerRegister();
+    logger_service_1.$logger.info('✅ CustomerService real API register test passed!', undefined, 'real-test');
+    await testStoreProductCollection();
+    logger_service_1.$logger.info('✅ StoreService.productCollection real API test passed!', undefined, 'real-test');
+    logger_service_1.$logger.info('🎉 All real API tests passed!', undefined, 'real-test');
     process.exit(0);
 })();

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

@@ -1,6 +1,6 @@
 import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types';
 import { SmessService } from './smess.service';
-import { Observable } from "rxjs";
+import { BehaviorSubject, Observable } from "rxjs";
 export interface AuthLoginRequest {
     identifier: string;
     password: string;
@@ -22,15 +22,16 @@ export type AuthLoginResponse = {
     token: unknown;
     refresh_token: unknown;
 };
-export type AuthTarget = 'get-profile' | 'login' | 'logout' | 'register' | 'update-profile' | 'change-password' | 'password-forgot' | 'reset-password' | 'verify-reset-password-token';
+export type AuthTarget = 'login' | 'logout' | 'change-password' | 'password-forgot' | 'reset-password' | 'verify-reset-password-token';
 export declare class AuthProvider implements ProviderType {
     private readonly config;
     private readonly target;
-    constructor(config: NetworkingConfig, target: AuthTarget);
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: AuthTarget, $authToken: BehaviorSubject<string | null>);
     get baseURL(): string;
     get path(): string;
     get method(): string;
-    get headers(): Record<string, string | undefined>;
+    get headers(): Record<string, string>;
     getPath(...queryParams: unknown[]): string;
 }
 export interface AuthServiceType {
@@ -43,8 +44,9 @@ export interface AuthServiceType {
     verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
 }
 export declare class AuthService implements AuthServiceType {
-    private config;
-    constructor(config: NetworkingConfig);
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
     provider(target: AuthTarget): SmessService<AuthProvider>;
     login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
     logout(): Observable<NetworkingUIEventWrapped<void>>;

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

@@ -3,57 +3,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthService = exports.AuthProvider = void 0;
 const smess_service_1 = require("./smess.service");
 class AuthProvider {
-    constructor(config, target) {
+    constructor(config, target, $authToken) {
         this.config = config;
         this.target = target;
+        this.$authToken = $authToken;
     }
     get baseURL() {
-        return `${this.config.baseUrl}/api/v1`;
+        return this.config.version ? `${this.config.baseUrl}/${this.config.version}` : this.config.baseUrl;
     }
     get path() {
         switch (this.target) {
             case 'login':
                 return '/authentication/login_check';
-            case 'logout':
-                return '/authentication/logout';
-            case 'register':
-                return '/authentication/customer/register';
-            case 'get-profile':
-                return '/authentication/customer/get-profile';
-            case 'update-profile':
-                return '/authentication/customer/update';
             case 'password-forgot':
                 return '/authentication/forgot-password';
-            case 'change-password':
-                return '/authentication/change-password';
             case 'reset-password':
                 return '/authentication/reset-password';
+            case 'verify-reset-password-token':
+                return '/authentication/verify-reset-password-token';
+            case 'logout':
+                return '/authentication/logout';
+            case 'change-password':
+                return '/authentication/change-password';
             default:
                 return '/authentication';
         }
     }
     get method() {
         switch (this.target) {
-            case 'get-profile':
-                return 'GET';
-            case 'update-profile':
-                return 'PUT';
             default:
                 return 'POST';
         }
     }
     get headers() {
+        let authHeaders = {};
         switch (this.target) {
             case 'login':
-                return smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1);
-            case 'register':
-                return smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1, null, {
-                    shouldAddClientIdHeader: false,
-                });
+            case 'password-forgot':
+            case 'reset-password':
+            case 'verify-reset-password-token':
+                authHeaders = smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1);
+                break;
             default:
-                // Replace with your own auth logic as needed
-                return smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1, this.config.clientId);
+                authHeaders = smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1, this.$authToken.value);
+        }
+        if (this.config.clientId) {
+            authHeaders[smess_service_1.SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            authHeaders[smess_service_1.SMESSHeader.ApiKey] = this.config.apiKey;
         }
+        return smess_service_1.SmessService.filterHeaders(authHeaders);
     }
     getPath(...queryParams) {
         let definedPath = this.path;
@@ -66,11 +66,12 @@ class AuthProvider {
 }
 exports.AuthProvider = AuthProvider;
 class AuthService {
-    constructor(config) {
+    constructor(config, $authToken) {
         this.config = config;
+        this.$authToken = $authToken;
     }
     provider(target) {
-        const targetWrapper = new AuthProvider(this.config, target);
+        const targetWrapper = new AuthProvider(this.config, target, this.$authToken);
         return new smess_service_1.SmessService(targetWrapper);
     }
     login(payload) {

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

@@ -11,8 +11,10 @@ describe('AuthService', () => {
         apiKey: 'test-api-key',
     };
     let service;
+    let $authToken;
     beforeEach(() => {
-        service = new auth_service_1.AuthService(config);
+        $authToken = new rxjs_1.BehaviorSubject(null);
+        service = new auth_service_1.AuthService(config, $authToken);
     });
     it('login success', async () => {
         const payload = { identifier: 'user', password: 'pass' };

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

@@ -0,0 +1,43 @@
+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 {
+    client_id?: string;
+    email: string;
+    password: string;
+    phone_number?: string;
+    name?: string;
+    address?: string;
+    tax_identification_number?: string | null;
+}
+export interface CustomerUpdateRequest {
+    name: string;
+    address: string;
+    postal_code: string;
+    city: string;
+    state: string | null;
+    country: string | null;
+    contact_email: string | null;
+    phone_number: string | null;
+}
+export declare class CustomerProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: CustomerTarget, $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 CustomerService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: CustomerTarget): SmessService<CustomerProvider>;
+    register(payload: CustomerRegisterRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getProfile(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    updateProfile(payload: CustomerUpdateRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerService = exports.CustomerProvider = void 0;
+const smess_service_1 = require("./smess.service");
+class CustomerProvider {
+    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 'register':
+                return '/authentication/customer/register';
+            case 'get-profile':
+                return '/authentication/customer/get-profile';
+            case 'update-profile':
+                return '/authentication/customer/update';
+            default:
+                return '/authentication/customer';
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case 'get-profile':
+                return 'GET';
+            case 'update-profile':
+                return 'PUT';
+            default:
+                return 'POST';
+        }
+    }
+    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.CustomerProvider = CustomerProvider;
+class CustomerService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new CustomerProvider(this.config, target, this.$authToken);
+        return new smess_service_1.SmessService(targetWrapper);
+    }
+    register(payload) {
+        return this.provider('register').request(payload);
+    }
+    getProfile() {
+        return this.provider('get-profile').request();
+    }
+    updateProfile(payload) {
+        return this.provider('update-profile').request(payload);
+    }
+}
+exports.CustomerService = CustomerService;

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

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

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const customer_service_1 = require("./customer.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+describe('CustomerService', () => {
+    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 customer_service_1.CustomerService(config, $authToken);
+    });
+    it('register success', async () => {
+        const payload = {
+            email: 'test@example.com',
+            password: 'pass',
+        };
+        const response = { data: { id: 1, email: 'test@example.com' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.register(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('register error', async () => {
+        const payload = {
+            email: 'test@example.com',
+            password: 'pass',
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.register(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('getProfile success', async () => {
+        const response = { data: { id: 1, email: 'test@example.com' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.getProfile().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('getProfile error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.getProfile().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('updateProfile success', async () => {
+        const payload = {
+            name: 'Test',
+            address: '123 Main St',
+            postal_code: '12345',
+            city: 'City',
+            state: null,
+            country: null,
+            contact_email: null,
+            phone_number: null,
+        };
+        const response = { data: { id: 1, name: 'Test' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.updateProfile(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('updateProfile error', async () => {
+        const payload = {
+            name: 'Test',
+            address: '123 Main St',
+            postal_code: '12345',
+            city: 'City',
+            state: null,
+            country: null,
+            contact_email: null,
+            phone_number: null,
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.updateProfile(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);
+    });
+});

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

@@ -0,0 +1,60 @@
+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 {
+}
+export interface UpdateOrderRequest {
+    external_id?: string;
+    order_date: string;
+    type?: string;
+    status?: string;
+    payment_status?: string;
+    delivery_note?: string;
+    delivery_fee?: number;
+    payment_method?: string;
+    payment_period?: string;
+    discount_in_percent?: number;
+    due_payment_amount?: number;
+    total_gst?: number;
+    total_exclude_gst?: number;
+    total_include_gst?: number;
+    order_items: OrderItemRequest[];
+}
+export interface OrderItemRequest {
+    product_name: string;
+    product_category: string;
+    supplier?: string;
+    supplier_code?: string;
+    supplier_item_name?: string;
+    unit: string;
+    quantity: number;
+    price_include_taxes: number;
+    vat_in_percent: number;
+    discount_in_percent?: number;
+    page_number?: number;
+    item_row_in_page?: number;
+}
+export declare class OrderProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: OrderTarget, $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 OrderService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: OrderTarget): SmessService<OrderProvider>;
+    list(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    create(payload: CreateOrderRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    delete(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getDraft(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    update(id: string, payload: UpdateOrderRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    get(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderService = exports.OrderProvider = void 0;
+const smess_service_1 = require("./smess.service");
+class OrderProvider {
+    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 'order-list':
+                return '/order/list';
+            case 'order-create':
+                return '/order/create';
+            case 'order-delete':
+                return '/order/${id}';
+            case 'order-get-draft':
+                return '/order/get-draft';
+            case 'order-update':
+            case 'order-get':
+            default:
+                return '/order/${id}';
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case 'order-list':
+            case 'order-get':
+            case 'order-get-draft':
+                return 'GET';
+            case 'order-create':
+                return 'POST';
+            case 'order-update':
+                return 'PUT';
+            case 'order-delete':
+                return 'DELETE';
+            default:
+                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.OrderProvider = OrderProvider;
+class OrderService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new OrderProvider(this.config, target, this.$authToken);
+        return new smess_service_1.SmessService(targetWrapper);
+    }
+    list() {
+        return this.provider('order-list').request();
+    }
+    create(payload) {
+        return this.provider('order-create').request(payload);
+    }
+    delete(id) {
+        return this.provider('order-delete').request(null, undefined, id);
+    }
+    getDraft() {
+        return this.provider('order-get-draft').request();
+    }
+    update(id, payload) {
+        return this.provider('order-update').request(payload, undefined, id);
+    }
+    get(id) {
+        return this.provider('order-get').request(null, undefined, id);
+    }
+}
+exports.OrderService = OrderService;

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

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

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const order_service_1 = require("./order.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+describe('OrderService', () => {
+    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 order_service_1.OrderService(config, $authToken);
+    });
+    it('list success', async () => {
+        const response = { data: [{ id: '1', status: 'draft' }] };
+        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('create success', async () => {
+        const payload = {
+            order_date: '2024-01-01',
+            order_items: [],
+        };
+        const response = { data: { id: '1', status: 'created' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.create(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('create error', async () => {
+        const payload = {
+            order_date: '2024-01-01',
+            order_items: [],
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.create(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('delete success', async () => {
+        const response = { data: { id: '1', status: 'deleted' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.delete('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('delete 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.delete('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('getDraft success', async () => {
+        const response = { data: { id: 'draft', status: 'draft' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.getDraft().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('getDraft error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.getDraft().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('update success', async () => {
+        const payload = {
+            order_date: '2024-01-01',
+            order_items: [],
+        };
+        const response = { data: { id: '1', status: 'updated' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.update('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('update error', async () => {
+        const payload = {
+            order_date: '2024-01-01',
+            order_items: [],
+        };
+        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.update('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('get success', async () => {
+        const response = { data: { id: '1', status: 'fetched' } };
+        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);
+    });
+});

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

@@ -28,6 +28,7 @@ export declare class SmessService<T extends ProviderType> {
     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;

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

@@ -69,6 +69,10 @@ 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 headers = {
@@ -81,9 +85,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 +95,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') {

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

@@ -25,19 +25,14 @@ describe('SmessService', () => {
             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();
+            if (result.hasSuccess) {
+                expect(result.response).toEqual({ foo: 'bar' });
+                done();
+            }
         });
     });
     it('should return succeeded for POST', done => {
@@ -45,20 +40,17 @@ describe('SmessService', () => {
         const service = new smess_service_1.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(() => (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 => {
-            expect(result.response).toEqual({ foo: 'baz' });
-            done();
+            if (result.hasSuccess) {
+                expect(result.response).toEqual({ foo: 'baz' });
+                done();
+            }
         });
     });
     it('should handle error', done => {
@@ -73,11 +65,13 @@ describe('SmessService', () => {
         };
         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();
+            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 => {
@@ -94,13 +88,15 @@ describe('SmessService', () => {
                 if (mockResponse !== undefined) {
                     return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
                 }
-                return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 'mock' }));
+                return (0, rxjs_1.of)({ data: { foo: 'mock' } });
             }),
             interceptors: { response: { use: jest.fn() } },
         };
         service.request(undefined, { foo: 'mock' }).subscribe(result => {
-            expect(result.response).toEqual({ foo: 'mock' });
-            done();
+            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/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.3",
+  "version": "1.0.4",
   "description": "Networking utilities and services for SMESS platform.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",