@smess/networking 1.0.5 → 1.0.7

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

@@ -1,39 +0,0 @@
-"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/auth.service.test.d.ts

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

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

@@ -1,31 +0,0 @@
-export declare enum LogLevel {
-    DEBUG = 0,
-    INFO = 1,
-    WARN = 2,
-    ERROR = 3,
-    NONE = 4
-}
-export interface LogEntry {
-    level: LogLevel;
-    message: string;
-    data?: unknown;
-    timestamp: number;
-    context?: string;
-}
-export declare class LoggerService {
-    private currentLevel;
-    private logs;
-    private maxLogs;
-    setLogLevel(level: LogLevel): void;
-    private shouldLog;
-    private formatMessage;
-    private getEmojiForLevel;
-    private log;
-    debug(message: string, data?: unknown, context?: string): void;
-    info(message: string, data?: unknown, context?: string): void;
-    warn(message: string, data?: unknown, context?: string): void;
-    error(message: string, data?: unknown, context?: string): void;
-    getLogs(): LogEntry[];
-    clearLogs(): void;
-}
-export declare const $logger: LoggerService;

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

@@ -1,93 +0,0 @@
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
-    LogLevel[LogLevel["INFO"] = 1] = "INFO";
-    LogLevel[LogLevel["WARN"] = 2] = "WARN";
-    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
-    LogLevel[LogLevel["NONE"] = 4] = "NONE";
-})(LogLevel || (LogLevel = {}));
-export class LoggerService {
-    constructor() {
-        this.currentLevel = LogLevel.DEBUG;
-        this.logs = [];
-        this.maxLogs = 1000;
-    }
-    setLogLevel(level) {
-        this.currentLevel = level;
-    }
-    shouldLog(level) {
-        return level >= this.currentLevel;
-    }
-    formatMessage(level, message, context) {
-        const emoji = this.getEmojiForLevel(level);
-        const levelName = LogLevel[level];
-        const contextStr = context ? ` [${context}]` : '';
-        return `${emoji} ${levelName}${contextStr}: ${message}`;
-    }
-    getEmojiForLevel(level) {
-        switch (level) {
-            case LogLevel.DEBUG:
-                return '🔍';
-            case LogLevel.INFO:
-                return 'ℹ️';
-            case LogLevel.WARN:
-                return '⚠️';
-            case LogLevel.ERROR:
-                return '❌';
-            default:
-                return '📝';
-        }
-    }
-    log(level, message, data, context) {
-        if (!this.shouldLog(level))
-            return;
-        const logEntry = {
-            level,
-            message,
-            data,
-            timestamp: Date.now(),
-            context
-        };
-        // Store log entry
-        this.logs.push(logEntry);
-        if (this.logs.length > this.maxLogs) {
-            this.logs.shift();
-        }
-        // Console output
-        const formattedMessage = this.formatMessage(level, message, context);
-        switch (level) {
-            case LogLevel.DEBUG:
-                console.debug(formattedMessage, data || '');
-                break;
-            case LogLevel.INFO:
-                console.info(formattedMessage, data || '');
-                break;
-            case LogLevel.WARN:
-                console.warn(formattedMessage, data || '');
-                break;
-            case LogLevel.ERROR:
-                console.error(formattedMessage, data || '');
-                break;
-        }
-    }
-    debug(message, data, context) {
-        this.log(LogLevel.DEBUG, message, data, context);
-    }
-    info(message, data, context) {
-        this.log(LogLevel.INFO, message, data, context);
-    }
-    warn(message, data, context) {
-        this.log(LogLevel.WARN, message, data, context);
-    }
-    error(message, data, context) {
-        this.log(LogLevel.ERROR, message, data, context);
-    }
-    getLogs() {
-        return [...this.logs];
-    }
-    clearLogs() {
-        this.logs = [];
-    }
-}
-// Export singleton instance
-export const $logger = new LoggerService();

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

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

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

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

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

