{% extends "layouts/main.html" %} {% block title %}{{ t(key="feat.page_title", default="Features") }} — FuzionX Framework{% endblock %} {% block description %}{{ t(key="feat.meta_desc", default="Explore FuzionX features: Rust N-API Bridge, Multi-DB ORM, WebSocket, Task Queue, and more.") }}{% endblock %} {% block content %}
📖 {{ t(key="feat.badge", default="Framework Features") }}

{{ t(key="feat.header_title_1", default="Built for") }} {{ t(key="feat.header_title_2", default="Production") }}

{{ t(key="feat.header_sub", default="Every feature designed for performance, developer experience, and enterprise readiness.") }}

⚡

{{ t(key="feat.bridge_title", default="Rust N-API Bridge") }}

{{ t(key="feat.bridge_sub", default="Native performance for core operations — no JavaScript overhead.") }}

500K+ RPS

{{ t(key="feat.bridge_rps", default="The HTTP engine runs entirely in Rust through N-API, delivering throughput that JavaScript-based servers cannot match. Request parsing, routing, and response serialization happen at native speed.") }}

{{ t(key="feat.bridge_zerocopy", default="Zero-Copy File Uploads") }}

{{ t(key="feat.bridge_zerocopy_desc", default="Multipart parsing happens in Rust. Files are written directly to disk — the file buffer never enters JavaScript memory, making large file uploads safe and efficient.") }}

{{ t(key="feat.bridge_crypto", default="Native Crypto") }}

{{ t(key="feat.bridge_crypto_desc", default="bcrypt, argon2id, AES-256-GCM, SHA-256, MD5, UUID v4 — all executed in Rust. No crypto module overhead, no C++ addon compilation issues.") }}

{{ t(key="feat.bridge_media", default="Media Processing") }}

{{ t(key="feat.bridge_media_desc", default="Image resizing (Lanczos3), WebP conversion, and video thumbnail extraction powered by Rust image crate and ffmpeg bindings.") }}

{{ t(key="feat.bridge_code_title", default="Native Performance — Zero JS Overhead") }} 
// All these operations run in Rust — no JS overhead
const hash = app.hash.argon2(password);           // Rust argon2id
const id   = app.crypto.uuid();                   // Rust UUID v4
const enc  = app.crypto.encrypt(key, plaintext);   // Rust AES-256-GCM
app.media.resize(input, output, 800, 600, 'webp'); // Rust image crate
🗄️

{{ t(key="feat.orm_title", default="Multi-Database ORM") }}

{{ t(key="feat.orm_sub", default="One API for MariaDB, PostgreSQL, and MongoDB. Model = Schema = Single source of truth.") }}

{{ t(key="feat.orm_unified", default="Unified Query API") }}

{{ t(key="feat.orm_unified_desc", default="Write User.where('active', true).paginate(1, 20) and it works across all databases. No database-specific code needed for CRUD operations.") }}

{{ t(key="feat.orm_schema", default="Model-Based Schema Sync") }}

{{ t(key="feat.orm_schema_desc", default="Define columns in the model with static columns, then run fx db:sync. No more writing migration files — the model IS the schema.") }}

{{ t(key="feat.orm_relations", default="Relationships") }}

{{ t(key="feat.orm_relations_desc", default="hasMany, hasOne, belongsTo, belongsToMany — define relations as methods. Eager loading with .with('posts.comments').") }}

{{ t(key="feat.orm_access", default="3-Level Access") }}

{{ t(key="feat.orm_access_desc", default="Unified API for 99% of cases → Raw Query for DB-specific features → Native driver access when you need full control.") }}

models/User.js 
import { Model } from '@fuzionx/framework';

export default class User extends Model {
    static table = 'users';
    static timestamps = true;

    static columns = {
        id:    { type: 'increments' },
        name:  { type: 'string', length: 100 },
        email: { type: 'string', length: 150, unique: true },
    };

