mastercontroller 1.2.1 → 1.2.3

package/MasterAction.js

@@ -133,6 +133,18 @@ class MasterAction{
 		}
 	}
 
+	returnReact(data, location){
+		
+			var masterView = null;
+			data = data === undefined ? {} : data;
+			this.params = this.params === undefined ? {} : this.params;
+			this.params = tools.combineObjects(data, this.params);
+			var func = master.viewList;
+			this.params = tools.combineObjects(this.params, func);
+			var html = master.reactView.compile(this.__currentRoute.toController, this.__currentRoute.toAction, this.__currentRoute.root);
+		
+	}
+
 	returnView(data, location){
 		
 		var masterView = null;
@@ -165,7 +177,32 @@ class MasterAction{
 		response.end(end);
 	}
 
+	// Utility method to check if response is ready for writing
+	// Returns true if safe to continue, false if response already sent
+	waitUntilReady(){
+		// Check the primary response object first (matches existing returnJson pattern)
+		if (this.__response) {
+			return !this.__response._headerSent;
+		}
+		// Check request object response as fallback (matches existing redirectTo pattern)
+		if (this.__requestObject && this.__requestObject.response) {
+			return !this.__requestObject.response._headerSent;
+		}
+		// If neither exists, assume it's safe to continue (early in request lifecycle)
+		return true;
+	}
+
+	// Enhanced returnJson that checks readiness first
+	safeReturnJson(data){
+		if (this.waitUntilReady()) {
+			this.returnJson(data);
+			return true;
+		}
+		console.warn('Attempted to send JSON response but headers already sent');
+		return false;
+	}
+
 
 }
 
-master.extendController(MasterAction);
+master.extendController(MasterAction);

package/MasterActionFilters.js

