aotrautils-srv 0.0.1057 → 0.0.1059

aotrautils-srv/aotrautils-srv.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (13/10/2024-22:46:19)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (19/02/2025-23:50:43)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -1551,6 +1551,13 @@ aotest.profile=function(rootObject,methodName,visited=[]){
 
 
 
+//================================================================
+//================= Tjread control utility methods =================
+//================================================================
+
+
+window.sleep = (millis) => new Promise( resolve => setTimeout(resolve, millis) );
+
 
 
 //================================================================
@@ -1988,6 +1995,15 @@ window.compare=function(value1,value2){
 	if(value1==value2)	return 0;
 }
 
+window.pushInArrayAsQueue=function(array, maxSize, item){
+	if(maxSize<=getArraySize(array)){
+		array.shift();
+	}
+	array.push(item);
+	return item;
+}
+
+
 
 /*KNOWN LIMITATIONS : You will have an incomplete browsing loop if there are the string values "break" or "continue" in your array or associative array !*/
 // CAUTION : Only use «return foreach» syntax in client code loops with SINGLE-LEVEL nested loops ONLY !
@@ -1998,7 +2014,7 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 //  -1: if(a<b)
 //   1: if(a>b)
 	// for instance this is a valid javascript compare function : function(a, b){return a-b} so (100,20) returns positive result and (20,100) returns negative result !
-	/*OPTIONAL*/compareFunction=null){
+	/*OPTIONAL*/compareFunction=null, sortKeys=false){
 	
 	// TODO : FIXME : Add the possibility to iterate over a string characters ?
 	
@@ -2054,7 +2070,8 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 	
 	// Else : associative array
 	
-	var associativeArray=arrayOfValues;
+	let keysToIterateOn=[];
+	const associativeArray=arrayOfValues;
 	if(compareFunction){
 		
 //	if(!associativeArray.hasOwnProperty){
@@ -2075,24 +2092,26 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 		}
 		sortedKeysAndValues.sort(compareFunction);
 		
-		associativeArray={};
+		// OLD : associativeArray={};
 		for(var i=0;i<sortedKeysAndValues.length;i++){
 			var item=sortedKeysAndValues[i];
-			associativeArray[item.key]=item.value;
+			// OLD : associativeArray[item.key]=item.value;
+			keysToIterateOn.push(item.key);
 		}
 		
+	}else{
+		keysToIterateOn=Object.keys(associativeArray);
 	}
 
-//if(!associativeArray.hasOwnProperty){
-//	// TRACE
-//	console.log("WARN : Object of type «"+(typeof(associativeArray))+"» has no method hasOwnProperty() method, cannot perform foreach ! ",associativeArray);
-//	return null;
-//}
-	
+	if(!compareFunction && sortKeys){
+		keysToIterateOn=keysToIterateOn.sort();
+	}
+		
 	var cnt=0;
-	for(var key in associativeArray){
+	for(var key of keysToIterateOn){
 		if(associativeArray.hasOwnProperty && !associativeArray.hasOwnProperty(key))	continue;
 		var item=associativeArray[key];
+		
 		if(!compareFunction){ // If we have a compare function, then array is already filtered !
 			if(filterFunction && !filterFunction(item,key))	continue;
 		}
@@ -2108,6 +2127,8 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 		}// else continue looping...
 		cnt++;
 	}
+		
+	
 	
 	//
 	return null;
