webspresso 0.0.102 → 0.0.104

package/src/plugin-manager.js

@@ -7,20 +7,29 @@
  * Simple semver comparison utilities
  * (Lightweight alternative to full semver package)
  */
+const semverCache = new Map();
+
 const semver = {
   /**
    * Parse version string to components
    */
   parse(version) {
     if (!version) return null;
+    const cached = semverCache.get(version);
+    if (cached !== undefined) return cached;
     const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
-    if (!match) return null;
-    return {
+    if (!match) {
+      if (semverCache.size < 200) semverCache.set(version, null);
+      return null;
+    }
+    const parsed = {
       major: parseInt(match[1], 10),
       minor: parseInt(match[2], 10),
       patch: parseInt(match[3], 10),
       prerelease: match[4] || null
     };
+    if (semverCache.size < 200) semverCache.set(version, parsed);
+    return parsed;
   },
 
   /**
@@ -93,21 +102,29 @@ const semver = {
   }
 };
 
+const patternRegexCache = new Map();
+
 /**
  * Simple glob/minimatch pattern matching
  */
 function matchPattern(path, pattern) {
   if (pattern === '*' || pattern === '**') return true;
   
-  // 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
-
-  const regex = new RegExp(`^${regexPattern}$`);
+  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}$`);
+    if (patternRegexCache.size < 500) {
+      patternRegexCache.set(pattern, regex);
+    }
+  }
   return regex.test(path);
 }
 
@@ -206,6 +223,8 @@ class PluginManager {
    * Resolve dependency order using topological sort
    */
   _resolveDependencyOrder(plugins) {
+    if (!plugins || plugins.length === 0) return [];
+
     const graph = new Map();
     const pluginMap = new Map();
 
@@ -228,6 +247,7 @@ class PluginManager {
 
     // Topological sort (Kahn's algorithm)
     const sorted = [];
+    const sortedNames = new Set();
     const noIncoming = [];
 
     // Find nodes with no dependencies
@@ -243,12 +263,13 @@ class PluginManager {
     while (noIncoming.length > 0) {
       const name = noIncoming.shift();
       sorted.push(pluginMap.get(name));
+      sortedNames.add(name);
 
       // Remove this node from all dependencies
       for (const [n, deps] of graph) {
         if (deps.has(name)) {
           deps.delete(name);
-          if (deps.size === 0 && !sorted.find(p => p.name === n)) {
+          if (deps.size === 0 && !sortedNames.has(n)) {
             noIncoming.push(n);
           }
         }
@@ -257,7 +278,7 @@ class PluginManager {
 
     // Check for cycles - warn and exclude circular plugins
     if (sorted.length !== pluginMap.size) {
-      const remaining = Array.from(pluginMap.keys()).filter(name => !sorted.find(p => p.name === name));
+      const remaining = Array.from(pluginMap.keys()).filter(name => !sortedNames.has(name));
       console.warn(
         `[plugin-manager] Circular dependency detected. Skipping plugins: ${remaining.join(', ')}`
       );

package/src/routing/route-table.js

@@ -6,19 +6,24 @@
  * @module src/routing/route-table
  */
 
+const routeSortMetaCache = new Map();
+
 /**
  * Computes route sorting priority metadata
  * @param {string} routePath
  * @returns {{ tier: number, literalSegCount: number, paramSegCount: number, depth: number, routePath: string }}
  */
 function getRouteSortMeta(routePath) {
+  const cached = routeSortMetaCache.get(routePath);
+  if (cached !== undefined) return cached;
+
   let hasStar = false;
   let hasColon = false;
   let depth = 0;
   let literalSegCount = 0;
   let paramSegCount = 0;
 
-  const clean = routePath.split('?')[0];
+  const clean = routePath.includes('?') ? routePath.split('?')[0] : routePath;
   const segments = clean.split('/').filter(Boolean);
 
   for (const seg of segments) {
@@ -40,13 +45,18 @@ function getRouteSortMeta(routePath) {
   if (hasStar) tier = 2;
   else if (hasColon) tier = 1;
 
-  return {
+  const meta = {
     tier,
     literalSegCount,
     paramSegCount,
     depth,
     routePath,
   };
+
+  if (routeSortMetaCache.size < 1000) {
+    routeSortMetaCache.set(routePath, meta);
+  }
+  return meta;
 }
 
 /**
@@ -56,8 +66,8 @@ function getRouteSortMeta(routePath) {
  * @returns {number}
  */
 function compareRouteOrder(a, b) {
-  const ma = a._sortMeta || getRouteSortMeta(a.path);
-  const mb = b._sortMeta || getRouteSortMeta(b.path);
+  const ma = a._sortMeta || (a._sortMeta = getRouteSortMeta(a.path));
+  const mb = b._sortMeta || (b._sortMeta = getRouteSortMeta(b.path));
 
   if (ma.tier !== mb.tier) return ma.tier - mb.tier;
   if (ma.literalSegCount !== mb.literalSegCount) return mb.literalSegCount - ma.literalSegCount;

package/src/server.js

@@ -54,6 +54,19 @@ const {
 // Async storage for tracking template render call stacks (circular extends guard)
 const renderStackStorage = new AsyncLocalStorage();
 
+let isWebspressoPackageCache = null;
+function checkIsWebspressoPackage() {
+  if (isWebspressoPackageCache === null) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+      isWebspressoPackageCache = Boolean(pkg && pkg.name === 'webspresso');
+    } catch (_) {
+      isWebspressoPackageCache = false;
+    }
+  }
+  return isWebspressoPackageCache;
+}
+
 /**
  * Fast hardware-accelerated Weak ETag generator using native zlib.crc32
  * Up to 13x faster than Express default SHA-1, zero external dependencies.
@@ -91,6 +104,7 @@ function fastETag(body, encoding) {
  */
 function normalizeTemplateName(name) {
   if (typeof name !== 'string') return name;
+  if (!name.includes('\\') && !name.includes('views')) return name;
   let normalized = name.replace(/\\/g, '/');
   // Collapse any repeated views/views/... to a single views/ or clean path
   while (/(?:^|\/)views\/(?:\.\/)?views(?:\/|$)/.test(normalized)) {
@@ -102,6 +116,7 @@ function normalizeTemplateName(name) {
 function canonicalTemplateKey(name) {
   const norm = normalizeTemplateName(name);
   if (typeof norm !== 'string') return String(norm);
+  if (!norm.startsWith('.') && !norm.startsWith('views/')) return norm;
   // Canonical key strips leading ./ or views/ for cycle detection
   return norm.replace(/^\.\//, '').replace(/^views\//, '');
 }
@@ -591,10 +606,7 @@ function createApp(options = {}) {
 
   const rootDir = options.rootDir || (() => {
     if (process.env.NODE_ENV === 'test') {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
-        if (pkg.name === 'webspresso') return process.cwd();
-      } catch (_) {}
+      if (checkIsWebspressoPackage()) return process.cwd();
       return path.resolve(__dirname, '..');
     }
     return process.cwd();
@@ -630,8 +642,8 @@ function createApp(options = {}) {
 
   const shutdownConfig = {
     enabled: true,
-    mode: 'graceful',
-    timeout: 10_000,
+    mode: isDev ? 'force' : 'graceful',
+    timeout: isDev ? 1000 : 10_000,
     ...(options.shutdown || options.server?.shutdown || {}),
   };
 
@@ -875,9 +887,13 @@ function createApp(options = {}) {
     for (let i = 0; i < paramNames.length; i++) {
       const val = match[i + 1];
       if (val !== undefined) {
-        try {
-          params[paramNames[i]] = decodeURIComponent(val);
-        } catch (_) {
+        if (typeof val === 'string' && val.includes('%')) {
+          try {
+            params[paramNames[i]] = decodeURIComponent(val);
+          } catch (_) {
+            params[paramNames[i]] = val;
+          }
+        } else {
           params[paramNames[i]] = val;
         }
       }

package/src/services/validator.js

@@ -8,12 +8,17 @@ const { ValidationError } = require('../../core/errors');
 const { z: zForServices, sanitizeInput, hasDangerousKeys } = require('../../core/validation');
 const z = zForServices;
 
+const descriptorCache = new Map();
+
 /**
  * Compile a concise type string descriptor into a Zod schema
  * @param {string} typeName - Type name descriptor (e.g. 'number', 'string', 'email', 'string?')
  * @returns {z.ZodTypeAny}
  */
 function descriptorToZod(typeName) {
+  const cached = descriptorCache.get(typeName);
+  if (cached) return cached;
+
   const isOptional = typeName.endsWith('?');
   const baseType = isOptional ? typeName.slice(0, -1).toLowerCase() : typeName.toLowerCase();
 
@@ -60,9 +65,15 @@ function descriptorToZod(typeName) {
       break;
   }
 
-  return isOptional ? schema.optional() : schema;
+  const finalSchema = isOptional ? schema.optional() : schema;
+  if (descriptorCache.size < 200) {
+    descriptorCache.set(typeName, finalSchema);
+  }
+  return finalSchema;
 }
 
+const compiledSchemaCache = new WeakMap();
+
 /**
  * Compile service schema definition into an executable validator
  * @param {Function|Object|null} rawSchema - Schema definition
@@ -71,50 +82,64 @@ function descriptorToZod(typeName) {
 function compileServiceSchema(rawSchema) {
   if (!rawSchema) return null;
 
-  // If already a Zod schema
-  if (rawSchema instanceof z.ZodType || typeof rawSchema.safeParse === 'function') {
-    return rawSchema;
+  if (typeof rawSchema === 'object' || typeof rawSchema === 'function') {
+    const cached = compiledSchemaCache.get(rawSchema);
+    if (cached !== undefined) {
+      return cached;
+    }
   }
 
-  // If function: check if ({ z }) schema compiler or custom validator function
-  if (typeof rawSchema === 'function') {
+  let compiled = null;
+
+  // If already a Zod schema
+  if (rawSchema instanceof z.ZodType || typeof rawSchema.safeParse === 'function') {
+    compiled = rawSchema;
+  } else if (typeof rawSchema === 'function') {
+    // If function: check if ({ z }) schema compiler or custom validator function
     try {
-      const compiled = rawSchema({ z: zForServices });
-      if (compiled && (compiled instanceof z.ZodType || typeof compiled.safeParse === 'function')) {
-        return compiled;
+      const res = rawSchema({ z: zForServices });
+      if (res && (res instanceof z.ZodType || typeof res.safeParse === 'function')) {
+        compiled = res;
       }
     } catch (e) {
       // If invoking with { z } throws, treat as a direct validator function
     }
-    return rawSchema;
-  }
-
-  // If object descriptor: { id: 'number', name: 'string', email: 'email' }
-  if (typeof rawSchema === 'object' && rawSchema !== null) {
+    if (!compiled) {
+      compiled = rawSchema;
+    }
+  } else if (typeof rawSchema === 'object' && rawSchema !== null) {
+    // If object descriptor: { id: 'number', name: 'string', email: 'email' }
     const keys = Object.keys(rawSchema);
     if (keys.length === 0) {
-      return null;
-    }
-    const shape = {};
-    for (const [key, val] of Object.entries(rawSchema)) {
-      if (typeof val === 'string') {
-        shape[key] = descriptorToZod(val);
-      } else if (val instanceof z.ZodType || (val && typeof val.safeParse === 'function')) {
-        shape[key] = val;
-      } else if (typeof val === 'object' && val !== null) {
-        const isOpt = val.optional === true || val.required === false;
-        let base = val.type ? descriptorToZod(String(val.type)) : z.any();
-        shape[key] = isOpt ? base.optional() : base;
-      } else if (typeof val === 'function') {
-        shape[key] = z.custom(val);
-      } else {
-        shape[key] = z.any();
+      compiled = null;
+    } else {
+      const shape = {};
+      for (const [key, val] of Object.entries(rawSchema)) {
+        if (typeof val === 'string') {
+          shape[key] = descriptorToZod(val);
+        } else if (val instanceof z.ZodType || (val && typeof val.safeParse === 'function')) {
+          shape[key] = val;
+        } else if (typeof val === 'object' && val !== null) {
+          const isOpt = val.optional === true || val.required === false;
+          let base = val.type ? descriptorToZod(String(val.type)) : z.any();
+          shape[key] = isOpt ? base.optional() : base;
+        } else if (typeof val === 'function') {
+          shape[key] = z.custom(val);
+        } else {
+          shape[key] = z.any();
+        }
       }
+      compiled = z.object(shape);
     }
-    return z.object(shape);
+  } else {
+    compiled = rawSchema;
+  }
+
+  if (typeof rawSchema === 'object' || typeof rawSchema === 'function') {
+    compiledSchemaCache.set(rawSchema, compiled);
   }
 
-  return rawSchema;
+  return compiled;
 }
 
 /**