webspresso 0.0.0

package/src/helpers.js

@@ -0,0 +1,275 @@
+/**
+ * Webspresso Template Helpers
+ * Laravel-ish utilities for Nunjucks templates
+ */
+
+const querystring = require('querystring');
+
+/**
+ * Create the fsy helper object bound to the current request context
+ * @param {Object} ctx - Request context { req, res, baseUrl, locale }
+ * @returns {Object} fsy helper object
+ */
+function createHelpers(ctx) {
+  const { req, res, baseUrl = process.env.BASE_URL || 'http://localhost:3000' } = ctx;
+
+  return {
+    /**
+     * Build a URL path with optional query parameters
+     * @param {string} path - URL path
+     * @param {Object} query - Query parameters
+     * @returns {string}
+     */
+    url(path, query = null) {
+      let url = path.startsWith('/') ? path : `/${path}`;
+      if (query && Object.keys(query).length > 0) {
+        url += '?' + querystring.stringify(query);
+      }
+      return url;
+    },
+
+    /**
+     * Build a route path by replacing pattern params
+     * @param {string} pattern - Route pattern like /tools/:slug
+     * @param {Object} params - Parameters to replace
+     * @returns {string}
+     */
+    route(pattern, params = {}) {
+      let result = pattern;
+      for (const [key, value] of Object.entries(params)) {
+        result = result.replace(`:${key}`, encodeURIComponent(value));
+        result = result.replace(`[${key}]`, encodeURIComponent(value));
+      }
+      return result;
+    },
+
+    /**
+     * Build a full URL including the base URL
+     * @param {string} path - URL path
+     * @param {Object} query - Query parameters
+     * @returns {string}
+     */
+    fullUrl(path, query = null) {
+      const base = baseUrl.replace(/\/$/, '');
+      return base + this.url(path, query);
+    },
+
+    /**
+     * Get a query parameter from the request
+     * @param {string} name - Parameter name
+     * @param {*} def - Default value
+     * @returns {*}
+     */
+    q(name, def = null) {
+      return req.query[name] !== undefined ? req.query[name] : def;
+    },
+
+    /**
+     * Get a route parameter from the request
+     * @param {string} name - Parameter name
+     * @param {*} def - Default value
+     * @returns {*}
+     */
+    param(name, def = null) {
+      return req.params[name] !== undefined ? req.params[name] : def;
+    },
+
+    /**
+     * Get a header from the request
+     * @param {string} name - Header name
+     * @param {*} def - Default value
+     * @returns {*}
+     */
+    hdr(name, def = null) {
+      return req.get(name) || def;
+    },
+
+    /**
+     * Check if running in development mode
+     * @returns {boolean}
+     */
+    isDev() {
+      return process.env.NODE_ENV !== 'production';
+    },
+
+    /**
+     * Check if running in production mode
+     * @returns {boolean}
+     */
+    isProd() {
+      return process.env.NODE_ENV === 'production';
+    },
+
+    /**
+     * Convert a string to URL-friendly slug
+     * @param {string} s - Input string
+     * @returns {string}
+     */
+    slugify(s) {
+      if (!s) return '';
+      return s
+        .toString()
+        .toLowerCase()
+        .trim()
+        .replace(/[\s_]+/g, '-')
+        .replace(/[^\w\-]+/g, '')
+        .replace(/\-\-+/g, '-')
+        .replace(/^-+/, '')
+        .replace(/-+$/, '');
+    },
+
+    /**
+     * Truncate a string to n characters
+     * @param {string} s - Input string
+     * @param {number} n - Max length
+     * @param {string} suffix - Suffix to append if truncated
+     * @returns {string}
+     */
+    truncate(s, n, suffix = '...') {
+      if (!s) return '';
+      if (s.length <= n) return s;
+      return s.substring(0, n - suffix.length) + suffix;
+    },
+
+    /**
+     * Format bytes to human-readable string
+     * @param {number} bytes - Number of bytes
+     * @returns {string}
+     */
+    prettyBytes(bytes) {
+      if (bytes === 0) return '0 B';
+      const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+      const i = Math.floor(Math.log(bytes) / Math.log(1024));
+      const value = bytes / Math.pow(1024, i);
+      return `${value.toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+    },
+
+    /**
+     * Format milliseconds to human-readable string
+     * @param {number} ms - Milliseconds
+     * @returns {string}
+     */
+    prettyMs(ms) {
+      if (ms < 1000) return `${ms}ms`;
+      if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+      if (ms < 3600000) return `${(ms / 60000).toFixed(1)}m`;
+      return `${(ms / 3600000).toFixed(1)}h`;
+    },
+
+    /**
+     * Get the canonical URL for the current request
+     * @returns {string}
+     */
+    canonical() {
+      const base = baseUrl.replace(/\/$/, '');
+      return base + req.originalUrl.split('?')[0];
+    },
+
+    /**
+     * Generate a JSON-LD script tag (returns safe HTML)
+     * @param {Object} obj - JSON-LD object
+     * @returns {string}
+     */
+    jsonld(obj) {
+      const json = JSON.stringify(obj, null, 0)
+        .replace(/</g, '\\u003c')
+        .replace(/>/g, '\\u003e')
+        .replace(/&/g, '\\u0026');
+      return `<script type="application/ld+json">${json}</script>`;
+    },
+
+    /**
+     * Get the path to a static asset
+     * @param {string} path - Asset path
+     * @returns {string}
+     */
+    asset(path) {
+      const assetPath = path.startsWith('/') ? path : `/${path}`;
+      return assetPath;
+    },
+
+    /**
+     * Get the current locale
+     * @returns {string}
+     */
+    locale() {
+      return ctx.locale || process.env.DEFAULT_LOCALE || 'en';
+    },
+
+    /**
+     * Get the current path
+     * @returns {string}
+     */
+    path() {
+      return req.path;
+    },
+
+    /**
+     * Check if the current path matches a pattern
+     * @param {string} pattern - Path pattern (supports * wildcard)
+     * @returns {boolean}
+     */
+    isPath(pattern) {
+      const currentPath = req.path;
+      if (pattern === currentPath) return true;
+      if (pattern.includes('*')) {
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+        return regex.test(currentPath);
+      }
+      return false;
+    }
+  };
+}
+
+/**
+ * Pure utility functions (can be used without request context)
+ */
+const utils = {
+  slugify(s) {
+    if (!s) return '';
+    return s
+      .toString()
+      .toLowerCase()
+      .trim()
+      .replace(/[\s_]+/g, '-')
+      .replace(/[^\w\-]+/g, '')
+      .replace(/\-\-+/g, '-')
+      .replace(/^-+/, '')
+      .replace(/-+$/, '');
+  },
+
+  truncate(s, n, suffix = '...') {
+    if (!s) return '';
+    if (s.length <= n) return s;
+    return s.substring(0, n - suffix.length) + suffix;
+  },
+
+  prettyBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    const value = bytes / Math.pow(1024, i);
+    return `${value.toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+  },
+
+  prettyMs(ms) {
+    if (ms < 1000) return `${ms}ms`;
+    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+    if (ms < 3600000) return `${(ms / 60000).toFixed(1)}m`;
+    return `${(ms / 3600000).toFixed(1)}h`;
+  },
+
+  isDev() {
+    return process.env.NODE_ENV !== 'production';
+  },
+
+  isProd() {
+    return process.env.NODE_ENV === 'production';
+  }
+};
+
+module.exports = {
+  createHelpers,
+  utils
+};
+

package/src/server.js

@@ -0,0 +1,180 @@
+/**
+ * Webspresso Server
+ * Express + Nunjucks SSR server with file-based routing
+ */
+
+const express = require('express');
+const nunjucks = require('nunjucks');
+const path = require('path');
+const { mountPages } = require('./file-router');
+
+/**
+ * Create and configure the Express app
+ * @param {Object} options - Configuration options
+ * @param {string} options.pagesDir - Path to pages directory
+ * @param {string} options.viewsDir - Path to views directory  
+ * @param {string} options.publicDir - Path to public/static directory
+ * @param {boolean} options.logging - Enable request logging (default: isDev)
+ * @returns {Object} { app, nunjucksEnv }
+ */
+function createApp(options = {}) {
+  const NODE_ENV = process.env.NODE_ENV || 'development';
+  const isDev = NODE_ENV !== 'production';
+  const isTest = NODE_ENV === 'test';
+  
+  const {
+    pagesDir,
+    viewsDir,
+    publicDir,
+    logging = isDev && !isTest
+  } = options;
+  
+  if (!pagesDir) {
+    throw new Error('pagesDir is required');
+  }
+  
+  const app = express();
+  
+  // Trust proxy (for correct req.ip, req.protocol behind reverse proxy)
+  app.set('trust proxy', 1);
+  
+  // JSON body parser for API routes
+  app.use(express.json());
+  app.use(express.urlencoded({ extended: true }));
+  
+  // Static files (if publicDir provided)
+  if (publicDir) {
+    app.use(express.static(publicDir, {
+      maxAge: isDev ? 0 : '1d',
+      etag: true
+    }));
+  }
+  
+  // Configure Nunjucks
+  const templateDirs = viewsDir ? [pagesDir, viewsDir] : [pagesDir];
+  
+  const nunjucksEnv = nunjucks.configure(templateDirs, {
+    autoescape: true,
+    express: app,
+    watch: isDev && !isTest,
+    noCache: isDev || isTest
+  });
+  
+  // Add custom Nunjucks filters
+  nunjucksEnv.addFilter('json', (obj) => {
+    return JSON.stringify(obj, null, 2);
+  });
+  
+  nunjucksEnv.addFilter('date', (date, format = 'short') => {
+    const d = new Date(date);
+    if (format === 'short') {
+      return d.toLocaleDateString();
+    }
+    if (format === 'long') {
+      return d.toLocaleDateString(undefined, {
+        weekday: 'long',
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric'
+      });
+    }
+    if (format === 'iso') {
+      return d.toISOString();
+    }
+    return d.toString();
+  });
+  
+  // Request logging middleware
+  if (logging) {
+    app.use((req, res, next) => {
+      const start = Date.now();
+      res.on('finish', () => {
+        const duration = Date.now() - start;
+        console.log(`${req.method} ${req.path} ${res.statusCode} ${duration}ms`);
+      });
+      next();
+    });
+  }
+  
+  // Mount file-based routes
+  if (!isTest) {
+    console.log('\nMounting routes:');
+  }
+  mountPages(app, {
+    pagesDir,
+    nunjucks: nunjucksEnv,
+    silent: isTest
+  });
+  
+  // 404 handler
+  app.use((req, res) => {
+    res.status(404);
+    if (req.accepts('html')) {
+      res.send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>404 - Not Found</title>
+          <style>
+            body { font-family: system-ui, sans-serif; display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; background: #f5f5f5; }
+            .container { text-align: center; }
+            h1 { font-size: 4rem; margin: 0; color: #333; }
+            p { color: #666; margin: 1rem 0; }
+            a { color: #0066cc; text-decoration: none; }
+            a:hover { text-decoration: underline; }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <h1>404</h1>
+            <p>Page not found</p>
+            <a href="/">← Back to Home</a>
+          </div>
+        </body>
+        </html>
+      `);
+    } else {
+      res.json({ error: 'Not Found' });
+    }
+  });
+  
+  // Error handler
+  app.use((err, req, res, next) => {
+    console.error('Server error:', err);
+    res.status(500);
+    if (req.accepts('html')) {
+      res.send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>500 - Server Error</title>
+          <style>
+            body { font-family: system-ui, sans-serif; display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; background: #f5f5f5; }
+            .container { text-align: center; }
+            h1 { font-size: 4rem; margin: 0; color: #333; }
+            p { color: #666; margin: 1rem 0; }
+            pre { background: #fff; padding: 1rem; border-radius: 4px; text-align: left; overflow: auto; max-width: 600px; }
+            a { color: #0066cc; text-decoration: none; }
+            a:hover { text-decoration: underline; }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <h1>500</h1>
+            <p>Internal Server Error</p>
+            ${isDev ? `<pre>${err.stack || err.message}</pre>` : ''}
+            <a href="/">← Back to Home</a>
+          </div>
+        </body>
+        </html>
+      `);
+    } else {
+      res.json({ error: 'Internal Server Error' });
+    }
+  });
+  
+  return { app, nunjucksEnv };
+}
+
+// Export for use as library
+module.exports = { createApp };