@nitronjs/framework 0.2.2 → 0.2.4

package/lib/Database/Connection.js

@@ -1,61 +0,0 @@
-class Connection {
-    #driver = null;
-    #name = null;
-    
-    constructor(name, driver) {
-        this.#name = name;
-        this.#driver = driver;
-    }
-
-    async query(sql, bindings = []) {
-        return await this.#driver.query(sql, bindings);
-    }
-
-    async raw(sql) {
-        return await this.#driver.raw(sql);
-    }
-
-    async withTransaction(callback, options = {}) {
-        const timeout = options.timeout || 30000; // 30 seconds default
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => {
-            controller.abort();
-        }, timeout);
-
-        try {
-            const result = await this.#driver.withTransaction(callback, {
-                signal: controller.signal
-            });
-
-            clearTimeout(timeoutId);
-            return result;
-        } catch (err) {
-            clearTimeout(timeoutId);
-            if (controller.signal.aborted) {
-                throw new Error(
-                    `Transaction timeout after ${timeout}ms. ` +
-                    'This may indicate a forgotten await in the callback or a slow query. ' +
-                    'Consider: 1) Adding await to all async operations, 2) Increasing timeout, 3) Optimizing queries.'
-                );
-            }
-
-            throw err;
-        }
-    }
-
-    async healthCheck() {
-        return await this.#driver.healthCheck();
-    }
-
-    getName() {
-        return this.#name;
-    }
-
-    async close() {
-        if (this.#driver && typeof this.#driver.close === 'function') {
-            await this.#driver.close();
-        }
-    }
-}
-
-export default Connection;

package/lib/Database/Manager.js

@@ -1,162 +0,0 @@
-import Connection from './Connection.js';
-import MySQLDriver from './Drivers/MySQLDriver.js';
-import Config from '../Core/Config.js';
-
-class DatabaseManager {
-
-    static instance = null;
-    static #isInternal = false;
-
-    #connections = new Map();
-    #defaultConnection = null;
-    #config = null;
-    #credentials = null;
-
-    constructor() {
-        if (!DatabaseManager.#isInternal) {
-            throw new Error('DatabaseManager must be initialized with await DatabaseManager.getInstance()');
-        }
-    }
-
-    static createInstance() {
-        DatabaseManager.#isInternal = true;
-        const instance = new DatabaseManager();
-        DatabaseManager.#isInternal = false;
-        
-        instance.#config = Config.all('database');
-        instance.#initializeDefaultConnection();
-        return instance;
-    }
-
-    #initializeDefaultConnection() {
-        const envDriver = (process.env.DATABASE_DRIVER || 'mysql').toLowerCase();
-        const normalized = envDriver === 'postgresql' ? 'postgres' : envDriver;
-
-        this.#defaultConnection = normalized === 'none' ? null : normalized;
-    }
-
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = DatabaseManager.createInstance();
-        }
-
-        return this.instance;
-    }
-
-    // ========================================
-    // Connection Management
-    // ========================================
-
-    connection(name = null) {
-        const connectionName = name || this.#defaultConnection;
-
-        if (!connectionName) {
-            throw new Error('Database is disabled (DATABASE_DRIVER=none)');
-        }
-
-        if (this.#connections.has(connectionName)) {
-            return this.#connections.get(connectionName);
-        }
-
-        const config = this.#config.connections[connectionName];
-
-        if (!config) {
-            throw new Error(`Database connection '${connectionName}' is not configured`);
-        }
-
-        return this.#addConnection(connectionName, config);
-    }
-
-    #addConnection(name, config) {
-        const driver = this.#createDriver(config);
-        const connection = new Connection(name, driver);
-
-        this.#connections.set(name, connection);
-
-        return connection;
-    }
-
-    #createDriver(config) {
-        switch (config.driver) {
-            case 'mysql':
-                return new MySQLDriver(config, this.#credentials);
-
-            case 'postgres':
-                throw new Error('Postgres driver not yet implemented');
-
-            case 'mongodb':
-                throw new Error('MongoDB driver not yet implemented');
-
-            default:
-                throw new Error(`Unknown database driver: ${config.driver}`);
-        }
-    }
-
-    // ========================================
-    // Reconfiguration (for Installer)
-    // ========================================
-
-    /**
-     * Reconfigure database with new credentials
-     * Closes existing connections and creates new pool with provided credentials
-     */
-    async reconfigure(credentials) {
-        await this.closeAll();
-
-        this.#credentials = {
-            host: credentials.host,
-            port: String(credentials.port),
-            database: credentials.database,
-            username: credentials.username,
-            password: credentials.password || ""
-        };
-
-        this.#defaultConnection = "mysql";
-    }
-
-    // ========================================
-    // Query & Health
-    // ========================================
-
-    async query(sql, bindings = []) {
-        return await this.connection().query(sql, bindings);
-    }
-
-    async healthCheck() {
-        const results = {};
-
-        for (const [name, connection] of this.#connections.entries()) {
-            try {
-                results[name] = await connection.healthCheck();
-            }
-            catch (error) {
-                results[name] = false;
-            }
-        }
-
-        return results;
-    }
-
-    // ========================================
-    // Lifecycle
-    // ========================================
-
-    async closeAll() {
-        for (const [name, connection] of this.#connections.entries()) {
-            try {
-                await connection.close();
-            }
-            catch (error) {
-                // Ignore close errors
-            }
-        }
-
-        this.#connections.clear();
-    }
-
-    getDefaultConnection() {
-        return this.#defaultConnection;
-    }
-}
-
-export default DatabaseManager;

