@nitronjs/framework 0.1.0

package/lib/Database/QueryValidation.js

@@ -0,0 +1,62 @@
+export function validateIdentifier(identifier) {
+    if (typeof identifier !== 'string' || identifier.length === 0) {
+        throw new Error('Identifier must be a non-empty string');
+    }
+
+    if (identifier.length > 64) {
+        throw new Error(`Invalid identifier: "${identifier}". Maximum length is 64 characters.`);
+    }
+
+    if (identifier === '*' || identifier === '*.*') {
+        return identifier;
+    }
+
+    if (/--|#|\/\*|\*\//.test(identifier)) {
+        throw new Error(`Invalid identifier: "${identifier}". SQL comments are not allowed.`);
+    }
+
+    const patterns = [
+        /^[a-zA-Z_][a-zA-Z0-9_]*$/,
+        /^[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*$/,
+        /^[a-zA-Z_][a-zA-Z0-9_]*\.\*$/
+    ];
+
+    const isValid = patterns.some(pattern => pattern.test(identifier));
+
+    if (!isValid) {
+        throw new Error(`Invalid identifier: "${identifier}". Must be alphanumeric with underscores, optionally qualified with table name.`);
+    }
+
+    return identifier;
+}
+
+export function validateWhereOperator(operator) {
+    const normalized = String(operator).trim().toUpperCase();
+    const allowedOperators = new Set([
+        '=', '!=', '<>', '<', '>', '<=', '>=',
+        'LIKE', 'NOT LIKE', 'ILIKE', 'NOT ILIKE',
+        'IN', 'NOT IN',
+        'IS', 'IS NOT',
+        'BETWEEN', 'NOT BETWEEN',
+        'REGEXP', 'NOT REGEXP',
+        'RLIKE', 'NOT RLIKE'
+    ]);
+
+    if (!allowedOperators.has(normalized)) {
+        throw new Error(
+            `Invalid WHERE operator: '${operator}'. ` +
+            `Allowed operators: ${[...allowedOperators].join(', ')}`
+        );
+    }
+
+    return normalized;
+}
+
+export function validateDirection(direction) {
+    const upper = String(direction).toUpperCase();
+    if (upper !== 'ASC' && upper !== 'DESC') {
+        throw new Error(`Invalid direction: ${direction}. Use 'ASC' or 'DESC'.`);
+    }
+
+    return upper;
+}

package/lib/Database/Schema/Blueprint.js

@@ -0,0 +1,126 @@
+/**
+ * Blueprint - Table schema builder
+ * Laravel-style fluent API for defining database tables
+ */
+class Blueprint {
+    #tableName;
+    #columns = [];
+
+    constructor(tableName) {
+        this.#tableName = tableName;
+    }
+
+    /**
+     * Get table name
+     */
+    getTableName() {
+        return this.#tableName;
+    }
+
+    /**
+     * Get all columns
+     */
+    getColumns() {
+        return this.#columns;
+    }
+
+    /**
+     * Add a column definition
+     */
+    #addColumn(type, name, options = {}) {
+        const column = {
+            name,
+            type,
+            ...options,
+            modifiers: {
+                nullable: false,
+                default: null,
+                unique: false
+            }
+        };
+
+        this.#columns.push(column);
+
+        // Return modifier object for chaining
+        return {
+            nullable: () => {
+                column.modifiers.nullable = true;
+                return this;
+            },
+            default: (value) => {
+                column.modifiers.default = value;
+                return this;
+            },
+            unique: () => {
+                column.modifiers.unique = true;
+                return this;
+            }
+        };
+    }
+
+    /**
+     * Primary key: BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY
+     */
+    id() {
+        const column = {
+            name: 'id',
+            type: 'id',
+            modifiers: {}
+        };
+        this.#columns.push(column);
+        
+        // No chaining for id()
+        return this;
+    }
+
+    /**
+     * VARCHAR column
+     */
+    string(name, length = 255) {
+        return this.#addColumn('string', name, { length });
+    }
+
+    /**
+     * TEXT column
+     */
+    text(name) {
+        return this.#addColumn('text', name);
+    }
+
+    /**
+     * INT column
+     */
+    integer(name) {
+        return this.#addColumn('integer', name);
+    }
+
+    /**
+     * BIGINT column
+     */
+    bigInteger(name) {
+        return this.#addColumn('bigInteger', name);
+    }
+
+    /**
+     * TINYINT(1) column for boolean values
+     */
+    boolean(name) {
+        return this.#addColumn('boolean', name);
+    }
+
+    /**
+     * TIMESTAMP column
+     */
+    timestamp(name) {
+        return this.#addColumn('timestamp', name);
+    }
+
+    /**
+     * JSON column
+     */
+    json(name) {
+        return this.#addColumn('json', name);
+    }
+}
+
+export default Blueprint;

