@bouygues-telecom/staticjs 0.1.11 → 1.0.0

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;

package/_build/server/middleware/security.js

@@ -0,0 +1,39 @@
+/**
+ * Security middleware configuration
+ * Handles helmet, CORS, and other security-related middleware
+ */
+import helmet from "helmet";
+import cors from "cors";
+import { isDevelopment } from "../index.js";
+/**
+ * Security headers middleware using helmet
+ * Configures appropriate security headers for the application
+ */
+export const securityMiddleware = helmet({
+    contentSecurityPolicy: {
+        directives: {
+            defaultSrc: ["'self'"],
+            styleSrc: ["'self'", "'unsafe-inline'"],
+            scriptSrc: ["'self'"],
+            imgSrc: ["'self'", "data:", "https:"],
+        },
+    },
+    crossOriginEmbedderPolicy: false, // Allow embedding for development
+});
+/**
+ * CORS configuration for development
+ * Allows cross-origin requests in development mode
+ */
+export const corsMiddleware = cors({
+    origin: true,
+    credentials: true,
+});
+/**
+ * Apply security middleware to Express app
+ */
+export const applySecurity = (app) => {
+    app.use(securityMiddleware);
+    if (isDevelopment) {
+        app.use(corsMiddleware);
+    }
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Static file serving middleware configuration
+ * Handles static file serving with proper cache headers
+ */
+import { Express } from "express";
+/**
+ * Apply static file serving middleware to Express app
+ */
+export declare const applyStatic: (app: Express) => void;

package/_build/server/middleware/static.js

@@ -0,0 +1,63 @@
+/**
+ * Static file serving middleware configuration
+ * Handles static file serving with proper cache headers
+ */
+import express from "express";
+import { extname } from "path";
+import { CONFIG, isDevelopment } from "../config/index.js";
+/**
+ * Apply static file serving middleware to Express app
+ */
+export const applyStatic = (app) => {
+    /**
+     * Enhanced static file serving with proper cache headers
+     * In development mode, exclude JavaScript files so they can be handled by Vite
+     */
+    app.use((req, res, next) => {
+        // In development mode, skip JavaScript files - let Vite handle them
+        if (isDevelopment && req.path.endsWith('.js')) {
+            console.log(`[DIAGNOSTIC] Skipping static middleware for JS file in development: ${req.path}`);
+            return next();
+        }
+        // Use express.static for non-JS files or in production
+        express.static(CONFIG.BUILD_DIR, {
+            maxAge: CONFIG.CACHE_MAX_AGE * 1000, // Convert to milliseconds
+            etag: true,
+            lastModified: true,
+            setHeaders: (res, path) => {
+                // Set cache headers based on file type
+                const ext = extname(path).toLowerCase();
+                // DIAGNOSTIC: Log static file serving
+                if (ext === '.js') {
+                    console.log(`[DIAGNOSTIC] Static middleware serving JS file: ${path}`);
+                    console.log(`[DIAGNOSTIC] Cache max age: ${CONFIG.CACHE_MAX_AGE}`);
+                    console.log(`[DIAGNOSTIC] Is development: ${isDevelopment}`);
+                }
+                if (['.js', '.css', '.woff', '.woff2', '.ttf', '.eot'].includes(ext)) {
+                    if (ext === '.js' && isDevelopment) {
+                        // Don't cache JavaScript files in development to prevent stale code
+                        const cacheControl = 'no-cache, no-store, must-revalidate';
+                        res.setHeader('Cache-Control', cacheControl);
+                        res.setHeader('Pragma', 'no-cache');
+                        res.setHeader('Expires', '0');
+                        console.log(`[DIAGNOSTIC] Setting no-cache for JS in development: ${cacheControl}`);
+                    }
+                    else {
+                        // Cache static assets for longer in production
+                        const cacheControl = `public, max-age=${CONFIG.CACHE_MAX_AGE}`;
+                        res.setHeader('Cache-Control', cacheControl);
+                        if (ext === '.js') {
+                            console.log(`[DIAGNOSTIC] Setting Cache-Control for JS: ${cacheControl}`);
+                        }
+                    }
+                }
+                else if (['.html', '.htm'].includes(ext)) {
+                    // Don't cache HTML files in development
+                    res.setHeader('Cache-Control', isDevelopment ? 'no-cache' : `public, max-age=${CONFIG.CACHE_MAX_AGE / 24}`);
+                }
+                // Security headers for static files
+                res.setHeader('X-Content-Type-Options', 'nosniff');
+            },
+        })(req, res, next);
+    });
+};

package/_build/server/routes/api.d.ts

@@ -0,0 +1,23 @@
+/**
+ * API route handlers
+ * Handles health check, pages listing, and revalidate endpoints
+ */
+import { Request, Response, Express } from "express";
+/**
+ * Health check endpoint
+ * Returns server status and basic information
+ */
+export declare const healthCheck: (req: Request, res: Response) => void;
+/**
+ * API endpoint to list available pages
+ * In development mode, uses readPages helper; in production, scans static directory
+ */
+export declare const listPages: (req: Request, res: Response) => Promise<void>;
+/**
+ * Revalidate endpoint with enhanced error handling and rate limiting
+ */
+export declare const revalidateEndpoint: (req: Request, res: Response) => Promise<void>;
+/**
+ * Register API routes with Express app
+ */
+export declare const registerApiRoutes: (app: Express) => void;

package/_build/server/routes/api.js

@@ -0,0 +1,124 @@
+/**
+ * API route handlers
+ * Handles health check, pages listing, and revalidate endpoints
+ */
+import { revalidate } from "../scripts/revalidate.js";
+import { getAvailablePagesRuntime } from "../../helpers/renderPageRuntime.js";
+import { readdir } from "fs/promises";
+import { extname, join } from "path";
+import { CONFIG, isDevelopment } from "../config/index.js";
+import { revalidateLimiter } from "../middleware/rateLimiting.js";
+/**
+ * Health check endpoint
+ * Returns server status and basic information
+ */
+export const healthCheck = (req, res) => {
+    const healthInfo = {
+        status: 'healthy',
+        timestamp: new Date().toISOString(),
+        uptime: process.uptime(),
+        environment: CONFIG.NODE_ENV,
+        version: process.version,
+        memory: process.memoryUsage(),
+    };
+    res.status(200).json(healthInfo);
+};
+/**
+ * API endpoint to list available pages
+ * In development mode, uses readPages helper; in production, scans static directory
+ */
+export const listPages = async (req, res) => {
+    try {
+        let pages;
+        if (isDevelopment) {
+            // Use runtime pages discovery in development
+            const runtimePages = getAvailablePagesRuntime();
+            pages = Object.keys(runtimePages).map(pageName => {
+                const filePath = runtimePages[pageName];
+                const isIndexFile = filePath.endsWith('/index.tsx');
+                return {
+                    name: isIndexFile ? `${pageName}/index.tsx` : `${pageName}.tsx`,
+                    path: pageName === 'index' ? '/' : `/${pageName}`,
+                    file: filePath,
+                };
+            });
+        }
+        else {
+            // Use static file scanning in production
+            pages = await getAvailablePages();
+        }
+        const response = {
+            success: true,
+            pages,
+            count: pages.length,
+            mode: isDevelopment ? 'development (runtime)' : 'production (static)',
+        };
+        res.status(200).json(response);
+    }
+    catch (error) {
+        console.error('Error listing pages:', error);
+        const errorResponse = {
+            success: false,
+            error: 'Failed to list available pages',
+            message: isDevelopment ? error.message : 'Internal server error',
+        };
+        res.status(500).json(errorResponse);
+    }
+};
+/**
+ * Revalidate endpoint with enhanced error handling and rate limiting
+ */
+export const revalidateEndpoint = async (req, res) => {
+    try {
+        await revalidate(req, res);
+    }
+    catch (error) {
+        console.error('Revalidate error:', error);
+        const errorResponse = {
+            success: false,
+            error: 'Revalidation failed',
+            message: isDevelopment ? error.message : 'Internal server error',
+        };
+        res.status(500).json(errorResponse);
+    }
+};
+/**
+ * Scans the static directory for available HTML pages
+ * @returns {Promise<Array>} Array of available page paths
+ */
+async function getAvailablePages() {
+    const pages = [];
+    try {
+        const scanDirectory = async (dir, basePath = '') => {
+            const items = await readdir(join(CONFIG.BUILD_DIR, dir), { withFileTypes: true });
+            for (const item of items) {
+                const itemPath = join(dir, item.name);
+                const urlPath = join(basePath, item.name);
+                if (item.isDirectory()) {
+                    await scanDirectory(itemPath, urlPath);
+                }
+                else if (item.isFile() && extname(item.name).toLowerCase() === '.html') {
+                    const pagePath = urlPath.replace(/\.html$/, '').replace(/\\/g, '/');
+                    pages.push({
+                        name: item.name,
+                        path: pagePath === 'index' ? '/' : `/${pagePath}`,
+                        file: itemPath.replace(/\\/g, '/'),
+                    });
+                }
+            }
+        };
+        await scanDirectory('');
+    }
+    catch (error) {
+        console.warn('Could not scan pages directory:', error.message);
+    }
+    return pages.sort((a, b) => a.path.localeCompare(b.path));
+}
+/**
+ * Register API routes with Express app
+ */
+export const registerApiRoutes = (app) => {
+    app.get('/health', healthCheck);
+    app.get('/api/pages', listPages);
+    app.post('/revalidate', revalidateLimiter, revalidateEndpoint);
+};

package/_build/server/scripts/revalidate.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response } from "express";
+export declare const revalidate: (req: Request, res: Response) => void;

