@rws-framework/client 2.7.2 → 2.8.1

package/src/run.ts

@@ -1,33 +0,0 @@
-import { ConfigServiceInstance } from './services/ConfigService';
-import { NotifyServiceInstance } from './services/NotifyService';
-import { WSServiceInstance} from './services/WSService';
-
-import { RoutingServiceInstance} from './services/RoutingService';
-
-const main = async (
-    config: ConfigServiceInstance, 
-    WSService: WSServiceInstance, 
-    NotifyService: NotifyServiceInstance, 
-    RoutingService: RoutingServiceInstance
-): Promise<boolean> => {        
-    if(config.get('backendUrl')){
-        WSService.on('ws:disconnected', (instance, params) => {
-            NotifyService.notify(`Your websocket client disconnected from the server. Your ID was <strong>${params.socketId}</strong>`, 'error');
-        });
-
-        WSService.on('ws:connected', (instance, params) => {
-            NotifyService.notify('You are connected to websocket. Your ID is: <strong>' + instance.socket().id + '</strong>', 'info');
-        });
-
-        WSService.on('ws:reconnect', (instance, params) => {
-            console.info('WS RECONNECTION ' + (params.reconnects + 1));
-            NotifyService.notify('Your websocket client has tried to reconnect to server. Attempt #' + (params.reconnects+1), 'warning');
-        });  
-
-        WSService.init(config.get('wsUrl'), config.get('user'), config.get('transports'));
-    }
-
-    return true;
-};
-
-export default main;

package/src/services/RoutingService.ts

@@ -1,47 +0,0 @@
-
-import TheService from './_service';
-import Router from 'url-router';
-import { RWSRouter, IRWSRouteResult, RouteReturn } from '../routing/_router';
-import UtilsService, {UtilsServiceInstance} from './UtilsService';
-import { IRWSViewComponent } from '../interfaces/IRWSViewComponent';
-import ConfigService, { ConfigServiceInstance } from './ConfigService';
-
-type IFrontRoutes = Record<string, unknown>; 
-
-class RoutingService extends TheService {
-    static _DEFAULT: boolean = true;
-    private router: Router<any>;
-    private routes: IFrontRoutes;
-
-    constructor(@UtilsService private utilsService: UtilsServiceInstance, @ConfigService private config: ConfigServiceInstance){
-        super();        
-    }    
-
-    public apply(comp: IRWSViewComponent): RWSRouter
-    {                    
-        this.routes = this.config.get('routes');
-        this.router = new Router(this.routes);
-   
-        return new RWSRouter(comp, this.router, this.utilsService);
-    }
-
-    public routeHandler = <T>(comp:  T) => () => {
-        return comp;
-    };  
-
-    public getRoutes(): IFrontRoutes
-    {
-        return this.routes;
-    }
-}
-
-const renderRouteComponent = <T>(routeName: string, cmp: T, defaultRouteParams: any = {}) => (): [string, T, any] => [routeName, cmp, defaultRouteParams];
-
-const _ROUTING_EVENT_NAME = 'routing.route.change';
-interface IRoutingEvent {
-  routeName: string,
-  component: IRWSViewComponent
-}
-
-export default RoutingService.getSingleton();
-export { RoutingService as RoutingServiceInstance, IFrontRoutes, RWSRouter, IRWSRouteResult, renderRouteComponent, RouteReturn, _ROUTING_EVENT_NAME, IRoutingEvent};

package/src/services/WSService.ts

