aotrautils-srv 0.0.1478 → 0.0.1479

aotrautils-srv/aotrautils-srv.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (26/04/2025-16:16:46)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (27/04/2025-01:02:04)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -4894,7 +4894,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils AI library associated with aotra version : «1_29072022-2359 (26/04/2025-16:16:46)»*/
+/*utils AI library associated with aotra version : «1_29072022-2359 (27/04/2025-01:02:04)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -5040,7 +5040,7 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 
 
 
-/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (26/04/2025-16:16:46)»*/
+/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (27/04/2025-01:02:04)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -5294,7 +5294,25 @@ WebsocketImplementation={
 			WebsocketImplementation.isNodeContext=isNodeContext;
 			WebsocketImplementation.useSocketIOImplementation=useSocketIOImplementation;
 
-			if(WebsocketImplementation.useSocketIOImplementation){
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				// TRACE
+				lognow("INFO : (SERVER/CLIENT) Using native WebSocket implementation.");	
+				
+				// https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications
+				if(isNodeContext){
+					if(typeof(WebSocket)==="undefined"){
+						// TRACE
+						console.log("«ws» SERVER library not called yet, calling it now.");
+						
+						WebSocket=require("ws");
+						if(typeof(WebSocket)==="undefined"){
+							// TRACE
+							console.log("ERROR : «ws» CONSOLE/BROWSER CLIENT/SERVER library not found. Cannot launch nodejs server. Aborting.");
+						}
+					}
+				}
+				
+			}else{
 				// TRACE
 				lognow("INFO : (SERVER/CLIENT) Using socket.io websocket implementation.");	
 				
@@ -5327,23 +5345,6 @@ WebsocketImplementation={
 					}
 				}
 
-			}else{
-				// TRACE
-				lognow("INFO : (SERVER/CLIENT) Using native WebSocket implementation.");	
-				
-				// https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications
-				if(isNodeContext){
-					if(typeof(WebSocket)==="undefined"){
-						// TRACE
-						console.log("«ws» SERVER library not called yet, calling it now.");
-						
-						WebSocket=require("ws");
-						if(typeof(WebSocket)==="undefined"){
-							// TRACE
-							console.log("ERROR : «ws» CONSOLE/BROWSER CLIENT/SERVER library not found. Cannot launch nodejs server. Aborting.");
-						}
-					}
-				}
 				
 			}
 
