gina 0.1.1-alpha.2 → 0.1.1-alpha.200

package/framework/{v0.1.1-alpha.2 → v0.1.1-alpha.200}/lib/routing/src/main.js

@@ -1,6 +1,6 @@
 /*
  * This file is part of the gina package.
- * Copyright (c) 2009-2022 Rhinostone <contact@gina.io>
+ * Copyright (c) 2009-2023 Rhinostone <contact@gina.io>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -21,12 +21,18 @@ function Routing() {
         allowedMethods: ['get', 'post', 'put', 'delete'],
         reservedParams: ['controle', 'file','title', 'namespace', 'path'],
         notFound: {}
-    };    
-        
+    };
+
     self.allowedMethodsString   = self.allowedMethods.join(',');
-    
-    // loading utils & plugins
-    var plugins = null, inherits = null, merge = null, Validator = null, fs = null, promisify = null;
+
+    // loading lib & plugins
+    var plugins     = null
+        , inherits  = null
+        , merge     = null
+        , Validator = null
+        , fs        = null
+        , promisify = null
+    ;
     if (!isGFFCtx) {
         fs          = require('fs');
         promisify   = require('util').promisify;
@@ -34,26 +40,26 @@ function Routing() {
         merge       = require('../../merge');
         plugins     = require(__dirname+'/../../../core/plugins') || getContext('gina').plugins;
         Validator   = plugins.Validator;
-                
-    } 
+
+    }
     // BO - In case of partial rendering whithout handler defined for the partial
     else {
         if ( !merge || typeof(merge) != 'function' ) {
-            var merge = require('utils/merge');
+            merge = require('lib/merge');
         }
-        if ( !Validator || typeof(Validator) != 'function' ) {
-            var Validator = require('utils/form-validator');
+        if ( !Validator || typeof(Validator) != 'function' ) {
+            Validator = require('lib/form-validator');
         }
-    }                        
+    }
     // EO - In case of partial rendering whithout handler defined for the partial
-    
+
     /**
      * Get url props
      * Used to retrieve additional properties for routes with redirect flag for example
-     * 
+     *
      * @param {string} [bundle]
-     * @param {string} [env] 
-     * 
+     * @param {string} [env]
+     *
      * @returns {object} urlProps - { .host, .hostname, .webroot }
      */
     self.getUrlProps = function(bundle, env) {
@@ -69,7 +75,7 @@ function Routing() {
                 urlProps.hostname   = _route.hostname;
                 urlProps.host       = _route.host;
                 urlProps.webroot    = _route.webroot;
-            }            
+            }
         } else {
             config = getContext('gina').config;
             if ( typeof(getContext('argvFilename')) != 'undefined' ) {
@@ -81,47 +87,47 @@ function Routing() {
             if ( typeof(env) == 'undefined' ) {
                 env      = config.env;
             }
-            
+
             urlProps.hostname   = config.envConf[bundle][env].hostname;
             urlProps.host       = config.envConf[bundle][env].host;
             urlProps.webroot    = config.envConf[bundle][env].server.webroot;
         }
-        
+
         return urlProps;
     }
-    
+
     /**
      * Load bundle routing configuration
-     * 
+     *
      * @param {object} options
      *  {
      *      isStadalone: false,
      *      bundle: 'default',   // bundle's name
      *      wroot: '/',          // by default
-     *      
+     *
      *  }
-     * 
+     *
      */
     // self.loadBundleRoutingConfiguration = function(options, filename) {
-        
+
     // }
-    
+
     /**
      * Get routing
-     * 
+     *
      * @param {string} [bundle]
      */
     // self.getRouting = function(bundle) {
-        
+
     // }
-    
+
     /**
      * Get reversed routing
-     * 
+     *
      * @param {string} [bundle]
      */
     // self.getReverseRouting = function(bundle) {
-        
+
     // }
 
     /**
@@ -136,7 +142,7 @@ function Routing() {
      * @returns {object|false} foundRoute
      * */
     self.compareUrls = async function(params, url, request, response, next) {
-        
+
         if ( typeof(request) == 'undefined' ) {
             request = { routing: {} };
         }
@@ -174,7 +180,7 @@ function Routing() {
      * @private
      * */
     var hasParams = function(pathname) {
-        return (/:/.test(pathname)) ? true : false;
+        return (/\:/.test(pathname)) ? true : false;
     };
 
     /**
@@ -190,12 +196,12 @@ function Routing() {
      *
      * */
     var parseRouting = async function(params, url, request, response, next) {
-        
+
         // Sample debug break for specific rule
         // if ( params.rule == 'my-specific-rule@bundle' ) {
         //     console.debug('passed '+ params.rule);
         // }
-        
+
         var uRe             = params.url.split(/\//)
             , uRo           = url.split(/\//)
             , uReCount      = 0
@@ -206,30 +212,30 @@ function Routing() {
             , i             = 0
             , method        = request.method.toLowerCase()
         ;
-        
+
         // TODO - remove comments
         // when requirement is not listed but still validated
-        // if ( 
-        //     typeof(params.requirements) != 'undefined' 
+        // if (
+        //     typeof(params.requirements) != 'undefined'
         //     && method == params.method.toLowerCase()
         //     //&& /validator\:\:/.test(JSON.stringify(params.requirements))
         // ) {
-                        
+
         //     var requiremements = Object.getOwnPropertyNames(params.requirements);
         //     var r = 0;
         //     // In order to filter variables
         //     var uRoVars = uRo.join(',').match(/\:[-_a-z0-9]+/g);
         //     // var uRoVarCount = (uRoVars) ? uRoVars.length : 0;
         //     while ( r < requiremements.length ) {
-                
+
         //         // if not listed, but still needing validation
-        //         if ( 
-        //             typeof(params.param[ requiremements[r] ]) == 'undefined' 
+        //         if (
+        //             typeof(params.param[ requiremements[r] ]) == 'undefined'
         //             && /^validator\:\:/i.test(params.requirements[ requiremements[r] ])
         //             && typeof(request[method][ requiremements[r] ])
         //         ) {
         //             if (uRo.length != uRe.length) {
-        //                 // r++;                     
+        //                 // r++;
         //                 // continue;
         //                 break;
         //             }
@@ -239,22 +245,22 @@ function Routing() {
         //              * "requirements" : {
         //              *      "email": "validator::{ isEmail: true, isString: [7] }"
         //              *  }
-        //              * 
+        //              *
         //              * e.g.: result = new Validator('routing', _data, null, {email: {isEmail: true, subject: \"Anything\"}} ).isEmail().valid;
-        //              */ 
+        //              */
         //             let regex = params.requirements[ requiremements[r] ];
         //             let _data = {}, _ruleObj = {}, _rule = {};
-                    
+
         //             try {
         //                 _ruleObj    = JSON.parse(
         //                 regex.split(/::/).splice(1)[0]
         //                     .replace(/([^\:\"\s+](\w+))\:/g, '"$1":') // { query: { validIf: true }} => { "query": { "validIf": true }}
         //                     .replace(/([^\:\"\s+](\w+))\s+\:/g, '"$1":') // note the space between `validIf` & `:` { query: { validIf : true }} => { "query": { "validIf": true }}
-        //                 );                    
+        //                 );
         //             } catch (err) {
         //                 throw err;
         //             }
-                    
+
         //             let key     = requiremements[r];
         //             // validator.query case
         //             if (typeof(_ruleObj.query) != 'undefined' && typeof(_ruleObj.query.data) != 'undefined') {
@@ -268,7 +274,7 @@ function Routing() {
         //                 for (let p = 0, pLen = uRo.length; p < pLen; p++) {
         //                     // :variable only
         //                     if (!/^\:/.test(uRo[p])) continue;
-                                
+
         //                     let pName = uRo[p].replace(/^\:/, '');
         //                     if ( pName != '' && typeof(uRe[p]) != 'undefined' ) {
         //                         _data[ pName ] = uRe[p];
@@ -278,24 +284,24 @@ function Routing() {
         //                             request.params[pName] = uRe[p];
         //                         }
         //                     }
-        //                 }                       
+        //                 }
         //             }
         //             // normal case
         //             _data = merge(_data, request[method]);
-                    
+
         //             if ( typeof(_data[key]) == 'undefined' ) {
         //                 // init default value for unlisted variable/param
         //                 _data[key] = null;
         //             }
-                    
-        //             _rule[key]  = _ruleObj;                
+
+        //             _rule[key]  = _ruleObj;
         //             _validator  = new Validator('routing', _data, null, _rule );
-                    
+
         //             if (_ruleObj.count() == 0 ) {
         //                 console.error('Route validation failed '+ params.rule);
         //                 return false;
         //             }
-                    
+
         //             for (let rule in _ruleObj) {
         //                 let _result = null;
         //                 if (Array.isArray(_ruleObj[rule])) { // has args
@@ -313,12 +319,12 @@ function Routing() {
         //         r++
         //     }
         // }
-                
+
         // attaching routing description for this request
         var paramMethod = params.method.toLowerCase();
-                    
+
         var hasAlreadyBeenScored = false;
-        if ( 
+        if (
             typeof(params.requirements) != 'undefined'
             && /get|delete/i.test(method)
             && typeof(request[method]) != 'undefined'
@@ -327,20 +333,20 @@ function Routing() {
             typeof(params.requirements) != 'undefined'
             && /get/i.test(method)
             && /delete/i.test(paramMethod)
-        ) {     
+        ) {
             if ( /get/i.test(method) && /delete/i.test(paramMethod) ) {
                 method = paramMethod;
             }
             // `delete` methods don't have a body
             // So, request.delete is {} by default
-            if ( /^(delete)$/i.test(method) && uRe.length === uRo.length ) { 
+            if ( /^(delete)$/i.test(method) && uRe.length === uRo.length ) {
                 // just in case
                 if ( typeof(request[method]) == 'undefined' ) {
                     request[method] = {};
                 }
                 for (let p = 0, pLen = uRo.length; p < pLen; p++) {
-                    if (uRe[p] === uRo[p]) {    
-                        ++score;                    
+                    if (uRe[p] === uRo[p]) {
+                        ++score;
                         continue;
                     }
                     let _key = uRo[p].substr(1);
@@ -355,44 +361,44 @@ function Routing() {
                         continue;
                     }
                     if (
-                        /^:/.test(uRo[p]) 
+                        /^:/.test(uRo[p])
                         && typeof(condition) != 'undefined'
                         && new RegExp(condition).test(uRe[p])
                     ) {
-                        ++score;                        
-                        request[method][uRo[p].substr(1)] = uRe[p];    
+                        ++score;
+                        request[method][uRo[p].substr(1)] = uRe[p];
                     }
                 }
-                hasAlreadyBeenScored = true;           
-            }            
-            
+                hasAlreadyBeenScored = true;
+            }
+
             // Sample debug break for specific rule
             // if ( params.rule == 'my-specific-rule@bundle' ) {
             //     console.debug('passed '+ params.rule);
             // }
             for (let p in request[method]) {
                 if ( typeof(params.requirements[p]) != 'undefined' && uRo.indexOf(':' + p) < 0 ) {
-                    uRo[uRoCount] = ':' + p; 
+                    uRo[uRoCount] = ':' + p;
                     ++uRoCount;
-                    
+
                     uRe[uReCount] = request[method][p];
                     ++uReCount;
                     if (!hasAlreadyBeenScored && uRe.length === uRo.length)
-                        ++maxLen;                    
+                        ++maxLen;
                 }
             }
         }
-        
-                
+
+
         // Sample debug break for specific rule
         // if ( params.rule == 'my-specific-rule@bundle' ) {
         //     console.debug('passed '+ params.rule);
         // }
-        
+
         if (!hasAlreadyBeenScored && uRe.length === uRo.length) {
-            
+
             for (; i < maxLen; ++i) {
-                
+
                 if (uRe[i] === uRo[i]) {
                     ++score;
                 }
@@ -401,15 +407,15 @@ function Routing() {
                 }
             }
         }
-        
+
         // This test is done to catch `validator::` rules under requirements
-        if ( 
-            typeof(params.requirements) != 'undefined' 
+        if (
+            typeof(params.requirements) != 'undefined'
             && method == params.method.toLowerCase()
             && !hasAlreadyBeenScored
             && score >= maxLen
         ) {
-                        
+
             var requiremements = Object.getOwnPropertyNames(params.requirements);
             var r = 0;
             // In order to filter variables
@@ -419,12 +425,12 @@ function Routing() {
                 // requirement name as `key`
                 let key = requiremements[r];
                 // if not listed, but still needing validation
-                if ( 
-                    typeof(params.param[ key ]) == 'undefined' 
+                if (
+                    typeof(params.param[ key ]) == 'undefined'
                     && /^validator\:\:/i.test(params.requirements[ key ])
                 ) {
                     if (uRo.length != uRe.length) {
-                        // r++;                     
+                        // r++;
                         // continue;
                         break;
                     }
@@ -434,22 +440,22 @@ function Routing() {
                      * "requirements" : {
                      *      "email": "validator::{ isEmail: true, isString: [7] }"
                      *  }
-                     * 
+                     *
                      * e.g.: result = new Validator('routing', _data, null, {email: {isEmail: true, subject: \"Anything\"}} ).isEmail().valid;
-                     */ 
+                     */
                     let regex = params.requirements[ key ];
                     let _data = {}, _ruleObj = {}, _rule = {};
-                    
+
                     try {
                         _ruleObj    = JSON.parse(
                         regex.split(/::/).splice(1)[0]
                             .replace(/([^\:\"\s+](\w+))\:/g, '"$1":') // { query: { validIf: true }} => { "query": { "validIf": true }}
                             .replace(/([^\:\"\s+](\w+))\s+\:/g, '"$1":') // note the space between `validIf` & `:` { query: { validIf : true }} => { "query": { "validIf": true }}
-                        );                    
+                        );
                     } catch (err) {
                         throw err;
                     }
-                    
+
                     // validator.query case
                     if (typeof(_ruleObj.query) != 'undefined' && typeof(_ruleObj.query.data) != 'undefined') {
                         _data = _ruleObj.query.data;
@@ -462,7 +468,7 @@ function Routing() {
                         for (let p = 0, pLen = uRo.length; p < pLen; p++) {
                             // :variable only
                             if (!/^\:/.test(uRo[p])) continue;
-                                
+
                             let pName = uRo[p].replace(/^\:/, '');
                             if ( pName != '' && typeof(uRe[p]) != 'undefined' ) {
                                 _data[ pName ] = uRe[p];
@@ -472,9 +478,9 @@ function Routing() {
                                     request.params[pName] = uRe[p];
                                 }
                             }
-                        }                       
+                        }
                     }
-                    
+
                     // If validator.query has data, _data should inherit from request data
                     _data = merge(_data, JSON.clone(request[method]) || {} );
                     // This test is to initialize query.data[key] to null by default
@@ -482,20 +488,20 @@ function Routing() {
                         // init default value for unlisted variable/param
                         _data[key] = null;
                     }
-                    
-                    _rule[key]  = _ruleObj;                
+
+                    _rule[key]  = _ruleObj;
                     if (!isGFFCtx) {
                         _validator  = new Validator('routing', _data, null, _rule );
                     } else {
                         _validator  = new Validator(_data);
                     }
-                    
+
                     if (_ruleObj.count() == 0 ) {
                         console.error('Route validation failed '+ params.rule);
                         --score;
                         r++;
                         continue;
-                    }                    
+                    }
                     // for each validation rule
                     for (let rule in _ruleObj) {
                         // updating query.data
@@ -507,8 +513,8 @@ function Routing() {
                             _result = await _validator[key][rule].apply(_validator[key], _ruleObj[rule]);
                         } else {
                             _result = await _validator[key][rule](_ruleObj[rule], request, response, next);
-                        }                     
-                        
+                        }
+
                         //let condition = _ruleObj[rule].validIf.replace(new RegExp('\\$isValid'), _result.isValid);
                         // if ( eval(condition)) {
                         if ( !_result.isValid ) {
@@ -524,7 +530,7 @@ function Routing() {
         }
 
         foundRoute.past     = (score === maxLen) ? true : false;
-        
+
         if (foundRoute.past) {
             // attaching routing description for this request
             //request.routing = params; // can be retried in controller with: req.routing
@@ -532,7 +538,7 @@ function Routing() {
             request.routing = checkRouteParams(params, request[method]);
             foundRoute.request  = request;
         }
-        
+
 
         return foundRoute;
     };
@@ -563,7 +569,7 @@ function Routing() {
             , flags     = null
             , key       = null
             , tested    = false
-            
+
             , _validator    = null
             , _data         = null
             , _ruleObj      = null
@@ -573,57 +579,57 @@ function Routing() {
             // request method
             , requestMethod        = request.method.toLowerCase()
         ;
-        
+
         if (!_param.length) return false;
 
         //  if custom path, path rewrite
         if (params.param.path && regex.test(params.param.path)) {
             params.param.path = params.param.path.replace(regex, urlVal);
         }
-        
+
         //  if custom namespace, namespace rewrite
-        if (params.param.namespace && regex.test(params.param.namespace)) {            
-            params.param.namespace = params.param.namespace.replace(regex, urlVal);            
+        if (params.param.namespace && regex.test(params.param.namespace)) {
+            params.param.namespace = params.param.namespace.replace(regex, urlVal);
         }
-        
+
         //  if custom file, file rewrite
-        // if (params.param.file && regex.test(params.param.file)) {            
-        //     params.param.file = params.param.file.replace(regex, urlVal);            
+        // if (params.param.file && regex.test(params.param.file)) {
+        //     params.param.file = params.param.file.replace(regex, urlVal);
         // }
         // file is handle like url replacement (path is like pathname)
-        if (typeof (params.param.file) != 'undefined' && /:/.test(params.param.file)) {
-            var _regex = new RegExp('(:'+urlVar+'/|:'+urlVar+'$)', 'g'); 
-            replacement.variable = urlVal;        
+        if ( typeof(params.param.file) != 'undefined' && /\:/.test(params.param.file)) {
+            var _regex = new RegExp('(:'+urlVar+'/|:'+urlVar+'$)', 'g');
+            replacement.variable = urlVal;
             params.param.file = params.param.file.replace( _regex, replacement );
         }
 
         //  if custom title, title rewrite
-        if (params.param.title && regex.test(params.param.title)) {    
+        if (params.param.title && regex.test(params.param.title)) {
             params.param.title = params.param.title.replace(regex, urlVal);
         }
 
         if (_param.length == 1) { // fast one
-            
+
             re = new RegExp( _param[0]);
             matched = (_param.indexOf(urlVar) > -1) ? _param.indexOf(urlVar) : false;
-            
+
             if (matched === false ) {
                 // In order to support rules defined like :
                 //      { params.url }  => `/section/:name/page:number`
                 //      { request.url } => `/section/plante/page4`
                 //
                 //      with keys = [ ":name", ":number" ]
-                
+
                 if ( urlVar.match(re) ) {
                     matched = 0;
                 }
             }
-            
+
 
             if (matched === false) return matched;
             // filter on method
             if (params.method.toLowerCase() !== requestMethod) return false;
-            
+
             if ( typeof(request[requestMethod]) == 'undefined' ) {
                 request[requestMethod] = {}
             }
@@ -635,7 +641,7 @@ function Routing() {
             regex = params.requirements[key];
             if (/^\//.test(regex)) {
                 re      = regex.match(/\/(.*)\//).pop();
-                flags   = regex.replace('/' + re + '/', '');                
+                flags   = regex.replace('/' + re + '/', '');
 
                 tested  = new RegExp(re, flags).test(urlVal)
             } else if ( /^validator\:\:/.test(regex) && urlVal) {
@@ -644,11 +650,11 @@ function Routing() {
                  *      "id" : "/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i",
                  *      "email": "validator::{ isEmail: true, isString: [7] }"
                  *  }
-                 * 
+                 *
                  * e.g.: tested = new Validator('routing', _data, null, {email: {isEmail: true, subject: \"Anything\"}} ).isEmail().valid;
-                 */ 
-                _data = {}; _ruleObj = {}; _rule = {}; str = '';                
-                urlVar.replace( new RegExp('[^'+ key +']','g'), function(){ str += arguments[0] });                
+                 */
+                _data = {}; _ruleObj = {}; _rule = {}; str = '';
+                urlVar.replace( new RegExp('[^'+ key +']','g'), function(){ str += arguments[0] });
                 _data[key]  = urlVal.replace( new RegExp(str, 'g'), '');
                 try {
                     //_ruleObj    = JSON.parse(regex.split(/::/).splice(1)[0].replace(/([^\W+ true false])+(\w+)/g, '"$&"'));
@@ -656,11 +662,11 @@ function Routing() {
                     regex.split(/::/).splice(1)[0]
                         .replace(/([^\:\"\s+](\w+))\:/g, '"$1":') // { query: { validIf: true }} => { "query": { "validIf": true }}
                         .replace(/([^\:\"\s+](\w+))\s+\:/g, '"$1":') // note the space between `validIf` & `:` { query: { validIf : true }} => { "query": { "validIf": true }}
-                    );                    
+                    );
                 } catch (err) {
                     throw err;
                 }
-                //_ruleObj    = JSON.parse(regex.split(/::/).splice(1)[0].replace(/([^\W+ true false])+(\w+)/g, '"$&"'));       
+                //_ruleObj    = JSON.parse(regex.split(/::/).splice(1)[0].replace(/([^\W+ true false])+(\w+)/g, '"$&"'));
                 if (typeof(_ruleObj.query) != 'undefined' && typeof(_ruleObj.query.data) != 'undefined') {
                     // since we only have one param
                     // :var1 == :var1
@@ -670,7 +676,7 @@ function Routing() {
                         request.params[key] = _data[key];
                     }
                 }
-                _rule[key]  = _ruleObj;                
+                _rule[key]  = _ruleObj;
                 _validator  = new Validator('routing', _data, null, _rule );
                 if (_ruleObj.count() == 0 ) {
                     console.error('Route validation failed '+ params.rule);
@@ -681,7 +687,7 @@ function Routing() {
                         await _validator[key][rule].apply(_validator[key], _ruleObj[rule]);
                     } else {
                         await _validator[key][rule](_ruleObj[rule], request, response, next);
-                    }                    
+                    }
                 }
                 tested = _validator.isValid();
             } else {
@@ -694,7 +700,7 @@ function Routing() {
                 typeof(params.requirements[key]) != 'undefined' &&
                 typeof(request.params) != 'undefined' &&
                 tested
-            ) {                
+            ) {
                 request.params[key] = urlVal;
                 if ( typeof(request[requestMethod][key]) == 'undefined' ) {
                     request[requestMethod][key] = urlVal;
@@ -744,22 +750,22 @@ function Routing() {
                          *      "id" : "/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i",
                          *      "email": "validator::{ isEmail: true, isString: [7] }"
                          *  }
-                         * 
+                         *
                          * e.g.: tested = new Validator('routing', _data, null, {email: {isEmail: true}} ).isEmail().valid;
-                         */ 
-                        _data = {}; _ruleObj = {}; _rule = {}; str = '';                
-                        urlVar.replace( new RegExp('[^'+ key[0] +']','g'), function(){ str += arguments[0]  });                
+                         */
+                        _data = {}; _ruleObj = {}; _rule = {}; str = '';
+                        urlVar.replace( new RegExp('[^'+ key[0] +']','g'), function(){ str += arguments[0]  });
                         _data[key[0]]  = urlVal.replace( new RegExp(str, 'g'), '');
-                        _ruleObj    = JSON.parse(regex.split(/::/).splice(1)[0].replace(/([^\W+ true false])+(\w+)/g, '"$&"'));       
-                        _rule[key[0]]  = _ruleObj;                
+                        _ruleObj    = JSON.parse(regex.split(/::/).splice(1)[0].replace(/([^\W+ true false])+(\w+)/g, '"$&"'));
+                        _rule[key[0]]  = _ruleObj;
                         _validator  = new Validator('routing', _data, null, _rule );
-                        
+
                         for (let rule in _ruleObj) {
                             if (Array.isArray(_ruleObj[rule])) { // has args
                                 _validator[key[0]][rule].apply(_validator[key[0]], _ruleObj[rule])
                             } else {
                                 _validator[key[0]][rule](_ruleObj[rule])
-                            }                    
+                            }
                         }
                         tested = _validator.isValid();
                     } else {
@@ -817,9 +823,9 @@ function Routing() {
 
         return false
     }
-    
+
     var replacement = function(matched){
-        return ( /\/$/.test(matched) ? replacement.variable+ '/': replacement.variable )            
+        return ( /\/$/.test(matched) ? replacement.variable+ '/': replacement.variable )
     };
     var checkRouteParams = function(route, params) {
         var variable        = null
@@ -833,48 +839,48 @@ function Routing() {
         ;
         for (p in route.param) {
             if ( typeof(params) != 'undefined' && typeof(params[p]) == 'undefined' ) continue;
-            
+
             if ( /^:/.test(route.param[p]) ) {
                 variable = route.param[p].substr(1);
-                
+
                 if ( typeof(params) != 'undefined' && typeof(params[variable]) != 'undefined' ) {
-                    
-                    regex = new RegExp('(:'+variable+'/|:'+variable+'$)', 'g');                   
-                    
 
-                    if ( typeof(route.param.path) != 'undefined' && /:/.test(route.param.path) ) {
+                    regex = new RegExp('(:'+variable+'/|:'+variable+'$)', 'g');
+
+
+                    if ( typeof(route.param.path) != 'undefined' && /\:/.test(route.param.path) ) {
                         route.param.path = route.param.path.replace( regex, params[variable]);
                     }
-                    if (typeof (route.param.title) != 'undefined' && /:/.test(route.param.title)) {
+                    if (typeof (route.param.title) != 'undefined' && /\:/.test(route.param.title)) {
                         route.param.title = route.param.title.replace( regex, params[variable]);
                     }
-                    if (typeof (route.param.namespace) != 'undefined' && /:/.test(route.param.namespace)) {
+                    if (typeof (route.param.namespace) != 'undefined' && /\:/.test(route.param.namespace)) {
                         route.param.namespace = route.param.namespace.replace( regex, params[variable]);
                     }
                     // file is handle like url replacement (path is like pathname)
-                    if (typeof (route.param.file) != 'undefined' && /:/.test(route.param.file)) {
-                        replacement.variable = params[variable];        
+                    if (typeof (route.param.file) != 'undefined' && /\:/.test(route.param.file)) {
+                        replacement.variable = params[variable];
                         route.param.file = route.param.file.replace( regex, replacement );
                     }
-                                        
-                    if ( /\,/.test(route.url) ) {                        
+
+                    if ( /\,/.test(route.url) ) {
                         urls = route.url.split(/\,/g);
                         i = 0; len = urls.length;
                         for (; i < len; ++i) {
-                            replacement.variable = params[variable]; 
+                            replacement.variable = params[variable];
                             urls[i] = urls[i].replace( regex, replacement );
                         }
                         route.url = urls.join(',');
-                    } else {        
-                        replacement.variable = params[variable];        
+                    } else {
+                        replacement.variable = params[variable];
                         route.url = route.url.replace( regex, replacement );
                     }
                 }
             }
         }
-        
+
         // Selecting url in case of multiple urls & optional requirmements
-        if ( urls ) {                      
+        if ( urls ) {
             i = 0; len = urls.length;
             var rawUrlVars = null
                 , rawUrlScore = null
@@ -901,8 +907,8 @@ function Routing() {
                     route.urlIndex = i;
                 }
             }
-        } 
-        
+        }
+
         return route;
     }
 
@@ -916,7 +922,7 @@ function Routing() {
      * @returns {object} route
      * */
     self.getRoute = function(rule, params, urlIndex) {
-        
+
         var config = null;
         if (isGFFCtx) {
             config = window.gina.config;
@@ -926,13 +932,13 @@ function Routing() {
                 config.getRouting = getContext('gina').Config.instance.getRouting;
             }
         }
-        
+
         var env         = config.env || GINA_ENV  // by default, takes the current bundle
             , envTmp    = null
             //, scheme    = null
             , bundle    = config.bundle // by default, takes the current bundle
         ;
-        
+
         if ( !/\@/.test(rule) && typeof(bundle) != 'undefined' && bundle != null) {
             rule = rule.toLowerCase()
             rule += '@' + bundle
@@ -957,22 +963,16 @@ function Routing() {
 
             rule = arr[0].toLowerCase() +'@'+ bundle;
         }
-        
-        
+
+
         var routing = config.getRouting(bundle, env);
 
         if ( typeof(routing[rule]) == 'undefined' ) {
             throw new Error('[ RoutingHelper::getRouting(rule, params) ] : `' +rule + '` not found !')
         }
 
-        var route = JSON.clone(routing[rule]);
-        var variable    = null
-            , regex     = null
-            , urls      = null
-            , i         = null
-            , len       = null
-            , msg       = null
-        ;
+        var route   = JSON.clone(routing[rule]);
+        var msg     = null;
         route = checkRouteParams(route, params);
 
         if ( /\,/.test(route.url) ) {
@@ -981,64 +981,92 @@ function Routing() {
                 delete route.urlIndex;
             }
             urlIndex = ( typeof(urlIndex) != 'undefined' ) ? urlIndex : 0;
-            route.url = route.url.split(/,/g)[urlIndex];            
+            route.url = route.url.split(/,/g)[urlIndex];
         }
         // fix url in case of empty param value allowed by the routing rule
         // to prevent having a folder.
         // eg.: {..., id: '/^\\s*$/'} => {..., id: ''} => /path/to/ becoming /path/to
         if ( /\/$/.test(route.url) && route.url != '/' )
             route.url = route.url.substr(0, route.url.length-1);
-        
+
         // Completeting url with extra params e.g.: ?param1=val1&param2=val2
         if ( /GET/i.test(route.method) && typeof(params) != 'undefined' ) {
-            var queryParams = '?', maskedUrl = routing[rule].url;
-            //self.reservedParams;
+            var queryParams = '?'
+                , maskedUrl = routing[rule].url
+            ;
+
+            // in route.rule params
+            var extracted = [], i = 0;
             for (let r in route.param) {
                 if ( self.reservedParams.indexOf(r) > -1 || new RegExp(route.param[r]).test(maskedUrl) )
                     continue;
-                if (typeof(params[r]) != 'undefined' )
-                    queryParams += r +'='+ encodeURIComponent(params[r])+ '&';
+                if (typeof(params[r]) != 'undefined' ) {
+                    queryParams += r +'='+ encodeRFC5987ValueChars(params[r])+ '&';
+                    extracted[i] = params[r];
+                    ++i;
+                }
             }
-            
+
+            // extra params ( not declared in the rule, but added by getUrl() )
+            for (let p in params) {
+                if (
+                    self.reservedParams.indexOf(p) > -1
+                    || typeof(route.requirements[p]) != 'undefined'
+                    || extracted.indexOf(p) > -1
+                ) {
+                    continue;
+                }
+                if ( typeof(params[p]) == 'object' ) {
+                    queryParams += p +'='+ encodeRFC5987ValueChars(JSON.stringify(params[p])) +'&';
+                } else {
+                    queryParams += p +'='+ params[p] +'&';
+                }
+            }
+            maskedUrl = null;
+            extracted = null;
+            i = null;
+
             if (queryParams.length > 1) {
                 queryParams = queryParams.substring(0, queryParams.length-1);
+
                 route.url += queryParams;
             }
+            queryParams = null;
         }
-        
+
         // recommanded for x-bundle coms
         // leave `ignoreWebRoot` empty or set it to false for x-bundle coms
         route.toUrl = function (ignoreWebRoot) {
-            
+
             var urlProps = null;
             if ( /^redirect$/i.test(this.param.control) ) {
                 urlProps = self.getUrlProps(this.bundle, (env||GINA_ENV));
             }
-            
+
             var wroot       = this.webroot || urlProps.webroot
                 , hostname  = this.hostname || urlProps.hostname
                 , path      = this.url
             ;
-            
+
             this.url = ( typeof(ignoreWebRoot) != 'undefined' && ignoreWebRoot == true ) ? path.replace(wroot, '/') : path;
 
             return hostname + this.url
         };
-        
+
         /**
          * request current url
-         * 
-         * 
-         * 
+         *
+         *
+         *
          * @param {boolean} [ignoreWebRoot]
          * @param {object} [options] - see: https://nodejs.org/api/https.html#https_new_agent_options
          * @param {object} [_this] - current context: only used when `promisify`is used
-         * 
+         *
          * @callback {callback} [cb] - see: https://nodejs.org/api/https.html#https_new_agent_options
          *      @param {object} res
          */
         route.request = function(ignoreWebRoot, options) {
-            
+
             var cb = null, _this = null;
             if ( typeof(arguments[arguments.length-1]) == 'function' ) {
                 cb = arguments[arguments.length-1];
@@ -1046,14 +1074,14 @@ function Routing() {
             if ( typeof(arguments[2]) == 'object' ) {
                 _this = arguments[2];
             }
-            
+
             var wroot       = this.webroot || _this.webroot
                 , hostname  = this.hostname || _this.hostname
                 , url       = ( typeof(ignoreWebRoot) != 'undefined' && ignoreWebRoot == true ) ? path.replace(wroot, '/') : this.url || _this.url
             ;
-            
+
             var scheme = ( /^https/.test(hostname) ) ? 'https' : 'http';
-            
+
             if (isGFFCtx) {
                 var target = ( typeof(options) != 'undefined' && typeof(options.target) != 'undefined' ) ? options.target : "_self";
                 window.open(url, target)
@@ -1063,11 +1091,11 @@ function Routing() {
                     // create an agent just for this request
                     options.agent = false;
                 }
-                var agent = require(''+scheme);                
-                var onAgentResponse = function(res) {  
-                                     
+                var agent = require(''+scheme);
+                var onAgentResponse = function(res) {
+
                     var data = '', err = false;
-                    
+
                     res.on('data', function (chunk) {
                         data += chunk;
                     });
@@ -1091,26 +1119,26 @@ function Routing() {
                                 err = parseError
                             }
                         }
-                        if (err) {                          
+                        if (err) {
                             cb(err);
                             return;
                         }
-                                               
+
                         cb(false, data);
                         return;
                     });
                 }
-                if (cb) {                 
+                if (cb) {
                     agent.get(url, options, onAgentResponse);
                 } else {
                     // just throw the request without waiting/handling response
                     agent.get(url, options);
-                }           
+                }
             }
-            return;            
-                         
+            return;
+
         } // EO route.request()
-        
+
         if ( /\:/.test(route.url) ) {
             var paramList = route.url
                                 .match(/(\:(.*)\/|\:(.*)$)/g)
@@ -1134,21 +1162,21 @@ function Routing() {
         // adding hash if found
         if (hash)
             url += hash;
-        
+
         route.url = url;
         // recommanded for x-bundle coms
         // leave `ignoreWebRoot` empty or set it to false for x-bundle coms
-        route.toUrl = function (ignoreWebRoot) {                
+        route.toUrl = function (ignoreWebRoot) {
             var wroot       = this.webroot
                 , hostname  = this.hostname
                 , path      = this.url
             ;
-            
+
             this.url = ( typeof(ignoreWebRoot) != 'undefined' && ignoreWebRoot == true ) ? path.replace(wroot, '/') : path;
 
             return hostname + this.url
         };
-        
+
         return route
     }
 
@@ -1161,18 +1189,18 @@ function Routing() {
      * @param {string} url e.g.: /webroot/some/url/path or http
      * @param {string} [bundle] targeted bundle
      * @param {string} [method] request method (GET|PUT|PUT|DELETE) - GET is set by default
-     * @param {object} [request] 
+     * @param {object} [request]
      * @param {boolean} [isOverridinMethod] // will replace request.method by the provided method - Used for redirections
-     * 
+     *
      * @returns {object|boolean} route - when route is found; `false` when not found
      * */
-    
+
     self.getRouteByUrl = function (url, bundle, method, request, isOverridinMethod) {
-        
+
         if (
-            arguments.length == 2 
-            && typeof(arguments[1]) != 'undefined' 
-            && self.allowedMethods.indexOf(arguments[1].toLowerCase()) > -1 
+            arguments.length == 2
+            && typeof(arguments[1]) != 'undefined'
+            && self.allowedMethods.indexOf(arguments[1].toLowerCase()) > -1
         ) {
             method = arguments[1];
             bundle = undefined;
@@ -1185,24 +1213,24 @@ function Routing() {
             , hostname          = null
             , host              = null
         ;
-        
+
         if ( /\#/.test(url) && url.length > 1 ) {
             var urlPart = url.split(/\#/);
             url     = urlPart[0];
             hash    = '#' + urlPart[1];
-            
+
             urlPart = null;
         }
-        
+
         // fast method
         if (
-            arguments.length == 1 
-            && typeof(arguments[0]) != 'undefined'            
+            arguments.length == 1
+            && typeof(arguments[0]) != 'undefined'
         ) {
             if ( !/^(https|http)/i.test(url) && !/^\//.test(url)) {
                 url = '/'+ url;
             }
-            
+
             webroot = '/' + url.split(/\//g)[1];
             if (isGFFCtx) {
                 reverseRouting  = gina.config.reverseRouting;
@@ -1216,24 +1244,24 @@ function Routing() {
                 host        = infos.host;
                 hostname    = infos.hostname;
                 infos       = null;
-            }          
+            }
         }
-        
+
         isOverridinMethod = ( typeof(arguments[arguments.length-1]) != 'boolean') ? false : arguments[arguments.length-1];
 
-        var matched             = false            
+        var matched             = false
             , config            = null
             , env               = null
             , prefix            = null
             , pathname          = null
             , params            = null
             , isRoute           = null
-            , foundRoute        = null            
-            , routeObj          = null            
+            , foundRoute        = null
+            , routeObj          = null
         ;
-        
-        
-        
+
+
+
         var isMethodProvidedByDefault = ( typeof(method) != 'undefined' ) ? true : false;
 
         if (isGFFCtx) {
@@ -1257,18 +1285,18 @@ function Routing() {
         } else {
 
             var gnaCtx      = getContext('gina');
-            
+
             config          = gnaCtx.config;
             bundle          = (typeof (bundle) != 'undefined') ? bundle : config.bundle;
             env             = config.env;
             routing         = config.getRouting(bundle);
-            
-            
+
+
 
             hostname        = config.envConf[bundle][env].hostname;
             webroot         = config.envConf[bundle][env].server.webroot;
             prefix          = hostname + webroot;
-            
+
             if ( !request ) {
                 request = {
                     routing: {},
@@ -1286,15 +1314,15 @@ function Routing() {
 
         pathname    = url.replace( new RegExp('^('+ hostname +'|'+hostname.replace(/\:\d+/, '') +')' ), '');
         if ( typeof(request.routing.path) == 'undefined' )
-            request.routing.path = unescape(pathname);
+            request.routing.path = decodeURI(pathname);
         method      = ( typeof(method) != 'undefined' ) ? method.toLowerCase() : 'get';
-                
+
         if (isMethodProvidedByDefault) {
             // to handle 303 redirect like PUT -> GET
             request.originalMethod = request.method;
-            
+
             request.method = method;
-            request.routing.path = unescape(pathname)
+            request.routing.path = decodeURI(pathname)
         }
         // last method check
         if ( !request.method)
@@ -1302,8 +1330,8 @@ function Routing() {
 
         //  getting params
         params = {};
-        
-        
+
+
 
         var paramsList = null;
         var re = new RegExp(method, 'i');
@@ -1318,18 +1346,18 @@ function Routing() {
                 if (routing[name].bundle != bundle) continue;
 
                 // method filter
-                localMethod = routing[name].method;             
+                localMethod = routing[name].method;
                 if ( /\,/.test( localMethod ) && re.test(localMethod) ) {
                     localMethod = request.method
-                } 
+                }
                 if (typeof (routing[name].method) != 'undefined' && !re.test(localMethod)) continue;
-                
-                //Preparing params to relay to the core/router.                
+
+                //Preparing params to relay to the core/router.
                 params = {
                     method              : localMethod,
                     requirements        : routing[name].requirements,
                     namespace           : routing[name].namespace || undefined,
-                    url                 : unescape(pathname), /// avoid %20
+                    url                 : decodeURI(pathname), /// avoid %20
                     rule                : routing[name].originalRule || name,
                     param               : routing[name].param,
                     //middleware: routing[name].middleware,
@@ -1340,8 +1368,8 @@ function Routing() {
 
                 // normal case
                 //Parsing for the right url.
-                try {                                        
-                    
+                try {
+
                     isRoute = self.compareUrls(params, routing[name].url, request);
 
                     if (isRoute.past) {
@@ -1361,96 +1389,96 @@ function Routing() {
             } //EO for break out
 
         if (!matched) {
-            if (isGFFCtx) {  
-                var urlHasChanged = false;              
-                if ( 
-                    url == '#' 
-                    && /GET/i.test(method) 
-                    && isMethodProvidedByDefault 
+            if (isGFFCtx) {
+                var urlHasChanged = false;
+                if (
+                    url == '#'
+                    && /GET/i.test(method)
+                    && isMethodProvidedByDefault
                     || /^404\:/.test(url)
                 ) {
                     url = location.pathname;
                     urlHasChanged = true;
                 }
-                
+
                 if ( typeof(self.notFound) == 'undefined' ) {
                     self.notFound = {}
                 }
-                
+
                 var notFound = null, msg = '[ RoutingHelper::getRouteByUrl(rule[, bundle, method]) ] : route [ %r ] is called but not found inside your view: `' + url + '` !';
                 if ( gina.hasPopinHandler && gina.popinIsBinded ) {
                     notFound = gina.popin.getActivePopin().target.innerHTML.match(/404\:\[\w+\][a-z 0-9-_@]+/);
                 } else {
                     notFound = document.body.innerHTML.match(/404\:\[\w+\][a-z 0-9-_@]+/);
                 }
-               
+
                 notFound = (notFound && notFound.length > 0) ? notFound[0] : null;
-                
+
                 if ( notFound && isMethodProvidedByDefault && urlHasChanged ) {
-                                        
-                    var m = notFound.match(/\[\w+\]/)[0];                    
-                    
+
+                    var m = notFound.match(/\[\w+\]/)[0];
+
                     notFound = notFound.replace('404:'+m, m.replace(/\[|\]/g, '')+'::' );
-                    
+
                     msg = msg.replace(/\%r/, notFound.replace(/404\:\s+/, ''));
-                    
+
                     if (typeof(self.notFound[notFound]) == 'undefined') {
-                        self.notFound[notFound] = { 
+                        self.notFound[notFound] = {
                             count: 1,
-                            message: msg 
+                            message: msg
                         };
                     } else if ( isMethodProvidedByDefault && typeof(self.notFound[notFound]) != 'undefined' ) {
                         ++self.notFound[notFound].count;
                     }
-                                                
-                    return false  
-                } 
-                
-                notFound = null;     
-                                               
-                var altRule = gina.config.reverseRouting[url] || null;                
+
+                    return false
+                }
+
+                notFound = null;
+
+                var altRule = gina.config.reverseRouting[url] || null;
                 if (
-                    !notFound 
+                    !notFound
                     && altRule
                     && typeof(altRule) != 'undefined'
                     && altRule.split(/\@(.+)$/)[1] == bundle
                 ) {
-                    
+
                     notFound = altRule;
                     if ( typeof(self.notFound[notFound]) == 'undefined' ) {
-                        
+
                         msg = msg.replace(/\%r/, method.toUpperCase() +'::'+ altRule);
-                        
-                        self.notFound[notFound] = { 
+
+                        self.notFound[notFound] = {
                             count: 1,
-                            message: msg 
+                            message: msg
                         };
-                        //console.warn(msg);   
+                        //console.warn(msg);
                     } else if ( isMethodProvidedByDefault && typeof(self.notFound[notFound]) != 'undefined' ) {
                         ++self.notFound[notFound].count;
                     }
-                                                    
+
                     return false
                 }
-                
+
                 // forms
                 var altRoute = self.compareUrls(params, url, request) || null;
                 if(altRoute.past && isMethodProvidedByDefault) {
                     notFound = method.toUpperCase() +'::'+ altRoute.request.routing.rule;
                     if ( typeof(self.notFound[notFound]) == 'undefined' ) {
                         msg = msg.replace(/\%r/, notFound);
-                        //console.warn(msg);  
+                        //console.warn(msg);
                     } else {
                         ++self.notFound[notFound].count;
                     }
-                                                     
+
                     return false
-                }                                             
+                }
                 return false
             }
 
-            
-            console.warn( new Error('[ RoutingHelper::getRouteByUrl(rule[, bundle, method, request]) ] : route not found for url: `' + url + '` !').stack );            
+
+            console.warn( new Error('[ RoutingHelper::getRouteByUrl(rule[, bundle, method, request]) ] : route not found for url: `' + url + '` !').stack );
             return false;
         } else {
             // fix url in case of empty param value allowed by the routing rule
@@ -1461,21 +1489,21 @@ function Routing() {
             // adding hash if found
             if (hash)
                 url += hash;
-            
+
             route.url = url;
             // recommanded for x-bundle coms
             // leave `ignoreWebRoot` empty or set it to false for x-bundle coms
-            route.toUrl = function (ignoreWebRoot) {                
+            route.toUrl = function (ignoreWebRoot) {
                 var wroot       = this.webroot
                     , hostname  = this.hostname
                     , path      = this.url
                 ;
-                
+
                 this.url = ( typeof(ignoreWebRoot) != 'undefined' && ignoreWebRoot == true ) ? path.replace(wroot, '/') : path;
-    
+
                 return hostname + this.url
             };
-            
+
             return route
         }
     }
@@ -1487,6 +1515,6 @@ if ((typeof (module) !== 'undefined') && module.exports) {
     // Publish as node.js module
     module.exports = Routing()
 } else if (typeof (define) === 'function' && define.amd) {
-    // Publish as AMD module    
-    define('utils/routing', ['require', 'utils/form-validator', 'utils/merge'], function() { return Routing() })
+    // Publish as AMD module
+    define('lib/routing', ['require', 'lib/form-validator', 'lib/merge'], function() { return Routing() })
 }