    posts()   { return this.hasMany('Post'); }
    profile() { return this.hasOne('Profile'); }
}
🎨

{{ t(key="feat.ssr_title", default="SSR + SPA Hybrid") }}

{{ t(key="feat.ssr_sub", default="Server-rendered pages and single-page apps in one project with domain routing.") }}

{{ t(key="feat.ssr_tera", default="Tera Template Engine") }}

{{ t(key="feat.ssr_tera_desc", default="Jinja2-compatible template engine compiled in Rust. Layouts, blocks, inheritance, filters, and macros for fast SSR rendering.") }}

{{ t(key="feat.ssr_theme", default="Theme System") }}

{{ t(key="feat.ssr_theme_desc", default="Multiple view themes with views/{theme}/ structure. Switch themes via config without changing any controller code.") }}

{{ t(key="feat.ssr_multiapp", default="Multi-App Routing") }}

{{ t(key="feat.ssr_multiapp_desc", default="Route different domains to different apps: api.example.com → spa, www.example.com → ssr. One codebase, multiple frontends.") }}

{{ t(key="feat.ssr_i18n", default="Built-in i18n") }}

{{ t(key="feat.ssr_i18n_desc", default="JSON-based translations with auto-detection, fallback locales, and missing key auto-complete.") }} ctx.t('key') / {{ "{{" }} t(key="...") }}

🔌

{{ t(key="feat.ws_title", default="Real-time WebSocket") }}

{{ t(key="feat.ws_sub", default="Namespace-based event routing with rooms, middleware sharing, and multi-server Hub.") }}

{{ t(key="feat.ws_dsl", default="Event Routing DSL") }}

{{ t(key="feat.ws_dsl_desc", default="static events(e) declares event → handler mappings, just like controller routes. Clean, declarative, and auto-scanned from ws/ folder.") }}

{{ t(key="feat.ws_rooms", default="Rooms") }}

{{ t(key="feat.ws_rooms_desc", default="socket.join('room:123'), socket.to('room:123').send({...}) — built-in room management without external libraries.") }}

{{ t(key="feat.ws_middleware", default="Middleware Sharing") }}

{{ t(key="feat.ws_middleware_desc", default="Reuse the same HTTP middleware for WebSocket handshake. Auth middleware works for both HTTP and WS connections.") }}

{{ t(key="feat.ws_hub", default="Hub Broadcasting") }}

{{ t(key="feat.ws_hub_desc", default="Multi-server? Just add { hub: true } to broadcast. Messages route through Hub server to all connected instances.") }}

ws/ChatHandler.js 
import { WsHandler } from '@fuzionx/framework';

export default class ChatHandler extends WsHandler {
    static namespace = '/chat';
    static middleware = ['auth'];

    static events(e) {
        e.on('chat',   this.handleChat);
        e.on('typing', this.handleTyping);
    }

    handleChat(socket, data) {
        socket.to(`room:${data.roomId}`).send({
            type: 'chat',
            data: { user: socket.user, message: data.message }
        });
    }
}
{{ t(key="feat.btn_try_chat", default="Try Live Chat Demo →") }}
⏰

{{ t(key="feat.queue_title", default="Task Queue + Workers") }}

{{ t(key="feat.queue_sub", default="Three ways to handle background work — scheduled, queued, and CPU-isolated.") }}

📅 {{ t(key="feat.queue_scheduled", default="Scheduled Jobs") }}

{{ t(key="feat.queue_scheduled_desc", default="Cron-based recurring tasks. static schedule = 'daily:02:00'. Runs on master process with Redis distributed lock for multi-server.") }}

📬 {{ t(key="feat.queue_queued", default="Queued Tasks") }}

{{ t(key="feat.queue_queued_desc", default="Async dispatch with retries: app.dispatch('SendEmail', data). Memory or Redis backend. Failed tasks call failed() hook.") }}

🧵 WorkerPool

