webspresso 0.0.74 → 0.0.76

package/src/file-router.js

@@ -9,6 +9,12 @@ const { ZodError } = require('zod');
 const { compileSchema, invalidateSchema } = require('../core/compileSchema');
 const { applySchema } = require('../core/applySchema');
 const { createHelpers } = require('./helpers');
+const {
+  loadNjkRouteTemplate,
+  parseNjkFrontmatter,
+  frontmatterToPatches,
+  clearNjkFrontmatterCaches,
+} = require('./njk-frontmatter');
 
 // Cache for i18n files (key: filePath, value: { mtime, data })
 const i18nCache = new Map();
@@ -22,6 +28,89 @@ const routeConfigDevCache = new Map();
 // Cache for API filename -> { method, baseName } (basename keys; stable per process)
 const methodFromFilenameCache = new Map();
 
+const MAX_LOCALE_LEN = 16;
+
+/** @returns {Set<string>} */
+function parseSupportedLocaleSet() {
+  const raw = process.env.SUPPORTED_LOCALES || 'en';
+  return new Set(
+    raw.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean)
+  );
+}
+
+/**
+ * @param {string} raw
+ * @returns {string|null}
+ */
+function normalizeLocaleCandidate(raw) {
+  let s = String(raw).trim().toLowerCase().split(';')[0].split(',')[0].trim().replace(/_/g, '-');
+  if (s.length < 1 || s.length > MAX_LOCALE_LEN) {
+    return null;
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(s)) {
+    return null;
+  }
+  return s;
+}
+
+/**
+ * @param {string|null} normalized
+ * @param {Set<string>} supported
+ * @returns {string|null}
+ */
+function pickMatchingLocale(normalized, supported) {
+  if (!normalized) {
+    return null;
+  }
+  if (supported.has(normalized)) {
+    return normalized;
+  }
+  const base = normalized.split('-')[0];
+  if (supported.has(base)) {
+    return base;
+  }
+  return null;
+}
+
+/**
+ * Linear-time conversion of [...x] → * then [x] → :x (filesystem route segments only).
+ * @param {string} route
+ */
+function rewriteDynamicRouteMarkers(route) {
+  let i = 0;
+  let out = '';
+  const n = route.length;
+  while (i < n) {
+    const open = route.indexOf('[', i);
+    if (open === -1) {
+      out += route.slice(i);
+      break;
+    }
+    out += route.slice(i, open);
+    const close = route.indexOf(']', open + 1);
+    if (close === -1) {
+      out += route.slice(open);
+      break;
+    }
+    const inner = route.slice(open + 1, close);
+    let repl;
+    if (inner.startsWith('...') && inner.length > 3) {
+      repl = '*';
+    } else if (inner.length > 0 && inner.indexOf('[') === -1) {
+      repl = ':' + inner;
+    } else {
+      repl = route.slice(open, close + 1);
+    }
+    out += repl;
+    i = close + 1;
+  }
+  return out;
+}
+
+function escapeRegExp(s) {
+  return String(s).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
 /**
  * Convert a file path to an Express route pattern
  * @param {string} filePath - Relative path from pages/
@@ -43,12 +132,9 @@ function filePathToRoute(filePath, ext) {
     route = '/';
   }
   
-  // Convert [param] to :param
-  route = route.replace(/\[([^\]\.]+)\]/g, ':$1');
-  
-  // Convert [...param] to * (catch-all)
-  route = route.replace(/\[\.\.\.([^\]]+)\]/g, '*');
-  
+  // Convert [param] / [...param] without regex backtracking hazards
+  route = rewriteDynamicRouteMarkers(route);
+
   // Ensure leading slash
   if (!route.startsWith('/')) {
     route = '/' + route;
@@ -65,27 +151,50 @@ function filePathToRoute(filePath, ext) {
  * @returns {{ tier: number, literalSegCount: number, paramSegCount: number, depth: number, routePath: string }}
  */
 function routeRegistrationMeta(routePath) {
-  const hasCatchAll = routePath.includes('*');
-  const hasDynamic = routePath.includes(':');
-  let tier;
-  if (hasCatchAll) tier = 2;
-  else if (hasDynamic) tier = 1;
-  else tier = 0;
-
-  const segments = routePath.split('/').filter(Boolean);
+  let pathHasStar = false;
+  let pathHasColon = false;
+  let depth = 0;
   let literalSegCount = 0;
   let paramSegCount = 0;
-  for (const seg of segments) {
-    if (seg === '*' || (seg.length > 0 && seg.includes('*'))) continue;
-    if (seg.includes(':')) paramSegCount += 1;
+
+  const s = routePath;
+  const n = s.length;
+  let i = 0;
+  while (i < n) {
+    while (i < n && s.charCodeAt(i) === 47 /* / */) i++;
+    if (i >= n) break;
+    const start = i;
+    while (i < n && s.charCodeAt(i) !== 47) i++;
+
+    depth++;
+    let segHasStar = false;
+    let segHasColon = false;
+    for (let j = start; j < i; j++) {
+      const c = s.charCodeAt(j);
+      if (c === 42 /* * */) segHasStar = true;
+      else if (c === 58 /* : */) segHasColon = true;
+    }
+    if (segHasStar) pathHasStar = true;
+    if (segHasColon) pathHasColon = true;
+
+    if (segHasStar) {
+      // Same as: seg === '*' || (seg.length > 0 && seg.includes('*'))
+      continue;
+    }
+    if (segHasColon) paramSegCount += 1;
     else literalSegCount += 1;
   }
 
+  let tier;
+  if (pathHasStar) tier = 2;
+  else if (pathHasColon) tier = 1;
+  else tier = 0;
+
   return {
     tier,
     literalSegCount,
     paramSegCount,
-    depth: segments.length,
+    depth,
     routePath,
   };
 }
@@ -260,7 +369,7 @@ function loadI18nFile(filePath) {
     i18nCache.set(filePath, { mtime: stats.mtimeMs, data });
     return data;
   } catch (err) {
-    console.error(`Error loading i18n file ${filePath}:`, err.message);
+    console.error('Error loading i18n file:', filePath, err.message);
     return {};
   }
 }
@@ -315,7 +424,8 @@ function createTranslator(translations) {
     // Replace params like {{name}} in the translation
     if (typeof value === 'string' && Object.keys(params).length > 0) {
       for (const [paramKey, paramValue] of Object.entries(params)) {
-        value = value.replace(new RegExp(`{{\\s*${paramKey}\\s*}}`, 'g'), paramValue);
+        const escaped = escapeRegExp(paramKey);
+        value = value.replace(new RegExp(`{{\\s*${escaped}\\s*}}`, 'g'), paramValue);
       }
     }
     
@@ -358,7 +468,7 @@ function loadRouteConfig(configPath, isDev) {
     configCache.set(configPath, config);
     return config;
   } catch (err) {
-    console.error(`Error loading route config ${configPath}:`, err.message);
+    console.error('Error loading route config:', configPath, err.message);
     return null;
   }
 }
@@ -380,9 +490,9 @@ function loadGlobalHooks(pagesDir, isDev) {
  * @param {string} hookName - Hook name
  * @param {Object} ctx - Context object
  */
-async function executeHook(hooks, hookName, ctx) {
+async function executeHook(hooks, hookName, ctx, ...extra) {
   if (hooks && typeof hooks[hookName] === 'function') {
-    await hooks[hookName](ctx);
+    await hooks[hookName](ctx, ...extra);
   }
 }
 
@@ -392,23 +502,32 @@ async function executeHook(hooks, hookName, ctx) {
  * @returns {string} Locale code
  */
 function detectLocale(req) {
-  // 1. Check query parameter
-  if (req.query.lang) {
-    return req.query.lang;
+  const supported = parseSupportedLocaleSet();
+  const defaultCand = normalizeLocaleCandidate(process.env.DEFAULT_LOCALE || 'en');
+  const def =
+    pickMatchingLocale(defaultCand, supported)
+    ?? (supported.has('en') ? 'en' : [...supported][0])
+    ?? 'en';
+
+  if (req.query && req.query.lang != null && req.query.lang !== '') {
+    const q = normalizeLocaleCandidate(String(req.query.lang));
+    const hit = pickMatchingLocale(q, supported);
+    if (hit) {
+      return hit;
+    }
   }
-  
-  // 2. Check Accept-Language header
+
   const acceptLanguage = req.get('Accept-Language');
   if (acceptLanguage) {
-    const supported = (process.env.SUPPORTED_LOCALES || 'en').split(',');
-    const preferred = acceptLanguage.split(',')[0].split('-')[0].toLowerCase();
-    if (supported.includes(preferred)) {
-      return preferred;
+    const langPart = acceptLanguage.split(',')[0];
+    const a = normalizeLocaleCandidate(langPart);
+    const hit = pickMatchingLocale(a, supported);
+    if (hit) {
+      return hit;
     }
   }
-  
-  // 3. Default locale
-  return process.env.DEFAULT_LOCALE || 'en';
+
+  return def;
 }
 
 /**
@@ -551,7 +670,7 @@ function mountPages(app, options) {
       apiRoutes.push({
         file,
         method,
-        routePath: filePathToRoute(routePath.replace(/^\/api/, '/api'), ''),
+        routePath: filePathToRoute(routePath, ''),
         fullPath: path.join(absolutePagesDir, file)
       });
     } else if (ext === '.njk') {
@@ -586,6 +705,10 @@ function mountPages(app, options) {
     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)
+      : [];
     
     if (typeof handlerFn !== 'function') {
       console.warn(`API route ${route.file} does not export a function`);
@@ -634,11 +757,9 @@ function mountPages(app, options) {
           throw err;
         }
         
-        // Run middleware if defined
-        const mwConfig = isDev ? currentHandler.middleware : routeMiddleware;
-        if (mwConfig) {
-          const resolvedMw = resolveMiddlewares(mwConfig, middlewares);
-          for (const mw of resolvedMw) {
+        // 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);
@@ -651,7 +772,13 @@ function mountPages(app, options) {
         await fn(req, res, next);
       } catch (err) {
         console.error(`API error ${route.routePath}:`, err);
-        res.status(500).json({ error: 'Internal Server Error' });
+        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);
       }
     });
     
@@ -662,6 +789,11 @@ function mountPages(app, options) {
   /** 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)
+      : [];
+
     app.get(route.routePath, async (req, res, next) => {
       try {
         // Detect locale
@@ -679,6 +811,8 @@ function mountPages(app, options) {
         const baseHelpers = createHelpers({ req, res, locale });
         const pluginHelpers = pluginManager ? pluginManager.getHelpers() : {};
         
+        const njkTpl = loadNjkRouteTemplate(route.fullPath, isDev);
+
         const ctx = {
           req,
           res,
@@ -688,12 +822,13 @@ function mountPages(app, options) {
           routeDir: route.routeDir,
           locale,
           t,
-          data: {},
+          data: { ...njkTpl.dataPatch },
           meta: {
             title: t('meta.title') !== 'meta.title' ? t('meta.title') : null,
             description: t('meta.description') !== 'meta.description' ? t('meta.description') : null,
             indexable: true,
-            canonical: null
+            canonical: null,
+            ...njkTpl.metaPatch,
           },
           fsy: { ...baseHelpers, ...pluginHelpers },
           clientRuntime,
@@ -711,10 +846,9 @@ function mountPages(app, options) {
         await executeHook(globalHooks, 'beforeMiddleware', ctx);
         await executeHook(routeHooks, 'beforeMiddleware', ctx);
         
-        // Run route middleware
-        if (config?.middleware) {
-          const resolvedMiddlewares = resolveMiddlewares(config.middleware, middlewares);
-          for (const mw of resolvedMiddlewares) {
+        // Run route middleware (chain fixed at route registration; edit middleware in dev → restart)
+        if (preResolvedPageMw.length) {
+          for (const mw of preResolvedPageMw) {
             await new Promise((resolve, reject) => {
               mw(req, res, (err) => {
                 if (err) reject(err);
@@ -774,7 +908,10 @@ function mountPages(app, options) {
         
         // Render the template
         const templatePath = route.file.split(path.sep).join('/');
-        const html = nunjucks.render(templatePath, renderContext);
+        const html =
+          njkTpl.useStringRender && njkTpl.templateBody != null
+            ? nunjucks.renderString(njkTpl.templateBody, renderContext, { path: route.fullPath })
+            : nunjucks.render(templatePath, renderContext);
         
         // Execute hooks: afterRender
         ctx.html = html;
@@ -793,7 +930,7 @@ function mountPages(app, options) {
           console.error('Error in onError hook:', hookErr);
         }
         
-        res.status(500).send('Internal Server Error');
+        return next(err);
       }
     });
     
@@ -845,5 +982,9 @@ module.exports = {
   compareRouteRegistrationOrder,
   resolvePageAssets,
   applyPageAssetsToTemplateData,
+  parseNjkFrontmatter,
+  frontmatterToPatches,
+  loadNjkRouteTemplate,
+  clearNjkFrontmatterCaches,
 };
 

package/src/njk-frontmatter.js

@@ -0,0 +1,156 @@
+/**
+ * YAML frontmatter for pages/*.njk (optional).
+ * Opens with --- … --- at file top; merges into ctx.meta / ctx.data before route hooks/load.
+ */
+
+const fs = require('fs');
+const { parse } = require('yaml');
+
+const FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
+
+/** @typedef {{ metaPatch: Record<string, unknown>, dataPatch: Record<string, unknown> }} Patch */
+
+const prodRouteCache = new Map();
+/** @type {Map<string, { mtimeMs: number, cached: LoadedNjk }>} */
+const devRouteCache = new Map();
+
+/** @typedef {{ useStringRender: boolean, templateBody: string|null, metaPatch: Record<string, unknown>, dataPatch: Record<string, unknown> }} LoadedNjk */
+
+/**
+ * @param {string} raw
+ * @returns {{ body: string, yamlText: string|null, extracted: boolean }}
+ */
+function extractFrontmatterBlock(raw) {
+  const strippedBom = raw.replace(/^\uFEFF/, '');
+  const match = strippedBom.match(FRONTMATTER_BLOCK);
+  if (!match) {
+    return { body: strippedBom, yamlText: null, extracted: false };
+  }
+  const body = strippedBom.slice(match[0].length);
+  const yamlText = match[1] != null ? String(match[1]).trimEnd() : '';
+  return { body, yamlText, extracted: true };
+}
+
+/**
+ * @param {string} content Full .njk file contents
+ */
+function parseNjkFrontmatter(content) {
+  const { body, yamlText, extracted } = extractFrontmatterBlock(content);
+  if (!extracted || yamlText == null) {
+    return { body, fm: null, hasDelimiter: extracted };
+  }
+  if (yamlText === '') {
+    return { body, fm: {}, hasDelimiter: true };
+  }
+  try {
+    const fm = parse(yamlText);
+    return {
+      body,
+      fm: fm && typeof fm === 'object' && !Array.isArray(fm) ? fm : null,
+      hasDelimiter: true,
+    };
+  } catch (err) {
+    console.warn('[webspresso] .njk frontmatter YAML parse failed — rendering without fm meta:', err.message);
+    return { body, fm: null, hasDelimiter: true };
+  }
+}
+
+/**
+ * @param {unknown} fm
+ * @returns {Patch}
+ */
+function frontmatterToPatches(fm) {
+  if (!fm || typeof fm !== 'object' || Array.isArray(fm)) {
+    return { metaPatch: {}, dataPatch: {} };
+  }
+
+  /** @type {Record<string, unknown>} */
+  const metaPatch = {};
+  const fmObj = fm;
+  const nestedMeta = fmObj.meta;
+  if (nestedMeta && typeof nestedMeta === 'object' && !Array.isArray(nestedMeta)) {
+    Object.assign(metaPatch, nestedMeta);
+  }
+  for (const k of ['title', 'description', 'canonical', 'indexable']) {
+    if (Object.prototype.hasOwnProperty.call(fmObj, k) && fmObj[k] !== undefined) {
+      metaPatch[k] = fmObj[k];
+    }
+  }
+
+  /** @type {Record<string, unknown>} */
+  let dataPatch = {};
+  const d = fmObj.data;
+  if (d && typeof d === 'object' && !Array.isArray(d)) {
+    dataPatch = { ...d };
+  }
+
+  return { metaPatch, dataPatch };
+}
+
+/**
+ * @param {boolean} [isDevLike]
+ */
+function readAndParse(absPath, isDevLike = false) {
+  const raw = fs.readFileSync(absPath, 'utf8');
+  const { body, fm, hasDelimiter } = parseNjkFrontmatter(raw);
+  const patches = frontmatterToPatches(fm);
+
+  /** @type {LoadedNjk} */
+  const loaded = {
+    useStringRender: !!hasDelimiter,
+    templateBody: hasDelimiter ? body : null,
+    metaPatch: patches.metaPatch,
+    dataPatch: patches.dataPatch,
+  };
+
+  if (isDevLike) {
+    return loaded;
+  }
+  prodRouteCache.set(absPath, loaded);
+  return loaded;
+}
+
+/**
+ * @param {string} absPath Absolute path to pages/…/*.njk
+ * @param {boolean} isDev NODE_ENV !== 'production' style
+ */
+function loadNjkRouteTemplate(absPath, isDev) {
+  if (!fs.existsSync(absPath)) {
+    return {
+      useStringRender: false,
+      templateBody: null,
+      metaPatch: {},
+      dataPatch: {},
+    };
+  }
+
+  const stat = fs.statSync(absPath);
+
+  if (isDev) {
+    const prev = devRouteCache.get(absPath);
+    if (prev && prev.mtimeMs >= stat.mtimeMs) {
+      return prev.cached;
+    }
+    const fresh = readAndParse(absPath, true);
+    devRouteCache.set(absPath, { mtimeMs: stat.mtimeMs, cached: fresh });
+    return fresh;
+  }
+
+  if (prodRouteCache.has(absPath)) {
+    return prodRouteCache.get(absPath);
+  }
+  return readAndParse(absPath, false);
+}
+
+function clearNjkFrontmatterCaches() {
+  prodRouteCache.clear();
+  devRouteCache.clear();
+}
+
+module.exports = {
+  parseNjkFrontmatter,
+  frontmatterToPatches,
+  loadNjkRouteTemplate,
+  clearNjkFrontmatterCaches,
+  extractFrontmatterBlock,
+};

package/src/plugin-manager.js

@@ -130,7 +130,7 @@ class PluginManager {
   /**
    * Register plugins with the manager (async version)
    * @param {Array} plugins - Array of plugin definitions or factory functions
-   * @param {Object} context - Context object { app, nunjucksEnv, options }
+   * @param {Object} context - Context object `{ app, nunjucksEnv, options, middlewares? }`
    */
   async register(plugins, context) {
     if (!plugins || !Array.isArray(plugins)) return;
@@ -159,7 +159,7 @@ class PluginManager {
   /**
    * Register plugins with the manager (sync version)
    * @param {Array} plugins - Array of plugin definitions or factory functions
-   * @param {Object} context - Context object { app, nunjucksEnv, options }
+   * @param {Object} context - Context object `{ app, nunjucksEnv, options, middlewares? }`
    */
   registerSync(plugins, context) {
     if (!plugins || !Array.isArray(plugins)) return;
@@ -372,6 +372,8 @@ class PluginManager {
       options: plugin._options || {},
       nunjucksEnv: context.nunjucksEnv,
       db: context.options?.db ?? null,
+      /** @type {Record<string, unknown>} Named middleware registry (same reference as createApp → mountPages) */
+      middlewares: context.middlewares ?? {},
 
       /**
        * Get another plugin's API

package/src/server.js

@@ -11,7 +11,7 @@ const timeout = require('connect-timeout');
 const { setAppContext } = require('./app-context');
 const { mountClientRuntime } = require('./client-runtime/mount');
 const { resolveClientRuntime } = require('./client-runtime/resolve');
-const { mountPages } = require('./file-router');
+const { mountPages, detectLocale } = require('./file-router');
 const { configureAssets, createHelpers, getScriptInjector } = require('./helpers');
 const { createPluginManager } = require('./plugin-manager');
 
@@ -57,6 +57,16 @@ function getDefaultHelmetConfig(isDev) {
   };
 }
 
+/**
+ * Use JSON error responses for `pages/api/*` routes and clients that do not prefer HTML.
+ * @param {import('express').Request} req
+ * @returns {boolean}
+ */
+function preferJsonErrorResponse(req) {
+  if (req.path && req.path.startsWith('/api')) return true;
+  return !req.accepts('html');
+}
+
 /**
  * Shared CSS for built-in HTML error pages (viewport-safe, fluid type, dark mode)
  */
@@ -376,6 +386,12 @@ function createApp(options = {}) {
     middlewares.auth = authMiddleware.auth;
     middlewares.guest = authMiddleware.guest;
   }
+
+  // Under Vitest, shared API fixtures use `fixtureRequireAuth`; default no-op unless overridden.
+  const runsUnderVitest = process.env.VITEST === 'true' || process.env.VITEST_WORKER_ID !== undefined;
+  if (runsUnderVitest && middlewares.fixtureRequireAuth == null) {
+    middlewares.fixtureRequireAuth = (req, res, next) => next();
+  }
   
   // Static files (if publicDir provided)
   if (publicDir) {
@@ -421,8 +437,8 @@ function createApp(options = {}) {
     return d.toString();
   });
   
-  // Register plugins (sync)
-  const pluginContext = { app, nunjucksEnv, options };
+  // Register plugins (sync) — middlewares is the same object later passed to mountPages
+  const pluginContext = { app, nunjucksEnv, options, middlewares };
   pluginManager.registerSync(plugins, pluginContext);
   
   // Request logging middleware
@@ -463,6 +479,7 @@ function createApp(options = {}) {
         app,
         nunjucksEnv,
         options,
+        middlewares,
         db: options.db ?? null,
         routes: pluginManager.routes,
         usePlugin: (n) => pluginManager.getPluginAPI(n),
@@ -501,7 +518,7 @@ function createApp(options = {}) {
   // Helper to create error page context with fsy
   function createErrorContext(req, extraData = {}) {
     const baseUrl = process.env.BASE_URL || `http://localhost:${process.env.PORT || 3000}`;
-    const locale = req.query?.lang || process.env.DEFAULT_LOCALE || 'en';
+    const locale = detectLocale(req);
     
     // Create fsy helpers
     const fsy = createHelpers({ req, res: {}, baseUrl, locale });
@@ -562,7 +579,7 @@ function createApp(options = {}) {
       }
       
       // Custom timeout template
-      if (typeof errorPages.timeout === 'string') {
+      if (typeof errorPages.timeout === 'string' && !preferJsonErrorResponse(req)) {
         try {
           const html = nunjucksEnv.render(errorPages.timeout, ctx);
           return res.send(html);
@@ -572,7 +589,7 @@ function createApp(options = {}) {
       }
       
       // Default timeout response
-      if (req.accepts('html')) {
+      if (!preferJsonErrorResponse(req)) {
         return res.send(default503Html());
       } else {
         return res.json({ error: 'Request Timeout', status: 503 });
@@ -591,8 +608,8 @@ function createApp(options = {}) {
       return errorPages.serverError(err, req, res, ctx);
     }
     
-    // Custom template
-    if (typeof errorPages.serverError === 'string') {
+    // Custom template (skipped for /api and JSON-preferring clients so they never get HTML)
+    if (typeof errorPages.serverError === 'string' && !preferJsonErrorResponse(req)) {
       try {
         const html = nunjucksEnv.render(errorPages.serverError, ctx);
         return res.send(html);
@@ -602,7 +619,7 @@ function createApp(options = {}) {
     }
     
     // Default response
-    if (req.accepts('html')) {
+    if (!preferJsonErrorResponse(req)) {
       res.send(default500Html(err, isDev));
     } else {
       res.json({