# ๐Ÿš€ Veko.js An **ultra-modern** and **intelligent** web framework for Node.js with Express and EJS, designed for rapid and efficient development with **intelligent hot reload**, **beautiful logging**, **extensible plugin system**, and **revolutionary auto-updater**. # ๐Ÿš€ Veko.js v1.2.0 An **ultra-modern** and **intelligent** web framework for Node.js with Express and EJS, designed for rapid and efficient development with **intelligent hot reload**, **beautiful logging**, **extensible plugin system**, **advanced code verification**, and the **most advanced auto-updater** in the Node.js ecosystem. ## โœจ Features - ๐Ÿ”ฅ **Intelligent Hot Reload** - Selective reloading of modified routes - ๐ŸŽจ **Beautiful Logging** - Colorful logging system with icons and timestamps - โšก **Integrated WebSocket** - Real-time communication for development - ๐Ÿ“ **Auto-loading** - Routes, views, and middleware auto-configured - ๐Ÿ› ๏ธ **Development Mode** - Advanced file monitoring - ๐ŸŒ **Smart Prefetching** - Route caching and prefetching - ๐Ÿ”Œ **Plugin System** - Extensible architecture with hooks and complete API - ๐Ÿ›ฃ๏ธ **Dynamic Route Management** - Create/delete routes on-the-fly - ๐ŸŽจ **Advanced Layout System** - Powerful templating with sections and helpers - ๐Ÿ“ฆ **Auto Module Installation** - Automatic dependency management - ๐Ÿ”ฌ **Advanced Code Verification** - Comprehensive code quality analysis - ๐Ÿ“Š **HTML Reports** - Beautiful verification reports with interactive dashboard - ๐Ÿ”’ **Security Auditing** - Advanced security vulnerability detection - ๐Ÿงฎ **Complexity Analysis** - Cyclomatic complexity and performance metrics - ๐Ÿ”„ **Revolutionary Auto-Updater** - The most advanced auto-updater in Node.js ecosystem - ๐Ÿ›ก๏ธ **Security-First Updates** - Automatic critical security updates with rollback protection - ๐Ÿ’พ **Intelligent Backup System** - Smart backups with one-click rollback - ๐ŸŽฏ **Multi-Channel Updates** - Support for stable, beta, and alpha channels - ๐ŸŽจ **Interactive CLI** - Beautiful command-line interface with auto-completion ## ๐Ÿ“‹ Changelog ### ๐ŸŽ‰ Version 1.2.0 (Latest) - December 2024 #### ๐Ÿ†• Revolutionary Auto-Updater System - **๐Ÿ”„ Advanced Auto-Updater** - Automatic version checking with intelligent scheduling - Multi-channel support (stable, beta, alpha, custom registries) - Security-first approach with cryptographic validation - Interactive CLI with beautiful colored interface - Real-time notifications and progress indicators - Seamless integration with existing applications - **๐Ÿ”’ Security-First Architecture** - SHA512 integrity verification for all packages - Automatic security updates with priority handling - Rollback protection against failed updates - Vulnerability scanning before installation - Secure communication protocols - Audit trail for all operations - **๐Ÿ’พ Smart Backup & Rollback System** - Automatic backup before every update - Configurable backup retention (1-10 backups) - Instant rollback in case of failure - Backup size optimization and integrity verification - Selective file backup with smart exclusions - Emergency rollback functionality - **๐ŸŽจ Interactive CLI Experience** - Beautiful colored interface with emojis and animations - Auto-completion for all commands - Interactive configuration wizard - Real-time progress bars and status indicators - Comprehensive help system with examples - Menu-driven navigation - **๐Ÿ“Š Advanced Monitoring & Statistics** - Update history tracking with detailed logs - Performance metrics and success rates - Rollback statistics and failure analysis - Update channel analytics - System health monitoring - Historical trend analysis #### ๐Ÿ”„ Auto-Updater Quick Start ```bash # Installation globale recommandรฉe npm install -g veko # Commandes disponibles veko update # Lancer le gestionnaire de mises ร  jour interactif veko update check # Vรฉrifier les mises ร  jour veko update config # Configurer l'auto-updater veko update fix # Rรฉparer l'auto-updater en cas de problรจme # Alternative sans installation globale npx veko update # Utiliser veko update sans installation globale ``` #### ๐Ÿ”„ Auto-Updater Simplifiรฉ L'auto-updater de Veko a รฉtรฉ simplifiรฉ pour plus de stabilitรฉ et d'efficacitรฉ. Il se concentre maintenant sur les commandes essentielles et รฉvite les interfaces interactives qui pourraient interfรฉrer avec le fonctionnement de l'application. ```bash # Vรฉrifier les mises ร  jour veko update check # Installer une mise ร  jour veko update update # Afficher la configuration veko update config # Modifier un paramรจtre de configuration veko update config autoUpdate true # Afficher les statistiques veko update stats # Restaurer une version prรฉcรฉdente veko update rollback # Rรฉparer l'auto-updater veko update fix # Afficher l'aide et les commandes disponibles veko update help ``` #### ๐Ÿ”ง Auto-Updater Robuste L'auto-updater a รฉtรฉ conรงu pour รชtre stable et ne jamais interfรฉrer avec le fonctionnement de l'application principale. Il offre : - โœ… **Installation non-bloquante** - Aucun risque de ralentissement de votre application - โœ… **Mises ร  jour automatisรฉes** - Programmez des vรฉrifications rรฉguliรจres - โœ… **Gestion des erreurs avancรฉe** - Restauration automatique en cas d'รฉchec - โœ… **Systรจme de backup** - Avant toute mise ร  jour - โœ… **Configuration simple** - Via la ligne de commande #### ๐Ÿ”ง Auto-Updater Integration ```javascript const { App } = require('veko'); const app = new App({ // Auto-updater configuration optimisรฉe autoUpdater: { enabled: true, // Activer l'auto-updater checkOnStart: true, // Vรฉrifier au dรฉmarrage autoUpdate: false, // Mode manuel (recommandรฉ) updateChannel: 'stable', // stable | beta | alpha securityUpdates: true, // Auto-installer les mises ร  jour de sรฉcuritรฉ backupCount: 5, // Nombre de backups ร  conserver checkInterval: 3600000, // Vรฉrifier chaque heure (en millisecondes) rollbackOnFailure: true // Restauration automatique en cas d'รฉchec } }); app.listen(); ``` #### ๐ŸŒ RESTful Auto-Updater API Built-in API endpoints for remote management: ```javascript // Check for updates programmatically const updateInfo = await app.checkForUpdates(); console.log(updateInfo); // { hasUpdate: true, currentVersion: '1.0.0', latestVersion: '2.0.0' } // Perform update if (updateInfo.hasUpdate) { const success = await app.performUpdate(updateInfo); console.log('Update successful:', success); } // Rollback if needed await app.rollbackUpdate(); // Get auto-updater status const status = app.getAutoUpdaterInfo(); console.log(status); // { active: true, currentVersion: '2.0.0', config: {...}, stats: {...} } ``` #### ๐Ÿ›ก๏ธ RESTful Endpoints ```bash # Check for updates via HTTP GET http://localhost:3000/_veko/updates/check # Trigger update via HTTP POST http://localhost:3000/_veko/updates/perform # Get statistics via HTTP GET http://localhost:3000/_veko/updates/stats # Perform rollback via HTTP POST http://localhost:3000/_veko/updates/rollback ``` #### ๐ŸŽฏ Update Channels **Stable Channel (Production)** ```bash npx veko-update config # Select "Update Channel" -> "stable" ``` - โœ… Production-ready releases - โœ… Thoroughly tested and stable - โœ… Backward compatibility guaranteed - โœ… Recommended for production environments **Beta Channel (Testing)** ```bash npx veko-update config # Select "Update Channel" -> "beta" ``` - โœ… Pre-release versions with new features - โœ… Stability testing phase - โš ๏ธ May contain minor issues - ๐ŸŽฏ Perfect for testing environments **Alpha Channel (Development)** ```bash npx veko-update config # Select "Update Channel" -> "alpha" ``` - โœ… Cutting-edge features and improvements - โœ… Immediate access to latest developments - โš ๏ธ Experimental features included - ๐Ÿšง Development and testing use only #### ๐Ÿ“Š Statistics Dashboard ```bash npx veko-update stats ``` Comprehensive statistics including: - ๐Ÿ“ˆ Total updates performed - โœ… Success/failure rates - ๐Ÿ”„ Rollback history and frequency - ๐Ÿ“ข Update channel distribution - โšก Performance metrics and timing - ๐Ÿ”’ Security update history - ๐Ÿ“… Last check/update timestamps ### ๐Ÿ“œ Previous Versions #### Version 1.1.0 - Initial plugin system implementation - Basic layout system with EJS integration - Hot reload functionality with WebSocket - CLI commands (dev, setup, build, start) - Basic logging system with colors - Auto-loading for routes and middleware ## โœจ Features - ๐Ÿ”ฅ **Intelligent Hot Reload** - Selective reloading of modified routes - ๐ŸŽจ **Beautiful Logging** - Colorful logging system with icons and timestamps - โšก **Integrated WebSocket** - Real-time communication for development - ๐Ÿ“ **Auto-loading** - Routes, views, and middleware auto-configured - ๐Ÿ› ๏ธ **Development Mode** - Advanced file monitoring - ๐ŸŒ **Smart Prefetching** - Route caching and prefetching - ๐Ÿ”Œ **Plugin System** - Extensible architecture with hooks and complete API - ๐Ÿ›ฃ๏ธ **Dynamic Route Management** - Create/delete routes on-the-fly - ๐ŸŽจ **Advanced Layout System** - Powerful templating with sections and helpers - ๐Ÿ“ฆ **Auto Module Installation** - Automatic dependency management ## ๐Ÿš€ Installation ### Global Installation (CLI) ```bash npm install -g veko ``` ### Project Installation ```bash npm install veko ``` ## ๐Ÿ“ฆ Quick Start ### 1. Create a New Project ```bash # Create a new project veko setup my-app # With options veko setup --name my-blog --template blog --git # Available templates: default, api, blog, admin ``` ### 2. Basic Application ```javascript const { App } = require('veko'); const app = new App({ port: 3000, viewsDir: 'views', staticDir: 'public', routesDir: 'routes', layouts: { enabled: true, defaultLayout: 'main' }, plugins: { enabled: true, autoLoad: true, pluginsDir: 'plugins' } }); app.loadRoutes() // Automatically load all routes .listen(); ``` ### 3. Ultra-Modern Development Mode ```javascript const { startDev } = require('veko'); // Simple dev startup startDev({ port: 3000 }); ``` Or directly with the App class: ```javascript const { App } = require('veko'); const app = new App({ port: 3000, isDev: true, // Enable development mode wsPort: 3008, // WebSocket port for hot reload watchDirs: ['views', 'routes', 'public'], // Watched directories layouts: { enabled: true, defaultLayout: 'main' }, plugins: { enabled: true, autoLoad: true, pluginsDir: 'plugins' } }); app.loadRoutes().listen(); ``` ### 4. CLI Commands ```bash # Start development server veko dev # Start with custom port veko dev --port 8080 # Create new project veko setup my-project # Create API project veko setup --template api --name my-api # Create blog project veko setup --template blog --name my-blog # Create admin project veko setup --template admin --name admin-panel ``` ## ๐ŸŽจ Advanced Layout System Veko.js includes a powerful layout system that automatically wraps your views with layouts, providing sections, helpers, and dynamic content injection. ### Layout Configuration ```javascript const app = new App({ layouts: { enabled: true, // Enable layout system layoutsDir: 'views/layouts', // Layout directory defaultLayout: 'main', // Default layout name extension: '.ejs', // Layout file extension sections: ['head', 'header', 'content', 'footer', 'scripts'], cache: true // Cache layouts in production } }); ``` ### Creating Layouts **views/layouts/main.ejs:** ```html <%= meta.title || 'Veko.js App' %> <% if (meta.description) { %> <% } %> <% if (layout && layout.css) { %> <% layout.css.forEach(href => { %> <% }); %> <% } %> <% if (sections && sections.head) { %> <%- sections.head %> <% } %> <% if (sections && sections.header) { %>
<%- sections.header %>
<% } %>
<%- sections.content %>
<% if (layout && layout.js) { %> <% layout.js.forEach(src => { %> <% }); %> <% } %> <% if (sections && sections.scripts) { %> <%- sections.scripts %> <% } %> ``` ### Using Layouts in Views **views/home.ejs:** ```html <% layout.title('Home - My App') %> <% layout.meta('description', 'Welcome to my Veko.js application') %> <% layout.css('/css/home.css') %> <% layout.section('header', `

๐ŸŽ‰ Welcome to Veko.js

Ultra-modern Node.js framework

`) %>