@@ -1,21 +0,0 @@
-import { BaseProvider } from '../core/base.provider.js';
-import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
-import { NetworkingConfig } from '../types/types.js';
-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.js").NetworkingUIEventWrapped<Product>>;
-    fetchAllProducts(): import("rxjs").Observable<import("../types/types.js").NetworkingUIEventWrapped<Product[]>>;
-    createProduct(product: Omit<Product, 'id'>): import("rxjs").Observable<import("../types/types.js").NetworkingUIEventWrapped<Product>>;
-}

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

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

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

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

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

@@ -1,128 +0,0 @@
-import { NetworkingUIEventWrapped, AlertModel, AlertButtonModel } from '../types/types.js';
-import { of, catchError, mergeMap, startWith } from '../utils/rxjs-import.js';
-import HttpService from '../core/rx.http.service.js';
-import { $logger } from '../services/logger.service.js';
-export var SMESSHeader;
-(function (SMESSHeader) {
-    SMESSHeader["ContentType"] = "Content-Type";
-    SMESSHeader["Authorization"] = "Authorization";
-    SMESSHeader["Accept"] = "Accept";
-    SMESSHeader["ApiKey"] = "X-Api-Key";
-    SMESSHeader["ClientId"] = "X-Client-Id";
-})(SMESSHeader || (SMESSHeader = {}));
-export var ContentType;
-(function (ContentType) {
-    ContentType["Json"] = "application/json";
-    ContentType["FormURLEncoded"] = "application/x-www-form-urlencoded";
-})(ContentType || (ContentType = {}));
-export var Accept;
-(function (Accept) {
-    Accept["V1"] = "application/json";
-    Accept["V2"] = "application/vnd.smess.v2+json";
-    Accept["V3"] = "application/vnd.smess.v3+json";
-    Accept["V4"] = "application/vnd.smess.v4+json";
-    Accept["V5"] = "application/vnd.smess.v5+json";
-    Accept["V6"] = "application/vnd.smess.v6+json";
-    Accept["V7"] = "application/vnd.smess.v7+json";
-    Accept["V8"] = "application/vnd.smess.v8+json";
-    Accept["V9"] = "application/vnd.smess.v9+json";
-    Accept["V10"] = "application/vnd.smess.v10+json";
-})(Accept || (Accept = {}));
-export class SmessService {
-    constructor(target) {
-        this.target = target;
-        // Set default headers
-        $logger.info('SmessService initialized', {
-            target: this.target,
-            baseURL: this.target.baseURL,
-            method: this.target.method,
-            headers: this.target.headers,
-        }, 'SmessService');
-        this.httpService = HttpService.create({
-            baseURL: this.target.baseURL,
-            headers: this.target.headers,
-            method: this.target.method,
-        });
-        this.httpService.interceptors.response.use((response) => response, async (error) => {
-            const originalRequest = error.config;
-            if (error.response?.status === 401 && !originalRequest._retry) {
-                originalRequest._retry = true;
-                $logger.info('SmessService constructor - 401 retry', originalRequest, 'SmessService');
-                // Implement token refresh logic here
-                // Then retry the original request
-                // return httpService.request(originalRequest);
-            }
-            return Promise.reject(error);
-        });
-    }
-    static getHeaders(version, authorization = null, options) {
-        const headers = this.commonHeaders(version, options);
-        if (authorization) {
-            headers['Authorization'] = authorization;
-        }
-        return headers;
-    }
-    static filterHeaders(headers) {
-        const filteredHeaders = Object.fromEntries(Object.entries(headers).filter(([_, value]) => value !== undefined && value !== null && value !== ''));
-        return filteredHeaders;
-    }
-    static commonHeaders(version, options) {
-        const { shouldAddClientIdHeader = true, } = options ?? {};
-        const headers = {
-            Accept: version,
-            Authorization: '',
-            'Content-Type': ContentType.Json,
-            'X-Api-Key': ''
-        };
-        return headers;
-    }
-    // MARK: - Public
-    request(request, mockResponse, ...queryParams) {
-        const url = queryParams.length
-            ? this.target.getPath(...queryParams)
-            : this.target.path;
-        const config = { url };
-        let observable;
-        if (this.target.method === 'GET') {
-            if (request) {
-                config.data = request;
-                config.params = request;
-            }
-            observable = this.httpService.get(url, config);
-        }
-        else if (this.target.method === 'POST') {
-            observable = this.httpService.post(url, request, config);
-        }
-        else if (this.target.method === 'PATCH') {
-            observable = this.httpService.patch(url, request, config);
-        }
-        else if (this.target.method === 'PUT') {
-            observable = this.httpService.put(url, request, config);
-        }
-        else {
-            observable = this.httpService.request(config);
-        }
-        return observable.pipe(catchError((error) => this.transformAxiosError(error, mockResponse)), mergeMap((data) => this.transformAxiosResponse(data)), startWith(NetworkingUIEventWrapped.waiting()));
-    }
-    // MARK: - Private
-    transformAxiosError(error, mockResponse) {
-        $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?.statusText;
-        const alertModel = new AlertModel(message, httpErrorCode, true, title, response?.data, [AlertButtonModel.buttonYes()]);
-        if (mockResponse) {
-            return of(NetworkingUIEventWrapped.succeeded(mockResponse));
-        }
-        return of(NetworkingUIEventWrapped.failed(alertModel));
-    }
-    transformAxiosResponse(response) {
-        $logger.info('transformAxiosResponse', response, 'SmessService');
-        if (response instanceof NetworkingUIEventWrapped) {
-            return of(response);
-        }
-        return of(NetworkingUIEventWrapped.succeeded(response.data));
-    }
-}

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

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

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