@@ -2124,7 +2145,7 @@ window.getAt=function(associativeOrNormalArray,index,returnKey=false){
 	return foreach(associativeOrNormalArray,(item, key)=>{
 		if(index<=i)	return returnKey?key:item;
 		i++;
-	});
+	},null,null,returnKey);
 }
 
 window.getFirst=function(associativeOrNormalArray){
@@ -2856,24 +2877,46 @@ Math.averageInArray=function(arrayOfValues){
 	return Math.sumInArray(arrayOfValues) / arrayOfValues.length;
 };
 
-Math.maxInArray=function(arrayOfValues){
+Math.maxInArray=function(arrayOfValues, returnKey=false){
 	if(empty(arrayOfValues))
 		return null;
-	var max=arrayOfValues[0];
-	for (var i=0; i<arrayOfValues.length; i++)
-		if(max<arrayOfValues[i])
-			max=arrayOfValues[i];
-	return max;
+		
+//	var max=arrayOfValues[0];
+//	for (var i=0; i<arrayOfValues.length; i++)
+//		if(max<arrayOfValues[i])
+//			max=arrayOfValues[i];
+	
+	let returnedKey=getKeyAt(arrayOfValues,0);
+	let max=getAt(arrayOfValues,0);
+	foreach(arrayOfValues,(item, key)=>{
+		if(max<item){
+			returnedKey=key;
+			max=item;
+		}
+	},null,null,true);
+	
+	return (returnKey?returnedKey:max);
 };
 
-Math.minInArray=function(arrayOfValues){
+Math.minInArray=function(arrayOfValues, returnKey=false){
 	if(empty(arrayOfValues))
 		return null;
-	var min=arrayOfValues[0];
-	for (var i=0; i<arrayOfValues.length; i++)
-		if(arrayOfValues[i]<min)
-			min=arrayOfValues[i];
-	return min;
+		
+//	var min=arrayOfValues[0];
+//	for (var i=0; i<arrayOfValues.length; i++)
+//		if(arrayOfValues[i]<min)
+//			min=arrayOfValues[i];
+	
+	let returnedKey=getKeyAt(arrayOfValues,0);
+	let min=getAt(arrayOfValues,0);
+	foreach(arrayOfValues,(item, key)=>{
+		if(item<min){
+			returnedKey=key;
+			min=item;
+		}
+	},null,null,true);
+	
+	return (returnKey?returnedKey:min);
 };
 
 
@@ -5248,6 +5291,25 @@ window.stringifyObject=function(objectToStringify){
 }
 
 
+window.splitURL=(urlOrigin)=>{
+	let protocol=null;
+	let hostAndPort=urlOrigin;
+	if(contains(urlOrigin,"://")){
+		const hostAndPortSplits=urlOrigin.split("://");
+		protocol=hostAndPortSplits[0];
+		hostAndPort=hostAndPortSplits[1];
+	}
+	let host=null, port=null;
+	if(contains(hostAndPort,":")){
+		const splits=hostAndPort.split(":");
+		host=splits[0];
+		port=splits[1];
+	}else{
+		host=hostAndPort;
+	}
+	const isSecure=(protocol && contains(protocol,"s"));
+	return {protocol:protocol, host:host, port:port, isSecure:isSecure};
+};
 
 
 
@@ -5259,7 +5321,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils AI library associated with aotra version : «1_29072022-2359 (13/10/2024-22:46:19)»*/
+/*utils AI library associated with aotra version : «1_29072022-2359 (19/02/2025-23:50:43)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -5403,7 +5465,7 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 
 
 
-/*utils SERVER library associated with aotra version : «1_29072022-2359 (13/10/2024-22:46:19)»*/
+/*utils SERVER library associated with aotra version : «1_29072022-2359 (19/02/2025-23:50:43)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -5581,12 +5643,12 @@ getServerParams=function(portParam=null, certPathParam=null, keyPathParam=null,
 	// https=require("https");
 	// fs=require("fs");
 	
-	if(!https){
+	if(typeof(https)==="undefined"){
 		// TRACE
 		console.log("WARN : Could not find the nodejs dependency «https», aborting SSL setup.");
 		return null;
 	}
-	if(!fs){
+	if(typeof(fs)==="undefined"){
 		// TRACE
 		console.log("WARN : Could not find the nodejs dependency «fs», aborting SSL setup.");
 		return null;
@@ -5629,7 +5691,17 @@ getServerParams=function(portParam=null, certPathParam=null, keyPathParam=null,
 	return result;
 }
 
-
+getConsoleParam=function(index=0, argsOffset=0){
+	let result=null;
+	if(!process){
+		throw new Error("ERROR : Cannot extract console parameter in this context !");
+	}	
+	process.argv.forEach((val, i)=>{
+		if(i<=argsOffset+1)	return;
+		else if(i==argsOffset+index+1)	result=val;
+	});
+	return result;
+}
 
 
 
@@ -5697,6 +5769,7 @@ WebsocketImplementation={
 					if(typeof(WebSocket)==="undefined"){
 						// TRACE
 						console.log("«ws» SERVER library not called yet, calling it now.");
+						
 						WebSocket=require("ws");
 						if(typeof(WebSocket)==="undefined"){
 							// TRACE
@@ -5798,7 +5871,7 @@ WebsocketImplementation={
 					receive:(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null)=>{
 						
 						// DBG
-						lognow("(SERVER) Registering receive for «"+channelNameParam+"»...",doOnIncomingMessage);
+						lognow("(SERVER) Registering receive for «"+channelNameParam+"»...");
 						
 						
 						
@@ -5836,10 +5909,11 @@ WebsocketImplementation={
 								
 								if(!isClientInRoom) return;
 
-								// DBG
-								lognow("(SERVER) doOnIncomingMessage:",doOnIncomingMessage);
-								if(doOnIncomingMessage)	doOnIncomingMessage(dataWrapped.data, clientSocketParam);
-
+								if(doOnIncomingMessage){
+									// DBG
+									lognow("(SERVER) doOnIncomingMessage:");
+									doOnIncomingMessage(dataWrapped.data, clientSocketParam);
+								}
 								
 							},
 						};
@@ -6097,7 +6171,7 @@ WebsocketImplementation={
 			return nodeServerInstance;
 		},
 		
-		
+		// DO NOT USE DIRECTLY, USE INSTEAD initClient(...) (this function uses connectToServer(...)) !
 		// NODE / BROWSER CLIENT CONNECTS TO SERVER MAIN ENTRYPOINT:
 		connectToServer:(serverURL, port, isSecure=false, timeout)=>{
 
@@ -6725,7 +6799,7 @@ launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /
 	server.onFinalize((serverParam)=>{
 		
 		// DBG
-		lognow("onFinalize!!!!!");
+		lognow("onFinalize() server");
 		
 		if(doOnFinalizeServer)	doOnFinalizeServer(serverParam);
 	});
@@ -6863,7 +6937,7 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 		// Eventual encryption options : 
 		let sslOptions=null; 
 		if(!isForceUnsecure){
-			if(!fs){
+			if(typeof(fs)==="undefined"){
 				// TRACE
 				lognow("ERROR : «fs» node subsystem not present, cannot access files. Aborting SSL configuration of server.");
 			}else{
@@ -6914,7 +6988,7 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 //	
 //	const server=initNodeServerInfrastructureWrapper(
 //		// On each client connection :
-////	(serverParam, clientSocketParam)=>{},
+// //	(serverParam, clientSocketParam)=>{},
 //		null,
 //		// On server finalization :
 //		(serverParam)=>{
@@ -6947,15 +7021,15 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 //		},portParam,certPathParam,keyPathParam);
 //
 //
-////	const doOnConnect=(serverParam, clientSocketParam)=>{
-////	};
-////	const doOnFinalizeServer=(serverParam)=>{
-////		/*DO NOTHING*/
-////	};
-////	const server={};
-////	server.start=(port=6080)=>{
-////		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
-////	};
+// //	const doOnConnect=(serverParam, clientSocketParam)=>{
+// //	};
+// //	const doOnFinalizeServer=(serverParam)=>{
+// //		/*DO NOTHING*/
+// //	};
+// //	const server={};
+// //	server.start=(port=6080)=>{
+// //		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
+// //	};
 //
 //	return server;
 //}
@@ -7299,23 +7373,47 @@ appendGetParameters=function(apiURL, namedArgs){
 
 //*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
 
+AORTAC_OUTCOMING_SERVERS_CONNECTION_GLOBAL_TIMEOUT=30000;
+REQUESTS_IDS_HISTORY_SIZE=10;
+
 class AORTACNode{
-	constructor(selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[], model, controller, sslConfig={/*OPTIONAL*/port:null,/*OPTIONAL*/certPath:null,/*OPTIONAL*/keyPath:null}){
+	
+	constructor(nodeId, selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[], model, controller, allowAnonymousNodes=true, sslConfig={/*OPTIONAL*/certPath:null,/*OPTIONAL*/keyPath:null}){
+		
+		this.nodeId=nodeId;
 		this.selfOrigin=selfOrigin;
+		this.sslConfig=sslConfig;
 		this.outcomingNodesOrigins=outcomingNodesOrigins;
+		this.allowAnonymousNodes=allowAnonymousNodes;
 		
-		this.model=model;						// must implement function
-		this.controller=controller; // Must implement function
-		this.serverId=getUUID();
+		this.model=model;						// must implement functions
+		this.controller=controller; // Must implement functions
 		
 		this.server=null;
 		this.clients={};
 		this.incomingServers={};
 		this.outcomingServers={};
+		this.authorizedNodesIds=[this.nodeId];
 		
+		this.listeners={"protocol":[],"cluster":[],"neighbors":[],"inputs":[]};
+	
+		this.executedRequestIdsHistory=[];
+		
+		this.isConnectedToCluster=false;
+		
+		this.modelObjectsDirectory={};
+		this.objectsIndexesForClients={};
+
+		this.addProtocolListeners();
+
+		// TRACE
+		lognow(`AORTAC node created with id ${this.nodeId}.`);
 	}
 	
 	start(){
+
+		const splits=splitURL(this.selfOrigin);
+		let port=nonull(splits.port,"40000");
 		
 		const self=this;
 		this.server = initNodeServerInfrastructureWrapper(
@@ -7323,62 +7421,819 @@ class AORTACNode{
 			null,
 			// On client finalization :
 			function(server){
-				
 				self.server=server;
 				
-				server.receive("protocol", (message, clientSocket)=>{
-					
-					// TRACE
-					console.log("INFO : SERVER : Client has sent a protocol message: ", message);
-		
-					// ============== OTHER SERVER / CLIENT REGISTRATION PHASE ==============
-		
-					if(message.type==="registerOtherServer"){
-						const incomingServerId=message.serverId;
+				// Listeners handling ;
+				foreach(Object.keys(self.listeners), channelName=>{
+					self.server.receive(channelName, (message, clientSocket)=>{
 						
-						self.incomingServers[incomingServerId]={clientSocket:clientSocket};
-						
-					}else if(message.type==="registerClient"){
-						const clientId=message.clientId;
+						// INCOMING NODES LISTENERS HOOK :
+						// TRACE
+						console.log("INFO : SERVER : Client or incoming node has sent a "+channelName+" message: ", message);
+						foreach(self.listeners[channelName], listener => {
+							listener.execute(self, message, self.server, clientSocket);
+						},(listener)=>(message.type===listener.messageType));
 						
-						self.clients[incomingServerId]={clientSocket:clientSocket};
-					}
-					
+					});
 				});
+				
+				// OLD : self.connectToOutcomingServers(self, server).then((server)=>{	self.doOnConnectedToCluster();	});
+				
+				
+		}, port, this.sslConfig.certPath, this.sslConfig.keyPath);
+		
+		this.server.serverManager.start();
+		
+		// TRACE
+		lognow(`AORTAC node started with id ${this.nodeId}.`);
+
 
+		return this;
+	}
+	
+	
+	connect(){
+		
+		const self=this;
+		self.connectToOutcomingServers(self).then((server)=>{	self.doOnConnectedToCluster();	});
 
+		return this;		
+	}
+	
+	
+	
+	
+	/*private*/addProtocolListeners(){
+		
+		const self=this;
+		// ============== OTHER SERVER / CLIENT REGISTRATION PHASE ==============
+		// - OTHER SERVER REGISTRATION PHASE :
+		this.listeners["protocol"].push({
+			messageType:"request.register.server.incoming",
+			execute:(self, message, server, clientSocket)=>{
+				const incomingServerNodeId=message.nodeId;
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving registering request from node ${incomingServerNodeId}...`);
+				
+				if(!self.allowAnonymousNodes && self.isInAuthorizedNodes(incomingServerNodeId)){
+					// TRACE
+					lognow("WARN : Cannot accept incoming server with node id «"+incomingServerNodeId+"» because it's not in the authorized nodes list.");
+					return;
+				}
+				if(!contains(self.authorizedNodesIds,incomingServerNodeId))	self.authorizedNodesIds.push(incomingServerNodeId);
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Adding registering node ${incomingServerNodeId} to incoming servers...`);
+				
+				self.incomingServers[incomingServerNodeId]={clientSocket:clientSocket};
+				
+				const welcomeResponse={
+					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
+					type:"response.register.server.incoming",
+					authorizedNodesIds:self.authorizedNodesIds
+				};
+				server.send("protocol", welcomeResponse, null, clientSocket);
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Sent registering response to node ${incomingServerNodeId}.`);
+			}
+		});
+		
+		// - CLIENT REGISTRATION PHASE : (for clients to the server, NOT INCOMING NODES !)
+		this.handleClients();
+		
+	}
+	
+	/*private*/handleClients(){
+		const self=this;
+		
+		// --------- PROTOCOL HANDLING ---------
+		 
+		this.listeners["protocol"].push({
+			messageType:"request.register.client",
+			execute:(self, message, server, clientSocket)=>{
+				const clientId=message.clientId;
+				
+				self.clients[clientId]={clientSocket:clientSocket};
+
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving non-cluster client registration request from client ${clientId}.`);
+				
+				const welcomeClientResponse={
+					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
+					type:"response.register.client",
+					// If necessary we also send them our model part :
+					partialModelString:(message.isReferenceNode?null:JSON.stringifyDecycle(self.model)),
+					isReferenceNode:(!!message.isReferenceNode),
+				};
+				server.send("protocol", welcomeClientResponse, null, clientSocket);
+			}
+		});
+		
+		this.listeners["protocol"].push({
+			messageType:"request.unregister.client",
+			execute:(self, message, server, clientSocket)=>{
+				const clientId=message.clientId;
+				
+				delete self.clients[clientId];
+
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving non-cluster client unregistration request from client ${clientId}.`);
+				
+				const unwelcomeClientResponse={
+					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
+					type:"response.unregister.client",
+				};
+				server.send("protocol", unwelcomeClientResponse, null, clientSocket);
+			}
+		});
+		
+		
+		this.listeners["protocol"].push({
+			messageType:"request.interrogation.client",
+			execute:(self, message, server, clientSocket)=>{
+				const clientId=message.clientId;
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving non-cluster client interrogation request from client ${clientId}.`);
+				
+				const clientBoundaries=message.boundaries;
+				
+				// We ask the whole cluster to find the requested objects :
+				const modelSeekObjectsRequest={
+					type:"request.model.seekObjects",
+					originatingClientId:clientId,
+					clientBoundaries:clientBoundaries,
+				};
+				this.propagateToCluster(modelSeekObjectsRequest);
+
+				self.objectsIndexesForClients[clientId]={};
+				
+			}
+		});
+		
+		// --------- INPUTS HANDLING --------- 
+		
+		this.listeners["inputs"].push({
+			messageType:"request.inputs.client",
+			execute:(self, message, server, clientSocket)=>{
+				const clientId=message.clientId;
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving non-cluster client inputs request from client ${clientId}.`);
+				
+				const clientInputs=message.inputs;
+				const clientSubBoundaries=message.subBoundaries;
+
+				
+				// We let the controller interpret these inputs :
+				const modifiedObjects=self.controller.interpretInputs(clientInputs, clientSubBoundaries);
+				
+
+			}
+		});
+		
+	}
+
+
+	/*private*/addPropagationForClientsListeners(){
+		
+		const self=this;
+		
+		// ------------------------------------- CLIENTS PROTOCOL HANDLING -------------------------------------
+		// Adding propagation listener :
+		this.setPropagation("cluster","request.model.seekObjects",(self, message, server, clientSocket)=>{
+			
+			// If we receive this request from cluster, then we try to find the requested objects
+			const relayNodeid=message.nodeId;
+			const originatingClientId=message.originatingClientId;
+			const clientBoundaries=message.clientBoundaries
+			const objectsIds=self.model.getObjectsIdsWithinBoundaries(clientBoundaries);
+
+			// If server has not the seeked objects, it answers with an empty array.			
+			
+			// TRACE
+			lognow(`(${self.nodeId}) Node receiving a seek objects request from relay node ${message.nodeId}...objectsIds=`,objectsIds);
+
+			// TRACE
+			lognow(`(${self.nodeId}) Sending objects ids to relay node ${relayNodeid}...`);
+			
+			const modelObjectsSeekResponse={
+				type:"response.model.seekObject",
+				originatingClientId:originatingClientId,
+				clientBoundaries:clientBoundaries,
+				objectsIds:objectsIds,
+				nodeServerInfo:self.selfOrigin
+			};
+			this.propagateToCluster(modelObjectsSeekResponse, relayNodeid/*destination node*/);
+
+		});
+		
+		// Adding propagation listener :
+		this.setPropagation("cluster","response.model.seekObject",(self, message, server, clientSocket)=>{
+			
+			// Here the relay server gathers the information from the other nodes, and sends it back to client ; 
+			
+			const referenceNodeId=self.nodeId;
+			const originatingClientId=message.originatingClientId;
+			const originatingNodeId=message.nodeId;
+			const clientBoundaries=message.clientBoundaries;
+			const objectsIds=message.objectsIds;
+			const nodeServerInfo=message.nodeServerInfo;
+			
+			// TRACE
+			lognow(`(${self.nodeId}) Node receiving a seek objects request from relay node ${message.nodeId}...objectsIds=`,objectsIds);
+			
+			// Here the currently answering node fills its information :
+			const objectsIndexForClient=self.objectsIndexesForClients[originatingClientId];
+			objectsIndexForClient[originatingNodeId]={nodeServerInfo:nodeServerInfo, objectsIds:objectsIds};
+			
+			
+			// We check if all known nodes have answered :
+			if(getArraySize(self.authorizedNodesIds)-1/*Because we exclude the reference node*/<=getArraySize(objectsIndexForClient)){
+
+				// The reference node also answers to the request to its direct client :
+				const objectsIdsFromReferenceNode=self.model.getObjectsIdsWithinBoundaries(clientBoundaries);
+				const referenceNodeServerInfo=self.selfOrigin;
+				objectsIndexForClient[referenceNodeId]={nodeServerInfo:referenceNodeServerInfo, objectsIds:objectsIdsFromReferenceNode};
+				
+				const client=self.clients[originatingClientId];
+				const clientSocket=client.clientSocket;
+
+				// TRACE
+				lognow(`(${self.nodeId}) Sending objects ids to the client ${originatingClientId}...objectsIndexForClient=`,objectsIndexForClient);
+				
+				// We filter all the index entries with an empty objetcs ids array :
+				const objectsIndexForClientWithoutEmptyObjects={};
+				foreach(objectsIndexForClient,(nodeInfoAndObjectsIds, serverNodeId)=>{
+					objectsIndexForClientWithoutEmptyObjects[serverNodeId]=nodeInfoAndObjectsIds;
+				},(nodeInfoAndObjectsIds,serverNodeId)=>(!empty(nodeInfoAndObjectsIds.objectsIds)));
+				
+				// We send the final result information (objects ids) to client :
+				const interrogationClientResponse={
+					nodeId:self.nodeId,
+					type:"response.interrogation.client",
+					serversNodesIdsForModelObjectsForClient:objectsIndexForClientWithoutEmptyObjects
+				};
+				self.server.send("protocol", interrogationClientResponse, null, clientSocket);
+			}
+			
+		});
+		
+		
+		// ------------------------------------- CLIENTS INPUTS HANDLING -------------------------------------
+		// Adding propagation listener :
+
+		
+		
+		// DBG
+		lognow(">>>>>>>>FOR CLIENTS this.listeners",this.listeners);
+		
+	}
+
+//	/*private*/getServersNodesIdsForModelObjectsForClient(clientObjectsIds){
+//		const serversNodesIdsForModelObjectsForClient={};
+//		const self=this;
+//		// TODO : FIXME : INEFFICIENT !!!
+//		foreach(clientObjectsIds,(objectId)=>{
+//			foreach(self.modelObjectsDirectory,(objectsInNode, nodeId)=>{
+//				if(contains(objectsInNode,objectId))
+//					serversNodesIdsForModelObjectsForClient[objectId]=nodeId;
+//			});
+//		});
+//		
+//		return serversNodesIdsForModelObjectsForClient;
+//	}
+
+	/*private*/connectToOutcomingServers(self){
+		
+		const server=self.server;
+	
+		const theoreticNumberOfOutcomingServers=getArraySize(self.outcomingNodesOrigins);
+		
+		return new Promise((resolve,error)=>{
+			
+			// In case we timeout :
+			setTimeout(()=>{
+				if(self.isConnectedToCluster)	return;
+				self.isConnectedToCluster=true;
+				resolve(server);
+			},AORTAC_OUTCOMING_SERVERS_CONNECTION_GLOBAL_TIMEOUT);
+		
 			// We try to connect to all the other outcoming servers :
+			
+			// Special case : if node has no outcoming serves, (it's the seed node), then 
+			// it should be considered as connected to cluster nonetheless :
+			if(empty(self.outcomingNodesOrigins)){
+				self.finalizeClusterConnection(self.nodeId);
+				resolve(server);
+				return;
+			}
+			
+			// We try to connect to all outcoming nodes : 
 			foreach(self.outcomingNodesOrigins, outcomingNodeOrigin=>{
-				let outcomingNodeHost;
-				let outcomingNodePort;
-				if(contains(outcomingNodeOrigin,":")){
-					const splits=outcomingNodeOrigin.split(":");
-					outcomingNodeHost=splits[0];
-					outcomingNodePort=splits[1];
-				}
-				const isSecure=(contains(outcomingNodeOrigin,"wss"));
-				const clientInstance=connectToServer(outcomingNodeHost,outcomingNodePort, isSecure, 5000);
 				
-				//self.outcomingServers[]={clientInstanceToServer:clientInstance};
+				// TRACE
+				lognow(`	(${self.nodeId}) Sending registering response to node ${outcomingNodeOrigin}...`);
+				
+				const splits=splitURL(outcomingNodeOrigin);
+				const outcomingNodeProtocol=nonull(splits.protocol,"ws");
+				const outcomingNodeHost=nonull(splits.host,"localhost");
+				const outcomingNodePort=nonull(splits.port,"40000");
+				//const isSecure=splits.isSecure; // UNUSED
+				
+				const clientInstance=initClient(true, false, (socketToServer)=>{
+					
+					// TODO : FIXME : IF CONNECTION TO SERVER FAILS, IT MUST BE ABLE TO TRY AGAIN LATER !
+					
+					// TRACE
+					lognow(`		(${self.nodeId}) Sending registering request to outcoming node...`);
+					
+					const helloRequest={
+						nodeId:self.nodeId,
+						type:"request.register.server.incoming"
+					};
+					socketToServer.send("protocol", helloRequest);
+					
+					
+					// We place a listener from outcoming node on this client instance to this outcoming node :
+					socketToServer.receive("protocol",(message)=>{
+						if(message.type==="response.register.server.incoming"){
+							
+							// TRACE
+							lognow(`		(${self.nodeId}) Receving registering response from requested outcoming node...`);
+							
+							const welcomeNodeId=message.nodeId;
+							const duplicatesFreeAuthorizedNodesIds=[...new Set([...self.authorizedNodesIds, ...message.authorizedNodesIds, welcomeNodeId ])];
+							self.authorizedNodesIds=duplicatesFreeAuthorizedNodesIds;
+							
+							self.outcomingServers[welcomeNodeId]={clientInstance:clientInstance};
+							
+							// Once we have registered to all the outcoming nodes :
+							const currentNumberOfOutcomingServers=getArraySize(self.outcomingServers);
+							if(!self.isConnectedToCluster && theoreticNumberOfOutcomingServers<=currentNumberOfOutcomingServers){
+								//self.finalizeClusterConnection(welcomeNodeId);
+								self.finalizeClusterConnection(self.nodeId);
+								resolve(server);
+							}
+						}
+					});
+					
+					// Listeners handling ;
+					foreach(Object.keys(self.listeners), channelName=>{
+						socketToServer.receive(channelName, (message, clientSocket)=>{
+							
+							// OUTCOMING NODES LISTENERS HOOK :
+							// TRACE
+							console.log("INFO : SERVER : Outcoming node has sent a "+channelName+" message: ", message);
+							foreach(self.listeners[channelName], listener => {
+								listener.execute(self, message, self.server, clientSocket);
+							},(listener)=>(message.type===listener.messageType));
+							
+						});
+					});
+					
+					
+				}, outcomingNodeProtocol+"://"+outcomingNodeHost, outcomingNodePort, false);
+				clientInstance.client.start();
 				
 			});
 			
+		});
+	
+	}
+	
+	/*private*/finalizeClusterConnection(welcomeNodeId){
+		// TRACE
+		lognow(`		(${this.nodeId}) Propagating this new node to the whole cluster...`);
+		
+		// We propagate the new node id to the whole cluster :
+		const newNodeRequest={
+			nodeId:welcomeNodeId,
+			type:"request.node.new"
+		};
+		this.propagateToCluster(newNodeRequest);
+		
+		this.isConnectedToCluster=true;
+		
+		this.addPropagationListeners();
+		this.addPropagationForClientsListeners();
+	}
+								
+	
+
+	
+	/*public*/doOnConnectedToCluster(){
 			
+		// TRACE
+		lognow(`(${this.nodeId}) Node is connected to cluster...`);
+		
+		// The node asks the cluster for its model partition :
+		
+		// At this point, the new node does not know the state of the model in the cluster, only cluster nodes know.
+		
+		// TRACE
+		lognow(`(${this.nodeId}) Node is asking to its model partition...`);
+		
+		// New node asks for its model partition :
+		
+		// - First we need to know which server has the biggest model :
+		const modelSizeRequest={
+			type:"request.model.getSize",
+		};
+		this.propagateToCluster(modelSizeRequest);
 			
+	}
+	
+	
+	/*private*/addPropagationListeners(){
+		
+		// Adding propagation listener for acknowledging new node added to cluster :
+		this.setPropagation("cluster","request.node.new", (self, message, server, clientSocket)=>{
+			const newNodeId=message.nodeId;
+			// TRACE
+			lognow(`		(${self.nodeId}) Acknowledging new node ${newNodeId} added to cluster...`);
+			if(!contains(self.authorizedNodesIds,newNodeId))	self.authorizedNodesIds.push(newNodeId);
+		});
+
+		// Adding propagation listener if a node receives a model size request :
+		this.setPropagation("cluster","request.model.getSize",(self, message, server, clientSocket)=>{
+			const modelSize=self.model.getModelSize();
+			// TRACE
+			lognow(`(${self.nodeId}) Node gives its model size to node ${message.nodeId}, modelSize=${modelSize}...`);
+			return modelSize;
+		},"response.model.getSize");
+		
+		// Adding propagation listener :
+		this.modelSizes={};
+		this.setPropagation("cluster","response.model.getSize",(self, message, server, clientSocket)=>{
 			
-			////
-			// CURRENT AORTAC
+			const modelSizes=self.modelSizes;
+			const currentClusterSize=getArraySize(self.authorizedNodesIds);
 			
+			const concernedNodeId=message.nodeId;
+			const modelSize=message.result;
 			
-		},this.sslConfig.port, this.sslConfig.certPath, this.sslConfig.keyPath);
+			let currentNumberOfAnswers=getArraySize(modelSizes);
+
+			if(currentNumberOfAnswers<=currentClusterSize-1){// -1 because we want to exclude this node also !
+				modelSizes[concernedNodeId]=modelSize;
+			}
+
+			currentNumberOfAnswers=getArraySize(modelSizes);
+			// TRACE
+			lognow(`(${self.nodeId}) Node receiving a model size from node ${message.nodeId}...currentClusterSize=${currentClusterSize} ; modelSizes:`,modelSizes);
+			if(currentClusterSize-1<=currentNumberOfAnswers){
+				const nodeIdWithBiggestModel=Math.maxInArray(modelSizes, true);
+				// TRACE
+				lognow(`(${self.nodeId}) Node with biggest model is nodeIdWithBiggestModel=${nodeIdWithBiggestModel}...`);
+				
+				const modelPartitionRequest={
+					type:"request.model.partition",
+				};
+				this.propagateToCluster(modelPartitionRequest, nodeIdWithBiggestModel);
+			}
+		});
 		
+		// Adding propagation listener :
+		// If a node receives a model partition request :
+		this.setPropagation("cluster","request.model.partition",(self, message, server, clientSocket)=>{
+			// Each node will give a little portion of its model, according to its size :					
+			// TRACE
+			lognow(`(${self.nodeId}) Node splits its model for node ${message.nodeId}...`);
+			
+			const ownModel=self.model;
+			const splittedModel=ownModel.split();
+			
+			// Node shares also its model objects directory with the newcomer node :
+			const ownModelObjectsIds=ownModel.getAllObjectsIds();
+			self.modelObjectsDirectory[self.nodeId]=ownModelObjectsIds;
+			
+			const modelString=JSON.stringifyDecycle(splittedModel);
+			const modelPartitionResponse={
+				type:"response.model.partition",
+				modelString:modelString,
+				modelObjectsDirectory:self.modelObjectsDirectory
+			};
+			this.propagateToCluster(modelPartitionResponse, message.nodeId);
+			
+			// This node also advertises that its model has changed to all other nodes (not the newcomer, because it's unnecessary) :
+			const updatemodelObjectsDirectoryRequest={
+				type:"request.update.modelObjectsDirectory",
+				ownModelObjectsIds:ownModelObjectsIds
+			};
+			this.propagateToCluster(updatemodelObjectsDirectoryRequest, null, [message.nodeId]);
+			
+		});
+
+		// Adding propagation listener :
+		this.setPropagation("cluster","response.model.partition",(self, message, server, clientSocket)=>{
+			// TRACE
+			lognow(`(${self.nodeId}) Node receives a model partition from node ${message.nodeId}...`,message);
+			
+			const newModel=JSON.parseRecycle(message.modelString);
+			self.model.replaceBy(newModel);
 			
+			// We initialize this node's model objects directory from the one froom the node tha provided it its model partition :
+			self.modelObjectsDirectory=message.modelObjectsDirectory;
+			
+			// Once this node has received its model partition, it updates its model objects directory
+			const ownModelObjectsIds=newModel.getAllObjectsIds();
+			self.modelObjectsDirectory[self.nodeId]=ownModelObjectsIds;
+			
+			// TRACE
+			lognow(`(${self.nodeId}) Node sends a model objects directory update request...ownModelObjectsIds=${ownModelObjectsIds}`);
+			
+			// And notifies the other nodes of the change :
+			const updatemodelObjectsDirectoryRequest={
+				type:"request.update.modelObjectsDirectory",
+				ownModelObjectsIds:ownModelObjectsIds
+			};
+			this.propagateToCluster(updatemodelObjectsDirectoryRequest);
+
+		});
+		
+		this.addModelObjectsDirectoryListeners();
+		
+		
+		// DBG
+		lognow(">>>>>>>>FOR OTHER NODES this.listeners",this.listeners);
+		
 	}
 	
+	
+	
+	/*private*/addModelObjectsDirectoryListeners(){
+		
+		const self=this;
+		
+		// Adding propagation listener :
+		// If a node receives a model objects directory update request :
+		this.setPropagation("cluster","request.update.modelObjectsDirectory",(self, message, server, clientSocket)=>{
+			
+			// TRACE
+			lognow(`(${self.nodeId}) !!!!!! Node receives a model objects directory update request from node ${message.nodeId}...`,message);
+			
+			const modelObjectsIds=message.ownModelObjectsIds;
+			self.modelObjectsDirectory[message.nodeId]=modelObjectsIds;
+
+		});
+		
+				
+		// Adding propagation listener :
+		// If a node receives a model objects directory update request :
+		this.setPropagation("cluster","request.add.modelObjectsDirectory",(self, message, server, clientSocket)=>{
+			
+			// TRACE
+			lognow(`(${self.nodeId}) !!!!!! Node receives a model objects directory add request from node ${message.nodeId}...`,message);
+			
+			const newObjectsIds=message.newObjectsIds;
+			self.modelObjectsDirectory[message.nodeId].push(...newObjectsIds);
+
+		});
+		
+	}
+	
+	
+	/*public*/sendUpdatedObjects(modifiedObjects, modifiedObjectsIds){
+				
+		if(empty(modifiedObjects))	return modifiedObjects;
+
+		// Then we send back the modified objects to all the concerned clients : (which are all clients connected to this node)
+		return this.sendObjectsUpdatesToClients(modifiedObjects);
+	}
+	
+	/*public*/sendNewObjects(newObjects, newObjectsIds){
+		
+		if(empty(newObjects))	return newObjects;
+
+		// At this point, node controller has already added the objects to its model.
+		// We just want to update the objects directories of all the nodes in the cluster:
+		
+		// !!! CAUTION : NOTE THAT THE EMITTER NODE IS ALWAYS INCLUDED IN THE THE VISITED NODES !!!
+		// So this is why ir needs to update its mode objects directory itself, before sending the add request to the cluster :
+		this.modelObjectsDirectory[this.nodeId].push(...newObjectsIds);
+
+		// This node also advertises that its model has changed to all other nodes (not the newcomer, because it's unnecessary) :
+		const updatemodelObjectsDirectoryRequest={
+			type:"request.add.modelObjectsDirectory",
+			newObjectsIds:newObjectsIds
+		};
+		this.propagateToCluster(updatemodelObjectsDirectoryRequest);
+		
+		
+		// But we also want all the concerned clients to update their local models : (which are all clients connected to this node)
+		return this.sendObjectsUpdatesToClients(newObjects, true);
+	}
+	
+	/*private*/sendObjectsUpdatesToClients(modifiedOrAddedObjects, isAddingObjects=false){
+		
+		const self=this;
+		foreach(this.clients, client=>{
+			const clientSocket=client.clientSocket;
+			const objectsModifiedOrAddedClientResponse={
+				nodeId:self.nodeId,
+				type:"response.objectsModifiedOrAdded.client",
+				objectsString:JSON.stringifyDecycle(modifiedOrAddedObjects),
+				isAddingObjects:isAddingObjects,
+			};
+			self.server.send("inputs", objectsModifiedOrAddedClientResponse, null, clientSocket);
+		});
+
+		return modifiedOrAddedObjects;
+	}
+	
+	
+	
+	
+	/*private*/getNeighborsNodesIds(){
+		const neighborsNodesIds=[];
+		foreach(this.incomingServers,(incomingServer,nodeId)=>{
+			neighborsNodesIds.push(nodeId);
+		});
+		foreach(this.outcomingServers,(outcomingServer,nodeId)=>{
+			neighborsNodesIds.push(nodeId);
+		});
+		return neighborsNodesIds;
+	}
+	
+	/*private*/getLeastOccupiedNeighborNodeId(){
+		const self=this;
+	
+		// We send the new objects to the neighbor node with the least amount of objects :
+		let leastOccupiedNodeId=null;
+		foreach(this.getNeighborsNodesIds(), (nodeId)=>{
+			const entry=self.modelObjectsDirectory[nodeId];
+			const numberOfObjects=getArraySize(entry);
+			if(!leastOccupiedNodeId || numberOfObjects<getArraySize(self.modelObjectsDirectory[leastOccupiedNodeId]))
+				leastOccupiedNodeId=nodeId;
+		});
+		
+		if(!leastOccupiedNodeId){
+			// TRACE
+			lognow("WARN : Cannot find the least occupied node. Aborting.");
+		}
+		return leastOccupiedNodeId;
+	}
+
+
+	// ****************************************************************************************************
+	/*private*/setPropagation(channelName, requestType, doOnReception=null, responseRequestType=null, propagateToAllCluster=true){
+		const self=this;
+		this.setUniqueReceptionPoint(channelName, requestType, (self, message, server, clientSocket)=>{
+			
+			const requestId=message.requestId;
+			if(contains(self.executedRequestIdsHistory, requestId)){
+				// TRACE
+				lognow(`WARN : Request of type ${message.type} already answered. Aborting.`);
+				return;
+			}
+			if(message.visitedNodeIds){
+				if(contains(message.visitedNodeIds, self.nodeId)){
+					return;
+				}
+				message.visitedNodeIds.push(self.nodeId);
+			}
+			
+			const hasNoExclusionsOrExclusionDoesNotApplyOnThisNode=(!message.excludedNodesIds || !contains(message.excludedNodesIds,self.nodeId));
+			let response=null;
+			if(!message.destinationNodeId && hasNoExclusionsOrExclusionDoesNotApplyOnThisNode){
+				// Case broadcast message :
+				if(doOnReception)
+					response=doOnReception(self, message, server, clientSocket);
+				pushInArrayAsQueue(self.executedRequestIdsHistory, REQUESTS_IDS_HISTORY_SIZE, requestId);
+				if(propagateToAllCluster)	self.sendToOtherNodes(channelName, message);		
+			}else{
+				if(message.destinationNodeId===self.nodeId && hasNoExclusionsOrExclusionDoesNotApplyOnThisNode){
+					if(doOnReception)
+						response=doOnReception(self, message, server, clientSocket);
+					pushInArrayAsQueue(self.executedRequestIdsHistory, REQUESTS_IDS_HISTORY_SIZE, requestId);
+				}else{
+					if(propagateToAllCluster)	self.sendToOtherNodes(channelName, message);		
+				}
+			}
+			
+			// We send back the answer to the originating node :
+			if(response!=null && responseRequestType){
+				// TRACE
+				lognow(`(${self.nodeId}) Node sending back a response of type ${responseRequestType}...`);				
+
+				const clusterResponse={
+					type:responseRequestType,
+					result:response
+				};
+				const originNodeId=message.nodeId;
+				if(propagateToAllCluster)	self.propagateToCluster(clusterResponse, originNodeId);
+				else											self.propagateToSingleNeighbor(clusterResponse, originNodeId);
+			}
+			
+		});
+	}
+	// ****************************************************************************************************
+		
+	/*private*/propagateToCluster(request, destinationNodeId=null, excludedNodesIds=null){
+		request.requestId=getUUID();
+		const originNodeId=this.nodeId;
+		request.nodeId=originNodeId;
+		if(destinationNodeId)	request.destinationNodeId=destinationNodeId;
+		if(excludedNodesIds)	request.excludedNodesIds=excludedNodesIds;
+		request.visitedNodeIds=[originNodeId];
+		this.sendToOtherNodes("cluster",request);
+	}
+	
+	/*private*/propagateToNeighbors(request){
+		request.requestId=getUUID();
+		const originNodeId=this.nodeId;
+		request.nodeId=originNodeId;
+		this.sendToOtherNodes("neightbors", request);
+	}
+	/*private*/propagateToSingleNeighbor(request, destinationNodeId){
+		request.requestId=getUUID();
+		const originNodeId=this.nodeId;
+		request.nodeId=originNodeId;
+		request.destinationNodeId=destinationNodeId;
+		this.sendToOtherSingleNode("neightbors", request, destinationNodeId);
+	}
+	
+	// ****************************************************************************************************
+
+	/*private*/sendToOtherNodes(channelName, message){
+		let hasBeenSentIncoming=this.sendToIncomingServers(channelName, message);
+		let hasBeenSentOutcoming=this.sendToOutcomingServers(channelName, message);
+		return (hasBeenSentIncoming || hasBeenSentOutcoming);
+	}
+	/*private*/sendToIncomingServers(channelName, message){
+		const self=this;
+		let hasBeenSent=false;
+		foreach(this.incomingServers, (client)=>{
+			const clientSocket=client.clientSocket;
+			self.server.send(channelName, message, null, clientSocket);
+			hasBeenSent=true;
+		});
+		return hasBeenSent;
+	}
+	/*private*/sendToOutcomingServers(channelName, message){
+		let hasBeenSent=false;
+		foreach(this.outcomingServers, (client)=>{
+			const clientInstanceToOtherServer=client.clientInstance;
+			clientInstanceToOtherServer.client.socketToServer.send(channelName, message);
+			hasBeenSent=true;
+		});
+		return hasBeenSent;
+	}
+	/*private*/sendToOtherSingleNode(channelName, request, destinationNodeId){
+		const self=this;
+		let hasBeenSent=false;
+		foreach(this.incomingServers, (client)=>{
+			const clientSocket=client.clientSocket;
+			self.server.send(channelName, message, null, clientSocket);
+			hasBeenSent=true;
+		},(c, nodeId)=>(nodeId===destinationNodeId));
+		if(!hasBeenSent){
+			foreach(this.outcomingServers, (client)=>{
+				const clientInstanceToOtherServer=client.clientInstance;
+				clientInstanceToOtherServer.client.socketToServer.send(channelName, message);
+				hasBeenSent=true;
+			},(c, nodeId)=>(nodeId===destinationNodeId));
+		}
+		return hasBeenSent;
+	}
+
+	/*private*/setUniqueReceptionPoint(channelName, messageType, doOnReception){
+		const self=this;
+		const listeners=this.listeners[channelName];
+		if(foreach(listeners,listener=>{
+			if(listener.messageType===messageType)	return true;
+		}))	return;
+		listeners.push({
+			messageType:messageType,
+			execute:(self, message, server, clientSocket)=>{
+				doOnReception(self, message, server, clientSocket);
+			}
+		});
+	}
+	
+	// ****************************************************************************************************
+
+	/*private*/isInAuthorizedNodes(incomingServerNodeId){
+		return contains(this.authorizedNodesIds,incomingServerNodeId);
+	}
+	
+	/*public*/traceNode(){
+		// TRACE
+		lognow("-------------------------------------------------------------");
+		lognow(`(${this.nodeId}) :`,this);
+		lognow("-------------------------------------------------------------");
+	}
+	
+	
+	
 }
 
-getAORTACNode=function(selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[]){
-	return new AORTACNode(selfOrigin,outcomingNodesOrigins);
+
+getAORTACNode=function(nodeId=getUUID(), selfOrigin="ws://127.0.0.1:40000", outcomingNodesOrigins=[], model, controller){
+	return new AORTACNode(nodeId, selfOrigin, outcomingNodesOrigins, model, controller);
 }
 
 
@@ -7388,6 +8243,7 @@ getAORTACNode=function(selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[]){
 
 
 
+
 /* INCLUDED EXTERNAL LIBRAIRIES
 */
 "use strict";var sjcl={cipher:{},hash:{},keyexchange:{},mode:{},misc:{},codec:{},exception:{corrupt:function(a){this.toString=function(){return"CORRUPT: "+this.message};this.message=a},invalid:function(a){this.toString=function(){return"INVALID: "+this.message};this.message=a},bug:function(a){this.toString=function(){return"BUG: "+this.message};this.message=a},notReady:function(a){this.toString=function(){return"NOT READY: "+this.message};this.message=a}}};

aotrautils-srv/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "aotrautils-srv",
-	"version": "0.0.1057",
+	"version": "0.0.1059",
 	"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)",