gina 0.7.2 → 0.7.3

package/framework/{v0.7.2 → v0.7.3}/core/config.js

@@ -3013,6 +3013,11 @@ function Config(opt, contextResetNeeded) {
 
                         if ( typeof(files['templates'][section][ref]) == 'undefined' ) {
                             files['templates'][section][ref] = files['templates']._common[ref];
+                        } else if ( typeof(files['templates'][section][ref]) == 'boolean' ) {
+                            // #B772 — a page's own boolean is kept as it is: lib/merge returns
+                            // `true` for merge(false, true), so a page that set a `_common`
+                            // switch to `false` (assetVersioningEnabled, preloadHintsEnabled...)
+                            // used to get `true` back
                         } else {
                             files['templates'][section][ref] = merge(files['templates'][section][ref], files['templates']._common[ref]);
                         }

package/framework/{v0.7.2 → v0.7.3}/core/controller/controller.js

@@ -56,6 +56,10 @@ var inspectorRedact = require('../../lib/inspector-redact');
 // Compiled once: the pattern set is a module constant.
 var _carryRedactPatterns = inspectorRedact.compile(inspectorRedact.DEFAULT_PATTERNS);
 
+// #B765 — the size and the switch of the automatic preload hints (the 200
+// `link` header and the 103 Early Hints), shared with controller.render-swig.js.
+var preloadHints    = require('./preload-hints');
+
 /**
  * #A11Y3 — BCP-47 language tag for a framework-generated document.
  *
@@ -2435,6 +2439,8 @@ function SuperController(options) {
         if (_h2Links) {
             // trim trailing comma inserted by computeH2PreloadPrefix()
             var _hints = /,$/.test(_h2Links) ? _h2Links.slice(0, -1) : _h2Links;
+            // #B765 — templates.json's switch and size cap; duplicates dropped (#B767)
+            _hints = preloadHints.shapeLinks(_hints, (errOptions) ? errOptions.template : local.options.template);
             if (_hints) self.setEarlyHints(_hints);
         }
         // #B496 — restore the router's seed so the delegate's getNodeRes() accumulates
@@ -2763,13 +2769,25 @@ function SuperController(options) {
      * still preparing the final response.
      *
      *   HTTP/2  — `stream.additionalHeaders({ ':status': 103, link: '...' })`
-     *   HTTP/1.1 — `res.writeEarlyHints({ link: '...' })` (Node.js 18.11+)
+     *   HTTP/1.1 — only when `settings.json > server.earlyHintsOverHTTP1` is
+     *              `true` (#B771): `res.writeEarlyHints({ link: [...] })`, one
+     *              array element per entry (#B770), cut at the page's
+     *              `preloadHintsMaxSize` (templates.json, #B765)
+     *
+     * Why HTTP/1.1 is off by default: browsers act on a 103 only over HTTP/2
+     * and HTTP/3, so over HTTP/1.1 it reaches a reverse proxy, and nginx before
+     * 1.29 takes an upstream 103 for the final response, which breaks every
+     * page behind it. Turn it on behind a proxy that handles 103 (nginx 1.29 or
+     * later with `early_hints`, Apache).
      *
      * Silently no-ops when:
      *   - `links` is falsy or an empty array / string
      *   - headers have already been sent (guards against double-call)
+     *   - the request is HTTP/1.1 and `server.earlyHintsOverHTTP1` is not `true`
      *   - the runtime does not support `writeEarlyHints` (Node < 18.11)
-     *   - any internal error occurs (103 is best-effort, never fatal)
+     *   - any internal error occurs (103 is best-effort, never fatal), including
+     *     node refusing an HTTP/1.1 entry it does not take as a link value (a
+     *     parameter value holding a space, such as an `imagesrcset`)
      *
      * Returns `self` for optional chaining.
      *
@@ -2778,6 +2796,12 @@ function SuperController(options) {
      *     '<https://cdn.example.com/app.css>; rel=preload; as=style'
      *     or an array of such strings (joined with ', ' into one header).
      * @returns {object} self
+     *
+     * @example
+     * self.setEarlyHints([
+     *     '</css/app.css>; rel=preload; as=style',
+     *     '</js/app.js>; rel=preload; as=script'
+     * ]);
      */
     this.setEarlyHints = function(links) {
         if (!links) return self;
@@ -2798,11 +2822,20 @@ function SuperController(options) {
             // HTTP/2 — stream.additionalHeaders() sends a HEADERS frame with :status 103
             if (_res.stream && !_res.stream.headersSent) {
                 _res.stream.additionalHeaders({ ':status': 103, 'link': _link });
-            } else if (typeof _res.writeEarlyHints === 'function') {
-                // HTTP/1.1 — available since Node.js 18.11.0
-                _res.writeEarlyHints({ 'link': _link });
+            } else if (
+                typeof _res.writeEarlyHints === 'function'
+                // #B771 — over HTTP/1.1 only when the bundle asks for it (see above)
+                && local.options.conf.server.earlyHintsOverHTTP1 === true
+            ) {
+                // HTTP/1.1 — available since Node.js 18.11.0. #B770: node checks a
+                // string as ONE link value, and a ', '-joined list failed that check,
+                // so nothing was sent; an array is checked entry by entry
+                var _entries = preloadHints.toEarlyHintsList(links, local.options.template);
+                if (_entries.length > 0) {
+                    _res.writeEarlyHints({ 'link': _entries });
+                }
             }
-            // else: silently no-op on older Node.js
+            // else: no 103 — HTTP/1.1 without the setting, or Node.js older than 18.11
         } catch(e) {
             // 103 is best-effort — never let a hint failure affect the main response
         }

package/framework/{v0.7.2 → v0.7.3}/core/controller/controller.render-swig.js

@@ -18,6 +18,8 @@ var inspectorRedact   = require('lib/inspector-redact');
 var emitInspectorWindowData = require('./inspector-window-emit');
 // #RWATCH S3 — stale-release banner injector (server-side inline; gated inert).
 var releaseBanner = require('./release-banner');
+// #B765 — the size and the switch of the automatic preload hints, shared with controller.js.
+var preloadHints  = require('./preload-hints');
 // Precompiled regex — avoids per-request RegExp allocation (#P3)
 var blacklistRe       = /[<>]/g;
 
@@ -1477,7 +1479,14 @@ module.exports = async function render(userData, displayInspector, errOptions, d
         //     console.warn('----------------> loading partial `'+ path);
         // }
 
-        isDeferModeEnabled = localOptions.template.javascriptsDeferEnabled || localOptions.conf.content.templates._common.javascriptsDeferEnabled || false;
+        // #B778 — the template value alone, as getNodeRes() (controller.js) reads it to write
+        // `defer` on the tags, and as the other three delegates place them: this read fell back
+        // to `_common`, so since #B772 let a page's own `false` reach its template, such a page
+        // under a `_common` `true` got its scripts in <head> without `defer` (render-blocking)
+        // instead of before </body>. Both reads use the same object (#B497 points a custom-error
+        // render at the request's own template), so placement and `defer` always agree.
+        // was: localOptions.template.javascriptsDeferEnabled || localOptions.conf.content.templates._common.javascriptsDeferEnabled || false
+        isDeferModeEnabled = !!localOptions.template.javascriptsDeferEnabled;
         hasExternalsPlugins = (localOptions.template.externalPlugins.length > 0) ? true : false;
 
         // iframe case - without HTML TAG
@@ -1846,6 +1855,10 @@ module.exports = async function render(userData, displayInspector, errOptions, d
                     // re-emits it without a layout parse; '' when nothing qualifies,
                     // and an empty header is no longer sent.
                     _h2PreloadLinks = buildH2PreloadLinks(localOptions.template.h2Links, localOptions.template.assets);
+                    // #B765 — the same shaping as the 103: duplicates dropped (#B767), cut at
+                    // the page's `preloadHintsMaxSize`, nothing when `preloadHintsEnabled` is
+                    // false; the cache entry below memoises the shaped value for the hit path
+                    _h2PreloadLinks = preloadHints.shapeLinks(_h2PreloadLinks, localOptions.template);
                     if ( !self.isXMLRequest() && !self.isCacheless() && _h2PreloadLinks ) {
                         res.setHeader('link', _h2PreloadLinks);
                     }

package/framework/v0.7.3/core/controller/preload-hints.js

@@ -0,0 +1,230 @@
+'use strict';
+/**
+ * #B765 — the size and the switch of gina's automatic preload hints: the `link`
+ * header of an HTML 200 and the 103 Early Hints sent before it (an `http/2.0`
+ * bundle in production).
+ *
+ * A reverse proxy reads a response's header block into a fixed buffer and
+ * answers 502 when it does not fit: nginx's `proxy_buffer_size` is one memory
+ * page, 4 KiB on x86_64. Both hints grew by one entry per declared stylesheet
+ * and script and per layout image, with no limit and no way to turn them off.
+ * Both now go through `shapeLinks()`: an entry whose URL already appeared is
+ * dropped (#B767), and the value stops at the last entry that keeps it within
+ * `preloadHintsMaxSize` bytes (templates.json, default 1024; `0` = no cap);
+ * `preloadHintsEnabled: false` sends neither hint.
+ *
+ * Parameters only; the one piece of state is the flag that keeps the warning
+ * for an invalid size to once per process.
+ *
+ * @module core/controller/preload-hints
+ */
+
+/**
+ * The cap applied when `preloadHintsMaxSize` is absent or invalid.
+ * @constant {number}
+ */
+var DEFAULT_MAX_SIZE = 1024;
+
+/**
+ * Set once the invalid-size warning has been printed: the check runs on every
+ * render, so a bad value is reported once rather than per request (under
+ * dev-mode hot-reload the module may be evaluated again, and the warning with it).
+ * @type {boolean}
+ * @private
+ */
+var warnedInvalidSize = false;
+
+/**
+ * Split a `Link` header value into its entries. A new entry starts at a comma
+ * followed by `<` (whitespace allowed in between), so the commas inside an
+ * `imagesrcset` value stay in their entry.
+ *
+ * @param {string} value - A `Link` header value
+ * @returns {string[]} The entries, trimmed, empty ones dropped
+ *
+ * @example
+ * splitLinkEntries('</a.css>; as=style; rel=preload,</b.js>; as=script; rel=preload');
+ * // -> ['</a.css>; as=style; rel=preload', '</b.js>; as=script; rel=preload']
+ */
+function splitLinkEntries(value) {
+    var entries = [];
+    if ( !value ) {
+        return entries;
+    }
+    var parts = String(value).split(/,(?=\s*<)/);
+    for (var i = 0, len = parts.length; i < len; ++i) {
+        var entry = parts[i].trim().replace(/,+$/, '').trim();
+        if ( entry ) {
+            entries.push(entry);
+        }
+    }
+    return entries;
+}
+
+/**
+ * The URL of a `Link` entry: the text between its first `<` and the next `>`.
+ *
+ * @param {string} entry - One `Link` entry
+ * @returns {string|null} The URL, or `null` when the entry has none
+ *
+ * @example
+ * linkEntryUrl('</css/app.css?v=99bf1f0781>; as=style; rel=preload'); // -> '/css/app.css?v=99bf1f0781'
+ */
+function linkEntryUrl(entry) {
+    var start = entry.indexOf('<');
+    var end   = ( start > -1 ) ? entry.indexOf('>', start + 1) : -1;
+    return ( end > start ) ? entry.slice(start + 1, end) : null;
+}
+
+/**
+ * Drop every entry whose URL appeared in an earlier entry (#B767). The first
+ * one wins, so the order is kept; an entry without a URL is kept as is.
+ *
+ * @param {string[]} entries
+ * @returns {string[]}
+ *
+ * @example
+ * dedupLinkEntries(['</a.css>; as=style; rel=preload', '</a.css>; as=style; rel=preload']);
+ * // -> ['</a.css>; as=style; rel=preload']
+ */
+function dedupLinkEntries(entries) {
+    var seen = Object.create(null), kept = [];
+    for (var i = 0, len = entries.length; i < len; ++i) {
+        var url = linkEntryUrl(entries[i]);
+        if ( url !== null ) {
+            if ( seen[url] ) {
+                continue;
+            }
+            seen[url] = true;
+        }
+        kept.push(entries[i]);
+    }
+    return kept;
+}
+
+/**
+ * Keep entries, in order, while their joined value stays within `maxSize`
+ * bytes; stop at the first entry that would exceed it.
+ *
+ * @param {string[]} entries
+ * @param {number} maxSize - Bytes; `0` keeps every entry
+ * @param {string} separator - What the entries will be joined with (`','`, or `', '` for node's HTTP/1.1 array)
+ * @returns {string[]}
+ *
+ * @example
+ * capLinkEntries(['</a.css>; as=style; rel=preload', '</b.css>; as=style; rel=preload'], 40, ',');
+ * // -> ['</a.css>; as=style; rel=preload']   (31 bytes; the second would make 63)
+ */
+function capLinkEntries(entries, maxSize, separator) {
+    if ( !maxSize ) {
+        return entries.slice();
+    }
+    var sepBytes = Buffer.byteLength(separator), kept = [], bytes = 0;
+    for (var i = 0, len = entries.length; i < len; ++i) {
+        var add = Buffer.byteLength(entries[i]) + ( (kept.length > 0) ? sepBytes : 0 );
+        if ( bytes + add > maxSize ) {
+            break;
+        }
+        kept.push(entries[i]);
+        bytes += add;
+    }
+    return kept;
+}
+
+/**
+ * Read `preloadHintsEnabled` and `preloadHintsMaxSize` off a resolved template
+ * config. Only `false` turns the hints off. A size must be a non-negative
+ * integer; any other value (a negative number, a fraction, a string, `NaN`)
+ * falls back to `DEFAULT_MAX_SIZE` and prints one warning per process.
+ * An absent or `null` size is the default, silently.
+ *
+ * @param {object} [templateConf] - The page's resolved `templates.json` entry
+ * @returns {{enabled: boolean, maxSize: number}}
+ *
+ * @example
+ * resolvePreloadHints({ preloadHintsMaxSize: 0 });     // -> { enabled: true, maxSize: 0 }
+ * resolvePreloadHints({ preloadHintsEnabled: false }); // -> { enabled: false, maxSize: 1024 }
+ */
+function resolvePreloadHints(templateConf) {
+    var conf    = templateConf || {};
+    var size    = conf.preloadHintsMaxSize;
+    var maxSize = DEFAULT_MAX_SIZE;
+
+    if ( typeof(size) != 'undefined' && size !== null ) {
+        if ( typeof(size) == 'number' && Number.isInteger(size) && size >= 0 ) {
+            maxSize = size;
+        } else if ( !warnedInvalidSize ) {
+            warnedInvalidSize = true;
+            console.warn('[preload-hints] templates.json `preloadHintsMaxSize` must be a whole number of bytes, 0 or more (0 = no cap) - got '+ JSON.stringify(size) +', using '+ DEFAULT_MAX_SIZE +'. Warned once per process.');
+        }
+    }
+
+    return { enabled: conf.preloadHintsEnabled !== false, maxSize: maxSize };
+}
+
+/**
+ * The value of an automatic hint (the 200 `link` header or the 103): `''` when
+ * `preloadHintsEnabled` is `false`; otherwise duplicates dropped and the cap
+ * applied, entries joined with `','` as gina writes them. Under the cap and
+ * without duplicates the value comes back byte-identical.
+ *
+ * @param {string} value - The assembled `Link` value
+ * @param {object} [templateConf] - The page's resolved `templates.json` entry
+ * @returns {string} `''` when nothing is to be sent
+ *
+ * @example
+ * shapeLinks('</a.css>; as=style; rel=preload,</a.css>; as=style; rel=preload', {});
+ * // -> '</a.css>; as=style; rel=preload'
+ */
+function shapeLinks(value, templateConf) {
+    var opts = resolvePreloadHints(templateConf);
+    if ( !opts.enabled || !value ) {
+        return '';
+    }
+    return capLinkEntries(dedupLinkEntries(splitLinkEntries(value)), opts.maxSize, ',').join(',');
+}
+
+/**
+ * The entries `setEarlyHints()` hands node's `res.writeEarlyHints()` over
+ * HTTP/1.1: one array element per entry (node validates each element as ONE
+ * link value and joins them with `', '`, #B770), capped at the page's
+ * `preloadHintsMaxSize` measured on that join.
+ *
+ * @param {string|string[]} links - What `setEarlyHints()` was given
+ * @param {object} [templateConf] - The page's resolved `templates.json` entry
+ * @returns {string[]} Possibly empty
+ *
+ * @example
+ * toEarlyHintsList(['</a.css>; rel=preload; as=style', '</b.js>; rel=preload; as=script'], {});
+ * // -> ['</a.css>; rel=preload; as=style', '</b.js>; rel=preload; as=script']
+ */
+function toEarlyHintsList(links, templateConf) {
+    var given   = Array.isArray(links) ? links : [links];
+    var entries = [];
+    for (var i = 0, len = given.length; i < len; ++i) {
+        if ( given[i] ) {
+            entries = entries.concat(splitLinkEntries(given[i]));
+        }
+    }
+    return capLinkEntries(entries, resolvePreloadHints(templateConf).maxSize, ', ');
+}
+
+/**
+ * Test seam: re-arm the once-per-process warning.
+ * @private
+ */
+function _resetWarnings() {
+    warnedInvalidSize = false;
+}
+
+module.exports = {
+    DEFAULT_MAX_SIZE    : DEFAULT_MAX_SIZE,
+    splitLinkEntries    : splitLinkEntries,
+    linkEntryUrl        : linkEntryUrl,
+    dedupLinkEntries    : dedupLinkEntries,
+    capLinkEntries      : capLinkEntries,
+    resolvePreloadHints : resolvePreloadHints,
+    shapeLinks          : shapeLinks,
+    toEarlyHintsList    : toEarlyHintsList,
+    _resetWarnings      : _resetWarnings
+};

package/framework/{v0.7.2 → v0.7.3}/core/plugins/lib/validator/src/main.js

@@ -3185,9 +3185,17 @@ function ValidatorPlugin(rules, data, formId, culture) {
      * send
      * N.B.: no validation here; if you want to validate against rules, use `.submit()` or `.validateFormById(formId)` before
      *
+     * Reads nothing from the event being dispatched when it runs (#B758): with no `data` it
+     * sends an empty body, and a staged upload's group comes from the file input its virtual
+     * upload form stages for (`data-gina-form-upload-group`, `untagged` when unset).
      *
-     * @param {object} data - FormData object (https://developer.mozilla.org/en-US/docs/Web/API/FormData/Using_FormData_Objects)
+     * @param {object|FormData} [data] - the payload: a plain object (sent as JSON) or a FormData object (https://developer.mozilla.org/en-US/docs/Web/API/FormData/Using_FormData_Objects); omitted, an empty body is sent
      * @param {object} [ options ] : { isSynchrone: false, withCredentials: true, withRateLimit: true }
+     * @returns {void}
+     *
+     * @example
+     * // after your own validation, post the form's data over AJAX
+     * gina.validator.$forms['signup'].send(result.toData());
      * */
     var send = function(data, options) {
 
@@ -4482,8 +4490,12 @@ function ValidatorPlugin(rules, data, formId, culture) {
 
 
             // sending
-            if (!data)
-                data = event.detail.data;
+            // #B758 — a no-data send() no longer reads `event.detail.data` from the implicit
+            // global `event`: outside a dispatch it is undefined, so the call threw here, after
+            // `isSending` was claimed above, and left the form in sending. A no-data call now
+            // takes the empty-body branch below; nothing in gina calls send() without data.
+            // was: if (!data)
+            // was:     data = event.detail.data;
 
             if (data) {
 
@@ -4499,7 +4511,17 @@ function ValidatorPlugin(rules, data, formId, culture) {
                         if ( !(data instanceof FormData) ) {
                             data = JSON.stringify(data)
                         } else {
-                            var uploadGroup   = event.currentTarget.getAttribute('data-gina-form-upload-group') || 'untagged';
+                            // #B758 — the group comes from the file input this virtual upload form
+                            // stages for (`uploadProperties.uploadTriggerId`), not from the implicit
+                            // global `event`: the picker and the dropzone call send() inside that
+                            // input's change dispatch, but a direct `$forms[<virtual id>].send(formData)`
+                            // ran outside any dispatch (a TypeError, reported as a staging error) or
+                            // inside an unrelated one (that event's element's group, silently).
+                            // was: var uploadGroup   = event.currentTarget.getAttribute('data-gina-form-upload-group') || 'untagged';
+                            var $uploadGroupInput = ( $target.uploadProperties && $target.uploadProperties.uploadTriggerId )
+                                ? document.getElementById($target.uploadProperties.uploadTriggerId)
+                                : null;
+                            var uploadGroup   = ( $uploadGroupInput && $uploadGroupInput.getAttribute('data-gina-form-upload-group') ) || 'untagged';
                             for (var [key, value] of data.entries() ) {
                                 // file upload case
                                 if (value instanceof File) {