package/lib/Database/Schema/Manager.js

@@ -0,0 +1,116 @@
+import DatabaseManager from "../Manager.js";
+import Config from "../../Core/Config.js";
+
+/**
+ * Schema Builder
+ * Laravel-style database schema operations
+ */
+export default class Schema {
+    /**
+     * Create a new table
+     */
+    static async create(tableName, callback) {
+        const blueprint = new (await import('./Blueprint.js')).default(tableName);
+        callback(blueprint);
+        
+        const sql = this.#buildCreateTableSQL(blueprint);
+        
+        const connection = DatabaseManager.getInstance().connection();
+        await connection.raw(sql);
+    }
+    
+    /**
+     * Drop table if exists
+     */
+    static async dropIfExists(tableName) {
+        const connection = DatabaseManager.getInstance().connection();
+        await connection.raw(`DROP TABLE IF EXISTS \`${tableName}\``);
+    }
+    
+    /**
+     * Build CREATE TABLE SQL
+     */
+    static #buildCreateTableSQL(blueprint) {
+        const columns = blueprint.getColumns();
+        const columnsSql = columns.map(col => this.#buildColumnSQL(col));
+        
+        // Get connection config
+        const manager = DatabaseManager.getInstance();
+        const connection = manager.connection();
+        const connectionName = connection.getName();
+        const databaseConfig = Config.all('database');
+        const dbConfig = databaseConfig.connections[connectionName];
+        
+        const charset = dbConfig.charset || 'utf8mb4';
+        const collation = dbConfig.collation || 'utf8mb4_unicode_ci';
+        
+        let sql = `CREATE TABLE \`${blueprint.getTableName()}\` (\n`;
+        sql += '    ' + columnsSql.join(',\n    ');
+        sql += `\n) ENGINE=InnoDB DEFAULT CHARSET=${charset} COLLATE=${collation}`;
+        
+        return sql;
+    }
+    
+    /**
+     * Build SQL for a single column
+     */
+    static #buildColumnSQL(column) {
+        let sql = `\`${column.name}\` `;
+        
+        // Type
+        switch (column.type) {
+            case 'id':
+                // id is special - no modifiers
+                sql += 'BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY';
+                return sql;
+            case 'string':
+                sql += `VARCHAR(${column.length || 255})`;
+                break;
+            case 'text':
+                sql += 'TEXT';
+                break;
+            case 'integer':
+                sql += 'INT';
+                break;
+            case 'bigInteger':
+                sql += 'BIGINT';
+                break;
+            case 'boolean':
+                sql += 'TINYINT(1)';
+                break;
+            case 'timestamp':
+                sql += 'TIMESTAMP';
+                break;
+            case 'json':
+                sql += 'JSON';
+                break;
+            default:
+                throw new Error(`Unknown column type: ${column.type}`);
+        }
+        
+        // Modifiers (not for id)
+        if (column.modifiers) {
+            // NOT NULL / NULL
+            if (column.modifiers.nullable) {
+                sql += ' NULL';
+            } else {
+                sql += ' NOT NULL';
+            }
+            
+            // DEFAULT
+            if (column.modifiers.default !== null) {
+                const defaultValue = typeof column.modifiers.default === 'string'
+                    ? `'${column.modifiers.default}'`
+                    : column.modifiers.default;
+                sql += ` DEFAULT ${defaultValue}`;
+            }
+            
+            // UNIQUE
+            if (column.modifiers.unique) {
+                sql += ' UNIQUE';
+            }
+        }
+        
+        return sql;
+    }
+}

package/lib/Date/DateTime.js

