webspresso 0.0.103 → 0.0.105

package/src/helpers.js

@@ -11,6 +11,7 @@ const relativeTime = require('dayjs/plugin/relativeTime');
 const utc = require('dayjs/plugin/utc');
 const timezone = require('dayjs/plugin/timezone');
 const customParseFormat = require('dayjs/plugin/customParseFormat');
+const { globToRegExp } = require('../core/utils/regex');
 
 // Extend dayjs with plugins
 dayjs.extend(relativeTime);
@@ -627,15 +628,7 @@ class AssetManager {
    * Escape HTML special characters
    */
   escapeHtml(str) {
-    if (!str || typeof str !== 'string' || !/[&"'<>]/.test(str)) {
-      return str;
-    }
-    return str
-      .replace(/&/g, '&amp;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&#39;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;');
+    return require('../core/utils/html').escapeHtml(str);
   }
 }
 
@@ -667,7 +660,15 @@ function getAssetManager() {
  * @returns {Object} fsy helper object
  */
 function createHelpers(ctx) {
-  const { req, res, baseUrl = process.env.BASE_URL || 'http://localhost:3000', locale = 'en', t = null } = ctx || {};
+  const { req, res, baseUrl = process.env.BASE_URL || 'http://localhost:7331', locale = 'en', t = null } = ctx || {};
+  const resolveAssetManager = () => ctx?.assetManager || ctx?.app?.assetManager || req?.app?.assetManager || getAssetManager();
+  const assetManager = new Proxy({}, {
+    get(_, prop) {
+      const mgr = resolveAssetManager();
+      const val = mgr[prop];
+      return typeof val === 'function' ? val.bind(mgr) : val;
+    }
+  });
 
   return {
     /** Active request locale */
@@ -996,16 +997,6 @@ function createHelpers(ctx) {
       return `<script type="application/ld+json">${json}</script>`;
     },
 
-    /**
-     * Get the path to a static asset
-     * @param {string} path - Asset path
-     * @returns {string}
-     */
-    asset(path) {
-      const assetPath = path.startsWith('/') ? path : `/${path}`;
-      return assetPath;
-    },
-
     /**
      * Get the current locale
      * @returns {string}
@@ -1033,7 +1024,7 @@ function createHelpers(ctx) {
       if (pattern.includes('*')) {
         let regex = isPathRegexCache.get(pattern);
         if (regex === undefined) {
-          regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+          regex = globToRegExp(pattern, { separator: null });
           if (isPathRegexCache.size < 500) {
             isPathRegexCache.set(pattern, regex);
           }
@@ -1050,7 +1041,7 @@ function createHelpers(ctx) {
      * @returns {string}
      */
     asset(assetPath) {
-      return getAssetManager().asset(assetPath);
+      return assetManager.asset(assetPath);
     },
 
     /**
@@ -1060,7 +1051,7 @@ function createHelpers(ctx) {
      * @returns {string}
      */
     css(href, attrs = {}) {
-      return getAssetManager().css(href, attrs);
+      return assetManager.css(href, attrs);
     },
 
     /**
@@ -1070,7 +1061,7 @@ function createHelpers(ctx) {
      * @returns {string}
      */
     js(src, attrs = {}) {
-      return getAssetManager().js(src, attrs);
+      return assetManager.js(src, attrs);
     },
 
     /**
@@ -1081,7 +1072,7 @@ function createHelpers(ctx) {
      * @returns {string}
      */
     img(src, alt = '', attrs = {}) {
-      return getAssetManager().img(src, alt, attrs);
+      return assetManager.img(src, alt, attrs);
     },
 
     /**
@@ -1101,7 +1092,7 @@ function createHelpers(ctx) {
      * @returns {string}
      */
     pageJs(name, attrs = {}) {
-      return getAssetManager().pageJs(name, attrs);
+      return assetManager.pageJs(name, attrs);
     },
 
     /**
@@ -1110,7 +1101,7 @@ function createHelpers(ctx) {
      * @returns {string}
      */
     pageJsUrl(name) {
-      return getAssetManager().pageJsUrl(name);
+      return assetManager.pageJsUrl(name);
     },
 
     /**
@@ -1120,7 +1111,7 @@ function createHelpers(ctx) {
      * @returns {string}
      */
     pageCss(name, attrs = {}) {
-      return getAssetManager().pageCss(name, attrs);
+      return assetManager.pageCss(name, attrs);
     },
 
     /**
@@ -1129,7 +1120,7 @@ function createHelpers(ctx) {
      * @returns {string}
      */
     pageCssUrl(name) {
-      return getAssetManager().pageCssUrl(name);
+      return assetManager.pageCssUrl(name);
     },
 
     /**
@@ -1138,7 +1129,7 @@ function createHelpers(ctx) {
      * @returns {boolean}
      */
     hasPageJs(name) {
-      return getAssetManager().hasPageJs(name);
+      return assetManager.hasPageJs(name);
     },
 
     /**
@@ -1147,7 +1138,7 @@ function createHelpers(ctx) {
      * @returns {boolean}
      */
     hasPageCss(name) {
-      return getAssetManager().hasPageCss(name);
+      return assetManager.hasPageCss(name);
     },
 
     /**
@@ -1158,12 +1149,12 @@ function createHelpers(ctx) {
      */
     pageAssets(nameOrAttrs, attrs) {
       if (typeof nameOrAttrs === 'string' && nameOrAttrs.trim()) {
-        return getAssetManager().pageAssets(nameOrAttrs, attrs);
+        return assetManager.pageAssets(nameOrAttrs, attrs);
       }
       const opts = (typeof nameOrAttrs === 'object' && nameOrAttrs !== null) ? nameOrAttrs : (attrs || {});
       const routeFile = req?.context?.file;
       const routePath = req?.context?.path || req?.path;
-      return getAssetManager().pageAssetsForRoute(routeFile, routePath, opts);
+      return assetManager.pageAssetsForRoute(routeFile, routePath, opts);
     },
 
     /**
@@ -2204,6 +2195,162 @@ const utils = {
 
   pageAssets(nameOrAttrs, attrs) {
     return getAssetManager().pageAssets(nameOrAttrs, attrs);
+  },
+
+  fetchWithTimeout(url, options) {
+    return require('../core/utils/fetch').fetchWithTimeout(url, options);
+  },
+
+  safeCompare(a, b) {
+    return require('../core/utils/crypto').safeCompare(a, b);
+  },
+
+  sha256(data, encoding) {
+    return require('../core/utils/crypto').sha256(data, encoding);
+  },
+
+  hmacSha256(data, secret, encoding) {
+    return require('../core/utils/crypto').hmacSha256(data, secret, encoding);
+  },
+
+  randomToken(byteLength, encoding) {
+    return require('../core/utils/crypto').randomToken(byteLength, encoding);
+  },
+
+  randomId(prefix, byteLength, encoding) {
+    return require('../core/utils/crypto').randomId(prefix, byteLength, encoding);
+  },
+
+  base64UrlEncode(input) {
+    return require('../core/utils/crypto').base64UrlEncode(input);
+  },
+
+  base64UrlDecode(input) {
+    return require('../core/utils/crypto').base64UrlDecode(input);
+  },
+
+  escapeHtml(value) {
+    return require('../core/utils/html').escapeHtml(value);
+  },
+
+  unescapeHtml(value) {
+    return require('../core/utils/html').unescapeHtml(value);
+  },
+
+  walkDirectory(dir, options) {
+    return require('../core/utils/fs').walkDirectory(dir, options);
+  },
+
+  walkDirectoryDetailed(dir, options) {
+    return require('../core/utils/fs').walkDirectoryDetailed(dir, options);
+  },
+
+  getClientIp(req, fallback) {
+    return require('../core/utils/ip').getClientIp(req, fallback);
+  },
+
+  stripTrailingSlash(input, options) {
+    return require('../core/utils/url').stripTrailingSlash(input, options);
+  },
+
+  ensureLeadingSlash(input) {
+    return require('../core/utils/url').ensureLeadingSlash(input);
+  },
+
+  ensureTrailingSlash(input) {
+    return require('../core/utils/url').ensureTrailingSlash(input);
+  },
+
+  stripLeadingSlash(input) {
+    return require('../core/utils/url').stripLeadingSlash(input);
+  },
+
+  joinUrl(base, ...paths) {
+    return require('../core/utils/url').joinUrl(base, ...paths);
+  },
+
+  escapeRegExp(str) {
+    return require('../core/utils/regex').escapeRegExp(str);
+  },
+
+  escapeRegex(str) {
+    return require('../core/utils/regex').escapeRegExp(str);
+  },
+
+  globToRegExp(pattern, options) {
+    return require('../core/utils/regex').globToRegExp(pattern, options);
+  },
+
+  parseDurationSec(duration, defaultSec) {
+    return require('../core/utils/time').parseDurationSec(duration, defaultSec);
+  },
+
+  parseDuration(duration, defaultSec) {
+    return require('../core/utils/time').parseDurationSec(duration, defaultSec);
+  },
+
+  parseDurationMs(ttl, defaultMs) {
+    return require('../core/utils/time').parseDurationMs(ttl, defaultMs);
+  },
+
+  parseTtlMs(ttl, defaultMs) {
+    return require('../core/utils/time').parseDurationMs(ttl, defaultMs);
+  },
+
+  sleep(ms) {
+    return require('../core/utils/time').sleep(ms);
+  },
+
+  safeJsonParse(input, fallback, reviver) {
+    return require('../core/utils/json').safeJsonParse(input, fallback, reviver);
+  },
+
+  safeJsonStringify(value, space, fallback) {
+    return require('../core/utils/json').safeJsonStringify(value, space, fallback);
+  },
+
+  isValidJson(str) {
+    return require('../core/utils/json').isValidJson(str);
+  },
+
+  toCamelCase(str) {
+    return require('../core/utils/string').toCamelCase(str);
+  },
+
+  snakeToCamel(str) {
+    return require('../core/utils/string').snakeToCamel(str);
+  },
+
+  toSnakeCase(str) {
+    return require('../core/utils/string').toSnakeCase(str);
+  },
+
+  camelToSnake(str) {
+    return require('../core/utils/string').camelToSnake(str);
+  },
+
+  toKebabCase(str) {
+    return require('../core/utils/string').toKebabCase(str);
+  },
+
+  toPascalCase(str) {
+    return require('../core/utils/string').toPascalCase(str);
+  },
+
+  ensureArray(value) {
+    return require('../core/utils/object').ensureArray(value);
+  },
+
+  pick(obj, keys) {
+    return require('../core/utils/object').pick(obj, keys);
+  },
+
+  omit(obj, keys) {
+    return require('../core/utils/object').omit(obj, keys);
+  },
+
+  deepClone(obj) {
+    return require('../core/utils/object').deepClone(obj);
   }
 };
 

package/src/modules/module-discovery.js

@@ -9,15 +9,7 @@
 const fs = require('fs');
 const path = require('path');
 const { scanDirSafely, isPrivateOrIgnored } = require('../discovery/file-route-parser');
-
-/**
- * Converts a file path to camelCase or dot-separated identifier
- * @param {string} str
- * @returns {string}
- */
-function toCamelCase(str) {
-  return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
-}
+const { toCamelCase } = require('../../core/utils/string');
 
 /**
  * Discovers services, middlewares, and configuration for a module directory

package/src/pages/page-loader.js

@@ -18,6 +18,7 @@ const {
   resolvePageAssets,
   applyPageAssetsToTemplateData,
 } = require('../file-router');
+const { sendEarlyHints } = require('../../core/early-hints');
 
 const EMPTY_ARRAY = Object.freeze([]);
 
@@ -113,7 +114,7 @@ function createPageHandler(descriptor, context) {
       }
 
       // 3. Build Page Context
-      const baseUrl = process.env.BASE_URL || `http://localhost:${process.env.PORT || 3000}`;
+      const baseUrl = process.env.BASE_URL || `http://localhost:${process.env.PORT || 7331}`;
       const locale = detectLocale(req);
       const fsy = createHelpers({ req, res, baseUrl, locale });
 
@@ -162,12 +163,63 @@ function createPageHandler(descriptor, context) {
           err.status = status;
           throw err;
         },
+        earlyHints: (links, cb) => sendEarlyHints(res, links, cb),
         fsy,
         locale,
         t,
         db,
       };
 
+      // 3.5. Dispatch Early Hints (if configured or enabled) before load()
+      const earlyHintsOpt = pageDef.earlyHints !== undefined
+        ? pageDef.earlyHints
+        : (descriptor.earlyHints !== undefined
+            ? descriptor.earlyHints
+            : (appOptions && (appOptions.earlyHints ?? appOptions.server?.earlyHints)));
+
+      if (earlyHintsOpt && earlyHintsOpt !== false && !res.headersSent) {
+        const auto = typeof earlyHintsOpt === 'object' ? (earlyHintsOpt.auto !== false) : Boolean(earlyHintsOpt);
+        const linksToSend = [];
+
+        // Explicit links from page definition or app earlyHints config
+        if (Array.isArray(earlyHintsOpt)) {
+          linksToSend.push(...earlyHintsOpt);
+        } else if (typeof earlyHintsOpt === 'object' && earlyHintsOpt.links) {
+          const customLinks = typeof earlyHintsOpt.links === 'function' ? earlyHintsOpt.links(req) : earlyHintsOpt.links;
+          if (Array.isArray(customLinks)) linksToSend.push(...customLinks);
+          else if (customLinks) linksToSend.push(customLinks);
+        }
+
+        // Auto-discover route CSS & JS assets via AssetManager
+        if (auto) {
+          const assetManager = fsy?.assetManager || getAssetManager();
+          if (assetManager && typeof assetManager.getRouteAssetCandidates === 'function') {
+            const candidates = assetManager.getRouteAssetCandidates(
+              descriptor.source || descriptor.file,
+              descriptor.path
+            );
+            if (Array.isArray(candidates)) {
+              for (const cand of candidates) {
+                if (typeof assetManager.hasPageCss === 'function' && assetManager.hasPageCss(cand)) {
+                  linksToSend.push(assetManager.pageCssUrl(cand));
+                  break;
+                }
+              }
+              for (const cand of candidates) {
+                if (typeof assetManager.hasPageJs === 'function' && assetManager.hasPageJs(cand)) {
+                  linksToSend.push(assetManager.pageJsUrl(cand));
+                  break;
+                }
+              }
+            }
+          }
+        }
+
+        if (linksToSend.length > 0) {
+          sendEarlyHints(res, linksToSend);
+        }
+      }
+
       // 4. Run load() lifecycle
       let loadedData = {};
       if (typeof pageDef.load === 'function') {

package/src/plugin-manager.js

@@ -7,6 +7,8 @@
  * Simple semver comparison utilities
  * (Lightweight alternative to full semver package)
  */
+const { globToRegExp } = require('../core/utils/regex');
+
 const semverCache = new Map();
 
 const semver = {
@@ -112,15 +114,7 @@ function matchPattern(path, pattern) {
   
   let regex = patternRegexCache.get(pattern);
   if (!regex) {
-    // Convert glob to regex
-    const regexPattern = pattern
-      .replace(/[.+^${}()|[\]\\]/g, '\\$&')  // Escape special regex chars
-      .replace(/\*\*/g, '{{GLOBSTAR}}')       // Temp placeholder for **
-      .replace(/\*/g, '[^/]*')                // * matches anything except /
-      .replace(/\{\{GLOBSTAR\}\}/g, '.*')     // ** matches everything
-      .replace(/\?/g, '.');                   // ? matches single char
-
-    regex = new RegExp(`^${regexPattern}$`);
+    regex = globToRegExp(pattern, { separator: '/' });
     if (patternRegexCache.size < 500) {
       patternRegexCache.set(pattern, regex);
     }
@@ -327,8 +321,7 @@ class PluginManager {
         }
       } catch (err) {
         console.warn(`[plugin-manager] Plugin "${plugin.name}" setup() failed:`, err.message);
-        this.plugins.delete(plugin.name);
-        if (plugin.api) this.pluginAPIs.delete(plugin.name);
+        await this._rollbackPlugin(plugin.name, plugin, ctx);
         return;
       }
     }
@@ -343,8 +336,7 @@ class PluginManager {
         }
       } catch (err) {
         console.warn(`[plugin-manager] Plugin "${plugin.name}" register() failed:`, err.message);
-        this.plugins.delete(plugin.name);
-        if (plugin.api) this.pluginAPIs.delete(plugin.name);
+        await this._rollbackPlugin(plugin.name, plugin, ctx);
         return;
       }
     }
@@ -362,6 +354,89 @@ class PluginManager {
     this._applyHelpersAndFilters();
   }
 
+  /**
+   * Roll back any partially acquired state or disposers for a failed plugin
+   * @private
+   */
+  async _rollbackPlugin(name, plugin, ctx) {
+    this.plugins.delete(name);
+    if (plugin && plugin.api) {
+      this.pluginAPIs.delete(name);
+    }
+
+    const remainingDisposers = [];
+    const rollbackDisposers = [];
+    for (const d of this.disposers) {
+      if (d.name === name) {
+        rollbackDisposers.push(d);
+      } else {
+        remainingDisposers.push(d);
+      }
+    }
+    this.disposers = remainingDisposers;
+
+    // Run disposers registered so far by this plugin in reverse order
+    for (let i = rollbackDisposers.length - 1; i >= 0; i--) {
+      try {
+        const res = rollbackDisposers[i].fn();
+        if (res && typeof res.then === 'function') {
+          await res;
+        }
+      } catch (cleanupErr) {
+        console.warn(`[plugin-manager] Rollback disposer for "${name}" failed:`, cleanupErr?.message);
+      }
+    }
+
+    if (plugin && typeof plugin.dispose === 'function') {
+      try {
+        const res = plugin.dispose(ctx);
+        if (res && typeof res.then === 'function') {
+          await res;
+        }
+      } catch (cleanupErr) {
+        console.warn(`[plugin-manager] Rollback dispose() for "${name}" failed:`, cleanupErr?.message);
+      }
+    }
+  }
+
+  /**
+   * Roll back partially acquired state or disposers for a failed plugin (sync)
+   * @private
+   */
+  _rollbackPluginSync(name, plugin, ctx) {
+    this.plugins.delete(name);
+    if (plugin && plugin.api) {
+      this.pluginAPIs.delete(name);
+    }
+
+    const remainingDisposers = [];
+    const rollbackDisposers = [];
+    for (const d of this.disposers) {
+      if (d.name === name) {
+        rollbackDisposers.push(d);
+      } else {
+        remainingDisposers.push(d);
+      }
+    }
+    this.disposers = remainingDisposers;
+
+    for (let i = rollbackDisposers.length - 1; i >= 0; i--) {
+      try {
+        rollbackDisposers[i].fn();
+      } catch (cleanupErr) {
+        console.warn(`[plugin-manager] Rollback disposer for "${name}" failed:`, cleanupErr?.message);
+      }
+    }
+
+    if (plugin && typeof plugin.dispose === 'function') {
+      try {
+        plugin.dispose(ctx);
+      } catch (cleanupErr) {
+        console.warn(`[plugin-manager] Rollback dispose() for "${name}" failed:`, cleanupErr?.message);
+      }
+    }
+  }
+
   /**
    * Register a single plugin (sync)
    */
@@ -402,8 +477,7 @@ class PluginManager {
         }
       } catch (err) {
         console.warn(`[plugin-manager] Plugin "${plugin.name}" setup() failed:`, err.message);
-        this.plugins.delete(plugin.name);
-        if (plugin.api) this.pluginAPIs.delete(plugin.name);
+        this._rollbackPluginSync(plugin.name, plugin, ctx);
         return;
       }
     }
@@ -418,8 +492,7 @@ class PluginManager {
         }
       } catch (err) {
         console.warn(`[plugin-manager] Plugin "${plugin.name}" register() failed:`, err.message);
-        this.plugins.delete(plugin.name);
-        if (plugin.api) this.pluginAPIs.delete(plugin.name);
+        this._rollbackPluginSync(plugin.name, plugin, ctx);
         return;
       }
     }