millas 0.2.11 → 0.2.12-beta-1

package/src/commands/migrate.js

@@ -6,17 +6,15 @@ const fs    = require('fs-extra');
 
 module.exports = function (program) {
 
-  // ── makemigrations ────────────────────────────────────────────────────────
-
+  // ── makemigrations ──────────────────────────────────────────────────────────
   program
     .command('makemigrations')
     .description('Scan model files, detect schema changes, generate migration files')
     .action(async () => {
       try {
-        const ctx       = getProjectContext();
-        // Fixed: was incorrectly destructured as { ModelInspector }
+        const ctx            = getProjectContext();
         const ModelInspector = require('../orm/migration/ModelInspector');
-        const inspector = new ModelInspector(
+        const inspector      = new ModelInspector(
           ctx.modelsPath,
           ctx.migrationsPath,
           ctx.snapshotPath,
@@ -31,14 +29,12 @@ module.exports = function (program) {
           console.log(chalk.gray('\n  Run: millas migrate   to apply these migrations.\n'));
         }
       } catch (err) {
-        console.error(chalk.red(`\n  ✖  makemigrations failed: ${err.message}\n`));
-        if (process.env.DEBUG) console.error(err.stack);
-        process.exit(1);
+        bail('makemigrations', err);
       }
+      // makemigrations doesn't open a DB connection so no closeDb() needed
     });
 
-  // ── migrate ───────────────────────────────────────────────────────────────
-
+  // ── migrate ─────────────────────────────────────────────────────────────────
   program
     .command('migrate')
     .description('Run all pending migrations')
@@ -46,14 +42,15 @@ module.exports = function (program) {
       try {
         const runner = await getRunner();
         const result = await runner.migrate();
-        printResult(result, 'Ran');
+        printMigrationResult(result, 'Ran');
       } catch (err) {
         bail('migrate', err);
+      } finally {
+        await closeDb();
       }
     });
 
-  // ── migrate:fresh ─────────────────────────────────────────────────────────
-
+  // ── migrate:fresh ────────────────────────────────────────────────────────────
   program
     .command('migrate:fresh')
     .description('Drop ALL tables then re-run every migration from scratch')
@@ -62,14 +59,15 @@ module.exports = function (program) {
         console.log(chalk.yellow('\n  ⚠  Dropping all tables…\n'));
         const runner = await getRunner();
         const result = await runner.fresh();
-        printResult(result, 'Ran');
+        printMigrationResult(result, 'Ran');
       } catch (err) {
         bail('migrate:fresh', err);
+      } finally {
+        await closeDb();
       }
     });
 
-  // ── migrate:rollback ──────────────────────────────────────────────────────
-
+  // ── migrate:rollback ─────────────────────────────────────────────────────────
   program
     .command('migrate:rollback')
     .description('Rollback the last batch of migrations')
@@ -78,14 +76,15 @@ module.exports = function (program) {
       try {
         const runner = await getRunner();
         const result = await runner.rollback(Number(options.steps));
-        printResult(result, 'Rolled back');
+        printMigrationResult(result, 'Rolled back');
       } catch (err) {
         bail('migrate:rollback', err);
+      } finally {
+        await closeDb();
       }
     });
 
-  // ── migrate:reset ─────────────────────────────────────────────────────────
-
+  // ── migrate:reset ────────────────────────────────────────────────────────────
   program
     .command('migrate:reset')
     .description('Rollback ALL migrations')
@@ -93,14 +92,15 @@ module.exports = function (program) {
       try {
         const runner = await getRunner();
         const result = await runner.reset();
-        printResult(result, 'Rolled back');
+        printMigrationResult(result, 'Rolled back');
       } catch (err) {
         bail('migrate:reset', err);
+      } finally {
+        await closeDb();
       }
     });
 
-  // ── migrate:refresh ───────────────────────────────────────────────────────
-
+  // ── migrate:refresh ──────────────────────────────────────────────────────────
   program
     .command('migrate:refresh')
     .description('Rollback all then re-run all migrations')
@@ -108,14 +108,15 @@ module.exports = function (program) {
       try {
         const runner = await getRunner();
         const result = await runner.refresh();
-        printResult(result, 'Ran');
+        printMigrationResult(result, 'Ran');
       } catch (err) {
         bail('migrate:refresh', err);
+      } finally {
+        await closeDb();
       }
     });
 
-  // ── migrate:status ────────────────────────────────────────────────────────
-
+  // ── migrate:status ───────────────────────────────────────────────────────────
   program
     .command('migrate:status')
     .description('Show the status of all migration files')
@@ -143,11 +144,12 @@ module.exports = function (program) {
         console.log();
       } catch (err) {
         bail('migrate:status', err);
+      } finally {
+        await closeDb();
       }
     });
 
-  // ── db:seed ───────────────────────────────────────────────────────────────
-
+  // ── db:seed ──────────────────────────────────────────────────────────────────
   program
     .command('db:seed')
     .description('Run all database seeders')
