@nitronjs/framework 0.1.0

package/lib/Http/Server.js

@@ -0,0 +1,317 @@
+import { pathToFileURL } from "node:url";
+import dotenv from "dotenv";
+import path from "node:path";
+import fastify from "fastify";
+import fastifyCors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import fastifyCookie from "@fastify/cookie";
+import fastifyHelmet from "@fastify/helmet";
+import fastifyMultipart from "@fastify/multipart";
+import Paths from "../Core/Paths.js";
+import Config from "../Core/Config.js";
+import Route from "../Route/Manager.js";
+import View from "../View/Manager.js";
+import Auth from "../Auth/Manager.js";
+import SessionManager from "../Session/Manager.js";
+import DB from "../Database/DB.js";
+import Log from "../Logging/Manager.js";
+import Loader from "../Route/Loader.js";
+
+const IS_DEV = process.env.APP_DEV === "true";
+
+class Server {
+    static #server;
+    static #serverConfigs;
+
+    static async start() {
+        dotenv.config({ quiet: true });
+        
+        // Initialize config system first (loads all configs once)
+        await Config.initialize();
+        
+        // Load project configs dynamically
+        this.#serverConfigs = Config.all("server");
+
+        await Loader.initialize();
+        
+        // Load project routes dynamically
+        await import(Paths.routeUrl("web"));
+
+        await this.#createServer();
+        await DB.setup();
+        await SessionManager.setup(this.#server);
+        Auth.setup(this.#server);
+        await Route.setup(this.#server);
+        View.setup(this.#server);
+        await this.#listen();
+    }
+
+    static async #createServer() {
+        this.#server = fastify({
+            logger: false,
+            bodyLimit: this.#serverConfigs.web_server.bodyLimit,
+            trustProxy: this.#serverConfigs.web_server.trustProxy,
+            requestIdHeader: "x-request-id",
+            exposeHeadRoutes: false,
+            requestTimeout: 60000,
+            connectionTimeout: 120000,
+            routerOptions: {
+                ignoreTrailingSlash: true,
+                maxParamLength: this.#serverConfigs.web_server.maxParamLength
+            }
+        });
+
+        this.#registerPlugins();
+        this.#registerHooks();
+        this.#registerShutdownHandlers();
+    }
+
+    static #registerPlugins() {
+        this.#server.register(fastifyCors, {
+            origin: this.#getCorsOrigin.bind(this),
+            credentials: this.#serverConfigs.cors.origin === "*" ? false : this.#serverConfigs.cors.credentials === true
+        });
+
+        this.#server.register(fastifyStatic, {
+            root: Paths.public,
+            decorateReply: false,
+            index: false
+        });
+
+        this.#server.register(fastifyCookie, {
+            secret: process.env.APP_KEY,
+            hook: "onRequest"
+        });
+
+        this.#server.register(fastifyHelmet, {
+            contentSecurityPolicy: false,
+            crossOriginEmbedderPolicy: false,
+            crossOriginOpenerPolicy: { policy: "same-origin" },
+            crossOriginResourcePolicy: { policy: "same-origin" },
+            dnsPrefetchControl: { allow: false },
+            frameguard: { action: "deny" },
+            hidePoweredBy: true,
+            hsts: !IS_DEV,
+            ieNoOpen: true,
+            noSniff: true,
+            originAgentCluster: true,
+            permittedCrossDomainPolicies: { permittedPolicies: "none" },
+            referrerPolicy: { policy: "strict-origin-when-cross-origin" },
+            xssFilter: true
+        });
+
+        this.#server.register(fastifyMultipart, {
+            limits: {
+                fieldNameSize: this.#serverConfigs.web_server.multipart.fieldNameSize,
+                fieldSize: this.#serverConfigs.web_server.multipart.fieldSize,
+                fields: this.#serverConfigs.web_server.multipart.maxFields,
+                fileSize: this.#serverConfigs.web_server.multipart.maxFileSize,
+                files: this.#serverConfigs.web_server.multipart.maxFiles,
+                parts: this.#serverConfigs.web_server.multipart.maxParts
+            },
+            attachFieldsToBody: this.#serverConfigs.web_server.multipart.attachFieldsToBody
+        });
+    }
+
+    static #getCorsOrigin(requestOrigin, cb) {
+        if (!requestOrigin) return cb(null, true);
+
+        const { origin } = this.#serverConfigs.cors;
+
+        if (origin === "*") return cb(null, true);
+
+        if (origin === "auto") {
+            const url = process.env.APP_URL;
+            const port = process.env.APP_PORT;
+            if (!url) return cb(null, false);
+
+            const appOrigin = !port || port === "80" || port === "443" ? url : `${url}:${port}`;
+            return cb(null, requestOrigin === appOrigin);
+        }
+
+        if (typeof origin === "string") return cb(null, requestOrigin === origin);
+        if (Array.isArray(origin)) return cb(null, origin.includes(requestOrigin));
+
+        return cb(null, false);
+    }
+
+    static #parseBracketNotation(data) {
+        if (!data || typeof data !== "object") {
+            return data;
+        }
+
+        const hasBrackets = Object.keys(data).some(key => key.includes("["));
+        if (!hasBrackets) {
+            return data;
+        }
+
+        const result = {};
+
+        for (const [key, value] of Object.entries(data)) {
+            if (!key.includes("[")) {
+                result[key] = value;
+                continue;
+            }
+
+            const parts = key.replace(/\]/g, "").split("[");
+            let current = result;
+
+            for (let i = 0; i < parts.length - 1; i++) {
+                const part = parts[i];
+                const nextPart = parts[i + 1];
+                const isNextIndex = /^\d+$/.test(nextPart);
+
+                if (current[part] === undefined) {
+                    current[part] = isNextIndex ? [] : {};
+                }
+
+                current = current[part];
+            }
+
+            const lastPart = parts[parts.length - 1];
+            current[lastPart] = value;
+        }
+
+        return result;
+    }
+
+    static #registerHooks() {
+        this.#server.addHook("preHandler", async (req) => {
+            if (req.isMultipart() && req.body) {
+                const normalized = {};
+                const files = {};
+
+                for (const [key, field] of Object.entries(req.body)) {
+                    if (field && typeof field === 'object') {
+                        if (field.toBuffer) {
+                            if (!field.filename) continue;
+                            
+                            files[key] = field;
+                        }
+                        else if ('value' in field) {
+                            normalized[key] = field.value;
+                        }
+                        else {
+                            normalized[key] = field;
+                        }
+                    }
+                    else {
+                        normalized[key] = field;
+                    }
+                }
+
+                req.body = this.#parseBracketNotation({ ...normalized, ...files });
+            }
+        });
+
+        this.#server.addHook("onResponse", async (req, res) => {
+            Log.info("HTTP request processed", {
+                method: req.method,
+                url: req.url,
+                statusCode: res.statusCode,
+                responseTime: `${res.elapsedTime}ms`,
+                ip: req.ip,
+                userAgent: req.headers["user-agent"] || "-",
+                referer: req.headers["referer"] || "-",
+                contentLength: res.getHeader("content-length") || "-",
+                requestId: req.id
+            });
+        });
+    }
+
+    static #registerShutdownHandlers() {
+        const shutdown = async () => {
+            const sessionManager = await SessionManager.getInstance();
+            sessionManager.stopGarbageCollection();
+            await DB.close();
+            await this.#server.close();
+            process.exit(0);
+        };
+
+        process.on("SIGTERM", shutdown);
+        process.on("SIGINT", shutdown);
+    }
+
+    static async #listen() {
+        try {
+            const url = process.env.APP_URL ? new URL(process.env.APP_URL) : null;
+            const host = url ? url.hostname : "127.0.0.1";
+            const port = Number(process.env.APP_PORT) || 3000;
+            const address = await this.#server.listen({ host, port });
+
+            this.#printBanner({ success: true, address, host, port });
+
+            Log.info("Server started successfully!", {
+                address,
+                host,
+                port,
+                environment: IS_DEV ? "development" : "production"
+            });
+        }
+        catch (err) {
+            this.#printBanner({ success: false, error: err });
+
+            Log.fatal("Server startup failed", {
+                error: err.message,
+                code: err.code,
+                stack: err.stack
+            });
+
+            process.exit(1);
+        }
+    }
+
+    static #printBanner({ success, address, host, port, error }) {
+        const { log } = this.#serverConfigs;
+        if (log.channel !== "none" && log.channel !== "file") return;
+
+        const color = success ? "\x1b[32m" : "\x1b[31m";
+        const reset = "\x1b[0m";
+        const bold = "\x1b[1m";
+        const boxWidth = 70;
+
+        const logo = `
+${color}███╗   ██╗██╗████████╗██████╗  ██████╗ ███╗   ██╗     ██╗███████╗
+████╗  ██║██║╚══██╔══╝██╔══██╗██╔═══██╗████╗  ██║     ██║██╔════╝
+██╔██╗ ██║██║   ██║   ██████╔╝██║   ██║██╔██╗ ██║     ██║███████╗
+██║╚██╗██║██║   ██║   ██╔══██╗██║   ██║██║╚██╗██║██   ██║╚════██║
+██║ ╚████║██║   ██║   ██║  ██║╚██████╔╝██║ ╚████║╚█████╔╝███████║
+╚═╝  ╚═══╝╚═╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝ ╚════╝ ╚══════╝${reset}
+`;
+
+        const stripAnsi = str => str.replace(/\x1b\[[0-9;]*m/g, "");
+        const pad = (content, length) => {
+            const visible = stripAnsi(content);
+            return content + " ".repeat(Math.max(0, length - visible.length));
+        };
+
+        const lines = success
+            ? [
+                `${color}${bold}✓${reset} ${bold}Server started successfully!${reset}`,
+                "",
+                `${bold}Address:${reset} ${address}`,
+                `${bold}Host:${reset}    ${host}`,
+                `${bold}Port:${reset}    ${port}`,
+                `${bold}Mode:${reset}    ${IS_DEV ? "development" : "production"}`
+            ]
+            : [
+                `${color}${bold}✕${reset} ${bold}Server failed to start${reset}`,
+                "",
+                `${bold}Error:${reset} ${error?.message || error}`,
+                ...(error?.code ? [`${bold}Code:${reset}  ${error.code}`] : [])
+            ];
+
+        console.log(logo);
+        console.log(`${color}┌${"─".repeat(boxWidth - 2)}┐${reset}`);
+
+        for (const line of lines) {
+            console.log(`${color}│${reset} ${pad(line, boxWidth - 4)} ${color}│${reset}`);
+        }
+
+        console.log(`${color}│${reset} ${" ".repeat(boxWidth - 4)} ${color}│${reset}`);
+        console.log(`${color}└${"─".repeat(boxWidth - 2)}┘${reset}`);
+        console.log();
+    }
+}
+
+export default Server;

