gina 0.6.20 → 0.6.21

package/framework/{v0.6.20 → v0.6.21}/core/model/entity.js

@@ -686,7 +686,7 @@ function EntitySuper(conn, caller, injected) {
                         //         delete this._arguments[trigger];
                         //     }
                         // })
-                        .once(trigger, function () {// patched for Air Liquide: case when emit occurs before listener is ready
+                        .once(trigger, function () {// buffers an emit that arrives before its listener is attached
                             if (!this._arguments) {
                                 this._arguments = {}
                             }

package/framework/{v0.6.20 → v0.6.21}/core/plugins/lib/validator/src/main.js

@@ -8014,8 +8014,21 @@ function ValidatorPlugin(rules, data, formId, culture) {
                 _evt = 'keydown.'+$el.id
             }
             if (gina.events[_evt]) {
-                cancelEvent(event);
-                triggerEvent(gina, $el, _evt, event.detail, event);
+                // #B444 - dispatch FIRST and let the namespaced handler decide:
+                // the native keydown is cancelled only when that handler asked
+                // for it (it prevents the synthetic event on the paths it
+                // re-implements, and deliberately does not on modifier chords,
+                // per the interception's own contract). Cancelling BEFORE the
+                // dispatch suppressed the browser's own editing commands for
+                // every chord - on a real-Safari UA that made paste, select-all,
+                // copy, cut and undo all dead on any live-checked
+                // autocomplete-suppressed field, with no event observable
+                // anywhere (gh issue #67).
+                // was: cancelEvent(event); triggerEvent(gina, $el, _evt, event.detail, event);
+                var _syntheticEvt = triggerEvent(gina, $el, _evt, event.detail, event);
+                if ( _syntheticEvt && _syntheticEvt.defaultPrevented ) {
+                    cancelEvent(event);
+                }
             }
         };
         var keyupProxyHandler = function(event) {

package/framework/{v0.6.20 → v0.6.21}/lib/merge/src/main.js

@@ -326,11 +326,16 @@ function Merge() {
                 && options[0] != null
                 && typeof(options[0][keyComparison]) != 'undefined'
                 && typeof(target[0]) == 'object'
+                // #B443 - typeof passes for a null first element; mirror the
+                // options-side check two lines above or the next line dereferences it
+                && target[0] != null
                 && typeof(target[0][keyComparison]) != 'undefined'
             ) {
 
                 newTarget =  (Array.isArray(target)) ? Array.from(target) : JSON.clone(target);
                 for (var nt = 0, ntLen = newTarget.length; nt < ntLen; ++nt) {
+                    // #B443 - a null (or hole) at a later index has no key to contribute
+                    if (newTarget[nt] == null) { continue; }
                     newTargetIds.push(newTarget[nt][keyComparison]);
                 }
 
@@ -340,6 +345,10 @@ function Merge() {
                 aLen = _options.length;
                 for (var n = next || 0, nLen = target.length; n < nLen; ++n) {
 
+                    // #B443 - a null target element has no key: it can match nothing,
+                    // so it neither blocks nor contributes; skip the comparison slot
+                    if (target[n] == null) { continue; }
+
                     // if (newTargetIds.indexOf(target[n][keyComparison]) == -1) {
                     //     newTargetIds.push(target[n][keyComparison]);
 
@@ -350,6 +359,10 @@ function Merge() {
                     label:
                     for (a = a || 0; a < aLen; ++a) {
 
+                        // #B443 - same disposition for a null source element: no key,
+                        // nothing to push, advance the cursor past it
+                        if (_options[a] == null) { continue; }
+
                         if (_options[a][keyComparison] === target[n][keyComparison] ) {
 
                             if (newTargetIds.indexOf(_options[a][keyComparison]) > -1) {
@@ -433,6 +446,9 @@ function Merge() {
                 && options[0] != null
                 && typeof(options[0][keyComparison]) != 'undefined'
                 && typeof(target[0]) == 'object'
+                // #B443 - typeof passes for a null first element; mirror the
+                // options-side check two lines above or the next line dereferences it
+                && target[0] != null
                 && typeof(target[0][keyComparison]) != 'undefined'
             ) {
 
@@ -443,11 +459,17 @@ function Merge() {
                 i = 0;
                 a = 0; aLen = newTarget.length;
                 for (; a < aLen; ++a) {
+                    // #B443 - a null (or hole) at a later index has no key to contribute
+                    if (newTarget[a] == null) { continue; }
                     newTargetIds.push(newTarget[a][keyComparison]);
                 }
                 a = 0;
                 for (; a < aLen; ++a) {
 
+                    // #B443 - a null slot on the rebuilt target has no key; both arms
+                    // of the comparison below dereference it
+                    if (newTarget[a] == null) { continue; }
+
                     end:
                         for (var n = next || 0, nLen = _options.length; n < nLen; ++n) {
 
@@ -561,6 +583,7 @@ function Merge() {
                             && !/null/i.test(target[a])
                             && typeof (target[a][keyComparison]) != 'undefined'
                             && typeof (options[a]) != 'undefined'
+                            && options[a] != null
                             && typeof (options[a][keyComparison]) != 'undefined'
                             && target[a][keyComparison] == options[a][keyComparison]
                         ) {
@@ -581,6 +604,7 @@ function Merge() {
                             && !/null/i.test(target[a])
                             && typeof (target[a][localKeyComparison]) != 'undefined'
                             && typeof (options[a]) != 'undefined'
+                            && options[a] != null
                             && typeof (options[a][localKeyComparison]) != 'undefined'
                             && target[a][localKeyComparison] == options[a][localKeyComparison]
                         ) {

package/framework/{v0.6.20 → v0.6.21}/lib/routing/src/main.js

@@ -1280,13 +1280,27 @@ function Routing() {
          * request current url
          * Attention: You should first try without an authentification middleware
          *
+         * The callback is settled EXACTLY ONCE, on every outcome: a successful response,
+         * a dial failure (ECONNREFUSED / EHOSTUNREACH / ENETUNREACH ...), a response stream
+         * that dies mid-body, or a timeout. Without a callback the request is fire-and-forget
+         * and a dial failure is reported with `console.warn` instead of being thrown.
          *
          * @param {boolean} [ignoreWebRoot]
          * @param {object} [options] - see: https://nodejs.org/api/https.html#https_new_agent_options
+         *      @param {number} [options.timeout] - milliseconds; on expiry the request is destroyed
+         *              and the callback settles with an Error carrying `code === 'ETIMEDOUT'`
          * @param {object} [_this] - current context: only used when `promisify`is used
          *
-         * @callback {callback} [cb] - see: https://nodejs.org/api/https.html#https_new_agent_options
-         *      @param {object} res
+         * @callback {callback} [cb]
+         *      @param {Error|string|boolean} err - an Error for transport failures, a string for a
+         *              broken response stream, `false` on success
+         *      @param {object|string} [data] - the response body, parsed when it is JSON
+         *
+         * @example
+         *      route.request(false, { timeout: 5000 }, function (err, data) {
+         *          if (err) { return handle(err); }
+         *          use(data);
+         *      });
          */
         route.request = function(ignoreWebRoot, options) {
 
@@ -1321,6 +1335,17 @@ function Routing() {
                 options.agent = false;
             }
             var agent = require(''+scheme);
+            // #B442: every exit path settles the caller exactly once. Before this guard the
+            // ClientRequest was discarded, so a dial failure had NO 'error' listener: a carved-out
+            // code (e.g. ECONNREFUSED, see lib/proc.js) left the caller waiting forever with
+            // nothing logged, and an uncarved one (ETIMEDOUT / EHOSTUNREACH / ENETUNREACH)
+            // escalated to uncaughtException and took the bundle down via dismiss(pid,'SIGTERM').
+            var settled = false;
+            var settle = function (err, data) {
+                if (settled) { return; }
+                settled = true;
+                cb(err, data);
+            };
             var onAgentResponse = function(res) {
 
                 var data = '', err = false;
@@ -1329,12 +1354,15 @@ function Routing() {
                     data += chunk;
                 });
                 res.on('error', function (error) {
-                    err = 'Failed to get mail content';
+                    // #B442: a response that dies mid-body never emits 'end', so assigning here
+                    // and waiting for 'end' to deliver meant the caller was never settled at all.
+                    err = 'route.request: response stream failed for ' + url;
                     if (error && typeof(error.stack) != 'undefined' ) {
-                        err += error.stack;
+                        err += '\n' + error.stack;
                     } else if ( typeof(error) == 'string' ) {
                         err += '\n' + error;
                     }
+                    settle(err);
                 });
                 res.on('end', function () {
                     if (/^\{/.test(data) ) {
@@ -1349,19 +1377,39 @@ function Routing() {
                         }
                     }
                     if (err) {
-                        cb(err);
+                        settle(err);
                         return;
                     }
 
-                    cb(false, data);
+                    settle(false, data);
                     return;
                 });
             }
+            var req = null;
             if (cb) {
-                agent.get(url, options, onAgentResponse);
+                req = agent.get(url, options, onAgentResponse);
+                // #B442: the dial-failure path. Without this the 'error' event has no listener.
+                req.on('error', function (error) {
+                    settle(error);
+                });
+                // #B442: `options.timeout` reaches http(s).get and Node EMITS 'timeout' without
+                // destroying the socket — and the request object used to be unreachable, so the
+                // option looked like a workaround and did nothing. Honour it here.
+                if ( options && typeof(options.timeout) != 'undefined' && options.timeout ) {
+                    req.on('timeout', function () {
+                        var e = new Error('route.request: timed out after ' + options.timeout + 'ms requesting ' + url);
+                        e.code = 'ETIMEDOUT';
+                        req.destroy(e);
+                    });
+                }
             } else {
                 // just throw the request without waiting/handling response
-                agent.get(url, options);
+                req = agent.get(url, options);
+                // #B442: nobody is waiting, but an unhandled 'error' here is still an
+                // uncaughtException — which is how a fire-and-forget call could kill the bundle.
+                req.on('error', function (error) {
+                    console.warn('[ ROUTING ] route.request: fire-and-forget request to ' + url + ' failed: ' + ( (error && error.message) ? error.message : error ));
+                });
             }
             return;
 

package/framework/{v0.6.20 → v0.6.21}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gina-framework",
-  "version": "0.6.20",
+  "version": "0.6.21",
   "dependencies": {
     "@rhinostone/busboy": "^1.6.1",
     "@rhinostone/swig": "^2.7.2",

package/gna.js

@@ -15,14 +15,14 @@
 'use strict';
 
 // Framework core — the main gna module (lifecycle hooks, lib, etc.)
-var _gna = require('./framework/v0.6.20/core/gna');
+var _gna = require('./framework/v0.6.21/core/gna');
 
 // SuperController and EntitySuper — loaded from their source modules
-var SuperController = require('./framework/v0.6.20/core/controller');
-var EntitySuper     = require('./framework/v0.6.20/core/model/entity');
+var SuperController = require('./framework/v0.6.21/core/controller');
+var EntitySuper     = require('./framework/v0.6.21/core/model/entity');
 
 // uuid — from the lib registry
-var uuid = require('./framework/v0.6.20/lib/uuid');
+var uuid = require('./framework/v0.6.21/lib/uuid');
 
 module.exports = {