@@ -1,99 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any -- Required for test mocks */
-import { SmessService } from './smess.service.js';
-import { NetworkingUIEventWrapped } from '../types/types.js';
-import { of, throwError } from 'rxjs';
-describe('SmessService', () => {
-    const config = {
-        baseUrl: 'https://api.example.com',
-        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 SmessService(provider);
-        service['httpService'] = {
-            get: jest.fn(() => of({ data: { foo: 'bar' } })),
-            post: jest.fn(),
-            patch: jest.fn(),
-            put: jest.fn(),
-            request: jest.fn(),
-            interceptors: { response: { use: jest.fn() } },
-        };
-        service.request().subscribe((result) => {
-            if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: 'bar' });
-                done();
-            }
-        });
-    });
-    it('should return succeeded for POST', done => {
-        const postProvider = { ...provider, method: 'POST' };
-        const service = new SmessService(postProvider);
-        service['httpService'] = {
-            get: jest.fn(),
-            post: jest.fn(() => of({ data: { foo: 'baz' } })),
-            patch: jest.fn(),
-            put: jest.fn(),
-            request: jest.fn(),
-            interceptors: { response: { use: jest.fn() } },
-        };
-        service.request({ some: 'data' }).subscribe((result) => {
-            if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: 'baz' });
-                done();
-            }
-        });
-    });
-    it('should handle error', done => {
-        const service = new SmessService(provider);
-        service['httpService'] = {
-            get: jest.fn(() => throwError(() => new Error('Test error'))),
-            post: jest.fn(),
-            patch: jest.fn(),
-            put: jest.fn(),
-            request: jest.fn(),
-            interceptors: { response: { use: jest.fn() } },
-        };
-        service.request().subscribe((result) => {
-            if (result.hasFailed) {
-                expect(result).toBeInstanceOf(NetworkingUIEventWrapped);
-                expect(result.hasFailed).toBe(true);
-                expect(result.alertModel).toBeTruthy();
-                expect(result.alertModel?.message).toBe('Test error');
-                done();
-            }
-        });
-    });
-    it('should return mock response if provided', done => {
-        const service = new SmessService(provider);
-        service['httpService'] = {
-            get: jest.fn(() => throwError(() => new Error('Test error'))),
-            post: jest.fn(),
-            patch: jest.fn(),
-            put: jest.fn(),
-            request: jest.fn((payload, mockResponse) => {
-                if (payload === 'error') {
-                    return throwError(() => new Error('Test error'));
-                }
-                if (mockResponse !== undefined) {
-                    return of(NetworkingUIEventWrapped.succeeded(mockResponse));
-                }
-                return of({ data: { foo: 'mock' } });
-            }),
-            interceptors: { response: { use: jest.fn() } },
-        };
-        service.request(undefined, { foo: 'mock' }).subscribe((result) => {
-            if (result.hasSuccess) {
-                expect(result.response).toEqual({ foo: 'mock' });
-                done();
-            }
-        });
-    });
-});

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

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

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

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

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

