webspresso 0.0.90 → 0.0.93

package/src/file-router.js

@@ -15,6 +15,7 @@ const {
   frontmatterToPatches,
   clearNjkFrontmatterCaches,
 } = require('./njk-frontmatter');
+const { renderStream } = require('../core/ssr/stream');
 
 const NOOP = () => {};
 const EMPTY_OBJECT = Object.freeze({});
@@ -366,9 +367,31 @@ function scanDirectory(dir, baseDir = dir) {
 /**
  * Load i18n JSON file with caching
  * @param {string} filePath - Path to JSON file
+ * @param {boolean} [isDev=false] - Whether in development mode
  * @returns {Object} Parsed JSON or empty object
  */
-function loadI18nFile(filePath) {
+function loadI18nFile(filePath, isDev = (process.env.NODE_ENV !== 'production')) {
+  if (!isDev) {
+    const cached = i18nCache.get(filePath);
+    if (cached) {
+      return cached.data;
+    }
+    if (!fs.existsSync(filePath)) {
+      i18nCache.set(filePath, { mtime: 0, data: EMPTY_OBJECT });
+      return EMPTY_OBJECT;
+    }
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const data = JSON.parse(content);
+      i18nCache.set(filePath, { mtime: 0, data });
+      return data;
+    } catch (err) {
+      console.error('Error loading i18n file:', filePath, err.message);
+      i18nCache.set(filePath, { mtime: 0, data: EMPTY_OBJECT });
+      return EMPTY_OBJECT;
+    }
+  }
+
   if (!fs.existsSync(filePath)) {
     return EMPTY_OBJECT;
   }
@@ -397,25 +420,43 @@ function loadI18nFile(filePath) {
  * @param {string} pagesDir - Pages directory path
  * @param {string} routeDir - Route directory path
  * @param {string} locale - Locale code
+ * @param {boolean} [isDev=false] - Whether in development mode
  * @returns {Object} Merged translations
  */
-function loadI18n(pagesDir, routeDir, locale) {
+function loadI18n(pagesDir, routeDir, locale, isDev = (process.env.NODE_ENV !== 'production')) {
+  const cacheKey = `${pagesDir}::${routeDir}::${locale}`;
+
+  if (!isDev) {
+    const mergedCached = mergedI18nCache.get(cacheKey);
+    if (mergedCached) {
+      return mergedCached.data;
+    }
+  }
+
   // Load global translations
   const globalPath = path.join(pagesDir, 'locales', `${locale}.json`);
-  const globalTranslations = loadI18nFile(globalPath);
+  const globalTranslations = loadI18nFile(globalPath, isDev);
   
   // Load route-specific translations
   const routePath = path.join(routeDir, 'locales', `${locale}.json`);
-  const routeTranslations = loadI18nFile(routePath);
+  const routeTranslations = loadI18nFile(routePath, isDev);
   
   const gEmpty = globalTranslations === EMPTY_OBJECT || !globalTranslations || Object.keys(globalTranslations).length === 0;
   const rEmpty = routeTranslations === EMPTY_OBJECT || !routeTranslations || Object.keys(routeTranslations).length === 0;
 
-  if (gEmpty && rEmpty) return EMPTY_OBJECT;
-  if (gEmpty) return routeTranslations;
-  if (rEmpty) return globalTranslations;
+  if (gEmpty && rEmpty) {
+    if (!isDev) mergedI18nCache.set(cacheKey, { gm: 0, rm: 0, data: EMPTY_OBJECT });
+    return EMPTY_OBJECT;
+  }
+  if (gEmpty) {
+    if (!isDev) mergedI18nCache.set(cacheKey, { gm: 0, rm: 0, data: routeTranslations });
+    return routeTranslations;
+  }
+  if (rEmpty) {
+    if (!isDev) mergedI18nCache.set(cacheKey, { gm: 0, rm: 0, data: globalTranslations });
+    return globalTranslations;
+  }
 
-  const cacheKey = `${pagesDir}::${routeDir}::${locale}`;
   const gCached = i18nCache.get(globalPath);
   const rCached = i18nCache.get(routePath);
   const gm = gCached?.mtime ?? 0;
@@ -432,33 +473,103 @@ function loadI18n(pagesDir, routeDir, locale) {
   return data;
 }
 
-function createTranslator(translations = {}) {
-  return function t(key, params = EMPTY_OBJECT, defaultVal = null) {
+// Cache for Intl.PluralRules instances
+const pluralRulesCache = new Map();
+
+function getPluralRules(locale) {
+  let pr = pluralRulesCache.get(locale);
+  if (!pr) {
+    try {
+      pr = new Intl.PluralRules(locale);
+    } catch {
+      pr = new Intl.PluralRules('en');
+    }
+    if (pluralRulesCache.size < 100) {
+      pluralRulesCache.set(locale, pr);
+    }
+  }
+  return pr;
+}
+
+function resolveTranslationValue(dict, key) {
+  if (!dict || typeof dict !== 'object') return undefined;
+  if (dict[key] !== undefined) return dict[key];
+
+  const parts = key.split('.');
+  let curr = dict;
+  for (const part of parts) {
+    if (curr && typeof curr === 'object') {
+      curr = curr[part];
+    } else {
+      return undefined;
+    }
+  }
+  return curr;
+}
+
+/**
+ * Create a translation helper function with pluralization, fallback, and formatting support
+ * @param {Object} translations - Primary locale translations dictionary
+ * @param {Object|string} [options] - Options object or locale string
+ * @param {string} [options.locale='en'] - Active locale code
+ * @param {Object} [options.fallbackTranslations] - Fallback translations dictionary
+ * @param {string} [options.fallbackLocale='en'] - Fallback locale code
+ * @returns {Function} Translation function `t`
+ */
+function createTranslator(translations = {}, options = EMPTY_OBJECT) {
+  const opts = typeof options === 'string' ? { locale: options } : (options || EMPTY_OBJECT);
+  const locale = opts.locale || 'en';
+  const fallbackTranslations = opts.fallbackTranslations || null;
+
+  function t(key, params = EMPTY_OBJECT, defaultVal = null) {
     const defaultValue = typeof params === 'string' ? params : defaultVal;
     const interpolationParams = typeof params === 'object' && params !== null ? params : EMPTY_OBJECT;
 
-    let value = translations ? translations[key] : undefined;
-    
-    if (value === undefined && translations) {
-      // Try nested key lookup (e.g., "meta.title")
-      const parts = key.split('.');
-      value = translations;
-      for (const part of parts) {
-        if (value && typeof value === 'object') {
-          value = value[part];
+    let value = resolveTranslationValue(translations, key);
+
+    // If missing in primary locale, fallback to fallback translations
+    if (value === undefined && fallbackTranslations) {
+      value = resolveTranslationValue(fallbackTranslations, key);
+    }
+
+    // Handle Pluralization if value is an object (or when count is passed)
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      const count = interpolationParams.count !== undefined
+        ? Number(interpolationParams.count)
+        : (interpolationParams.n !== undefined
+          ? Number(interpolationParams.n)
+          : (interpolationParams.cardinal !== undefined ? Number(interpolationParams.cardinal) : undefined));
+
+      if (count !== undefined && !Number.isNaN(count)) {
+        const countStr = String(count);
+        if (typeof value[countStr] === 'string') {
+          value = value[countStr];
+        } else if (count === 0 && typeof value.zero === 'string') {
+          value = value.zero;
         } else {
-          value = undefined;
-          break;
+          const category = getPluralRules(locale).select(count);
+          if (typeof value[category] === 'string') {
+            value = value[category];
+          } else if (typeof value.other === 'string') {
+            value = value.other;
+          } else {
+            const firstString = Object.values(value).find((v) => typeof v === 'string');
+            value = firstString !== undefined ? firstString : key;
+          }
         }
       }
     }
-    
+
     if (value === undefined) {
       return defaultValue !== null && defaultValue !== undefined ? defaultValue : key;
     }
-    
+
+    if (typeof value !== 'string') {
+      return value;
+    }
+
     // Replace params like {{name}} in the translation
-    if (typeof value === 'string' && interpolationParams && interpolationParams !== EMPTY_OBJECT && Object.keys(interpolationParams).length > 0) {
+    if (interpolationParams && interpolationParams !== EMPTY_OBJECT && Object.keys(interpolationParams).length > 0) {
       for (const [paramKey, paramValue] of Object.entries(interpolationParams)) {
         let regex = paramRegexCache.get(paramKey);
         if (regex === undefined) {
@@ -468,12 +579,84 @@ function createTranslator(translations = {}) {
             paramRegexCache.set(paramKey, regex);
           }
         }
-        value = value.replace(regex, paramValue);
+        value = value.replace(regex, () => String(paramValue));
       }
     }
-    
+
     return value;
+  }
+
+  // Attach metadata & native formatting helpers to `t`
+  t.locale = locale;
+  t.translations = translations;
+
+  t.number = function formatNumber(num, numOpts) {
+    if (num === null || num === undefined || Number.isNaN(Number(num))) return '';
+    try {
+      return new Intl.NumberFormat(locale, numOpts).format(Number(num));
+    } catch {
+      return String(num);
+    }
   };
+  t.formatNumber = t.number;
+
+  t.currency = function formatCurrency(amount, currency = 'USD', currOpts = {}) {
+    if (amount === null || amount === undefined || Number.isNaN(Number(amount))) return '';
+    try {
+      return new Intl.NumberFormat(locale, { style: 'currency', currency, ...currOpts }).format(Number(amount));
+    } catch {
+      return `${amount} ${currency}`;
+    }
+  };
+  t.formatCurrency = t.currency;
+
+  t.date = function formatDate(date, dateOpts = { dateStyle: 'medium' }) {
+    if (!date) return '';
+    try {
+      const d = date instanceof Date ? date : new Date(date);
+      if (Number.isNaN(d.getTime())) return '';
+      return new Intl.DateTimeFormat(locale, dateOpts).format(d);
+    } catch {
+      return String(date);
+    }
+  };
+  t.formatDate = t.date;
+
+  t.relativeTime = function formatRelativeTime(val, unit = 'day', relOpts = { numeric: 'auto' }) {
+    if (val === null || val === undefined || Number.isNaN(Number(val))) return '';
+    try {
+      return new Intl.RelativeTimeFormat(locale, relOpts).format(Number(val), unit);
+    } catch {
+      return `${val} ${unit}`;
+    }
+  };
+  t.formatRelativeTime = t.relativeTime;
+
+  t.plural = function inlinePlural(count, forms, params = {}) {
+    if (!forms || typeof forms !== 'object') return '';
+    const num = Number(count);
+    const countStr = String(num);
+    let template = forms[countStr];
+    if (typeof template !== 'string') {
+      if (num === 0 && typeof forms.zero === 'string') {
+        template = forms.zero;
+      } else {
+        const category = getPluralRules(locale).select(num);
+        template = forms[category] || forms.other || Object.values(forms)[0] || '';
+      }
+    }
+    const allParams = { count: num, ...params };
+    return template.replace(/{{\s*(\w+)\s*}}/g, (_, k) => String(allParams[k] ?? ''));
+  };
+
+  t.has = function hasKey(key) {
+    if (resolveTranslationValue(translations, key) !== undefined) return true;
+    if (fallbackTranslations && resolveTranslationValue(fallbackTranslations, key) !== undefined) return true;
+    return false;
+  };
+  t.exists = t.has;
+
+  return t;
 }
 
 /**
@@ -483,32 +666,41 @@ function createTranslator(translations = {}) {
  * @returns {Object|null} Route config or null
  */
 function loadRouteConfig(configPath, isDev) {
+  if (!isDev) {
+    if (configCache.has(configPath)) {
+      return configCache.get(configPath);
+    }
+    if (!fs.existsSync(configPath)) {
+      configCache.set(configPath, null);
+      return null;
+    }
+    try {
+      const config = require(configPath);
+      configCache.set(configPath, config);
+      return config;
+    } catch (err) {
+      console.error('Error loading route config:', configPath, err.message);
+      configCache.set(configPath, null);
+      return null;
+    }
+  }
+
   if (!fs.existsSync(configPath)) {
     routeConfigDevCache.delete(configPath);
     return null;
   }
 
   try {
-    if (isDev) {
-      const stats = fs.statSync(configPath);
-      const devCached = routeConfigDevCache.get(configPath);
-      if (devCached && devCached.mtime >= stats.mtimeMs) {
-        return devCached.config;
-      }
-      if (require.cache[require.resolve(configPath)]) {
-        delete require.cache[require.resolve(configPath)];
-      }
-      const config = require(configPath);
-      routeConfigDevCache.set(configPath, { mtime: stats.mtimeMs, config });
-      return config;
+    const stats = fs.statSync(configPath);
+    const devCached = routeConfigDevCache.get(configPath);
+    if (devCached && devCached.mtime >= stats.mtimeMs) {
+      return devCached.config;
     }
-
-    if (configCache.has(configPath)) {
-      return configCache.get(configPath);
+    if (require.cache[require.resolve(configPath)]) {
+      delete require.cache[require.resolve(configPath)];
     }
-
     const config = require(configPath);
-    configCache.set(configPath, config);
+    routeConfigDevCache.set(configPath, { mtime: stats.mtimeMs, config });
     return config;
   } catch (err) {
     console.error('Error loading route config:', configPath, err.message);
@@ -677,6 +869,7 @@ function mountPages(app, options) {
     db = null,
     clientRuntime: clientRuntimeOpt = null,
     pageAssets: pageAssetsOpt = null,
+    serviceRegistry = null,
   } = options;
   const pageAssetsResolved = resolvePageAssets(pageAssetsOpt);
   const clientRuntime = clientRuntimeOpt && typeof clientRuntimeOpt === 'object'
@@ -832,113 +1025,136 @@ function mountPages(app, options) {
   /** Register API routes (shared by static phase and dynamic phase). */
   const registerApiRoutes = (routes) => {
     for (const route of routes) {
-    const handler = require(route.fullPath);
-    const handlerFn = typeof handler === 'function' ? handler : handler.default || handler.handler;
-    const routeMiddleware = handler.middleware;
+      const handler = require(route.fullPath);
+      const handlerFn = typeof handler === 'function' ? handler : handler.default || handler.handler;
+      const routeMiddleware = handler.middleware;
 
-    const preResolvedMw = routeMiddleware
-      ? resolveMiddlewares(routeMiddleware, middlewares)
-      : EMPTY_ARRAY;
-    
-    if (typeof handlerFn !== 'function') {
-      console.warn(`API route ${route.file} does not export a function`);
-      continue;
-    }
+      const preResolvedMw = routeMiddleware
+        ? resolveMiddlewares(routeMiddleware, middlewares)
+        : EMPTY_ARRAY;
     
-    app[route.method](route.routePath, async (req, res, next) => {
-      try {
-        // Same instance as createApp({ db }) / getAppContext().db — available to handler & route middleware
-        if (db != null) {
-          req.db = db;
-        }
+      if (typeof handlerFn !== 'function') {
+        console.warn(`API route ${route.file} does not export a function`);
+        continue;
+      }
 
-        // Reload handler in dev mode
-        if (isDev && require.cache[require.resolve(route.fullPath)]) {
-          delete require.cache[require.resolve(route.fullPath)];
-        }
-        const currentHandler = isDev 
-          ? require(route.fullPath) 
-          : handler;
-        const fn = typeof currentHandler === 'function' 
-          ? currentHandler 
-          : currentHandler.default || currentHandler.handler;
-
-        if (isDev) {
-          invalidateSchema(route.fullPath);
-        }
-        let compiledSchema;
+      let preCompiledSchema = null;
+      if (!isDev) {
         try {
-          compiledSchema = compileSchema(route.fullPath, currentHandler);
+          preCompiledSchema = compileSchema(route.fullPath, handler);
         } catch (schemaErr) {
           console.error(`API schema compile error ${route.routePath}:`, schemaErr);
-          res.status(500).json({ error: 'Internal Server Error', message: schemaErr.message });
-          return;
         }
-
+      }
+      
+      app[route.method](route.routePath, async (req, res, next) => {
         try {
-          applySchema(req, compiledSchema);
-        } catch (err) {
-          if (err instanceof ZodError) {
-            return res.status(400).json({
-              error: 'Validation Error',
-              issues: err.issues,
-            });
+          // Same instance as createApp({ db }) / getAppContext().db — available to handler & route middleware
+          if (db != null) {
+            req.db = db;
           }
-          throw err;
-        }
-        
-        // Run middleware if defined (resolved at route registration — required for stateful middleware like express-rate-limit)
-        if (preResolvedMw.length) {
-          for (const mw of preResolvedMw) {
-            await new Promise((resolve, reject) => {
-              mw(req, res, (err) => {
-                if (err) reject(err);
-                else resolve();
+          if (serviceRegistry != null) {
+            req.service = (name, input, opts) =>
+              serviceRegistry.call(name, input, { req, res, db }, opts);
+          }
+
+          let fn = handlerFn;
+          let compiledSchema = preCompiledSchema;
+
+          // Reload handler and schema in dev mode
+          if (isDev) {
+            if (require.cache[require.resolve(route.fullPath)]) {
+              delete require.cache[require.resolve(route.fullPath)];
+            }
+            const currentHandler = require(route.fullPath);
+            fn = typeof currentHandler === 'function' 
+              ? currentHandler 
+              : currentHandler.default || currentHandler.handler;
+
+            invalidateSchema(route.fullPath);
+            try {
+              compiledSchema = compileSchema(route.fullPath, currentHandler);
+            } catch (schemaErr) {
+              console.error(`API schema compile error ${route.routePath}:`, schemaErr);
+              res.status(500).json({ error: 'Internal Server Error', message: schemaErr.message });
+              return;
+            }
+          }
+
+          try {
+            applySchema(req, compiledSchema);
+          } catch (err) {
+            if (err instanceof ZodError) {
+              return res.status(400).json({
+                error: 'Validation Error',
+                issues: err.issues,
               });
-            });
+            }
+            throw err;
           }
+          
+          // Run middleware if defined (resolved at route registration — required for stateful middleware like express-rate-limit)
+          if (preResolvedMw.length) {
+            for (const mw of preResolvedMw) {
+              await new Promise((resolve, reject) => {
+                mw(req, res, (err) => {
+                  if (err) reject(err);
+                  else resolve();
+                });
+              });
+            }
+          }
+          
+          await fn(req, res, next);
+        } catch (err) {
+          console.error(`API error ${route.routePath}:`, err);
+          const hookCtx = { req, res, error: err };
+          try {
+            await executeHook(globalHooks, 'onError', hookCtx, err);
+          } catch (hookErr) {
+            console.error('Error in onError hook:', hookErr);
+          }
+          return next(err);
         }
-        
-        await fn(req, res, next);
-      } catch (err) {
-        console.error(`API error ${route.routePath}:`, err);
-        const hookCtx = { req, res, error: err };
-        try {
-          await executeHook(globalHooks, 'onError', hookCtx, err);
-        } catch (hookErr) {
-          console.error('Error in onError hook:', hookErr);
-        }
-        return next(err);
-      }
-    });
-    
-    log(`  ${route.method.toUpperCase()} ${route.routePath} -> ${route.file}`);
+      });
+      
+      log(`  ${route.method.toUpperCase()} ${route.routePath} -> ${route.file}`);
     }
   };
 
   /** Register SSR GET routes (shared by static phase and dynamic phase). */
   const registerSsrRoutes = (routes) => {
     for (const route of routes) {
-    const mountConfig = loadRouteConfig(route.configPath, isDev);
-    const preResolvedPageMw = mountConfig?.middleware
-      ? resolveMiddlewares(mountConfig.middleware, middlewares)
-      : EMPTY_ARRAY;
-
-    app.get(route.routePath, async (req, res, next) => {
-      try {
-        // Detect locale
-        const locale = detectLocale(req);
-        
-        // Load translations
-        const translations = loadI18n(absolutePagesDir, route.routeDir, locale);
-        const t = createTranslator(translations);
-        
-        // Load route config
-        const config = loadRouteConfig(route.configPath, isDev);
-        const routeHooks = config?.hooks || EMPTY_OBJECT;
+      const mountConfig = loadRouteConfig(route.configPath, isDev);
+      const preResolvedPageMw = mountConfig?.middleware
+        ? resolveMiddlewares(mountConfig.middleware, middlewares)
+        : EMPTY_ARRAY;
+      const staticRouteHooks = mountConfig?.hooks || EMPTY_OBJECT;
+
+      app.get(route.routePath, async (req, res, next) => {
+        try {
+          // Detect locale
+          const locale = detectLocale(req);
+          const defaultLocale = process.env.DEFAULT_LOCALE || 'en';
+          
+          // Load translations (primary + fallback)
+          const translations = loadI18n(absolutePagesDir, route.routeDir, locale, isDev);
+          const fallbackTranslations = (locale !== defaultLocale)
+            ? loadI18n(absolutePagesDir, route.routeDir, defaultLocale, isDev)
+            : EMPTY_OBJECT;
+
+          const t = createTranslator(translations, {
+            locale,
+            fallbackTranslations,
+            fallbackLocale: defaultLocale,
+          });
+          
+          // Load route config
+          const config = isDev ? loadRouteConfig(route.configPath, true) : mountConfig;
+          const routeHooks = isDev ? (config?.hooks || EMPTY_OBJECT) : staticRouteHooks;
         
         // Create context with plugin helpers merged
-        const baseHelpers = createHelpers({ req, res, locale });
+        const baseHelpers = createHelpers({ req, res, locale, t });
         const pluginHelpers = pluginManager ? pluginManager.getHelpers() : EMPTY_OBJECT;
         if (pluginManager) {
           const contentApi = pluginManager.getPluginAPI('content');
@@ -959,6 +1175,12 @@ function mountPages(app, options) {
           routeDir: route.routeDir,
           locale,
           t,
+          service: (name, input, opts) => {
+            if (serviceRegistry) {
+              return serviceRegistry.call(name, input, ctx, opts);
+            }
+            throw new Error(`Services not configured. Cannot call service '${name}'.`);
+          },
           data: { ...njkTpl.dataPatch },
           meta: {
             title: t('meta.title') !== 'meta.title' ? t('meta.title') : null,
@@ -971,6 +1193,8 @@ function mountPages(app, options) {
           clientRuntime,
         };
         
+        req.context = ctx;
+        
         // Execute hooks: onRequest
         await executeHook(globalHooks, 'onRequest', ctx);
         await executeHook(routeHooks, 'onRequest', ctx);
@@ -1055,6 +1279,18 @@ function mountPages(app, options) {
         
         // Render the template
         const templatePath = route.file.split(path.sep).join('/');
+
+        // SSR Streaming mode (chunked transfer)
+        if (config?.stream || ctx.data?.__stream || ctx.defer) {
+          const streamDefer = ctx.defer || ctx.data?.__defer || {};
+          const status = (route.routePath === '/404' || route.file === '404.njk') ? 404 : 200;
+          return await renderStream(res, templatePath, renderContext, {
+            env: nunjucks,
+            defer: streamDefer,
+            status,
+          });
+        }
+
         let html =
           njkTpl.useStringRender && njkTpl.templateBody != null
             ? nunjucks.renderString(njkTpl.templateBody, renderContext, { path: route.fullPath })

package/src/helpers.js

@@ -140,7 +140,7 @@ class AssetManager {
    */
   buildAttributes(attrs) {
     return Object.entries(attrs)
-      .filter(([_, v]) => v !== undefined && v !== null && v !== false)
+      .filter(([k, v]) => v !== undefined && v !== null && v !== false && /^[a-zA-Z0-9_\-:]+$/.test(k))
       .map(([k, v]) => v === true ? k : `${k}="${this.escapeHtml(String(v))}"`)
       .join(' ');
   }
@@ -186,9 +186,27 @@ function getAssetManager() {
  * @returns {Object} fsy helper object
  */
 function createHelpers(ctx) {
-  const { req, res, baseUrl = process.env.BASE_URL || 'http://localhost:3000' } = ctx;
+  const { req, res, baseUrl = process.env.BASE_URL || 'http://localhost:3000', locale = 'en', t = null } = ctx || {};
 
   return {
+    /** Active request locale */
+    locale,
+
+    /** Active i18n translator function */
+    t,
+
+    /**
+     * Generate URL for switching to a target locale with current query parameters preserved
+     * @param {string} targetLocale - Locale code to switch to (e.g. 'en', 'tr')
+     * @param {string} [customPath] - Optional custom path (defaults to current req.path)
+     * @returns {string} URL string with updated locale query param
+     */
+    localeUrl(targetLocale, customPath) {
+      const p = customPath || (req && req.path ? req.path : '/');
+      const q = { ...(req && req.query ? req.query : {}), lang: targetLocale };
+      return this.url(p, q);
+    },
+
     /**
      * Build a URL path with optional query parameters
      * @param {string} path - URL path