webspresso 0.0.99 → 0.0.100

package/plugins/webhooks/sender.js

@@ -0,0 +1,176 @@
+/**
+ * Webhook Sender Module
+ * Zero-dependency HTTP/HTTPS delivery using native fetch with signatures & timeouts
+ * @module plugins/webhooks/sender
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const { signPayload } = require('./crypto');
+
+/**
+ * Send a webhook HTTP request to a target endpoint
+ * 
+ * @param {Object} options
+ * @param {string} options.url - Destination URL
+ * @param {string} options.event - Event name (e.g. 'order.created')
+ * @param {any} options.payload - Event payload data
+ * @param {string} [options.secret] - Signing secret
+ * @param {string} [options.deliveryId] - Unique delivery ID
+ * @param {Object} [options.headers] - Custom headers to merge
+ * @param {number} [options.timeoutMs=10000] - Request timeout in milliseconds
+ * @param {boolean} [options.wrapPayload=true] - Wrap data in standard event envelope
+ * @param {number} [options.maxResponseBodyLength=2048] - Max response length to store
+ * @returns {Promise<{
+ *   success: boolean,
+ *   statusCode: number,
+ *   responseBody: string,
+ *   durationMs: number,
+ *   error: string|null,
+ *   deliveryId: string,
+ *   timestamp: number
+ * }>}
+ */
+async function sendWebhook(options) {
+  const {
+    url,
+    event,
+    payload,
+    secret,
+    deliveryId = crypto.randomUUID ? crypto.randomUUID() : `dlv_${Date.now()}_${crypto.randomBytes(6).toString('hex')}`,
+    headers: customHeaders = {},
+    timeoutMs = 10000,
+    wrapPayload = true,
+    maxResponseBodyLength = 2048,
+  } = options;
+
+  if (!url || typeof url !== 'string') {
+    return {
+      success: false,
+      statusCode: 0,
+      responseBody: '',
+      durationMs: 0,
+      error: 'Invalid webhook URL: destination URL is required.',
+      deliveryId,
+      timestamp: Math.floor(Date.now() / 1000),
+    };
+  }
+
+  const timestamp = Math.floor(Date.now() / 1000);
+
+  // Construct request body
+  let bodyObj = payload;
+  if (wrapPayload && (typeof payload !== 'object' || payload === null || !payload.event)) {
+    bodyObj = {
+      id: deliveryId,
+      event,
+      timestamp,
+      data: payload,
+    };
+  }
+  const bodyStr = typeof bodyObj === 'string' ? bodyObj : JSON.stringify(bodyObj);
+
+  // Calculate cryptographic signatures if secret is configured
+  let signatureHeaders = {};
+  if (secret) {
+    const { signature, timestampedSignature } = signPayload(bodyStr, secret, { timestamp });
+    signatureHeaders = {
+      'x-webspresso-signature': signature,
+      'x-hub-signature-256': signature,
+      'webhook-signature': timestampedSignature,
+    };
+  }
+
+  // Parse custom headers if stored as JSON string
+  let parsedCustomHeaders = {};
+  if (typeof customHeaders === 'string') {
+    try {
+      parsedCustomHeaders = JSON.parse(customHeaders);
+    } catch (e) {
+      parsedCustomHeaders = {};
+    }
+  } else if (typeof customHeaders === 'object' && customHeaders !== null) {
+    parsedCustomHeaders = customHeaders;
+  }
+
+  const requestHeaders = {
+    'content-type': 'application/json',
+    'accept': 'application/json, text/plain, */*',
+    'user-agent': 'Webspresso-Webhooks/1.0',
+    'x-webspresso-event': event,
+    'x-webspresso-delivery': deliveryId,
+    'x-webspresso-timestamp': String(timestamp),
+    'webhook-id': deliveryId,
+    'webhook-timestamp': String(timestamp),
+    ...signatureHeaders,
+    ...parsedCustomHeaders,
+  };
+
+  const startTime = Date.now();
+  let controller = null;
+  let timeoutId = null;
+
+  try {
+    controller = new AbortController();
+    timeoutId = setTimeout(() => {
+      controller.abort();
+    }, timeoutMs);
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: requestHeaders,
+      body: bodyStr,
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+    const durationMs = Date.now() - startTime;
+
+    let responseBody = '';
+    try {
+      const rawText = await response.text();
+      responseBody = rawText ? rawText.slice(0, maxResponseBodyLength) : '';
+    } catch (textErr) {
+      responseBody = '';
+    }
+
+    const success = response.status >= 200 && response.status < 300;
+    const error = success ? null : `HTTP ${response.status}: ${response.statusText || 'Delivery Failed'}`;
+
+    return {
+      success,
+      statusCode: response.status,
+      responseBody,
+      durationMs,
+      error,
+      deliveryId,
+      timestamp,
+      bodyStr,
+    };
+  } catch (err) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    const durationMs = Date.now() - startTime;
+    const isTimeout = err.name === 'AbortError' || err.code === 'ABORT_ERR';
+    const errorMsg = isTimeout
+      ? `Webhook delivery timed out after ${timeoutMs}ms`
+      : (err.message || 'Network error');
+
+    return {
+      success: false,
+      statusCode: 0,
+      responseBody: '',
+      durationMs,
+      error: errorMsg,
+      deliveryId,
+      timestamp,
+      bodyStr,
+    };
+  }
+}
+
+module.exports = {
+  sendWebhook,
+};

