nitronjs 0.1.0

package/cli/njs.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+const COLORS = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    cyan: "\x1b[36m"
+};
+
+function printHelp() {
+    console.log(`
+${COLORS.cyan}╔══════════════════════════════════════════════════════════════╗${COLORS.reset}
+${COLORS.cyan}║${COLORS.reset}                    ${COLORS.bold}NitronJS CLI${COLORS.reset}                             ${COLORS.cyan}║${COLORS.reset}
+${COLORS.cyan}╚══════════════════════════════════════════════════════════════╝${COLORS.reset}
+
+${COLORS.bold}Usage:${COLORS.reset}
+  ${COLORS.cyan}npx nitronjs <project>${COLORS.reset}    Create a new NitronJS project
+  ${COLORS.cyan}njs <command>${COLORS.reset}             Run a command in your project
+
+${COLORS.bold}Development:${COLORS.reset}
+  ${COLORS.cyan}njs dev${COLORS.reset}                   Start development server with hot reload
+  ${COLORS.cyan}njs build${COLORS.reset}                 Build application for production
+  ${COLORS.cyan}njs start${COLORS.reset}                 Start production server
+
+${COLORS.bold}Database:${COLORS.reset}
+  ${COLORS.cyan}njs migrate${COLORS.reset}               Run database migrations
+  ${COLORS.cyan}njs migrate --seed${COLORS.reset}        Run migrations and seeders
+  ${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 database seeders
+
+${COLORS.bold}Generators:${COLORS.reset}
+  ${COLORS.cyan}njs make:controller${COLORS.reset}       Create a new controller
+  ${COLORS.cyan}njs make:middleware${COLORS.reset}       Create a new middleware
+  ${COLORS.cyan}njs make:model${COLORS.reset}            Create a new model
+  ${COLORS.cyan}njs make:migration${COLORS.reset}        Create a new migration
+  ${COLORS.cyan}njs make:seeder${COLORS.reset}           Create a new seeder
+
+${COLORS.bold}Utilities:${COLORS.reset}
+  ${COLORS.cyan}njs storage:link${COLORS.reset}          Create symbolic link for storage
+
+${COLORS.bold}Examples:${COLORS.reset}
+  ${COLORS.dim}# Create a new project${COLORS.reset}
+  npx nitronjs my-app
+
+  ${COLORS.dim}# Generate a controller with subdirectory${COLORS.reset}
+  njs make:controller Admin/DashboardController
+
+  ${COLORS.dim}# Fresh migrate with seeders${COLORS.reset}
+  njs migrate:fresh --seed
+`);
+}
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printHelp();
+    process.exit(0);
+}
+
+const command = args[0];
+const additionalArgs = args.slice(1);
+
+const KNOWN_COMMANDS = [
+    "dev", "start", "build",
+    "migrate", "migrate:fresh", "seed",
+    "storage:link",
+    "make:controller", "make:middleware", "make:model", "make:migration", "make:seeder"
+];
+
+const isProjectName = command &&
+    !command.startsWith("-") &&
+    !KNOWN_COMMANDS.includes(command) &&
+    !command.startsWith("make:");
+
+async function run() {
+    try {
+        if (isProjectName) {
+            const { default: create } = await import("./create.js");
+            await create(command);
+            return;
+        }
+
+        switch (command) {
+            case "dev": {
+                const { default: Dev } = await import("../lib/Console/Commands/DevCommand.js");
+                await Dev();
+                break;
+            }
+
+            case "start": {
+                const { start } = await import("../lib/Runtime/Entry.js");
+                await start();
+                break;
+            }
+
+            case "build": {
+                const { default: Build } = await import("../lib/Console/Commands/BuildCommand.js");
+                await Build();
+                break;
+            }
+
+            case "migrate": {
+                const { default: Migrate } = await import("../lib/Console/Commands/MigrateCommand.js");
+                await Migrate(additionalArgs.includes("--seed"));
+                break;
+            }
+
+            case "migrate:fresh": {
+                const { default: MigrateFresh } = await import("../lib/Console/Commands/MigrateFreshCommand.js");
+                await MigrateFresh(additionalArgs.includes("--seed"));
+                break;
+            }
+
+            case "seed": {
+                const { default: Seed } = await import("../lib/Console/Commands/SeedCommand.js");
+                await Seed();
+                break;
+            }
+
+            case "storage:link": {
+                const { default: StorageLink } = await import("../lib/Console/Commands/StorageLinkCommand.js");
+                await StorageLink();
+                break;
+            }
+
+            case "make:controller":
+            case "make:middleware":
+            case "make:model":
+            case "make:migration":
+            case "make:seeder": {
+                const type = command.split(":")[1];
+                const name = additionalArgs[0];
+
+                if (!name) {
+                    console.error(`${COLORS.red}Error: Name is required${COLORS.reset}`);
+                    console.log(`${COLORS.dim}Usage: njs ${command} <Name>${COLORS.reset}`);
+                    console.log(`${COLORS.dim}Example: njs ${command} ${type === "controller" ? "HomeController" : type === "middleware" ? "AuthMiddleware" : type === "model" ? "User" : type === "migration" ? "users" : "UserSeeder"}${COLORS.reset}`);
+                    process.exit(1);
+                }
+
+                const { default: Make } = await import("../lib/Console/Commands/MakeCommand.js");
+                await Make(type, name);
+                break;
+            }
+
+            default:
+                console.error(`${COLORS.red}Error: Unknown command '${command}'${COLORS.reset}`);
+                console.log(`${COLORS.dim}Run 'njs --help' for available commands${COLORS.reset}`);
+                process.exit(1);
+        }
+    } catch (error) {
+        console.error(`${COLORS.red}Error: ${error.message}${COLORS.reset}`);
+        if (process.env.DEBUG) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+
+run();

package/lib/Auth/Manager.js

@@ -0,0 +1,111 @@
+import Hash from "../Hashing/Manager.js";
+import Config from "../Core/Config.js";
+
+class Auth {
+    static setup(server) {
+        server.decorateRequest('auth', null);
+
+        server.addHook('onRequest', async (req, res) => {
+            req.auth = {
+                guard: (guardName = null) => ({
+                    attempt: (credentials) => Auth.attempt(req, credentials, guardName),
+                    logout: () => Auth.logout(req, guardName),
+                    user: () => Auth.user(req, guardName),
+                    check: () => Auth.check(req, guardName),
+                    home: () => Auth.home(res, guardName),
+                    redirect: () => Auth.redirect(res, guardName)
+                }),
+                attempt: (credentials) => Auth.attempt(req, credentials, null),
+                logout: () => Auth.logout(req, null),
+                user: () => Auth.user(req, null),
+                check: () => Auth.check(req, null),
+                home: () => Auth.home(res, null),
+                redirect: () => Auth.redirect(res, null)
+            };
+        });
+    }
+
+    static #getAuthConfig() {
+        return Config.all("auth");
+    }
+
+    static async attempt(req, credentials, guardName = null) {
+        const authConfig = this.#getAuthConfig();
+        const guard = guardName || authConfig.defaults.guard;
+        const config = authConfig.guards[guard];
+
+        if (!config) throw new Error(`Guard '${guard}' not configured`);
+
+        const { provider, identifier } = config;
+
+        const user = await provider
+            .where(identifier, '=', credentials[identifier])
+            .first();
+
+        if (!user) return false;
+
+        const isValid = await Hash.check(credentials.password, user.password);
+        if (!isValid) return false;
+
+        req.session.regenerate();
+        req.session.set(`auth_${guard}`, user.id);
+
+        return true;
+    }
+
+    static logout(req, guardName = null) {
+        const authConfig = this.#getAuthConfig();
+        const guard = guardName || authConfig.defaults.guard;
+        
+        req.session.set(`auth_${guard}`, null);
+    }
+
+    static async user(req, guardName = null) {
+        const authConfig = this.#getAuthConfig();
+        const guard = guardName || authConfig.defaults.guard;
+        const userId = req.session.get(`auth_${guard}`) || null;
+
+        if (!userId) return null;
+
+        const config = authConfig.guards[guard];
+
+        if (!config) return null;
+
+        return await config.provider.find(userId);
+    }
+
+    static check(req, guardName = null) {
+        const authConfig = this.#getAuthConfig();
+        const guard = guardName || authConfig.defaults.guard;
+
+        return req.session.get(`auth_${guard}`) !== null && req.session.get(`auth_${guard}`) !== undefined;
+    }
+
+    static home(res, guardName = null) {
+        const authConfig = this.#getAuthConfig();
+        const guard = guardName || authConfig.defaults.guard;
+        const config = authConfig.guards[guard];
+
+        return res.redirect(this.#resolveUrl(config?.home));
+    }
+
+    static redirect(res, guardName = null) {
+        const authConfig = this.#getAuthConfig();
+        const guard = guardName || authConfig.defaults.guard;
+        const config = authConfig.guards[guard];
+
+        return res.redirect(this.#resolveUrl(config?.redirect));
+    }
+
+    static #resolveUrl(path) {
+        if (!path) return '/';
+
+        if (path.startsWith('/') || path.startsWith('http://') || path.startsWith('https://')) {
+            return path;
+        }
+        
+        return route(path);
+    }
+}
+
+export default Auth;