๐Ÿš€ Fast

Optimized performance and ultra-fast loading times.

๐Ÿ’Ž Modern

Cutting-edge technologies and modern architecture.

๐ŸŽจ Flexible

Advanced layout system and reusable components.

<% layout.section('scripts', ` `) %> ``` ### Layout Helpers Available helpers in your views: ```javascript // Set page title <% layout.title('My Page Title') %> // Add meta tags <% layout.meta('description', 'Page description') %> <% layout.meta('keywords', 'veko, nodejs, framework') %> // Add CSS files <% layout.css('/css/custom.css') %> <% layout.css('https://cdn.example.com/lib.css') %> // Add JavaScript files <% layout.js('/js/custom.js') %> <% layout.js('https://cdn.example.com/lib.js') %> // Define sections <% layout.section('sectionName', 'content') %> <% layout.section('header', `

Custom Header

`) %> ``` ### Layout Management API ```javascript // Create a new layout app.createLayout('admin', customLayoutContent); // Delete a layout app.deleteLayout('admin'); // List all available layouts const layouts = app.listLayouts(); // Reload layouts in development mode app.reloadLayouts(); // Render with specific layout app.renderWithCustomLayout(res, 'view', 'admin', data); // Render without layout app.renderWithoutLayout(res, 'view', data); ``` ## ๐Ÿ”Œ Plugin System Veko.js includes a powerful and extensible plugin system that allows adding functionality without modifying the framework core. ### Plugin Configuration ```javascript const app = new App({ plugins: { enabled: true, // Enable plugin system autoLoad: true, // Automatic plugin loading pluginsDir: 'plugins' // Plugin directory } }); ``` ### Plugin Structure ```javascript // plugins/my-plugin.js module.exports = { name: 'my-plugin', version: '1.0.0', description: 'Description of my plugin', author: 'My Name', // Dependencies (other required plugins) dependencies: ['other-plugin'], // Default configuration defaultConfig: { enabled: true, option1: 'value' }, // Method called during loading async load(app, config, context) { // Your initialization code context.log('success', 'Plugin loaded!'); // Add a route context.addRoute('get', '/my-plugin', (req, res) => { res.json({ message: 'Hello from plugin!' }); }); // Add middleware context.addMiddleware((req, res, next) => { req.pluginData = { source: 'my-plugin' }; next(); }); // Add hooks context.hook('route:create', (method, path) => { context.log('info', `Route created: ${method} ${path}`); }); }, // Method called during unloading async unload(app, config) { console.log('Plugin unloaded'); }, // Activation/deactivation async activate(app, config) { console.log('Plugin activated'); }, async deactivate(app, config) { console.log('Plugin deactivated'); } }; ``` ### Plugin Context API Each plugin receives a rich context with numerous functionalities: ```javascript async load(app, config, context) { // === HOOKS === // Add a hook context.hook('hookName', callback); context.removeHook('hookName', callback); // === ROUTES AND MIDDLEWARE === // Add a route context.addRoute('get', '/path', handler); // Add middleware context.addMiddleware(middlewareFunction); // Add CLI command context.addCommand('name', handler, 'description'); // === LOGGING === // Log with automatic plugin name context.log('success', 'Message', 'details'); // === ACCESS TO OTHER PLUGINS === // Get another plugin const otherPlugin = context.getPlugin('other-plugin'); // List all plugins const plugins = context.listPlugins(); // === CONFIGURATION === // Read config const config = context.getConfig(); // Modify config context.updateConfig({ newOption: 'value' }); // === PERSISTENT STORAGE === // Save data context.storage.set('key', 'value'); context.storage.set({ key1: 'value1', key2: 'value2' }); // Read data const value = context.storage.get('key', 'defaultValue'); const allData = context.storage.get(); // Delete data context.storage.delete('key'); context.storage.clear(); } ``` ### Plugin Management ```javascript // Load plugin manually await app.loadPlugin('plugin-name', { option: 'value' }); // Unload plugin await app.unloadPlugin('plugin-name'); // Reload plugin await app.reloadPlugin('plugin-name', { newConfig: true }); // List plugins const plugins = app.listPlugins(); // Enable/disable plugin await app.plugins.togglePlugin('plugin-name', true); // Statistics const stats = app.plugins.getStats(); console.log(`${stats.active}/${stats.total} plugins active`); ``` ### Available Hooks The plugin system provides numerous built-in hooks: ```javascript // Application hooks app:init // Application initialization app:start // Server startup app:stop // Server shutdown // Route hooks route:load // Route loading route:create // Route creation route:created // Route created (after) route:delete // Route deletion // Request hooks request:start // Request start request:end // Request end // WebSocket hooks websocket:connect // WebSocket connection websocket:disconnect // WebSocket disconnection // File hooks file:change // File modification // Plugin hooks plugin:load // Plugin loading plugin:unload // Plugin unloading // Error hooks error:handle // Error handling ``` ### Plugin Examples #### Database Plugin ```javascript // plugins/database.js const mongoose = require('mongoose'); module.exports = { name: 'database', version: '1.0.0', description: 'MongoDB connection plugin', defaultConfig: { uri: 'mongodb://localhost:27017/myapp', options: { useNewUrlParser: true, useUnifiedTopology: true } }, async load(app, config, context) { try { await mongoose.connect(config.uri, config.options); context.log('success', 'MongoDB connection established'); // Expose mongoose in app app.db = mongoose; // Shutdown hook context.hook('app:stop', async () => { await mongoose.disconnect(); context.log('info', 'MongoDB connection closed'); }); } catch (error) { context.log('error', 'MongoDB connection error', error.message); throw error; } }, async unload() { await mongoose.disconnect(); } }; ``` #### Authentication Plugin ```javascript // plugins/auth.js const jwt = require('jsonwebtoken'); module.exports = { name: 'auth', version: '1.0.0', description: 'JWT authentication plugin', dependencies: ['database'], defaultConfig: { secret: 'your-secret-key', expiresIn: '24h' }, async load(app, config, context) { // Authentication middleware const authMiddleware = (req, res, next) => { const token = req.headers.authorization?.split(' ')[1]; if (!token) { return res.status(401).json({ error: 'Missing token' }); } try { const decoded = jwt.verify(token, config.secret); req.user = decoded; next(); } catch (error) { res.status(401).json({ error: 'Invalid token' }); } }; // Authentication routes context.addRoute('post', '/auth/login', async (req, res) => { const { email, password } = req.body; // User validation (example) const user = await validateUser(email, password); if (user) { const token = jwt.sign( { id: user.id, email: user.email }, config.secret, { expiresIn: config.expiresIn } ); res.json({ token, user }); } else { res.status(401).json({ error: 'Invalid credentials' }); } }); context.addRoute('get', '/auth/profile', authMiddleware, (req, res) => { res.json({ user: req.user }); }); // Expose middleware in app app.authMiddleware = authMiddleware; context.log('success', 'Authentication plugin loaded'); } }; ``` #### Cache Plugin ```javascript // plugins/cache.js const NodeCache = require('node-cache'); module.exports = { name: 'cache', version: '1.0.0', description: 'In-memory cache plugin', defaultConfig: { stdTTL: 600, // 10 minutes checkperiod: 120 }, async load(app, config, context) { const cache = new NodeCache(config); // Cache middleware const cacheMiddleware = (duration = 300) => { return (req, res, next) => { const key = req.originalUrl; const cached = cache.get(key); if (cached) { context.log('info', 'Cache hit', key); return res.json(cached); } const originalSend = res.json; res.json = function(data) { cache.set(key, data, duration); context.log('info', 'Cache set', key); return originalSend.call(this, data); }; next(); }; }; // Cache API app.cache = { get: (key) => cache.get(key), set: (key, value, ttl) => cache.set(key, value, ttl), del: (key) => cache.del(key), flush: () => cache.flushAll(), middleware: cacheMiddleware, stats: () => cache.getStats() }; // Stats route context.addRoute('get', '/cache/stats', (req, res) => { res.json(cache.getStats()); }); context.log('success', 'Cache plugin loaded'); } }; ``` ### Inline Plugin Creation ```javascript // Create a simple plugin directly in code const simplePlugin = app.plugins.createSimplePlugin( 'logger-plugin', (app, config, context) => { // Hook to log all requests context.hook('request:start', (req) => { context.log('info', `${req.method} ${req.url}`); }); // Debug route context.addRoute('get', '/debug/logs', (req, res) => { res.json({ plugin: 'logger-plugin', requests: context.storage.get('requestCount', 0) }); }); }, { version: '1.0.0', description: 'Request logging plugin' } ); await app.loadPlugin(simplePlugin); ``` ## ๐Ÿ›ฃ๏ธ Dynamic Route Management Veko.js allows creating, modifying, and deleting routes dynamically during runtime. ### Dynamic Route Creation ```javascript // Create route on-the-fly app.createRoute('get', '/api/dynamic', (req, res) => { res.json({ message: 'Route created dynamically!' }); }); // With middleware app.createRoute('post', '/api/secure', [ authMiddleware, validationMiddleware, (req, res) => { res.json({ success: true }); } ]); // Update existing route app.updateRoute('get', '/api/dynamic', (req, res) => { res.json({ message: 'Route updated!' }); }); // Delete route app.deleteRoute('get', '/api/dynamic'); ``` ### Creating Route Files ```javascript // Create physical route file app.createRouteFile('/users/profile', { get: (req, res) => { res.render('profile', { user: req.user }); }, post: (req, res) => { // Profile update res.json({ updated: true }); } }, { description: 'User profile management', middleware: [authMiddleware] }); // Delete route file app.deleteRouteFile('/users/profile'); // List all routes const routes = app.listRoutes(); console.log(routes); ``` ## ๐ŸŽจ Beautiful Logging Veko.js offers a revolutionary logging system with: - ๐Ÿ•’ **Formatted timestamps** - ๐ŸŽฏ **Colored badges** with Unicode icons - ๐Ÿ“Š **Specialized log types** - ๐ŸŒˆ **Optimized ANSI colors** ### Available Log Types ```javascript app.log('success', 'Operation successful', 'โœ… Additional details'); app.log('error', 'Critical error', 'โŒ Error message'); app.log('warning', 'Warning', 'โš ๏ธ Warning message'); app.log('info', 'Information', 'โ„น๏ธ General info'); app.log('server', 'Server', '๐Ÿš€ Server startup'); app.log('route', 'Route', '๐ŸŒ New route'); app.log('dev', 'Development', '๐Ÿ› ๏ธ Dev mode'); app.log('file', 'File', '๐Ÿ“ File modification'); app.log('reload', 'Reload', '๐Ÿ”„ Hot reload'); app.log('create', 'Creation', 'โž• Element created'); app.log('delete', 'Deletion', '๐Ÿ—‘๏ธ Element deleted'); app.log('install', 'Installation', '๐Ÿ“ฆ Module installed'); ``` ### Console Output Example ``` [2:32:15 PM] โœจ Server started successfully ๐ŸŒ http://localhost:3000 [2:32:16 PM] ๐Ÿ› ๏ธ Development mode active ๐Ÿ”ฅ Intelligent hot reload on port 3008 [2:32:16 PM] ๐Ÿ”Œ Plugin database loaded database v1.0.0 [2:32:16 PM] ๐Ÿ”Œ Plugin auth loaded auth v1.0.0 [2:32:17 PM] ๐Ÿ’Ž Plugin system ๐Ÿ”Œ 2/2 plugins active [2:32:17 PM] ๐ŸŒ Route loaded index.js โ†’ / [2:32:18 PM] โž• Route created dynamically GET /api/users [2:32:19 PM] ๐Ÿ“ File modified ๐Ÿ“ routes/users.js [2:32:19 PM] ๐Ÿ”„ Route reloaded ๐Ÿ”„ routes/users.js ``` ## ๐Ÿ”ฅ Intelligent Hot Reload ### Selective Reload by File Type - **Modified routes** โ†’ Route-only reload - **Modified views** โ†’ Light template reload - **Static files** โ†’ Full browser reload - **Modified plugins** โ†’ Specific plugin reload - **Modified layouts** โ†’ Layout cache clear and reload ### Hot Reload Configuration ```javascript const app = new App({ isDev: true, wsPort: 3008, // WebSocket port watchDirs: ['views', 'routes', 'public', 'src', 'plugins'], // Watched directories prefetch: { enabled: true, maxConcurrent: 3, notifyUser: true, cacheRoutes: true, prefetchDelay: 1000 } }); ``` ### Automatic Client Script The hot reload script is automatically injected into your pages: ```javascript // Automatically injected before ``` ## ๐Ÿ“ Project Structure ``` my-project/ โ”œโ”€โ”€ routes/ โ”‚ โ”œโ”€โ”€ index.js # Route: / โ”‚ โ”œโ”€โ”€ about.js # Route: /about โ”‚ โ”œโ”€โ”€ users/ โ”‚ โ”‚ โ”œโ”€โ”€ index.js # Route: /users โ”‚ โ”‚ โ””โ”€โ”€ [id].js # Route: /users/:id โ”‚ โ””โ”€โ”€ api/ โ”‚ โ””โ”€โ”€ products.js # Route: /api/products โ”œโ”€โ”€ views/ โ”‚ โ”œโ”€โ”€ layouts/ # Layout templates โ”‚ โ”‚ โ”œโ”€โ”€ main.ejs # Main layout โ”‚ โ”‚ โ””โ”€โ”€ admin.ejs # Admin layout โ”‚ โ”œโ”€โ”€ partials/ # Reusable components โ”‚ โ”œโ”€โ”€ index.ejs โ”‚ โ””โ”€โ”€ about.ejs โ”œโ”€โ”€ public/ โ”‚ โ”œโ”€โ”€ css/ โ”‚ โ”œโ”€โ”€ js/ โ”‚ โ””โ”€โ”€ images/ โ”œโ”€โ”€ plugins/ # Custom plugins โ”‚ โ”œโ”€โ”€ database.js โ”‚ โ”œโ”€โ”€ auth.js โ”‚ โ””โ”€โ”€ cache.js โ”œโ”€โ”€ data/ # Plugin data โ”‚ โ””โ”€โ”€ plugins/ โ”‚ โ”œโ”€โ”€ database.json โ”‚ โ””โ”€โ”€ auth.json โ”œโ”€โ”€ config/ # Configuration files โ”‚ โ””โ”€โ”€ app.js โ”œโ”€โ”€ middleware/ # Custom middleware โ””โ”€โ”€ package.json ``` ## ๐Ÿ›ฃ๏ธ Route System ### Automatic Routes Veko.js automatically loads all routes from the `routes/` folder. The filename determines the URL: - `routes/index.js` โ†’ `/` - `routes/about.js` โ†’ `/about` - `routes/users/profile.js` โ†’ `/users/profile` - `routes/api/users.js` โ†’ `/api/users` ### Dynamic Parameters Use brackets for parameters: - `routes/users/[id].js` โ†’ `/users/:id` - `routes/posts/[slug]/comments.js` โ†’ `/posts/:slug/comments` ### Route File Formats #### HTTP Methods (Recommended) ```javascript // routes/users.js module.exports = { // GET /users get: (req, res) => { res.render('users', { users: [] }); }, // POST /users post: (req, res) => { const newUser = req.body; res.status(201).json({ user: newUser }); }, // PUT /users put: (req, res) => { res.json({ message: 'User updated' }); }, // DELETE /users delete: (req, res) => { res.json({ message: 'User deleted' }); } }; ``` #### Custom Function ```javascript // routes/custom.js module.exports = (app) => { app.get('/custom', (req, res) => { res.json({ message: 'Custom route' }); }); app.post('/custom/:action', middleware, (req, res) => { res.json({ action: req.params.action }); }); }; ``` ## โšก Ultra-Modern Development Mode Development mode includes: - ๐Ÿ”ฅ **Intelligent Hot Reload** - Selective reload by file type - ๐Ÿ“ก **WebSocket** - Real-time server โ†” client communication - ๐ŸŽจ **Colorful Logs** - Logging system with badges and icons - ๐Ÿ” **Advanced Monitoring** - File monitoring with chokidar - โšก **Performance** - Reload only modified parts - ๐Ÿ› ๏ธ **Debugging** - Detailed error messages with stack traces - ๐Ÿ”Œ **Hot Plugin Reload** - Real-time plugin reloading ### Complete Configuration ```javascript const app = new App({ port: 3000, wsPort: 3008, viewsDir: 'views', staticDir: 'public', routesDir: 'routes', isDev: true, watchDirs: ['views', 'routes', 'public', 'src', 'plugins'], errorLog: 'error.log', showStack: true, autoInstall: true, layouts: { enabled: true, defaultLayout: 'main', layoutsDir: 'views/layouts', cache: false // Disable cache in dev mode }, plugins: { enabled: true, autoLoad: true, pluginsDir: 'plugins' }, prefetch: { enabled: true, maxConcurrent: 3, notifyUser: true, cacheRoutes: true, prefetchDelay: 1000 } }); ``` ### Advanced Error Handling ```javascript // Automatic handling of uncaught errors process.on('uncaughtException', (error) => { app.log('error', 'Uncaught exception', error.message); // Automatic WebSocket notification to clients }); process.on('unhandledRejection', (reason) => { app.log('error', 'Promise rejected', reason.toString()); // Automatic error broadcast }); ``` ## ๐ŸŽจ Views with EJS Veko.js uses EJS as the default template engine with advanced configuration. ### View Configuration ```javascript // Automatic view directory configuration this.express.set('view engine', 'ejs'); this.express.set('views', [ path.join(process.cwd(), this.options.viewsDir), // Project directory path.join(process.cwd(), this.options.layouts.layoutsDir), // Layouts directory path.join(__dirname, '..', 'views'), // Veko.js views path.join(__dirname, '..', 'error') // Error pages ]); ``` ### Modern View Example ```html <%= title %>

