webspresso 0.0.99 → 0.0.101

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/api/api-loader.js

@@ -82,7 +82,7 @@ function createApiHandler(descriptor, context) {
     options: appOptions = {},
   } = context;
 
-  const isDev = process.env.NODE_ENV === 'development';
+  const isDev = context.isDev !== undefined ? context.isDev : (appOptions.isDev !== undefined ? appOptions.isDev : process.env.NODE_ENV === 'development');
   let cachedMiddlewares = null;
   let cachedApiDef = null;
   let cachedHandlerFn = null;

package/src/app-context.js

@@ -3,23 +3,25 @@
  * @module src/app-context
  */
 
-/** @type {{ db: object|null, shutdownManager: object|null, serviceRegistry: object|null }} */
+/** @type {{ db: object|null, shutdownManager: object|null, serviceRegistry: object|null, events: object|null, mailer: object|null }} */
 let context = {
   db: null,
   shutdownManager: null,
   serviceRegistry: null,
+  events: null,
+  mailer: null,
 };
 
 /**
  * Merge into the current context (typically called once from createApp).
- * @param {{ db?: object|null, shutdownManager?: object|null, serviceRegistry?: object|null }} partial
+ * @param {{ db?: object|null, shutdownManager?: object|null, serviceRegistry?: object|null, events?: object|null, mailer?: object|null }} partial
  */
 function setAppContext(partial) {
   context = { ...context, ...partial };
 }
 
 /**
- * @returns {{ db: object|null, shutdownManager: object|null, serviceRegistry: object|null }}
+ * @returns {{ db: object|null, shutdownManager: object|null, serviceRegistry: object|null, events: object|null, mailer: object|null }}
  */
 function getAppContext() {
   return context;
@@ -77,15 +79,45 @@ function hasServiceRegistry() {
   return context.serviceRegistry != null;
 }
 
+/**
+ * Get the registered EventDispatcher instance
+ * @returns {object|null}
+ */
+function getEvents() {
+  return context.events;
+}
+
+/**
+ * Check if an EventDispatcher is registered
+ * @returns {boolean}
+ */
+function hasEvents() {
+  return context.events != null;
+}
+
 /**
  * Clear context (e.g. between tests).
  */
 function resetAppContext() {
-  context = { db: null, shutdownManager: null, serviceRegistry: null };
+  context = { db: null, shutdownManager: null, serviceRegistry: null, events: null, mailer: null };
+}
+
+/**
+ * @returns {object|null}
+ */
+function getMailer() {
+  return context.mailer;
 }
 
 /**
- * Express middleware: sets `req.db` and `req.service` from registered app context.
+ * @returns {boolean}
+ */
+function hasMailer() {
+  return context.mailer != null;
+}
+
+/**
+ * Express middleware: sets `req.db`, `req.service`, `req.events`, and `req.mailer` from registered app context.
  * File-based `pages/api/*` routes attach this automatically; use in `setupRoutes`
  * for manually registered handlers that need `req.db` and `req.service`.
  * @type {import('express').RequestHandler}
@@ -94,9 +126,15 @@ function attachDbMiddleware(req, res, next) {
   if (context.db != null) {
     req.db = context.db;
   }
+  if (context.events != null) {
+    req.events = context.events;
+  }
+  if (context.mailer != null) {
+    req.mailer = context.mailer;
+  }
   if (context.serviceRegistry != null) {
     req.service = (name, input, opts) =>
-      context.serviceRegistry.call(name, input, req.context || { req, res, db: context.db }, opts);
+      context.serviceRegistry.call(name, input, req.context || { req, res, db: context.db, events: context.events, mailer: context.mailer }, opts);
   }
   next();
 }
@@ -110,6 +148,10 @@ module.exports = {
   hasShutdownManager,
   getServiceRegistry,
   hasServiceRegistry,
+  getEvents,
+  hasEvents,
+  getMailer,
+  hasMailer,
   resetAppContext,
   attachDbMiddleware,
 };

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/dev-reload/index.js

@@ -475,12 +475,20 @@ function createDevReloadHub(config = {}) {
 
     const recursiveSuccess = addWatcher(absDir, true);
     if (!recursiveSuccess) {
+      const visited = new Set();
       function walkAndWatch(currentDir) {
+        try {
+          const real = fs.realpathSync(currentDir);
+          if (visited.has(real)) return;
+          visited.add(real);
+        } catch (_) {
+          return;
+        }
         addWatcher(currentDir, false);
         try {
           const entries = fs.readdirSync(currentDir, { withFileTypes: true });
           for (const entry of entries) {
-            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules' && !entry.isSymbolicLink()) {
               walkAndWatch(path.join(currentDir, entry.name));
             }
           }

package/src/discovery/scan-routes.js

@@ -62,7 +62,16 @@ function scanDirSafely(dirPath, baseDir = dirPath) {
  * @returns {Array<Object>} Discovered route descriptors
  */
 function scanRoutes(options = {}) {
-  const rootDir = options.rootDir || process.cwd();
+  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 (_) {}
+      return path.resolve(__dirname, '../..');
+    }
+    return process.cwd();
+  })();
   const descriptors = [];
 
   // Helper to resolve directory paths

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);
       }
     });