package/lib/Logging/Manager.js

@@ -0,0 +1,153 @@
+import fs from "fs";
+import path from "path";
+import Config from "../Core/Config.js";
+
+class LogManager {
+    static #levels = {
+        debug: 0,
+        info: 1,
+        warn: 2,
+        error: 3,
+        fatal: 4
+    };
+
+    static debug(message, context = {}) {
+        this.#log("debug", message, context);
+    }
+
+    static info(message, context = {}) {
+        this.#log("info", message, context);
+    }
+
+    static warn(message, context = {}) {
+        this.#log("warn", message, context);
+    }
+
+    static error(message, context = {}) {
+        this.#log("error", message, context);
+    }
+
+    static fatal(message, context = {}) {
+        this.#log("fatal", message, context);
+    }
+
+    static #getConfig() {
+        return {
+            channel: Config.get("server.log.channel", "console"),
+            level: Config.get("server.log.level", "info"),
+            file: Config.get("server.log.file", "./storage/logs/app.log"),
+            sync: Config.get("server.log.sync", false)
+        };
+    }
+
+    static #log(level, message, context) {
+        try {
+            const config = this.#getConfig();
+
+            if (!this.#shouldLog(level, config)) {
+                return;
+            }
+
+            const payload = {
+                level,
+                message,
+                context,
+                timestamp: new Date().toISOString(),
+                pid: process.pid
+            };
+
+            const channel = config.channel;
+
+            if (channel === "none") {
+                return;
+            }
+
+            if (channel === "console") {
+                this.#logToConsole(payload);
+            }
+
+            if (channel === "file") {
+                this.#logToFile(payload, config);
+            }
+        } catch (e) {
+            console.error("Logger failure:", e.message);
+        }
+    }
+
+    static #shouldLog(level, config) {
+        const configLevel = config.level;
+        return this.#levels[level] >= this.#levels[configLevel];
+    }
+
+    static #logToConsole({ level, message, context, timestamp }) {
+        const colors = {
+            debug: "\x1b[90m",
+            info: "\x1b[36m",
+            warn: "\x1b[33m",
+            error: "\x1b[31m",
+            fatal: "\x1b[35m"
+        };
+
+        const icons = {
+            debug: "◆",
+            info: "●",
+            warn: "⚠",
+            error: "✕",
+            fatal: "■"
+        };
+
+        const color = colors[level] || "";
+        const icon = icons[level] || "";
+        const reset = "\x1b[0m";
+        const bold = "\x1b[1m";
+        const dim = "\x1b[2m";
+
+        const date = new Date(timestamp);
+        const time = date.toLocaleTimeString("en-US", { hour12: false });
+        const dateStr = date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+        const width = process.stdout.columns || 80;
+
+        console.log(`${color}┌${"─".repeat(width - 2)}${reset}`);
+        console.log(`${color}│${reset} ${color}${icon}${reset} ${bold}${level.toUpperCase()}${reset}`);
+        console.log(`${color}│${reset} ${dim}${dateStr} at ${time}${reset}`);
+        console.log(`${color}├${"─".repeat(width - 2)}${reset}`);
+        console.log(`${color}│${reset}`);
+        console.log(`${color}│${reset} ${bold}${message}${reset}`);
+        console.log(`${color}│${reset}`);
+
+        if (Object.keys(context).length > 0) {
+            console.log(`${color}│${reset} ${dim}Context:${reset}`);
+            const contextJson = JSON.stringify(context, null, 2);
+            contextJson.split("\n").forEach(line => {
+                console.log(`${color}│${reset} ${dim}${line}${reset}`);
+            });
+            console.log(`${color}│${reset}`);
+        }
+
+        console.log(`${color}└${"─".repeat(width - 2)}${reset}`);
+        console.log();
+    }
+
+    static #logToFile(payload, config) {
+        const filePath = path.resolve(process.cwd(), config.file);
+        const dir = path.dirname(filePath);
+
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        const logLine = JSON.stringify(payload) + "\n";
+
+        if (config.sync) {
+            fs.appendFileSync(filePath, logLine);
+        } else {
+            fs.appendFile(filePath, logLine, (err) => {
+                if (err) {
+                    console.error("Failed to write log:", err.message);
+                }
+            });
+        }
+    }
+}
+
+export default LogManager;