@@ -1,4 +1,4 @@
-// version 1.6	
+// version 1.7
 var master = require('./MasterControl');
 
 var _beforeActionFunc = {
@@ -54,7 +54,9 @@ class MasterActionFilters {
         var flag = false;
         if(_beforeActionFunc.namespace === obj.__namespace){
             for (var a = 0; a < _beforeActionFunc.actionList.length; a++) { 
-                if(_beforeActionFunc.actionList[a] === request.toAction){
+                var action = request.toAction.replace(/\s/g, '');
+                var incomingAction = _beforeActionFunc.actionList[a].replace(/\s/g, '');
+                if(incomingAction === action){
                     flag = true;
                 }
             }
@@ -65,7 +67,9 @@ class MasterActionFilters {
     __callBeforeAction(obj, request, emitter) {
             if(_beforeActionFunc.namespace === obj.__namespace){
                 _beforeActionFunc.actionList.forEach(action => {
-                    if(action === request.toAction){
+                    var action = action.replace(/\s/g, '');
+                    var reqAction = request.toAction.replace(/\s/g, '');
+                    if(action === reqAction){
                         emit = emitter;
                         // call function inside controller 
                         _beforeActionFunc.callBack.call(_beforeActionFunc.that, request);
@@ -77,7 +81,9 @@ class MasterActionFilters {
      __callAfterAction(obj, request) {
             if(_afterActionFunc.namespace === obj.__namespace){
                 _afterActionFunc.actionList.forEach(action => {
-                        if(action === request.toAction){
+                        var action = action.replace(/\s/g, '');
+                        var reqAction = request.toAction.replace(/\s/g, '');
+                        if(action === reqAction){
                             _afterActionFunc.callBack.call(_afterActionFunc.that, request);
                         }
                     });

package/MasterControl.js

@@ -1,5 +1,5 @@
 // MasterControl - by Alexander rich
-// version 1.0.22
+// version 1.0.245
 
 var url = require('url');
 var fileserver = require('fs');
@@ -191,28 +191,71 @@ class MasterControl {
 
     // sets up https or http server protocals
     setupServer(type, credentials ){
-        var $that = this;
-        if(type === "http"){
-            $that.serverProtocol = "http";
-            return http.createServer(async function(req, res) {
-                $that.serverRun(req, res);
-            });
-        }
-        if(type === "https"){
-            $that.serverProtocol = "https";
-            if(credentials){
-                return https.createServer(credentials, async function(req, res) {
+        try {
+            var $that = this;
+            if(type === "http"){
+                $that.serverProtocol = "http";
+                return http.createServer(async function(req, res) {
                     $that.serverRun(req, res);
-                  });
-            }else{
-                throw "Credentials needed to setup https"
+                });
+            }
+            if(type === "https"){
+                $that.serverProtocol = "https";
+                if(credentials){
+                    return https.createServer(credentials, async function(req, res) {
+                        $that.serverRun(req, res);
+                    });
+                }else{
+                    throw "Credentials needed to setup https"
+                }
             }
         }
+        catch(error){
+            console.error("Failed to setup server:", error);
+            throw error;
+        }
     }
 
     async serverRun(req, res){
         var $that = this;
         console.log("path", `${req.method} ${req.url}`);
+
+          // Handle CORS preflight (OPTIONS) requests early and positively
+        if (req.method === 'OPTIONS') {
+            try {
+                if (this.cors && typeof this.cors.load === 'function') {
+                    if (!this.cors.options) {
+                        this.cors.init({
+                            origin: true,
+                            methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+                            allowedHeaders: true,
+                            credentials: false,
+                            maxAge: 86400
+                        });
+                    }
+                    this.cors.load({ request: req, response: res });
+                } else {
+                    res.setHeader('access-control-allow-origin', '*');
+                    res.setHeader('access-control-allow-methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+                    if (req.headers['access-control-request-headers']) {
+                        res.setHeader('access-control-allow-headers', req.headers['access-control-request-headers']);
+                    }
+                    res.setHeader('access-control-max-age', '86400');
+                }
+            } catch (e) {
+                res.setHeader('access-control-allow-origin', '*');
+                res.setHeader('access-control-allow-methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+                if (req.headers['access-control-request-headers']) {
+                    res.setHeader('access-control-allow-headers', req.headers['access-control-request-headers']);
+                }
+                res.setHeader('access-control-max-age', '86400');
+            }
+            res.statusCode = 204;
+            res.setHeader('content-length', '0');
+            res.end();
+            return;
+        }
+
         // parse URL
         const parsedUrl = url.parse(req.url);
         // extract URL path
@@ -221,6 +264,9 @@ class MasterControl {
         // based on the URL path, extract the file extension. e.g. .js, .doc, ...
         const ext = path.parse(pathname).ext;
       
+        // handle simple preflight configuration - might need a complex approch for all scenarios
+    
+
         // if extension exist then its a file.
         if(ext === ""){
           var requestObject = await this.middleware(req, res);
@@ -228,11 +274,14 @@ class MasterControl {
             var loadedDone = false;
             if (typeof $that._loadedFunc === 'function') {
                loadedDone = $that._loadedFunc(requestObject);
-               
+                if (loadedDone){
+                    require(`${this.root}/config/load`)(requestObject);
+                } 
             }
-            if (loadedDone){
+            else{
                 require(`${this.root}/config/load`)(requestObject);
             }
+           
           
           }
         }
@@ -315,6 +364,7 @@ class MasterControl {
             return -1;
         }
         else{
+            
             var params = await this.request.getRequestParam(request, response);
             return {
                 request : request,

package/MasterCors.js

@@ -1,4 +1,4 @@
-// version 1.1.10
+// version 0.0.3 - robust origin handling (all envs), creds-safe reflection, function origins, extended Vary
 var master = require('./MasterControl');
 
 	// todo - res.setHeader('Access-Control-Request-Method', '*');
@@ -16,7 +16,9 @@ class MasterCors{
 	load(params){
 		if(params){
 			this.response = params.response;
-			this.request = params. request;
+			this.request = params.request;
+			// Always signal that response may vary by Origin and requested headers/method
+			try { this.response.setHeader('Vary', 'Origin, Access-Control-Request-Headers, Access-Control-Request-Method'); } catch(_) {}
 			this.configureOrigin();
 			this.configureMethods()
 			this.configureAllowedHeaders();
@@ -46,7 +48,13 @@ class MasterCors{
 			}
 
 			if(this.options.origin === true){
-				this.setHeader('access-control-allow-origin', '*');
+				// If credentials are enabled, reflect request origin per spec
+				var requestOrigin = this.request.headers.origin;
+				if (this.options.credentials === true && requestOrigin) {
+					this.setHeader('access-control-allow-origin', requestOrigin);
+				} else {
+					this.setHeader('access-control-allow-origin', '*');
+				}
 			}
 
 			// remove all origins
@@ -54,11 +62,29 @@ class MasterCors{
 				this.removeHeader('access-control-allow-origin');
 			}
 				
-			if(this.options.origin.constructor === Array){		
-				for (const element of this.options.origin) {
-					this.setHeader('access-control-allow-origin', element);
+			if(this.options.origin.constructor === Array){
+				// Get the origin from the incoming request
+				var requestOrigin = this.request.headers.origin;
+				
+				// Check if the request origin is in our allowed list
+				if(requestOrigin && this.options.origin.includes(requestOrigin)){
+					this.setHeader('access-control-allow-origin', requestOrigin);
 				}
-			
+				// If no specific origin matches, don't set the header
+			}
+
+			// Function predicate support: (origin, req) => boolean|string
+			if (typeof this.options.origin === 'function'){
+				try {
+					var requestOrigin = this.request.headers.origin;
+					var res = this.options.origin(requestOrigin, this.request);
+					if (res === true && requestOrigin){
+						this.setHeader('access-control-allow-origin', requestOrigin);
+					}
+					else if (typeof res === 'string' && res){
+						this.setHeader('access-control-allow-origin', res);
+					}
+				} catch(_) {}
 			}
 
 		}
@@ -143,4 +169,4 @@ class MasterCors{
 	}
 }
 
-master.extend("cors", MasterCors);
+master.extend("cors", MasterCors);

package/MasterError.js

@@ -1,5 +1,5 @@
 
-// version 1.0.19
+// version 1.0.20 - improved console/error logging with syntax error code frames
 var master = require('./MasterControl');
 var winston = require('winston');
 var fileserver = require('fs');
@@ -22,19 +22,23 @@ class MasterError{
               ]
           });
         
-        process.on('uncaughtException', function (reason, promise) {
-            that.log(reason, "error");
-            //master.request.clear(500, reason.message);
-        });
-        
-                // will catch all promise exceptions
-        process.on('unhandledRejection', function (reason, promise) {
-            that.log(reason, "warn");
-        });
+		// Global error handlers with better diagnostics (stack and code frame)
+		process.on('uncaughtException', function (err) {
+			that._reportError(err, 'uncaughtException');
+		});
 
-        process.on('rejectionHandled', function (reason, promise) {
-            that.log(reason, "warn");
-        });
+		// will catch all promise exceptions
+		process.on('unhandledRejection', function (reason, promise) {
+			that._reportError(reason instanceof Error ? reason : new Error(String(reason)), 'unhandledRejection');
+		});
+
+		process.on('rejectionHandled', function (reason, promise) {
+			that._reportError(reason instanceof Error ? reason : new Error(String(reason)), 'rejectionHandled');
+		});
+
+		process.on('warning', function (warning) {
+			that._reportError(warning instanceof Error ? warning : new Error(String(warning)), 'warning');
+		});
         
     }
 
@@ -111,6 +115,63 @@ class MasterError{
             stack : msg.stack
         });
     }
+
+	// Enhanced error reporter: logs formatted stack and nearby source code
+	_reportError(err, tag){
+		try{
+			const name = err && err.name ? err.name : 'Error';
+			const message = err && err.message ? err.message : String(err);
+			const stack = err && err.stack ? String(err.stack) : '';
+			const header = `[${tag}] ${name}: ${message}`;
+			console.error('\u001b[31m' + header + '\u001b[0m');
+			if (stack) {
+				console.error(stack);
+				const loc = this._extractTopFrame(stack);
+				if (loc && loc.file && loc.line) {
+					const frame = this._buildCodeFrame(loc.file, loc.line, loc.column);
+					if (frame) {
+						console.error('\n\u001b[33mCode frame:\u001b[0m');
+						console.error(frame);
+					}
+				}
+			}
+			this.log(err, 'error');
+		} catch(e){
+			try { console.error('Error while reporting error:', e); } catch(_) {}
+		}
+	}
+
+	_extractTopFrame(stack){
+		try{
+			const lines = stack.split('\n');
+			for (let i = 0; i < lines.length; i++) {
+				const m = lines[i].match(/\((.*):(\d+):(\d+)\)/) || lines[i].match(/at ([^\s]+):(\d+):(\d+)/);
+				if (m) {
+					return { file: m[1], line: parseInt(m[2]), column: parseInt(m[3]||'0') };
+				}
+			}
+			return null;
+		} catch(_) { return null; }
+	}
+
+	_buildCodeFrame(file, line, column){
+		try{
+			if (!fileserver.existsSync(file)) return null;
+			const src = fileserver.readFileSync(file, 'utf8').split(/\r?\n/);
+			const start = Math.max(1, line - 3);
+			const end = Math.min(src.length, line + 3);
+			const digits = String(end).length;
+			let out = '';
+			for (let i = start; i <= end; i++) {
+				const prefix = (i === line ? '>' : ' ') + String(i).padStart(digits, ' ') + ' | ';
+				out += prefix + src[i - 1] + '\n';
+				if (i === line && column && column > 0) {
+					out += ' '.repeat(prefix.length + column - 1) + '^\n';
+				}
+			}
+			return out;
+		} catch(_) { return null; }
+	}
 }
 
 master.extend("error", MasterError);

package/MasterRequest.js

@@ -1,5 +1,5 @@
 
-// version 0.0.1
+// version 0.0.2
 
 var master = require('./MasterControl');
 var url = require('url');
@@ -91,9 +91,17 @@ class MasterRequest{
                                 resolve($that.parsedURL);
                             });  
 
+                        break
+                        case "text/plain" : 
+                        $that.fetchData(request, function(data){
+                            $that.parsedURL.formData = data;
+                            resolve($that.parsedURL);
+
+                        });
+
                         break
                         default:
-                            var errorMessage = `Cannot parse - We currently support text/html, application/json, multipart/form-data, and application/x-www-form-urlencoded - your sending us = ${contentType.type}`;
+                            var errorMessage = `Cannot parse - We currently support text/plain, text/html, application/json, multipart/form-data, and application/x-www-form-urlencoded - your sending us = ${contentType.type}`;
                             resolve(errorMessage);
                             console.log(errorMessage);
                       }
@@ -110,6 +118,47 @@ class MasterRequest{
       }
   };
 
+
+  fetchData(request, func) {
+
+    let body = '';
+    let receivedBytes = 0;
+    const maxBytes = 1 * 1024 * 1024; // 1MB limit
+  
+ 
+    try {
+
+        request.on('data', (chunk) => {
+            receivedBytes += chunk.length;
+      
+            // Prevent memory overload
+            if (receivedBytes > maxBytes) {
+              req.destroy(); // Close the connection
+              return;
+            }
+            
+            // Append chunk to body
+            body += chunk.toString('utf8');
+        });
+  
+        request.on('end', () => {
+            try {
+                // Process the plain text data here
+                const responseData = body;
+                func(responseData );
+              } catch (err) {
+
+                console.error('Processing error handling text/plain:', err);
+                throw err;
+              }
+
+        });
+    } catch (error) {
+      console.error("Failed to fetch data:", error);
+      throw error;
+    }
+  }
+
   deleteFileBuffer(filePath){
     fs.unlink(filePath, function (err) {
         if (err) {
@@ -134,6 +183,10 @@ class MasterRequest{
       });
 
   }
+
+  stringToJson(request, func){
+
+  }
   
   jsonStream(request, func){
       //request.pipe(decoder);
@@ -143,8 +196,13 @@ class MasterRequest{
       });
 
       request.on('end', () => {
-          var buff = qs.parse(buffer);
-          func(buff);
+            try {
+                var buff = JSON.parse(buffer);
+                func(buff);
+            } catch (e) {
+                var buff = qs.parse(buffer);
+                func(buff);
+            }
       });
 
   }

package/MasterRouter.js

@@ -1,4 +1,4 @@
-// version 0.0.24
+// version 0.0.247
 
 var master = require('./MasterControl');
 var toolClass =  require('./MasterTools');
@@ -35,53 +35,65 @@ var tools = new toolClass();
     var routeList = routeObject.routes;
     var root = routeObject.root;
     var isComponent = routeObject.isComponent;
+    try{
+            if(routeList.length > 0){
+                // loop through routes
+                for(var item in routeList){
 
-    if(routeList.length > 0){
-        // loop through routes
-        for(var item in routeList){
+                    requestObject.toController = routeList[item].toController;
+                    requestObject.toAction = routeList[item].toAction;
+                    var pathObj = normalizePaths(requestObject.pathName, routeList[item].path, requestObject.params);
+                    // if we find the route that matches the request
+                    if(pathObj.requestPath === pathObj.routePath && routeList[item].type === requestObject.type){
 
-            requestObject.toController = routeList[item].toController;
-            requestObject.toAction = routeList[item].toAction;
-            var pathObj = normalizePaths(requestObject.pathName, routeList[item].path, requestObject.params)
-            // if we find the route that matches the request
-            if(pathObj.requestPath === pathObj.routePath && routeList[item].type === requestObject.type){
+                        // call Constraint
+                        if(typeof routeList[item].constraint === "function"){
+                            
+                            var newObj = {};
+                            //tools.combineObjects(newObj, master.controllerList);
+                            newObj.next = function(){
+                                currentRoute.root = root;
+                                currentRoute.pathName = requestObject.pathName;
+                                currentRoute.toAction = requestObject.toAction;
+                                currentRoute.toController = requestObject.toController;
+                                currentRoute.response = requestObject.response;
+                                currentRoute.isComponent = isComponent;
+                                emitter.emit("routeConstraintGood", requestObject);
+                            };
+                            routeList[item].constraint.call(newObj, requestObject);
+                            return true;
+                        }else{
 
-                // call Constraint
-                if(typeof routeList[item].constraint === "function"){
-                    
-                    var newObj = {};
-                    //tools.combineObjects(newObj, master.controllerList);
-                    newObj.next = function(){
-                        currentRoute.root = root;
-                        currentRoute.pathName = requestObject.pathName;
-                        currentRoute.toAction = requestObject.toAction;
-                        currentRoute.toController = requestObject.toController;
-                        currentRoute.response = requestObject.response;
-                        currentRoute.isComponent = isComponent;
-                        emitter.emit("routeConstraintGood", requestObject);
-                    };
-                    routeList[item].constraint.call(newObj, requestObject);
-                    return true;
-                }else{
+                            currentRoute.root = root;
+                            currentRoute.pathName = requestObject.pathName;
+                            currentRoute.toAction = requestObject.toAction;
+                            currentRoute.toController = requestObject.toController;
+                            currentRoute.response = requestObject.response;
+                            currentRoute.isComponent = isComponent;
+                            emitter.emit("routeConstraintGood", requestObject);
+                            return true;
+                        }
+                        
+                    }
 
-                    currentRoute.root = root;
-                    currentRoute.pathName = requestObject.pathName;
-                    currentRoute.toAction = requestObject.toAction;
-                    currentRoute.toController = requestObject.toController;
-                    currentRoute.response = requestObject.response;
-                    currentRoute.isComponent = isComponent;
-                    emitter.emit("routeConstraintGood", requestObject);
-                    return true;
-                }
-                
+                    if(pathObj.requestPath === pathObj.routePath && "options" ===requestObject.type.toLowerCase()){
+                        // this means that the request is correct but its an options request means its the browser checking to see if the request is allowed
+                        requestObject.response.writeHead(200, {'Content-Type': 'application/json'});
+			            requestObject.response.end(JSON.stringify({"done": "true"}));
+                        return true;
+                    }
+                   
+                };
+                return -1;
             }
-        };
-        return -1;
-    }
-    else{
-        master.error.log(`route list is not an array`, "Error");
-        return -1;
-    }
+            else{
+                master.error.log(`route list is not an array`, "Error");
+                return -1;
+            }
+        }
+        catch(e){
+            throw new Error("Error processing routes: " + e.stack); 
+        }
 };
 
 var loadScopedListClasses = function(){

package/MasterSession.js

@@ -1,5 +1,5 @@
  
-// version 0.0.19
+// version 0.0.22
 
 var master = require('./MasterControl');
 var cookie = require('cookie');
@@ -22,10 +22,17 @@ class MasterSession{
         secret : this.createSessionID()
     };
 
-    init(TID){
+    init(options){
         var $that = this;
-        if(TID){
-            $that.options.secret = TID;
+
+        // Combine the rest of the options carefully
+        this.options = {
+            ...this.options,
+            ...options
+        };
+
+        if(this.options.TID){
+            this.options.secret = TID;
         }
 
         return {
@@ -84,10 +91,17 @@ class MasterSession{
          return this.secret;
     }
 
-    setCookie(name, payload, response, secret, options){
+    setCookie(name, payload, response, options){
         var cookieOpt = options === undefined? this.options : options;
-        if(secret){
-            response.setHeader('Set-Cookie', cookie.serialize(name, tools.encrypt(payload, secret), cookieOpt));
+        if(typeof options === "object"){
+            if(options.secret){
+                response.setHeader('Set-Cookie', cookie.serialize(name, tools.encrypt(payload, cookieOpt.secret), cookieOpt));
+            }else{
+
+                response.setHeader('Set-Cookie', cookie.serialize(name, payload, cookieOpt));
+       
+            }
+
         }
         else{
             response.setHeader('Set-Cookie', cookie.serialize(name, payload, cookieOpt));
@@ -119,10 +133,10 @@ class MasterSession{
         }
     }
 
-    deleteCookie (name, response){
-        this.options.expires = new Date(0);
-        response.setHeader('Set-Cookie', cookie.serialize(name, "", this.options));
-        this.options.expires = undefined;
+    deleteCookie (name, response, options){
+        var cookieOpt = options === undefined? this.options : options;
+        response.setHeader('Set-Cookie', cookie.serialize(name, "", cookieOpt));
+        cookieOpt.expires = undefined;
     }
 
     // delete session and cookie

package/MasterSocket.js

@@ -1,5 +1,9 @@
-// version 0.0.3
+// version 0.1.1
+
 var master = require('./MasterControl');
+const { Server } = require('socket.io');
+const fs = require('fs');
+const path = require('path');
 
 var jsUcfirst = function(string){
     return string.charAt(0).toUpperCase() + string.slice(1);
@@ -7,8 +11,82 @@ var jsUcfirst = function(string){
 
 class MasterSocket{
     
-    init(){
+    init(serverOrIo, options = {}){
         this._baseurl = master.root;
+
+        // Build Socket.IO options using master cors initializer when available
+        const defaults = this._buildDefaultIoOptions();
+        const ioOptions = mergeDeep(defaults, options || {});
+
+        // Determine whether we're given an io instance or an HTTP server
+        if (serverOrIo && typeof serverOrIo.of === 'function') {
+            // It's already an io instance
+            this.io = serverOrIo;
+        } else {
+            // Prefer explicit server, fallback to master.server
+            const httpServer = serverOrIo || master.server;
+            if (!httpServer) {
+                throw new Error('MasterSocket.init requires an HTTP server or a pre-created Socket.IO instance');
+            }
+            this.io = new Server(httpServer, ioOptions);
+        }
+
+        this._bind();
+    }
+
+    _buildDefaultIoOptions(){
+        const corsCfg = this._loadCorsConfig();
+        const transports = ['websocket', 'polling'];
+        const cors = {};
+        try {
+            if (corsCfg) {
+                if (typeof corsCfg.origin !== 'undefined') cors.origin = corsCfg.origin;
+                if (typeof corsCfg.credentials !== 'undefined') cors.credentials = !!corsCfg.credentials;
+                if (Array.isArray(corsCfg.methods)) cors.methods = corsCfg.methods;
+                if (Array.isArray(corsCfg.allowedHeaders)) cors.allowedHeaders = corsCfg.allowedHeaders;
+            } else {
+                // sensible defaults for dev
+                cors.origin = true;
+                cors.credentials = true;
+                cors.methods = ['GET','POST'];
+            }
+        } catch (_) {}
+        return { cors, transports };
+    }
+
+    _loadCorsConfig(){
+        try {
+            const cfgPath = path.join(master.root, 'config', 'initializers', 'cors.json');
+            if (fs.existsSync(cfgPath)) {
+                const raw = fs.readFileSync(cfgPath, 'utf8');
+                return JSON.parse(raw);
+            }
+        } catch (e) {
+            try { console.warn('[MasterSocket] Failed to load cors.json:', e && e.message ? e.message : e); } catch(_){}
+        }
+        return null;
+    }
+
+    _bind(){
+        const io = this.io;
+        io.on('connection', (socket) => {
+            try{
+                // Route all events through MasterSocket loader
+                socket.onAny((eventName, payload) => {
+                    try{
+                        // MasterSocket.load expects [action, payload]
+                        const data = [eventName, payload];
+                        if (master && master.socket && typeof master.socket.load === 'function') {
+                            master.socket.load(data, socket, io);
+                        }
+                    }catch(e){
+                        try { console.error('Socket routing error:', e?.message || e); } catch(_){}
+                    }
+                });
+            }catch(e){
+                try { console.error('Socket connection handler error:', e?.message || e); } catch(_){}
+            }
+        });
     }
 
     async load(data, socket, io){
@@ -45,4 +123,44 @@ class MasterSocket{
     }
 }
 
-master.extend("socket", MasterSocket);
+master.extend("socket", MasterSocket);
+
+// shallow+deep merge helper
+function isObject(item) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+function mergeDeep(target, source) {
+    const output = Object.assign({}, target);
+    if (isObject(target) && isObject(source)) {
+        Object.keys(source).forEach(key => {
+            if (isObject(source[key])) {
+                if (!(key in target)) Object.assign(output, { [key]: source[key] });
+                else output[key] = mergeDeep(target[key], source[key]);
+            } else {
+                Object.assign(output, { [key]: source[key] });
+            }
+        });
+    }
+    return output;
+}
+
+/**
+ * 
+ * 
+ * 
+ * It loads CORS and methods from config/initializers/cors.json automatically. During init, it reads master.root/config/initializers/cors.json and builds the Socket.IO options from:
+origin, credentials, methods, allowedHeaders (if present)
+transports defaults to ['websocket', 'polling']
+If cors.json is missing or a field isn’t present, it falls back to:
+cors: { origin: true, credentials: true, methods: ['GET','POST'] }
+transports: ['websocket','polling']
+You can still override anything explicitly:
+master.socket.init(master.server, { cors: { origin: ['https://foo.com'], methods: ['GET','POST','PUT'] }, transports: ['websocket'] })
+
+If you don’t pass a server/io, init() falls back to master.server:
+master.socket.init() → uses master.server automatically
+You can pass overrides as the second arg:
+master.socket.init(undefined, { cors: { origin: ['https://app.com'] }, transports: ['websocket'] })
+Or pass a prebuilt io:
+const io = new Server(master.server, opts); master.socket.init(io)
+ */

package/package.json

@@ -1,10 +1,10 @@
 {
   "dependencies": {
-    "qs" : "^6.11.2",
-    "formidable": "^3.5.1",
-    "cookie": "^0.5.0",
-    "winston": "^3.10.0",
-    "glob" :"^10.3.4"
+    "qs" : "^6.14.0",
+    "formidable": "^3.5.4",
+    "cookie": "^1.0.2",
+    "winston": "^3.17.0",
+    "glob" :"^11.0.3"
   },
   "description": "A class library that makes using the Master Framework a breeze",
   "homepage": "https://github.com/Tailor/MasterController#readme",
@@ -18,5 +18,5 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "1.2.1"
+  "version": "1.2.3"
 }

package/MasterJWT.js

@@ -1,112 +0,0 @@
-
-// version 0.0.17
-
-var master = require('./MasterControl');	
-var crypto = require('crypto');	
-var toolClass =  require('./MasterTools');
-var tools = new toolClass();
-
- //https://www.youtube.com/watch?v=67mezK3NzpU&t=2492s
-class MasterJWT{
-
-        init(TID){
-            this.alg = "sha256";
-            var $that = this;
-            this.secret = this.createJWTID();
-            if(TID){
-                this.secret = TID;
-            }
-            return {
-                sha256 : function(){
-                    $that.alg = "sha256"
-                }
-            };
-        }
-        
-        createJWTID(){
-           return crypto.randomBytes(20).toString('hex');
-        }
-
-        getJWTID(){
-            return this.secret;
-        }
-
-        create(payload, encrypted, encryptionKey){
-            var hmac = null;
-            var now = new Date();
-            var twoHoursLater = new Date(now.getTime() + (2*1000*60*60))
-            var encrypted = typeof encrypted === "undefined" ? false : true;
-            var encodePayload = null;
-            
-            if(typeof payload === "string"){
-                throw "payload must be object not string";
-            }
-
-            var header = {
-                    typ: 'JWT',
-                    alg: this.alg
-            };
-
-            var body = {
-                jti: tools.generateRandomKey('sha256'),
-                iat: Math.floor(new Date() / 1000),
-                exp: twoHoursLater
-                };
-
-            body = tools.combineObjects(body, payload);
-            
-            if(encrypted === true){
-                header["encrypt"] = 'aes-256-ctr';
-                if(encryptionKey === undefined){
-                    encodePayload =  tools.base64().encode(tools.encrypt(JSON.stringify(body), this.secret));
-                }else{
-                    encodePayload =  tools.base64().encode(tools.encrypt(JSON.stringify(body), encryptionKey));
-                }
-            }
-            else{
-                encodePayload =  tools.base64().encode(JSON.stringify(body));
-            }
-
-            
-            if(encryptionKey === undefined){
-                hmac = crypto.createHmac(this.alg, this.secret);
-            }else{
-                hmac = crypto.createHmac(this.alg, encryptionKey);
-            }
-
-            var encodeHeader = tools.base64().encode(JSON.stringify(header));
-            hmac.update(encodeHeader + "." + encodePayload);
-            var sig = hmac.digest('base64');
-            
-            return encodeHeader + "." + encodePayload + "." + sig;
-        }
-
-        verify(signature, encrypted, secret){
-            var secret = secret === undefined ? this.secret : secret;
-            var encrypted = typeof encrypted === "undefined" ? false : true;
-            var jwt = signature.split(".");
-            var decodeHeader = JSON.parse(tools.base64().decode(jwt[0]));
-
-            var hmac = crypto.createHmac(decodeHeader.alg, secret );
-            hmac.update(jwt[0] + "." + jwt[1]);
-            var ourSignature = hmac.digest('base64');
-
-            if(ourSignature === jwt[2]){
-                // if they are the same return json payload or un ecrypt payload
-                var decodePayload = tools.base64().decode(jwt[1]);
-                if(encrypted === true){
-                    var decryptPayload = JSON.parse(tools.decrypt(decodePayload, secret ));
-                    return decryptPayload;
-                }
-                else{
-                    return decodePayload;
-                }
-            }
-            else{
-                return -1;
-            }
-        }
-}
-
-
-master.extend("jwt", MasterJWT);