package/lib/Database/Migration/migrations/0000_00_00_00_01_create_seeders_table.js

@@ -1,20 +0,0 @@
-import Schema from "../../Schema/Manager.js";
-
-class CreateSeedersTable {
-
-    static async up() {
-        await Schema.create("seeders", (table) => {
-            table.id();
-            table.string("name").unique();
-            table.string("checksum", 64);
-            table.timestamp("executed_at");
-        });
-    }
-
-    static async down() {
-        await Schema.dropIfExists("seeders");
-    }
-
-}
-
-export default CreateSeedersTable;

package/lib/Database/Seeder/SeederRepository.js

@@ -1,45 +0,0 @@
-import DB from "../DB.js";
-
-class SeederRepository {
-
-    static table = 'seeders';
-
-    static async tableExists() {
-        const [rows] = await DB.rawQuery(`SHOW TABLES LIKE '${this.table}'`);
-        return rows.length > 0;
-    }
-
-    static async getExecuted() {
-        if (!await this.tableExists()) return [];
-        return await DB.table(this.table).orderBy("id", "asc").get();
-    }
-
-    static async getExecutedNames() {
-        const seeders = await this.getExecuted();
-        return new Set(seeders.map(s => s.name));
-    }
-
-    static async log(name, checksum) {
-        await DB.table(this.table).insert({
-            name,
-            checksum,
-            executed_at: new Date()
-        });
-    }
-
-    static async find(name) {
-        return await DB.table(this.table).where("name", name).first();
-    }
-
-    static async exists(name) {
-        return (await this.find(name)) !== null;
-    }
-
-    static async getChecksum(name) {
-        const seeder = await this.find(name);
-        return seeder?.checksum || null;
-    }
-
-}
-
-export default SeederRepository;

package/lib/Encryption/Manager.js

@@ -1,47 +0,0 @@
-import crypto from "crypto";
-
-class EncryptionManager {
-    static encrypt(value) {
-        if (typeof value === "object") {
-            value = JSON.stringify(value);
-        }
-
-        const secretKey = this.#createSecretKey();
-        const iv = this.#createIV();
-
-        const cipher = crypto.createCipheriv("aes-256-cbc", secretKey, iv);
-        let encrypted = cipher.update(value, "utf8", "hex");
-        encrypted += cipher.final("hex");
-        encrypted = iv.toString("hex") + ":" + encrypted;
-
-        return encrypted;
-    }
-
-    static decrypt(encryptedValue) {
-        try {
-            const parts = encryptedValue.split(":");
-            const iv = Buffer.from(parts.shift(), "hex");
-            const encryptedText = Buffer.from(parts.join(":"), "hex");
-
-            const secretKey = this.#createSecretKey();
-
-            const decipher = crypto.createDecipheriv("aes-256-cbc", secretKey, iv);
-            let decrypted = decipher.update(encryptedText, "hex", "utf8");
-            decrypted += decipher.final("utf8");
-
-            return decrypted;
-        } catch (error) {
-            return false;
-        }
-    }
-
-    static #createSecretKey() {
-        return crypto.createHash("sha256").update(process.env.APP_KEY).digest();
-    }
-
-    static #createIV() {
-        return crypto.randomBytes(16);
-    }
-}
-
-export default EncryptionManager;

