@aaqu/fromcubes-portal-react 0.1.0-alpha.23 → 0.1.0-alpha.24

package/nodes/lib/helpers.js

@@ -363,6 +363,30 @@ function findMissingComponentRefs(userCode, knownNames) {
   return missing;
 }
 
+/**
+ * Resolve the content hash the server may advertise to a browser over the WS
+ * `version` frame. The hash MUST only be non-empty when there is a page the
+ * GET route can actually serve — otherwise a stale hash makes the served error
+ * / building page reload in a tight loop (it reloads on any non-empty
+ * `version` hash).
+ *
+ * States, in order:
+ *   - no state / nulled `compiled` (post-`close` teardown window) → ""
+ *   - degraded (build error but a previous good build is kept) → lastGood hash
+ *   - hard build error with no fallback → ""
+ *   - real serveable build (`compiled.js` present) → contentHash
+ *
+ * @param {?PageState} state  pageState[endpoint] (may be null/partially torn down).
+ * @returns {string}          Hash to advertise, or "" when nothing is serveable.
+ */
+function serveableHash(state) {
+  if (!state || !state.compiled) return "";
+  if (state.compiled.error) {
+    return state.lastGood ? state.lastGood.contentHash || "" : "";
+  }
+  return state.compiled.js ? state.contentHash || "" : "";
+}
+
 module.exports = function (RED) {
   return createHelpers(RED);
 };
@@ -373,6 +397,7 @@ module.exports.quickCheckSyntax = quickCheckSyntax;
 module.exports.formatEsbuildError = formatEsbuildError;
 module.exports.extractPortalUser = extractPortalUser;
 module.exports.findMissingComponentRefs = findMissingComponentRefs;
+module.exports.serveableHash = serveableHash;
 module.exports.NAME_MAX_LEN = NAME_MAX_LEN;
 module.exports.MAX_GROUPS_HEADER_BYTES = MAX_GROUPS_HEADER_BYTES;
 
@@ -593,6 +618,7 @@ function createHelpers(RED) {
     quickCheckSyntax,
     generateCSS,
     extractPortalUser,
+    serveableHash,
     removeRoute,
     isSafeName,
     validateSubPath,

package/nodes/lib/page-builder.js

@@ -218,6 +218,16 @@ function buildPage(title, transpiledJs, wsPath, customHead, cssHash, user, showW
           // Flushed in onopen so node status can go red even when the
           // exception fires synchronously during initial bundle execution.
           _pendingRuntimeError: null,
+          // Page-load timestamp + guarded reload: never reload within 2s of
+          // load, so a briefly-inconsistent server (error page served while a
+          // "ready" version hash is advertised over WS) cannot drive a tight
+          // reload loop. Caps recovery to one reload / 2s.
+          _loadT: Date.now(),
+          _reload() {
+            const wait = 2000 - (Date.now() - this._loadT);
+            if (wait > 0) setTimeout(() => location.reload(), wait);
+            else location.reload();
+          },
           _user: ${user ? escScript(JSON.stringify(user)) : "null"},
 
           connect() {
@@ -253,7 +263,7 @@ function buildPage(title, transpiledJs, wsPath, customHead, cssHash, user, showW
                   // exception caught locally renders the same overlay node and would
                   // otherwise loop reload to runtime-error to reload forever.
                   if (this._buildErrorActive || (this._version && this._version !== m.hash)) {
-                    location.reload();
+                    this._reload();
                     return;
                   }
                   this._version = m.hash;
@@ -379,6 +389,16 @@ function buildErrorPage(title, error, wsPath) {
           const st = document.getElementById('__err_status');
           const pre = document.querySelector('#__error_overlay pre');
           let retries = 0;
+          // Reload guard: never reload within 2s of this page loading. If the
+          // server is briefly inconsistent (serves this error page yet
+          // advertises a "ready" version hash over WS), an unguarded reload
+          // turns into a tight loop. The guard caps it to one reload / 2s.
+          const __loadT = Date.now();
+          function __reload() {
+            const wait = 2000 - (Date.now() - __loadT);
+            if (wait > 0) { setTimeout(function(){ location.reload(); }, wait); }
+            else { location.reload(); }
+          }
           function setStatus(text, ok) {
             if (!st) return;
             st.textContent = text;
@@ -394,7 +414,7 @@ function buildErrorPage(title, error, wsPath) {
             ws.onmessage = function(e) {
               try {
                 const m = JSON.parse(e.data);
-                if (m.type === 'version' && m.hash) location.reload();
+                if (m.type === 'version' && m.hash) __reload();
                 if (m.type === 'error' && pre) pre.textContent = m.message;
               } catch(_) {}
             };

package/nodes/portal-react.js

@@ -544,6 +544,7 @@ module.exports = function (RED) {
     quickCheckSyntax,
     generateCSS,
     extractPortalUser,
+    serveableHash,
     removeRoute,
     isSafeName,
     validateSubPath,
@@ -1564,7 +1565,11 @@ module.exports = function (RED) {
         RED.httpNode.get(endpoint, async function (_req, res) {
           try {
             const state = pageState[endpoint];
-            if (!state || state.building) {
+            // `!state.compiled` is the teardown window between node close
+            // (which nulls compiled) and the next rebuild. Treat it like
+            // "building" — serve the holding page (200), never fall through to
+            // `state.compiled.error` which would throw and 500 via the catch.
+            if (!state || state.building || !state.compiled) {
               const bWsPath = state?.wsPath || wsPath;
               res
                 .set("Cache-Control", "no-store")
@@ -1721,10 +1726,11 @@ module.exports = function (RED) {
           // In degraded mode (current build failed but lastGood served), advertise
           // the lastGood hash so the freshly reloaded client matches the JS we sent.
           const cs = pageState[endpoint];
-          const contentHash =
-            cs?.compiled?.error && cs?.lastGood
-              ? cs.lastGood.contentHash
-              : cs?.contentHash || "";
+          // Only advertise a non-empty hash when there is a page the GET route
+          // can actually serve (real build, or degraded lastGood). Advertising
+          // a stale hash for a nulled/error state drives the served error page
+          // into a reload loop. See helpers.serveableHash.
+          const contentHash = serveableHash(cs);
           wsSend(ws, { type: "version", hash: contentHash });
 
           // Send assigned portalClient to browser
@@ -1964,6 +1970,11 @@ module.exports = function (RED) {
             st.cssReady = null;
             st.compiled = null;
             st.css = null;
+            // Clear the advertised hash too. Leaving a stale non-empty
+            // contentHash while compiled is null makes the WS `version` frame
+            // advertise a "ready" page that the GET route can no longer serve,
+            // which drives the served error/building page into a reload loop.
+            st.contentHash = "";
           }
 
           // Clean up route only on full removal/disable (not on redeploy).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaqu/fromcubes-portal-react",
-  "version": "0.1.0-alpha.23",
+  "version": "0.1.0-alpha.24",
   "description": "Fromcubes Portal - React for Node-RED with Tailwind CSS and auto complete",
   "type": "commonjs",
   "keywords": [