@@ -1,226 +0,0 @@
-import TheService from './_service';
-import { io, Socket } from 'socket.io-client';
-import ITheUser from '../interfaces/IRWSUser';
-import { v4 as uuid } from 'uuid';
-import { ping, disconnect as disconnectWs, reconnect as reconnectWs } from './_ws_handlers/ConnectionHandler';
-import WSEventHandler from './_ws_handlers/EventHandler';
-import WSMessageHandler from './_ws_handlers/MessageHandler';
-
-type WSEvent = string;
-type WSStatus = 'WS_OPEN' | 'WS_CLOSED' | 'WS_CONNECTING';
-
-// function logClickableLink(text: string, url: string) {  
-//     console.log('[', url, ']:', text);  
-// }
-
-// const getCurrentLineNumber = UtilsService.getCurrentLineNumber;
-
-
-const  wsLog = async (fakeError: Error, text: any, socketId: string = null, isError: boolean = false): Promise<void> => {  
-    const logit = isError ? console.error : console.log;
-    logit(`<WS-CLIENT>${socketId ? `(${socketId})` : ''}`, text);
-};
-
-class WSService extends TheService {
-    static _DEFAULT: boolean = true;
-    static websocket_instance: Socket;
-    private _ws: Socket | null = null;
-  
-  
-    private user: ITheUser | null = null;
-    private url: string | null = null;
-  
-    private _status_string: WSStatus = 'WS_CLOSED';
-
-    public _wsId: string | null = null;
-
-  
-    public _interval: any = null;    
-    public _connecting: boolean = false;
-    public _shut_down: boolean = false;
-    public reconnects: number = 0;
-
-    public eventListeners: Map<string, Array<(instance: WSService, params: any) => any>> = new Map();
-
-    public async init(url: string, user?: ITheUser, transports: string[] = null): Promise<WSService> {
-        this._connecting = true;        
-        wsLog(new Error(), 'Connecting to: ' + url);
-        this.url = url;
-        this.user = user;            
-
-        const headers = this.user?.jwt_token ? {
-            Authorization: 'Bearer ' + this.user?.jwt_token,
-        } : {};
-
-        if(!WSService.websocket_instance){
-            console.log('WSSERVICE', headers);
-            const tokenString = headers.Authorization ? `?token=${this.user.jwt_token}` : '' ;
-            WSService.websocket_instance = io(this.url + tokenString, { 
-                auth: user?.jwt_token ? { token:  user.jwt_token} : {}, 
-                transports:  transports || null 
-            });
-        }          
-        //, transports:  ['websocket']
-        this._ws = WSService.websocket_instance;
-
-  
-
-        if (this.user?.mongoId) {
-            this._wsId = this.user.mongoId;
-        }else{
-            this._wsId = uuid();
-        }
-
-        let socketId: string = null;
-
-        this._ws.on('connect', () => {
-            socketId = this.socket().id;         
-
-            wsLog(new Error(), 'Socket connected with ID: ' + socketId, socketId);
-
-            this._connecting = false;
-            this._ws.connected = true;  
-
-            this.executeEventListener('ws:connected');               
-        
-            wsLog(new Error(), 'Emitting ping to server', socketId);
-            ping(this);
-        });
-        
-        this._ws.on('__PONG__', async (data: any) => {              
-            if (data === '__PONG__') {
-                wsLog(new Error(), 'Recieving valid ping callback from server', socketId);                                                           
-                return;
-            }
-        });
-
-        this._ws.on('disconnect', async (e) => {              
-            wsLog(new Error(), 'Disconnected from the server', socketId);              
-            this.executeEventListener('ws:disconnected', { socketId: socketId, error: e });
-            socketId = null;
-        });
-
-        this._ws.on('error', async (error: Error) => {
-            wsLog(error, 'Socket error:', socketId, true);
-            console.error(error);
-            this.executeEventListener('ws:error', { socketId: socketId, error: error });
-
-        });
-        
-
-        // this._interval = setInterval(() => {
-        //     ping(_self);
-        // }, 3000);
-
-        this.reconnects = 0;
-
-        if (this._ws?.connected) {
-            this._connecting = false;
-        }
-
-        this.statusChange();
-
-        return this;
-    }
-
-    public getStatus(): WSStatus {
-        return this._status_string;
-    }  
-
-    public isActive(): boolean {
-        return !this._connecting && this._ws?.connected;
-    }
-
-    setUser(user: ITheUser): void
-    {
-        this.user = user;
-    }
-
-    public listenForError<T extends Error | any = Error | any>(callback: (data: { error: T }) => void, method: string): void
-    {
-        this.socket().on(method, (rawData: string) => {            
-            callback(JSON.parse(rawData));
-        });
-    }
-
-    public listenForMessage(callback: (data: any, isJson?: boolean) => void, method?: string): () => void 
-    {
-        const disableHandler = () => {
-            this.socket().off(method, callback);
-        };
-
-        WSMessageHandler.listenForMessage(this, callback, method);
-
-        return disableHandler.bind(this);
-    }
-
-    async waitForStatus(): Promise<void>
-    {
-        return new Promise((resolve, reject) => {
-            let iteration = 0;
-            const t = setInterval(() => {
-                if(iteration > 4){
-                    clearInterval(t);
-                    reject('Websocket did not connect!');                  
-                }
-
-                if(this.isActive()){                        
-                    clearInterval(t);
-                    resolve();                  
-                }
-
-                iteration++;
-            }, 1000);
-        });
-    }
-
-    public sendMessage<T>(method: string, msg: T): void {                
-        WSMessageHandler.sendMessage<T>(this, method, msg);
-    }
-
-    public statusChange(): void {
-        let status: WSStatus = 'WS_CLOSED';
-        if (this._connecting) {
-            status = 'WS_CONNECTING';
-        } else if (this.isActive()) {
-            status = 'WS_OPEN';
-        }
-
-        this.executeEventListener('ws:status_change', { status });      
-        this._status_string = status;
-    }
-
-    public on(event: WSEvent, callback: (wsInstance: WSService, params: any) => any): void {
-        WSEventHandler.on(this, event, callback);
-    }
-
-    public executeEventListener(event: WSEvent, params: any = {}): void {
-        WSEventHandler.executeEventListener(this, event, params);
-    }
-
-    public socket(): Socket
-    {
-        return this._ws;
-    }
-
-    public disconnect()
-    {
-        disconnectWs(this);
-    }
-
-    public reconnect()
-    {
-        reconnectWs(this);
-    }
-
-    getUser(): ITheUser {
-        return this.user;
-    }
-
-    getUrl(): string {
-        return this.url;
-    }
-}
-
-export default WSService.getSingleton();
-export { WSService as WSServiceInstance, WSEvent, WSService as WSInstance, WSStatus };

