webspresso 0.0.108 → 0.0.110

package/src/helpers.js

@@ -19,15 +19,43 @@ dayjs.extend(utc);
 dayjs.extend(timezone);
 dayjs.extend(customParseFormat);
 
+/**
+ * Zero-allocation bounded Map LRU helpers
+ */
+function lruGet(map, key) {
+  const val = map.get(key);
+  if (val !== undefined) {
+    map.delete(key);
+    map.set(key, val);
+  }
+  return val;
+}
+
+function lruSet(map, key, val, maxSize) {
+  if (map.has(key)) {
+    map.delete(key);
+  } else if (map.size >= maxSize) {
+    const oldestKey = map.keys().next().value;
+    map.delete(oldestKey);
+  }
+  map.set(key, val);
+}
+
 // Cache for isPath regex patterns
 const isPathRegexCache = new Map();
+const MAX_IS_PATH_CACHE = 1000;
 
 // Caches for manifest files and filesystem existence checks
 const manifestFileCache = new Map();
+const MAX_MANIFEST_CACHE = 50;
+
 const diskExistenceCache = new Map();
+const MAX_DISK_CACHE = 2000;
+
+const MAX_ASSET_CACHE = 2000;
 
 function cachedExistsSync(filePath) {
-  const cached = diskExistenceCache.get(filePath);
+  const cached = lruGet(diskExistenceCache, filePath);
   if (cached !== undefined) return cached;
   let exists = false;
   try {
@@ -35,9 +63,7 @@ function cachedExistsSync(filePath) {
   } catch (_) {
     exists = false;
   }
-  if (diskExistenceCache.size < 2000) {
-    diskExistenceCache.set(filePath, exists);
-  }
+  lruSet(diskExistenceCache, filePath, exists, MAX_DISK_CACHE);
   return exists;
 }
 
@@ -109,7 +135,7 @@ class AssetManager {
       if (fs.existsSync(fullPath)) {
         try {
           const stats = fs.statSync(fullPath);
-          const cached = manifestFileCache.get(fullPath);
+          const cached = lruGet(manifestFileCache, fullPath);
           if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
             this.manifest = cached.manifest;
             this._lookupIndex = cached.lookupIndex;
@@ -118,12 +144,12 @@ class AssetManager {
           const content = fs.readFileSync(fullPath, 'utf-8');
           this.manifest = JSON.parse(content);
           this._buildLookupIndex();
-          manifestFileCache.set(fullPath, {
+          lruSet(manifestFileCache, fullPath, {
             mtimeMs: stats.mtimeMs,
             size: stats.size,
             manifest: this.manifest,
             lookupIndex: this._lookupIndex,
-          });
+          }, MAX_MANIFEST_CACHE);
           return;
         } catch (_) {
           const content = fs.readFileSync(fullPath, 'utf-8');
@@ -145,7 +171,7 @@ class AssetManager {
    * @returns {string}
    */
   resolve(assetPath) {
-    const cached = this._resolveCache.get(assetPath);
+    const cached = lruGet(this._resolveCache, assetPath);
     if (cached !== undefined) return cached;
 
     // Remove leading slash for manifest lookup
@@ -188,9 +214,7 @@ class AssetManager {
           result = this.prefix ? (this.prefix + file).replace(/\/+/g, '/') : file;
         }
         if (result !== undefined) {
-          if (this._resolveCache.size < 2000) {
-            this._resolveCache.set(assetPath, result);
-          }
+          lruSet(this._resolveCache, assetPath, result, MAX_ASSET_CACHE);
           return result;
         }
       }
@@ -205,9 +229,7 @@ class AssetManager {
       finalPath += `${separator}v=${this.version}`;
     }
     
-    if (this._resolveCache.size < 2000) {
-      this._resolveCache.set(assetPath, finalPath);
-    }
+    lruSet(this._resolveCache, assetPath, finalPath, MAX_ASSET_CACHE);
     return finalPath;
   }
   
@@ -419,7 +441,7 @@ class AssetManager {
    */
   hasPageJs(name) {
     if (!name || typeof name !== 'string') return false;
-    const cached = this._hasJsCache.get(name);
+    const cached = lruGet(this._hasJsCache, name);
     if (cached !== undefined) return cached;
 
     let clean = String(name).trim().replace(/^\/+/, '');
@@ -440,7 +462,7 @@ class AssetManager {
         this.manifest['src/client/' + pagePath] ||
         this.manifest['client/' + pagePath]
       ) {
-        if (this._hasJsCache.size < 500) this._hasJsCache.set(name, true);
+        lruSet(this._hasJsCache, name, true, MAX_ASSET_CACHE);
         return true;
       }
     }
@@ -468,12 +490,12 @@ class AssetManager {
 
     for (const p of diskChecks) {
       if (cachedExistsSync(p)) {
-        if (this._hasJsCache.size < 500) this._hasJsCache.set(name, true);
+        lruSet(this._hasJsCache, name, true, MAX_ASSET_CACHE);
         return true;
       }
     }
 
-    if (this._hasJsCache.size < 500) this._hasJsCache.set(name, false);
+    lruSet(this._hasJsCache, name, false, MAX_ASSET_CACHE);
     return false;
   }
 
@@ -484,7 +506,7 @@ class AssetManager {
    */
   hasPageCss(name) {
     if (!name || typeof name !== 'string') return false;
-    const cached = this._hasCssCache.get(name);
+    const cached = lruGet(this._hasCssCache, name);
     if (cached !== undefined) return cached;
 
     let clean = String(name).trim().replace(/^\/+/, '');
@@ -505,7 +527,7 @@ class AssetManager {
         this.manifest['src/client/' + pagePath] ||
         this.manifest['client/' + pagePath]
       ) {
-        if (this._hasCssCache.size < 500) this._hasCssCache.set(name, true);
+        lruSet(this._hasCssCache, name, true, MAX_ASSET_CACHE);
         return true;
       }
     }
@@ -529,12 +551,12 @@ class AssetManager {
 
     for (const p of diskChecks) {
       if (cachedExistsSync(p)) {
-        if (this._hasCssCache.size < 500) this._hasCssCache.set(name, true);
+        lruSet(this._hasCssCache, name, true, MAX_ASSET_CACHE);
         return true;
       }
     }
 
-    if (this._hasCssCache.size < 500) this._hasCssCache.set(name, false);
+    lruSet(this._hasCssCache, name, false, MAX_ASSET_CACHE);
     return false;
   }
 
@@ -1054,12 +1076,10 @@ function createHelpers(ctx) {
       const currentPath = req.path;
       if (pattern === currentPath) return true;
       if (pattern.includes('*')) {
-        let regex = isPathRegexCache.get(pattern);
+        let regex = lruGet(isPathRegexCache, pattern);
         if (regex === undefined) {
           regex = globToRegExp(pattern, { separator: null });
-          if (isPathRegexCache.size < 500) {
-            isPathRegexCache.set(pattern, regex);
-          }
+          lruSet(isPathRegexCache, pattern, regex, MAX_IS_PATH_CACHE);
         }
         return regex.test(currentPath);
       }

package/src/njk-frontmatter.js

@@ -17,6 +17,30 @@ const FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
 
 /** @typedef {{ metaPatch: Record<string, unknown>, dataPatch: Record<string, unknown> }} Patch */
 
+/**
+ * Zero-allocation bounded Map LRU helpers
+ */
+function lruGet(map, key) {
+  const val = map.get(key);
+  if (val !== undefined) {
+    map.delete(key);
+    map.set(key, val);
+  }
+  return val;
+}
+
+function lruSet(map, key, val, maxSize) {
+  if (map.has(key)) {
+    map.delete(key);
+  } else if (map.size >= maxSize) {
+    const oldestKey = map.keys().next().value;
+    map.delete(oldestKey);
+  }
+  map.set(key, val);
+}
+
+const MAX_ROUTE_CACHE = 2000;
+
 const prodRouteCache = new Map();
 /** @type {Map<string, { mtimeMs: number, cached: LoadedNjk }>} */
 const devRouteCache = new Map();
@@ -117,7 +141,7 @@ function readAndParse(absPath, isDevLike = false) {
   if (isDevLike) {
     return loaded;
   }
-  prodRouteCache.set(absPath, loaded);
+  lruSet(prodRouteCache, absPath, loaded, MAX_ROUTE_CACHE);
   return loaded;
 }
 
@@ -127,7 +151,7 @@ function readAndParse(absPath, isDevLike = false) {
  */
 function loadNjkRouteTemplate(absPath, isDev) {
   if (!isDev) {
-    const cached = prodRouteCache.get(absPath);
+    const cached = lruGet(prodRouteCache, absPath);
     if (cached) {
       return cached;
     }
@@ -138,7 +162,7 @@ function loadNjkRouteTemplate(absPath, isDev) {
         metaPatch: {},
         dataPatch: {},
       };
-      prodRouteCache.set(absPath, empty);
+      lruSet(prodRouteCache, absPath, empty, MAX_ROUTE_CACHE);
       return empty;
     }
     return readAndParse(absPath, false);
@@ -156,10 +180,12 @@ function loadNjkRouteTemplate(absPath, isDev) {
   const stat = fs.statSync(absPath);
   const prev = devRouteCache.get(absPath);
   if (prev && prev.mtimeMs >= stat.mtimeMs) {
+    devRouteCache.delete(absPath);
+    devRouteCache.set(absPath, prev);
     return prev.cached;
   }
   const fresh = readAndParse(absPath, true);
-  devRouteCache.set(absPath, { mtimeMs: stat.mtimeMs, cached: fresh });
+  lruSet(devRouteCache, absPath, { mtimeMs: stat.mtimeMs, cached: fresh }, MAX_ROUTE_CACHE);
   return fresh;
 }
 

package/src/routing/cascading.js

@@ -18,6 +18,9 @@ const middlewareFileCache = new Map();
 const layoutFileCache = new Map();
 const errorFileCache = new Map();
 const loadingFileCache = new Map();
+// fullPath -> whether the template file contains `{% extends %}`
+const extendsFileCache = new Map();
+const EXTENDS_RE = /\{%\s*extends\s+/;
 
 function shouldBypassCache(isDev) {
   return !!isDev;
@@ -54,21 +57,35 @@ function getDirectoryChain(relativeFilePath) {
 /**
  * Check if a template content explicitly declares its own layout inheritance via `{% extends ... %}`
  *
+ * When the body is not provided, the file is read once and the answer is cached per path
+ * (outside development), so rendering never does synchronous disk I/O per request.
+ *
  * @param {string} [templateBody]
  * @param {string} [fullPath]
+ * @param {boolean} [isDev=false]
  * @returns {boolean}
  */
-function templateHasExtends(templateBody, fullPath) {
-  if (typeof templateBody === 'string' && /\{%\s*extends\s+/.test(templateBody)) {
+function templateHasExtends(templateBody, fullPath, isDev = false) {
+  if (typeof templateBody === 'string' && EXTENDS_RE.test(templateBody)) {
     return true;
   }
-  if (fullPath && fs.existsSync(fullPath)) {
-    try {
-      const content = fs.readFileSync(fullPath, 'utf8');
-      return /\{%\s*extends\s+/.test(content);
-    } catch (_) {}
+  if (!fullPath) return false;
+
+  if (!shouldBypassCache(isDev) && extendsFileCache.has(fullPath)) {
+    return extendsFileCache.get(fullPath);
+  }
+
+  let result = false;
+  try {
+    result = EXTENDS_RE.test(fs.readFileSync(fullPath, 'utf8'));
+  } catch (_) {
+    result = false;
+  }
+
+  if (!shouldBypassCache(isDev)) {
+    extendsFileCache.set(fullPath, result);
   }
-  return false;
+  return result;
 }
 
 /**
@@ -476,6 +493,7 @@ function clearCascadingCaches() {
   layoutFileCache.clear();
   errorFileCache.clear();
   loadingFileCache.clear();
+  extendsFileCache.clear();
 }
 
 module.exports = {

package/src/routing/mount-discovered-routes.js

@@ -9,6 +9,9 @@
 const { createPageHandler } = require('../pages/page-loader');
 const { createApiHandler } = require('../api/api-loader');
 const { getRouteSortMeta } = require('./route-table');
+const { createFragmentRefreshHandler } = require('../../core/client/server-fragments');
+const { createHelpers } = require('../helpers');
+const { resolveMiddlewares } = require('../file-router');
 
 const NOOP = () => {};
 
@@ -55,6 +58,79 @@ function mountDiscoveredRoutes(app, routeTable, context) {
     log(`  ${descriptor.method.toUpperCase().padEnd(6)} ${descriptor.path} -> ${descriptor.source || descriptor.file}`);
   }
 
+  // Record discovered page entries for `/__webspresso/fragments` refresh handler
+  const discoveredPageEntries = routeTable.routes
+    .filter((r) => r.type === 'page')
+    .map((r) => ({
+      routePath: r.path,
+      file: r.file,
+      getPageMod: () => {
+        if (!r.file || !r.file.endsWith('.js')) return null;
+        try {
+          if (context.isDev && require.cache[require.resolve(r.file)]) {
+            delete require.cache[require.resolve(r.file)];
+          }
+          const mod = require(r.file);
+          return typeof mod === 'function' ? { load: mod } : mod.default || mod;
+        } catch (_e) {
+          return null;
+        }
+      },
+      cascadingMiddlewares: [],
+    }));
+
+  app.__discoveredPageEntries = discoveredPageEntries;
+
+  if (!app.__fragmentRefreshMounted && context.nunjucks) {
+    app.__fragmentRefreshMounted = true;
+    const fragmentRefreshHandler = createFragmentRefreshHandler({
+      getPageEntries: () => [
+        ...(app.__ssrPageEntries || []),
+        ...(app.__discoveredPageEntries || []),
+      ],
+      nunjucksEnv: context.nunjucks,
+      buildFsy: (req) => createHelpers({ req, res: req.res }),
+      buildContext: (req, res, { fsy }) => {
+        const ctx = {
+          req,
+          res,
+          db: context.db || null,
+          fsy,
+          params: req.params || {},
+          query: req.query || {},
+          user: req.user,
+          auth: req.auth,
+          session: req.session,
+          service: (name, input, opts) => {
+            if (context.serviceRegistry) {
+              return context.serviceRegistry.call(name, input, ctx, opts);
+            }
+            throw new Error(`Services not configured. Cannot call service '${name}'.`);
+          },
+        };
+        ctx.ctx = ctx;
+        req.context = ctx;
+        req.ctx = ctx;
+        req.req = req;
+        req.res = res;
+        if (context.db && !req.db) req.db = context.db;
+        if (!req.service) req.service = ctx.service;
+        return ctx;
+      },
+      resolveMiddlewareList: (mwList) => resolveMiddlewares(mwList, context.middlewares || {}),
+    });
+
+    const { rateLimit } = require('../../core/rate-limit');
+    const fragmentLimiter = rateLimit({
+      window: 60000,
+      limit: 300,
+      skip: () => process.env.NODE_ENV === 'test',
+    });
+
+    app.get('/__webspresso/fragments', fragmentLimiter, fragmentRefreshHandler);
+    app.post('/__webspresso/fragments', fragmentLimiter, fragmentRefreshHandler);
+  }
+
   // Phase 1: Mount static routes immediately
   for (const r of staticRoutes) {
     bindRoute(r);