gina 0.7.0 → 0.7.1

package/framework/{v0.7.0 → v0.7.1}/core/config.js

@@ -2650,7 +2650,16 @@ function Config(opt, contextResetNeeded) {
 
             // we only need to retrieve the tmpFiles (files[settings])
             files['settings'] = JSON.clone(conf[bundle][env].tmpSettingFileContent) || {};
-            delete conf[bundle][env].tmpSettingFileContent;
+            // Drop the key by REBUILDING the object, not by deleting it (phase-2 per-request
+            // trims, slice C2): a delete of a non-last property — like the keyed stores of
+            // merge(files, conf[bundle][env]) above — leaves the object in V8 dictionary mode,
+            // and the router copies it on every routed request (~20 µs slow, ~0.2 µs fast).
+            // The rebuild (object rest: the own enumerable keys, the same values by reference)
+            // follows the last structural change and precedes secrets.resolve(), which keys
+            // its resolved-paths WeakMap by this object; `files` is the same object until
+            // `files = whisper(...)`, so both names are re-pointed.
+            var { tmpSettingFileContent: _tmpSettingFileContent, ..._envRest } = conf[bundle][env];
+            files = conf[bundle][env] = _envRest;
 
             if ( files['settings'].count() == 0 ) {
                 files['settings'] = requireJSON(settingsPath)

package/framework/{v0.7.0 → v0.7.1}/core/controller/controller.js

@@ -575,6 +575,33 @@ var _defineLazyLocales = function(conf, srcRows) {
 };
 var _isProdScope    = process.env.NODE_SCOPE_IS_PRODUCTION && process.env.NODE_SCOPE_IS_PRODUCTION.toLowerCase() === 'true';
 
+/**
+ * The page.environment `memory allocated` label — the V8 heap limit in GB — computed on the
+ * first render. The limit is fixed for the life of the process, yet reading it cost a
+ * `require('v8')` and a getHeapStatistics() call on every routed request of a bundle with
+ * views (phase-2 per-request trims, slice B).
+ *
+ * @private
+ * @type {?string}
+ */
+var _heapLimitLabel = null;
+
+/**
+ * The encoded `page.environment.forms` whisper, memoized per forms catalog object (phase-2
+ * per-request trims, slice B). The export is a function of the catalog alone, and the
+ * catalog is built once per bundle load; the framework never writes it afterwards — the
+ * validator and getFormsRules() work on clones, and getConfig() hands out copy-on-write
+ * views — so encoding it again on every routed request of a bundle with views (5–7 µs per
+ * KB of catalog, measured standalone) produced the same string each time. A reloaded
+ * catalog is a new key, and a dropped one is collected with its entry. One difference:
+ * `page.forms` holds the catalog by reference, so render data that deep-fills `page.forms`
+ * writes into it; that write no longer reaches later requests' whispers.
+ *
+ * @private
+ * @type {WeakMap<object, string>}
+ */
+var _formsWhisperMemo = new WeakMap();
+
 /**
  * formatAttachmentDisposition
  *
@@ -698,7 +725,7 @@ function _resolveServedContentType(optsContentType, metaContentType) {
  * @extends EventEmitter
  *
  * Base controller class. Instantiated fresh on every request via `inherits`
- * (`b.apply(this, arguments)` in `lib/inherits/src/main.js:78`), giving each
+ * (`b.apply(this, arguments)` in `lib/inherits/src/main.js:75`), giving each
  * request its own isolated `local` closure. No singleton static properties are
  * maintained. (#M1)
  *
@@ -1072,7 +1099,10 @@ function SuperController(options) {
                 "middleware"    : ctx.middleware
             };
 
-            set('page.environment.memory allocated', (require('v8').getHeapStatistics().heap_size_limit / (1024 * 1024 * 1024)).toFixed(2) +' GB');
+            if (_heapLimitLabel === null) {
+                _heapLimitLabel = (require('v8').getHeapStatistics().heap_size_limit / (1024 * 1024 * 1024)).toFixed(2) +' GB';
+            }
+            set('page.environment.memory allocated', _heapLimitLabel);
             if ( self.isLocalScope() ) {
                 const mem = process.memoryUsage();
                 set('page.environment.memory heap', `${(mem.heapUsed / 1024 / 1024).toFixed(2)} MB` );
@@ -1090,7 +1120,10 @@ function SuperController(options) {
             set('page.environment.scope', process.env.NODE_SCOPE);
             set('page.environment.scopeIsLocal', _isLocalScope);
             set('page.environment.scopeIsProduction', _isProdScope);
-            set('page.environment.date.now', new Date().format("isoDateTime"));
+            // one stamp per request, shared with the locale's `date.now` below (phase-2
+            // per-request trims, slice B): two calls could straddle a second boundary
+            var _nowIso = new Date().format("isoDateTime");
+            set('page.environment.date.now', _nowIso);
             set('page.environment.isCacheless', self.isCacheless());
 
             // var requestPort = req.headers.port || req.headers[':port'];
@@ -1295,16 +1328,27 @@ function SuperController(options) {
             // export excludes it in EVERY env (uniform client contract, page weight).
             // Shallow copy only: `forms` is the SHARED per-process catalog reference also
             // grafted below (`conf.forms`, `page.forms`) -- never mutate it.
-            var _whisperedForms = {};
-            if ( forms && typeof(forms) == 'object' ) {
-                // replaced: for...in -- use Object.keys() (#P22)
-                var _formsGroups = Object.keys(forms);
-                for (var _fgi = 0; _fgi < _formsGroups.length; ++_fgi) {
-                    if (_formsGroups[_fgi] === 'mocks') continue;
-                    _whisperedForms[_formsGroups[_fgi]] = forms[_formsGroups[_fgi]];
+            // Memoized per catalog object — see `_formsWhisperMemo` (phase-2 per-request trims,
+            // slice B). The `typeof` guard keeps this block runnable where the module-scope memo
+            // is out of reach (a test harness compiles it on its own); there it computes every time.
+            var _formsWhisperKey = ( typeof(_formsWhisperMemo) != 'undefined' && forms && typeof(forms) == 'object' ) ? forms : null;
+            var _formsWhisper    = ( _formsWhisperKey ) ? _formsWhisperMemo.get(_formsWhisperKey) : undefined;
+            if ( typeof(_formsWhisper) == 'undefined' ) {
+                var _whisperedForms = {};
+                if ( forms && typeof(forms) == 'object' ) {
+                    // replaced: for...in -- use Object.keys() (#P22)
+                    var _formsGroups = Object.keys(forms);
+                    for (var _fgi = 0; _fgi < _formsGroups.length; ++_fgi) {
+                        if (_formsGroups[_fgi] === 'mocks') continue;
+                        _whisperedForms[_formsGroups[_fgi]] = forms[_formsGroups[_fgi]];
+                    }
+                }
+                _formsWhisper = encodeRFC5987ValueChars(JSON.stringify(_whisperedForms)); // export for GFF (#B344: minus `mocks`)
+                if ( _formsWhisperKey ) {
+                    _formsWhisperMemo.set(_formsWhisperKey, _formsWhisper);
                 }
             }
-            set('page.environment.forms', encodeRFC5987ValueChars(JSON.stringify(_whisperedForms))); // export for GFF (#B344: minus `mocks`)
+            set('page.environment.forms', _formsWhisper);
             set('page.forms', options.conf.content.forms);
 
 
@@ -1507,7 +1551,7 @@ function SuperController(options) {
                 options.conf.locale = {}
             }
             options.conf.locale.date = {
-                now: new Date().format("isoDateTime")
+                now: _nowIso
             }
             set('page.view.locale', options.conf.locale);
             // #A11Y3 — `userCulture` is underscore-form (`en_CM`) and, when it came from a
@@ -1537,7 +1581,13 @@ function SuperController(options) {
             // initSwigEngine.
             var _swigAutoescape = false;
             try {
-                var _tSwig = ( getConfig()[local.options.conf.bundle][local.options.conf.env].content.settings.swig ) || {};
+                // #B695 — was: read through the global `getConfig()`, whose caller-file
+                // walk threw on every request under an npm install; this catch then
+                // turned auto-escaping off while the bundle had it on. The request's
+                // own conf is the same object (router.js builds `options.conf` from
+                // the bundle's envConf[bundle][env] and shares its `settings`).
+                // var _tSwig = ( getConfig()[local.options.conf.bundle][local.options.conf.env].content.settings.swig ) || {};
+                var _tSwig = ( local.options.conf.content.settings.swig ) || {};
                 _swigAutoescape = ( _tSwig.autoescape === true );
             } catch (_swigAeErr) {
                 _swigAutoescape = false;
@@ -1639,8 +1689,10 @@ function SuperController(options) {
      * */
     var set = function(name, value, override) {
 
-        if ( typeof(name) == 'string' && /\./.test(name) ) {
-            var keys = name.split(/\./g), last = keys.length - 1;
+        // string forms, not regexes: ~60 calls per routed request of a bundle with views
+        // (phase-2 per-request trims, slice D1)
+        if ( typeof(name) == 'string' && name.indexOf('.') !== -1 ) {
+            var keys = name.split('.'), last = keys.length - 1;
             var node = local.userData;
             if ( node === null || typeof(node) != 'object' ) {
                 node = local.userData = {};

package/framework/{v0.7.0 → v0.7.1}/core/router.js

@@ -50,10 +50,74 @@ var fs                  = require('fs')
 // cached at module load — these env vars never change at runtime (#P18)
 var _isDev = process.env.NODE_ENV_IS_DEV && process.env.NODE_ENV_IS_DEV.toLowerCase() === 'true';
 
+// A bundle's `controllers/setup.js` is probed once per bundle in production and the answer
+// memoized here by bundle name: nothing evicts a controller's require cache there, so the
+// file cannot appear or vanish without a restart, while the per-request probe cost an
+// accessSync throw plus an lstatSync throw whenever the file was absent. Dev keeps the
+// per-request probe — its eviction block in route() depends on the fresh answer.
+var _setupFileMemo = Object.create(null);
+
+/**
+ * Resolves a bundle's `controllers/setup.js` path and whether the file exists.
+ *
+ * In production (`isCacheless` false) the answer is computed once per bundle and served
+ * from the memo afterwards — the path object is not constructed again either. In dev the
+ * file is probed on every call, because the router evicts and re-requires it per request.
+ *
+ * @private
+ * @param {string}  bundle      - Bundle name (the memo key)
+ * @param {string}  bundlesPath - `conf.bundlesPath` of the running project
+ * @param {boolean} isCacheless - Dev-mode flag (`self.isCacheless()`)
+ * @returns {{file: string, exists: boolean}} The resolved path string and its existence
+ *
+ * @example
+ * var probe = resolveSetupFile('frontend', '/srv/app/src', false);
+ * // { file: '/srv/app/src/frontend/controllers/setup.js', exists: true }
+ */
+var resolveSetupFile = function(bundle, bundlesPath, isCacheless) {
+    if ( !isCacheless && typeof(_setupFileMemo[bundle]) != 'undefined' ) {
+        return _setupFileMemo[bundle];
+    }
+    var setupFileObj = new _(bundlesPath +'/'+ bundle + '/controllers/setup.js', true);
+    var probe = {
+        file    : setupFileObj.toString(),
+        exists  : setupFileObj.existsSync()
+    };
+    if (!isCacheless) {
+        _setupFileMemo[bundle] = probe;
+    }
+    return probe;
+};
+
 // extracted from Router::route() — try-catch prevents V8 JIT optimization of the outer function (#P25)
+/**
+ * Resolves the environment configuration for a routed request and, when the
+ * route carries no bundle, fills `params` from the reverse routing table.
+ *
+ * @private
+ * @param {object}   serverInstance - The server, for `throwError()`
+ * @param {object}   params         - The matched route's params (merged into when unbundled)
+ * @param {object}   response       - The response, for `throwError()`
+ * @param {string}   controllerFile - The controller path, named in a config error
+ * @param {object}   local          - The router's local state (`local.bundle` is set)
+ * @returns {?{config: object, bundle: string, env: string, scope: string, conf: object, params: object}}
+ *          The resolved configuration, or `null` once an error response was sent
+ *
+ * @example
+ * var resolved = resolveRouteConfig(serverInstance, params, response, controllerFile, local);
+ * if (resolved === null) return; // the 500 has already been sent
+ */
 function resolveRouteConfig(serverInstance, params, response, controllerFile, local) {
     try {
-        var config = new Config().getInstance();
+        // Once Config is initialised, `new Config().getInstance()` builds a throwaway
+        // instance only to return the singleton's envConf, and re-sets Env/Scope/Host on
+        // the singleton to the values they already hold (getInstance() ran once at boot):
+        // read the singleton directly. Before that — or in a worker, where Config.instance
+        // comes from the global context and Config.initialized stays unset — the call runs
+        // as before, #B542's refusal included (phase-2 per-request trims, slice E).
+        var config = ( Config.initialized && Config.instance )
+            ? Config.instance.envConf
+            : new Config().getInstance();
         if (!params.bundle) {
             try {
                 //params.bundle = config.bundle;
@@ -844,16 +908,12 @@ function Router(env, scope) {
         /**
          * EO routing configuration
          */
-        var setupFileObj    = new _(conf.bundlesPath +'/'+ bundle + '/controllers/setup.js', true)
-            , setupFile     = setupFileObj.toString()
+        var setupProbe  = resolveSetupFile(bundle, conf.bundlesPath, isCacheless)
+            , setupFile = setupProbe.file
         ;
+        hasSetup = setupProbe.exists;
         try {
 
-            if ( setupFileObj.existsSync() ) {
-                hasSetup = true;
-            }
-            setupFileObj = null;
-
             if (isCacheless) {
                 var _hotReload = getContext('__hotReload');
                 // #M6 — only evict when watcher not running (fallback) or a controller changed