package/lib/Mail/Manager.js

@@ -0,0 +1,120 @@
+import nodemailer from "nodemailer";
+import ViewManager from "../View/Manager.js";
+
+class MailManager {
+    static from(email) {
+        return MailManager.#fromService(new MailManager(), email);
+    }
+
+    from(email) {
+        return MailManager.#fromService(this, email);
+    }
+
+    static to(email) {
+        return MailManager.#toService(new MailManager(), email);
+    }
+
+    to(email) {
+        return MailManager.#toService(this, email);
+    }
+
+    subject(subject) {
+        this.subject = subject;
+        return this;
+    }
+
+    attachment(attachment) {
+        if (!this.attachments) {
+            this.attachments = [];
+        }
+        this.attachments.push(attachment);
+        return this;
+    }
+
+    calendar(icsContent) {
+        this.calendarContent = icsContent;
+        return this;
+    }
+
+    text(message) {
+        this.text = message;
+        return this;
+    }
+
+    view(res, view, data = null) {
+        this.view = ViewManager.renderFile(view, data);
+        return this;
+    }
+
+    async send(transportCallback = null) {
+        let transporter;
+
+        if (typeof transportCallback === "function") {
+            const transportData = {
+                MAIL_HOST: null,
+                MAIL_PORT: null,
+                MAIL_USERNAME: null,
+                MAIL_PASSWORD: null,
+                MAIL_SECURE: null
+            };
+            transportCallback(transportData);
+            transporter = MailManager.#createTransport(transportData);
+        } else {
+            transporter = MailManager.#createTransport(process.env);
+        }
+
+        const response = await MailManager.#sendMail(this, transporter);
+        return response;
+    }
+
+    static #fromService(object, email) {
+        object.fromAddress = email;
+        return object;
+    }
+
+    static #toService(object, email) {
+        object.toAddress = email;
+        return object;
+    }
+
+    static #createTransport(transportData) {
+        return nodemailer.createTransport({
+            host: transportData.MAIL_HOST,
+            port: transportData.MAIL_PORT,
+            secure: transportData.MAIL_SECURE || false,
+            auth: {
+                user: transportData.MAIL_USERNAME,
+                pass: transportData.MAIL_PASSWORD
+            }
+        });
+    }
+
+    static async #sendMail(object, transporter) {
+        const mailOptions = {
+            from: object.fromAddress || null,
+            to: object.toAddress || null,
+            subject: object.subject || null,
+            text: object.text || null,
+            html: object.view || null,
+            attachments: object.attachments || undefined,
+            alternatives: object.calendarContent
+                ? [
+                      {
+                          contentType: 'text/calendar; method=REQUEST; charset="UTF-8"',
+                          content: object.calendarContent,
+                          component: "VEVENT",
+                          headers: {
+                              "Content-Class": "urn:content-classes:calendarmessage"
+                          }
+                      }
+                  ]
+                : undefined
+        };
+
+        const response = await transporter.sendMail(mailOptions);
+        transporter.close();
+        return response;
+    }
+}
+
+export default MailManager;

