@bouygues-telecom/staticjs 0.1.11 → 0.1.15

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

package/_build/server/utils/fileWatcher.js

@@ -0,0 +1,194 @@
+/**
+ * File watcher system for hot reloading
+ * Watches source files and triggers WebSocket broadcasts on changes
+ */
+import chokidar from 'chokidar';
+import path from 'path';
+import { broadcastReload } from './websocket.js';
+import { isDevelopment } from '../config/index.js';
+import { invalidateRuntimeCache } from '../middleware/runtime.js';
+let watcher = null;
+let debounceTimer = null;
+const DEBOUNCE_DELAY = 300; // 300ms debounce
+/**
+ * Determine reload type based on file extension
+ */
+const getReloadType = (filePath) => {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case '.css':
+        case '.scss':
+        case '.sass':
+        case '.less':
+            return 'style';
+        case '.tsx':
+        case '.jsx':
+        case '.ts':
+        case '.js':
+            return 'page';
+        case '.json':
+        case '.config.js':
+        case '.config.ts':
+            return 'full';
+        case '.png':
+        case '.jpg':
+        case '.jpeg':
+        case '.gif':
+        case '.svg':
+        case '.ico':
+        case '.woff':
+        case '.woff2':
+        case '.ttf':
+        case '.eot':
+            return 'asset';
+        default:
+            return 'page';
+    }
+};
+/**
+ * Handle file change with debouncing
+ */
+const handleFileChange = (eventType, filePath) => {
+    // Clear existing timer
+    if (debounceTimer) {
+        clearTimeout(debounceTimer);
+    }
+    // Set new timer
+    debounceTimer = setTimeout(async () => {
+        const reloadType = getReloadType(filePath);
+        const relativePath = path.relative(process.cwd(), filePath);
+        // Invalidate runtime cache when source files change
+        if (relativePath.includes('src/') || relativePath.includes('src\\')) {
+            await invalidateRuntimeCache();
+        }
+        // Broadcast reload message to WebSocket clients
+        broadcastReload(reloadType, {
+            file: relativePath,
+            event: eventType,
+            timestamp: Date.now()
+        });
+        debounceTimer = null;
+    }, DEBOUNCE_DELAY);
+};
+/**
+ * Initialize file watcher
+ */
+export const initializeFileWatcher = () => {
+    if (!isDevelopment) {
+        // Skipping file watcher in production mode
+        return null;
+    }
+    try {
+        // Define paths to watch based on current working directory
+        const cwd = process.cwd();
+        const watchPaths = [
+            'src', // Source directory
+            'src/**/*', // All source files in current directory
+            'package.json', // Dependency changes
+            'tsconfig.json', // TypeScript configuration
+            'eslint.config.js' // ESLint configuration
+        ];
+        // If we're in the main project directory, also watch template directories
+        if (cwd.includes('static.js') && !cwd.includes('templates/')) {
+            watchPaths.push('templates/**/src/**/*', // Template source files
+            'templates/**/package.json', // Template dependencies
+            'templates/**/tsconfig.json' // Template TypeScript configs
+            );
+        }
+        // Create watcher with options
+        watcher = chokidar.watch(watchPaths, {
+            ignored: [
+                '**/node_modules/**',
+                '**/_build/**',
+                '**/node_modules/**',
+                '**/.git/**',
+                '**/coverage/**',
+                '**/*.log',
+                '**/.*'
+            ],
+            ignoreInitial: true,
+            persistent: true,
+            followSymlinks: true,
+            depth: 10, // Allow deep directory watching
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50
+            }
+        });
+        // Set up event handlers
+        watcher
+            .on('add', (filePath) => handleFileChange('add', filePath))
+            .on('change', (filePath) => handleFileChange('change', filePath))
+            .on('unlink', (filePath) => handleFileChange('unlink', filePath))
+            .on('addDir', (dirPath) => {
+            // Directory added (silent)
+        })
+            .on('unlinkDir', (dirPath) => {
+            // Directory removed, triggering full reload
+            // Trigger full reload when directories are removed
+            broadcastReload('full', {
+                directory: path.relative(process.cwd(), dirPath),
+                event: 'unlinkDir'
+            });
+        })
+            .on('error', (err) => {
+            console.error('[FileWatcher] Watcher error:', err);
+        })
+            .on('ready', () => {
+            const watched = watcher.getWatched();
+            const watchedPaths = Object.keys(watched);
+            // File watcher initialized
+        });
+        return watcher;
+    }
+    catch (error) {
+        console.error('[FileWatcher] Failed to initialize file watcher:', error);
+        return null;
+    }
+};
+/**
+ * Get current file watcher instance
+ */
+export const getFileWatcher = () => watcher;
+/**
+ * Get watched files count
+ */
+export const getWatchedFilesCount = () => {
+    if (!watcher)
+        return 0;
+    const watched = watcher.getWatched();
+    return Object.values(watched).reduce((total, files) => total + files.length, 0);
+};
+/**
+ * Close file watcher and cleanup
+ */
+export const closeFileWatcher = async () => {
+    if (!watcher) {
+        return;
+    }
+    return new Promise((resolve) => {
+        // Closing file watcher
+        // Clear debounce timer
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+        // Close watcher
+        watcher.close().then(() => {
+            // File watcher closed
+            watcher = null;
+            resolve();
+        }).catch((error) => {
+            console.error('[FileWatcher] Error closing file watcher:', error);
+            watcher = null;
+            resolve();
+        });
+    });
+};
+/**
+ * Manually trigger a reload (useful for testing)
+ */
+export const triggerReload = (type = 'page', data = {}) => {
+    // Manually triggering reload
+    broadcastReload(type, { ...data, manual: true });
+};

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