package/lib/Filesystem/Manager.js

@@ -1,74 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import Paths from "../Core/Paths.js";
-
-class FilesystemManager {
-    static #publicRoot = Paths.storagePublic;
-    static #privateRoot = Paths.storagePrivate;
-
-    /**
-     * Validate path to prevent directory traversal attacks
-     * @throws Error if path escapes base directory
-     */
-    static #validatePath(base, filePath) {
-        const normalizedBase = path.normalize(base) + path.sep;
-        const fullPath = path.normalize(path.join(base, filePath));
-        
-        if (!fullPath.startsWith(normalizedBase)) {
-            throw new Error("Invalid file path: directory traversal detected");
-        }
-        
-        return fullPath;
-    }
-
-    static async get(filePath, isPrivate = false) {
-        const base = isPrivate ? this.#privateRoot : this.#publicRoot;
-        
-        try {
-            const fullPath = this.#validatePath(base, filePath);
-            return await fs.promises.readFile(fullPath);
-        } catch (err) {
-            if (err.message.includes("directory traversal")) throw err;
-            return null;
-        }
-    }
-
-    static async put(file, dir, fileName, isPrivate = false) {
-        const base = isPrivate ? this.#privateRoot : this.#publicRoot;
-        
-        // Validate both dir and fileName
-        const folderPath = this.#validatePath(base, dir);
-        const fullPath = this.#validatePath(base, path.join(dir, fileName));
-
-        await fs.promises.mkdir(folderPath, { recursive: true });
-        await fs.promises.writeFile(fullPath, file._buf);
-
-        return true;
-    }
-
-    static async delete(filePath, isPrivate = false) {
-        const base = isPrivate ? this.#privateRoot : this.#publicRoot;
-        const fullPath = this.#validatePath(base, filePath);
-        await fs.promises.unlink(fullPath);
-    }
-
-    static exists(filePath, isPrivate = false) {
-        const base = isPrivate ? this.#privateRoot : this.#publicRoot;
-        
-        try {
-            const fullPath = this.#validatePath(base, filePath);
-            return fs.existsSync(fullPath);
-        } catch {
-            return false;
-        }
-    }
-
-    static url(filePath) {
-        if (filePath.startsWith("/")) {
-            filePath = filePath.substring(1);
-        }
-        return `/storage/${filePath}`;
-    }
-}
-
-export default FilesystemManager;

package/lib/Hashing/Manager.js

@@ -1,25 +0,0 @@
-import bcrypt from "bcrypt";
-import Config from "../Core/Config.js";
-
-class HashManager {
-    static async make(textField) {
-        if (!process.env.APP_KEY) {
-            throw new Error("APP_KEY is required for hashing");
-        }
-
-        const saltRounds = Config.get("hash.salt_rounds", 10);
-        const salt = await bcrypt.genSalt(saltRounds);
-
-        return await bcrypt.hash(textField + process.env.APP_KEY, salt);
-    }
-
-    static async check(textField, hashedText) {
-        if (!process.env.APP_KEY) {
-            throw new Error("APP_KEY is required for hashing");
-        }
-
-        return await bcrypt.compare(textField + process.env.APP_KEY, hashedText);
-    }
-}
-
-export default HashManager;

package/lib/Mail/Manager.js

@@ -1,120 +0,0 @@
-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

@@ -1,80 +0,0 @@
-import path from "path";
-import fs from "fs";
-import Paths from "../Core/Paths.js";
-import Environment from "../Core/Environment.js";
-
-const DIRECTORIES = [
-    Paths.controllers,
-    Paths.middlewares
-];
-
-class Loader {
-    #registry = new Map();
-    #initialized = false;
-
-    async initialize() {
-        if (this.#initialized || !Environment.isDev) return;
-
-        for (const dir of DIRECTORIES) {
-            await this.#loadDirectory(dir);
-        }
-
-        this.#initialized = true;
-    }
-
-    wrapHandler(handler) {
-        if (!Environment.isDev) 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();