package/lib/Route/Loader.js

@@ -0,0 +1,81 @@
+import path from "path";
+import fs from "fs";
+import Paths from "../Core/Paths.js";
+
+const IS_DEV = process.env.APP_DEV === "true";
+
+const DIRECTORIES = [
+    Paths.controllers,
+    Paths.middlewares
+];
+
+class Loader {
+    #registry = new Map();
+    #initialized = false;
+
+    async initialize() {
+        if (this.#initialized || !IS_DEV) return;
+
+        for (const dir of DIRECTORIES) {
+            await this.#loadDirectory(dir);
+        }
+
+        this.#initialized = true;
+    }
+
+    wrapHandler(handler) {
+        if (!IS_DEV) return handler;
+
+        const info = this.#registry.get(handler);
+        if (!info) return handler;
+
+        const { filePath, methodName } = info;
+
+        return async (request, response, param) => {
+            const module = await import(`file://${filePath}?t=${Date.now()}`);
+            return module.default[methodName](request, response, param);
+        };
+    }
+
+    async #loadDirectory(dir) {
+        if (!fs.existsSync(dir)) return;
+
+        for (const filePath of this.#getJsFiles(dir)) {
+            try {
+                const module = await import(`file://${filePath}`);
+                const Class = module.default;
+
+                if (!Class || typeof Class !== "function") continue;
+
+                for (const name of Object.getOwnPropertyNames(Class)) {
+                    if (typeof Class[name] === "function" && !["length", "name", "prototype"].includes(name)) {
+                        this.#registry.set(Class[name], { filePath, methodName: name });
+                    }
+                }
+            }
+            catch {
+                //
+            }
+        }
+    }
+
+    #getJsFiles(dir) {
+        const files = [];
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+
+            if (entry.isDirectory()) {
+                files.push(...this.#getJsFiles(fullPath));
+            }
+            else if (entry.name.endsWith(".js")) {
+                files.push(fullPath);
+            }
+        }
+
+        return files;
+    }
+}
+
+export default new Loader();