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

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/archiver/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.
@@ -176,7 +176,7 @@ function Archiver() {
                     if ( typeof(options.name) != 'undefined' && options.name != 'default') {
                         target += options.name;
                     } else {
-                        target += src.substr(src.lastIndexOf('/')+1);
+                        target += src.substring(src.lastIndexOf('/')+1);
                     }
 
                     input   = fs.createReadStream(src);
@@ -198,7 +198,7 @@ function Archiver() {
                 if ( typeof(options.name) != 'undefined' && options.name != 'default') {
                     target += options.name;
                 } else {
-                    target += src.substr(src.lastIndexOf('/')+1);
+                    target += src.substring(src.lastIndexOf('/')+1);
                 }  */
 
                 if ( !isBatchProcessing ) {
@@ -207,8 +207,8 @@ function Archiver() {
                         options.root = './'+ options.name +'/';
                         target += options.name;
                     } else {
-                        options.root = './'+ src.substr(src.lastIndexOf('/')+1) +'/';
-                        target += src.substr(src.lastIndexOf('/')+1);
+                        options.root = './'+ src.substring(src.lastIndexOf('/')+1) +'/';
+                        target += src.substring(src.lastIndexOf('/')+1);
                     }
                 }
 
@@ -238,7 +238,7 @@ function Archiver() {
 
             // main zip dir
             var mainFolder  = target + options.name;
-            options.root    = '.'+ mainFolder.substr(mainFolder.lastIndexOf('/')) +'/';
+            options.root    = '.'+ mainFolder.substring(mainFolder.lastIndexOf('/')) +'/';
 
             var output = mainFolder +'.zip';
             if ( fs.existsSync(output)) {
@@ -289,8 +289,8 @@ function Archiver() {
 
                 // check if src is inside directory
                 if ( /\//.test(files[i].output) && fs.statSync(files[i].input).isFile() ) {
-                    //var newFolder = options.root + files[i].output.substr( 0, files[i].output.lastIndexOf('/')+1).replace(/^(\.\/|\/)/, '');
-                    var newFolder = files[i].output.substr( 0, files[i].output.lastIndexOf('/')+1).replace(/^(\.\/|\/)/, '');
+                    //var newFolder = options.root + files[i].output.substring( 0, files[i].output.lastIndexOf('/')+1).replace(/^(\.\/|\/)/, '');
+                    var newFolder = files[i].output.substring( 0, files[i].output.lastIndexOf('/')+1).replace(/^(\.\/|\/)/, '');
                     zipInstance.folder( newFolder )
                 }
 
@@ -386,7 +386,7 @@ function Archiver() {
                 mainOutput = fs.createWriteStream(outFiles[0]);
 
                 // main zip dir
-                target = zipFolder =  '.'+ dir.substr(dir.lastIndexOf('/')) + '/';
+                target = zipFolder =  '.'+ dir.substring(dir.lastIndexOf('/')) + '/';
                 zipInstance.folder(zipFolder);
             }
 
@@ -462,8 +462,8 @@ function Archiver() {
                 var newDir      = filename;
                 var moreFiles   = fs.readdirSync(newDir);
                 var newTarget   = (isBatchProcessing)
-                                    ? newDir.substr( newDir.lastIndexOf( '/'+target.substr(1).replace(options.root.substr(1), '') ) ) +'/'
-                                    : '.'+ newDir.substr( newDir.lastIndexOf(options.root.substr(1))) +'/'
+                                    ? newDir.substring( newDir.lastIndexOf( '/'+target.substring(1).replace(options.root.substring(1), '') ) ) +'/'
+                                    : '.'+ newDir.substring( newDir.lastIndexOf(options.root.substring(1))) +'/'
                 ;
                 zipInstance.folder(newTarget);
 

package/framework/v0.1.6-alpha.161/lib/cache/README.md

@@ -0,0 +1,19 @@
+## Debuging your test with nodeunit
+
+```tty
+ node --inspect-brk=6959 `which nodeunit` ./test/01-find.js
+```
+
+Options can be passed through routing or manually when writing to cache
+
+```json
+{
+    "cache": {
+        // Static cache from `memory` access or from `fs` access (file sytem)
+        "type": "memory",
+        "ttl": 3600,
+        // Only active when set to `true`, default is `false`
+        "sliding": true
+    }
+}
+```

package/framework/v0.1.6-alpha.161/lib/cache/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "gina-lib-cache",
+  "version": "1.0.0",
+  "description": "Cache hanlder",
+
+  "author": {
+    "name": "Maritn-Luther ETOUMAN",
+    "email": "contact@gina.io"
+  },
+  "copyright": "Copyright (c) 2009-2026 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.6-alpha.161/lib/cache/src/main.js

@@ -0,0 +1,239 @@
+'use strict';
+if ( typeof(module) !== 'undefined' && module.exports ) {
+    const lib = require('../../index');
+}
+
+var cache = new Map();
+
+
+function Cache() {
+    var isGFFCtx        = ( ( typeof(module) !== 'undefined' ) && module.exports ) ? false : true;
+    var merge           = (isGFFCtx) ? require('lib/merge') : require('../../../lib/merge');
+    var uuid            = (isGFFCtx) ? require('vendor/uuid') : require('uuid');
+    var Collection      = (isGFFCtx) ? require('lib/collection') : require('../../../lib/collection');
+    // var EventEmitter    = (isGFFCtx) ? EventTarget : require('events').EventEmitter;
+
+    var instance = {
+        _events              : new Collection() //,
+        // eventHadlerInstance  : new EventEmitter()
+    };
+    var importedMapInstance = null;
+
+    /**
+     * Import exixting cache
+     * @param {array} initialCache
+     */
+    instance['from'] = function(initialCache) {
+        cache = importedMapInstance = initialCache;
+    }
+
+    /**
+     * Set entry by key
+     *
+     * @param {string} key
+     * @param {string|object} value
+     * @param {callback} cleanupFn
+     */
+    instance['set'] = function(key, value, cleanupFn = null) {
+        const existing = cache.get(key);
+        // If old entry exists, clean it up first
+        if (existing && existing.cleanup) {
+            existing.cleanup();
+        }
+
+        if (
+            /^object$/i.test(typeof(value))
+        ) {
+            value.createdAt = new Date();
+
+            if ( typeof(value.ttl) != 'undefined' ) {
+                // Converting Ms to secondes
+                var ttlMs = 1000 * ~~(value.ttl);
+                const timeout = setTimeout(() => {
+                    cache.delete(key);
+                }, ttlMs);
+
+                cache.set(key, {
+                    value,
+                    timeout,
+                    cleanup: cleanupFn || null
+                });
+            } else {
+                cache.set(key, {
+                    value,
+                    cleanup: cleanupFn || null
+                });
+            }
+        } else {
+            cache.set(key, {
+                value,
+                cleanup: cleanupFn || null
+            });
+        }
+
+
+
+        if (importedMapInstance) {
+            importedMapInstance = cache;
+        }
+    }
+
+    /**
+     * Get entry by key
+     *
+     * @param {string} key
+     *
+     * @return {object} entry
+     */
+    instance['get'] = function(key) {
+        const entry = cache.get(key);
+        return entry ? entry.value : undefined;
+    }
+
+    /**
+     * Check if cache has entry by key
+     *
+     * @param {string} key
+     * @returns
+     */
+    instance['has'] = function(key) {
+        return cache.has(key);
+    }
+
+    /**
+     * Delete entry by key
+     *
+     * @param {string} key
+     *
+     * @return {boolean} successStatus (true||false)
+     */
+    instance['delete'] = function(key) {
+        const entry = cache.get(key);
+        if (entry?.timeout) clearTimeout(entry.timeout);
+        if (entry) {
+            if (entry.cleanup) {
+                // Prevent resource leaks
+                entry.cleanup();
+            }
+
+            cache.delete(key);
+            if (importedMapInstance) {
+                importedMapInstance = cache;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Safely clear entire cache
+     *
+     */
+    instance['clear'] = function() {
+        for (const [key, entry] of cache.entries()) {
+            if (entry?.timeout) clearTimeout(entry.timeout);
+            if (entry.cleanup) {
+                try {
+                    entry.cleanup();
+                } catch (err) {
+                    console.error('Cache cleanup error for key:', key, err);
+                }
+            }
+        }
+        cache.clear();
+        if (importedMapInstance) {
+            importedMapInstance = cache;
+        }
+    }
+
+    /**
+     * Get cache stats
+     *
+     * @return stats
+     */
+    instance['size'] = function() {
+        return cache.size;
+    }
+
+    function onInvalidateEvent(event, data) {
+        console.debug('[cache::onInvalidateEvent] ', event, data);
+
+        if (!cache._events) {
+            return;
+        }
+
+        var found = cache._events
+            .setSearchOption('cacheKey', 'skipEval', true)
+            .find({ event: event});
+        for (let i=0, len=found.length; i<len; i++) {
+            instance['delete'](found[i].cacheKey);
+            cache._events
+                .setSearchOption('cacheKey', 'skipEval', true)
+                .delete({cacheKey: found[i].cacheKey, event: event });
+        }
+
+        if (importedMapInstance) {
+            importedMapInstance = cache;
+        }
+    }
+
+
+    /**
+     * Invalidate cache by event
+     *
+     * @return stats
+     */
+    instance['setEvents'] = function(cacheKey, cacheEvents, cb) {
+        if ( typeof(cache._events) == 'undefined' ) {
+            // collection
+            cache._events = instance['_events'];
+        }
+        // if ( typeof(cache.eventHadlerInstance) == 'undefined' ) {
+        //     // EventEmitter
+        //     cache.eventHadlerInstance = instance['eventHadlerInstance'];
+        // }
+
+        // Placing listeners
+        for (let i=0, len=cacheEvents.length; i<len; i++ ) {
+            // Only place if not already defiend
+            // let trigger = 'cache#invalidate::'+ cacheEvents[i];
+            // if ( typeof(cache.eventHadlerInstance._events[trigger]) == 'undefined' ) {
+            //     console.debug('[cache][set listener] ',trigger);
+            //     cache.eventHadlerInstance.on(trigger, onInvalidateEvent);
+            // }
+
+            if ( !cache._events.setSearchOption('cacheKey', 'skipEval', true).findOne({cacheKey: cacheKey, event: cacheEvents[i]}) ) {
+                cache._events.insert({
+                    id: uuid.v4(),
+                    cacheKey: cacheKey,
+                    event: cacheEvents[i]
+                });
+            }
+        }
+
+        if (importedMapInstance) {
+            importedMapInstance = cache;
+        }
+    }
+
+    /**
+     * Invalidate cache by event
+     *
+     * @return stats
+     */
+    instance['invalidateByEvent'] = function(event, data) {
+        // console.debug('[cache][invalidateByEvent] ',event, data);
+        // cache.eventHadlerInstance.emit('cache#invalidate::'+event, event, data);
+        onInvalidateEvent(event, data)
+    }
+
+    return instance;
+};
+
+if ( ( typeof(module) !== 'undefined' ) && module.exports ) {
+    // Publish as node.js module
+    module.exports = Cache
+} else if ( typeof(define) === 'function' && define.amd) {
+    // Publish as AMD module
+    define(function() { return Cache })
+}

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/cmd/bundle/add.js

@@ -368,7 +368,8 @@ function Add(opt, cmd) {
                 content[local.bundle] = {}
             }
             content[local.bundle][ self.envs[e] ] = {
-                "host" : local.bundle + "-{env}-{scope}-v{projectVersionMajor}.{rootDomain}"
+                "host_if_dns_resolution" : "{rootDomain}",
+                "host" : "localhost"
             };
 
         }

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/cmd/bundle/restart.js

@@ -110,7 +110,7 @@ function Restart(opt, cmd) {
                         //opt.notStopped.push(bundle + '@' + self.projectName);
                         return setTimeout(() => {
                             end(opt, cmd, isBulkRestart, bundleIndex, true)
-                        }, 500);
+                        }, 250); // 500
                     }
 
                     // retrieve messages from the parent stdout
@@ -120,7 +120,7 @@ function Restart(opt, cmd) {
                     setTimeout(() => {
                         //opt.client.write('  => bundle [ ' + bundle + '@' + self.projectName + ' ] restarted on port #'+ bundlePort+' :D\n');
                         end(opt, cmd, isBulkRestart, bundleIndex)
-                    }, 500);
+                    }, 250); // 500
                 })
             })//EO isRealApp
         }

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/cmd/bundle/start.js