@@ -180,6 +182,8 @@ module.exports = function (program) {
         console.log();
       } catch (err) {
         bail('db:seed', err);
+      } finally {
+        await closeDb();
       }
     });
 };
@@ -208,14 +212,25 @@ async function getDbConnection() {
 }
 
 async function getRunner() {
-  // Fixed: was incorrectly destructured as { MigrationRunner }
   const MigrationRunner = require('../orm/migration/MigrationRunner');
   const ctx = getProjectContext();
   const db  = await getDbConnection();
   return new MigrationRunner(db, ctx.migrationsPath);
 }
 
-function printResult(result, verb) {
+/**
+ * Destroy all open knex connection pools so the CLI process exits cleanly.
+ * Without this, knex keeps the event loop alive indefinitely after the
+ * command finishes, causing the terminal to appear to hang.
+ */
+async function closeDb() {
+  try {
+    const DatabaseManager = require('../orm/drivers/DatabaseManager');
+    await DatabaseManager.closeAll();
+  } catch { /* already closed or never opened — safe to ignore */ }
+}
+
+function printMigrationResult(result, verb) {
   const list = result.ran || result.rolledBack || [];
   if (list.length === 0) {
     console.log(chalk.yellow(`\n  ${result.message}\n`));
@@ -223,7 +238,7 @@ function printResult(result, verb) {
   }
   console.log(chalk.green(`\n  ✔  ${result.message}`));
   list.forEach(f =>
-    console.log(chalk.cyan(`     ${verb === 'Ran' ? '+' : '-'} ${f}`)),
+    console.log(chalk.cyan(`     ${verb === 'Ran' ? '+' : '-'} ${f}`))
   );
   console.log();
 }
@@ -231,5 +246,5 @@ function printResult(result, verb) {
 function bail(cmd, err) {
   console.error(chalk.red(`\n  ✖  ${cmd} failed: ${err.message}\n`));
   if (process.env.DEBUG) console.error(err.stack);
-  process.exit(1);
+  closeDb().finally(() => process.exit(1));
 }

package/src/commands/serve.js

@@ -3,48 +3,248 @@
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs-extra');
+const fsnative = require('fs');
+const {fork} = require('child_process');
+const chokidar = require('chokidar');
+const patchConsole = require("../logger/patchConsole");
+const Logger = require("../logger/internal");
+// ── ASCII banner ───────────────────────────────────────────────────────────────
+
+const BANNER_LINES = [
+    '  ███╗   ███╗██╗██╗     ██╗      █████╗ ███████╗',
+    '  ████╗ ████║██║██║     ██║     ██╔══██╗██╔════╝',
+    '  ██╔████╔██║██║██║     ██║     ███████║███████╗',
+    '  ██║╚██╔╝██║██║██║     ██║     ██╔══██║╚════██║',
+    '  ██║ ╚═╝ ██║██║███████╗███████╗██║  ██║███████║',
+    '  ╚═╝     ╚═╝╚═╝╚══════╝╚══════╝╚═╝  ╚═╝╚══════╝',
+];
+
+function printBanner(host, port) {
+    const env = process.env.NODE_ENV || 'development';
+    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;
+
+    process.stdout.write('\n');
+    for (const line of BANNER_LINES) {
+        process.stdout.write(chalk.bold.cyan(line) + '\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'
+    );
+    process.stdout.write(hr + '\n\n');
+}
+
+// ── Constants ─────────────────────────────────────────────────────────────────
+
+const WATCH_DIRS = ['app', 'routes', 'config', 'bootstrap', 'providers', 'middleware'];
+const WATCH_EXTS = new Set(['.js', '.mjs', '.cjs', '.json', '.njk', '.env']);
+const DEBOUNCE_MS = 250;
+
+
+// ── HotReloader ───────────────────────────────────────────────────────────────
+
+class HotReloader {
+    constructor(bootstrapPath, publicPort, publicHost) {
+        this._bootstrap = bootstrapPath;
+        this._initialised = false
+
+        this._child = null;
+        this._starting = false;
+        this._restarts = 0;
+
+        // Queued { req, res, timer } entries while child is restarting
+        this._queue = [];
+        this._watchers = [];
+        this._timer = null;
+    }
+
+    start() {
+        this._spawnChild();
+        this._watch();
+        this._handleSignals();
+    }
+
+    _spawnChild() {
+        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: {
+                ...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;
+
+            if (code !== 0 && signal !== 'SIGTERM' && signal !== 'SIGKILL') {
+                console.error(chalk.red('✖  App crashed') +
+                    chalk.dim(` (exit ${code ?? signal})`) +
+                    chalk.dim(' — fix the error, file watcher will reload…')
+                );
+            }
+        });
+        //
+        this._child.on('error', err => {
+            this._starting = false;
+            console.error(chalk.red(`✖  ${err.message}`));
+        });
+    }
+
+    _killChild(cb) {
+        if (!this._child || this._child.exitCode !== null) return cb();
+        this._child.once('exit', cb);
+        this._child.kill('SIGTERM');
+    }
+
+    _restart(changedFile) {
+        const link = changedFile
+            ? `\x1b]8;;file://${changedFile}\x07${path.relative(process.cwd(), changedFile)}\x1b]8;;\x07`
+            : '';
+        console.warn(
+            chalk.yellow('↺') + '  ' +
+            chalk.white('Reloading') +
+            (link ? chalk.blueBright('  ' + link) : '')
+        );
+
+        this._restarts++;
+        this._killChild(() => this._spawnChild());
+    }
+
+    // ── 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)),
+            path.join(cwd, '.env'),
+            path.join(cwd, '.env.local'),
+        ];
+
+        const watcher = chokidar.watch(watchPaths, {
+            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) => {
+            if (WATCH_EXTS.has(path.extname(filePath))) {
+                this._scheduleRestart(filePath);
+            }
+        });
+
+        this._watchers.push(watcher);
+    }
+
+    _scheduleRestart(changedFile) {
+        clearTimeout(this._timer);
+        this._timer = setTimeout(() => this._restart(changedFile), DEBOUNCE_MS);
+    }
+
+    _stopWatching() {
+        for (const w of this._watchers) {
+            try {
+                w.close();
+            } catch {
+            }
+        }
+        this._watchers = [];
+    }
+
+    // ── Signals ───────────────────────────────────────────────────────────────
+
+    _handleSignals() {
+        const cleanup = () => {
+            clearTimeout(this._timer);
+            this._stopWatching();
+            if (this._child) this._child.kill('SIGTERM');
+            process.exit(0);
+        };
+        process.once('SIGINT', cleanup);
+        process.once('SIGTERM', cleanup);
+    }
+}
+
+// ── Command ────────────────────────────────────────────────────────────────────
 
 module.exports = function (program) {
-  program
-    .command('serve')
-    .description('Start the development server')
-    .option('-p, --port <port>', 'Port to listen on', '3000')
-    .option('-h, --host <host>', 'Host to bind to', 'localhost')
-    .action(async (options) => {
-      const appBootstrap = path.resolve(process.cwd(), 'bootstrap/app.js');
-
-      if (!fs.existsSync(appBootstrap)) {
-        console.error(chalk.red('\n  ✖ No Millas project found in current directory.\n'));
-        console.log(`  Make sure you are inside a Millas project and bootstrap/app.js exists.\n`);
-        process.exit(1);
-      }
+    program
+        .command('serve')
+        .description('Start the development server with hot reload')
+        .option('-p, --port <port>', 'Port to listen on', '3000')
+        .option('-h, --host <host>', 'Host to bind to', 'localhost')
+        .option('--no-reload', 'Disable hot reload (run once, like production)')
+        .action((options) => {
 
-      console.log();
-      console.log(chalk.cyan('  ⚡ Millas Dev Server'));
-      console.log(chalk.gray(`  Starting on http://${options.host}:${options.port}\n`));
+            const restoreAfterPatch = patchConsole(Logger,"SystemOut")
+            const appBootstrap = path.resolve(process.cwd(), 'bootstrap/app.js');
 
-      process.env.MILLAS_PORT = options.port;
-      process.env.MILLAS_HOST = options.host;
-      process.env.NODE_ENV = process.env.NODE_ENV || 'development';
+            if (!fs.existsSync(appBootstrap)) {
+                process.stderr.write(chalk.red('\n  ✖  No Millas project found here.\n'));
+                process.stderr.write(chalk.dim('     Make sure bootstrap/app.js exists.\n\n'));
+                process.exit(1);
+            }
 
-      try {
-        require(appBootstrap);
-      } catch (err) {
-        console.error(chalk.red(`\n  ✖ Failed to start server: ${err.message}\n`));
-        console.error(err.stack);
-        process.exit(1);
-      }
-    });
-};
 
-// Exported so queue:work can import the pattern
-module.exports.requireProject = function(command) {
-  const path = require('path');
-  const fs   = require('fs-extra');
-  const bootstrapPath = path.resolve(process.cwd(), 'bootstrap/app.js');
-  if (!fs.existsSync(bootstrapPath)) {
-    const chalk = require('chalk');
-    console.error(chalk.red(`\n  ✖ Not inside a Millas project (${command}).\n`));
-    process.exit(1);
-  }
+            const publicPort = parseInt(options.port, 10) || 3000;
+            const publicHost = options.host || 'localhost';
+
+            const env = {
+                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);
+
+            if (options.reload !== false) {
+
+                new HotReloader(appBootstrap, publicPort, publicHost).start();
+            } else {
+                try {
+                    require(appBootstrap);
+                } catch (e) {
+                    console.log("Error starting server: ", +e)
+                }
+            }
+        });
+
 };
+
+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;