gina 0.0.9-p91c → 0.1.1-alpha.3

package/framework/v0.1.1-alpha.3/lib/session-store.js

@@ -0,0 +1,33 @@
+/*
+ * This file is part of the gina package.
+ * Copyright (c) 2009-2022 Rhinostone <contact@gina.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var fs          = require('fs');
+
+//var inherits = require(require.resolve('./inherits'));
+var helpers = require('./../helpers');
+var console = require('./logger');
+
+function SessionStore(session) {
+    
+    var ctx                 = getContext()
+        , bundle            = ctx.bundle
+        , env               = ctx.env
+        , conf              = getConfig()[bundle][env]
+        , connectorsPath    = conf.connectorsPath
+        , connector         = conf.content.connectors[session.name].connector
+    ; 
+    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');
+    }
+    
+    return require(filename)(session, bundle)
+};
+    
+module.exports = SessionStore;

package/{core/utils → framework/v0.1.1-alpha.3}/lib/shell.js

@@ -5,17 +5,25 @@ var inherits = require(require.resolve('./inherits'));
 var helpers = require('./../helpers');
 var console = require('./logger');
 
-
+/**
+ * SSH SHELL
+ */
 function Shell () {
 
     var self = this;
     var local = {
         chdir : undefined,
+        console: undefined
     };
 
     this.setOptions = function(opt) {
-        local = {
-            chdir : opt.chdir
+        
+        for (let name in opt) {
+            if ( Object.keys(local).indexOf(name) < 0 ) {
+                throw new Error('Option `'+ name +'` not supported !')
+            }
+            console.log('Settings options for ', name);
+            local[name] = opt[name]
         }
     }
 
@@ -30,24 +38,32 @@ function Shell () {
      * @param {boolean} runLocal
      * */
     this.run = function(cmdline, runLocal) {
-        var opt = getOptions();
-        var outFile = _(getPath('globalTmpPath') + '/out.log');
-        var errFile = _(getPath('globalTmpPath') + '/err.log');
-        var out = fs.openSync(outFile, 'a');
-        var err = fs.openSync(errFile, 'a');
 
-        var root = opt.chdir || getPath('root');
+        var opt         = getOptions()
+            , outFile   = _(GINA_TMPDIR + '/out.log')
+            , errFile   = _(GINA_TMPDIR + '/err.log')
+            , out       = fs.openSync(outFile, 'a')
+            , err       = fs.openSync(errFile, 'a')
+        ;
 
-        var result, error = false;
-        var hasCalledBack = false;
+        //var root = opt.chdir || getPath('root');
+        var root = opt.chdir;
+
+        var result          = null
+            , error         = false
+            , hasCalledBack = false
+        ;
+        
+        var _console = ( typeof(local.console) != 'undefined' ) ? local.console : console;
 
         var e = new EventEmitter();
 
-        var cmd;
+        var cmd = null;
+
         if ( isWin32() ) {
             throw new Error('Windows platform not supported yet for command line forward');
-            process.exit(1)
         }
+
         if ( typeof(runLocal) != 'undefined' && runLocal == true ) {
 
             // cmdline must be an array !!
@@ -58,13 +74,15 @@ function Shell () {
             cmd = spawn(cmdline.splice(0,1).toString(), cmdline, { cwd: root, stdio: [ 'ignore', out, err ] })
 
         } else {
-            console.info('running: ssh ', cmdline);
+            _console.debug('running: ssh ', cmdline);
             cmd = spawn('ssh', [ self.host, cmdline ], { stdio: [ 'ignore', out, err ] })
         }
 
         cmd.on('stdout', function(data) {
-            var str = data.toString();
-            var lines = str.split(/(\r?\n)/g);
+
+            var str     = data.toString();
+            var lines   = str.split(/(\r?\n)/g);
+
             result = lines.join('');
 
             e.emit('run#data', result)
@@ -72,10 +90,10 @@ function Shell () {
 
         // Errors are readable in the onComplete callback
         cmd.on('stderr', function (err) {
-            var err = err.toString();
-            //error = new Error(err).stack || false;
-            error = err || false;
 
+            if (err) {
+                error = err.toString();
+            }
 
             e.emit('run#err', error)
         });
@@ -89,7 +107,7 @@ function Shell () {
                 if ( fs.existsSync(errFile) ) fs.unlinkSync(errFile);
 
                 if (error) {
-                    //cmd.emit('stderr', new Buffer(error))
+                    //cmd.emit('stderr', Buffer.from(error))
                     error = new Error(error).stack;
                     cmd.emit('stderr', error)
                 }
@@ -101,11 +119,11 @@ function Shell () {
                 if (fs.existsSync(outFile) ) fs.unlinkSync(outFile);
 
                 if ( data ) {
-                    cmd.emit('stdout', new Buffer(data))
+                    cmd.emit('stdout', Buffer.from(data))
                 }
 
 
-                if (error == '') {
+                if ( error == '' || typeof(error) == 'undefined' || error == undefined  || error == null) {
                     error = false
                 }
 
@@ -117,7 +135,7 @@ function Shell () {
 
 
             } catch (err) {
-                console.error(err.stack)
+                _console.error(err.stack)
             }
         });
 
@@ -129,18 +147,13 @@ function Shell () {
 
             e.once('run#err', function(err, data) {
                 callback(err, data)
-            });
-
-            //return e
-
+            })
         };
 
         e.onComplete = function(callback) {
             e.once('run#complete', function(err, data) {
                 callback(err, data)
-            });
-
-            //return e
+            })
         };
 
         return e

package/framework/v0.1.1-alpha.3/lib/swig-filters/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "swig-filters",
+  "version": "1.0.0",
+  "description": "Swig Filters",
+
+  "author": {
+    "name": "Maritn-Luther ETOUMAN",
+    "email": "contact@gina.io"
+  },
+  "copyright": "Copyright (c) 2009-2022 Rhinostone <contact@gina.io>",
+  "engines": {
+    "node": ">=0.10.22"
+  },
+  "main": "src/main",
+  "scripts": {
+    "test": "nodeunit test"
+  },
+  "license": "MIT",
+  "readmeFilename": "README.md"
+}

package/framework/v0.1.1-alpha.3/lib/swig-filters/src/main.js

@@ -0,0 +1,322 @@
+/*
+ * This file is part of the gina package.
+ * Copyright (c) 2009-2022 Rhinostone <contact@gina.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * SwigFilters
+ * ------
+ * Setup
+ * ------
+ * var filters = SwigFilters({
+ *   options     : local.options,
+ *   isProxyHost : isProxyHost,
+ *   throwError  : self.throwError, // use ctx.throwError
+ *   req         : local.req,
+ *   res         : local.res 
+ * });
+ * -----
+ * Call
+ * ----- 
+ * swig.setFilter('getUrl', filters.getUrl);
+ *
+ * 
+ * @package     Gina.Lib
+ * @namespace   Gina.Lib.SwigFilters
+ * @author      Rhinostone <contact@gina.io>
+ * */
+function SwigFilters(conf) {
+    
+    var isGFFCtx    = ((typeof (module) !== 'undefined') && module.exports) ? false :  true;
+    
+    var self = { options: conf };  
+    var init = function() {
+
+        if ( typeof(SwigFilters.initialized) != 'undefined' ) {
+            return getInstance()
+        } else {
+            
+            SwigFilters.instance = self;
+            
+            if (self.options) {
+                SwigFilters.instance._options = self.options;
+            }
+            
+            SwigFilters.initialized = true;    
+            
+            return SwigFilters.instance
+        }
+    }
+
+    var getInstance = function() {
+        if (conf) {
+            self.options = SwigFilters.instance._options = JSON.clone(conf);
+        }
+            
+        return SwigFilters.instance
+    }
+    
+    self.getConfig = function() {
+        return JSON.clone(self.options)
+    }
+    
+    // Allows you to get a bundle web root
+    self.getWebroot = function (input, obj) {
+        var url = null, prop = self.options.envObj.getConf(obj, options.conf.env);
+        if ( isProxyHost ) {
+            url = prop.server.scheme + '://'+ prop.host;
+        } else {
+            url = prop.server.scheme + '://'+ prop.host +':'+ prop.port[prop.server.protocol][prop.server.scheme];
+        }
+            
+        if ( typeof(prop.server['webroot']) != 'undefined') {
+            url += prop.server['webroot']
+        }
+        return url
+    }
+    
+    // var getRouteDefinition = function(routing, rule, method) {
+    //     var routeObject = null;
+    //     for (r in routing) {
+    //         if ( r == rule && routing[r].method.toLowerCase() == method.toLowerCase() ) {
+    //             routeObject = routing[r];
+    //             break;
+    //         }
+    //     }
+        
+    //     return routeObject;
+    // }
+    
+    /**
+     * getUrl filter
+     *
+     * Usage:
+     *      <a href="{{ '/homepage' | getUrl() }}">Homepage</a>
+     *      <a href="{{ 'users-add' | getUrl({ id: user.id }) }}">Add User</a>
+     *      <a href="{{ 'users-edit' | getUrl({ id: user.id }) }}">Edit user</a>
+     *      <a href="{{ 'users-get-empty' | getUrl({ id: '' }) }}">Get empty</a>
+     *      <a href="{{ 'users-list' | getUrl(null, 'http://domain.com') }}">Display all users</a>
+     *      <a href="{{ '/dashboard' | getUrl(null, 'admin') }}">Go to admin bundle's dashboard page</a>
+     *      <a href="{{ 'home@admin' | getUrl() }}">Go to admin bundle's dashboard page</a>
+     *
+     *      // can also be used with standalone mode: will add webroot if current bundle is not master
+     *      <script src="{{ '/js/vendor/modernizr-2.8.3.min.js' | getUrl() }}"></script>
+     *      compiled as => <script src="/my-bundle/js/vendor/modernizr-2.8.3.min.js"></script>
+     *
+     * @param {string} route
+     * @param {object} params - can't be left blank if base is required -> null if not defined
+     * @param {string} [base] - can be a CDN, the http://domain.com or a bundle name
+     *
+     * @returns {string} relativeUrl|absoluteUrl - /sample/url.html or http://domain.com/sample/url.html
+     * */
+    self.getUrl = function (route, params, base) {                        
+        
+        //var ctx = SwigFilters().getConfig();
+        //var ctx = self.options;
+        if (typeof(params) == 'undefined') {
+            params = {}
+        } 
+        var ctx  = SwigFilters.instance._options || self.options;
+                
+        var config              = null
+            , hostname          = null
+            , wroot             = null
+            , wrootRe           = null
+            , isStandalone      = null
+            , isMaster          = null
+            , isProxyHost       = ctx.isProxyHost
+            , routing           = null                        
+            , rule              = null
+            , url               = NaN
+            , urlStr            = null
+            , method            = 'GET'
+        ;
+        
+        if (ctx.options.method != 'undefined') {
+            method = ctx.options.method
+        }
+            
+        // if no route, returns current route
+        if ( !route || typeof(route) == 'undefined') {
+            route = ctx.options.rule
+        }
+        
+        config = {};
+        if (/\@/.test(route) && typeof(base) == 'undefined') {
+            var r = route.split(/\@/);
+            route = r[0].toLowerCase();
+            base = config.bundle = r[1];
+        } else {
+            if (
+                !/\@/.test(route)
+                && !/\.(.*)$/.test(route)
+                && typeof(base) == 'undefined'
+            ) {
+                base = config.bundle = ctx.options.conf.bundle;
+            }
+            route = route.toLowerCase();
+        }
+
+        // setting default config
+        config          = merge(config, ctx.options.conf);
+        hostname        = '';
+        //console.debug('web roooot ', SwigFilters.instance._options.conf.server.webroot);
+        wroot           = config.server.webroot;
+        isStandalone    = (config.bundles.length > 1) ? true : false;
+        isMaster        = (config.bundles[0] === config.bundle) ? true : false;
+        routing         = config.routing;
+      
+
+        if ( typeof(base) != 'undefined' ) {
+
+            // if base is not an URL, must be a bundle
+            if ( !/^(http|https)\:/.test(base) ) {
+                var mainConf = getContext('gina').Config.instance;
+                // is real bundle ?
+                if ( mainConf.allBundles.indexOf(base) > -1 ) {
+                    // config override
+                    config          = mainConf.Env.getConf(base, mainConf.env);
+                    
+                    // retrieve hostname, webroot & routing
+                    hostname        = config.hostname + config.server.webroot;
+                    // rewrite hostname vs ctx.req.headers.host
+                    if ( isProxyHost ) {
+                        hostname = hostname.replace(/\:\d+/, '');
+                    }
+
+                    config.bundle   = base;
+                    isStandalone    = (mainConf.bundles.length > 1) ? true : false;
+                    isMaster        = (mainConf.bundles[0] === config.bundle) ? true : false;
+
+                } else {
+                    ctx.throwError(ctx.res, 500, new Error('bundle `'+ base +'` not found: Swig.getUrl() filter encountered a problem while trying to compile base `'+base+'` and route `'+route+'`').stack)
+                }
+            }
+        }
+        
+        wrootRe = new RegExp('^'+ config.server.webroot);
+
+        // is path ?
+        if (/^\//.test(route)) {
+            
+            if ( !wrootRe.test(route) ) {
+                route = config.server.webroot + route.substr(1);
+                hostname = hostname.replace(new RegExp( config.server.webroot +'$'), '')
+            } else {
+                route = route.substr(1)
+            }                          
+
+            return hostname + route;
+        }
+
+        // rules are now unique per bundle : rule@bundle
+        rule = route + '@' + config.bundle;
+        //var ruleObj = getRouteDefinition(routing, rule, method);
+        var ruleObj = routing[rule];
+        if ( typeof(ruleObj) != 'undefined' && ruleObj != null ) { //found
+                        
+            url = ruleObj.url;
+            
+            if ( typeof(ruleObj.requirements) != 'undefined' ) {
+                var urls    = null
+                    , i     = 0
+                    , len   = null
+                    , p     = null
+                ;
+                
+                for (p in ruleObj.requirements) {
+                    
+                    if ( /\,/.test(url) ) {
+                        urls = url.split(/\,/g);
+                        i = 0; len = urls.length;
+                        for (; i< len; ++i) {
+                            if ( params && /:/.test(urls[i]) ) {
+                                urlStr = urls[i].replace(new RegExp(':'+p+'(\\W|$)', 'g'), params[p]+'$1');
+                                break
+                            }
+                        }
+
+                        url = (urlStr != null) ? urlStr : urls[0];
+                    } else {
+                        try {
+                            url = url.replace(new RegExp(':'+p+'(\\W|$)', 'g'), params[p]+'$1')
+                        } catch (err) {
+                            ctx.throwError(ctx.res, 500, new Error('template compilation exception encoutered: [ '+ url +' ]\nsounds like you are having troubles with the following call `{{ "'+route+'" | getUrl() }}` where `'+p+'` parameter is expected according to your `routing.json`'  +'\n'+ (err.stack||err.message)));
+                        }
+                    }
+                }
+            } else {
+                if ( /\,/.test(url) ) {
+                    url = url.split(/\,/g)[0] || null; // just taking the default one: using the first element unless it is empty.
+                    if (!url) {
+                        ctx.throwError(ctx.res, 500, new Error('please check your `routing.json` at the defined rule `'+ rule +'` : `url` attribute cannot be empty').stack)
+                    }
+                }
+            }
+            
+            
+            if (hostname.length > 0) {
+                url = url.replace(wrootRe, '');
+            }   
+            
+            // 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 = hostname + url;
+
+        } else {
+            
+            if ( typeof(routing['404@'+ config.bundle]) != 'undefined' && typeof(routing['404@'+ config.bundle].url) != 'undefined' ) {                              
+                //url = ( /^\//.test(routing['404@'+ config.bundle].url) ) ? hostname + routing['404@'+ config.bundle].url.substr(1) : hostname + routing['404@'+ config.bundle].url;
+                url = routing['404@'+ config.bundle].url.replace(wrootRe, '');
+                if (hostname.length > 0) {
+                    url = url.replace(wrootRe, '');
+                }  
+                url = hostname + url;
+            } else {
+                url = route;
+                if (hostname.length > 0) {
+                    url = url.substr(1);
+                } 
+                url = hostname + url
+            }
+            
+            return '404:['+ ctx.req.method +']'+rule                            
+        }
+
+        return url
+    }
+    
+    // Extends default `length` filter
+    self.length = function (input, obj) {
+
+        if ( typeof(input.count) != 'undefined' ) {
+            return input.count()
+        } else {
+            return input.length
+        }
+    }
+    
+    self.nl2br = function(text, replacement) {
+        replacement = ( typeof( replacement ) != 'undefined' ) ? replacement : '<br/>';
+        return text.replace(/(\n|\r)/g, replacement);
+    }
+    
+    
+    return init()
+    
+}
+
+if ((typeof (module) !== 'undefined') && module.exports) {
+    // Publish as node.js module
+    module.exports = SwigFilters
+} else if (typeof (define) === 'function' && define.amd) {
+    // Publish as AMD module
+    define(function() { return SwigFilters })
+}

package/{core/utils → framework/v0.1.1-alpha.3}/lib/url/index.js

@@ -1,9 +1,10 @@
+// Deprecated
 function Url(env, routes) {
     var self = this;
 
     var init = function() {
         self.base = '';
-        self.routes = JSON.parse(JSON.stringify(routes));
+        self.routes = JSON.clone(routes);
 
         if (typeof(env.fqdn) != 'undefined' && env.fqdn != null) {
             self.base = (/^http:\/\//.test(env.fqdn)) ? env.fqdn : 'http://'+env.fqdn

package/{core/utils → framework/v0.1.1-alpha.3}/lib/url/routing.json

@@ -1,25 +1,25 @@
 {
     "default": {
         "url": "/",
-        "param": { "action": "zero" }
+        "param": { "control": "zero" }
     },
     "test1": {
         "url": ["/one", "/one/"],
-        "param": { "action": "one" }
+        "param": { "control": "one" }
     },
     "test2": {
         "requirements": {
             "pone": ".*"
         },
         "url": "/:pone/two",
-        "param": { "action": "two", "pone" : ":pone" }
+        "param": { "control": "two", "pone" : ":pone" }
     },
     "test3": {
         "requirements": {
             "pone": ".*"
         },
         "url": "/three",
-        "param": { "action": "three" }
+        "param": { "control": "three" }
     },
     "test4": {
         "requirements": {
@@ -27,7 +27,7 @@
             "ptwo": ".*"
         },
         "url": "/:pone/four/:ptwo",
-        "param": { "action": "four", "pone" : ":pone", "ptwo" : ":ptwo" }
+        "param": { "control": "four", "pone" : ":pone", "ptwo" : ":ptwo" }
     },
     "test5": {
         "requirements": {
@@ -35,7 +35,7 @@
             "ptwo": ".*"
         },
         "url": ["/:pone/five/:ptwo", "/five/:pone/:ptwoRi"],
-        "param": { "action": "five", "pone" : ":pone", "ptwo" : ":ptwo" }
+        "param": { "control": "five", "pone" : ":pone", "ptwo" : ":ptwo" }
     },
     "test6": {
         "requirements": {
@@ -43,7 +43,7 @@
             "ptwo": "^[0-9]+$"
         },
         "url": "/six/:pone/:ptwo",
-        "param": { "action": "six", "pone" : ":pone", "ptwo" : ":ptwo" }
+        "param": { "control": "six", "pone" : ":pone", "ptwo" : ":ptwo" }
     },
     "test7": {
         "requirements": {
@@ -51,13 +51,13 @@
             "ptwo": ".*"
         },
         "url": "/:pone/seven/:ptwo",
-        "param": { "action": "seven" }
+        "param": { "control": "seven" }
     },
     "test8": {
         "requirements": {
             "pone": ".*"
         },
         "url": ["/eight/", "/eight/:pone"],
-        "param": { "action": "six" }
+        "param": { "control": "six" }
     }
 }

package/{core/utils → framework/v0.1.1-alpha.3}/lib/validator.js

@@ -1,10 +1,10 @@
-var helpers     = require('./helpers');
+var helpers     = require('./../helpers');
 var merge       = require('./merge');
 var dateFormat  = helpers.dateFormat;
 
 /**
  * @class Validator
- *
+ * Backend validator
  * e.g.:
  *  var data = req.post;
  *  var d = new Validator(data);
@@ -400,7 +400,7 @@ function Validator(data, errorLabels) {
          *
          * @param {string} [mask] - by default "yyyy-mm-dd"
          *
-         * @return {date} date - extended by gina::utils::dateFormat; an adaptation of Steven Levithan's code
+         * @returns {date} date - extended by gina::utils::dateFormat; an adaptation of Steven Levithan's code
          * */
         self[el].isDate = function(mask) {
             var val = this.value;
@@ -419,9 +419,9 @@ function Validator(data, errorLabels) {
 
             var date = this.value = local.data[this.name] = new Date(newMask);
 
-            this.valid = ( !date instanceof Date ) ? false : true;
+            this.valid = ( date instanceof Date ) ? true : false;
 
-            if ( !date instanceof Date ) {
+            if ( date instanceof Date  === false ) {
                 local.errors[this.name].isDate = replace(this.error || local.errorLabels.isDate, this)
             }
 
@@ -473,7 +473,7 @@ function Validator(data, errorLabels) {
         /**
          * Exclude when converting back to datas
          *
-         * @return {object} data
+         * @returns {object} data
          * */
         self[el].exclude = function() {
             //if (!this.value) return self[this.name];
@@ -492,7 +492,7 @@ function Validator(data, errorLabels) {
     /**
      * Check if errors found during validation
      *
-     * @return {boolean}
+     * @returns {boolean}
      * */
     self.isValid = function() {
         var i = local.errors.count();