@nitronjs/framework 0.1.0

package/lib/Console/Commands/MigrateFreshCommand.js

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+import dotenv from 'dotenv';
+import DB from '../../Database/DB.js';
+import Paths from '../../Core/Paths.js';
+import Config from '../../Core/Config.js';
+
+class MigrateFresh {
+    #shouldSeed;
+
+    constructor(shouldSeed = false) {
+        this.#shouldSeed = shouldSeed;
+    }
+
+    async run() {
+        dotenv.config({ quiet: true });
+        await Config.initialize();
+        
+        try {
+            await DB.setup();
+        }
+        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;
+        }
+
+        await this.#dropAllTables();
+        await this.#runMigrations();
+        
+        if (this.#shouldSeed) {
+            await this.#runSeeders();
+        }
+
+        await DB.close();
+        return true;
+    }
+
+    async #dropAllTables() {
+        const connection = await DB.connection();
+        const currentTables = await connection.query("SHOW TABLES");
+        await connection.query("SET FOREIGN_KEY_CHECKS = 0");
+
+        for (const table of currentTables[0]) {
+            const tableName = Object.values(table)[0];
+            console.log(`❌ [\x1b[36m${tableName}\x1b[0m] Dropping table...`);
+            await connection.query(`DROP TABLE IF EXISTS \`${tableName}\``);
+            console.log(`✅ [\x1b[36m${tableName}\x1b[0m] Table dropped\n`);
+        }
+
+        await connection.query("SET FOREIGN_KEY_CHECKS = 1");
+    }
+
+    async #runMigrations() {
+        const migrationsDir = Paths.migrations;
+        const files = fs.readdirSync(migrationsDir);
+
+        for (const file of files) {
+            const filePath = Paths.migrationUrl(file);
+            const module = await import(filePath);
+            console.log(`📦 [\x1b[36m${module.default.name}\x1b[0m] Creating table...`);
+            await module.default.up();
+            console.log(`✅ [\x1b[36m${module.default.name}\x1b[0m] Table created successfully\n`);
+        }
+    }
+
+    async #runSeeders() {
+        const seedersDir = Paths.seeders;
+        const seedFiles = fs.readdirSync(seedersDir);
+
+        for (const file of seedFiles) {
+            const filePath = Paths.seederUrl(file);
+            const seeder = await import(filePath);
+            console.log(`🌱 [\x1b[36m${seeder.default.name}\x1b[0m] Seeding...`);
+            await seeder.default.run();
+            console.log(`✅ [\x1b[36m${seeder.default.name}\x1b[0m] Seeding completed\n`);
+        }
+    }
+}
+
+export default async function migrateFresh(shouldSeed = false) {
+    const instance = new MigrateFresh(shouldSeed);
+    return instance.run();
+}
+
+// Auto-run when called directly
+const isMain = process.argv[1]?.endsWith("MigrateFreshCommand.js");
+if (isMain) {
+    const args = process.argv.slice(2);
+    const shouldSeed = args.includes("--seed");
+    migrateFresh(shouldSeed)
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+}