@@ -84,7 +84,7 @@ function Start(opt, cmd) {
         var projectArchFile = projectArchFileObj.toString();
         var projectPlatformFileObj = new _(gnaPath +'/platform', true);
         var projectPlatformFile = projectPlatformFileObj.toString();
-        var nodeModulesContentArr = ( nodeModulesPathObj.existsSync() ) ? fs.readdirSync(nodeModulesPathObj.toString()) : [];
+        var nodeModulesContentArr = ( nodeModulesPathObj.existsSync() && !nodeModulesPathObj.isSymlinkSync() ) ? fs.readdirSync(nodeModulesPathObj.toString()) : [];
         var newNodeModulesContentArr = [], n = 0;
         for (let f in nodeModulesContentArr) {
             if (/^\./.test(nodeModulesContentArr[f]) ) {
@@ -95,20 +95,25 @@ function Start(opt, cmd) {
         nodeModulesContentArr = newNodeModulesContentArr.slice();
         newNodeModulesContentArr = null;
 
-        var pack = requireJSON(packagePath);
+        var pack    = requireJSON(packagePath);
+        var scope   = process.env.NODE_SCOPE || self.defaultScope
+        var env     = process.env.NODE_ENV || self.defaultEnv;
 
         if (
             !projectArchFileObj.existsSync()
             ||
             !projectPlatformFileObj.existsSync()
             ||
-            projectArchFileObj.existsSync() && fs.readFileSync(projectArchFile).toString() != currentArch
+            projectArchFileObj.existsSync()
+            && fs.readFileSync(projectArchFile).toString() != currentArch
             ||
-            projectPlatformFileObj.existsSync() && fs.readFileSync(projectPlatformFile).toString() != currentPlatform
+            projectPlatformFileObj.existsSync()
+            && fs.readFileSync(projectPlatformFile).toString() != currentPlatform
             ||
             !nodeModulesPathObj.existsSync()
             ||
             nodeModulesPathObj.existsSync()
+            && !nodeModulesPathObj.isSymlinkSync()
             && !nodeModulesContentArr.length
             ||
             nodeModulesPathObj.existsSync()
@@ -117,11 +122,13 @@ function Start(opt, cmd) {
             && typeof(pack.dependencies) != 'object'
             && pack.dependencies.count() > 0
         ) {
-            isNodeModulesReinstallNeeded = true;
+            if (scope == "local")
+                isNodeModulesReinstallNeeded = true;
         }
 
+        opt.client.write('\nScope: '+ scope);
+        opt.client.write('\nEnv: '+ env);
         opt.client.write('\nArch: '+ currentArch);
-        // opt.client.write('\nprojectArchFile: '+ projectArchFile);
         opt.client.write('\nPlatform: '+ currentPlatform);
         opt.client.write('\nisNodeModulesReinstallNeeded: '+ isNodeModulesReinstallNeeded);
 
@@ -180,7 +187,7 @@ function Start(opt, cmd) {
                 lib.generator.createFileFromDataSync(GINA_PLATFORM, projectPlatformFile);
                 setTimeout(() => {
                     done(false)
-                }, 1000);
+                }, 500); // 1000
 
             });
 
@@ -293,9 +300,12 @@ function Start(opt, cmd) {
                     params = [
                         // node arguments will be passed by gina
                         appPath,
-                        JSON.stringify(getContext()), //Passing context to child.
-                        self.projectName, // project name
-                        bundle// bundle name
+                        //Passing context to child.
+                        JSON.stringify(getContext()),
+                        // project name
+                        self.projectName,
+                        // bundle name
+                        bundle
                     ];
 
                     // injecting node arguments
@@ -314,6 +324,8 @@ function Start(opt, cmd) {
                         }
                     }
 
+                    // terminal.debug('Spawning '+ opt.argv[0] +' [with args] '+ params);
+
                     var child = spawn(opt.argv[0], params,
                         {
                             // cwd: bundleDir,
@@ -401,6 +413,7 @@ function Start(opt, cmd) {
 
                         // Expecting 2 flags (checkCaseCount) to free the child stdout !!
                         // terminal.debug('BO case count '+ checkCaseCount);
+                        // terminal.log('[debug] ', data);
                         var _matched =  data.match(checkCaseRe);
                         if ( _matched ) {
                             // terminal.warn('case count: '+ checkCaseCount +'\nMatched: '+ _matched.length + '\n'+ checkCaseRe +'\n-> '+ data + '<-\n');
@@ -605,7 +618,9 @@ function Start(opt, cmd) {
         }
 
         //Checking root.
-        if ( new _(d, true).existsSync() ) {
+        var dExists = new _(d, true).existsSync();
+        terminal.debug('[Checking bundle bootstrap] `'+ d +'`: '+ dExists);
+        if ( dExists ) {
             //checking bundle directory.
             fs.stat(p, function(err, stats) {
                 if (err) {

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/cmd/env/get.js

@@ -51,7 +51,7 @@ function Get(opt, cmd){
         }
 
         if (str != '')
-            console.log(str.substr(0, str.length-1));
+            console.log(str.substring(0, str.length-1));
 
         process.exit(0)
     }

package/framework/v0.1.6-alpha.161/lib/cmd/env/help.js

@@ -0,0 +1,30 @@
+var fs          = require('fs');
+
+var CmdHelper   = require('./../helper');
+var console     = lib.logger;
+
+/**
+ * Help
+ *
+ * */
+function Help(opt, cmd) {
+    var self = {};
+
+    var init = function() {
+
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+
+        // check CMD configuration
+        if ( !isCmdConfigured() ) return false;
+
+
+        getHelp();
+
+        return process.exit(0);
+    }
+
+    init()
+};
+
+module.exports = Help

package/framework/{v0.1.6-alpha.16 → v0.1.6-alpha.161}/lib/cmd/env/set.js

@@ -50,8 +50,29 @@ function Set(opt, cmd){
             data,
             target
         );
+
+        end('Env variable(s) set with success');
     };
 
+    var end = function (output, type, messageOnly) {
+        var err = false;
+        if ( typeof(output) != 'undefined') {
+            if ( output instanceof Error ) {
+                err = output = ( typeof(messageOnly) != 'undefined' && /^true$/i.test(messageOnly) ) ? output.message : (output.stack||output.message);
+            }
+            if ( typeof(type) != 'undefined' ) {
+                console[type](output);
+                if ( messageOnly && type != 'log') {
+                    console.log(output);
+                }
+            } else {
+                console.log(output);
+            }
+        }
+
+        process.exit( err ? 1:0 )
+    }
+
     init();
 }
 module.exports = Set;

package/framework/v0.1.6-alpha.161/lib/cmd/framework/arguments.json

@@ -0,0 +1,7 @@
+[
+  "--env",
+  "--path",
+  "--force",
+  "--more",
+  "--scope"
+]

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

@@ -21,7 +21,7 @@ function Build(opt, cmd){
     var self    = {};
 
     var init = function(opt, cmd) {
-        console.debug('Building framework...');
+        console.log('Building framework, please wait ...');
 
         // import CMD helpers
         new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });

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

@@ -62,6 +62,27 @@ function Dot(){
                 open(getPath('gina').lib)
                 break;
         }
+
+        end();
+    }
+
+    var end = function (output, type, messageOnly) {
+        var err = false;
+        if ( typeof(output) != 'undefined') {
+            if ( output instanceof Error ) {
+                err = output = ( typeof(messageOnly) != 'undefined' && /^true$/i.test(messageOnly) ) ? output.message : (output.stack||output.message);
+            }
+            if ( typeof(type) != 'undefined' ) {
+                console[type](output);
+                if ( messageOnly && type != 'log') {
+                    console.log(output);
+                }
+            } else {
+                console.log(output);
+            }
+        }
+
+        process.exit( err ? 1:0 )
     }
 
     init()

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

@@ -99,9 +99,9 @@ function Initialize(opt) {
             }
             require(path)(opt, cmd)
         } catch(err) {
-            console.crit('Gina has some troubles with command [ ', process.argv.join(' ') + ' ]\n' + err.stack);
+            console.crit('Gina has some troubles with this command\n'+ err.stack);
             if (opt.client) {
-                opt.client.write('Gina has some troubles with command [ ', process.argv.join(' ') + ' ]\n' + err.stack);
+                opt.client.write('Gina has some troubles with this command :\n' + err.stack);
             }
             process.exit(1);
         }
@@ -182,7 +182,7 @@ function Initialize(opt) {
         var source      = getPath('gina').root + '/resources/home/main.json';
         var target      = self.opt.homedir + '/main.json';
         var version     = 'v' + getEnvVar('GINA_VERSION');
-        var prefix      = getEnvVar('GINA_PREFIX') || execSync('npm config get prefix').toString().replace(/\n$/g, '');
+        var prefix      = getEnvVar('GINA_PREFIX') || execSync('$(which npm) config get prefix').toString().replace(/\n$/g, '');
         var globalMode  = getEnvVar('GINA_GLOBAL_MODE');
 
         var data = require(source);
@@ -291,6 +291,20 @@ function Initialize(opt) {
     self.checkArch = function(done) {
 
         var currentArch = process.arch;
+        switch (process.arch) {
+            case 'x64':
+                currentArch = 'amd64'
+                break;
+            case 'armv7l':
+                currentArch = 'armhf'
+                break;
+            case 'x86':
+                currentArch = 'i386'
+                break;
+            default:
+                break;
+        }
+
         var currentPlatform = process.platform;
         // ignored for framework:set
         var mainConfig = require( self.opt.homedir + '/main.json' );
@@ -493,6 +507,10 @@ function Initialize(opt) {
              * make sure to complete : self.checkIfMain()
              */
 
+            // Check GINA_HOST_V4 for changes in case of k8s environement
+            // Get current host IP, compare with getEnvVar('GINA_HOST_V4')
+            // IF changed: setEnvVar('GINA_HOST_V4', new_host_v4)
+
             var dic = {
                 'prefix' : prefix,
                 'global_mode': globalMode,