@bouygues-telecom/staticjs 0.1.11 → 1.0.0

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

package/_build/server/utils/vite.js

@@ -0,0 +1,61 @@
+/**
+ * Vite server utilities
+ * Handles Vite server initialization and JavaScript serving for development mode
+ */
+import { createServer as createViteServer } from "vite";
+import { isDevelopment } from "../config/index.js";
+import { registerJavaScriptMiddleware } from "../middleware/runtime.js";
+let viteServer = null;
+/**
+ * Initialize Vite server for development mode
+ */
+export const initializeViteServer = async (app) => {
+    if (isDevelopment) {
+        // Check if Vite server is already initialized
+        if (viteServer) {
+            // Vite server already initialized
+            return viteServer;
+        }
+        try {
+            // Initializing Vite server
+            // Create Vite server for development mode JS compilation
+            viteServer = await createViteServer({
+                server: {
+                    middlewareMode: true,
+                    hmr: {
+                        port: 24679 // Use different port to avoid conflicts
+                    }
+                },
+                appType: 'custom',
+                configFile: '../../lib/server/config/vite.config.ts'
+            });
+            // Vite server initialized
+            // Add Vite's middleware to handle dependency requests
+            app.use(viteServer.middlewares);
+            // Register JavaScript serving middleware after Vite server is ready
+            registerJavaScriptMiddleware(app, viteServer);
+        }
+        catch (error) {
+            console.error('❌ Failed to initialize Vite server:', error);
+        }
+    }
+    return viteServer;
+};
+/**
+ * Get the current Vite server instance
+ */
+export const getViteServer = () => viteServer;
+/**
+ * Close the Vite server
+ */
+export const closeViteServer = async () => {
+    if (viteServer) {
+        try {
+            await viteServer.close();
+            // Vite server closed
+        }
+        catch (error) {
+            console.error('❌ Error closing Vite server:', error);
+        }
+    }
+};

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

@@ -0,0 +1,26 @@
+/**
+ * WebSocket server utilities for hot reloading
+ * Handles WebSocket connections and broadcasting reload messages
+ */
+import { WebSocketServer } from 'ws';
+import { Server as HttpServer } from 'http';
+/**
+ * Initialize WebSocket server attached to HTTP server
+ */
+export declare const initializeWebSocketServer: (httpServer: HttpServer) => WebSocketServer | null;
+/**
+ * Broadcast reload message to all connected clients
+ */
+export declare const broadcastReload: (type?: string, data?: Record<string, any>) => void;
+/**
+ * Get current WebSocket server instance
+ */
+export declare const getWebSocketServer: () => WebSocketServer | null;
+/**
+ * Get number of connected clients
+ */
+export declare const getConnectedClientsCount: () => number;
+/**
+ * Close WebSocket server and cleanup
+ */
+export declare const closeWebSocketServer: () => Promise<void>;

package/_build/server/utils/websocket.js