package/lib/Console/Commands/SeedCommand.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import dotenv from 'dotenv';
+import DB from '../../Database/DB.js';
+import Paths from '../../Core/Paths.js';
+import Config from '../../Core/Config.js';
+
+class Seed {
+    #seederClass;
+
+    constructor(seederClass = null) {
+        this.#seederClass = seederClass;
+    }
+
+    async run() {
+        dotenv.config({ quiet: true });
+        await Config.initialize();
+        
+        try {
+            await DB.setup();
+        } 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;
+        }
+
+        if (this.#seederClass) {
+            await this.#runSeeder(this.#seederClass);
+        } else {
+            await this.#runAllSeeders();
+        }
+
+        await DB.close();
+        return true;
+    }
+
+    async #runSeeder(className) {
+        const file = className + ".js";
+        const filePath = Paths.seederUrl(file);
+        
+        try {
+            const seeder = await import(filePath);
+            console.log(`🌱 [\x1b[36m${seeder.default.name}\x1b[0m] Seeding...`);
+            await seeder.default.run();
+            console.log(`✅ [\x1b[36m${seeder.default.name}\x1b[0m] Seeding completed\n`);
+        } catch (error) {
+            console.error(`❌ Seeder '${className}' not found or failed:`, error.message);
+            throw error;
+        }
+    }
+
+    async #runAllSeeders() {
+        const seedersDir = Paths.seeders;
+        const seedFiles = fs.readdirSync(seedersDir);
+
+        if (seedFiles.length === 0) {
+            console.log("No seeders found in database/seeders");
+            return;
+        }
+
+        for (const file of seedFiles) {
+            const filePath = Paths.seederUrl(file);
+            const seeder = await import(filePath);
+            console.log(`🌱 [\x1b[36m${seeder.default.name}\x1b[0m] Seeding...`);
+            await seeder.default.run();
+            console.log(`✅ [\x1b[36m${seeder.default.name}\x1b[0m] Seeding completed\n`);
+        }
+    }
+}
+
+export default async function seed(seederClass = null) {
+    const instance = new Seed(seederClass);
+    return instance.run();
+}
+
+// Auto-run when called directly
+const isMain = process.argv[1]?.endsWith("SeedCommand.js");
+if (isMain) {
+    const args = process.argv.slice(2);
+    const classArg = args.find(arg => arg.startsWith('--class='));
+    const seederClass = classArg 
+        ? classArg.split('=')[1] 
+        : (args[0] && !args[0].startsWith('-') ? args[0] : null);
+
+    seed(seederClass)
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+}

package/lib/Console/Commands/StorageLinkCommand.js

@@ -0,0 +1,31 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+export default async function storageLink() {
+    const source = path.join(process.cwd(), "storage", "app", "public");
+    const target = path.join(process.cwd(), "public", "storage");
+
+    let linkType = os.platform() === 'win32' ? 'junction' : 'dir';
+
+    return new Promise((resolve, reject) => {
+        fs.symlink(source, target, linkType, (err) => {
+            if (err) {
+                console.error('Error creating symbolic link:', err);
+                reject(err);
+            }
+            else {
+                console.log('Symbolic link has been created successfully.');
+                resolve(true);
+            }
+        });
+    });
+}
+
+// Auto-run when called directly
+const isMain = process.argv[1]?.endsWith("StorageLinkCommand.js");
+if (isMain) {
+    storageLink()
+        .then(() => process.exit(0))
+        .catch(() => process.exit(1));
+}

package/lib/Console/Stubs/controller.js

@@ -0,0 +1,19 @@
+class __CLASS__ {
+    static async get (req, res) {
+        //
+    }
+
+    static async post (req, res) {
+        //
+    }
+
+    static async put (req, res) {
+        //
+    }
+
+    static async delete (req, res) {
+        //
+    }
+}
+
+export default __CLASS__;

package/lib/Console/Stubs/middleware.js

@@ -0,0 +1,9 @@
+class __CLASS__ {
+
+    static async handler (req, res) {
+        //
+    }
+
+}
+
+export default __CLASS__;

package/lib/Console/Stubs/migration.js

@@ -0,0 +1,23 @@
+import { Schema } from "@nitronjs/framework";
+
+class __CLASS__ {
+
+    static async up () {
+        await Schema.create("__TABLE__", (table) => {
+            table.id();
+            //
+            table.boolean("status").default(1);
+            table.integer("creator");
+            table.timestamp("created_at");
+            table.integer("editor").nullable();
+            table.timestamp("edited_at").nullable();
+        });
+    }
+
+    static async down () {
+        await Schema.dropIfExists("__TABLE__");
+    }
+
+}
+
+export default __CLASS__;

package/lib/Console/Stubs/model.js

@@ -0,0 +1,7 @@
+import { Model } from "@nitronjs/framework";
+
+class __CLASS__ extends Model{
+    static table = "__TABLE__";
+}
+
+export default __CLASS__;

package/lib/Console/Stubs/page-hydration.tsx