@@ -0,0 +1,108 @@
+import locale from './Locale.js';
+import Config from '../Core/Config.js';
+
+class DateTime {
+    static #getDate(date = null) {
+        const timezone = Config.get('app.timezone', 'UTC');
+        const d = date ? new Date(date) : new Date();
+        
+        return new Date(d.toLocaleString('en-US', { timeZone: timezone }));
+    }
+    
+    static #format(date, formatString) {
+        const lang = locale[Config.get('app.locale', 'en')] || locale.en;
+        const pad = (n) => String(n).padStart(2, '0');
+        
+        const map = {
+            'Y': date.getFullYear(),
+            'y': String(date.getFullYear()).slice(-2),
+            'm': pad(date.getMonth() + 1),
+            'n': date.getMonth() + 1,
+            'd': pad(date.getDate()),
+            'j': date.getDate(),
+            'H': pad(date.getHours()),
+            'i': pad(date.getMinutes()),
+            's': pad(date.getSeconds()),
+            'D': lang.days[date.getDay()],
+            'l': lang.daysShort[date.getDay()],
+            'M': lang.months[date.getMonth()],
+            'F': lang.monthsShort[date.getMonth()]
+        };
+        
+        return formatString.replace(/[YynmdjHislDMF]/g, match => map[match]);
+    }
+    
+    /**
+     * Get current date/time in SQL format
+     * @param {number|null} timestamp - Optional timestamp
+     * @returns {string} SQL formatted datetime (YYYY-MM-DD HH:mm:ss)
+     */
+    static toSQL(timestamp = null) {
+        const d = timestamp ? new Date(timestamp) : this.#getDate();
+        return d.toISOString().slice(0, 19).replace('T', ' ');
+    }
+    
+    /**
+     * Get timestamp in milliseconds
+     * @param {string|null} sqlDateTime - Optional SQL datetime string
+     * @returns {number} Timestamp in milliseconds
+     */
+    static getTime(sqlDateTime = null) {
+        if (sqlDateTime === null) {
+            return this.#getDate().getTime();
+        }
+        return new Date(sqlDateTime).getTime();
+    }
+    
+    /**
+     * Get formatted date
+     * @param {number|null} timestamp - Optional timestamp
+     * @param {string} format - Date format string
+     * @returns {string} Formatted date
+     */
+    static getDate(timestamp = null, format = 'Y-m-d H:i:s') {
+        return this.#format(this.#getDate(timestamp), format);
+    }
+    
+    /**
+     * Add days to current date
+     * @param {number} days - Number of days to add
+     * @returns {string} SQL formatted datetime
+     */
+    static addDays(days) {
+        const date = this.#getDate();
+        date.setDate(date.getDate() + days);
+        return date.toISOString().slice(0, 19).replace('T', ' ');
+    }
+    
+    /**
+     * Add hours to current date
+     * @param {number} hours - Number of hours to add
+     * @returns {string} SQL formatted datetime
+     */
+    static addHours(hours) {
+        const date = this.#getDate();
+        date.setHours(date.getHours() + hours);
+        return date.toISOString().slice(0, 19).replace('T', ' ');
+    }
+    
+    /**
+     * Subtract days from current date
+     * @param {number} days - Number of days to subtract
+     * @returns {string} SQL formatted datetime
+     */
+    static subDays(days) {
+        return this.addDays(-days);
+    }
+    
+    /**
+     * Subtract hours from current date
+     * @param {number} hours - Number of hours to subtract
+     * @returns {string} SQL formatted datetime
+     */
+    static subHours(hours) {
+        return this.addHours(-hours);
+    }
+}
+
+export default DateTime;

package/lib/Date/Locale.js