@@ -0,0 +1,140 @@
+/**
+ * WebSocket server utilities for hot reloading
+ * Handles WebSocket connections and broadcasting reload messages
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+import { isDevelopment } from '../config/index.js';
+let wss = null;
+let clients = new Set();
+/**
+ * Initialize WebSocket server attached to HTTP server
+ */
+export const initializeWebSocketServer = (httpServer) => {
+    if (!isDevelopment) {
+        // Skipping WebSocket server in production mode
+        return null;
+    }
+    try {
+        // Create WebSocket server attached to HTTP server
+        wss = new WebSocketServer({
+            server: httpServer,
+            path: '/ws'
+        });
+        wss.on('connection', (ws, req) => {
+            // Client connected
+            clients.add(ws);
+            // Send welcome message
+            ws.send(JSON.stringify({
+                type: 'connected',
+                message: 'Hot reload client connected'
+            }));
+            // Handle client disconnect
+            ws.on('close', () => {
+                // Client disconnected
+                clients.delete(ws);
+            });
+            // Handle client errors
+            ws.on('error', (error) => {
+                console.error('[WebSocket] Client error:', error);
+                clients.delete(ws);
+            });
+            // Handle ping/pong for connection health
+            ws.on('pong', () => {
+                ws.isAlive = true;
+            });
+        });
+        // Setup ping interval to detect dead connections
+        const pingInterval = setInterval(() => {
+            if (wss && wss.clients) {
+                wss.clients.forEach((ws) => {
+                    if (ws.isAlive === false) {
+                        clients.delete(ws);
+                        return ws.terminate();
+                    }
+                    ws.isAlive = false;
+                    ws.ping();
+                });
+            }
+        }, 30000); // 30 seconds
+        wss.on('close', () => {
+            clearInterval(pingInterval);
+        });
+        // WebSocket server initialized
+        return wss;
+    }
+    catch (error) {
+        console.error('[WebSocket] Failed to initialize WebSocket server:', error);
+        return null;
+    }
+};
+/**
+ * Broadcast reload message to all connected clients
+ */
+export const broadcastReload = (type = 'page', data = {}) => {
+    if (!isDevelopment) {
+        return;
+    }
+    if (!wss) {
+        // WebSocket server not initialized
+        return;
+    }
+    const message = {
+        type: 'reload',
+        reloadType: type,
+        timestamp: Date.now(),
+        data
+    };
+    const messageString = JSON.stringify(message);
+    let sentCount = 0;
+    let deadConnections = 0;
+    clients.forEach((ws) => {
+        if (ws.readyState === WebSocket.OPEN) {
+            try {
+                ws.send(messageString);
+                sentCount++;
+            }
+            catch (error) {
+                console.error('[WebSocket] Error sending message to client:', error);
+                clients.delete(ws);
+                deadConnections++;
+            }
+        }
+        else {
+            clients.delete(ws);
+            deadConnections++;
+        }
+    });
+    // Reload broadcast completed (silent)
+};
+/**
+ * Get current WebSocket server instance
+ */
+export const getWebSocketServer = () => wss;
+/**
+ * Get number of connected clients
+ */
+export const getConnectedClientsCount = () => clients.size;
+/**
+ * Close WebSocket server and cleanup
+ */
+export const closeWebSocketServer = async () => {
+    if (!wss) {
+        return;
+    }
+    return new Promise((resolve) => {
+        // Closing WebSocket server
+        // Close all client connections
+        clients.forEach((ws) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.close(1000, 'Server shutting down');
+            }
+        });
+        clients.clear();
+        // Close the server
+        wss.close(() => {
+            // WebSocket server closed
+            wss = null;
+            resolve();
+        });
+    });
+};

package/package.json

@@ -1,43 +1,55 @@
 {
   "name": "@bouygues-telecom/staticjs",
-  "version": "0.1.11",
+  "version": "1.0.0",
   "type": "module",
+  "main": "./_build/server/index.js",
+  "exports": {
+    ".": "./_build/server/index.js",
+    "./server": "./_build/server/index.js",
+    "./config": "./_build/server/config/index.js",
+    "./helpers": "./_build/helpers/cachePages.js"
+  },
   "files": [
-    "dist",
+    "_build",
     "package.json",
     "README.md"
   ],
   "bin": {
-    "create-staticjs-app": "./dist/scripts/create-static-app.js",
-    "bt-staticjs": "./dist/scripts/cli.js",
-    "generate-test-multiapps": "./dist/scripts/generate-test-multiapps.js"
+    "create-staticjs-app": "./_build/scripts/create-static-app.js",
+    "bt-staticjs": "./_build/scripts/cli.js",
+    "static": "./_build/scripts/cli.js",
+    "generate-test-multiapps": "./_build/scripts/generate-test-multiapps.js"
   },
   "scripts": {
-    "prebuild": "tsc -p ./tsconfig.json",
-    "build": "cd templates/react && rimraf dist && rimraf cache && node ../../dist/helpers/cachePages.js && vite build --config ../../vite.config.js && tsx ../../dist/scripts/build-html.js",
-    "generate:test": "cd templates/react && node ../../scripts/generate-test-multiapps.js",
-    "start": "cd templates/react && npm start"
+    "build": "rm -rf _build && tsc && chmod +x _build/scripts/*.js",
+    "dev": "npm run build && cd ../templates/react && npm run dev"
   },
   "dependencies": {
-    "@types/node": "^20",
+    "chokidar": "^4.0.1",
     "cli-spinner": "^0.2.10",
     "commander": "^14.0.0",
+    "compression": "^1.7.5",
+    "cors": "^2.8.5",
+    "express": "^5.0.1",
+    "express-rate-limit": "^8.0.1",
     "giget": "^2.0.0",
+    "helmet": "^8.0.0",
     "nodemon": "^3.1.10",
     "path": "^0.12.7",
     "readline": "^1.3.0",
     "rimraf": "^6.0.1",
-    "tsx": "^4.19.4",
-    "typescript": "^5"
+    "ws": "^8.18.0"
   },
   "volta": {
     "node": "24.1.0"
   },
-  "workspaces": [
-    "templates/react"
-  ],
   "devDependencies": {
+    "@types/chokidar": "^2.1.7",
     "@types/cli-spinner": "^0.2.3",
-    "@types/express": "^5.0.3"
+    "@types/compression": "^1.8.1",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.3",
+    "@types/helmet": "^4.0.0",
+    "@types/ws": "^8.18.1"
   }
 }