package/src/bundle/index.js

@@ -132,7 +132,8 @@ function expandGlob(pattern, cwd = process.cwd()) {
 
   const isRecursive = normalized.includes('**');
   const regexPattern = '^' + normalized
-    .replace(/\./g, '\\.')
+    .replace(/\\/g, '\\\\')
+    .replace(/[.+?^${}()|[\]]/g, '\\$&')
     .replace(/\*\*\//g, '(.+/)?')
     .replace(/\*\*/g, '.*')
     .replace(/\*/g, '[^/]*') + '$';

package/src/file-router.js

@@ -23,6 +23,8 @@ const {
   findCascadingLayouts,
   executeCascadingLayoutLoads,
   applyCascadingLayouts,
+  findNearestErrorBoundary,
+  findNearestLoadingTemplate,
   templateHasExtends,
 } = require('./routing/cascading');
 const {
@@ -33,6 +35,148 @@ const {
 
 const NOOP = () => {};
 const EMPTY_OBJECT = Object.freeze({});
+
+/**
+ * Handles directory-level error boundaries (_error.njk and companion _error.js)
+ * @returns {Promise<boolean>} True if rendered, false if unhandled
+ */
+async function handleDirectoryErrorBoundary({
+  err,
+  route,
+  req,
+  res,
+  ctx,
+  absolutePagesDir,
+  nunjucks,
+  isDev,
+  compiledStringTemplateCache,
+  baseHelpers,
+}) {
+  if (res.headersSent) {
+    return false;
+  }
+
+  const errorBoundary = findNearestErrorBoundary(absolutePagesDir, route.file, isDev);
+  if (!errorBoundary) {
+    return false;
+  }
+
+  const statusCode =
+    err?.status ||
+    err?.statusCode ||
+    (typeof err?.getStatus === 'function' ? err.getStatus() : null) ||
+    500;
+
+  try {
+    let errorData = {};
+    let errorConfig = null;
+
+    if (errorBoundary.configPath) {
+      try {
+        if (isDev && require.cache[require.resolve(errorBoundary.configPath)]) {
+          delete require.cache[require.resolve(errorBoundary.configPath)];
+        }
+        const mod = require(errorBoundary.configPath);
+        errorConfig = mod?.default || mod;
+        const loadFn = typeof errorConfig === 'function' ? errorConfig : errorConfig?.load;
+        if (typeof loadFn === 'function') {
+          const loaded = await loadFn({
+            req,
+            res,
+            error: err,
+            ctx,
+            db: req.db,
+          });
+          if (loaded && typeof loaded === 'object' && !Array.isArray(loaded)) {
+            Object.assign(errorData, loaded);
+          }
+        }
+      } catch (loadErr) {
+        console.error(`[webspresso] Error in _error.js loader "${errorBoundary.configPath}":`, loadErr.message);
+      }
+    }
+
+    const njkTpl = loadNjkRouteTemplate(errorBoundary.fullPath, isDev);
+    if (njkTpl.dataPatch && Object.keys(njkTpl.dataPatch).length > 0) {
+      Object.assign(errorData, njkTpl.dataPatch);
+    }
+
+    const errorRenderContext = {
+      ...(ctx?.data || {}),
+      ...errorData,
+      error: {
+        message: err?.message || 'An error occurred',
+        status: statusCode,
+        statusCode,
+        code: err?.code || 'ERROR',
+        name: err?.name || 'Error',
+        details: err?.details,
+        fields: err?.fields,
+        stack: isDev ? err?.stack : undefined,
+      },
+      route: {
+        routePath: route.routePath,
+        file: route.file,
+      },
+      meta: Object.assign({}, ctx?.meta, {
+        title: errorData.title || `Error ${statusCode}`,
+        description: errorData.description || err?.message,
+      }),
+      locale: ctx?.locale,
+      t: ctx?.t,
+      fsy: ctx?.fsy || (typeof createHelpers === 'function' ? createHelpers({ req, res, locale: ctx?.locale || 'en' }) : {}),
+      clientRuntime: ctx?.clientRuntime,
+      req: {
+        path: req.path,
+        query: req.query,
+        params: req.params,
+        method: req.method,
+        url: req.url,
+      },
+      isDev,
+    };
+
+    let html;
+    if (njkTpl.useStringRender && njkTpl.templateBody != null) {
+      if (typeof nunjucks.Template === 'function') {
+        let compiled = isDev ? null : compiledStringTemplateCache.get(errorBoundary.fullPath);
+        if (!compiled || (isDev && compiled._templateBody !== njkTpl.templateBody)) {
+          compiled = new nunjucks.Template(njkTpl.templateBody, nunjucks, errorBoundary.fullPath);
+          compiled._templateBody = njkTpl.templateBody;
+          compiledStringTemplateCache.set(errorBoundary.fullPath, compiled);
+        }
+        html = compiled.render(errorRenderContext);
+      } else if (typeof nunjucks.renderString === 'function') {
+        html = nunjucks.renderString(njkTpl.templateBody, errorRenderContext, { path: errorBoundary.fullPath });
+      } else {
+        html = nunjucks.render(errorBoundary.errorRelPath, errorRenderContext);
+      }
+    } else {
+      html = nunjucks.render(errorBoundary.errorRelPath, errorRenderContext);
+    }
+
+    const shouldApplyLayout = errorConfig?.layout !== false &&
+      errorData?.layout !== false &&
+      !templateHasExtends(njkTpl.templateBody, errorBoundary.fullPath);
+
+    if (shouldApplyLayout) {
+      const errorLayouts = findCascadingLayouts(absolutePagesDir, errorBoundary.errorRelPath, isDev);
+      if (errorLayouts.length > 0) {
+        const layoutCtx = { data: { ...errorRenderContext } };
+        await executeCascadingLayoutLoads(errorLayouts, req, layoutCtx, isDev);
+        const mergedLayoutContext = { ...errorRenderContext, ...(layoutCtx.data || {}) };
+        html = applyCascadingLayouts(nunjucks, errorLayouts, html, mergedLayoutContext, isDev);
+      }
+    }
+
+    res.status(statusCode);
+    res.send(html);
+    return true;
+  } catch (renderErr) {
+    console.error(`[webspresso] Failed rendering error boundary "${errorBoundary.errorRelPath}":`, renderErr);
+    return false;
+  }
+}
 const EMPTY_ARRAY = Object.freeze([]);
 
 // Cache for i18n files (key: filePath, value: { mtime, data })
@@ -1459,15 +1603,26 @@ function mountPages(app, options) {
         
         // Render the template
         const templatePath = route.file.split(path.sep).join('/');
+        const nearestLoading = findNearestLoadingTemplate(absolutePagesDir, route.file, isDev);
+        if (nearestLoading) {
+          renderContext.loadingTemplate = nearestLoading.loadingRelPath;
+        }
 
         // SSR Streaming mode (chunked transfer)
-        if (config?.stream || ctx.data?.__stream || ctx.defer) {
-          const streamDefer = ctx.defer || ctx.data?.__defer || {};
+        if (config?.stream || ctx.data?.__stream || ctx.data?.stream || ctx.defer || ctx.data?.defer) {
+          const streamDefer = ctx.defer || ctx.data?.defer || ctx.data?.__defer || {};
           const status = (route.routePath === '/404' || route.file === '404.njk') ? 404 : 200;
+          const shouldApplyLayout = config?.layout !== false &&
+            ctx.data?.layout !== false &&
+            ctx.meta?.layout !== false &&
+            !templateHasExtends(njkTpl.templateBody, route.fullPath);
+
           return await renderStream(res, templatePath, renderContext, {
             env: nunjucks,
             defer: streamDefer,
             status,
+            loadingTemplate: nearestLoading?.loadingRelPath,
+            layouts: shouldApplyLayout && cascadingLayouts.length > 0 ? cascadingLayouts : undefined,
           });
         }
 
@@ -1520,13 +1675,27 @@ function mountPages(app, options) {
         console.error(`SSR error ${route.routePath}:`, err);
         
         // Execute onError hook
-        const ctx = { req, res, error: err };
+        const hookCtx = { req, res, error: err };
         try {
-          await executeHook(globalHooks, 'onError', ctx, err);
+          await executeHook(globalHooks, 'onError', hookCtx, err);
         } catch (hookErr) {
           console.error('Error in onError hook:', hookErr);
         }
         
+        const handled = await handleDirectoryErrorBoundary({
+          err,
+          route,
+          req,
+          res,
+          ctx: req.context || hookCtx,
+          absolutePagesDir,
+          nunjucks,
+          isDev,
+          compiledStringTemplateCache,
+        });
+
+        if (handled) return;
+
         return next(err);
       }
     });

package/src/helpers.js

@@ -294,7 +294,13 @@ class AssetManager {
     }
 
     if (routePath) {
-      let cleanPath = String(routePath).trim().replace(/^\/+/, '').replace(/\/+$/, '');
+      let cleanPath = String(routePath).trim();
+      while (cleanPath.startsWith('/')) {
+        cleanPath = cleanPath.slice(1);
+      }
+      while (cleanPath.endsWith('/')) {
+        cleanPath = cleanPath.slice(0, -1);
+      }
       if (cleanPath) {
         candidates.add(cleanPath);
         if (cleanPath.includes(':')) {

package/src/njk-frontmatter.js

@@ -83,6 +83,9 @@ function frontmatterToPatches(fm) {
   if (d && typeof d === 'object' && !Array.isArray(d)) {
     dataPatch = { ...d };
   }
+  if (Object.prototype.hasOwnProperty.call(fmObj, 'layout') && fmObj.layout !== undefined) {
+    dataPatch.layout = fmObj.layout;
+  }
 
   return { metaPatch, dataPatch };
 }

package/src/routing/cascading.js

@@ -16,6 +16,8 @@ const EMPTY_ARRAY = Object.freeze([]);
 // Caches for production mode (key: directory path)
 const middlewareFileCache = new Map();
 const layoutFileCache = new Map();
+const errorFileCache = new Map();
+const loadingFileCache = new Map();
 
 /**
  * Returns ancestor directory segments from root down to file's directory.
@@ -359,9 +361,117 @@ function applyCascadingLayouts(nunjucksEnv, layouts, pageHtml, renderContext, is
   return currentHtml;
 }
 
+/**
+ * Discover the nearest _error.njk error boundary template in the directory hierarchy
+ * (from the file's directory segment climbing up to the root pages directory).
+ *
+ * @param {string} baseDir - Base pages directory
+ * @param {string} relativeFilePath - Relative file path (e.g. 'dashboard/billing/invoices.njk')
+ * @param {boolean} [isDev=false]
+ * @returns {{ dirSegment: string, errorRelPath: string, fullPath: string, configPath: string|null }|null}
+ */
+function findNearestErrorBoundary(baseDir, relativeFilePath, isDev = false) {
+  const chain = getDirectoryChain(relativeFilePath);
+  const cacheKey = `${baseDir}::${chain.join('>')}`;
+
+  if (!isDev && errorFileCache.has(cacheKey)) {
+    return errorFileCache.get(cacheKey);
+  }
+
+  const reversedChain = [...chain].reverse();
+
+  for (const dirSegment of reversedChain) {
+    const errorNjkName = '_error.njk';
+    const errorJsName = '_error.js';
+
+    const errorRelPath = dirSegment === ''
+      ? errorNjkName
+      : `${dirSegment}/${errorNjkName}`;
+
+    const fullPath = dirSegment === ''
+      ? path.join(baseDir, errorNjkName)
+      : path.join(baseDir, ...dirSegment.split('/'), errorNjkName);
+
+    const fullJsPath = dirSegment === ''
+      ? path.join(baseDir, errorJsName)
+      : path.join(baseDir, ...dirSegment.split('/'), errorJsName);
+
+    if (fs.existsSync(fullPath)) {
+      const result = {
+        dirSegment,
+        errorRelPath: errorRelPath.split(path.sep).join('/'),
+        fullPath,
+        configPath: fs.existsSync(fullJsPath) ? fullJsPath : null,
+      };
+
+      if (!isDev) {
+        errorFileCache.set(cacheKey, result);
+      }
+      return result;
+    }
+  }
+
+  if (!isDev) {
+    errorFileCache.set(cacheKey, null);
+  }
+  return null;
+}
+
+/**
+ * Discover the nearest _loading.njk loading/skeleton template in the directory hierarchy
+ * (from the file's directory segment climbing up to the root pages directory).
+ *
+ * @param {string} baseDir - Base pages directory
+ * @param {string} relativeFilePath - Relative file path (e.g. 'dashboard/billing/invoices.njk')
+ * @param {boolean} [isDev=false]
+ * @returns {{ dirSegment: string, loadingRelPath: string, fullPath: string }|null}
+ */
+function findNearestLoadingTemplate(baseDir, relativeFilePath, isDev = false) {
+  const chain = getDirectoryChain(relativeFilePath);
+  const cacheKey = `${baseDir}::${chain.join('>')}`;
+
+  if (!isDev && loadingFileCache.has(cacheKey)) {
+    return loadingFileCache.get(cacheKey);
+  }
+
+  const reversedChain = [...chain].reverse();
+
+  for (const dirSegment of reversedChain) {
+    const loadingNjkName = '_loading.njk';
+
+    const loadingRelPath = dirSegment === ''
+      ? loadingNjkName
+      : `${dirSegment}/${loadingNjkName}`;
+
+    const fullPath = dirSegment === ''
+      ? path.join(baseDir, loadingNjkName)
+      : path.join(baseDir, ...dirSegment.split('/'), loadingNjkName);
+
+    if (fs.existsSync(fullPath)) {
+      const result = {
+        dirSegment,
+        loadingRelPath: loadingRelPath.split(path.sep).join('/'),
+        fullPath,
+      };
+
+      if (!isDev) {
+        loadingFileCache.set(cacheKey, result);
+      }
+      return result;
+    }
+  }
+
+  if (!isDev) {
+    loadingFileCache.set(cacheKey, null);
+  }
+  return null;
+}
+
 function clearCascadingCaches() {
   middlewareFileCache.clear();
   layoutFileCache.clear();
+  errorFileCache.clear();
+  loadingFileCache.clear();
 }
 
 module.exports = {
@@ -374,5 +484,7 @@ module.exports = {
   findCascadingLayouts,
   executeCascadingLayoutLoads,
   applyCascadingLayouts,
+  findNearestErrorBoundary,
+  findNearestLoadingTemplate,
   clearCascadingCaches,
 };