<%= message %>

<% if (users && users.length > 0) { %>
<% users.forEach(user => { %>

<%= user.name %>

<%= user.email %>

<% }); %>
<% } else { %>

No users found.

<% } %>
``` ## ๐Ÿ“ฆ Auto Module Installation Veko.js automatically installs missing dependencies during initialization. ### Module Installation Configuration ```javascript const app = new App({ autoInstall: true // Enable automatic installation (default: true) }); // Check if module is available if (app.isModuleAvailable('express')) { console.log('Express is available'); } // Install module on-the-fly await app.installModule('lodash', '4.17.21'); // Require module with auto-installation const lodash = await app.requireModule('lodash'); ``` ### Required Modules Veko.js automatically manages these dependencies: ```javascript const requiredModules = { 'express': '^4.18.2', 'ejs': '^3.1.9', 'ws': '^8.14.2', 'chokidar': '^3.5.3', 'chalk': '^4.1.2', 'commander': '^11.1.0' }; ``` ## ๐Ÿ”ง Complete API ### App Class #### Constructor ```javascript const app = new App({ port: 3000, // Listening port wsPort: 3008, // WebSocket port (dev mode) viewsDir: 'views', // Views directory staticDir: 'public', // Static directory routesDir: 'routes', // Routes directory isDev: false, // Development mode watchDirs: ['views', 'routes', 'public'], // Watched directories errorLog: 'error.log', // Error log file showStack: true, // Show stack trace autoInstall: true, // Auto module installation layouts: { // Layout configuration enabled: true, defaultLayout: 'main', layoutsDir: 'views/layouts', extension: '.ejs', cache: true }, plugins: { // Plugin configuration enabled: true, autoLoad: true, pluginsDir: 'plugins' }, prefetch: { // Prefetch configuration enabled: true, maxConcurrent: 3, notifyUser: true, cacheRoutes: true, prefetchDelay: 1000 } }); ``` #### Main Methods ```javascript // Loading and startup app.loadRoutes(routesDir) // Load routes automatically app.listen(port) // Start server app.startDev(port) // Start in development mode app.stop() // Stop server // Middleware and configuration app.use(middleware) // Add middleware app.setupExpress() // Configure Express app.setupDevMode() // Enable development mode // Beautiful logging app.log(type, message, details) // Advanced logging system // Dynamic route management app.createRoute(method, path, handler, options) // Create route dynamically app.deleteRoute(method, path) // Delete route app.updateRoute(method, path, newHandler) // Update route app.createRouteFile(routePath, handlers, options) // Create route file app.deleteRouteFile(routePath) // Delete route file app.listRoutes() // List all routes // Layout management app.createLayout(name, content) // Create layout app.deleteLayout(name) // Delete layout app.listLayouts() // List layouts app.reloadLayouts() // Reload layouts app.renderWithCustomLayout(res, view, layout, data) // Render with specific layout app.renderWithoutLayout(res, view, data) // Render without layout // Module management app.installModule(name, version) // Install module app.isModuleAvailable(name) // Check module availability app.requireModule(name, version) // Require with auto-install // Route management (internal) app.reloadSpecificRoute(filePath) // Reload specific route app.removeRoute(filePath) // Remove route app.filePathToRoute(filePath) // Convert path โ†’ route // WebSocket and broadcast app.broadcast(data) // Broadcast WebSocket message app.sendAvailableRoutes(ws) // Send available routes // Plugin management app.loadPlugin(plugin, config) // Load plugin app.unloadPlugin(pluginName) // Unload plugin app.reloadPlugin(pluginName, config) // Reload plugin app.listPlugins() // List plugins app.executeHook(hookName, ...args) // Execute hook ``` ### Utility Functions ```javascript const { createApp, startDev, start } = require('veko'); // Quick app creation const app = createApp({ port: 3000 }); // Development startup startDev({ port: 3000, watchDirs: ['src'] }); // Production startup start({ port: 8080 }); ``` ## ๐Ÿ” Advanced Examples ### Complete Application with Plugins ```javascript const { App } = require('veko'); const app = new App({ port: 3000, isDev: process.env.NODE_ENV === 'development', layouts: { enabled: true, defaultLayout: 'main' }, plugins: { enabled: true, autoLoad: true, pluginsDir: 'plugins' } }); // Load plugins with specific configuration await app.loadPlugin('database', { uri: process.env.MONGODB_URI || 'mongodb://localhost:27017/myapp' }); await app.loadPlugin('auth', { secret: process.env.JWT_SECRET || 'development-secret', expiresIn: '7d' }); await app.loadPlugin('cache', { stdTTL: 3600 // 1 hour }); // Add global hooks app.plugins.addHook('request:start', (req) => { app.log('info', `${req.method} ${req.url}`, `IP: ${req.ip}`); }); app.plugins.addHook('error:handle', (error, req) => { app.log('error', 'Application error', `${error.message} - ${req.url}`); }); app.loadRoutes().listen(); ``` ### Modern REST API with Error Handling ```javascript // routes/api/users.js const users = []; module.exports = { get: async (req, res) => { try { // Use plugin cache const cacheKey = `users:${JSON.stringify(req.query)}`; const cached = req.app.cache?.get(cacheKey); if (cached) { return res.json(cached); } // Database simulation const page = parseInt(req.query.page) || 1; const limit = parseInt(req.query.limit) || 10; const start = (page - 1) * limit; const end = start + limit; const paginatedUsers = users.slice(start, end); const result = { users: paginatedUsers, pagination: { page, limit, total: users.length, pages: Math.ceil(users.length / limit) } }; // Cache result req.app.cache?.set(cacheKey, result, 300); res.json(result); } catch (error) { res.status(500).json({ error: 'Server error' }); } }, post: [ // Use auth middleware from plugin (req, res, next) => req.app.authMiddleware?.(req, res, next) || next(), async (req, res) => { try { const { name, email } = req.body; if (!name || !email) { return res.status(400).json({ error: 'Name and email required' }); } const newUser = { id: users.length + 1, name, email, createdAt: new Date().toISOString() }; users.push(newUser); // Invalidate cache req.app.cache?.del('users:*'); res.status(201).json({ message: 'User created', user: newUser }); } catch (error) { res.status(500).json({ error: 'Server error' }); } } ] }; ``` ### Advanced Plugin with CLI ```javascript // plugins/admin.js module.exports = { name: 'admin', version: '2.0.0', description: 'Advanced administration plugin', dependencies: ['database', 'auth'], defaultConfig: { adminPath: '/admin', secretKey: 'admin-secret' }, async load(app, config, context) { // Admin-only middleware const adminMiddleware = (req, res, next) => { if (!req.user || req.user.role !== 'admin') { return res.status(403).json({ error: 'Access denied' }); } next(); }; // Administration routes context.addRoute('get', `${config.adminPath}/dashboard`, [ app.authMiddleware, adminMiddleware, (req, res) => { res.render('admin/dashboard', { layout: 'admin', stats: context.storage.get('stats', {}), plugins: context.listPlugins() }); } ]); // Plugin management API context.addRoute('post', `${config.adminPath}/plugins/:name/toggle`, [ app.authMiddleware, adminMiddleware, async (req, res) => { try { const { name } = req.params; const result = await context.getPlugin('plugins')?.togglePlugin(name); res.json({ success: true, active: result }); } catch (error) { res.status(500).json({ error: error.message }); } } ]); // CLI commands context.addCommand('admin:stats', () => { console.log('=== Admin Statistics ==='); console.log('Plugins:', context.listPlugins().length); console.log('Stats:', context.storage.get('stats', {})); }, 'Display administration statistics'); context.addCommand('admin:reset', () => { context.storage.clear(); console.log('Admin data reset'); }, 'Reset administration data'); // Hook to collect stats context.hook('request:end', (req, res) => { const stats = context.storage.get('stats', { requests: 0, errors: 0 }); stats.requests++; if (res.statusCode >= 400) { stats.errors++; } context.storage.set('stats', stats); }); context.log('success', 'Admin plugin loaded', `Interface: ${config.adminPath}`); } }; ``` ## ๐Ÿš€ Deployment ### Production Mode ```javascript // app.js const { App } = require('veko'); const app = new App({ port: process.env.PORT || 3000, isDev: false, // Disable development mode errorLog: 'logs/error.log', showStack: false, // Hide stack traces in production autoInstall: false, // Disable auto-installation in production layouts: { enabled: true, cache: true // Enable layout caching }, plugins: { enabled: true, autoLoad: true, pluginsDir: 'plugins' } }); app.loadRoutes().listen(); ``` ### Environment Variables ```bash # .env NODE_ENV=production PORT=8080 LOG_LEVEL=info MONGODB_URI=mongodb://prod-server:27017/myapp JWT_SECRET=super-secret-production-key ``` ### Docker ```dockerfile FROM node:18-alpine WORKDIR /app COPY package*.json ./ RUN npm ci --only=production COPY . . EXPOSE 3000 CMD ["node", "app.js"] ``` ## ๐Ÿ“Š Performance and Optimization ### Smart Prefetching ```javascript const app = new App({ prefetch: { enabled: true, // Enable prefetching maxConcurrent: 3, // Max simultaneous requests notifyUser: true, // Notify user cacheRoutes: true, // Route caching prefetchDelay: 1000 // Delay before prefetching } }); ``` ### Performance Monitoring ```javascript // Monitoring plugin const monitoringPlugin = { name: 'monitoring', async load(app, config, context) { context.hook('request:start', (req) => { req.startTime = process.hrtime.bigint(); }); context.hook('request:end', (req, res) => { const duration = Number(process.hrtime.bigint() - req.startTime) / 1000000; if (duration > 100) { context.log('warning', 'Slow request detected', `${req.method} ${req.url} - ${duration.toFixed(2)}ms`); } // Store metrics const metrics = context.storage.get('metrics', { slow: 0, total: 0 }); metrics.total++; if (duration > 100) metrics.slow++; context.storage.set('metrics', metrics); }); } }; app.loadPlugin(monitoringPlugin); ``` ## ๐Ÿ› ๏ธ CLI Commands ### Setup Commands ```bash # Create new project with default template veko setup my-app # Create with specific template veko setup --template api --name my-api veko setup --template blog --name my-blog veko setup --template admin --name admin-panel # Setup with options veko setup my-app --git --skip-install veko setup --name my-app --dir ./projects/my-app ``` ### Development Commands ```bash # Start development server veko dev # Start with custom port veko dev --port 8080 # Start with custom watch directories veko dev --watch "src,views,routes" # Start with custom entry file veko dev --file ./src/server.js ``` ### Build Commands ```bash # Build for production veko build # Start production server veko start ``` ## ๐Ÿค Contributing Contributions are welcome! ### Local Development ```bash git clone https://github.com/username/veko.js.git cd veko.js npm install npm run dev ``` ### Testing ```bash npm test npm run test:watch npm run test:coverage ``` ### Creating a Plugin 1. Create a file in `plugins/` 2. Follow the documented plugin structure 3. Test in development mode 4. Submit a PR ### Code Style - Use ES6+ features - Follow JSDoc comments - Use meaningful variable names - Add unit tests for new features ## ๐Ÿ“„ License MIT License - see LICENSE file for details. --- **Veko.js v2.0** - Ultra-modern web framework with the most advanced auto-updater in the Node.js ecosystem ๐Ÿš€๐Ÿ”„ ### Quick Auto-Updater Commands ```bash veko update # ๐ŸŽจ Menu interactif veko update check # ๐Ÿ” Vรฉrification des mises ร  jour veko update update # โšก Mettre ร  jour maintenant veko update status # ๐Ÿ“Š Afficher le statut veko update daemon # ๐Ÿ‘พ Mode arriรจre-plan veko update --help # โ“ Aide complรจte ``` ### Quick Links - [๐Ÿ  Home](/) - [๐Ÿ“š Documentation](/docs) - [๐Ÿ”„ Auto-Updater Guide](/docs/auto-updater) - [๐Ÿ”Œ Plugins](/plugins) - [๐Ÿ› ๏ธ CLI](/cli) - [๐Ÿ’ก Examples](/examples) - [๐Ÿ› Issues](https://github.com/username/veko.js/issues) - [๐Ÿ’ฌ Discussions](https://github.com/username/veko.js/discussions) Built with โค๏ธ by the Veko.js team **Experience the future of Node.js development with Veko.js 2.0! ๐Ÿš€โœจ**