gina 0.3.2 → 0.3.3

package/framework/v0.3.3/lib/cmd/port/set.js

@@ -0,0 +1,348 @@
+var fs = require('fs');
+var readline = require('readline');
+var CmdHelper = require('./../helper');
+var console = lib.logger;
+
+/**
+ * @module gina/lib/cmd/port/set
+ */
+/**
+ * Sets or updates the port number for a bundle/environment/protocol/scheme combination.
+ *
+ * Usage (positional):
+ *  gina port:set <bundle_name> @<project_name>
+ *  gina port:set <protocol>:<port_number> <bundle_name> @<project_name>/<environment>
+ *
+ * Usage (flags):
+ *  gina port:set <bundle_name> @<project_name> --protocol=http/1.1 --scheme=http --port=3200 --env=dev
+ *
+ * When a required value is omitted, the user is prompted interactively.
+ *
+ * @class Set
+ * @constructor
+ * @param {object} opt - Parsed command-line options
+ * @param {object} opt.client - Socket client for terminal output
+ * @param {string[]} opt.argv - Full argv array
+ * @param {number} [opt.debugPort] - Node.js inspector port
+ * @param {boolean} [opt.debugBrkEnabled] - True when --inspect-brk is active
+ * @param {object} cmd - The cmd dispatcher object (lib/cmd/index.js)
+ */
+function Set(opt, cmd) {
+
+    var self = {}, local = {};
+    var requestedProtocol = null
+        , requestedScheme = null
+        , requestedPort   = null
+        , requestedEnv    = null
+    ;
+
+    // Pre-parse argv before CmdHelper to extract protocol:port and @project/env
+    // CmdHelper would misclassify the positional protocol:port as a bundle name
+    // and fail on @project/env because the project name would include the /env suffix.
+    (function preParseArgs() {
+        var cleaned = process.argv.slice(0, 3);
+        for (var i = 3; i < process.argv.length; i++) {
+            var arg = process.argv[i];
+
+            // Positional protocol:port (e.g. http/1.1:3200, http/2.0:8443)
+            var m = arg.match(/^([a-z]+\/[0-9.]+)\:(\d+)$/);
+            if (m) {
+                requestedProtocol = m[1];
+                requestedPort     = ~~m[2];
+                continue;
+            }
+
+            // @project/env  →  extract env, pass clean @project to CmdHelper
+            if ( /^\@[a-z0-9_.]/.test(arg) && arg.indexOf('/') > 0 ) {
+                var slash = arg.indexOf('/');
+                requestedEnv = arg.substring(slash + 1);
+                cleaned.push( arg.substring(0, slash) );
+                continue;
+            }
+
+            // Flag-based overrides
+            if ( /^\-\-port\=/.test(arg) )     { requestedPort     = ~~arg.split('=')[1]; continue; }
+            if ( /^\-\-protocol\=/.test(arg) ) { requestedProtocol = arg.split('=')[1];   continue; }
+            if ( /^\-\-scheme\=/.test(arg) )   { requestedScheme   = arg.split('=')[1];   continue; }
+            if ( /^\-\-env\=/.test(arg) )      { requestedEnv      = arg.split('=')[1];   continue; }
+
+            cleaned.push(arg);
+        }
+        process.argv = cleaned;
+    })();
+
+
+    var init = function() {
+
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+
+        // check CMD configuration
+        if (!isCmdConfigured()) return false;
+
+        if (!self.name || !self.projectName) {
+            console.error('Usage: gina port:set <bundle_name> @<project_name>');
+            process.exit(1);
+        }
+
+        // Default scheme from protocol when not explicitly given
+        if (requestedProtocol && !requestedScheme) {
+            requestedScheme = /^http\/2/.test(requestedProtocol) ? 'https' : self.defaultScheme;
+        }
+
+        // If all params are present, set directly; otherwise prompt for missing ones
+        if (requestedProtocol && requestedScheme && requestedPort && requestedEnv) {
+            setPort(requestedProtocol, requestedScheme, requestedPort, requestedEnv);
+        } else {
+            promptMissing();
+        }
+    };
+
+
+    /**
+     * Interactively prompts for any missing parameter (protocol, scheme, env, port)
+     * using readline, then delegates to setPort().
+     *
+     * @inner
+     * @private
+     */
+    var promptMissing = function() {
+        var rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        var steps = [];
+
+        // --- protocol ---
+        if (!requestedProtocol) {
+            steps.push(function(cb) {
+                var choices = self.protocolsAvailable;
+                var list = '';
+                for (var i = 0; i < choices.length; i++) {
+                    var def = (choices[i] === self.defaultProtocol) ? ' - default' : '';
+                    list += '\n (' + (i+1) + ') ' + choices[i] + def;
+                }
+                list += '\n\n (c) cancel';
+                rl.question('Choose a protocol:' + list + '\r\n> ', function(answer) {
+                    answer = answer.trim().toLowerCase();
+                    if ( /^(c|cancel)$/.test(answer) ) { rl.close(); process.exit(0); }
+                    var idx = ~~answer - 1;
+                    if (idx >= 0 && idx < choices.length) {
+                        requestedProtocol = choices[idx];
+                    } else if (choices.indexOf(answer) > -1) {
+                        requestedProtocol = answer;
+                    } else {
+                        console.error('Invalid choice.');
+                        rl.close(); process.exit(1);
+                    }
+                    cb();
+                });
+            });
+        }
+
+        // --- scheme ---
+        if (!requestedScheme) {
+            steps.push(function(cb) {
+                // auto-derive when possible
+                if (requestedProtocol && /^http\/2/.test(requestedProtocol)) {
+                    requestedScheme = 'https';
+                    return cb();
+                }
+                var choices = self.schemesAvailable;
+                var list = '';
+                for (var i = 0; i < choices.length; i++) {
+                    var def = (choices[i] === self.defaultScheme) ? ' - default' : '';
+                    list += '\n (' + (i+1) + ') ' + choices[i] + def;
+                }
+                list += '\n\n (c) cancel';
+                rl.question('Choose a scheme:' + list + '\r\n> ', function(answer) {
+                    answer = answer.trim().toLowerCase();
+                    if ( /^(c|cancel)$/.test(answer) ) { rl.close(); process.exit(0); }
+                    var idx = ~~answer - 1;
+                    if (idx >= 0 && idx < choices.length) {
+                        requestedScheme = choices[idx];
+                    } else if (choices.indexOf(answer) > -1) {
+                        requestedScheme = answer;
+                    } else {
+                        console.error('Invalid choice.');
+                        rl.close(); process.exit(1);
+                    }
+                    cb();
+                });
+            });
+        }
+
+        // --- environment ---
+        if (!requestedEnv) {
+            steps.push(function(cb) {
+                var choices = self.envs;
+                var list = '';
+                for (var i = 0; i < choices.length; i++) {
+                    var def = (choices[i] === self.defaultEnv) ? ' - default' : '';
+                    list += '\n (' + (i+1) + ') ' + choices[i] + def;
+                }
+                list += '\n\n (c) cancel';
+                rl.question('Choose an environment:' + list + '\r\n> ', function(answer) {
+                    answer = answer.trim().toLowerCase();
+                    if ( /^(c|cancel)$/.test(answer) ) { rl.close(); process.exit(0); }
+                    var idx = ~~answer - 1;
+                    if (idx >= 0 && idx < choices.length) {
+                        requestedEnv = choices[idx];
+                    } else if (choices.indexOf(answer) > -1) {
+                        requestedEnv = answer;
+                    } else {
+                        console.error('Invalid choice.');
+                        rl.close(); process.exit(1);
+                    }
+                    cb();
+                });
+            });
+        }
+
+        // --- port number ---
+        if (!requestedPort) {
+            steps.push(function(cb) {
+                rl.question('Enter port number:\r\n> ', function(answer) {
+                    answer = answer.trim();
+                    if ( /^(c|cancel)$/.test(answer) ) { rl.close(); process.exit(0); }
+                    requestedPort = ~~answer;
+                    if (!requestedPort || requestedPort < 1 || requestedPort > 65535) {
+                        console.error('Invalid port number. Must be between 1 and 65535.');
+                        rl.close(); process.exit(1);
+                    }
+                    cb();
+                });
+            });
+        }
+
+        // Run prompt steps sequentially, then apply
+        var runSteps = function(i) {
+            if (i >= steps.length) {
+                rl.close();
+                setPort(requestedProtocol, requestedScheme, requestedPort, requestedEnv);
+                return;
+            }
+            steps[i](function() { runSteps(i + 1); });
+        };
+        runSteps(0);
+    };
+
+
+    /**
+     * Validates inputs and writes the port assignment to ports.json and
+     * ports.reverse.json. Removes any previous assignment for the same
+     * bundle/env/protocol/scheme before writing the new one.
+     *
+     * @inner
+     * @private
+     * @param {string} protocol - e.g. 'http/1.1', 'http/2.0'
+     * @param {string} scheme   - e.g. 'http', 'https'
+     * @param {number} port     - Port number to assign
+     * @param {string} env      - Environment name (e.g. 'dev', 'staging')
+     */
+    var setPort = function(protocol, scheme, port, env) {
+
+        // --- validation ---
+        if ( self.protocolsAvailable.indexOf(protocol) < 0 ) {
+            console.error('Protocol [ '+ protocol +' ] is not allowed. Available: '+ self.protocolsAvailable.join(', '));
+            process.exit(1);
+        }
+        if ( self.schemesAvailable.indexOf(scheme) < 0 ) {
+            console.error('Scheme [ '+ scheme +' ] is not allowed. Available: '+ self.schemesAvailable.join(', '));
+            process.exit(1);
+        }
+        if ( self.envs.indexOf(env) < 0 ) {
+            console.error('Environment [ '+ env +' ] is not defined. Available: '+ self.envs.join(', '));
+            process.exit(1);
+        }
+        if ( port < 1 || port > 65535 ) {
+            console.error('Port must be between 1 and 65535.');
+            process.exit(1);
+        }
+        // Reserved range (Gina infrastructure)
+        if ( port >= 4100 && port <= 4199 ) {
+            console.error('Ports 4100-4199 are reserved for Gina infrastructure.');
+            process.exit(1);
+        }
+
+        loadAssets();
+
+        var ports        = requireJSON(_(self.portsPath));
+        var portsReverse = requireJSON(_(self.portsReversePath));
+
+        var bundleKey = self.name +'@'+ self.projectName;
+        var portValue = bundleKey +'/'+ env;
+        var portStr   = ''+ port;
+
+        // Check if port is already assigned to a different bundle/env
+        if (
+            typeof(ports[protocol]) != 'undefined'
+            && typeof(ports[protocol][scheme]) != 'undefined'
+            && typeof(ports[protocol][scheme][portStr]) != 'undefined'
+            && ports[protocol][scheme][portStr] !== portValue
+        ) {
+            console.error('Port '+ port +' is already assigned to '+ ports[protocol][scheme][portStr]);
+            process.exit(1);
+        }
+
+        // Remove previous port for this bundle/env/protocol/scheme (if reassigning)
+        if ( typeof(ports[protocol]) != 'undefined' && typeof(ports[protocol][scheme]) != 'undefined' ) {
+            for (var p in ports[protocol][scheme]) {
+                if ( ports[protocol][scheme][p] === portValue ) {
+                    delete ports[protocol][scheme][p];
+                    break;
+                }
+            }
+        }
+
+        // Ensure structure exists
+        if ( typeof(ports[protocol]) == 'undefined' )          ports[protocol] = {};
+        if ( typeof(ports[protocol][scheme]) == 'undefined' )  ports[protocol][scheme] = {};
+
+        // Write new assignment
+        ports[protocol][scheme][portStr] = portValue;
+
+        // Update reverse map
+        if ( typeof(portsReverse[bundleKey]) == 'undefined' )                       portsReverse[bundleKey] = {};
+        if ( typeof(portsReverse[bundleKey][env]) == 'undefined' )                  portsReverse[bundleKey][env] = {};
+        if ( typeof(portsReverse[bundleKey][env][protocol]) == 'undefined' )        portsReverse[bundleKey][env][protocol] = {};
+        portsReverse[bundleKey][env][protocol][scheme] = ~~port;
+
+        // Persist
+        lib.generator.createFileFromDataSync(ports, self.portsPath);
+        lib.generator.createFileFromDataSync(portsReverse, self.portsReversePath);
+
+        console.log('Port '+ port +' assigned to '+ portValue +' ('+ protocol +'/'+ scheme +')');
+        end('You may need to restart the bundle for the change to take effect.');
+    };
+
+
+    /**
+     * Prints optional output and exits the process.
+     *
+     * @inner
+     * @private
+     * @param {string|Error} [output] - Message or Error to display
+     * @param {string} [type] - console method to call (e.g. 'error', 'warn')
+     * @param {boolean} [messageOnly] - When true, print only the message, not the stack
+     */
+    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.3.2 → v0.3.3}/lib/collection/src/main.js