package/src/services/_ws_handlers/ConnectionHandler.ts

@@ -1,52 +0,0 @@
-import { WSInstance } from '../WSService';
-
-
-function ping(instance: WSInstance): void {    
-    instance.socket().emit('__PING__');
-    // instance._timeout = setTimeout(() => {
-    //     reconnect(instance);
-    // }, 3000);
-}
-
-
-function reconnect(instance: WSInstance): void {    
-    disconnect(instance, true);
-    const rc = instance.reconnects;
-    if (rc < 2) {
-        instance.executeEventListener('ws:reconnect', { reconnects: rc + 1 });        
-        instance._connecting = true;
-        instance.reconnects++;
-        setTimeout(() => {
-            instance.init(instance.getUrl()!, instance.getUser());
-            instance.reconnects = rc + 1;
-        }, 1500);
-
-        instance.statusChange();
-    } else {
-        disconnect(instance);
-    }
-}
-function disconnect(instance: WSInstance, noEvent = false): void {
-
-    if(instance.socket()){
-        instance.socket().disconnect();
-    }
-
-    if(!noEvent){
-        console.log(`{WS}${instance.socket() ? `(${instance.socket().id}):` : ''} Disconnected from WS`);
-        instance.executeEventListener('ws:disconnected');
-    }
-    
-    clearInterval(instance._interval);
-
-    instance._connecting = false;
-    instance._shut_down = true;
-
-    instance.statusChange();
-}    
-
-export {
-    ping,
-    reconnect,
-    disconnect
-};

package/src/services/_ws_handlers/EventHandler.ts

@@ -1,28 +0,0 @@
-import { WSInstance, WSEvent } from '../WSService';
-
-function on(instance: WSInstance, event: WSEvent, callback: (wsInstance: WSInstance, params: any) => any): void {
-    let listeners = instance.eventListeners.get(event);
-    if (!listeners) {
-        listeners = [];
-        instance.eventListeners.set(event, listeners);
-    }
-    listeners.push(callback);
-}
-
-function executeEventListener(instance: WSInstance, event: WSEvent, params: any = {}): void {    
-    const listeners = instance.eventListeners.get(event);
-    if (listeners) {
-        listeners.forEach(callback => {
-            try {
-                callback(instance, params);
-            } catch (e) {
-                console.error(`Error executing callback for event '${event}':`, e);
-            }
-        });
-    }
-}
-
-export default {
-    on,
-    executeEventListener
-};

package/src/services/_ws_handlers/MessageHandler.ts

@@ -1,49 +0,0 @@
-import { WSInstance } from '../WSService';
-
-function listenForMessage(instance: WSInstance, callback: (data: any, isJson?: boolean) => void, method?: string): WSInstance {
-    if (!instance.socket()) {
-        throw new Error('socket is not active');
-    }
-
-    instance.socket().on(method || 'message', (data: any) => {
-        try {            
-            const parsedData = JSON.parse(data);
-            if (!!method && parsedData.method === method) {                              
-                callback(parsedData, true);
-                instance.executeEventListener('ws:message_received', { message: parsedData });
-
-            } else if (!method) {
-                callback(parsedData, true);
-            }            
-        } catch (e) {
-            console.error(e);
-            
-            if (!method) {                
-                callback(data);
-            }
-        }
-    });
-
-    return instance;
-}
-
-function sendMessage<T>(instance: WSInstance, method: string, msg: T): void {
-    if (!instance.socket()) {
-        throw new Error('socket is not active');
-    }
-
-    const the_message = {
-        user_id: instance.socket().id,
-        method: method,
-        msg: msg
-    };
-
-    
-    instance.socket().emit(method, JSON.stringify(the_message));
-    instance.executeEventListener('ws:message_sent', { message: the_message });
-} 
-
-export default{
-    listenForMessage,
-    sendMessage
-};