millas 0.2.12-beta → 0.2.12-beta-1

package/package.json

@@ -1,25 +1,12 @@
 {
   "name": "millas",
-  "version": "0.2.12-beta",
+  "version": "0.2.12-beta-1",
   "description": "A modern batteries-included backend framework for Node.js — built on Express, inspired by Laravel, Django, and FastAPI",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",
-    "./src": "./src/index.js",
-    "./src/*": "./src/*.js",
-    "./bin/*": "./bin/*.js",
-    "./validation": "./src/validation/Validator.js",
-    "./facades/Http": "./src/facades/Http.js",
-    "./facades/Validation": "./src/facades/Validation.js",
-    "./facades/Database": "./src/facades/Database.js",
-    "./facades/Auth": "./src/facades/Auth.js",
-    "./facades/Log": "./src/facades/Log.js",
-    "./facades/Cache": "./src/facades/Cache.js",
-    "./facades/Mail": "./src/facades/Mail.js",
-    "./facades/Queue": "./src/facades/Queue.js",
-    "./facades/Events": "./src/facades/Events.js",
-    "./facades/Storage": "./src/facades/Storage.js",
-    "./facades/Admin": "./src/facades/Admin.js"
+    "./core/*": "./src/core/*.js",
+    "./facades/*": "./src/facades/*.js"
   },
   "bin": {
     "millas": "./bin/millas.js"

package/src/auth/Auth.js

@@ -230,13 +230,18 @@ class Auth {
   }
 
   _buildTokenPayload(user) {
-    return {
-      id:    user.id,
-      sub:   user.id,
-      email: user.email,
-      role:  user.role || null,
-      iat:   Math.floor(Date.now() / 1000),
-    };
+    // If the model defines tokenPayload(), use it — allows custom JWT claims.
+    // Otherwise fall back to the standard shape.
+    const base = typeof user.tokenPayload === 'function'
+      ? user.tokenPayload()
+      : {
+          id:    user.id,
+          sub:   user.id,
+          email: user.email,
+          role:  user.role || null,
+        };
+
+    return { ...base, iat: Math.floor(Date.now() / 1000) };
   }
 
   _requireUserModel() {
@@ -251,4 +256,4 @@ class Auth {
 
 // Singleton facade
 module.exports = new Auth();
-module.exports.Auth = Auth;
+module.exports.Auth = Auth;

package/src/auth/AuthController.js

@@ -87,6 +87,8 @@ class AuthController extends Controller {
 
   _safeUser(user) {
     if (!user) return null;
+    // Use the model's toSafeObject() if defined (AuthUser and subclasses provide this)
+    if (typeof user.toSafeObject === 'function') return user.toSafeObject();
     const data = user.toJSON ? user.toJSON() : { ...user };
     delete data.password;
     delete data.remember_token;
@@ -94,4 +96,4 @@ class AuthController extends Controller {
   }
 }
 
-module.exports = AuthController;
+module.exports = AuthController;

package/src/auth/AuthUser.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const Model  = require('../orm/model/Model');
+const fields = require('../orm/fields/index').fields;
+
+/**
+ * AuthUser
+ *
+ * Base model for authentication. Ships with Millas.
+ * Covers the exact contract that Auth, AuthMiddleware, and AuthController expect:
+ *   - email       (unique, required for login)
+ *   - password    (hashed by Auth.register / Auth.hashPassword)
+ *   - role        (read by RoleMiddleware)
+ *
+ * ── Extending ────────────────────────────────────────────────────────────────
+ *
+ * Extend this instead of writing a User model from scratch.
+ * Add your own fields on top — all Auth behaviour is inherited.
+ *
+ *   class User extends AuthUser {
+ *     static table = 'users';
+ *     static fields = {
+ *       ...AuthUser.fields,
+ *       phone:      fields.string({ nullable: true }),
+ *       avatar_url: fields.string({ nullable: true }),
+ *       bio:        fields.text({ nullable: true }),
+ *     };
+ *   }
+ *
+ * ── Customising the token payload ─────────────────────────────────────────
+ *
+ * Override tokenPayload() to add custom claims to the JWT:
+ *
+ *   class User extends AuthUser {
+ *     tokenPayload() {
+ *       return {
+ *         ...super.tokenPayload(),
+ *         plan:  this.plan,
+ *         orgId: this.org_id,
+ *       };
+ *     }
+ *   }
+ *
+ * ── Customising register / login hooks ────────────────────────────────────
+ *
+ * Override static hooks to run logic around auth operations:
+ *
+ *   class User extends AuthUser {
+ *     static async afterCreate(instance) {
+ *       await emit('user.registered', { user: instance });
+ *     }
+ *   }
+ */
+class AuthUser extends Model {
+  static table = 'users';
+
+  static fields = {
+    id:         fields.id(),
+    name:       fields.string({ max: 100 }),
+    email:      fields.string({ unique: true }),
+    password:   fields.string(),
+    role:       fields.enum(['admin', 'user'], { default: 'user' }),
+    created_at: fields.timestamp(),
+    updated_at: fields.timestamp(),
+  };
+
+  // ── Auth contract helpers ──────────────────────────────────────────────────
+
+  /**
+   * The fields to include in the JWT payload.
+   * Override to add custom claims.
+   *
+   * @returns {object}
+   */
+  tokenPayload() {
+    return {
+      id:    this.id,
+      sub:   this.id,
+      email: this.email,
+      role:  this.role || null,
+    };
+  }
+
+  /**
+   * Safe representation — strips sensitive fields.
+   * Used by AuthController._safeUser().
+   *
+   * @returns {object}
+   */
+  toSafeObject() {
+    const data = { ...this };
+    delete data.password;
+    delete data.remember_token;
+    return data;
+  }
+}
+
+module.exports = AuthUser;

package/src/cli.js

@@ -7,7 +7,7 @@ const program = new Command();
 program
   .name('millas')
   .description(chalk.cyan('⚡ Millas — A modern batteries-included Node.js framework'))
-  .version('0.1.0');
+  .version('0.2.12-beta-1');
 
 // Load all command modules
 require('./commands/new')(program);

package/src/commands/serve.js

@@ -6,8 +6,9 @@ const fs = require('fs-extra');
 const fsnative = require('fs');
 const {fork} = require('child_process');
 const chokidar = require('chokidar');
-
-// ── ASCII banner ──────────────────────────────────────────────────────────────
+const patchConsole = require("../logger/patchConsole");
+const Logger = require("../logger/internal");
+// ── ASCII banner ───────────────────────────────────────────────────────────────
 
 const BANNER_LINES = [
     '  ███╗   ███╗██╗██╗     ██╗      █████╗ ███████╗',
@@ -20,10 +21,9 @@ const BANNER_LINES = [
 
 function printBanner(host, port) {
     const env = process.env.NODE_ENV || 'development';
-    const ver = 'v' + (require('../../package.json').version || '0.1.2');
+    const ver = 'v' + (require('../../package.json').version || '0.1.0');
     const url = `http://${host}:${port}`;
     const hr = chalk.dim('  ' + '─'.repeat(54));
-
     const envColour = env === 'production' ? chalk.red
         : env === 'staging' ? chalk.yellow
             : chalk.green;
@@ -32,52 +32,37 @@ function printBanner(host, port) {
     for (const line of BANNER_LINES) {
         process.stdout.write(chalk.bold.cyan(line) + '\n');
     }
-    process.stdout.write('\n');
-    process.stdout.write(hr + '\n');
+    process.stdout.write('\n' + hr + '\n');
     process.stdout.write(
-        '  ' +
-        chalk.dim(ver.padEnd(8)) +
-        chalk.dim('│') + '  ' +
-        envColour('⬤  ' + env) + '  ' +
-        chalk.dim('│') + '  ' +
-        chalk.bold.white(url) +
-        '\n'
+        '  ' + chalk.dim(ver.padEnd(8)) +
+        chalk.dim('│') + '  ' + envColour('⬤  ' + env) + '  ' +
+        chalk.dim('│') + '  ' + chalk.bold.white(url) + '\n'
     );
     process.stdout.write(hr + '\n\n');
 }
 
-// ── Hot reload watcher ────────────────────────────────────────────────────────
-
-/**
- * Directories watched for changes (relative to project root).
- * Watching parent dirs is enough — fs.watch recursive covers all descendants.
- */
-const WATCH_DIRS = [
-    'app',
-    'routes',
-    'config',
-    'bootstrap',
-    'providers',
-    'middleware',
-];
+// ── Constants ─────────────────────────────────────────────────────────────────
 
-/** File extensions that trigger a reload when changed. */
+const WATCH_DIRS = ['app', 'routes', 'config', 'bootstrap', 'providers', 'middleware'];
 const WATCH_EXTS = new Set(['.js', '.mjs', '.cjs', '.json', '.njk', '.env']);
+const DEBOUNCE_MS = 250;
+
 
-/** How long to wait after the last change before restarting (ms). */
-const DEBOUNCE_MS = 300;
+// ── HotReloader ───────────────────────────────────────────────────────────────
 
 class HotReloader {
-    constructor(bootstrapPath, env) {
+    constructor(bootstrapPath, publicPort, publicHost) {
         this._bootstrap = bootstrapPath;
-        this._cwd = path.dirname(bootstrapPath.replace(/bootstrap.+$/, '')) ||
-            process.cwd();
-        this._env = env;
+        this._initialised = false
+
         this._child = null;
-        this._watchers = [];
-        this._timer = null;
         this._starting = false;
         this._restarts = 0;
+
+        // Queued { req, res, timer } entries while child is restarting
+        this._queue = [];
+        this._watchers = [];
+        this._timer = null;
     }
 
     start() {
@@ -86,75 +71,74 @@ class HotReloader {
         this._handleSignals();
     }
 
-    // ── Child process management ──────────────────────────────────────────────
-
     _spawnChild() {
-        if (this._starting) return;
+        if (this._starting) {
+            return;
+        }
         this._starting = true;
-
+        const extra = {}
+        if (!this._initialised) {
+            extra["MILLAS_START_UP"] = true
+            this._initialised = true
+        }
         this._child = fork(this._bootstrap, [], {
-            env: {...process.env, ...this._env},
-            stdio: 'inherit',    // child shares parent's stdout/stderr — output appears inline
-            // detached: false   — child dies with parent
+            env: {
+                ...extra,
+                MILLAS_CHILD: '1',
+            },
+            stdio: 'inherit',
         });
 
+        // Application.listen() sends { type:'ready' } via IPC once bound
+        this._child.on('message', msg => {
+            if (msg && msg.type === 'ready') {
+                this._starting = false;
+            }
+        });
+        //
         this._child.on('exit', (code, signal) => {
             this._starting = false;
-            // Abnormal exit (crash) — don't auto-restart, let the developer fix it
+
             if (code !== 0 && signal !== 'SIGTERM' && signal !== 'SIGKILL') {
-                process.stdout.write(
-                    '\n' + chalk.red('  ✖  App crashed') +
+                console.error(chalk.red('✖  App crashed') +
                     chalk.dim(` (exit ${code ?? signal})`) +
-                    chalk.dim(' — waiting for changes…\n\n')
+                    chalk.dim(' — fix the error, file watcher will reload…')
                 );
             }
         });
-
-        this._child.on('error', (err) => {
+        //
+        this._child.on('error', err => {
             this._starting = false;
-            process.stderr.write(chalk.red(`\n  ✖  Child error: ${err.message}\n\n`));
+            console.error(chalk.red(`✖  ${err.message}`));
         });
     }
 
     _killChild(cb) {
-        if (!this._child || this._child.exitCode !== null) {
-            cb();
-            return;
-        }
+        if (!this._child || this._child.exitCode !== null) return cb();
         this._child.once('exit', cb);
         this._child.kill('SIGTERM');
-
-        // Force kill if graceful shutdown takes too long
-        setTimeout(() => {
-            if (this._child && this._child.exitCode === null) {
-                this._child.kill('SIGKILL');
-            }
-        }, 3000).unref();
     }
 
     _restart(changedFile) {
-        const rel = changedFile ? path.relative(process.cwd(), changedFile) : '';
         const link = changedFile
-            ? `\x1b]8;;file://${changedFile}\x07${changedFile}\x1b]8;;\x07`
+            ? `\x1b]8;;file://${changedFile}\x07${path.relative(process.cwd(), changedFile)}\x1b]8;;\x07`
             : '';
-
-        process.stdout.write(
-            '\n  ' + chalk.yellow('↺') + '  ' +
+        console.warn(
+            chalk.yellow('↺') + '  ' +
             chalk.white('Reloading') +
-            (link ? '  ' + chalk.cyan(link) : '') +
-            '\n'
+            (link ? chalk.blueBright('  ' + link) : '')
         );
 
         this._restarts++;
-
-        this._killChild(() => {
-            this._spawnChild();
-        });
+        this._killChild(() => this._spawnChild());
     }
 
-    // ── File watching ─────────────────────────────────────────────────────────
+    // ── Watcher ───────────────────────────────────────────────────────────────
 
     _watch() {
+        console.log(chalk.green('✔') + '  ' +
+            chalk.dim('Watching for changes…')
+        );
         const cwd = process.cwd();
         const watchPaths = [
             ...WATCH_DIRS.map(d => path.join(cwd, d)),
@@ -166,6 +150,9 @@ class HotReloader {
             persistent: true,
             ignoreInitial: true,
             ignored: /(^|[\/\\])\..(?!env)/,
+            // Wait for the file write to settle before reloading.
+            // Prevents double-restarts on editors that truncate then rewrite.
+            awaitWriteFinish: {stabilityThreshold: 80, pollInterval: 20},
         });
 
         watcher.on('all', (event, filePath) => {
@@ -179,9 +166,7 @@ class HotReloader {
 
     _scheduleRestart(changedFile) {
         clearTimeout(this._timer);
-        this._timer = setTimeout(() => {
-            this._restart(changedFile);
-        }, DEBOUNCE_MS);
+        this._timer = setTimeout(() => this._restart(changedFile), DEBOUNCE_MS);
     }
 
     _stopWatching() {
@@ -194,8 +179,7 @@ class HotReloader {
         this._watchers = [];
     }
 
-
-    // ── Signal handling ───────────────────────────────────────────────────────
+    // ── Signals ───────────────────────────────────────────────────────────────
 
     _handleSignals() {
         const cleanup = () => {
@@ -204,16 +188,14 @@ class HotReloader {
             if (this._child) this._child.kill('SIGTERM');
             process.exit(0);
         };
-
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
+        process.once('SIGINT', cleanup);
+        process.once('SIGTERM', cleanup);
     }
 }
 
-// ── Command definition ────────────────────────────────────────────────────────
+// ── Command ────────────────────────────────────────────────────────────────────
 
 module.exports = function (program) {
-
     program
         .command('serve')
         .description('Start the development server with hot reload')
@@ -221,6 +203,8 @@ module.exports = function (program) {
         .option('-h, --host <host>', 'Host to bind to', 'localhost')
         .option('--no-reload', 'Disable hot reload (run once, like production)')
         .action((options) => {
+
+            const restoreAfterPatch = patchConsole(Logger,"SystemOut")
             const appBootstrap = path.resolve(process.cwd(), 'bootstrap/app.js');
 
             if (!fs.existsSync(appBootstrap)) {
@@ -229,51 +213,38 @@ module.exports = function (program) {
                 process.exit(1);
             }
 
+
+            const publicPort = parseInt(options.port, 10) || 3000;
+            const publicHost = options.host || 'localhost';
+
             const env = {
-                MILLAS_PORT: options.port,
-                MILLAS_HOST: options.host,
-                NODE_ENV: process.env.NODE_ENV || 'development',
-                MILLAS_RELOAD: options.reload ? '1' : '0',
+                NODE_ENV: process.env.APP_ENV || 'development',
+                MILLERS_NODE_ENV: true,
+                MILLAS_HOST: publicHost,
+                MILLAS_PORT: String(publicPort),
             };
 
             Object.assign(process.env, env);
+            printBanner(publicHost, publicPort);
 
-            printBanner(options.host, options.port);
-
-            const hotReload = options.reload !== false;
-
-            if (hotReload) {
-                // ── Hot reload mode ──────────────────────────────────────────────────
-                // Parent process watches files. App runs in a child process.
-                // On change: kill child, clear require cache, refork.
-                process.stdout.write(
-                    '  ' + chalk.green('✔') + '  ' +
-                    chalk.dim('Watching for file changes…') +
-                    '\n'
-                );
-
-                const reloader = new HotReloader(appBootstrap, env);
-                reloader.start();
+            if (options.reload !== false) {
 
+                new HotReloader(appBootstrap, publicPort, publicHost).start();
             } else {
-                // ── Single-run mode (--no-reload) ────────────────────────────────────
                 try {
                     require(appBootstrap);
-                } catch (err) {
-                    process.stderr.write(chalk.red(`\n  ✖  Failed to start: ${err.message}\n\n`));
-                    if (process.env.DEBUG) process.stderr.write(chalk.dim(err.stack) + '\n');
-                    process.exit(1);
+                } catch (e) {
+                    console.log("Error starting server: ", +e)
                 }
             }
         });
 
 };
 
-// Exported so other commands (queue:work) can validate the project exists
 module.exports.requireProject = function (command) {
     const bootstrapPath = path.resolve(process.cwd(), 'bootstrap/app.js');
     if (!fsnative.existsSync(bootstrapPath)) {
         process.stderr.write(chalk.red(`\n  ✖  Not inside a Millas project (${command}).\n\n`));
         process.exit(1);
     }
-};
+};

package/src/container/AppInitializer.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const express = require('express');
+const Application = require('./Application');
+const HttpServer = require('./HttpServer');
+
+/**
+ * AppInitialiser
+ *
+ * The internal engine that receives what bootstrap/app.js exports
+ * (a MillasInstance), extracts its config, and wires up everything:
+ *
+ *   - ExpressAdapter
+ *   - Application kernel (DI container, providers, routes, middleware)
+ *   - Admin panel
+ *   - HttpServer (port, signals, startup log, IPC ready signal)
+ *
+ * Developers never see or interact with this class.
+ * It is used exclusively by runner.js (millas serve) and the no-reload path.
+ *
+ * ── Flow ─────────────────────────────────────────────────────────────────────
+ *
+ *   bootstrap/app.js  →  MillasInstance  →  AppInitialiser.boot()
+ *                                              ├─ builds ExpressAdapter
+ *                                              ├─ builds Application
+ *                                              ├─ registers providers
+ *                                              ├─ registers routes
+ *                                              ├─ registers middleware aliases
+ *                                              ├─ boots providers
+ *                                              ├─ mounts routes
+ *                                              ├─ mounts admin (if configured)
+ *                                              ├─ mounts fallbacks
+ *                                              └─ starts HttpServer
+ */
+class AppInitializer {
+    /**
+     * @param {Object} config — the sealed export of bootstrap/app.js
+     */
+    constructor(config) {
+        this._config = config;
+        this._kernel = null;
+        this._adapter = null;
+    }
+
+    /**
+     * Boot the full application and start the HTTP server.
+     * Returns a Promise that resolves once the server is listening.
+     */
+    async boot() {
+        const cfg = this._config;
+
+        // ── Build the HTTP adapter ───────────────────────────────────────────────
+        const ExpressAdapter = require('../http/adapters/ExpressAdapter');
+        const expressApp = express();
+        this._adapter = new ExpressAdapter(expressApp);
+        this._adapter.applyBodyParsers();
+
+        // Raw adapter middleware (helmet, compression, etc.)
+        for (const mw of (cfg.adapterMiddleware || [])) {
+            this._adapter.applyMiddleware(mw);
+        }
+
+        // ── Build the Application kernel ─────────────────────────────────────────
+        this._kernel = new Application(this._adapter);
+
+        // Core providers (auto-enabled unless disabled in config)
+        const coreProviders = this._buildCoreProviders(cfg);
+        this._kernel.providers([...coreProviders, ...cfg.providers]);
+
+        // Named middleware aliases
+        for (const {alias, handler} of (cfg.middleware || [])) {
+            this._kernel.middleware(alias, handler);
+        }
+
+        // Route definitions
+        if (cfg.routes) {
+            this._kernel.routes(cfg.routes);
+        }
+
+        // ── Boot providers ───────────────────────────────────────────────────────
+        await this._kernel.boot();
+
+        // ── Mount routes ─────────────────────────────────────────────────────────
+        if (!process.env.MILLAS_ROUTE_LIST) {
+            this._kernel.mountRoutes();
+
+            // Admin panel — mounted between routes and fallbacks
+            if (cfg.admin !== null) {
+                try {
+                    const Admin = require('../admin/Admin');
+                    if (cfg.admin && Object.keys(cfg.admin).length) {
+                        Admin.configure(cfg.admin);
+                    }
+                    Admin.mount(expressApp);
+                } catch (err) {
+                    process.stderr.write(`[millas] Admin mount failed: ${err.message}\n`);
+                }
+            }
+
+            this._kernel.mountFallbacks();
+
+            // ── Start the HTTP server ──────────────────────────────────────────────
+            const server = new HttpServer(this._kernel, {
+                onStart: cfg.onStart || undefined,
+                onShutdown: cfg.onShutdown || undefined,
+            });
+
+            await server.start();
+        }
+    }
+
+    // ── Internal ───────────────────────────────────────────────────────────────
+
+    _buildCoreProviders(cfg) {
+        const providers = [];
+        const load = (p) => {
+            try {
+                return require(p);
+            } catch {
+                return null;
+            }
+        };
+
+        if (cfg.logging !== false) {
+            const p = load('../providers/LogServiceProvider');
+            if (p) providers.push(p);
+        }
+        if (cfg.database !== false) {
+            const p = load('../providers/DatabaseServiceProvider');
+            if (p) providers.push(p);
+        }
+
+        if (cfg.cache !== false || cfg.storage !== false) {
+            const p = load('../providers/CacheStorageServiceProvider');
+            if (p) {
+                if (cfg.cache !== false && p.CacheServiceProvider) providers.push(p.CacheServiceProvider);
+                if (cfg.storage !== false && p.StorageServiceProvider) providers.push(p.StorageServiceProvider);
+            }
+        }
+
+        if (cfg.mail !== false) {
+            const p = load('../providers/MailServiceProvider');
+            if (p) providers.push(p);
+        }
+        if (cfg.queue !== false) {
+            const p = load('../providers/QueueServiceProvider');
+            if (p) providers.push(p);
+        }
+        if (cfg.events !== false) {
+            const p = load('../providers/EventServiceProvider');
+            if (p) providers.push(p);
+        }
+
+        return providers;
+    }
+}
+
+module.exports = AppInitializer;