@@ -0,0 +1,54 @@
+import React from "react";
+import { hydrateRoot } from "react-dom/client";
+
+// __COMPONENT_IMPORTS__
+
+declare global {
+    interface Window {
+        __NITRON_PROPS__?: Record<string, any>;
+    }
+}
+
+const componentManifest: Record<string, React.ComponentType<any>> = {};
+
+// __COMPONENT_MANIFEST__
+
+function hydrate() {
+    const props = window.__NITRON_PROPS__ || {};
+
+    const islands = document.querySelectorAll<HTMLElement>("[data-cid]");
+
+    islands.forEach(element => {
+        const componentName = element.dataset.island;
+        const componentId = element.dataset.cid;
+
+        if (!componentName || !componentId) {
+            return;
+        }
+
+        const Component = componentManifest[componentName];
+
+        if (!Component) {
+            return;
+        }
+
+        const componentProps = props[componentId] || {};
+
+        try {
+            hydrateRoot(
+                element,
+                React.createElement(Component, componentProps),
+                { identifierPrefix: componentId }
+            );
+        } catch {
+        }
+    });
+
+    delete window.__NITRON_PROPS__;
+}
+
+if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", hydrate);
+} else {
+    hydrate();
+}

package/lib/Console/Stubs/seeder.js

@@ -0,0 +1,9 @@
+class __CLASS__ {
+
+    static async run () {
+        //
+    }
+
+}
+
+export default __CLASS__;

package/lib/Console/Stubs/vendor.tsx

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import * as ReactDOMClient from 'react-dom/client';
+import * as ReactJSXRuntime from 'react/jsx-runtime';
+
+Object.assign(window, {
+    __NITRON_REACT__: React,
+    __NITRON_REACT_DOM__: ReactDOM,
+    __NITRON_REACT_DOM_CLIENT__: ReactDOMClient,
+    __NITRON_JSX_RUNTIME__: ReactJSXRuntime
+});

package/lib/Core/Config.js

