@bouygues-telecom/staticjs 0.1.11 → 0.1.14

package/_build/server/middleware/errorHandling.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Error handling middleware configuration
+ * Handles 404 errors and global error handling
+ */
+import { Request, Response, NextFunction, Express } from "express";
+interface CustomError extends Error {
+    status?: number;
+    statusCode?: number;
+}
+/**
+ * 404 handler for unmatched routes
+ */
+export declare const notFoundHandler: (req: Request, res: Response) => void;
+/**
+ * Global error handling middleware
+ */
+export declare const globalErrorHandler: (err: CustomError, req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Apply error handling middleware to Express app
+ */
+export declare const applyErrorHandling: (app: Express) => void;
+export {};

package/_build/server/middleware/errorHandling.js

@@ -0,0 +1,48 @@
+/**
+ * Error handling middleware configuration
+ * Handles 404 errors and global error handling
+ */
+import { isDevelopment } from "../index.js";
+/**
+ * 404 handler for unmatched routes
+ */
+export const notFoundHandler = (req, res) => {
+    res.status(404).json({
+        success: false,
+        error: 'Not Found',
+        message: `Cannot ${req.method} ${req.url}`,
+        timestamp: new Date().toISOString(),
+    });
+};
+/**
+ * Global error handling middleware
+ */
+export const globalErrorHandler = (err, req, res, next) => {
+    const timestamp = new Date().toISOString();
+    const status = err.status || err.statusCode || 500;
+    // Log error details
+    console.error(`[${timestamp}] Error ${status}:`, {
+        message: err.message,
+        stack: isDevelopment ? err.stack : undefined,
+        url: req.url,
+        method: req.method,
+        ip: req.ip,
+    });
+    // Send error response
+    res.status(status).json({
+        success: false,
+        error: status === 500 ? 'Internal Server Error' : err.message,
+        message: isDevelopment ? err.message : 'An error occurred',
+        timestamp,
+        ...(isDevelopment && { stack: err.stack }),
+    });
+};
+/**
+ * Apply error handling middleware to Express app
+ */
+export const applyErrorHandling = (app) => {
+    // 404 handler for unmatched routes
+    app.use(notFoundHandler);
+    // Global error handling middleware
+    app.use(globalErrorHandler);
+};

package/_build/server/middleware/hotReload.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Hot reload middleware
+ * Handles client script injection and hot reload static file serving
+ */
+import { Request, Response, NextFunction, Express } from 'express';
+interface HotReloadStatus {
+    enabled: boolean;
+    scriptLoaded: boolean;
+    scriptSize: number;
+}
+/**
+ * Middleware to serve hot reload client script
+ */
+export declare const hotReloadStaticMiddleware: (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Middleware to inject hot reload client script into HTML responses
+ */
+export declare const hotReloadInjectionMiddleware: (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Apply hot reload middleware to Express app
+ */
+export declare const applyHotReload: (app: Express) => void;
+/**
+ * Clear cached hot reload script (useful for development)
+ */
+export declare const clearHotReloadCache: () => void;
+/**
+ * Get hot reload middleware status
+ */
+export declare const getHotReloadStatus: () => HotReloadStatus;
+export {};

package/_build/server/middleware/hotReload.js

@@ -0,0 +1,152 @@
+/**
+ * Hot reload middleware
+ * Handles client script injection and hot reload static file serving
+ */
+import fs from 'fs';
+import path from 'path';
+import { isDevelopment } from '../index.js';
+// Cache for rendered pages and module cache invalidation
+let hotReloadClientScript = null;
+/**
+ * Load and cache the hot reload client script
+ */
+const loadHotReloadScript = () => {
+    if (!hotReloadClientScript) {
+        try {
+            // Always resolve to the centralized server location
+            // Find the project root by looking for the lib/server directory structure
+            let projectRoot = process.cwd();
+            while (projectRoot !== path.dirname(projectRoot)) {
+                const libServerDir = path.join(projectRoot, 'lib/server');
+                const packageJson = path.join(projectRoot, 'package.json');
+                // Look for lib/server directory structure and package.json to ensure we're at the main project root
+                if (fs.existsSync(libServerDir) && fs.existsSync(packageJson)) {
+                    break;
+                }
+                projectRoot = path.dirname(projectRoot);
+            }
+            const scriptPath = path.join(projectRoot, 'lib/server/static/hot-reload-client.js');
+            if (fs.existsSync(scriptPath)) {
+                hotReloadClientScript = fs.readFileSync(scriptPath, 'utf8');
+                // Hot reload client script loaded
+            }
+            else {
+                throw new Error(`Script not found at ${scriptPath}`);
+            }
+        }
+        catch (error) {
+            console.error('[HotReload] Failed to load hot reload client script:', error);
+            hotReloadClientScript = `
+// Hot reload client script fallback
+console.log('[HotReload] Hot reload client script not found, using fallback');
+`;
+        }
+    }
+    return hotReloadClientScript;
+};
+/**
+ * Middleware to serve hot reload client script
+ */
+export const hotReloadStaticMiddleware = (req, res, next) => {
+    if (!isDevelopment) {
+        return next();
+    }
+    // Serve hot reload client script
+    if (req.path === '/hot-reload-client.js') {
+        const script = loadHotReloadScript();
+        res.setHeader('Content-Type', 'application/javascript');
+        res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+        res.setHeader('Pragma', 'no-cache');
+        res.setHeader('Expires', '0');
+        res.send(script);
+        return;
+    }
+    next();
+};
+/**
+ * Middleware to inject hot reload client script into HTML responses
+ */
+export const hotReloadInjectionMiddleware = (req, res, next) => {
+    if (!isDevelopment) {
+        return next();
+    }
+    // Only inject into HTML responses
+    const originalSend = res.send;
+    res.send = function (body) {
+        // Check if this is an HTML response
+        const contentType = res.getHeader('Content-Type') || '';
+        const isHtml = contentType.toString().includes('text/html') ||
+            (typeof body === 'string' && (body.trim().startsWith('<!DOCTYPE html>') ||
+                body.includes('<div') ||
+                body.includes('<script')));
+        if (isHtml && typeof body === 'string') {
+            // Inject hot reload script
+            const hotReloadScript = `
+    <!-- Hot Reload Client Script (Development Only) -->
+    <script src="/hot-reload-client.js"></script>`;
+            // Try different injection strategies
+            let injected = false;
+            // Strategy 1: Before closing body tag
+            const bodyCloseIndex = body.lastIndexOf('</body>');
+            if (bodyCloseIndex !== -1) {
+                body = body.slice(0, bodyCloseIndex) + hotReloadScript + '\n' + body.slice(bodyCloseIndex);
+                injected = true;
+            }
+            // Strategy 2: Before closing html tag
+            if (!injected) {
+                const htmlCloseIndex = body.lastIndexOf('</html>');
+                if (htmlCloseIndex !== -1) {
+                    body = body.slice(0, htmlCloseIndex) + hotReloadScript + '\n' + body.slice(htmlCloseIndex);
+                    injected = true;
+                }
+            }
+            // Strategy 3: Before the last closing div (for React fragments)
+            if (!injected) {
+                const lastDivIndex = body.lastIndexOf('</div>');
+                if (lastDivIndex !== -1) {
+                    body = body.slice(0, lastDivIndex + 6) + hotReloadScript + body.slice(lastDivIndex + 6);
+                    injected = true;
+                }
+            }
+            // Strategy 4: Append to end as fallback
+            if (!injected) {
+                body += hotReloadScript;
+            }
+            // Hot reload script injected
+        }
+        // Call original send method
+        return originalSend.call(this, body);
+    };
+    next();
+};
+/**
+ * Apply hot reload middleware to Express app
+ */
+export const applyHotReload = (app) => {
+    if (!isDevelopment) {
+        // Skipping hot reload middleware in production mode
+        return;
+    }
+    // Applying hot reload middleware
+    // Apply static file serving middleware first
+    app.use(hotReloadStaticMiddleware);
+    // Apply injection middleware
+    app.use(hotReloadInjectionMiddleware);
+};
+/**
+ * Clear cached hot reload script (useful for development)
+ */
+export const clearHotReloadCache = () => {
+    hotReloadClientScript = null;
+    // Hot reload script cache cleared
+};
+/**
+ * Get hot reload middleware status
+ */
+export const getHotReloadStatus = () => {
+    return {
+        enabled: isDevelopment,
+        scriptLoaded: hotReloadClientScript !== null,
+        scriptSize: hotReloadClientScript ? hotReloadClientScript.length : 0
+    };
+};

package/_build/server/middleware/logging.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Logging middleware configuration
+ * Handles request logging with timestamps and details
+ */
+import { Request, Response, NextFunction, Express } from "express";
+/**
+ * Request logging middleware with timestamps and details
+ */
+export declare const loggingMiddleware: (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Apply logging middleware to Express app
+ */
+export declare const applyLogging: (app: Express) => void;

package/_build/server/middleware/logging.js

@@ -0,0 +1,23 @@
+/**
+ * Logging middleware configuration
+ * Handles request logging with timestamps and details
+ */
+/**
+ * Request logging middleware with timestamps and details
+ */
+export const loggingMiddleware = (req, res, next) => {
+    const timestamp = new Date().toISOString();
+    // Log response time
+    const startTime = Date.now();
+    res.on('finish', () => {
+        const duration = Date.now() - startTime;
+        console.log(`[${timestamp}] ${req.method} ${req.url} - ${res.statusCode} - ${duration}ms`);
+    });
+    next();
+};
+/**
+ * Apply logging middleware to Express app
+ */
+export const applyLogging = (app) => {
+    app.use(loggingMiddleware);
+};

package/_build/server/middleware/parsing.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Request parsing middleware configuration
+ * Handles JSON and URL-encoded body parsing
+ */
+import { Express } from "express";
+/**
+ * Apply parsing middleware to Express app
+ */
+export declare const applyParsing: (app: Express) => void;

package/_build/server/middleware/parsing.js

@@ -0,0 +1,21 @@
+/**
+ * Request parsing middleware configuration
+ * Handles JSON and URL-encoded body parsing
+ */
+import express from "express";
+import { CONFIG } from "../config/index.js";
+/**
+ * Apply parsing middleware to Express app
+ */
+export const applyParsing = (app) => {
+    // JSON body parser with size limit
+    app.use(express.json({
+        limit: CONFIG.BODY_SIZE_LIMIT,
+        type: 'application/json',
+    }));
+    // URL-encoded body parser with size limit
+    app.use(express.urlencoded({
+        extended: true,
+        limit: CONFIG.BODY_SIZE_LIMIT,
+    }));
+};

package/_build/server/middleware/performance.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Performance middleware configuration
+ * Handles compression, timeouts, and other performance-related middleware
+ */
+import { Request, Response, NextFunction, Express } from "express";
+/**
+ * Request timeout middleware
+ */
+export declare const timeoutMiddleware: (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Apply performance middleware to Express app
+ */
+export declare const applyPerformance: (app: Express) => void;

package/_build/server/middleware/performance.js

@@ -0,0 +1,26 @@
+/**
+ * Performance middleware configuration
+ * Handles compression, timeouts, and other performance-related middleware
+ */
+import compression from "compression";
+import { CONFIG } from "../config/index.js";
+/**
+ * Request timeout middleware
+ */
+export const timeoutMiddleware = (req, res, next) => {
+    req.setTimeout(CONFIG.REQUEST_TIMEOUT, () => {
+        const err = new Error('Request timeout');
+        err.status = 408;
+        next(err);
+    });
+    next();
+};
+/**
+ * Apply performance middleware to Express app
+ */
+export const applyPerformance = (app) => {
+    // Compression middleware for response optimization
+    app.use(compression());
+    // Request timeout middleware
+    app.use(timeoutMiddleware);
+};

package/_build/server/middleware/rateLimiting.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Rate limiting middleware configuration
+ * Handles general and specific rate limiting for different endpoints
+ */
+import { Express } from "express";
+/**
+ * General rate limiting for all endpoints
+ */
+export declare const generalLimiter: import("express-rate-limit").RateLimitRequestHandler;
+/**
+ * Stricter rate limiting for revalidate endpoint
+ */
+export declare const revalidateLimiter: import("express-rate-limit").RateLimitRequestHandler;
+/**
+ * Apply rate limiting middleware to Express app
+ */
+export declare const applyRateLimiting: (app: Express) => void;

package/_build/server/middleware/rateLimiting.js

@@ -0,0 +1,38 @@
+/**
+ * Rate limiting middleware configuration
+ * Handles general and specific rate limiting for different endpoints
+ */
+import rateLimit from "express-rate-limit";
+import { CONFIG } from "../config/index.js";
+/**
+ * General rate limiting for all endpoints
+ */
+export const generalLimiter = rateLimit({
+    windowMs: CONFIG.RATE_LIMIT_WINDOW,
+    max: CONFIG.RATE_LIMIT_MAX,
+    message: {
+        error: 'Too many requests from this IP, please try again later.',
+        retryAfter: Math.ceil(CONFIG.RATE_LIMIT_WINDOW / 1000),
+    },
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+/**
+ * Stricter rate limiting for revalidate endpoint
+ */
+export const revalidateLimiter = rateLimit({
+    windowMs: CONFIG.RATE_LIMIT_WINDOW,
+    max: CONFIG.REVALIDATE_RATE_LIMIT_MAX,
+    message: {
+        error: 'Too many revalidate requests, please try again later.',
+        retryAfter: Math.ceil(CONFIG.RATE_LIMIT_WINDOW / 1000),
+    },
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+/**
+ * Apply rate limiting middleware to Express app
+ */
+export const applyRateLimiting = (app) => {
+    app.use(generalLimiter);
+};

package/_build/server/middleware/runtime.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Runtime rendering middleware configuration
+ * Handles development mode runtime page rendering and JavaScript serving
+ */
+import { Request, Response, NextFunction, Express } from "express";
+import { ViteDevServer } from "vite";
+/**
+ * Clear all caches when files change
+ */
+export declare const invalidateRuntimeCache: () => Promise<void>;
+/**
+ * Runtime page rendering middleware for development mode
+ * Uses renderPageRuntime which handles all page resolution and dynamic routing
+ */
+export declare const runtimeRenderingMiddleware: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/**
+ * Register JavaScript serving middleware for each page
+ */
+export declare const registerJavaScriptMiddleware: (app: Express, viteServer: ViteDevServer) => void;
+/**
+ * Apply runtime middleware to Express app (development mode only)
+ */
+export declare const applyRuntime: (app: Express) => void;

package/_build/server/middleware/runtime.js

@@ -0,0 +1,186 @@
+/**
+ * Runtime rendering middleware configuration
+ * Handles development mode runtime page rendering and JavaScript serving
+ */
+import { renderPageRuntime } from "../../helpers/renderPageRuntime.js";
+import { isDevelopment } from "../index.js";
+import { CONFIG } from "../config/index.js";
+import fs from "fs";
+// Cache for rendered pages and module cache invalidation
+let pageCache = new Map();
+let lastCacheInvalidation = Date.now();
+/**
+ * Clear all caches when files change
+ */
+export const invalidateRuntimeCache = async () => {
+    try {
+        // Cache invalidation (silent)
+        pageCache.clear();
+        lastCacheInvalidation = Date.now();
+        // Import Vite server using ES modules
+        const { getViteServer } = await import('../utils/vite.js');
+        const viteServer = getViteServer();
+        if (viteServer) {
+            // Check if Vite has module graph and invalidate caches
+            if (viteServer.moduleGraph) {
+                viteServer.moduleGraph.invalidateAll();
+                // Clear Vite's transform cache if it exists
+                if (viteServer.transformCache && typeof viteServer.transformCache.clear === 'function') {
+                    viteServer.transformCache.clear();
+                }
+                // Clear Vite's internal caches if they exist
+                if (viteServer.ssrTransform && typeof viteServer.ssrTransform.clear === 'function') {
+                    viteServer.ssrTransform.clear();
+                }
+            }
+        }
+        // Force garbage collection to clear any remaining cached modules
+        if (global.gc) {
+            global.gc();
+        }
+        // Cache invalidation completed
+    }
+    catch (error) {
+        console.error('[Runtime] Error during cache invalidation:', error);
+    }
+};
+/**
+ * Runtime page rendering middleware for development mode
+ * Uses renderPageRuntime which handles all page resolution and dynamic routing
+ */
+export const runtimeRenderingMiddleware = async (req, res, next) => {
+    // Only handle GET requests for pages, but skip static assets and JS files
+    if (req.method === 'GET' && !req.path.match(/\.(js|css|ico|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot)$/)) {
+        /**
+         * Handle runtime rendering for development mode
+         * Leverages renderPageRuntime's built-in page resolution and parameter handling
+         */
+        try {
+            const cacheKey = req.path;
+            let htmlContent = null;
+            // Check if we have cached content and it's still valid
+            if (pageCache.has(cacheKey)) {
+                const cached = pageCache.get(cacheKey);
+                if (cached.timestamp > lastCacheInvalidation) {
+                    htmlContent = cached.content;
+                    // Serving cached content
+                }
+            }
+            // If no valid cached content, render fresh
+            if (!htmlContent) {
+                // Rendering fresh content
+                htmlContent = await renderPageRuntime(req.path);
+                if (htmlContent) {
+                    // Cache the rendered content
+                    pageCache.set(cacheKey, {
+                        content: htmlContent,
+                        timestamp: Date.now()
+                    });
+                }
+            }
+            if (htmlContent) {
+                res.setHeader('Content-Type', 'text/html');
+                res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+                res.setHeader('Pragma', 'no-cache');
+                res.setHeader('Expires', '0');
+                res.send(htmlContent);
+                return;
+            }
+            else {
+                // Continue to next middleware (static files or 404)
+                return next();
+            }
+        }
+        catch (error) {
+            console.error('[Runtime] Error rendering page:', error);
+            // Continue to next middleware on error
+            return next();
+        }
+    }
+    else {
+        next();
+    }
+};
+/**
+ * Register JavaScript serving middleware for each page
+ */
+export const registerJavaScriptMiddleware = (app, viteServer) => {
+    // Register specific routes for each page's JavaScript file
+    const pagesCache = JSON.parse(fs.readFileSync(`./${CONFIG.BUILD_DIR}/cache/pagesCache.json`, 'utf8'));
+    const excludedFiles = JSON.parse(fs.readFileSync(`./${CONFIG.BUILD_DIR}/cache/excludedFiles.json`, 'utf8'));
+    // Register a route for each page's JS file (skip dynamic routes)
+    Object.keys(pagesCache).forEach(pageName => {
+        if (!excludedFiles.includes(pageName) && !pageName.includes('[') && !pageName.includes(']')) {
+            const jsRoute = `/${pageName}.js`;
+            // Registering JS route for page
+            app.get(jsRoute, async (req, res) => {
+                try {
+                    // Check if the page file has "no scripts" directive
+                    const pageContent = fs.readFileSync(pagesCache[pageName], 'utf8');
+                    const firstLine = pageContent.split('\n')[0];
+                    if (firstLine.includes('no scripts')) {
+                        return res.status(404).json({
+                            success: false,
+                            error: 'Not Found',
+                            message: `JavaScript disabled for ${pageName}`,
+                        });
+                    }
+                    // Check file modification time and invalidate cache if needed
+                    const stats = fs.statSync(pagesCache[pageName]);
+                    const fileModTime = stats.mtime.getTime();
+                    if (fileModTime > lastCacheInvalidation && viteServer.moduleGraph) {
+                        const moduleId = pagesCache[pageName];
+                        const module = viteServer.moduleGraph.getModuleById(moduleId);
+                        if (module) {
+                            viteServer.moduleGraph.invalidateModule(module);
+                        }
+                    }
+                    // Transform the page file using Vite
+                    const transformStartTime = Date.now();
+                    const result = await viteServer.transformRequest(`${pagesCache[pageName]}?t=${transformStartTime}`, {
+                        ssr: false
+                    });
+                    if (result && result.code) {
+                        // Create a hash of the code for cache busting
+                        const crypto = await import('crypto');
+                        const codeHash = crypto.createHash('md5').update(result.code).digest('hex').slice(0, 8);
+                        res.setHeader('Content-Type', 'application/javascript');
+                        res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+                        res.setHeader('Pragma', 'no-cache');
+                        res.setHeader('Expires', '0');
+                        res.setHeader('X-Timestamp', Date.now().toString());
+                        res.setHeader('X-Code-Hash', codeHash);
+                        res.setHeader('X-File-Modified', fileModTime.toString());
+                        return res.send(result.code);
+                    }
+                    else {
+                        return res.status(404).json({
+                            success: false,
+                            error: 'Not Found',
+                            message: `No JavaScript generated for ${pageName}`,
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error(`Error compiling JavaScript for ${pageName}:`, error);
+                    return res.status(500).json({
+                        success: false,
+                        error: 'Internal Server Error',
+                        message: `Failed to compile JavaScript for ${pageName}`,
+                    });
+                }
+            });
+        }
+        else if (pageName.includes('[') || pageName.includes(']')) {
+            // Dynamic routes are handled differently - could add logging here if needed
+        }
+    });
+};
+/**
+ * Apply runtime middleware to Express app (development mode only)
+ */
+export const applyRuntime = (app) => {
+    if (isDevelopment) {
+        app.use(runtimeRenderingMiddleware);
+    }
+};

package/_build/server/middleware/security.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Security middleware configuration
+ * Handles helmet, CORS, and other security-related middleware
+ */
+import cors from "cors";
+import { Express } from "express";
+/**
+ * Security headers middleware using helmet
+ * Configures appropriate security headers for the application
+ */
+export declare const securityMiddleware: (req: import("http").IncomingMessage, res: import("http").ServerResponse, next: (err?: unknown) => void) => void;
+/**
+ * CORS configuration for development
+ * Allows cross-origin requests in development mode
+ */
+export declare const corsMiddleware: (req: cors.CorsRequest, res: {
+    statusCode?: number | undefined;
+    setHeader(key: string, value: string): any;
+    end(): any;
+}, next: (err?: any) => any) => void;
+/**
+ * Apply security middleware to Express app
+ */
+export declare const applySecurity: (app: Express) => void;