@@ -7118,6 +7119,47 @@ getAORTACNode=function(nodeId=getUUID(), selfOrigin="ws://127.0.0.1:40000", outc
 
 // ==================================================================================================================
 
+class ServerReceptionEntryPoint{
+	
+	constructor(channelNameParam, clientsRoomsTag){
+		this.channelName=channelNameParam;
+		this.clientsRoomsTag=clientsRoomsTag; 
+	}
+	
+	execute(eventOrMessage, clientSocketParam){
+
+	  // With «ws» library we have no choive than register message events inside a «connection» event !
+
+		const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
+	
+		// Channel information is stored in exchanged data :
+		if(dataWrapped.channelName!==this.channelName) return;
+										
+		// TODO : FIXME : Use one single interface !
+		// Room information is stored in client socket object :
+		const isClientInRoom=WebsocketImplementation.isInRoom(clientSocketParam, this.clientsRoomsTag);
+		
+		// DBG
+		lognow("(SERVER) isClientInRoom:",isClientInRoom);
+		
+		if(!isClientInRoom) return;
+
+		if(doOnIncomingMessage){
+			// DBG
+			lognow("(SERVER) doOnIncomingMessage:");
+			doOnIncomingMessage(dataWrapped.data, clientSocketParam);
+		}
+				
+	}
+}
+
+
+
+
+
+
+
+
 class NodeServerInstance{
 	
 	constructor(serverSocket, listenableServer){
@@ -7127,7 +7169,7 @@ class NodeServerInstance{
 		this.clientPingIntervalMillis=5000;
 		this.serverSocket=serverSocket;
 		this.listenableServer=listenableServer;
-		this.receptionEntryPoints=[];
+		this.serverReceptionEntryPoints=[];
 		
 	}
 	
@@ -7150,47 +7192,16 @@ class NodeServerInstance{
 		// DBG
 		lognow("(SERVER) Registering receive for «"+channelNameParam+"»...");
 		
-		
-		const receptionEntryPoint={
-			channelName:channelNameParam,
-			clientsRoomsTag:clientsRoomsTag, 
-			execute:(eventOrMessage, clientSocketParam)=>{
-
-			  // With «ws» library we have no choive than register message events inside a «connection» event !
-
-				const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
-			
-				// Channel information is stored in exchanged data :
-				if(dataWrapped.channelName!==receptionEntryPoint.channelName) return;
-												
-
-				// TODO : FIXME : Use one single interface !
-				// Room information is stored in client socket object :
-				const isClientInRoom=WebsocketImplementation.isInRoom(clientSocketParam, receptionEntryPoint.clientsRoomsTag);
-				
-				// DBG
-				lognow("(SERVER) isClientInRoom:",isClientInRoom);
-				
-				if(!isClientInRoom) return;
-
-				if(doOnIncomingMessage){
-					// DBG
-					lognow("(SERVER) doOnIncomingMessage:");
-					doOnIncomingMessage(dataWrapped.data, clientSocketParam);
-				}
-				
-			},
-		};
-		
+		const serverReceptionEntryPoint=new ServerReceptionEntryPoint(channelNameParam,clientsRoomsTag);
 		
 		///!!!
-		self.receptionEntryPoints.push(receptionEntryPoint);
+		this.serverReceptionEntryPoints.push(serverReceptionEntryPoint);
 		
 		// SPECIAL FOR THE SOCKETIO IMPLEMENTATION :
 		if(WebsocketImplementation.useSocketIOImplementation){
-			const channelName=receptionEntryPoint.channelName;
+			const channelName=serverReceptionEntryPoint.channelName;
 			clientSocket.on(channelName, (eventOrMessage)=>{
-				receptionEntryPoint.execute(eventOrMessage, clientSocket);
+				serverReceptionEntryPoint.execute(eventOrMessage, clientSocket);
 			});
 		}
 		
@@ -7289,13 +7300,14 @@ class NodeServerInstance{
 
 			const doOnMessage=(eventOrMessage)=>{
 				// We execute the events registration listeners entry points:
-				foreach(self.receptionEntryPoints,(receptionEntryPoint,i)=>{
-					receptionEntryPoint.execute(eventOrMessage, clientSocket);
+				foreach(self.serverReceptionEntryPoints,(serverReceptionEntryPoint,i)=>{
+					serverReceptionEntryPoint.execute(eventOrMessage, clientSocket);
 				});
 			};
 
-			if(!WebsocketImplementation.useSocketIOImplementation)
+			if(!WebsocketImplementation.useSocketIOImplementation){
 				clientSocket.addEventListener("message", doOnMessage);
+			}
 				
 			doOnConnection(this, clientSocket);
 			
@@ -7335,19 +7347,26 @@ class NodeServerInstance{
 			    
 			    clientSocket.isConnectionAlive=false;
 				
-					if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.ping();
-					else 																										self.send("protocol",{type:"ping"}, null, clientSocket);
+					if(!WebsocketImplementation.useSocketIOImplementation){
+						// FOR THE WEBSOCKET IMPLEMENTATION :
+						clientSocket.ping();
+					}else{
+						// FOR THE SOCKETIO IMPLEMENTATION :
+						self.send("protocol",{type:"ping"}, null, clientSocket);
+					}
 
 			    
 			}, this.clientPingIntervalMillis);
 			
-			
+
+			// PING-PONG :		
 			if(!WebsocketImplementation.useSocketIOImplementation){
+				// FOR THE WEBSOCKET IMPLEMENTATION :
 				clientSocket.on("pong",()=>{
 					clientSocket.isConnectionAlive=true;
 				});
 			}else{
-
+				// FOR THE SOCKETIO IMPLEMENTATION :
 				this.receive("protocol",(message)=>{
 					if(message.type!=="pong")	return;
 					clientSocket.isConnectionAlive=true;
@@ -7410,6 +7429,48 @@ if(typeof(window)==="undefined")	window=global;
 
 // ==================================================================================================================
 
+
+class ClientReceptionEntryPoint{
+	
+	constructor(channelNameParam, entryPointId, clientsRoomsTag, listenerConfig, doOnIncomingMessage){
+		
+		this.channelName=channelNameParam;
+		this.entryPointId=entryPointId;
+		this.clientsRoomsTag=clientsRoomsTag;
+		this.listenerConfig=listenerConfig;
+		this.doOnIncomingMessage=doOnIncomingMessage;
+	}
+	
+	execute(eventOrMessage, clientSocket, clientReceptionEntryPoints){
+		
+		const channelName=this.channelName;
+
+		
+		const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
+		
+		// Channel information is stored in exchanged data :
+		if(dataWrapped.channelName && dataWrapped.channelName!==this.channelName) return;
+		
+		// Room information is stored in client socket object :
+		if(!WebsocketImplementation.isInRoom(clientSocket, this.clientsRoomsTag)) return;
+		
+		
+		if(		this.listenerConfig && this.listenerConfig.messageType && dataWrapped.type
+			 && this.listenerConfig.messageType===dataWrapped.type)	return;
+		
+		// We remove one-time usage listeners :
+		// We remove BEFORE executing doOnIncomingMessage(), because in this reception entry point function we can have other listener registration UNDER THE SAME ID !
+		if(this.listenerConfig && this.listenerConfig.destroyListenerAfterReceiving)
+			remove(this, clientReceptionEntryPoints);
+		
+		if(this.doOnIncomingMessage)
+			this.doOnIncomingMessage(dataWrapped.data, clientSocket);
+			
+	}
+	
+}
+
+
 //
 // CLIENT INSTANCE :
 //
@@ -7417,59 +7478,33 @@ class ClientInstance{
 
 	constructor(clientSocket){
 		this.clientSocket=clientSocket;
-		this.receptionEntryPoints=[];
+		this.clientReceptionEntryPoints=[];
 		
 	}
 		
-	receive(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null, receptionEntryPointId=null, listenerConfig={destroyListenerAfterReceiving:false}){
+	receive(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null, entryPointId=null, listenerConfig={destroyListenerAfterReceiving:false}){
 		const self=this;
 		
 		// DBG
-		lognow("INFO : (CLIENT-BROWSER)  SETTING UP RECEIVE for :",channelNameParam);
-
-		const receptionEntryPoint={
-				channelName:channelNameParam,
-				clientsRoomsTag:clientsRoomsTag,
-				// TODO : ADD TO ALL OTHER SUBSYSTEMS !
-				id:receptionEntryPointId,
-				listenerConfig:listenerConfig,
-				doOnIncomingMessage:doOnIncomingMessage,
-				execute:(eventOrMessage)=>{
-						
-					const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
-					
-					// Channel information is stored in exchanged data :
-					if(dataWrapped.channelName && dataWrapped.channelName!==receptionEntryPoint.channelName) return;
-					
-					// Room information is stored in client socket object :
-					const clientSocket=self.clientSocket;
-					if(!WebsocketImplementation.isInRoom(clientSocket, receptionEntryPoint.clientsRoomsTag)) return;
-					
-					// We remove one-time usage listeners :
-					// We remove BEFORE executing doOnIncomingMessage(), because in receptionEntryPoint function we can have other listener registration UNDER THE SAME ID !
-					if(receptionEntryPoint.listenerConfig && receptionEntryPoint.listenerConfig.destroyListenerAfterReceiving)
-						remove(self.receptionEntryPoints, receptionEntryPoint);
-					
-					if(receptionEntryPoint.doOnIncomingMessage)
-						receptionEntryPoint.doOnIncomingMessage(dataWrapped.data, clientSocket);
-						
-				}
-		};
-		
-		///!!!
-		// TODO : ADD TO ALL OTHER SUBSYSTEMS !
-		if(!contains.filter((l)=>(l.id && receptionEntryPoint.id && l.id===receptionEntryPoint.id))(this.receptionEntryPoints))
-			this.receptionEntryPoints.push(receptionEntryPoint);
+		lognow("INFO : (CLIENT)  SETTING UP RECEIVE for :",channelNameParam);
 		
-		// SPECIAL FOR THE SOCKETIO IMPLEMENTATION :
-		if(WebsocketImplementation.useSocketIOImplementation){
-			const channelName=receptionEntryPoint.channelName;
-			clientSocket.on(channelName, (eventOrMessage)=>{
-				receptionEntryPoint.execute(eventOrMessage, clientSocket);
+		const clientReceptionEntryPoint=new ClientReceptionEntryPoint(channelNameParam, entryPointId, clientsRoomsTag, listenerConfig, doOnIncomingMessage);
+		if(!contains.filter((l)=>(
+					 l.entryPointId && clientReceptionEntryPoint.entryPointId 
+				&& l.entryPointId===clientReceptionEntryPoint.entryPointId
+			))(this.clientReceptionEntryPoints)){
+				
+			this.clientReceptionEntryPoints.push(clientReceptionEntryPoint);
+		}
+
+		const clientSocket=this.clientSocket;
+	  if(WebsocketImplementation.useSocketIOImplementation){
+			// FOR THE SOCKETIO IMPLEMENTATION :
+			clientSocket.on(channelNameParam, (eventOrMessage)=>{
+				clientReceptionEntryPoint.execute(eventOrMessage, clientSocket, clientReceptionEntryPoint);
 			});
 		}
-				
-		
+			
 		return this;
 	}
 
@@ -7505,6 +7540,7 @@ class ClientInstance{
 					}
 					
 					doOnIncomingMessageForResponse(dataLocal, clientSocket);
+
 				}, resultPromise.clientsRoomsTag, listenerId, {destroyListenerAfterReceiving:true});
 				//
 				
@@ -7567,39 +7603,40 @@ class ClientInstance{
 			// DBG
 			lognow("DEBUG : CLIENT : doOnConnection !");
 			
-			const doOnMessage=(eventOrMessage)=>{
-				
-				// We execute the listeners entry points registration :
-				foreach(self.receptionEntryPoints,(receptionEntryPoint)=>{
-					receptionEntryPoint.execute(eventOrMessage);
-				});
-
-			};
-		    
 			const clientSocket=self.clientSocket;
-		  if(!WebsocketImplementation.useSocketIOImplementation){	clientSocket.addEventListener("message", doOnMessage);
+		  if(!WebsocketImplementation.useSocketIOImplementation){
+				// FOR THE WEBSOCKET IMPLEMENTATION :
+				clientSocket.addEventListener("message", (eventOrMessage)=>{
+					foreach(self.clientReceptionEntryPoints,(clientReceptionEntryPoint)=>{
+						clientReceptionEntryPoint.execute(eventOrMessage, clientSocket, self.clientReceptionEntryPoints);
+					});
+				});
 			}
 
 			doOnConnection(self, clientSocket);
-			
 		};
 		
-		if(!WebsocketImplementation.useSocketIOImplementation)	this.clientSocket.addEventListener("open",doAllOnConnection);
-		else																										this.clientSocket.on("connect",doAllOnConnection);
-		
 		
-		// Client ping handling : (SocketIO implementation only)
-		if(WebsocketImplementation.useSocketIOImplementation){
+		if(!WebsocketImplementation.useSocketIOImplementation){
+			// FOR THE WEBSOCKET IMPLEMENTATION :
+			this.clientSocket.addEventListener("open",doAllOnConnection);
+		}else{
+			// FOR THE SOCKETIO IMPLEMENTATION :
+			this.clientSocket.on("connect",doAllOnConnection);
+
+			// Client ping handling :
+			// (SocketIO implementation only, the websocket implementation sends back a hidden pong !)
+			// PING-PONG :
 			this.receive("protocol",(message)=>{
 				if(message.type!=="ping")	return;
 				self.send("protocol",{type:"pong"});
-				
-				// DBG
-				lognow("DEBUG : CLIENT : Pong sent.");
+				// // DBG
+				// lognow("DEBUG : CLIENT : Pong sent.");
 			});
 		}
 		
 		
+		
 	}
 	
 }

aotrautils-srv/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "aotrautils-srv",
-	"version": "0.0.1478",
+	"version": "0.0.1479",
 	"main": "aotrautils-srv.build.js",
 	"description": "A library for vanilla javascript utils (server-side) used in aotra javascript CMS",
 	"author": "Jeremie Ratomposon <info@alqemia.com> (https://alqemia.com)",