@@ -0,0 +1,86 @@
+import Paths from "./Paths.js";
+
+/**
+ * Config Manager
+ * 
+ * Loads all config files once at startup and provides synchronous access.
+ * Must be initialized before any other module tries to access config.
+ */
+class Config {
+    static #configs = {};
+    static #initialized = false;
+
+    /**
+     * Initialize all configs - called once at server startup
+     */
+    static async initialize() {
+        if (this.#initialized) return;
+
+        const configFiles = ['app', 'auth', 'database', 'hash', 'server', 'session'];
+        
+        for (const name of configFiles) {
+            try {
+                this.#configs[name] = (await import(Paths.configUrl(name))).default;
+            } catch (err) {
+                // Config file might not exist, that's ok
+                this.#configs[name] = {};
+            }
+        }
+
+        this.#initialized = true;
+    }
+
+    /**
+     * Get a config value synchronously
+     * @param {string} key - Config key in dot notation (e.g., 'app.timezone', 'database.default')
+     * @param {*} defaultValue - Default value if key not found
+     * @returns {*} Config value
+     */
+    static get(key, defaultValue = null) {
+        if (!this.#initialized) {
+            throw new Error('Config not initialized. Call Config.initialize() first.');
+        }
+
+        const parts = key.split('.');
+        const configName = parts[0];
+        
+        if (!this.#configs[configName]) {
+            return defaultValue;
+        }
+
+        if (parts.length === 1) {
+            return this.#configs[configName];
+        }
+
+        let value = this.#configs[configName];
+        for (let i = 1; i < parts.length; i++) {
+            if (value === undefined || value === null) {
+                return defaultValue;
+            }
+            value = value[parts[i]];
+        }
+
+        return value !== undefined ? value : defaultValue;
+    }
+
+    /**
+     * Get entire config object for a config file
+     * @param {string} name - Config file name (e.g., 'app', 'database')
+     * @returns {object} Config object
+     */
+    static all(name) {
+        if (!this.#initialized) {
+            throw new Error('Config not initialized. Call Config.initialize() first.');
+        }
+        return this.#configs[name] || {};
+    }
+
+    /**
+     * Check if config system is initialized
+     */
+    static isInitialized() {
+        return this.#initialized;
+    }
+}
+
+export default Config;

package/lib/Core/Environment.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+
+class Environment {
+
+    static update (key, value) {
+        let content = fs.readFileSync(".env", 'utf-8');
+        const regex = new RegExp(`^${key}=.*`, 'm');
+
+        if (content.match(regex)) {
+            content = content.replace(regex, `${key}=${value}`);
+        }
+        else {
+            content += `\n${key}=${value}`;
+        }
+
+        fs.writeFileSync(".env", content.trim() + '\n');
+    }
+
+}
+
+export default Environment;

package/lib/Core/Paths.js

@@ -0,0 +1,188 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { pathToFileURL } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+class Paths {
+    static #framework = path.resolve(__dirname, "../..");
+    static #project = process.cwd();
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Base Directories
+    // ─────────────────────────────────────────────────────────────────────────
+
+    static get framework() {
+        return this.#framework;
+    }
+
+    static get project() {
+        return this.#project;
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Framework Paths
+    // ─────────────────────────────────────────────────────────────────────────
+
+    static get frameworkLib() {
+        return path.join(this.#framework, "lib");
+    }
+
+    static get frameworkViews() {
+        return path.join(this.#framework, "lib/View/Templates");
+    }
+
+    static get frameworkTemplates() {
+        return path.join(this.#framework, "lib/Console/Stubs");
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Project Paths
+    // ─────────────────────────────────────────────────────────────────────────
+
+    static get config() {
+        return path.join(this.#project, "config");
+    }
+
+    static get app() {
+        return path.join(this.#project, "app");
+    }
+
+    static get controllers() {
+        return path.join(this.#project, "app/Controllers");
+    }
+
+    static get middlewares() {
+        return path.join(this.#project, "app/Middlewares");
+    }
+
+    static get models() {
+        return path.join(this.#project, "app/Models");
+    }
+
+    static get routes() {
+        return path.join(this.#project, "routes");
+    }
+
+    static get resources() {
+        return path.join(this.#project, "resources");
+    }
+
+    static get views() {
+        return path.join(this.#project, "resources/views");
+    }
+
+    static get css() {
+        return path.join(this.#project, "resources/css");
+    }
+
+    static get langs() {
+        return path.join(this.#project, "resources/langs");
+    }
+
+    static get database() {
+        return path.join(this.#project, "database");
+    }
+
+    static get migrations() {
+        return path.join(this.#project, "database/migrations");
+    }
+
+    static get seeders() {
+        return path.join(this.#project, "database/seeders");
+    }
+
+    static get storage() {
+        return path.join(this.#project, "storage");
+    }
+
+    static get storagePublic() {
+        return path.join(this.#project, "storage/app/public");
+    }
+
+    static get storagePrivate() {
+        return path.join(this.#project, "storage/app/private");
+    }
+
+    static get storageSessions() {
+        return path.join(this.#project, "storage/framework/sessions");
+    }
+
+    static get storageLogs() {
+        return path.join(this.#project, "storage/logs");
+    }
+
+    static get public() {
+        return path.join(this.#project, "public");
+    }
+
+    static get publicCss() {
+        return path.join(this.#project, "storage/app/public/css");
+    }
+
+    static get publicJs() {
+        return path.join(this.#project, "storage/app/public/js");
+    }
+
+    static get build() {
+        return path.join(this.#project, "build");
+    }
+
+    static get buildViews() {
+        return path.join(this.#project, "build/views");
+    }
+
+    static get buildFrameworkViews() {
+        return path.join(this.#project, "build/framework/views");
+    }
+
+    static get nitronTemp() {
+        return path.join(this.#project, ".nitron");
+    }
+
+    static get jsxRuntime() {
+        return path.join(this.#project, ".nitron/jsx-runtime.js");
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Config Files (returns file:// URL for dynamic import)
+    // ─────────────────────────────────────────────────────────────────────────
+
+    static configUrl(name) {
+        return pathToFileURL(path.join(this.#project, `config/${name}.js`)).href;
+    }
+
+    static routeUrl(name) {
+        return pathToFileURL(path.join(this.#project, `routes/${name}.js`)).href;
+    }
+
+    static migrationUrl(file) {
+        return pathToFileURL(path.join(this.migrations, file)).href;
+    }
+
+    static seederUrl(file) {
+        return pathToFileURL(path.join(this.seeders, file)).href;
+    }
+
+    static kernelUrl() {
+        return pathToFileURL(path.join(this.#project, "app/Kernel.js")).href;
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Helper Methods
+    // ─────────────────────────────────────────────────────────────────────────
+
+    static join(...segments) {
+        return path.join(this.#project, ...segments);
+    }
+
+    static frameworkJoin(...segments) {
+        return path.join(this.#framework, ...segments);
+    }
+
+    static resolve(...segments) {
+        return path.resolve(this.#project, ...segments);
+    }
+}
+
+export default Paths;