@@ -0,0 +1,18 @@
+/**
+ * Server startup and shutdown utilities
+ * Handles server initialization and graceful shutdown
+ */
+import { Server } from 'http';
+import { Express } from 'express';
+/**
+ * Start the server with proper error handling
+ */
+export declare const startServer: (app: Express, initializeViteServer?: (app: Express) => Promise<any>) => Promise<Server>;
+/**
+ * Graceful shutdown handling
+ */
+export declare const gracefulShutdown: (server: Server, signal: string) => Promise<void>;
+/**
+ * Setup process event handlers for graceful shutdown
+ */
+export declare const setupProcessHandlers: (server: Server) => void;

package/_build/server/utils/startup.js

@@ -0,0 +1,93 @@
+/**
+ * Server startup and shutdown utilities
+ * Handles server initialization and graceful shutdown
+ */
+import { CONFIG } from "../config/index.js";
+import { closeViteServer, getViteServer } from "./vite.js";
+import { closeWebSocketServer, getConnectedClientsCount } from "./websocket.js";
+import { closeFileWatcher, getWatchedFilesCount } from "./fileWatcher.js";
+/**
+ * Start the server with proper error handling
+ */
+export const startServer = async (app, initializeViteServer) => {
+    // Initialize Vite server first (if provided)
+    if (initializeViteServer) {
+        await initializeViteServer(app);
+    }
+    return app.listen(CONFIG.PORT, () => {
+        const viteServer = getViteServer();
+        const wsClients = getConnectedClientsCount();
+        const watchedFiles = getWatchedFilesCount();
+        console.log(`
+🚀 StaticJS Server Started
+=====================================
+Environment: ${CONFIG.NODE_ENV}
+Port: ${CONFIG.PORT}
+URL: http://localhost:${CONFIG.PORT}
+Health Check: http://localhost:${CONFIG.PORT}/health
+Pages API: http://localhost:${CONFIG.PORT}/api/pages
+${viteServer ? 'Vite JS Compilation: ✅ Enabled' : 'Vite JS Compilation: ❌ Disabled'}
+${CONFIG.WEBSOCKET_ENABLED ? `WebSocket Hot Reload: ✅ Enabled (${wsClients} clients)` : 'WebSocket Hot Reload: ❌ Disabled'}
+${CONFIG.FILE_WATCHING_ENABLED ? `File Watching: ✅ Enabled (${watchedFiles} files)` : 'File Watching: ❌ Disabled'}
+=====================================
+      `);
+    });
+};
+/**
+ * Graceful shutdown handling
+ */
+export const gracefulShutdown = async (server, signal) => {
+    console.log(`\n📡 Received ${signal}. Starting graceful shutdown...`);
+    try {
+        // Close file watcher first
+        if (CONFIG.FILE_WATCHING_ENABLED) {
+            console.log('🔍 Closing file watcher...');
+            await closeFileWatcher();
+        }
+        // Close WebSocket server
+        if (CONFIG.WEBSOCKET_ENABLED) {
+            console.log('🔌 Closing WebSocket server...');
+            await closeWebSocketServer();
+        }
+        // Close Vite server if it exists
+        console.log('⚡ Closing Vite server...');
+        await closeViteServer();
+        // Close HTTP server
+        console.log('🌐 Closing HTTP server...');
+        server.close((err) => {
+            if (err) {
+                console.error('❌ Error during server shutdown:', err);
+                process.exit(1);
+            }
+            console.log('✅ Server closed successfully');
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        console.error('❌ Error during graceful shutdown:', error);
+        process.exit(1);
+    }
+    // Force shutdown after 10 seconds
+    setTimeout(() => {
+        console.error('⚠️  Forced shutdown after timeout');
+        process.exit(1);
+    }, 10000);
+};
+/**
+ * Setup process event handlers for graceful shutdown
+ */
+export const setupProcessHandlers = (server) => {
+    // Handle shutdown signals
+    process.on('SIGTERM', () => gracefulShutdown(server, 'SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown(server, 'SIGINT'));
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (err) => {
+        console.error('💥 Uncaught Exception:', err);
+        gracefulShutdown(server, 'uncaughtException');
+    });
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('💥 Unhandled Rejection at:', promise, 'reason:', reason);
+        gracefulShutdown(server, 'unhandledRejection');
+    });
+};

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

@@ -0,0 +1,18 @@
+/**
+ * Vite server utilities
+ * Handles Vite server initialization and JavaScript serving for development mode
+ */
+import { ViteDevServer } from "vite";
+import { Express } from "express";
+/**
+ * Initialize Vite server for development mode
+ */
+export declare const initializeViteServer: (app: Express) => Promise<ViteDevServer | null>;
+/**
+ * Get the current Vite server instance
+ */
+export declare const getViteServer: () => ViteDevServer | null;
+/**
+ * Close the Vite server
+ */
+export declare const closeViteServer: () => Promise<void>;