gina 0.1.6-alpha.16 → 0.1.6-alpha.161

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/routing/src/main.js

@@ -1,6 +1,6 @@
 /*
  * This file is part of the gina package.
- * Copyright (c) 2009-2023 Rhinostone <contact@gina.io>
+ * Copyright (c) 2009-2026 Rhinostone <contact@gina.io>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -16,15 +16,33 @@
 
 function Routing() {
 
-    var isGFFCtx    = ((typeof (module) !== 'undefined') && module.exports) ? false :  true;
+    var isGFFCtx    = ((typeof (module) !== 'undefined') && module.exports) ? false : true;
     var self        = {
         allowedMethods: ['get', 'post', 'put', 'delete'],
         reservedParams: ['controle', 'file','title', 'namespace', 'path'],
         notFound: {}
     };
 
+    self.getInstance = function(params) {
+        return Routing.instance;
+    }
+
+
+    if ( typeof(Routing.initialized) == 'undefined' ) {
+        Routing.initialized     = true;
+        Routing.instance        = self;
+        Routing._cached         = [];
+        Routing._cachedRoutes   = {};
+    } else {
+        self = self.getInstance();
+        return self;
+    }
+
+
     self.allowedMethodsString   = self.allowedMethods.join(',');
 
+
+
     // loading lib & plugins
     var plugins     = null
         , inherits  = null
@@ -44,6 +62,7 @@ function Routing() {
     }
     // BO - In case of partial rendering whithout handler defined for the partial
     else {
+
         if ( !merge || typeof(merge) != 'function' ) {
             merge = require('lib/merge');
         }
@@ -71,7 +90,7 @@ function Routing() {
             urlProps.hostname = config.hostname;
             if ( typeof(bundle) != 'undefined' ) {
                 // get from webroot
-                _route = routing.getRoute('webroot@'+ bundle);
+                _route = this.getRoute('webroot@'+ bundle);
                 urlProps.hostname   = _route.hostname;
                 urlProps.host       = _route.host;
                 urlProps.webroot    = _route.webroot;
@@ -91,6 +110,7 @@ function Routing() {
             urlProps.hostname   = config.envConf[bundle][env].hostname;
             urlProps.host       = config.envConf[bundle][env].host;
             urlProps.webroot    = config.envConf[bundle][env].server.webroot;
+            console.debug("[self.getUrlProps][isProxyHost = "+ getContext('isProxyHost') +"] hostname ", config.envConf[bundle][env].hostname, vs, process.gina.PROXY_HOSTNAME);
         }
 
         return urlProps;
@@ -130,6 +150,80 @@ function Routing() {
 
     // }
 
+    /**
+     * Cache route information to be retrieved later
+     *
+     * @param {string} routeId - e.g.: GET:/index
+     * @param {string} name - route name
+     * @param {object} routeObject - routing[name]
+     * @param {object} params - route params
+     * @param {object} methodParams - GET|PUT ...
+     */
+    self.cache = function(routeId, name, routeObject, params, methodParams) {
+        if ( Routing._cached.indexOf(routeId) == -1 ) {
+            Routing._cached.push(routeId);
+            Routing._cachedRoutes[routeId] = {
+                name            : name,
+                routing         : routeObject,
+                params          : params,
+                methodParams    : methodParams
+            };
+        }
+    }
+
+    /**
+     * Get cached route information to be retrieved later
+     *
+     * @param {string} routeId - e.g.: GET:/index
+     * @param {string} name - route name
+     * @param {object} routeObject - routing[name]
+     * @param {object} params - route params
+     */
+    self.getCached = function(routeId, req) {
+        if ( Routing._cached.indexOf(routeId) > -1 ) {
+
+            var cachedRoute = Routing._cachedRoutes[routeId];
+            var method      = req.method.toLowerCase();
+
+
+            // routeObject
+            var routeObject       = JSON.clone(cachedRoute.routing);
+            var params = {
+                method              : method,
+                requirements        : routeObject.requirements,
+                namespace           : routeObject.namespace || undefined,
+                url                 : decodeURI(req.url), /// avoid %20
+                rule                : routeObject.originalRule || cachedRoute.name,
+
+                param               : routeObject.param,
+
+                middleware          : routeObject.middleware,
+                bundle              : routeObject.bundle,
+                isXMLRequest        : req.isXMLRequest,
+                isWithCredentials   : req.isWithCredentials
+            };
+            if ( typeof(routeObject.rule) == 'undefined' && typeof(params.rule) != 'undefined' ) {
+                routeObject.rule = params.rule;
+            }
+            if ( typeof(routeObject.cache) != 'undefined' ) {
+                params.cache = routeObject.cache;
+            }
+
+            // isRoute
+            return self.compareUrls(params, routeObject.url, req);
+        }
+
+        return null
+    }
+
+    self.invalidateCached = function(routeId) {
+        if ( Routing._cached.indexOf(routeId) > -1 ) {
+            // routeObject
+            Routing._cached.splice( Routing._cached.indexOf(routeId), 1);
+            delete Routing._cachedRoutes[routeId];
+        }
+    }
+
     /**
      * Compare urls
      *
@@ -172,9 +266,11 @@ function Routing() {
             return foundRoute;
         }
 
+
         return await parseRouting(params, url, request, response, next);
     };
 
+
     /**
      * Check if rule has params
      *
@@ -258,13 +354,13 @@ function Routing() {
                         ++score;
                         continue;
                     }
-                    let _key = uRo[p].substr(1);
+                    let _key = uRo[p].substring(1);
                     if ( typeof(params.requirements[_key]) == 'undefined' ) {
                         continue;
                     }
                     let condition = params.requirements[_key];
                     if ( /^\//.test(condition) ) {
-                        condition = condition.substr(1, condition.lastIndexOf('/')-1);
+                        condition = condition.substring(1, condition.lastIndexOf('/')-1);
                     } else if ( /^validator\:\:/.test(condition) && await fitsWithRequirements(uRo[p], uRe[p], params, request, response, next) ) {
                         ++score;
                         continue;
@@ -275,7 +371,7 @@ function Routing() {
                         && new RegExp(condition).test(uRe[p])
                     ) {
                         ++score;
-                        request[method][uRo[p].substr(1)] = uRe[p];
+                        request[method][uRo[p].substring(1)] = uRe[p];
                     }
                 }
                 hasAlreadyBeenScored = true;
@@ -553,7 +649,7 @@ function Routing() {
                 request[requestMethod] = {}
             }
 
-            key     = _param[matched].substr(1);
+            key     = _param[matched].substring(1);
             // escaping `\` characters
             // TODO - remove comment : all regex requirement must start with `/`
             //regex   = ( /\\/.test(params.requirements[key]) ) ? params.requirements[key].replace(/\\/, '') : params.requirements[key];
@@ -655,7 +751,7 @@ function Routing() {
                 } else if (c > (tplUrl.indexOf(keys[0]) + keys[0].length)) {
 
                     regex = params.requirements[keys[0]];
-                    urlVal = strVal.substr(0, strVal.length);
+                    urlVal = strVal.substring(0, strVal.length);
 
                     if (/^\//.test(regex)) {
                         re      = regex.match(/\/(.*)\//).pop();
@@ -692,7 +788,7 @@ function Routing() {
                     }
 
                     if (tested) {
-                        values[keys[0].substr(1)] = urlVal
+                        values[keys[0].substring(1)] = urlVal
                     } else {
                         return false
                     }
@@ -711,7 +807,7 @@ function Routing() {
                 if (c == posLen - 1) {
 
                     regex = params.requirements[keys[0]];
-                    urlVal = strVal.substr(0, strVal.length);
+                    urlVal = strVal.substring(0, strVal.length);
 
                     if (/^\//.test(regex)) {
                         re = regex.match(/\/(.*)\//).pop();
@@ -724,7 +820,7 @@ function Routing() {
                     }
 
                     if (tested) {
-                        values[keys[0].substr(1)] = urlVal
+                        values[keys[0].substring(1)] = urlVal
                     } else {
                         return false
                     }
@@ -746,6 +842,14 @@ function Routing() {
     var replacement = function(matched){
         return ( /\/$/.test(matched) ? replacement.variable+ '/': replacement.variable )
     };
+
+    /**
+     * checkRouteParams
+     *
+     * @param {object} route
+     * @param {object} params
+     * @return {object} route - updated route object
+     */
     var checkRouteParams = function(route, params) {
         var variable        = null
             , regex         = null
@@ -756,11 +860,12 @@ function Routing() {
             , p             = null
             , pLen          = null
         ;
+
         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);
+                variable = route.param[p].substring(1);
 
                 if ( typeof(params) != 'undefined' && typeof(params[variable]) != 'undefined' ) {
 
@@ -815,7 +920,7 @@ function Routing() {
                 p = 0;
                 pLen = rawUrlVars.length;
                 for (; p < pLen; p++) {
-                    pKey = rawUrlVars[p].substr(1);
+                    pKey = rawUrlVars[p].substring(1);
                     if ( typeof(params[ pKey ]) != 'undefined' && params[ pKey ] ) {
                         rawUrlScore++;
                     }
@@ -842,14 +947,24 @@ function Routing() {
      * */
     self.getRoute = function(rule, params, urlIndex) {
 
-        var config = null;
+        var config = null, isProxyHost = false;
         if (isGFFCtx) {
+            if (
+                !window.location.port
+                && window.location.hostname == window.gina.config.hostname.replace(/^(https|http|wss|ws)\:\/\//, '').replace(/\:\d+$/, '')
+            ) {
+                isProxyHost = true;
+                window.gina.config.hostname = window.gina.config.hostname.replace(/^(https|http|wss|ws)\:\/\//, '').replace(/\:\d+$/, '')
+            }
             config = window.gina.config;
         } else {
+
             config = getContext('gina').config;
             if ( typeof(getContext('argvFilename')) != 'undefined' ) {
                 config.getRouting = getContext('gina').Config.instance.getRouting;
             }
+
+            isProxyHost = getContext('isProxyHost');
         }
 
         var env         = config.env || GINA_ENV  // by default, takes the current bundle
@@ -883,8 +998,17 @@ function Routing() {
             rule = arr[0].toLowerCase() +'@'+ bundle;
         }
 
-
         var routing = config.getRouting(bundle, env);
+        // TODO- change the way it is done
+        // var routing = null;
+        // if ( config.bundle != bundle) {
+        //     // We are going to try to retrieved an exposed route (single)
+        //     routing = config.getRouting(rule, env);
+        // } else {
+        //     // We are getting the current bundle routing (all routes)
+        //     routing = config.getRouting(bundle, env);
+        // }
+
 
         if ( typeof(routing[rule]) == 'undefined' ) {
             throw new Error('[ RoutingHelper::getRouting(rule, params) ] : `' +rule + '` not found !')
@@ -894,6 +1018,25 @@ function Routing() {
         var msg     = null;
         route = checkRouteParams(route, params);
 
+        route.isProxyHost = isProxyHost;
+        if (isProxyHost) {
+            if (isGFFCtx) {
+                route.proxy_hostname  = window.location.protocol +'//'+ document.location.hostname;
+            } else {
+                route.proxy_hostname  = process.gina.PROXY_HOSTNAME || config.envConf._proxyHostname;
+                // console.debug("[getRoute#1]["+isProxyHost+"] process.gina.PROXY_HOSTNAME ("+ process.gina.PROXY_HOSTNAME  +") VS config.envConf._proxyHostname ("+ config.envConf._proxyHostname +")");
+            }
+            route.proxy_host      = route.proxy_hostname.replace(/^(https|http)\:\/\//, '');
+
+        } else if (
+            !isGFFCtx
+            && typeof(process.gina.PROXY_HOSTNAME) != 'undefined'
+        ) {
+            route.proxy_hostname  = process.gina.PROXY_HOSTNAME;
+            route.proxy_host      = route.proxy_hostname.replace(/^(https|http)\:\/\//, '');
+            console.debug("[getRoute#2]["+isProxyHost+"] process.gina.PROXY_HOSTNAME ("+ process.gina.PROXY_HOSTNAME  +") VS config.envConf._proxyHostname ("+ config.envConf._proxyHostname +")");
+        }
+
         if ( /\,/.test(route.url) ) {
             if ( typeof(route.urlIndex) != 'undefined' ) {
                 urlIndex = route.urlIndex; // set by checkRouteParams(route, params)
@@ -906,7 +1049,7 @@ function Routing() {
         // 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);
+            route.url = route.url.substring(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' ) {
@@ -963,18 +1106,30 @@ function Routing() {
             }
 
             var wroot       = this.webroot || urlProps.webroot
-                , hostname  = this.hostname || urlProps.hostname
-                , path      = this.url
+                , hostname  = ''+this.hostname || ''+urlProps.hostname
+                , path      = ''+this.url
             ;
+            if (this.isProxyHost) {
+                hostname = ''+this.proxy_hostname;
+            }
+
+            this.url = (
+                    typeof(ignoreWebRoot) != 'undefined'
+                    && /^true$/i.test(ignoreWebRoot)
+                ) ? path.replace( new RegExp('^'+ wroot), '/') : path.replace( new RegExp('^('+wroot +'|\/$)'), wroot);
+
+            // this.url = (
+            //     typeof(ignoreWebRoot) != 'undefined'
+            //     && /^true$/i.test(ignoreWebRoot)
+            // ) ? path.replace( new RegExp('\/'+ wroot), '/') : path;
 
-            this.url = ( typeof(ignoreWebRoot) != 'undefined' && ignoreWebRoot == true ) ? path.replace(wroot, '/') : path;
 
             return hostname + this.url
         };
 
         /**
          * request current url
-         *
+         * Attention: You should first try without an authentification middleware
          *
          *
          * @param {boolean} [ignoreWebRoot]
@@ -999,6 +1154,10 @@ function Routing() {
                 , url       = ( typeof(ignoreWebRoot) != 'undefined' && ignoreWebRoot == true ) ? path.replace(wroot, '/') : this.url || _this.url
             ;
 
+            if ( /^\//.test(url) ) {
+                url = hostname + url;
+            }
+
             var scheme = ( /^https/.test(hostname) ) ? 'https' : 'http';
 
             if (isGFFCtx) {
@@ -1081,12 +1240,13 @@ function Routing() {
         return route
     };
 
+    // TODO - Remove this : deprecated && not used
     var getFormatedRoute = function(route, url, hash) {
         // 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(url) && url != '/' )
-            url = url.substr(0, url.length-1);
+            url = url.substring(0, url.length-1);
         // adding hash if found
         if (hash)
             url += hash;
@@ -1111,19 +1271,20 @@ function Routing() {
     /**
      * Get route by url
      * N.B.: this will only work with rules declared with `GET` method property
+     * ATTENTION !!! Not fully working for frontend because of unresolved promises !!!!
      *
      * @function getRouteByUrl
      *
      * @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 {string} [method] 2nd or 3rd -  request method (GET|PUT|PUT|DELETE) - GET is set by default
      * @param {object} [request]
-     * @param {boolean} [isOverridinMethod] // will replace request.method by the provided method - Used for redirections
+     * @param {boolean} [isOverridingMethod] // 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) {
+    self.getRouteByUrl = function (url, bundle, method, request, isOverridingMethod) {
 
         if (
             arguments.length == 2
@@ -1176,7 +1337,7 @@ function Routing() {
             }
         }
 
-        isOverridinMethod = ( typeof(arguments[arguments.length-1]) != 'boolean') ? false : arguments[arguments.length-1];
+        isOverridingMethod = ( typeof(arguments[arguments.length-1]) != 'boolean') ? false : arguments[arguments.length-1];
 
         var matched             = false
             , config            = null
@@ -1197,8 +1358,8 @@ function Routing() {
             config          = window.gina.config;
             bundle          = (typeof (bundle) != 'undefined') ? bundle : config.bundle;
             env             = config.env;
-            routing         = routing || config.getRouting(bundle);
-            reverseRouting  = reverseRouting || config.reverseRouting;
+            routing         = config.routing || config.getRouting(bundle);
+            reverseRouting  = config.reverseRouting;
             isXMLRequest    = ( typeof(isXMLRequest) != 'undefined' ) ? isXMLRequest : false; // TODO - retrieve the right value
 
             hostname        = hostname || config.hostname;
@@ -1211,6 +1372,9 @@ function Routing() {
                 params: {},
                 url: url
             };
+            if (bundle) {
+                request.bundle = bundle;
+            }
         } else {
 
             var gnaCtx      = getContext('gina');
@@ -1235,7 +1399,7 @@ function Routing() {
                     url: url
                 }
             }
-            if (isOverridinMethod) {
+            if (isOverridingMethod) {
                 request.method = method;
             }
             isXMLRequest    = request.isXMLRequest || false;
@@ -1298,11 +1462,8 @@ function Routing() {
                 // normal case
                 //Parsing for the right url.
                 try {
-
                     isRoute = self.compareUrls(params, routing[name].url, request);
-
                     if (isRoute.past) {
-
                         route = JSON.clone(routing[name]);
                         route.name = name;
 
@@ -1324,7 +1485,7 @@ function Routing() {
                     url == '#'
                     && /GET/i.test(method)
                     && isMethodProvidedByDefault
-                    || /^404\:/.test(url)
+                    || /^404\:/.test(url)
                 ) {
                     url = location.pathname;
                     urlHasChanged = true;
@@ -1414,7 +1575,7 @@ function Routing() {
             // to prevent having a folder.
             // eg.: {..., id: '/^\\s*$/'} => {..., id: ''} => /path/to/ becoming /path/to
             if ( /\/$/.test(url) && url != '/' )
-                url = url.substr(0, url.length-1);
+                url = url.substring(0, url.length-1);
             // adding hash if found
             if (hash)
                 url += hash;
@@ -1441,9 +1602,17 @@ function Routing() {
 }
 
 if ((typeof (module) !== 'undefined') && module.exports) {
+
+    // Loading logger
+    if ( typeof(console.err) == 'undefined' ) {
+        console = require('../../logger');
+    }
+
     // Publish as node.js module
-    module.exports = Routing()
+    module.exports = Routing();
 } else if (typeof (define) === 'function' && define.amd) {
     // Publish as AMD module
-    define('lib/routing', ['require', 'lib/form-validator', 'lib/merge'], function() { return Routing() })
+    define('lib/routing', ['require', 'lib/form-validator', 'lib/merge'], function() {
+        return Routing();
+    });
 }

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/session-store.js

@@ -1,6 +1,6 @@
 /*
  * This file is part of the gina package.
- * Copyright (c) 2009-2023 Rhinostone <contact@gina.io>
+ * Copyright (c) 2009-2026 Rhinostone <contact@gina.io>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -23,14 +23,14 @@ function SessionStore(session) {
     try {
         connector         = conf.content.connectors[session.name].connector;
     } catch (err) {
-        throw new Error('SessionStore could not be loaded: Connector issue. Please check your bundle configuration @config/connectors.json\n'+ err.stack);
+        throw new Error('[SessionStore] Could not be loaded: Connector issue. Please check your bundle configuration @config/connectors.json\n'+ err.stack);
     }
 
     var connectorName = 'couchbase';
     var filename = _(connectorsPath + '/'+ connector +'/lib/session-store.js', true);
 
     if ( !fs.existsSync(filename) ) {
-        throw new Error('SessionStore could not be loaded: `'+ filename+'` is missing');
+        throw new Error('[SessionStore] Could not be loaded: `'+ filename+'` is missing');
     }
 
     return require(filename)(session, bundle)

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/shell.js

@@ -1,9 +1,10 @@
-var fs = require('fs');
-var EventEmitter = require('events').EventEmitter;
-var spawn = require('child_process').spawn;
-var inherits = require(require.resolve('./inherits'));
-var helpers = require('./../helpers');
-var console = require('./logger');
+var fs              = require('fs');
+var EventEmitter    = require('events').EventEmitter;
+var spawn           = require('child_process').spawn;
+var execSync        = require('child_process').execSync;
+var inherits        = require(require.resolve('./inherits'));
+var helpers         = require('./../helpers');
+var console         = require('./logger');
 
 /**
  * SSH SHELL

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/swig-filters/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "swig-filters",
+  "name": "gina-lib-swig-filters",
   "version": "1.0.0",
   "description": "Swig Filters",
 
@@ -7,7 +7,7 @@
     "name": "Maritn-Luther ETOUMAN",
     "email": "contact@gina.io"
   },
-  "copyright": "Copyright (c) 2009-2023 Rhinostone <contact@gina.io>",
+  "copyright": "Copyright (c) 2009-2026 Rhinostone <contact@gina.io>",
   "engines": {
     "node": ">=0.10.22"
   },