gina 0.1.1-alpha.21 → 0.1.1-alpha.210

package/framework/{v0.1.1-alpha.21 → v0.1.1-alpha.210}/lib/archiver/src/main.js

@@ -1,13 +1,13 @@
 /*
  * 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.
  */
 // nodejs dependencies
 if ( typeof(module) !== 'undefined' && module.exports) {
-    
+
     var fs          = require('fs');
     var zlib        = require('zlib');
     var JSZip       = require('./dep/jszip.min.js');
@@ -19,14 +19,14 @@ if ( typeof(module) !== 'undefined' && module.exports) {
 
 /**
  * Archiver
- *  zlib APIs except those that are explicitly synchronous 
+ *  zlib APIs except those that are explicitly synchronous
  *  To prenvent any suprises, you can use this in a child process
- * 
- *  Note: 
- *      Because libuv's threadpool has a fixed size, 
- *      it means that if for whatever reason any of these APIs takes a long time, 
- *      other (seemingly unrelated) APIs that run in libuv's threadpool will experience degraded performance. 
- *      In order to mitigate this issue, one potential solution is to increase the size of libuv's threadpool 
+ *
+ *  Note:
+ *      Because libuv's threadpool has a fixed size,
+ *      it means that if for whatever reason any of these APIs takes a long time,
+ *      other (seemingly unrelated) APIs that run in libuv's threadpool will experience degraded performance.
+ *      In order to mitigate this issue, one potential solution is to increase the size of libuv's threadpool
  *      by setting the 'UV_THREADPOOL_SIZE' environment variable to a value greater than 4 (its current default value).
  *      For more information, see the libuv threadpool documentation (http://docs.libuv.org/en/latest/threadpool.html)
  *
@@ -36,41 +36,41 @@ if ( typeof(module) !== 'undefined' && module.exports) {
  * */
 
 function Archiver() {
-    
-    
-    var self        = this;    
+
+
+    var self        = this;
     var isGFFCtx    = ((typeof (module) !== 'undefined') && module.exports) ? false :  true;
-    var merge       = (isGFFCtx) ? require('utils/merge') : require('../../../lib/merge');
+    var merge       = (isGFFCtx) ? require('lib/merge') : require('../../../lib/merge');
     var zip         = null;
-    
-    
+
+
     // var fs = null, zlib = null, Emitter = null;
     // // node dependencies - backend use only !
-    // if (!isGFFCtx) { 
+    // if (!isGFFCtx) {
     //     fs      = require('fs');
     //     zlib    = require('zlib');
     // }
-    
+
     this.allowedCompressionMethods = ['gzip', 'br', 'deflate'];
-    
+
     var defaultCompressionOptions = {
         tmp         : null,
         method      : 'gzip', // gzip (Gzip/Gunzip) | br (Brotli) | deflate (Deflate/Inflate)
         unlinkSrc   : false,
         name        : 'default',
         // Zlib class options : https://nodejs.org/api/zlib.html#zlib_class_options
-        level       : 9   // compression level 
+        level       : 9   // compression level
     };
-    
+
     var local = {};
-    
-    
-    
+
+
+
     /**
      * compress
-     * 
+     *
      * @param {string|array} src - filename, dirname or array of filenames & dirnames e.g: `/usr/local/data/dump.sql`
-     * 
+     *
      * Array must be a collection e.g.:
      *  [
      *      {
@@ -82,7 +82,7 @@ function Archiver() {
      *          ouput: 'dump/my-db.sql'
      *      }
      *  ]
-     * 
+     *
      * @param {string} output pathname - e.g: `/var/backup/mysql/`
      * @param {object} [options] you can also pass Zlib class options, see: https://nodejs.org/api/zlib.html#zlib_class_options
      *  {
@@ -90,35 +90,35 @@ function Archiver() {
      *      name: 'my-dump', // this is optional
      *      level: 7    // `0` for no compression; `1` for best speed; `9` for best compression
      *  }
-     * 
+     *
      */
     this.compress = function(src, target, options) {
-        
+
         options = ( typeof(options) != 'undefined' ) ? merge(options, defaultCompressionOptions) : defaultCompressionOptions;
-        
+
         if ( options.tmp != null ) {
             options.unlinkSrc = true;
         }
-        
+
         if ( !/\/$/.test(target) ) {
             target += '/'
         }
-        
+
         if ( !fs.existsSync(target))
             new _(target).mkdirSync();
-        
+
         // if ( /\.(zip|gz)$/.test(target) ) {
         //     options.method = 'gzip';
         // }
-        
+
         if ( self.allowedCompressionMethods.indexOf(options.method.toLowerCase()) < 0 ) {
             throw new Error('compression methode `'+ options.method +'` not supported !');
         }
         local.options = options;
         zip = new JSZip(); // zipInstance
-        
+
         compress(options.method, src, target, zip, options);
-        
+
         return {
             onComplete: function onCompressionCompleted(cb) {
                 self.once('archiver-'+ options.method +'#complete', function(err, target){
@@ -129,80 +129,80 @@ function Archiver() {
             //addSignature : selt.addSignature
         }
     }
-    
 
-    var compress = function(method, src, target, zipInstance, options) {        
-        
+
+    var compress = function(method, src, target, zipInstance, options) {
+
         var stats = null;
-        
+
         var processSrc = function(method, src, target, zipInstance, options, cb) {
-            
+
             if ( !fs.existsSync(src) ) {
                 self.emit('archiver-'+ method +'#complete', new Error('file not found `'+ src +'`'));
-                
+
                 return;
-            }        
-            
-            stats = fs.statSync(src); 
-            
+            }
+
+            stats = fs.statSync(src);
+
             var isBatchProcessing = ( typeof(cb) != 'undefined' ) ? true : false;
-            
+
             if ( stats.isFile() ) { // single file compression
-                    
-            
+
+
                 var input   = null;
                 var output  = null;
-                
+
                 if ( isBatchProcessing ) {
                     input   = src;
                     output  = target
                 } else {
-                    // targeted filename  
+                    // targeted filename
                     if ( typeof(options.name) != 'undefined' && options.name != 'default') {
                         target += options.name;
                     } else {
                         target += src.substr(src.lastIndexOf('/')+1);
-                    }  
-                    
+                    }
+
                     input   = fs.createReadStream(src);
                     output  = fs.createWriteStream(target +'.zip');
                 }
-                        
+
                 compressFile(method, input, output, zipInstance, isBatchProcessing, function(err, target, zipInstance) {
                     if ( isBatchProcessing ) {
                         cb(err, zipInstance);
                     } else {
                         self.emit('archiver-'+ method +'#complete', err, target)
                     }
-                    
+
                 });
             } else if ( stats.isDirectory() ) { // might be a fodler
-                
+
                 /**
-                // targeted filename  
+                // targeted filename
                 if ( typeof(options.name) != 'undefined' && options.name != 'default') {
                     target += options.name;
                 } else {
                     target += src.substr(src.lastIndexOf('/')+1);
                 }  */
-                
+
                 if ( !isBatchProcessing ) {
-                    // targeted filename  
+                    // targeted filename
                     if ( typeof(options.name) != 'undefined' && options.name != 'default') {
                         options.root = './'+ options.name +'/';
                         target += options.name;
                     } else {
                         options.root = './'+ src.substr(src.lastIndexOf('/')+1) +'/';
                         target += src.substr(src.lastIndexOf('/')+1);
-                    }                     
+                    }
                 }
-                               
+
                 browse(method, src, target, zipInstance, options, [], [], 0, null, isBatchProcessing, function(err, target, zipInstance) {
                     if ( isBatchProcessing ) {
                         cb(err, zipInstance);
                     } else {
                         self.emit('archiver-'+ method +'#complete', err, target);
-                    }                    
+                    }
                 });
             } else {
                 var err = new Error('[ lib/archiver ] only supporting real `filename` & `dirname` as `src` input at for now');
@@ -211,135 +211,135 @@ function Archiver() {
                     cb(err, zipInstance);
                 } else {
                     self.emit('archiver-'+ method +'#complete', err, null)
-                }                
+                }
             }
         }
-        
+
         // compress single file or scan an entire directory
-        if ( typeof(src) == 'string' ) {            
+        if ( typeof(src) == 'string' ) {
             processSrc(method, src, target, zipInstance, options)
-                        
+
         } else if ( Array.isArray(src) ) { // compress from a list of files & folders
-            
+
             // main zip dir
-            var mainFolder  = target + options.name;    
-            options.root    = '.'+ mainFolder.substr(mainFolder.lastIndexOf('/')) +'/'; 
-            
+            var mainFolder  = target + options.name;
+            options.root    = '.'+ mainFolder.substr(mainFolder.lastIndexOf('/')) +'/';
+
             var output = mainFolder +'.zip';
             if ( fs.existsSync(output)) {
                 fs.unlinkSync(output);
             }
-            
+
             outputStream = fs.createWriteStream(output);
-                        
-            
-            var i = 0, len = src.length;            
+
+
+            var i = 0, len = src.length;
             var processList = function(method, files, target, zipInstance, options, i, len, err) {
-                
+
                 if (i >= len || err) {
-                    
+
                     if (!err && zipInstance) {
-                                               
+
                         zipInstance
-                            .generateNodeStream({ compression: 'DEFLATE', compressionOptions : {level: options.level } })     
-                            .pipe(outputStream); 
-                            
+                            .generateNodeStream({ compression: 'DEFLATE', compressionOptions : {level: options.level } })
+                            .pipe(outputStream);
+
                         outputStream
-                            .once('err', function(){   
-                                outputStream.close();            
+                            .once('err', function(){
+                                outputStream.close();
                                 self.emit('archiver-'+ method +'#complete', err, null);
                             })
-                            .once('finish', function(){             
+                            .once('finish', function(){
                                 outputStream.close();
                                 self.emit('archiver-'+ method +'#complete', false, this.path);
                             })
-                            
+
                     } else {
                         self.emit('archiver-'+ method +'#complete', err, null);
                     }
-                    
+
                     return
                 }
-                
-                
+
+
                 if ( typeof(files[i]) == 'undefined' ) {
                     console.warn('[ lib/archiver ] undefined file found: cannot process index `'+ i +'`, skipping to next index');
-                    return processList(method, files, target, zipInstance, options, i+1, len, err);                    
+                    return processList(method, files, target, zipInstance, options, i+1, len, err);
                 }
-                
+
                 if ( !fs.existsSync(files[i].input) ) {
                     console.warn('[ lib/archiver ] src `'+ files[i].input +'` not found at index `'+ i +'`: skipping to next src');
                     return processList(method, files, target, zipInstance, options, i+1, len, err);
                 }
-                           
+
                 // 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(/^(\.\/|\/)/, '');
                     zipInstance.folder( newFolder )
                 }
-                
+
                 if ( fs.statSync(files[i].input).isDirectory() ) {
                     files[i].output = options.root + files[i].output;
                 }
-                
+
                 processSrc(method, files[i].input, files[i].output, zipInstance, options, function onSrcProcessed(err, zipInstance){
                     processList(method, src, target, zipInstance, options, i+1, len, err);
                 });
-                
+
                 return
-                
+
             }
-            
+
             processList(method, src, target, zipInstance, options, i, len, false);
-            
+
         } else {
             var err = new Error('[ lib/archiver ] `src` must be a `string` or an `array`');
             err.status = 500;
             self.emit('archiver-'+ method +'#complete', err, null)
         }
-        
+
     }
-    
+
     var compressFile = function(method, input, output, zipInstance, isBatchProcessing, cb, isPackage) {
-        
+
         var methodObject = null;
         isPackage = ( typeof(isPackage) == 'undefined' ) ? false: isPackage;
-        
+
         if ( isBatchProcessing ) {
-            
+
             zipInstance.file(output, fs.createReadStream(input));
-            
+
             cb(false, output, zipInstance);
             return
         }
-        
+
         switch (method) {
             case 'gzip':
                 methodObject = zlib.createGzip();
                 break;
-        
+
             default:
                 methodObject = zlib.createGzip();
                 break;
         }
-        
-        
+
+
         if ( /\/\.(.*)$/.test(input.path) ) {
-           
+
             if (isPackage) {
                 cb(false, input)
             } else {
                 cb(false, input.path)
-            }  
-            return 
+            }
+            return
         } else {
             input
                 .pipe(methodObject)
-                .pipe(output);   
+                .pipe(output);
         }
-            
-            
+
+
         output
             .once('error', function onCompressionError(err) {
                 cb(err, null)
@@ -349,33 +349,33 @@ function Archiver() {
                     cb(false, this, zipInstance)
                 } else {
                     cb(false, this.path, zipInstance)
-                }                
-            });            
-        
+                }
+            });
+
     }
-    
+
     var browse = function(method, dir, target, zipInstance, options, files, outFiles, i, mainOutput, isBatchProcessing, cb) {
-        
+
         var input  = null, output = null;
         var f = null, fLen = null;
         if (files.length == 0) {
             files.push(dir);
-            
+
             outFiles.push(target +'.zip');
-            
+
             if (!isBatchProcessing) {
                 if ( fs.existsSync(outFiles[0])) {
                     fs.unlinkSync(outFiles[0]);
                 }
-                
+
                 mainOutput = fs.createWriteStream(outFiles[0]);
-                
+
                 // main zip dir
-                target = zipFolder =  '.'+ dir.substr(dir.lastIndexOf('/')) + '/';            
+                target = zipFolder =  '.'+ dir.substr(dir.lastIndexOf('/')) + '/';
                 zipInstance.folder(zipFolder);
             }
-                    
-                        
+
+
             var list = fs.readdirSync(dir);
             f = 1; fLen = list.length;
             for (; f < fLen; ++f) {
@@ -386,53 +386,53 @@ function Archiver() {
             }
             ++i
         }
-        
+
         var filename  = files[i];
-        
+
         if ( /^(\.|\.\.)$/.test(filename) ) {// ignore this
             browse(method, dir, target, zipInstance, options, files, outFiles, i+1, mainOutput, isBatchProcessing, cb)
         }
-        
-        
-        
+
+
+
         // scan completed
         if ( typeof(filename) == 'undefined' ) {
-            
-            if ( isBatchProcessing ) {                
-                cb(false, null, zipInstance) 
+
+            if ( isBatchProcessing ) {
+                cb(false, null, zipInstance)
                 return
             }
-                        
+
             zipInstance
-                .generateNodeStream({ compression: 'DEFLATE', compressionOptions : {level: local.options.level } })     
-                .pipe(mainOutput);   
-                    
+                .generateNodeStream({ compression: 'DEFLATE', compressionOptions : {level: local.options.level } })
+                .pipe(mainOutput);
+
             mainOutput
-                .once('err', function(){   
-                    mainOutput.close();            
-                    cb(err, null); 
+                .once('err', function(){
+                    mainOutput.close();
+                    cb(err, null);
                 })
-                .once('finish', function(){             
+                .once('finish', function(){
                     mainOutput.close();
-                    cb(false, this.path); 
+                    cb(false, this.path);
                 })
-            
+
         } else {
-            
+
             if ( !fs.existsSync(filename) ) {
                 throw new Error('filename not found: '+ filename)
             }
-            
+
             var stats = fs.statSync(filename);
-            
+
             if ( stats.isFile() ) {
-                
+
                 input   = fs.createReadStream(filename);
-                // output  = fs.createWriteStream(outFiles[i]);  
-                
+                // output  = fs.createWriteStream(outFiles[i]);
+
                 zipInstance.file(outFiles[i], input);
                 browse(method, dir, target, zipInstance, options, files, outFiles, i+1, mainOutput, isBatchProcessing, cb);
-                
+
                 // ------------------------------------ once we get a method to retrieve the archive headers
                 // compressFile(method, input, output, zipInstance, isBatchProcessing, function(err, output) {
                 //     if (err) {
@@ -442,16 +442,16 @@ function Archiver() {
                 //         browse(method, dir, target, zipInstance, options, files, outFiles, i+1, mainOutput, isBatchProcessing, cb)
                 //     }
                 // }, true);
-                        
+
             } else {
                 var newDir      = filename;
                 var moreFiles   = fs.readdirSync(newDir);
-                var newTarget   = (isBatchProcessing) 
+                var newTarget   = (isBatchProcessing)
                                     ? newDir.substr( newDir.lastIndexOf( '/'+target.substr(1).replace(options.root.substr(1), '') ) ) +'/'
                                     : '.'+ newDir.substr( newDir.lastIndexOf(options.root.substr(1))) +'/'
                 ;
-                zipInstance.folder(newTarget);         
-            
+                zipInstance.folder(newTarget);
+
                 var index = i+1;
                 f = 0; fLen = moreFiles.length;
                 for (; f < fLen; ++f) {
@@ -459,34 +459,34 @@ function Archiver() {
                     files.splice(index, 0, newDir +'/'+ moreFiles[f]);
                     // update output list
                     outFiles.splice(index, 0, newTarget + moreFiles[f]);
-                    
+
                     ++index;
                 }
-                
+
                 browse(method, newDir, target, zipInstance, options, files, outFiles, i+1, mainOutput, isBatchProcessing, cb)
-            }  
-        }           
-                                  
+            }
+        }
+
     }
-    
-    
-    
+
+
+
     this.decompress = function(src, target, options) {
-        
+
     }
-    
+
     this.compressFromStream = function(readStream, target, options) {
-        
+
     }
-    
+
     this.compressHttpResponse = function(request, response, options) {
-        
+
     }
-    
+
     this.addSignature = function(filename, options) {
-        
+
     }
-    
+
 }
 
 if ( typeof(module) !== 'undefined' && module.exports ) {

package/framework/{v0.1.1-alpha.21 → v0.1.1-alpha.210}/lib/cmd/aliases.json

@@ -8,6 +8,9 @@
         "-r" : "restart",
         "--restart" : "restart",
         "-v" : "version",
-        "--version" : "version"
+        "--version" : "version",
+        "-ln" : "link",
+        "--link" : "link",
+        "--link-node-modules": "link-node-modules"
     }
 }