@@ -12,7 +12,7 @@ if ( typeof(module) !== 'undefined' && module.exports ) {
  * `Collection.length` returns entry count — do not use `.count()` as it
  * includes function properties in the count.
  *
- * Dependencies: `lib/merge`, `uuid`
+ * Dependencies: `lib/merge`, `lib/uuid`
  */
 
 /**
@@ -53,7 +53,7 @@ if ( typeof(module) !== 'undefined' && module.exports ) {
 function Collection(content, options) {
 
     var isGFFCtx        = ( ( typeof(module) !== 'undefined' ) && module.exports ) ? false : true;
-    var uuid            = { v4: function() { return crypto.randomUUID(); } };
+    var uuid            = (isGFFCtx) ? require('lib/uuid') : require('../../../lib/uuid');
     var merge           = (isGFFCtx) ? require('lib/merge') : require('../../../lib/merge');
 
     // defined search option rules
@@ -110,7 +110,7 @@ function Collection(content, options) {
         if ( typeof(content[entry]._uuid) != 'undefined' ) {
             content[entry]._hasItsOwnUuid = true;
         } else {
-            content[entry]._uuid = uuid.v4();
+            content[entry]._uuid = uuid();
         }
 
         // To avoid duplicate entries
@@ -871,7 +871,7 @@ function Collection(content, options) {
             var tmpContent = Array.isArray(this) ? this : content;
 
             // Indexing;
-            set._uuid = uuid.v4();
+            set._uuid = uuid();
             tmpContent.push(set);
 
             result = tmpContent;

package/framework/{v0.3.2 → v0.3.3}/lib/index.js

@@ -69,6 +69,7 @@ function Lib() {
         SessionStore    : _require('./session-store'),
         SwigFilters     : _require('./swig-filters'),
         Cache           : _require('./cache'),
+        uuid            : _require('./uuid'),
         // #R1 — WatcherService: fs.watch-based file-change registry. Class is hot-reloadable;
         // instantiated once per bundle in gna.js:onStarted and stored as gna.watcher.
         Watcher         : _require('./watcher'),

package/framework/{v0.3.2 → v0.3.3}/lib/logger/src/containers/mq/listener.js

@@ -3,7 +3,7 @@
 const fs      = require('fs');
 // const util                = require('util');
 const net     = require('net');
-const { randomUUID } = require('crypto');
+var uuid = require('../../../../uuid');
 
 function MQListener(opt, cb) {
     var self = {
@@ -154,7 +154,7 @@ function MQListener(opt, cb) {
         var host = opt.hostV4;
         var server = net.createServer( function(conn) {//'connection' listener
 
-            conn.sessionId = randomUUID();
+            conn.sessionId = uuid();
             // conn.request = 'report'; // by default
             sessions[conn.sessionId] = conn;
             conn.write(JSON.stringify({ sessionId: conn.sessionId }) +'\r\n' );

package/framework/v0.3.3/lib/uuid/package.json

@@ -0,0 +1,7 @@
+{
+    "name": "gina-lib-uuid",
+    "version": "1.0.0",
+    "description": "Lightweight uuid generator (base-62, zero dependencies)",
+    "main": "src/main",
+    "license": "MIT"
+}

package/framework/v0.3.3/lib/uuid/src/main.js

@@ -0,0 +1,99 @@
+'use strict';
+/**
+ * @module lib/uuid
+ * @description Lightweight, cryptographically secure ID generator.
+ * Produces short random strings from a base-62 alphabet (0-9 A-Z a-z).
+ * Uses `crypto.getRandomValues` (available in Node.js >= 15 and all modern browsers).
+ * Bitmask technique avoids modulo bias — identical to the approach used by the
+ * `nanoid` npm package, but with zero external dependencies.
+ *
+ * Works in Node.js (CommonJS) and browser (AMD / GFF) contexts.
+ *
+ * @example
+ * var uuid = require('lib/uuid');
+ * uuid();    // 'aB3x'  (4 chars, base-62 default)
+ * uuid(8);   // 'kQ7mZp2R'
+ *
+ * // Custom alphabet
+ * var hex = uuid.customAlphabet('0123456789abcdef', 8);
+ * hex();     // 'f47ac10b'  (8 chars, hex)
+ * hex(4);    // 'a3f1'      (override length)
+ *
+ * @param {number} [size=4] - Length of the generated ID
+ * @returns {string} Random string of `size` characters from the base-62 alphabet
+ */
+
+var _alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+var _mask = 63;  // smallest (2^n - 1) >= 62 — rejects 62,63 (~3% waste, no bias)
+var _step = 7;   // ceil(1.6 * 63 * 4 / 62) — enough random bytes per iteration
+
+/**
+ * Generate a cryptographically secure random ID.
+ *
+ * @param {number} [size=4] - Desired ID length
+ * @returns {string} Random base-62 string
+ */
+function uuid(size) {
+    size = size || 4;
+    var id = '';
+    while (true) {
+        var bytes = crypto.getRandomValues(new Uint8Array(_step));
+        for (var j = 0; j < _step; j++) {
+            var idx = bytes[j] & _mask;
+            if (idx < 62) {
+                id += _alphabet[idx];
+                if (id.length === size) return id;
+            }
+        }
+    }
+}
+
+/**
+ * Create a generator function for a custom alphabet and default size.
+ *
+ * @param {string} alphabet - Characters to use (e.g. '0123456789abcdef')
+ * @param {number} [defaultSize=4] - Default length when the returned function is called without arguments
+ * @returns {function(number=): string} Generator function
+ */
+uuid.customAlphabet = function(alphabet, defaultSize) {
+    defaultSize = defaultSize || 4;
+    // Compute bitmask: smallest (2^n - 1) >= alphabet.length - 1
+    var mask = 1;
+    while (mask < alphabet.length - 1) mask = (mask << 1) | 1;
+    // Step: enough random bytes per iteration to fill `defaultSize` with ~60% overhead
+    var step = Math.ceil(1.6 * (mask + 1) * defaultSize / alphabet.length);
+    if (step < 5) step = 5;
+
+    return function(size) {
+        size = size || defaultSize;
+        var id = '';
+        while (true) {
+            var bytes = crypto.getRandomValues(new Uint8Array(step));
+            for (var j = 0; j < step; j++) {
+                var idx = bytes[j] & mask;
+                if (idx < alphabet.length) {
+                    id += alphabet[idx];
+                    if (id.length === size) return id;
+                }
+            }
+        }
+    };
+};
+
+
+if ( ( typeof(module) !== 'undefined' ) && module.exports ) {
+    // Server-side: ensure crypto.getRandomValues is available (Node < 19 polyfill)
+    if ( typeof(crypto) === 'undefined' || typeof(crypto.getRandomValues) !== 'function' ) {
+        var _webcrypto = require('crypto').webcrypto || require('crypto');
+        if (typeof(globalThis) !== 'undefined') {
+            globalThis.crypto = _webcrypto;
+        } else {
+            crypto = _webcrypto;
+        }
+    }
+    // Publish as node.js module
+    module.exports = uuid
+} else if ( typeof(define) === 'function' && define.amd) {
+    // Publish as AMD module
+    define( function() { return uuid })
+}

package/framework/v0.3.3/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "gina-framework",
+  "version": "0.3.0-alpha.1",
+  "dependecies": {},
+  "dependencies": {
+    "@rhinostone/swig": "^1.4.4"
+  }
+}