{{ t(key="feat.queue_worker_desc", default="CPU-heavy work in worker_threads: app.worker.run('csv-parser', data). Prevents event loop blocking. Timeout + auto-cleanup.") }}

jobs/SendWelcomeEmail.js 
import { Task } from '@fuzionx/framework';

export default class SendWelcomeEmail extends Task {
    static queue   = 'emails';
    static retries = 3;

    async handle(data) {
        const user = await this.db.User.find(data.userId);
        await this.service('MailService').sendWelcome(user.email);
    }

    async failed(data, error) {
        this.logger.error('Email failed', { userId: data.userId });
    }
}
🔐

{{ t(key="feat.sec_title", default="Enterprise Security") }}

{{ t(key="feat.sec_sub", default="Production-grade security built into every layer — from wire encryption to password hashing.") }}

{{ t(key="feat.sec_asp", default="ASP Wire Encryption") }}

{{ t(key="feat.sec_asp_desc", default="FuzionX Stealth Protocol encrypts all HTTP request/response bodies on the wire. Transparent to application code, impenetrable to MITM attacks.") }}

{{ t(key="feat.sec_hash", default="Native Password Hashing") }}

{{ t(key="feat.sec_hash_desc", default="bcrypt (cost 12) and argon2id hashing in Rust — orders of magnitude faster than JavaScript implementations with the same security guarantees.") }}

{{ t(key="feat.sec_session", default="Session + JWT Auth") }}

{{ t(key="feat.sec_session_desc", default="File-based or Redis session store. JWT access/refresh token rotation. Built-in auth() middleware with route guards.") }}

{{ t(key="feat.sec_rate", default="Rate Limiting + CSRF") }}

{{ t(key="feat.sec_rate_desc", default="Per-IP rate limiting in the Rust bridge layer. CSRF token generation and validation. IP whitelist/blacklist. HSTS and CSP headers.") }}

🛠️

{{ t(key="feat.dx_title", default="Developer Experience") }}

{{ t(key="feat.dx_sub", default="CLI scaffolding, auto-scanning, hot reload, OpenAPI docs — everything to keep you productive.") }}

{{ t(key="feat.dx_cli", default="CLI Code Generator") }}

{{ t(key="feat.dx_cli_desc", default="fx make:controller, fx make:model, fx make:service — scaffold any component instantly with proper boilerplate.") }}

{{ t(key="feat.dx_autoscan", default="Auto-Scanning") }}

{{ t(key="feat.dx_autoscan_desc", default="Drop a file in controllers/, services/, ws/, or jobs/ — the framework discovers and registers it automatically. Zero manual wiring.") }}

{{ t(key="feat.dx_openapi", default="OpenAPI Auto-Generation") }}

{{ t(key="feat.dx_openapi_desc", default="Swagger UI at /docs with zero configuration. Route definitions are automatically converted to OpenAPI 3.0 spec.") }}

{{ t(key="feat.dx_test", default="Testing Helpers") }}

{{ t(key="feat.dx_test_desc", default="In-process HTTP test client, database transaction rollbacks, isolated test contexts. vitest integration out of the box.") }}

Terminal 
$ npx create-fuzionx my-app
$ cd my-app
$ fx make:controller User     # → controllers/UserController.js
$ fx make:model User          # → models/User.js
$ fx make:service User        # → services/UserService.js
$ fx db:sync --apply          # → Schema synced ✓
$ fx dev                       # → 🚀 Running on http://localhost:3000

{{ t(key="feat.cta_title_1", default="Start Building") }} {{ t(key="feat.cta_title_2", default="Today") }}

{{ t(key="feat.cta_sub", default="One command to scaffold. Zero configuration to start.") }}

npx create-fuzionx my-app
← {{ t(key="feat.btn_back", default="Back to Home") }} {{ t(key="feat.btn_chat", default="Try Chat Demo") }}
{% endblock %}