@@ -0,0 +1,68 @@
+export default {
+    tr: {
+        days: ['Pazar', 'Pazartesi', 'Salı', 'Çarşamba', 'Perşembe', 'Cuma', 'Cumartesi'],
+        daysShort: ['Paz', 'Pzt', 'Sal', 'Çar', 'Per', 'Cum', 'Cmt'],
+        months: ['Ocak', 'Şubat', 'Mart', 'Nisan', 'Mayıs', 'Haziran', 'Temmuz', 'Ağustos', 'Eylül', 'Ekim', 'Kasım', 'Aralık'],
+        monthsShort: ['Oca', 'Şub', 'Mar', 'Nis', 'May', 'Haz', 'Tem', 'Ağu', 'Eyl', 'Eki', 'Kas', 'Ara']
+    },
+    en: {
+        days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+        daysShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+        months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
+        monthsShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+    },
+    de: {
+        days: ['Sonntag', 'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag'],
+        daysShort: ['So', 'Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa'],
+        months: ['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'],
+        monthsShort: ['Jan', 'Feb', 'Mär', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dez']
+    },
+    fr: {
+        days: ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'],
+        daysShort: ['Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam'],
+        months: ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre'],
+        monthsShort: ['Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Jun', 'Jul', 'Aoû', 'Sep', 'Oct', 'Nov', 'Déc']
+    },
+    es: {
+        days: ['Domingo', 'Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'],
+        daysShort: ['Dom', 'Lun', 'Mar', 'Mié', 'Jue', 'Vie', 'Sáb'],
+        months: ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'],
+        monthsShort: ['Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun', 'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dic']
+    },
+    it: {
+        days: ['Domenica', 'Lunedì', 'Martedì', 'Mercoledì', 'Giovedì', 'Venerdì', 'Sabato'],
+        daysShort: ['Dom', 'Lun', 'Mar', 'Mer', 'Gio', 'Ven', 'Sab'],
+        months: ['Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio', 'Giugno', 'Luglio', 'Agosto', 'Settembre', 'Ottobre', 'Novembre', 'Dicembre'],
+        monthsShort: ['Gen', 'Feb', 'Mar', 'Apr', 'Mag', 'Giu', 'Lug', 'Ago', 'Set', 'Ott', 'Nov', 'Dic']
+    },
+    pt: {
+        days: ['Domingo', 'Segunda-feira', 'Terça-feira', 'Quarta-feira', 'Quinta-feira', 'Sexta-feira', 'Sábado'],
+        daysShort: ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sáb'],
+        months: ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro'],
+        monthsShort: ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez']
+    },
+    ru: {
+        days: ['Воскресенье', 'Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота'],
+        daysShort: ['Вс', 'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб'],
+        months: ['Январь', 'Февраль', 'Март', 'Апрель', 'Май', 'Июнь', 'Июль', 'Август', 'Сентябрь', 'Октябрь', 'Ноябрь', 'Декабрь'],
+        monthsShort: ['Янв', 'Фев', 'Мар', 'Апр', 'Май', 'Июн', 'Июл', 'Авг', 'Сен', 'Окт', 'Ноя', 'Дек']
+    },
+    ar: {
+        days: ['الأحد', 'الإثنين', 'الثلاثاء', 'الأربعاء', 'الخميس', 'الجمعة', 'السبت'],
+        daysShort: ['أحد', 'إثن', 'ثلا', 'أرب', 'خمي', 'جمع', 'سبت'],
+        months: ['يناير', 'فبراير', 'مارس', 'أبريل', 'مايو', 'يونيو', 'يوليو', 'أغسطس', 'سبتمبر', 'أكتوبر', 'نوفمبر', 'ديسمبر'],
+        monthsShort: ['ينا', 'فبر', 'مار', 'أبر', 'ماي', 'يون', 'يول', 'أغس', 'سبت', 'أكت', 'نوف', 'ديس']
+    },
+    ja: {
+        days: ['日曜日', '月曜日', '火曜日', '水曜日', '木曜日', '金曜日', '土曜日'],
+        daysShort: ['日', '月', '火', '水', '木', '金', '土'],
+        months: ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'],
+        monthsShort: ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月']
+    },
+    zh: {
+        days: ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'],
+        daysShort: ['周日', '周一', '周二', '周三', '周四', '周五', '周六'],
+        months: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
+        monthsShort: ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月']
+    }
+};

package/lib/Encryption/Manager.js

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

@@ -0,0 +1,49 @@
+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;
+
+    static async get(filePath, isPrivate = false) {
+        const base = isPrivate ? this.#privateRoot : this.#publicRoot;
+        const fullPath = path.join(base, filePath);
+
+        try {
+            return await fs.promises.readFile(fullPath);
+        } catch {
+            return null;
+        }
+    }
+
+    static async put(file, dir, fileName, isPrivate = false) {
+        const base = isPrivate ? this.#privateRoot : this.#publicRoot;
+        const folderPath = path.join(base, dir);
+        const fullPath = path.join(folderPath, 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;
+        await fs.promises.unlink(path.join(base, filePath));
+    }
+
+    static exists(filePath, isPrivate = false) {
+        const base = isPrivate ? this.#privateRoot : this.#publicRoot;
+        return fs.existsSync(path.join(base, filePath));
+    }
+
+    static url(filePath) {
+        if (filePath.startsWith("/")) {
+            filePath = filePath.substring(1);
+        }
+        return `/storage/${filePath}`;
+    }
+}
+
+export default FilesystemManager;

package/lib/Hashing/Manager.js

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