@smess/networking 1.0.1 → 1.0.3

package/README.md

@@ -26,12 +26,12 @@ const configB = {
 
 ### 2. Create providers/services with config
 ```typescript
-import { ProductService } from './core/product.service';
-import { UserService } from './core/user.service';
+import { ProductService, UserService, AuthService } from '@smess/networking';
 
 const productServiceA = new ProductService(configA);
 const productServiceB = new ProductService(configB);
 const userServiceA = new UserService(configA);
+const authServiceA = new AuthService(configA);
 ```
 
 ### 3. Use services independently
@@ -39,12 +39,12 @@ const userServiceA = new UserService(configA);
 productServiceA.fetchAllProducts().subscribe(...);
 productServiceB.createProduct({ name: 'X', price: 10 }).subscribe(...);
 userServiceA.fetchUserById(1).subscribe(...);
+authServiceA.login({ identifier: 'user', password: 'pass' }).subscribe(...);
 ```
 
 ### 4. Example: Custom Provider
 ```typescript
-import { BaseProvider } from './core/base.provider';
-import { SmessService } from './services/smess.service';
+import { BaseProvider, SmessService } from '@smess/networking';
 
 const config = {
   baseUrl: 'https://custom-api',
@@ -72,27 +72,6 @@ service.request().subscribe(result => {
 });
 ```
 
-### 4. Example: Custom CustomerProvider
-
-```typescript
-import { CustomerProvider, CustomerTarget } from './core/customer.provider';
-import { SmessService } from './services/smess.service';
-
-const config = {
-  baseUrl: 'https://api.example.com',
-  isProd: false,
-  clientId: 'customer-client',
-  apiKey: 'customer-key',
-};
-
-const provider = new CustomerProvider(config, 'get-profile');
-const service = new SmessService(provider);
-
-service.request().subscribe(result => {
-  // handle result
-});
-```
-
 ---
 
 ## Private Package Usage

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './src/services/user.service';
+export * from './src/services/product.service';
+export * from './src/services/auth.service';
+export * from './src/services/smess.service';
+export * from './src/core/base.provider';
+export * from './src/core/base.service.wrapper';
+export * from './src/core/axios.observable';
+export * from './src/types/types';
+export { $logger } from './src/services/logger.service';
+export declare const baseURL: () => string;
+export declare const apiVersion: () => string;

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiVersion = exports.baseURL = exports.$logger = void 0;
+__exportStar(require("./src/services/user.service"), exports);
+__exportStar(require("./src/services/product.service"), exports);
+__exportStar(require("./src/services/auth.service"), exports);
+__exportStar(require("./src/services/smess.service"), exports);
+__exportStar(require("./src/core/base.provider"), exports);
+__exportStar(require("./src/core/base.service.wrapper"), exports);
+__exportStar(require("./src/core/axios.observable"), exports);
+__exportStar(require("./src/types/types"), exports);
+var logger_service_1 = require("./src/services/logger.service");
+Object.defineProperty(exports, "$logger", { enumerable: true, get: function () { return logger_service_1.$logger; } });
+const baseURL = () => {
+    return '';
+};
+exports.baseURL = baseURL;
+const apiVersion = () => {
+    return 'api/v1';
+};
+exports.apiVersion = apiVersion;

package/dist/scripts/real-test.js

@@ -3,15 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const user_service_js_1 = require("../src/domain/user.service.js");
+const user_service_1 = require("../src/services/user.service");
 const rxjs_1 = require("rxjs");
 const axios_1 = __importDefault(require("axios"));
+function isNetworkingUIEventWrapped(val) {
+    return (typeof val === 'object' &&
+        val !== null &&
+        'hasSuccess' in val &&
+        'hasFailed' in val &&
+        'response' in val);
+}
 async function testUserService() {
     const config = {
         baseUrl: 'https://jsonplaceholder.typicode.com',
         isProd: false,
     };
-    const userService = new user_service_js_1.UserService(config);
+    const userService = new user_service_1.UserService(config);
     let emitted = false;
     try {
         const obs$ = userService.fetchUserById(1).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
@@ -23,11 +30,11 @@ async function testUserService() {
                 next: (val) => {
                     emitted = true;
                     console.log('UserService emission:', val);
-                    if (val && val.hasSuccess && val.response) {
+                    if (isNetworkingUIEventWrapped(val) && val.hasSuccess && val.response) {
                         console.log('✅ UserService real API test succeeded:', val.response);
                         resolve(undefined);
                     }
-                    else if (val && val.hasFailed) {
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
                         console.error('❌ UserService real API test failed:', val.alertModel || val);
                         reject(new Error('UserService failed'));
                     }

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

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

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

@@ -4,7 +4,7 @@ const base_service_wrapper_1 = require("./base.service.wrapper");
 const types_1 = require("../types/types");
 const rxjs_1 = require("rxjs");
 // Mock SmessService for testing
-jest.mock('../domain/smess.service', () => ({
+jest.mock('../services/smess.service', () => ({
     SmessService: jest.fn().mockImplementation(() => ({
         request: jest.fn(() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 'bar' })))
     }))

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

@@ -0,0 +1,55 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types';
+import { SmessService } from './smess.service';
+import { Observable } from "rxjs";
+export interface AuthLoginRequest {
+    identifier: string;
+    password: string;
+}
+export interface ForgotPasswordRequest {
+    identifier: string;
+}
+export interface AuthChangePasswordRequest {
+    old_password: string;
+    password: string;
+}
+export interface ResetPasswordRequest {
+    token: string;
+    password: string;
+}
+export type AuthLoginResponse = {
+    token_type: unknown;
+    expires_in: unknown;
+    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 declare class AuthProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    constructor(config: NetworkingConfig, target: AuthTarget);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string | undefined>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface AuthServiceType {
+    provider(target: AuthTarget): SmessService<AuthProvider>;
+    login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+    logout(): Observable<NetworkingUIEventWrapped<void>>;
+    forgotPassword(payload: ForgotPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    changePassword(payload: AuthChangePasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    resetPassword(payload: ResetPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+}
+export declare class AuthService implements AuthServiceType {
+    private config;
+    constructor(config: NetworkingConfig);
+    provider(target: AuthTarget): SmessService<AuthProvider>;
+    login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+    logout(): Observable<NetworkingUIEventWrapped<void>>;
+    forgotPassword(payload: ForgotPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    changePassword(payload: AuthChangePasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    resetPassword(payload: ResetPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = exports.AuthProvider = void 0;
+const smess_service_1 = require("./smess.service");
+class AuthProvider {
+    constructor(config, target) {
+        this.config = config;
+        this.target = target;
+    }
+    get baseURL() {
+        return `${this.config.baseUrl}/api/v1`;
+    }
+    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';
+            default:
+                return '/authentication';
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case 'get-profile':
+                return 'GET';
+            case 'update-profile':
+                return 'PUT';
+            default:
+                return 'POST';
+        }
+    }
+    get headers() {
+        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,
+                });
+            default:
+                // Replace with your own auth logic as needed
+                return smess_service_1.SmessService.getHeaders(smess_service_1.Accept.V1, this.config.clientId);
+        }
+    }
+    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.AuthProvider = AuthProvider;
+class AuthService {
+    constructor(config) {
+        this.config = config;
+    }
+    provider(target) {
+        const targetWrapper = new AuthProvider(this.config, target);
+        return new smess_service_1.SmessService(targetWrapper);
+    }
+    login(payload) {
+        return this.provider('login').request(payload);
+    }
+    logout() {
+        return this.provider('logout').request();
+    }
+    forgotPassword(payload) {
+        return this.provider('password-forgot').request(payload);
+    }
+    changePassword(payload) {
+        return this.provider('change-password').request(payload);
+    }
+    resetPassword(payload) {
+        return this.provider('reset-password').request(payload);
+    }
+    verifyResetPasswordToken(token) {
+        return this.provider('verify-reset-password-token').request({ token });
+    }
+}
+exports.AuthService = AuthService;

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

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

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_service_1 = require("./auth.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+describe('AuthService', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client-id',
+        apiKey: 'test-api-key',
+    };
+    let service;
+    beforeEach(() => {
+        service = new auth_service_1.AuthService(config);
+    });
+    it('login success', async () => {
+        const payload = { identifier: 'user', password: 'pass' };
+        const response = {
+            token_type: 'Bearer',
+            expires_in: 3600,
+            token: 'token',
+            refresh_token: 'refresh',
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.login(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('login error', async () => {
+        const payload = { identifier: 'user', password: 'wrong' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.login(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('logout success', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(undefined)),
+        });
+        const result = await service.logout().toPromise();
+        expect(result === null || result === void 0 ? void 0 : result.hasSuccess).toBe(true);
+    });
+    it('forgotPassword success', async () => {
+        const payload = { identifier: 'user' };
+        const response = { data: 'ok' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.forgotPassword(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('changePassword success', async () => {
+        const payload = { old_password: 'old', password: 'new' };
+        const response = { data: 'changed' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.changePassword(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('resetPassword success', async () => {
+        const payload = { token: 'token', password: 'newpass' };
+        const response = { data: 'reset' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.resetPassword(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('verifyResetPasswordToken success', async () => {
+        const token = 'token';
+        const response = {
+            token_type: 'Bearer',
+            expires_in: 3600,
+            token: 'token',
+            refresh_token: 'refresh',
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.verifyResetPasswordToken(token).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('forgotPassword error', async () => {
+        const payload = { identifier: 'user' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.forgotPassword(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('changePassword error', async () => {
+        const payload = { old_password: 'old', password: 'bad' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.changePassword(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('resetPassword error', async () => {
+        const payload = { token: 'bad', password: 'bad' };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.resetPassword(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('verifyResetPasswordToken error', async () => {
+        const token = 'bad';
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.failed(types_1.AlertModel.default())),
+        });
+        const result = await service.verifyResetPasswordToken(token).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/product.service.d.ts

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

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductService = exports.ProductProvider = void 0;
+const base_provider_1 = require("../core/base.provider");
+const base_service_wrapper_1 = require("../core/base.service.wrapper");
+// ProductProvider implements ProviderType for product endpoints
+class ProductProvider extends base_provider_1.BaseProvider {
+    constructor(config, { productId, method } = {}) {
+        super({
+            config,
+            path: productId ? `/products/${productId}` : '/products',
+            method: method || 'GET',
+            headers: { 'Content-Type': 'application/json' },
+            getPath: () => (productId ? `/products/${productId}` : '/products'),
+        });
+    }
+}
+exports.ProductProvider = ProductProvider;
+// ProductService provides high-level methods for product API
+class ProductService extends base_service_wrapper_1.BaseServiceWrapper {
+    constructor(config, productId, method) {
+        super(new ProductProvider(config, { productId, method }));
+        this.config = config;
+    }
+    // Fetch a product by ID
+    fetchProductById(id) {
+        this.provider = new ProductProvider(this.config, { productId: id });
+        return this.request();
+    }
+    // Fetch all products
+    fetchAllProducts() {
+        this.provider = new ProductProvider(this.config);
+        return this.request();
+    }
+    // Create a new product (POST)
+    createProduct(product) {
+        this.provider = new ProductProvider(this.config, { method: 'POST' });
+        return this.request(product);
+    }
+}
+exports.ProductService = ProductService;
+// Example usage:
+// setNetworkingConfig({ baseUrl: 'https://fakestoreapi.com', isProd: false });
+// const productService = new ProductService();
+// productService.fetchProductById(1).subscribe(result => console.log(result));
+// productService.fetchAllProducts().subscribe(result => console.log(result));
+// productService.createProduct({ name: 'New Product', price: 99.99 }).subscribe(result => console.log(result)); 

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const product_service_1 = require("./product.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+const base_service_wrapper_1 = require("../core/base.service.wrapper");
+describe('ProductService', () => {
+    const config = {
+        baseUrl: 'https://jsonplaceholder.typicode.com',
+        isProd: false,
+        clientId: 'test-client',
+        apiKey: 'test-key',
+    };
+    const product = { id: 1, name: 'Product', price: 10 };
+    let requestSpy;
+    beforeEach(() => {
+        requestSpy = jest.spyOn(base_service_wrapper_1.BaseServiceWrapper.prototype, 'request').mockImplementation(() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(product)));
+    });
+    afterEach(() => {
+        requestSpy.mockRestore();
+    });
+    it('should fetch product by id', done => {
+        const service = new product_service_1.ProductService(config, 1);
+        service.fetchProductById(1).subscribe(result => {
+            expect(result.response).toEqual(product);
+            done();
+        });
+    });
+    it('should fetch all products', done => {
+        const service = new product_service_1.ProductService(config);
+        service.fetchAllProducts().subscribe(result => {
+            expect(result.response).toEqual(product);
+            done();
+        });
+    });
+    it('should create a product', done => {
+        const service = new product_service_1.ProductService(config);
+        service.createProduct({ name: 'New Product', price: 99.99 }).subscribe(result => {
+            expect(result.response).toEqual(product);
+            done();
+        });
+    });
+    it('request should handle error', done => {
+        requestSpy.mockImplementationOnce(() => (0, rxjs_1.throwError)(() => new Error('Test error')));
+        const service = new product_service_1.ProductService(config);
+        service.request('error').subscribe({
+            error: err => {
+                expect(err).toBeInstanceOf(Error);
+                expect(err.message).toBe('Test error');
+                done();
+            },
+        });
+    });
+});

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

@@ -0,0 +1,35 @@
+import { HeaderType, NetworkingUIEventWrapped, ProviderType } from '../types/types';
+import { Observable } from '../utils/rxjs-import';
+export declare enum SMESSHeader {
+    ContentType = "Content-Type",
+    Authorization = "Authorization",
+    Accept = "Accept",
+    ApiKey = "X-Api-Key",
+    ClientId = "X-Client-Id"
+}
+export declare enum ContentType {
+    Json = "application/json",
+    FormURLEncoded = "application/x-www-form-urlencoded"
+}
+export declare enum Accept {
+    V1 = "application/json",
+    V2 = "application/vnd.smess.v2+json",
+    V3 = "application/vnd.smess.v3+json",
+    V4 = "application/vnd.smess.v4+json",
+    V5 = "application/vnd.smess.v5+json",
+    V6 = "application/vnd.smess.v6+json",
+    V7 = "application/vnd.smess.v7+json",
+    V8 = "application/vnd.smess.v8+json",
+    V9 = "application/vnd.smess.v9+json",
+    V10 = "application/vnd.smess.v10+json"
+}
+export declare class SmessService<T extends ProviderType> {
+    private httpService;
+    private target;
+    constructor(target: T);
+    static getHeaders(version: Accept, authorization?: string | null, options?: HeaderType): Partial<Record<SMESSHeader, string | undefined>>;
+    private static commonHeaders;
+    request<R = unknown>(request?: unknown, mockResponse?: R, ...queryParams: unknown[]): Observable<NetworkingUIEventWrapped<R>>;
+    private transformAxiosError;
+    private transformAxiosResponse;
+}

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

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmessService = exports.Accept = exports.ContentType = exports.SMESSHeader = void 0;
+const types_1 = require("../types/types");
+const rxjs_import_1 = require("../utils/rxjs-import");
+const rx_http_service_1 = __importDefault(require("../core/rx.http.service"));
+const logger_service_1 = require("../services/logger.service");
+var SMESSHeader;
+(function (SMESSHeader) {
+    SMESSHeader["ContentType"] = "Content-Type";
+    SMESSHeader["Authorization"] = "Authorization";
+    SMESSHeader["Accept"] = "Accept";
+    SMESSHeader["ApiKey"] = "X-Api-Key";
+    SMESSHeader["ClientId"] = "X-Client-Id";
+})(SMESSHeader || (exports.SMESSHeader = SMESSHeader = {}));
+var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["FormURLEncoded"] = "application/x-www-form-urlencoded";
+})(ContentType || (exports.ContentType = ContentType = {}));
+var Accept;
+(function (Accept) {
+    Accept["V1"] = "application/json";
+    Accept["V2"] = "application/vnd.smess.v2+json";
+    Accept["V3"] = "application/vnd.smess.v3+json";
+    Accept["V4"] = "application/vnd.smess.v4+json";
+    Accept["V5"] = "application/vnd.smess.v5+json";
+    Accept["V6"] = "application/vnd.smess.v6+json";
+    Accept["V7"] = "application/vnd.smess.v7+json";
+    Accept["V8"] = "application/vnd.smess.v8+json";
+    Accept["V9"] = "application/vnd.smess.v9+json";
+    Accept["V10"] = "application/vnd.smess.v10+json";
+})(Accept || (exports.Accept = Accept = {}));
+class SmessService {
+    constructor(target) {
+        this.target = target;
+        // Set default headers
+        logger_service_1.$logger.info('SmessService initialized', {
+            target: this.target,
+            baseURL: this.target.baseURL,
+            method: this.target.method,
+            headers: this.target.headers,
+        }, 'SmessService');
+        this.httpService = rx_http_service_1.default.create({
+            baseURL: this.target.baseURL,
+            headers: this.target.headers,
+            method: this.target.method,
+        });
+        this.httpService.interceptors.response.use((response) => response, async (error) => {
+            var _a;
+            const originalRequest = error.config;
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 && !originalRequest._retry) {
+                originalRequest._retry = true;
+                logger_service_1.$logger.info('SmessService constructor - 401 retry', originalRequest, 'SmessService');
+                // Implement token refresh logic here
+                // Then retry the original request
+                // return httpService.request(originalRequest);
+            }
+            return Promise.reject(error);
+        });
+    }
+    static getHeaders(version, authorization = null, options) {
+        const headers = this.commonHeaders(version, options);
+        if (authorization) {
+            headers['Authorization'] = authorization;
+        }
+        return headers;
+    }
+    static commonHeaders(version, options) {
+        const { shouldAddClientIdHeader = true, } = options !== null && options !== void 0 ? options : {};
+        const headers = {
+            Accept: version,
+            Authorization: '',
+            'Content-Type': ContentType.Json,
+            'X-Api-Key': ''
+        };
+        return headers;
+    }
+    // MARK: - Public
+    request(request, mockResponse, ...queryParams) {
+        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;
+        const config = { url };
+        let observable;
+        if (this.target.method === 'GET') {
+            if (request) {
+                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') {
+            observable = this.httpService.patch(url, request, config);
+        }
+        else if (this.target.method === 'PUT') {
+            observable = this.httpService.put(url, request, config);
+        }
+        else {
+            observable = this.httpService.request(config);
+        }
+        return observable.pipe((0, rxjs_import_1.catchError)((error) => this.transformAxiosError(error, mockResponse)), (0, rxjs_import_1.mergeMap)((data) => this.transformAxiosResponse(data)), (0, rxjs_import_1.startWith)(types_1.NetworkingUIEventWrapped.waiting()));
+    }
+    // MARK: - Private
+    transformAxiosError(error, mockResponse) {
+        logger_service_1.$logger.error('transformAxiosError', error, 'SmessService');
+        const message = error instanceof Error ? error.message : String(error);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for axios compatibility
+        const response = error.response;
+        const httpErrorCode = response ? response.status : 0;
+        const title = response === null || response === void 0 ? void 0 : response.statusText;
+        const alertModel = new types_1.AlertModel(message, httpErrorCode, true, title, response === null || response === void 0 ? void 0 : response.data, [types_1.AlertButtonModel.buttonYes()]);
+        if (mockResponse) {
+            return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
+        }
+        return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.failed(alertModel));
+    }
+    transformAxiosResponse(response) {
+        logger_service_1.$logger.info('transformAxiosResponse', response, 'SmessService');
+        if (response instanceof types_1.NetworkingUIEventWrapped) {
+            return (0, rxjs_import_1.of)(response);
+        }
+        return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response.data));
+    }
+}
+exports.SmessService = SmessService;

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

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

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for test mocks */
+const smess_service_1 = require("./smess.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+describe('SmessService', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client',
+        apiKey: 'test-key',
+    };
+    const provider = {
+        baseURL: config.baseUrl,
+        path: '/resource',
+        method: 'GET',
+        headers: {},
+        getPath: () => '/resource',
+    };
+    it('should return succeeded for GET', done => {
+        const service = new smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.of)({ data: { foo: 'bar' } })),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            // 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' }));
+            }),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request().subscribe(result => {
+            expect(result).toBeInstanceOf(types_1.NetworkingUIEventWrapped);
+            expect(result.response).toEqual({ foo: 'bar' });
+            done();
+        });
+    });
+    it('should return succeeded for POST', done => {
+        const postProvider = Object.assign(Object.assign({}, provider), { method: 'POST' });
+        const service = new smess_service_1.SmessService(postProvider);
+        service['httpService'] = {
+            get: jest.fn(),
+            post: jest.fn((payload) => {
+                if (payload === 'error') {
+                    return (0, rxjs_1.throwError)(() => new Error('Test error'));
+                }
+                return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ 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();
+        });
+    });
+    it('should handle error', done => {
+        const service = new smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error'))),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn(),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request().subscribe(result => {
+            var _a;
+            expect(result).toBeInstanceOf(types_1.NetworkingUIEventWrapped);
+            expect(result.hasFailed).toBe(true);
+            expect(result.alertModel).toBeTruthy();
+            expect((_a = result.alertModel) === null || _a === void 0 ? void 0 : _a.message).toBe('Test error');
+            done();
+        });
+    });
+    it('should return mock response if provided', done => {
+        const service = new smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error'))),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn((payload, mockResponse) => {
+                if (payload === 'error') {
+                    return (0, rxjs_1.throwError)(() => new Error('Test error'));
+                }
+                if (mockResponse !== undefined) {
+                    return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
+                }
+                return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 'mock' }));
+            }),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request(undefined, { foo: 'mock' }).subscribe(result => {
+            expect(result.response).toEqual({ foo: 'mock' });
+            done();
+        });
+    });
+});

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

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

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

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

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

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

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

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

package/package.json

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