package/{dist → _build/server}/scripts/revalidate.js

@@ -7,8 +7,8 @@ export const revalidate = (req, res) => {
     try {
         const paths = req?.body?.paths || [];
         const pathsArg = paths.length > 0 ? paths.join(" ") : "";
-        const cachePages = path.resolve(__dirname, "../helpers/cachePages.js");
-        const buildHtmlConfig = path.resolve(__dirname, "./build-html.js");
+        const cachePages = path.resolve(__dirname, "../../../helpers/cachePages.js");
+        const buildHtmlConfig = path.resolve(__dirname, "../../../scripts/build-html.js");
         const buildCommand = `NODE_TLS_REJECT_UNAUTHORIZED=0 node ${cachePages} ${pathsArg && `${pathsArg}`} && npx tsx ${buildHtmlConfig}`;
         exec(buildCommand, (error, stdout, stderr) => {
             if (error) {
@@ -20,7 +20,7 @@ export const revalidate = (req, res) => {
                 console.error(`stderr: ${stderr}`);
             }
         });
-        return res
+        res
             .status(200)
             .send(`Revalidation triggered, paths: ${paths.length > 0 ? paths.join(", ") : "all pages"} built!`);
     }

package/_build/server/utils/fileWatcher.d.ts

@@ -0,0 +1,27 @@
+/**
+ * File watcher system for hot reloading
+ * Watches source files and triggers WebSocket broadcasts on changes
+ */
+import { FSWatcher } from 'chokidar';
+type ReloadType = 'style' | 'page' | 'full' | 'asset';
+/**
+ * Initialize file watcher
+ */
+export declare const initializeFileWatcher: () => FSWatcher | null;
+/**
+ * Get current file watcher instance
+ */
+export declare const getFileWatcher: () => FSWatcher | null;
+/**
+ * Get watched files count
+ */
+export declare const getWatchedFilesCount: () => number;
+/**
+ * Close file watcher and cleanup
+ */
+export declare const closeFileWatcher: () => Promise<void>;
+/**
+ * Manually trigger a reload (useful for testing)
+ */
+export declare const triggerReload: (type?: ReloadType, data?: Record<string, any>) => void;
+export {};