@africode/core 5.0.0

package/core/bun-runtime.js

@@ -0,0 +1,799 @@
+/**
+ * Bun-Native Runtime Engine
+ * Optimized runtime leveraging Bun's Zig-based architecture
+ *
+ * Provides ultra-fast startup, native APIs, and hot reloading
+ * capabilities for high-performance fintech applications.
+ *
+ * @module core/bun-runtime
+ */
+
+import { createReactiveState } from './state.js';
+import { FileBasedRouter } from './file-router.js';
+import { EnhancedHMRMiddleware } from './enhanced-hmr.js';
+
+/**
+ * Bun Runtime Configuration
+ */
+export const BUN_CONFIG = {
+    startupTimeout: 5000, // 5ms target startup
+    memoryLimit: '1gb',
+    gcStrategy: 'generational',
+    threadPoolSize: 4
+};
+
+/**
+ * Bun HTTP Server with File-Based Routing
+ * Autonomous application lifecycle management
+ */
+export class BunHTTPServer {
+    constructor(options = {}) {
+        this.options = {
+            port: options.port || 3000,
+            pagesDir: options.pagesDir || 'pages',
+            publicDir: options.publicDir || 'public',
+            middleware: options.middleware || [],
+            enableHMR: options.enableHMR !== false,
+            ...options
+        };
+
+        this.router = new FileBasedRouter({
+            pagesDir: this.options.pagesDir
+        });
+
+        this.server = null;
+        this.hmr = null;
+    }
+
+    /**
+     * Start the HTTP server
+     */
+    async start() {
+        console.log(`🚀 Starting Bun HTTP Server on port ${this.options.port}`);
+
+        // Initialize HMR if enabled
+        if (this.options.enableHMR) {
+            this.hmr = new EnhancedHMRMiddleware({
+                port: this.options.port + 1,
+                watchPaths: [this.options.pagesDir, 'components', 'core']
+            });
+        }
+
+        // Create Bun server with file-based routing
+        this.server = Bun.serve({
+            port: this.options.port,
+            async fetch(request) {
+                const url = new URL(request.url);
+                const pathname = url.pathname;
+
+                // Handle static files
+                if (pathname.startsWith('/public/') || pathname.startsWith('/static/')) {
+                    return this._serveStaticFile(pathname);
+                }
+
+                // Handle HMR WebSocket upgrade
+                if (pathname === '/hmr' && this.hmr) {
+                    const upgrade = this.hmr.handleUpgrade(request);
+                    if (upgrade) return upgrade;
+                }
+
+                // Route to file-based handler
+                return this._handleRoute(request);
+            }.bind(this),
+
+            // WebSocket handling for HMR
+            websocket: this.hmr ? {
+                open: (ws) => this.hmr.handleClientConnect(ws),
+                message: (ws, message) => this.hmr.handleClientMessage(ws, message),
+                close: (ws) => this.hmr.handleClientDisconnect(ws)
+            } : undefined
+        });
+
+        // Start HMR watching
+        if (this.hmr) {
+            await this.hmr.initialize(this.server);
+        }
+
+        console.log(`📡 Server ready at http://localhost:${this.options.port}`);
+        console.log(`📊 Routes loaded:`, this.router.getRoutes());
+    }
+
+    /**
+     * Handle incoming requests with file-based routing
+     */
+    async _handleRoute(request) {
+        const url = new URL(request.url);
+        const pathname = url.pathname;
+        const method = request.method;
+
+        try {
+            // Match route
+            const routeMatch = this.router.matchRoute(pathname, method);
+
+            if (!routeMatch) {
+                return new Response('Not Found', { status: 404 });
+            }
+
+            // Load route handler/component
+            const handler = await this.router.loadRoute(routeMatch);
+
+            if (routeMatch.type === 'api') {
+                // Handle API route
+                return this._handleApiRoute(handler, request, routeMatch.params);
+            } else {
+                // Handle page route
+                return this._handlePageRoute(handler, request, routeMatch);
+            }
+
+        } catch (error) {
+            console.error('[Server] Route error:', error);
+            return new Response('Internal Server Error', { status: 500 });
+        }
+    }
+
+    /**
+     * Handle API route execution
+     */
+    async _handleApiRoute(handler, request, params) {
+        try {
+            // Execute API handler
+            const result = await handler(request, { params });
+
+            if (result instanceof Response) {
+                return result;
+            }
+
+            // Convert to JSON response
+            return new Response(JSON.stringify(result), {
+                headers: { 'Content-Type': 'application/json' }
+            });
+
+        } catch (error) {
+            console.error('[Server] API error:', error);
+            return new Response(JSON.stringify({ error: error.message }), {
+                status: 500,
+                headers: { 'Content-Type': 'application/json' }
+            });
+        }
+    }
+
+    /**
+     * Handle page route rendering
+     */
+    async _handlePageRoute(component, request, routeMatch) {
+        try {
+            // Render page component
+            const html = await this._renderPage(component, routeMatch);
+
+            return new Response(html, {
+                headers: { 'Content-Type': 'text/html' }
+            });
+
+        } catch (error) {
+            console.error('[Server] Page render error:', error);
+            return new Response('Render Error', { status: 500 });
+        }
+    }
+
+    /**
+     * Render page with layout
+     */
+    async _renderPage(component, routeMatch) {
+        let content = '';
+
+        // Render component
+        if (typeof component === 'function') {
+            content = component(routeMatch.params || {});
+        } else if (component.render) {
+            content = component.render(routeMatch.params || {});
+        } else {
+            content = String(component);
+        }
+
+        // Apply layout if available
+        if (routeMatch.layout) {
+            try {
+                const layoutModule = await import(routeMatch.layout);
+                const layout = layoutModule.default || layoutModule;
+
+                if (typeof layout === 'function') {
+                    content = layout({ children: content, params: routeMatch.params });
+                }
+            } catch (error) {
+                console.warn('[Server] Layout load error:', error.message);
+            }
+        }
+
+        // Wrap in basic HTML structure
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AfriCode App</title>
+    <link rel="stylesheet" href="/public/styles.css">
+</head>
+<body>
+    ${content}
+    <script type="module" src="/public/app.js"></script>
+</body>
+</html>`;
+    }
+
+    /**
+     * Serve static files
+     */
+    _serveStaticFile(pathname) {
+        try {
+            const filePath = join(process.cwd(), pathname);
+            const file = Bun.file(filePath);
+            return new Response(file);
+        } catch {
+            return new Response('File Not Found', { status: 404 });
+        }
+    }
+
+    /**
+     * Stop the server
+     */
+    async stop() {
+        if (this.server) {
+            this.server.stop();
+        }
+        if (this.hmr) {
+            await this.hmr.shutdown();
+        }
+        console.log('🛑 Server stopped');
+    }
+}
+
+/**
+ * Hot Reloading Engine
+ * Enables zero-downtime updates with state preservation
+ */
+export class HotReloadEngine {
+    constructor() {
+        this.modules = new Map();
+        this.state = createReactiveState({});
+        this.connections = new Set();
+    }
+
+    /**
+     * Initialize hot reloading for a module
+     * @param {string} moduleId - Module identifier
+     * @param {Function} moduleFactory - Module factory function
+     */
+    initModule(moduleId, moduleFactory) {
+        const module = {
+            id: moduleId,
+            factory: moduleFactory,
+            instance: null,
+            lastModified: Date.now(),
+            dependencies: new Set()
+        };
+
+        this.modules.set(moduleId, module);
+        this._instantiateModule(module);
+        return module;
+    }
+
+    /**
+     * Handle file change event
+     * @param {string} filePath - Changed file path
+     * @param {string} eventType - Change type (create, update, delete)
+     */
+    async handleFileChange(filePath, eventType) {
+        const moduleId = this._pathToModuleId(filePath);
+
+        if (eventType === 'delete') {
+            this.modules.delete(moduleId);
+            this._broadcastReload(moduleId, 'delete');
+            return;
+        }
+
+        // Check if module needs reloading
+        const module = this.modules.get(moduleId);
+        if (!module) return;
+
+        try {
+            const stats = await Bun.file(filePath).stat();
+            if (stats.mtime > module.lastModified) {
+                await this._reloadModule(moduleId);
+            }
+        } catch (error) {
+            console.warn('[HMR] File stat error:', error.message);
+        }
+    }
+
+    /**
+     * Reload a module with state preservation
+     * @param {string} moduleId - Module to reload
+     */
+    async _reloadModule(moduleId) {
+        const module = this.modules.get(moduleId);
+        if (!module) return;
+
+        // Preserve current state
+        const oldState = module.instance?.state || {};
+
+        // Dispose old instance
+        if (module.instance?.dispose) {
+            module.instance.dispose();
+        }
+
+        // Reload module
+        try {
+            // Clear module cache if possible
+            if (typeof require !== 'undefined' && require.cache) {
+                delete require.cache[moduleId];
+            }
+
+            await this._instantiateModule(module);
+
+            // Restore state
+            if (module.instance?.restoreState) {
+                module.instance.restoreState(oldState);
+            }
+
+            this._broadcastReload(moduleId, 'update');
+        } catch (error) {
+            console.error('[HMR] Module reload error:', error.message);
+        }
+    }
+
+    /**
+     * Instantiate a module
+     * @param {Object} module - Module object
+     */
+    async _instantiateModule(module) {
+        try {
+            module.instance = await module.factory();
+            module.lastModified = Date.now();
+        } catch (error) {
+            console.error('[HMR] Module instantiation error:', error.message);
+            module.instance = null;
+        }
+        return module;
+    }
+
+    /**
+     * Convert file path to module ID
+     * @param {string} filePath - File path
+     * @returns {string} Module ID
+     */
+    _pathToModuleId(filePath) {
+        return filePath.replace(/\\/g, '/').replace(process.cwd() + '/', '');
+    }
+
+    /**
+     * Broadcast reload event to connected clients
+     * @param {string} moduleId - Module ID
+     * @param {string} eventType - Event type
+     */
+    _broadcastReload(moduleId, eventType) {
+        const message = {
+            type: 'module-update',
+            moduleId,
+            eventType,
+            timestamp: Date.now()
+        };
+
+        for (const ws of this.connections) {
+            try {
+                ws.send(JSON.stringify(message));
+            } catch (error) {
+                this.connections.delete(ws);
+            }
+        }
+    }
+}
+
+// Import join function for static file serving
+import { join } from 'path';
+        this.connections = new Set();
+    }
+
+    /**
+     * Initialize hot reloading for a module
+     * @param {string} moduleId - Module identifier
+     * @param {Function} moduleFactory - Module factory function
+     */
+    initModule(moduleId, moduleFactory) {
+        const module = {
+            id: moduleId,
+            factory: moduleFactory,
+            instance: null,
+            lastModified: Date.now(),
+            dependencies: new Set()
+        };
+
+        this.modules.set(moduleId, module);
+        this._instantiateModule(module);
+
+        return module;
+    }
+
+    /**
+     * Handle file change event
+     * @param {string} filePath - Changed file path
+     * @param {string} eventType - Change type (create, update, delete)
+     */
+    async handleFileChange(filePath, eventType) {
+        const moduleId = this._pathToModuleId(filePath);
+
+        if (eventType === 'delete') {
+            this.modules.delete(moduleId);
+            this._broadcastReload(moduleId, 'delete');
+            return;
+        }
+
+        // Check if module needs reloading
+        const module = this.modules.get(moduleId);
+        if (!module) return;
+
+        const stats = await Bun.file(filePath).stat();
+        if (stats.mtime > module.lastModified) {
+            await this._reloadModule(moduleId);
+        }
+    }
+
+    /**
+     * Reload a module with state preservation
+     * @param {string} moduleId - Module to reload
+     */
+    async _reloadModule(moduleId) {
+        const module = this.modules.get(moduleId);
+        if (!module) return;
+
+        // Preserve current state
+        const oldState = module.instance?.state || {};
+
+        // Dispose old instance
+        if (module.instance?.dispose) {
+            module.instance.dispose();
+        }
+
+        // Reload module
+        delete require.cache[moduleId]; // Clear Node.js cache if applicable
+        await this._instantiateModule(module);
+
+        // Restore state
+        if (module.instance?.restoreState) {
+            module.instance.restoreState(oldState);
+        }
+
+        // Update timestamp
+        module.lastModified = Date.now();
+
+        // Broadcast reload to clients
+        this._broadcastReload(moduleId, 'update');
+    }
+
+    /**
+     * Instantiate a module
+     * @param {Object} module - Module definition
+     */
+    async _instantiateModule(module) {
+        try {
+            module.instance = await module.factory();
+
+            // Store state for hot reload
+            if (module.instance) {
+                module.instance.state = this.state[module.id] || {};
+            }
+        } catch (error) {
+            console.error(`Failed to instantiate module ${module.id}:`, error);
+        }
+    }
+
+    /**
+     * Broadcast reload event to connected clients
+     * @param {string} moduleId - Reloaded module
+     * @param {string} type - Reload type
+     */
+    _broadcastReload(moduleId, type) {
+        const message = {
+            type: 'hot-reload',
+            moduleId,
+            reloadType: type,
+            timestamp: Date.now()
+        };
+
+        for (const ws of this.connections) {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify(message));
+            }
+        }
+    }
+
+    /**
+     * Add WebSocket connection for hot reload notifications
+     * @param {WebSocket} ws - WebSocket connection
+     */
+    addConnection(ws) {
+        this.connections.add(ws);
+
+        ws.on('close', () => {
+            this.connections.delete(ws);
+        });
+    }
+
+    /**
+     * Convert file path to module ID
+     * @param {string} filePath - File path
+     */
+    _pathToModuleId(filePath) {
+        return filePath.replace(/\\/g, '/').replace(/^.*\/src\//, '');
+    }
+}
+
+/**
+ * Bun-Optimized HTTP Server
+ * Leveraging Bun.serve for maximum performance
+ */
+export class BunHTTPServer {
+    constructor(config = {}) {
+        this.config = {
+            port: config.port || 3000,
+            hostname: config.hostname || 'localhost',
+            ...config
+        };
+
+        this.routes = new Map();
+        this.middlewares = [];
+        this.hotReload = new HotReloadEngine();
+    }
+
+    /**
+     * Register a route handler
+     * @param {string} method - HTTP method
+     * @param {string} path - Route path
+     * @param {Function} handler - Route handler
+     */
+    route(method, path, handler) {
+        const key = `${method}:${path}`;
+        this.routes.set(key, handler);
+    }
+
+    /**
+     * Add middleware
+     * @param {Function} middleware - Middleware function
+     */
+    use(middleware) {
+        this.middlewares.push(middleware);
+    }
+
+    /**
+     * Start the server
+     */
+    start() {
+        const server = Bun.serve({
+            port: this.config.port,
+            hostname: this.config.hostname,
+
+            async fetch(request) {
+                const url = new URL(request.url);
+                const method = request.method;
+                const path = url.pathname;
+
+                // Apply middlewares
+                let response = null;
+                for (const middleware of this.middlewares) {
+                    response = await middleware(request, () => null);
+                    if (response) break;
+                }
+
+                if (!response) {
+                    // Find route handler
+                    const key = `${method}:${path}`;
+                    const handler = this.routes.get(key);
+
+                    if (handler) {
+                        response = await handler(request);
+                    } else {
+                        response = new Response('Not Found', { status: 404 });
+                    }
+                }
+
+                return response;
+            },
+
+            websocket: {
+                open: (ws) => {
+                    this.hotReload.addConnection(ws);
+                },
+
+                message: (ws, message) => {
+                    // Handle WebSocket messages
+                    console.log('WebSocket message:', message);
+                }
+            }
+        });
+
+        console.log(`🚀 Bun Server running on ${server.url}`);
+        return server;
+    }
+
+    /**
+     * Enable hot reloading
+     * @param {string[]} watchPaths - Paths to watch for changes
+     */
+    enableHotReload(watchPaths = ['./src']) {
+        // File watcher using Bun's native file watching
+        console.log('Hot reload not yet implemented for this Bun version');
+        // TODO: Implement when Bun.watch is available
+        /*
+        for (const watchPath of watchPaths) {
+            const watcher = Bun.watch(watchPath, {
+                persistent: true
+            });
+
+            watcher.on('change', async (event, filename) => {
+                await this.hotReload.handleFileChange(filename, event);
+            });
+        }
+        */
+    }
+}
+
+/**
+ * Bun-Native Database Connection
+ * Leveraging Bun.sql for type-safe SQLite operations
+ */
+export class BunDatabase {
+    constructor(dbPath = './afriCode.db') {
+        this.db = new Bun.sql(`${dbPath}`);
+
+        // Enable WAL mode for better concurrency
+        try {
+            this.db.query('PRAGMA journal_mode = WAL').run();
+            this.db.query('PRAGMA synchronous = NORMAL').run();
+            this.db.query('PRAGMA cache_size = 1000000').run();
+        } catch (e) {
+            // Ignore pragma errors in demo
+            console.warn('Database pragma setup failed:', e.message);
+        }
+    }
+
+    /**
+     * Execute a query with parameters
+     * @param {string} sql - SQL query
+     * @param {Array} params - Query parameters
+     */
+    query(sql, params = []) {
+        try {
+            return this.db.query(sql).all(...params);
+        } catch (e) {
+            console.warn('Query failed:', sql, e.message);
+            return [];
+        }
+    }
+
+    /**
+     * Execute a query and get first result
+     * @param {string} sql - SQL query
+     * @param {Array} params - Query parameters
+     */
+    get(sql, params = []) {
+        try {
+            return this.db.query(sql).get(...params);
+        } catch (e) {
+            console.warn('Get query failed:', sql, e.message);
+            return null;
+        }
+    }
+
+    /**
+     * Execute a mutation query
+     * @param {string} sql - SQL query
+     * @param {Array} params - Query parameters
+     */
+    run(sql, params = []) {
+        try {
+            return this.db.query(sql).run(...params);
+        } catch (e) {
+            console.warn('Run query failed:', sql, e.message);
+            return null;
+        }
+    }
+
+    /**
+     * Execute multiple queries in a transaction
+     * @param {Function} callback - Transaction callback
+     */
+    transaction(callback) {
+        return this.db.transaction(callback)();
+    }
+
+    /**
+     * Close database connection
+     */
+    close() {
+        this.db.close();
+    }
+}
+
+/**
+ * Performance Monitoring
+ * Real-time performance metrics using Bun's high-resolution timers
+ */
+export class PerformanceMonitor {
+    constructor() {
+        this.metrics = createReactiveState({
+            startupTime: 0,
+            requestCount: 0,
+            averageResponseTime: 0,
+            memoryUsage: 0,
+            activeConnections: 0
+        });
+
+        this.requestTimes = [];
+        this.startTime = performance.now();
+    }
+
+    /**
+     * Record request timing
+     * @param {number} duration - Request duration in ms
+     */
+    recordRequest(duration) {
+        this.requestTimes.push(duration);
+
+        // Keep only last 1000 requests for averaging
+        if (this.requestTimes.length > 1000) {
+            this.requestTimes.shift();
+        }
+
+        this.metrics.requestCount++;
+        this.metrics.averageResponseTime =
+            this.requestTimes.reduce((a, b) => a + b, 0) / this.requestTimes.length;
+    }
+
+    /**
+     * Update memory usage
+     */
+    updateMemoryUsage() {
+        if (typeof process !== 'undefined' && process.memoryUsage) {
+            this.metrics.memoryUsage = process.memoryUsage().heapUsed;
+        }
+    }
+
+    /**
+     * Get current metrics
+     */
+    getMetrics() {
+        this.updateMemoryUsage();
+        return { ...this.metrics };
+    }
+
+    /**
+     * Start periodic metrics collection
+     * @param {number} interval - Collection interval in ms
+     */
+    startCollection(interval = 5000) {
+        setInterval(() => {
+            this.updateMemoryUsage();
+        }, interval);
+    }
+}
+
+/**
+ * Initialize Bun-native runtime
+ */
+export function initBunRuntime(config = {}) {
+    const runtime = {
+        server: new BunHTTPServer(config.server),
+        database: config.database ? new BunDatabase(config.database.path) : null,
+        monitor: new PerformanceMonitor(),
+        hotReload: new HotReloadEngine()
+    };
+
+    // Start performance monitoring
+    runtime.monitor.startCollection();
+
+    // Enable hot reloading if in development
+    if (config.hotReload) {
+        runtime.server.enableHotReload(config.hotReload.watchPaths);
+    }
+
+    return runtime;
+}