@nitronjs/framework 0.2.1 → 0.2.3

package/cli/njs.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const COLORS = {
     reset: "\x1b[0m",
@@ -32,10 +32,8 @@ ${COLORS.bold}Database:${COLORS.reset}
   ${COLORS.cyan}njs migrate:status${COLORS.reset}        Show the status of each migration
   ${COLORS.cyan}njs migrate:fresh${COLORS.reset}         Drop all tables and re-migrate
   ${COLORS.cyan}njs migrate:fresh --seed${COLORS.reset}  Fresh migrate with seeders
-  ${COLORS.cyan}njs seed${COLORS.reset}                  Run prod seeders
-  ${COLORS.cyan}njs seed --dev${COLORS.reset}            Run dev seeders
-  ${COLORS.cyan}njs seed --all${COLORS.reset}            Run all seeders (prod + dev)
-  ${COLORS.cyan}njs seed --status${COLORS.reset}         Show the status of each seeder
+  ${COLORS.cyan}njs seed${COLORS.reset}                  Run all seeders
+  ${COLORS.cyan}njs seed <Name>${COLORS.reset}           Run a specific seeder
 
 ${COLORS.bold}Generators:${COLORS.reset}
   ${COLORS.cyan}njs make:controller${COLORS.reset}       Create a new controller
@@ -137,15 +135,8 @@ async function run() {
 
             case "seed": {
                 const { default: Seed } = await import("../lib/Console/Commands/SeedCommand.js");
-                const showStatus = additionalArgs.includes('--status');
-                const isDev = additionalArgs.includes('--dev');
-                const isAll = additionalArgs.includes('--all');
-
-                let environment = 'prod';
-                if (isDev) environment = 'dev';
-                if (isAll) environment = 'all';
-
-                await Seed({ environment, status: showStatus });
+                const seederName = additionalArgs.find(a => !a.startsWith('--')) || null;
+                await Seed(seederName);
                 break;
             }
 

package/lib/Console/Commands/MigrateCommand.js

@@ -12,7 +12,8 @@ export default async function migrate(options = {}) {
 
     try {
         await DB.setup();
-    } catch (error) {
+    }
+    catch (error) {
         console.error('❌ Database setup failed:', error.message);
         console.error('Check your .env file and ensure the database exists and is accessible');
         return false;
@@ -34,7 +35,8 @@ export default async function migrate(options = {}) {
         await DB.close();
         return true;
 
-    } catch (error) {
+    }
+    catch (error) {
         console.error('❌ Migration error:', error.message);
         await DB.close();
         return false;

package/lib/Console/Commands/MigrateFreshCommand.js

@@ -20,7 +20,8 @@ export default async function migrateFresh(options = {}) {
 
     try {
         await DB.setup();
-    } catch (error) {
+    }
+    catch (error) {
         console.error('❌ Database setup failed:', error.message);
         console.error('Check your .env file and ensure the database exists and is accessible');
         return false;
@@ -59,7 +60,8 @@ export default async function migrateFresh(options = {}) {
         await DB.close();
         return true;
 
-    } catch (error) {
+    }
+    catch (error) {
         console.error('❌ Fresh migration error:', error.message);
         await DB.close();
         return false;

package/lib/Console/Commands/MigrateRollbackCommand.js

@@ -11,7 +11,8 @@ export default async function rollback(options = {}) {
 
     try {
         await DB.setup();
-    } catch (error) {
+    }
+    catch (error) {
         console.error('❌ Database setup failed:', error.message);
         console.error('Check your .env file and ensure the database exists and is accessible');
         return false;

package/lib/Console/Commands/MigrateStatusCommand.js

@@ -9,7 +9,8 @@ export default async function status() {
 
     try {
         await DB.setup();
-    } catch (error) {
+    }
+    catch (error) {
         console.error('❌ Database setup failed:', error.message);
         console.error('Check your .env file and ensure the database exists and is accessible');
         return false;

package/lib/Console/Commands/SeedCommand.js

@@ -3,9 +3,7 @@ import DB from '../../Database/DB.js';
 import Config from '../../Core/Config.js';
 import SeederRunner from '../../Database/Seeder/SeederRunner.js';
 
-export default async function seed(options = {}) {
-    const { environment = 'prod', status = false } = options;
-
+export default async function seed(seederName = null) {
     dotenv.config({ quiet: true });
     await Config.initialize();
 
@@ -18,20 +16,7 @@ export default async function seed(options = {}) {
     }
 
     try {
-        if (status) {
-            await SeederRunner.printStatus();
-            await DB.close();
-            return true;
-        }
-
-        let result;
-
-        if (environment === 'all') {
-            result = await SeederRunner.runAll();
-        } else {
-            result = await SeederRunner.run(environment);
-        }
-
+        const result = await SeederRunner.run(seederName);
         await DB.close();
         return result.success;
 
@@ -45,16 +30,9 @@ export default async function seed(options = {}) {
 const isMain = process.argv[1]?.endsWith("SeedCommand.js");
 if (isMain) {
     const args = process.argv.slice(2);
+    const seederName = args.find(a => !a.startsWith('--')) || null;
 
-    const showStatus = args.includes('--status');
-    const isDev = args.includes('--dev');
-    const isAll = args.includes('--all');
-
-    let environment = 'prod';
-    if (isDev) environment = 'dev';
-    if (isAll) environment = 'all';
-
-    seed({ environment, status: showStatus })
+    seed(seederName)
         .then(success => process.exit(success ? 0 : 1))
         .catch(err => {
             console.error(err);

package/lib/Core/Paths.js

@@ -92,14 +92,6 @@ class Paths {
         return path.join(this.#project, "database/seeders");
     }
 
-    static get seedersProd() {
-        return path.join(this.#project, "database/seeders/prod");
-    }
-
-    static get seedersDev() {
-        return path.join(this.#project, "database/seeders/dev");
-    }
-
     static get storage() {
         return path.join(this.#project, "storage");
     }

package/lib/Database/Migration/MigrationRepository.js

@@ -5,7 +5,7 @@ class MigrationRepository {
     static table = 'migrations';
 
     static async tableExists() {
-        const [rows] = await DB.raw(`SHOW TABLES LIKE '${this.table}'`);
+        const [rows] = await DB.rawQuery(`SHOW TABLES LIKE '${this.table}'`);
         return rows.length > 0;
     }
 

package/lib/Database/Migration/MigrationRunner.js

@@ -3,7 +3,6 @@ import path from 'path';
 import { pathToFileURL, fileURLToPath } from 'url';
 import Checksum from './Checksum.js';
 import MigrationRepository from './MigrationRepository.js';
-import SeederRepository from '../Seeder/SeederRepository.js';
 import Paths from '../../Core/Paths.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -39,10 +38,7 @@ class MigrationRunner {
         const ran = [];
 
         for (const file of files) {
-            const isMigrationsTable = file.includes('migrations');
-            const tableExists = isMigrationsTable 
-                ? await MigrationRepository.tableExists()
-                : await SeederRepository.tableExists();
+            const tableExists = await MigrationRepository.tableExists();
 
             if (tableExists) continue;
 
@@ -147,7 +143,8 @@ class MigrationRunner {
             console.log(`${COLORS.green}${COLORS.bold}✅ All migrations completed successfully.${COLORS.reset}`);
             return { success: true, ran: executedInBatch.map(e => e.file) };
 
-        } catch (error) {
+        }
+        catch (error) {
             console.error(`\n${COLORS.red}❌ Migration failed: ${error.message}${COLORS.reset}`);
 
             if (executedInBatch.length > 0) {

package/lib/Database/Model.js

@@ -98,6 +98,22 @@ class Model {
         return DB.table(this.table, null, this).select(...columns);
     }
 
+    static orderBy(column, direction = 'ASC') {
+        if (!this.table) {
+            throw new Error(`Model ${this.name} must define a static 'table' property`);
+        }
+
+        return DB.table(this.table, null, this).orderBy(column, direction);
+    }
+
+    static limit(value) {
+        if (!this.table) {
+            throw new Error(`Model ${this.name} must define a static 'table' property`);
+        }
+
+        return DB.table(this.table, null, this).limit(value);
+    }
+
     static async first() {
         if (!this.table) {
             throw new Error(`Model ${this.name} must define a static 'table' property`);

package/lib/Database/QueryBuilder.js

@@ -159,6 +159,18 @@ class QueryBuilder {
     }
 
     where(column, operator, value) {
+        if (typeof column === 'object' && column !== null && !Array.isArray(column)) {
+            for (const [key, val] of Object.entries(column)) {
+                if (Array.isArray(val) && val.length === 2) {
+                    this.where(key, val[0], val[1]);
+                }
+                else {
+                    this.where(key, '=', val);
+                }
+            }
+            return this;
+        }
+
         if (arguments.length === 2) {
             value = operator;
             operator = '=';

package/lib/Database/QueryValidation.js

@@ -1,3 +1,24 @@
+const RESERVED_KEYWORDS = new Set([
+    'order', 'key', 'group', 'index', 'table', 'column', 'select', 'insert', 
+    'update', 'delete', 'from', 'where', 'join', 'left', 'right', 'inner', 
+    'outer', 'on', 'and', 'or', 'not', 'null', 'true', 'false', 'like', 
+    'in', 'between', 'is', 'as', 'by', 'asc', 'desc', 'limit', 'offset',
+    'having', 'distinct', 'all', 'any', 'exists', 'case', 'when', 'then',
+    'else', 'end', 'if', 'into', 'values', 'set', 'create', 'drop', 'alter',
+    'add', 'primary', 'foreign', 'references', 'constraint', 'default',
+    'unique', 'check', 'view', 'trigger', 'procedure', 'function', 'database',
+    'schema', 'use', 'show', 'describe', 'explain', 'grant', 'revoke',
+    'commit', 'rollback', 'transaction', 'lock', 'unlock', 'read', 'write',
+    'range', 'rows', 'rank', 'row', 'status', 'type', 'level', 'value', 'name'
+]);
+
+function escapeIdentifier(identifier) {
+    if (RESERVED_KEYWORDS.has(identifier.toLowerCase())) {
+        return `\`${identifier}\``;
+    }
+    return identifier;
+}
+
 export function validateIdentifier(identifier) {
     if (typeof identifier !== 'string' || identifier.length === 0) {
         throw new Error('Identifier must be a non-empty string');
@@ -27,7 +48,15 @@ export function validateIdentifier(identifier) {
         throw new Error(`Invalid identifier: "${identifier}". Must be alphanumeric with underscores, optionally qualified with table name.`);
     }
 
-    return identifier;
+    if (identifier.includes('.')) {
+        const [table, column] = identifier.split('.');
+        if (column === '*') {
+            return `${escapeIdentifier(table)}.*`;
+        }
+        return `${escapeIdentifier(table)}.${escapeIdentifier(column)}`;
+    }
+
+    return escapeIdentifier(identifier);
 }
 
 export function validateWhereOperator(operator) {

package/lib/Database/Seeder/SeederRunner.js

@@ -1,8 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import { pathToFileURL } from 'url';
-import Checksum from '../Migration/Checksum.js';
-import SeederRepository from './SeederRepository.js';
 import Paths from '../../Core/Paths.js';
 
 const COLORS = {
@@ -17,167 +15,67 @@ const COLORS = {
 
 class SeederRunner {
 
-    static async run(environment = 'prod') {
-        const seedersDir = environment === 'dev' ? Paths.seedersDev : Paths.seedersProd;
+    static async run(seederName = null) {
+        const seedersDir = Paths.seeders;
 
         if (!fs.existsSync(seedersDir)) {
-            console.log(`${COLORS.yellow}⚠️  No seeders directory found for ${environment}${COLORS.reset}`);
+            console.log(`${COLORS.yellow}⚠️  No seeders directory found${COLORS.reset}`);
             return { success: true, ran: [] };
         }
 
-        const files = fs.readdirSync(seedersDir)
+        let files = fs.readdirSync(seedersDir)
             .filter(f => f.endsWith('.js'))
             .sort();
 
         if (files.length === 0) {
-            console.log(`${COLORS.yellow}⚠️  No seeder files found in ${environment}${COLORS.reset}`);
+            console.log(`${COLORS.yellow}⚠️  No seeder files found${COLORS.reset}`);
             return { success: true, ran: [] };
         }
 
-        const executedNames = await SeederRepository.getExecutedNames();
-
-        for (const file of files) {
-            const fullName = `${environment}/${file}`;
-            if (executedNames.has(fullName)) {
-                const filePath = path.join(seedersDir, file);
-                const currentChecksum = Checksum.fromFile(filePath);
-                const storedChecksum = await SeederRepository.getChecksum(fullName);
-
-                if (currentChecksum !== storedChecksum) {
-                    console.error(`${COLORS.red}❌ CHECKSUM MISMATCH: ${fullName}${COLORS.reset}`);
-                    console.error(`${COLORS.dim}   Stored:  ${storedChecksum}${COLORS.reset}`);
-                    console.error(`${COLORS.dim}   Current: ${currentChecksum}${COLORS.reset}`);
-                    console.error(`${COLORS.red}   Seeder files must NEVER be modified after execution.${COLORS.reset}`);
-                    console.error(`${COLORS.red}   Create a NEW seeder for any data changes.${COLORS.reset}`);
-                    return { 
-                        success: false, 
-                        ran: [], 
-                        error: new Error(`Checksum mismatch for seeder: ${fullName}`) 
-                    };
-                }
+        // If specific seeder name provided, filter to only that one
+        if (seederName) {
+            const targetFile = seederName.endsWith('.js') ? seederName : `${seederName}.js`;
+            files = files.filter(f => f === targetFile);
+            
+            if (files.length === 0) {
+                console.log(`${COLORS.red}❌ Seeder not found: ${seederName}${COLORS.reset}`);
+                return { success: false, ran: [], error: new Error(`Seeder not found: ${seederName}`) };
             }
         }
 
-        const pending = files.filter(f => !executedNames.has(`${environment}/${f}`));
-
-        if (pending.length === 0) {
-            console.log(`${COLORS.green}✅ Nothing to seed. All ${environment} seeders are up to date.${COLORS.reset}`);
-            return { success: true, ran: [] };
-        }
-
-        console.log(`${COLORS.cyan}🌱 Running ${environment} seeders${COLORS.reset}\n`);
+        console.log(`${COLORS.cyan}🌱 Running seeders${COLORS.reset}\n`);
 
         const executed = [];
 
         try {
-            for (const file of pending) {
+            for (const file of files) {
                 const filePath = path.join(seedersDir, file);
                 const fileUrl = pathToFileURL(filePath).href;
-                const checksum = Checksum.fromFile(filePath);
-                const fullName = `${environment}/${file}`;
 
-                console.log(`${COLORS.dim}Seeding:${COLORS.reset} ${COLORS.cyan}${fullName}${COLORS.reset}`);
+                console.log(`${COLORS.dim}Seeding:${COLORS.reset} ${COLORS.cyan}${file}${COLORS.reset}`);
 
-                const { default: seeder } = await import(fileUrl);
+                const { default: seeder } = await import(`${fileUrl}?t=${Date.now()}`);
 
                 if (typeof seeder.run !== 'function') {
                     throw new Error(`Seeder ${file} does not have a run() method`);
                 }
 
                 await seeder.run();
-                await SeederRepository.log(fullName, checksum);
-                executed.push(fullName);
+                executed.push(file);
 
-                console.log(`${COLORS.green}✅ Seeded:${COLORS.reset}  ${COLORS.cyan}${fullName}${COLORS.reset}\n`);
+                console.log(`${COLORS.green}✅ Seeded:${COLORS.reset}  ${COLORS.cyan}${file}${COLORS.reset}\n`);
             }
 
-            console.log(`${COLORS.green}${COLORS.bold}✅ All ${environment} seeders completed successfully.${COLORS.reset}`);
+            console.log(`${COLORS.green}${COLORS.bold}✅ All seeders completed successfully.${COLORS.reset}`);
             return { success: true, ran: executed };
 
-        } catch (error) {
+        }
+        catch (error) {
             console.error(`\n${COLORS.red}❌ Seeding failed: ${error.message}${COLORS.reset}`);
             return { success: false, ran: executed, error };
         }
     }
 
-    static async runAll() {
-        console.log(`${COLORS.bold}Running prod seeders...${COLORS.reset}\n`);
-        const prodResult = await this.run('prod');
-
-        if (!prodResult.success) {
-            return prodResult;
-        }
-
-        console.log(`\n${COLORS.bold}Running dev seeders...${COLORS.reset}\n`);
-        const devResult = await this.run('dev');
-
-        return {
-            success: devResult.success,
-            ran: [...prodResult.ran, ...devResult.ran],
-            error: devResult.error
-        };
-    }
-
-    static async status() {
-        const prodDir = Paths.seedersProd;
-        const devDir = Paths.seedersDev;
-
-        const status = [];
-
-        if (fs.existsSync(prodDir)) {
-            const prodFiles = fs.readdirSync(prodDir).filter(f => f.endsWith('.js')).sort();
-            for (const file of prodFiles) {
-                const fullName = `prod/${file}`;
-                const record = await SeederRepository.find(fullName);
-                status.push({
-                    name: fullName,
-                    status: record ? 'Ran' : 'Pending',
-                    executedAt: record?.executed_at || null
-                });
-            }
-        }
-
-        if (fs.existsSync(devDir)) {
-            const devFiles = fs.readdirSync(devDir).filter(f => f.endsWith('.js')).sort();
-            for (const file of devFiles) {
-                const fullName = `dev/${file}`;
-                const record = await SeederRepository.find(fullName);
-                status.push({
-                    name: fullName,
-                    status: record ? 'Ran' : 'Pending',
-                    executedAt: record?.executed_at || null
-                });
-            }
-        }
-
-        return status;
-    }
-
-    static async printStatus() {
-        const status = await this.status();
-
-        if (status.length === 0) {
-            console.log(`${COLORS.yellow}⚠️  No seeders found.${COLORS.reset}`);
-            return;
-        }
-
-        console.log(`\n${COLORS.bold}Seeder Status${COLORS.reset}\n`);
-        console.log(`${COLORS.dim}${'─'.repeat(80)}${COLORS.reset}`);
-
-        for (const seeder of status) {
-            const statusColor = seeder.status === 'Ran' ? COLORS.green : COLORS.yellow;
-            const statusIcon = seeder.status === 'Ran' ? '✅' : '⏳';
-
-            console.log(`${statusIcon} ${statusColor}${seeder.status.padEnd(7)}${COLORS.reset} ${seeder.name}`);
-        }
-
-        console.log(`${COLORS.dim}${'─'.repeat(80)}${COLORS.reset}\n`);
-
-        const ran = status.filter(s => s.status === 'Ran').length;
-        const pending = status.filter(s => s.status === 'Pending').length;
-        console.log(`${COLORS.dim}Total: ${status.length} | Ran: ${ran} | Pending: ${pending}${COLORS.reset}\n`);
-    }
-
 }
 
 export default SeederRunner;

package/lib/Http/Server.js

@@ -7,6 +7,7 @@ import fastifyStatic from "@fastify/static";
 import fastifyCookie from "@fastify/cookie";
 import fastifyHelmet from "@fastify/helmet";
 import fastifyMultipart from "@fastify/multipart";
+import fastifyFormbody from "@fastify/formbody";
 import Paths from "../Core/Paths.js";
 import Config from "../Core/Config.js";
 import Environment from "../Core/Environment.js";
@@ -111,6 +112,8 @@ class Server {
             },
             attachFieldsToBody: this.#serverConfigs.web_server.multipart.attachFieldsToBody
         });
+
+        this.#server.register(fastifyFormbody);
     }
 
     static #getCorsOrigin(requestOrigin, cb) {

package/lib/index.d.ts

@@ -187,24 +187,13 @@ export class Lang {
 }
 
 export class DateTime {
-    static now(): DateTime;
-    static parse(date: string | Date): DateTime;
-    static create(year: number, month: number, day: number, hour?: number, minute?: number, second?: number): DateTime;
-    format(format: string): string;
-    toDate(): Date;
-    toISO(): string;
-    addDays(days: number): DateTime;
-    addMonths(months: number): DateTime;
-    addYears(years: number): DateTime;
-    subDays(days: number): DateTime;
-    subMonths(months: number): DateTime;
-    subYears(years: number): DateTime;
-    diffInDays(other: DateTime): number;
-    diffInMonths(other: DateTime): number;
-    diffInYears(other: DateTime): number;
-    isBefore(other: DateTime): boolean;
-    isAfter(other: DateTime): boolean;
-    isSame(other: DateTime): boolean;
+    static toSQL(timestamp?: number | null): string;
+    static getTime(sqlDateTime?: string | null): number;
+    static getDate(timestamp?: number | null, format?: string): string;
+    static addDays(days: number): string;
+    static addHours(hours: number): string;
+    static subDays(days: number): string;
+    static subHours(hours: number): string;
 }
 
 export class Str {
@@ -396,7 +385,6 @@ export class View {
 export const MigrationRunner: any;
 export const MigrationRepository: any;
 export const SeederRunner: any;
-export const SeederRepository: any;
 export const Checksum: any;
 export const DatabaseManager: any;
 export const SessionManager: any;

package/lib/index.js

@@ -23,7 +23,6 @@ export { default as Checksum } from "./Database/Migration/Checksum.js";
 
 // Seeder
 export { default as SeederRunner } from "./Database/Seeder/SeederRunner.js";
-export { default as SeederRepository } from "./Database/Seeder/SeederRepository.js";
 
 // Authentication
 export { default as Auth } from "./Auth/Manager.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nitronjs/framework",
-	"version": "0.2.1",
+	"version": "0.2.3",
 	"description": "NitronJS is a modern and extensible Node.js MVC framework built on Fastify. It focuses on clean architecture, modular structure, and developer productivity, offering built-in routing, middleware, configuration management, CLI tooling, and native React integration for scalable full-stack applications.",
 	"bin": {
 		"njs": "./cli/njs.js"

package/skeleton/package.json

@@ -10,6 +10,8 @@
         "migrate:seed": "njs migrate --seed",
         "migrate:fresh": "njs migrate:fresh",
         "migrate:fresh:seed": "njs migrate:fresh --seed",
+        "migrate:status": "njs migrate:status",
+        "migrate:rollback": "njs migrate:rollback",
         "seed": "njs seed",
         "storage:link": "njs storage:link",
         "make:controller": "njs make:controller",

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.raw(`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;