@@ -1,93 +0,0 @@
-export type CallbackHandler = () => void;
-interface AlertModelable {
-    isUnauthenticated: boolean;
-    isNetworkingError: boolean;
-}
-interface AlertButtonModelable {
-    title: string;
-    handler?: CallbackHandler;
-}
-export declare class AlertButtonModel implements AlertButtonModelable {
-    title: string;
-    handler?: CallbackHandler | undefined;
-    constructor(title: string, handler?: CallbackHandler | undefined);
-    static buttonYes(handler?: CallbackHandler): AlertButtonModelable;
-    static buttonNo(handler?: CallbackHandler): AlertButtonModelable;
-}
-export declare class AlertModel implements AlertModelable {
-    message: string;
-    httpErrorCode: number;
-    isDisplayable: boolean;
-    title?: string | undefined;
-    data?: unknown | undefined;
-    buttons?: AlertButtonModelable[] | undefined;
-    constructor(message: string, httpErrorCode: number, isDisplayable?: boolean, title?: string | undefined, data?: unknown | undefined, buttons?: AlertButtonModelable[] | undefined);
-    get isUnauthenticated(): boolean;
-    get isNetworkingError(): boolean;
-    static default(): AlertModel;
-}
-export declare class ValidationErrorMessage {
-    message: string;
-    constructor(message: string);
-}
-export type NetworkingFailed = {
-    alertModel: AlertModel;
-};
-export type NetworkingSucceeded<ResponseType> = {
-    responseBody: ResponseType;
-};
-export declare enum NetworkingUIEvent {
-    waiting = "waiting",
-    succeeded = "succeeded",
-    failed = "failed"
-}
-export declare class NetworkingUIEventWrapped<JSONResponse> {
-    private event;
-    private succeeded?;
-    private failed?;
-    constructor(event: NetworkingUIEvent, succeeded?: NetworkingSucceeded<JSONResponse> | undefined, failed?: NetworkingFailed | undefined);
-    get response(): JSONResponse | null;
-    get alertModel(): AlertModel | null;
-    get isWaiting(): boolean;
-    get hasSuccess(): boolean;
-    get hasFailed(): boolean;
-    get isUnauthenticated(): boolean;
-    static waiting<JSONResponse>(): NetworkingUIEventWrapped<JSONResponse>;
-    static succeeded<JSONResponse>(data: JSONResponse): NetworkingUIEventWrapped<JSONResponse>;
-    static failed<JSONResponse>(alertModel: AlertModel): NetworkingUIEventWrapped<JSONResponse>;
-}
-export interface ProviderType {
-    baseURL: string;
-    path: string;
-    method: string;
-    headers: Record<string, string | undefined>;
-    getPath(...queryParams: unknown[]): string;
-}
-export interface HeaderType {
-    shouldAddEncryptionHeader?: boolean;
-    shouldAddClientIdHeader?: boolean;
-}
-export interface HttpResponse {
-    data: unknown;
-}
-export interface ServerValidationErrorMessage {
-    message: string;
-    parameters?: {
-        error_code?: string;
-        field?: string;
-        [key: string]: unknown;
-    };
-}
-export interface ServerErrorResponse {
-    errors?: {
-        [field: string]: ServerValidationErrorMessage[];
-    };
-}
-export interface NetworkingConfig {
-    baseUrl: string;
-    version?: string;
-    isProd: boolean;
-    clientId?: string;
-    apiKey?: string;
-}
-export {};