package/gna.js

@@ -0,0 +1,86 @@
+/**
+ * Gina — Explicit exports for global helpers
+ *
+ * Usage:
+ *   const { getContext, _, onCompleteCall } = require('gina/gna');
+ *
+ * All symbols are also available as globals at runtime (no import required).
+ * This module provides explicit exports so IDEs can navigate to definitions
+ * and static analysis tools can verify usage.
+ *
+ * Getters are used so that symbols resolve at access time (after framework boot),
+ * not at require() time.
+ */
+
+'use strict';
+
+// Framework core — the main gna module (lifecycle hooks, lib, etc.)
+var _gna = require('./framework/v0.3.3-alpha.3/core/gna');
+
+// SuperController and EntitySuper — loaded from their source modules
+var SuperController = require('./framework/v0.3.3-alpha.3/core/controller');
+var EntitySuper     = require('./framework/v0.3.3-alpha.3/core/model/entity');
+
+// uuid — from the lib registry
+var uuid = require('./framework/v0.3.3-alpha.3/lib/uuid');
+
+module.exports = {
+
+    // ── Context helpers ──────────────────────────────────────────────────
+
+    get setContext()   { return global.setContext; },
+    get getContext()   { return global.getContext; },
+    get resetContext() { return global.resetContext; },
+    get getConfig()    { return global.getConfig; },
+    get getLib()       { return global.getLib; },
+    get whisper()      { return global.whisper; },
+    get define()       { return global.define; },
+    get getDefined()   { return global.getDefined; },
+
+    // ── Path helpers ─────────────────────────────────────────────────────
+
+    get _()               { return global._; },
+    get setPath()         { return global.setPath; },
+    get getPath()         { return global.getPath; },
+    get setPaths()        { return global.setPaths; },
+    get getPaths()        { return global.getPaths; },
+    get onCompleteCall()  { return global.onCompleteCall; },
+
+    // ── Model helpers ────────────────────────────────────────────────────
+
+    get getModel()       { return global.getModel; },
+    get getModelEntity() { return global.getModelEntity; },
+
+    // ── JSON helper ──────────────────────────────────────────────────────
+
+    get requireJSON() { return global.requireJSON; },
+
+    // ── Task helper ──────────────────────────────────────────────────────
+
+    get run() { return global.run; },
+
+    // ── Env helpers ──────────────────────────────────────────────────────
+
+    get getUserHome()  { return global.getUserHome; },
+    get getEnvVar()    { return global.getEnvVar; },
+    get getEnvVars()   { return global.getEnvVars; },
+    get setEnvVar()    { return global.setEnvVar; },
+    get getLogDir()    { return global.getLogDir; },
+    get getRunDir()    { return global.getRunDir; },
+    get getTmpDir()    { return global.getTmpDir; },
+    get parseTimeout() { return global.parseTimeout; },
+    get isWin32()      { return global.isWin32; },
+
+    // ── Classes ──────────────────────────────────────────────────────────
+
+    SuperController: SuperController,
+    EntitySuper:     EntitySuper,
+
+    // ── uuid ─────────────────────────────────────────────────────────────
+
+    uuid: uuid,
+
+    // ── ApiError ─────────────────────────────────────────────────────────
+
+    get ApiError() { return global.ApiError; }
+};